;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:22 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/delphi.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\302\301\303\304\305\306\307\310&\207" [provide delphi custom-declare-group nil "Major mode for editing Delphi source in Emacs." :version "21.1" :group languages] 8)
#@24 True if in debug mode.
(defconst delphi-debug nil (#$ . 751))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\313\306\307&\210\300\314\315\316\304\313\306\307&\210\300\317\310\320\304\313\306\307&\210\300\321\322\323\304\324\306\307&\210\300\325\322\326\304\324\306\307&\210\300\327\322\330\304\324\306\307&\210\300\331\332\333\304\334\306\307&\210\300\335\336\337\304\334\306\307&\210\300\340\341\342\304\334\306\307&\210\300\343\344\345\304\346\306\307&\207" [custom-declare-variable delphi-search-path "." "Directories to search when finding external units.\nIt is a list of directory strings.  If only a single directory,\nit can be a single string instead of a list.  If a directory\nends in \"...\" then that directory is recursively searched." :type string :group delphi delphi-indent-level 3 "Indentation of Delphi statements with respect to containing block.\nE.g.\n\nbegin\n   // This is an indent of 3.\nend;" integer delphi-compound-block-indent 0 "Extra indentation for blocks in compound statements. E.g.\n\n// block indent = 0     vs      // block indent = 2\nif b then                       if b then\nbegin                             begin\nend else begin                    end\nend;                            else\n                                  begin\n                                  end;" delphi-case-label-indent "Extra indentation for case statement labels. E.g.\n\n// case indent = 0      vs      // case indent = 3\ncase value of                   case value of\nv1: process_v1;                    v1: process_v1;\nv2: process_v2;                    v2: process_v2;\nelse                            else\n   process_else;                   process_else;\nend;                            end;" delphi-verbose t "If true then Delphi token processing progress is reported to the user." boolean delphi-tab-always-indents "Non-nil means TAB in Delphi mode should always reindent the current line,\nregardless of where in the line point is when the TAB command is used." delphi-newline-always-indents "Non-nil means NEWLINE in Delphi mode should always reindent the current\nline, insert a blank line and move to the default indent column of the blank\nline.  If nil, then no indentation occurs, and NEWLINE does the usual\nbehavior.  This is useful when one needs to do customized indentation that\ndiffers from the default." delphi-comment-face 'font-lock-comment-face "Face used to color Delphi comments." face delphi-string-face 'font-lock-string-face "Face used to color Delphi strings." delphi-keyword-face 'font-lock-keyword-face "Face used to color Delphi keywords." delphi-other-face nil "Face used to color everything else." (choice (const :tag "None" nil) face)] 8)
#@21 Delphi4 directives.
(defconst delphi-directives '(absolute abstract assembler automated cdecl default dispid dynamic export external far forward index inline message name near nodefault overload override pascal private protected public published read readonly register reintroduce resident resourcestring safecall stdcall stored virtual write writeonly) (#$ . 3493))
#@19 Delphi4 keywords.
(defconst delphi-keywords (append '(and array as asm at begin case class const constructor contains destructor dispinterface div do downto else end except exports file finalization finally for function goto if implementation implements in inherited initialization interface is label library mod nil not of object on or out package packed procedure program property raise record repeat requires result self set shl shr then threadvar to try type unit uses until var while with xor break exit) delphi-directives) (#$ . 3866))
#@69 Expression/statement terminators that denote a previous expression.
(defconst delphi-previous-terminators '(semicolon comma) (#$ . 4414))
#@33 Tokens that represent comments.
(defconst delphi-comments '(comment-single-line comment-multi-line-1 comment-multi-line-2) (#$ . 4558))
#@40 Tokens that represent string literals.
(defconst delphi-strings '(string double-quoted-string) (#$ . 4700))
#@40 Tokens that are considered whitespace.
(defconst delphi-whitespace (byte-code "\301\302BB\207" [delphi-comments space newline] 3) (#$ . 4814))
#@66 Marks the start of a routine, or routine-ish looking expression.
(defconst delphi-routine-statements '(procedure function constructor destructor property) (#$ . 4964))
#@109 Statements that have either a single statement or a block as a body and also
are followed by an expression.
(defconst delphi-body-expr-statements '(if while for on) (#$ . 5139))
#@64 Expression statements contain expressions after their keyword.
(defconst delphi-expr-statements (cons 'case delphi-body-expr-statements) (#$ . 5323))
#@70 Statements that have either a single statement or a block as a body.
(defconst delphi-body-statements (cons 'else delphi-body-expr-statements) (#$ . 5479))
#@30 Expression delimiter tokens.
(defconst delphi-expr-delimiters '(then do of) (#$ . 5641))
#@27 Delphi binary operations.
(defconst delphi-binary-ops '(plus minus equals not-equals times divides div mod and or xor) (#$ . 5736))
#@21 Class visibilities.
(defconst delphi-visibilities '(public private protected published automated) (#$ . 5874))
#@49 Statements that contain multiple substatements.
(defconst delphi-block-statements '(begin try case repeat initialization finalization asm) (#$ . 5991))
#@59 Statements that mark mid sections of the enclosing block.
(defconst delphi-mid-block-statements (byte-code "\301\302BB\207" [delphi-visibilities except finally] 3) (#$ . 6149))
#@37 Statements that end block sections.
(defconst delphi-end-block-statements '(end until) (#$ . 6333))
#@60 Statements that match the indentation of the parent block.
(defconst delphi-match-block-statements (append delphi-end-block-statements delphi-mid-block-statements) (#$ . 6439))
#@45 Denotes the start of a declaration section.
(defconst delphi-decl-sections '(type const var label resourcestring) (#$ . 6622))
#@18 Interface types.
(defconst delphi-interface-types '(dispinterface interface) (#$ . 6755))
#@14 Class types.
(defconst delphi-class-types '(class object) (#$ . 6851))
#@46 Types that contain declarations within them.
(defconst delphi-composite-types (append delphi-class-types delphi-interface-types '(record)) (#$ . 6928))
#@45 Unit sections within which the indent is 0.
(defconst delphi-unit-sections '(interface implementation program library package) (#$ . 7086))
#@43 Statements that refer to foreign symbols.
(defconst delphi-use-clauses '(uses requires exports contains) (#$ . 7232))
#@33 Statements indented at level 0.
(defconst delphi-unit-statements (append delphi-use-clauses delphi-unit-sections '(initialization finalization)) (#$ . 7356))
#@60 Statements that a declaration statement should align with.
(defconst delphi-decl-delimiters (append delphi-decl-sections delphi-unit-statements delphi-routine-statements) (#$ . 7520))
#@68 Statements that should match to declaration statement indentation.
(defconst delphi-decl-matchers (cons 'begin delphi-decl-sections) (#$ . 7710))
#@34 Delimits an enclosing statement.
(defconst delphi-enclosing-statements (append delphi-block-statements delphi-mid-block-statements delphi-decl-sections delphi-use-clauses delphi-routine-statements) (#$ . 7862))
#@32 Delimits a previous statement.
(defconst delphi-previous-statements (append delphi-unit-statements delphi-routine-statements) (#$ . 8079))
#@42 Delimits a previous enclosing statement.
(defconst delphi-previous-enclosing-statements (append delphi-block-statements delphi-mid-block-statements delphi-decl-sections) (#$ . 8224))
#@41 Tokens that a begin token indents from.
(defconst delphi-begin-enclosing-tokens (append delphi-block-statements delphi-mid-block-statements) (#$ . 8413))
#@82 Tokens that a begin token aligns with, but only if not part of a nested
routine.
(defconst delphi-begin-previous-tokens (append delphi-decl-sections delphi-routine-statements) (#$ . 8573))
(defconst delphi-space-chars "-	- ")
(defconst delphi-non-space-chars (concat "^" delphi-space-chars))
(defconst delphi-spaces-re (concat "[" delphi-space-chars "]*"))
(defconst delphi-leading-spaces-re (concat "^" delphi-spaces-re))
(defconst delphi-word-chars "a-zA-Z0-9_")
(defalias 'delphi-save-match-data '(macro . #[(&rest forms) "\301\302\303\304B\305BBE\207" [forms let ((data (match-data))) unwind-protect progn ((set-match-data data))] 5]))
(defalias 'delphi-save-excursion '(macro . #[(&rest forms) "\301\302\303\304\305BEDD\207" [forms save-excursion delphi-save-match-data let ((inhibit-point-motion-hooks t) (deactivate-mark nil)) progn] 6]))
(defalias 'delphi-save-state '(macro . #[(&rest forms) "\301\302\303\304\305B\306BBF\207" [forms let ((delphi-ignore-changes t) (old-supersession-threat (symbol-function 'ask-user-about-supersession-threat)) (buffer-read-only nil) (inhibit-read-only t) (buffer-undo-list t) (before-change-functions nil) (after-change-functions nil) (modified (buffer-modified-p))) (fset 'ask-user-about-supersession-threat (lambda (_fn))) unwind-protect progn ((set-buffer-modified-p modified) (fset 'ask-user-about-supersession-threat old-supersession-threat))] 6]))
(defalias 'delphi-is #[(element in-set) "	>\207" [element in-set] 2])
(put 'delphi-is 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'delphi-string-of #[(start end) "\302	\"\207" [start end buffer-substring-no-properties] 3])
(defalias 'delphi-looking-at-string #[(p s) "	G\\\211dX\205	\303\n\"\230)\207" [p s limit delphi-string-of] 5])
(defalias 'delphi-token-of #[(kind start end) "\303	\n#\207" [kind start end vector] 4])
(defalias 'delphi-token-kind #[(token) "\205\301H\207" [token 0] 2])
(put 'delphi-token-kind 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'delphi-set-token-kind #[(token to-kind) "\205\302	I\207" [token to-kind 0] 3])
(defalias 'delphi-token-start #[(token) "\203\301H\207e\207" [token 1] 2])
(put 'delphi-token-start 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'delphi-token-end #[(token) "\203\301H\207e\207" [token 2] 2])
(put 'delphi-token-end 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'delphi-set-token-start #[(token start) "\205\302	I\207" [token start 1] 3])
(defalias 'delphi-set-token-end #[(token end) "\205\302	I\207" [token end 2] 3])
(defalias 'delphi-token-string #[(token) "\203#\301\211\203\302H\202e)\211\203\303H\202 e)\"\207\304\207" [token delphi-string-of 1 2 ""] 5])
(defalias 'delphi-in-token #[(p token) "\211\203\f\302H\202
e)	X\205#	\211\203 \303H\202!e)W\207" [token p 1 2] 4])
(defalias 'delphi-column-of #[(p) "\212b\210i)\207" [p] 1])
(defalias 'delphi-face-of #[(token-kind) "	\211\n>*\203
\f\207
\211\n>*\203\207\211\n>*\203*\207	\207" [token-kind delphi-comments in-set element delphi-comment-face delphi-strings delphi-string-face delphi-keywords delphi-keyword-face delphi-other-face] 3])
#@48 The last point at which progress was reported.
(defvar delphi-progress-last-reported-point nil (#$ . 11755))
#@69 Number of chars to process before the next parsing progress report.
(defconst delphi-parsing-progress-step 16384 (#$ . 11870))
#@70 Number of chars to process before the next scanning progress report.
(defconst delphi-scanning-progress-step 2048 (#$ . 12003))
#@75 Number of chars to process before the next fontification progress report.
(defconst delphi-fontifying-progress-step delphi-scanning-progress-step (#$ . 12137))
(defalias 'delphi-progress-start #[nil "\301\211\207" [delphi-progress-last-reported-point nil] 2])
(defalias 'delphi-progress-done #[(&rest msgs) "\303	\205\n\204\304\305!\207\306\304\n\"\207" [delphi-progress-last-reported-point delphi-verbose msgs nil message "" apply] 3])
(defalias 'delphi-step-progress #[(p desc step-size) "\204	\211\207\n\205#\305	Z!Y\205#	\306\307\f\310 	\311_d\245$\207" [delphi-progress-last-reported-point p delphi-verbose step-size desc abs message "%s %s ... %d%%" buffer-name 100] 6])
(defalias 'delphi-next-line-start #[(&optional from-point) "`\303\n\203\nb\210\303\210`Td^	b\210*\207" [next curr-point from-point nil] 2])
#@258 Internal flag to control if the Delphi mode responds to buffer changes.
Defaults to t in case the `delphi-after-change' function is called on a
non-Delphi buffer.  Set to nil in a Delphi buffer.  To override, just do:
 (let ((delphi-ignore-changes t)) ...)
(defvar delphi-ignore-changes t (#$ . 12983))
(defalias 'delphi-set-text-properties #[(from to properties) "\306\307K\310\306\211\310\211\311 
\307\312M\210\313\216\314#.	\207" [modified after-change-functions before-change-functions buffer-undo-list inhibit-read-only buffer-read-only t ask-user-about-supersession-threat nil buffer-modified-p #[(_fn) "\300\207" [nil] 1] ((byte-code "\302!\210\303	M\207" [modified old-supersession-threat set-buffer-modified-p ask-user-about-supersession-threat] 2)) set-text-properties old-supersession-threat delphi-ignore-changes from to properties] 8])
(defalias 'delphi-literal-kind #[(p) "eX\205dX\205\301\302\"\207" [p get-text-property token] 3])
(defalias 'delphi-literal-start-pattern #[(literal-kind) "\301\302\"A\207" [literal-kind assoc ((comment-single-line . "//") (comment-multi-line-1 . "{") (comment-multi-line-2 . "(*") (string . "'") (double-quoted-string . "\""))] 3])
(defalias 'delphi-literal-end-pattern #[(literal-kind) "\301\302\"A\207" [literal-kind assoc ((comment-single-line . "\n") (comment-multi-line-1 . "}") (comment-multi-line-2 . "*)") (string . "'") (double-quoted-string . "\""))] 3])
(defalias 'delphi-literal-stop-pattern #[(literal-kind) "\301\302\"A\207" [literal-kind assoc ((comment-single-line . "\n") (comment-multi-line-1 . "}") (comment-multi-line-2 . "\\*)") (string . "['\n]") (double-quoted-string . "[\"\n]"))] 3])
(defalias 'delphi-is-literal-start #[(p) "\303!\304	!	?\206\305\n\"*\207" [p kind pattern delphi-literal-kind delphi-literal-start-pattern delphi-looking-at-string] 3])
(defalias 'delphi-is-literal-end #[(p) "\306S!\307	!	?\206<\310\nGZ\n\"\203,	\211\f>*?\206<\311S!?\206<	\211\f>*\205<Sf\312=*\207" [p kind pattern delphi-strings in-set element delphi-literal-kind delphi-literal-end-pattern delphi-looking-at-string delphi-is-literal-end 10] 4])
(defalias 'delphi-is-stable-literal #[(p) "\303!\304!dY\206(\n\203	\206(\n?\205(	?\205(\305S!\305!=*\207" [p at-end at-start delphi-is-literal-start delphi-is-literal-end delphi-literal-kind] 3])
(defalias 'delphi-complete-literal #[(literal-kind limit) "\303!\211;\204\304\305\"\202\306	\n\307#\210`)\207" [literal-kind pattern limit delphi-literal-stop-pattern error "Invalid literal kind %S" re-search-forward goto-limit-on-fail] 5])
(defalias 'delphi-literal-text-properties #[(kind) "\302\300!\203\203\303	\304\305	!\306\307\257\207\303	D\207" [font-lock-mode kind boundp token face delphi-face-of lazy-lock t] 6])
(defalias 'delphi-parse-next-literal #[(limit) "`\305!\204\306S!\307	\n\"\210\310`\311	!#\210)\202q\312\313\n\314#\203k\315\224\203/\316\202P\317\224\2038\320\202P\321\224\203A\322\202P\323\224\203J\324\202P\325\224\205P\326\327\224\310\330#\210\307	\n\"\210\310`\311	!#\210*\202q\310\n\330#\210\331`\332\f#)\207" [search-start kind limit start delphi-parsing-progress-step delphi-is-literal-end delphi-literal-kind delphi-complete-literal delphi-set-text-properties delphi-literal-text-properties re-search-forward "\\(//\\)\\|\\({\\)\\|\\((\\*\\)\\|\\('\\)\\|\\(\"\\)" goto-limit-on-fail 1 comment-single-line 2 comment-multi-line-1 3 comment-multi-line-2 4 string 5 double-quoted-string 0 nil delphi-step-progress "Parsing"] 5])
(defalias 'delphi-literal-token-at #[(p) "\304!\211\205!\305T\306\"\307\306\"\310	\206e\n\206d#*)\207" [p kind end start delphi-literal-kind previous-single-property-change token next-single-property-change delphi-token-of] 5])
(defalias 'delphi-point-token-at #[(p kind) "\302	\211T#\207" [kind p delphi-token-of] 4])
(defalias 'delphi-char-token-at #[(p char kind) "	f=\205
\303\n	\211T#\207" [char p kind delphi-token-of] 4])
(put 'delphi-char-token-at 'byte-optimizer 'byte-compile-inline-expand)
(defalias 'delphi-charset-token-at #[(p charset kind) "`\306\211b\210\f\306w\307V\203!`Tb\210\f\306x\210\310
`	#\nb\210+\207" [token end currp p charset kind nil 0 delphi-token-of] 4])
(defalias 'delphi-space-token-at #[(p) "\302	\303#\207" [p delphi-space-chars delphi-charset-token-at space] 4])
(defalias 'delphi-word-token-at #[(p) "\306	\302#\211\2052\307\n!\227\310!\211\204\311\230\2030\f
\211\f>*\2030\312\n\f\"\210\n*)\207" [p delphi-word-chars word word-image keyword delphi-keywords delphi-charset-token-at delphi-token-string intern-soft "nil" delphi-set-token-kind in-set element] 5])
(defalias 'delphi-explicit-token-at #[(p token-string kind) "\304	\n#\211\205	\305!\230\205)\207" [p token-string kind token delphi-charset-token-at delphi-token-string] 5])
(defalias 'delphi-token-at #[(p) "eX\205p
dX\205p
\303\304\nf=\205\305	\211T#+\206p
\306!\206p
\307!\206p
\310!\206p
\311\312\nf=\205H\305	\211T#+\206p
\313\314\nf=\205_\305	\211T#+\206p
\315\312\nf=\205v\305	\211T#+\206p
\316\314\nf=\205\215\305	\211T#+\206p
\317\320\nf=\205\244\305	\211T#+\206p
\321\322\nf=\205\273\305	\211T#+\206p
\323\324\nf=\205\322\305	\211T#+\206p
\325\326\nf=\205\351\305	\211T#+\206p
\327\330\nf=\205
\305	\211T#+\206p
\331\332\nf=\205
\305	\211T#+\206p
\333\334\nf=\205.
\305	\211T#+\206p
\335\336\nf=\205E
\305	\211T#+\206p
\337\340\nf=\205\\
\305	\211T#+\206p
\341\342\343#\206p
\344\345\"\206p
\346\207" [p kind char 10 newline delphi-token-of delphi-literal-token-at delphi-space-token-at delphi-word-token-at 40 open-group 41 close-group 91 93 59 semicolon 46 dot 44 comma 61 equals 43 plus 45 minus 42 times 47 divides 58 colon delphi-explicit-token-at "<>" not-equals delphi-point-token-at punctuation nil] 4])
(defalias 'delphi-current-token #[nil "\300`!\207" [delphi-token-at] 2])
(defalias 'delphi-next-token #[(token) "\205.\303\211\203\304H\202e)!\211\203,\305	\211\203&\306H\202'e)\307\n#\210	)\207" [token next delphi-scanning-progress-step delphi-token-at 2 delphi-step-progress 1 "Scanning"] 5])
(defalias 'delphi-previous-token #[(token) "\205/\303\211\203\304H\202e)S!\211\203-\305	\211\203'\304H\202(e)\306\n#\210	)\207" [token previous delphi-scanning-progress-step delphi-token-at 1 delphi-step-progress "Scanning"] 5])
(defalias 'delphi-next-visible-token #[(token) "\304\305	!\211\211\205	\306H)\307\211\n>*\204)\207" [next-token token in-set element nil delphi-next-token 0 (space newline)] 3])
(defalias 'delphi-parse-region #[(from to) "\214~\210b\210`	W\205\302	!\210\202)\207" [from to delphi-parse-next-literal] 2])
(defalias 'delphi-parse-region-until-stable #[(from to) "\214~\210\302	\"\210\303`!?\205\304d!\210\202)\207" [from to delphi-parse-region delphi-is-stable-literal delphi-parse-next-literal] 3])
(defalias 'delphi-fontify-region #[(from to &optional verbose) "\212\306 \307\216\310\311\310\312K\311\310\211\311\211\313 \312\314M\210\315\216 \311!\"#\316 \210#$W\203\231\317#!!\320!\211!\203S!\321H\202Te)!\211!\203d!\322H\202ee)\323\324!\211!\205t!\325H)!\326\310F#\210!\211!\203\212!\322H\202\213e)#\327#\330%#\210\2025\331 .\207" [data deactivate-mark inhibit-point-motion-hooks modified after-change-functions before-change-functions match-data ((set-match-data data)) t nil ask-user-about-supersession-threat buffer-modified-p #[(_fn) "\300\207" [nil] 1] ((byte-code "\302!\210\303	M\207" [modified old-supersession-threat set-buffer-modified-p ask-user-about-supersession-threat] 2)) delphi-progress-start delphi-token-at add-text-properties 1 2 face delphi-face-of 0 lazy-lock delphi-step-progress "Fontifying" delphi-progress-done buffer-undo-list inhibit-read-only buffer-read-only old-supersession-threat delphi-ignore-changes from verbose token delphi-verbose p to delphi-fontifying-progress-step] 9])
(defalias 'delphi-after-change #[(change-start change-end _old-length) "?\2054\306\212\307 \310\216\306\311\312 \210\313\314\fS!\211\203$
\315H\202%e)b\210\311\210`\"\210\316 .\207" [delphi-ignore-changes data deactivate-mark inhibit-point-motion-hooks change-start token t match-data ((set-match-data data)) nil delphi-progress-start delphi-parse-region-until-stable delphi-token-at 1 delphi-progress-done change-end] 4])
(defalias 'delphi-group-start #[(from-token) "\303!\304\305\306\215*\207" [from-token token-kind token delphi-previous-token nil done (byte-code "\203/\211\205
\302H)\211\303=\203\304!\202'	\305=\203'\306\307\"\210\310!\211\204\311\207" [token token-kind 0 close-group delphi-group-start open-group throw done delphi-previous-token nil] 4)] 2])
(defalias 'delphi-group-end #[(from-token) "\303!\304\305\306\215*\207" [from-token token-kind token delphi-next-token nil done (byte-code "\203/\211\205
\302H)\211\303=\203\304!\202'	\305=\203'\306\307\"\210\310!\211\204\311\207" [token token-kind 0 open-group delphi-group-end close-group throw done delphi-next-token nil] 4)] 2])
(defalias 'delphi-indent-of #[(token &optional offset) "\304\211\203
\305H\202e)!	\203	\202\306\\\203B\307\310\311!\304\211\2032\305H\2023e)!\n	\203>	\202?\306&\210\n)\207" [token offset indent delphi-debug delphi-column-of 1 0 delphi-debug-log "\n Indent of: %S %S\n column: %d indent: %d offset: %d" delphi-token-string] 8])
(defalias 'delphi-line-indent-of #[(from-token &optional offset &rest terminators) "\305!\306\307\310\215\210\311\n\f\"+\207" [from-token kind last-token token offset delphi-previous-token nil done (byte-code "\203U\211\205
\306H)\211\307=\203\310!\202?	\311\211\n>*\203/\312\313\314\"\210\202?	\f\211\n>*\203?\312\313\314\"\210	
\211\n>*\204M\315!\211\204\314\207" [token kind in-set element terminators delphi-whitespace 0 close-group delphi-group-start (newline open-group) throw done nil delphi-previous-token last-token] 4) delphi-indent-of] 3])
(defalias 'delphi-stmt-line-indent-of #[(from-token &optional offset) "\305!\306\307\310\215\210\311\n\f\"+\207" [from-token kind last-token token offset delphi-previous-token nil done (byte-code "\203o\211\205
\306H)\211\307=\2035\n\211\205\306H)\310\f\"\211
>*\2035\311\312\313\"\210\202X	\314=\203B\315!\202X	\316\317BB\211
>*\203X\311\312\313\"\210	\211
>*\204g\320!\211\204\313\207" [token kind last-token delphi-block-statements delphi-expr-statements in-set 0 colon append throw done nil close-group delphi-group-start newline open-group delphi-previous-token element delphi-use-clauses delphi-whitespace] 5) delphi-indent-of] 3])
(defalias 'delphi-open-group-indent #[(token last-token &optional offset) "\211\205	\304H)\305=\205	\203\306	\n\"\207\307\"\207" [token last-token offset delphi-indent-level 0 open-group delphi-indent-of delphi-stmt-line-indent-of] 4])
(defalias 'delphi-composite-type-start #[(token last-token) "\211\205	\305H)\306=\205$	\211\205\305H)\n\211>*\205$	\207" [token last-token delphi-composite-types in-set element 0 equals] 3])
(defalias 'delphi-is-simple-class-type #[(at-token limit-token) "\211\205		\305H)\n\211>*\205\306\307\215\207" [at-token token delphi-class-types in-set element 0 done (byte-code "\306!\307	\211\203\n\310H\202e)\211\205r\n\211\203%\n\310H\202&e)X\205r\n\211\2055\n\311H)\211\312=\203E\313\314\n\"\210\202i\f\315=\203R\316\n!\202i\f\317\320
BB\211>*\204i\313\314\307\"\210\306\n!\211\204\307+\207" [at-token limit-token token limit token-kind delphi-whitespace delphi-next-token nil 1 0 semicolon throw done open-group delphi-group-end of word in-set element] 5)] 3])
(defalias 'delphi-block-start #[(from-token &optional stop-on-class) "\304!\305\211\306\307\215+\207" [from-token token-kind last-token token delphi-previous-token nil done (byte-code "\203\223\211\205
\306H)\211\n\211>*\203!\307!\202|	
\211>*\203e\310\311	\312=\203_\307\313\"\211\211\205C\306H)\314=\203Z\203S\202[\315!\202[)\202`\"\210\202|\316\"\203|\310\311\203y\202z\"\210	\211>*\204\213\315!\211\204\317\207" [token token-kind delphi-end-block-statements in-set element delphi-block-statements 0 delphi-block-start throw done case stop-on-class record delphi-previous-token delphi-composite-type-start nil enclosing-token last-token delphi-whitespace] 6)] 3])
(defalias 'delphi-else-start #[(from-else) "\304!\305\306\307\310\215+\207" [from-else semicolon-count token-kind token delphi-previous-token nil 0 done (byte-code "\203a\211\205
\306H)\211\307=\203\310!\202Y	\n\211>*\203.\311!\202Y	\312=\203:
T\202Y	\313=\203N
\306U\203N\314\315\"\210\202Y	\316=\203Y\314\315\"\210\317!\211\204\320\207" [token token-kind delphi-end-block-statements in-set element semicolon-count 0 close-group delphi-group-start delphi-block-start semicolon if throw done case delphi-previous-token nil] 4)] 3])
(defalias 'delphi-comment-content-start #[(comment) "\211\205		\306H)\211\211\f>*\205?\212\307 
\310\216\311\312\211\203/	\313H\2020e)\314\n!G\\b\210\312w\210`-)\207" [comment token kind delphi-comments in-set element 0 match-data ((set-match-data data)) t nil 1 delphi-literal-start-pattern data deactivate-mark inhibit-point-motion-hooks delphi-space-chars] 4])
(defalias 'delphi-comment-block-start #[(comment) "\211\205		\305H)\306=\204\207\211\211\211\205	\305H)\211\307=\2063\f\306=\2032\211\2023\310)\203?\311!\211\202\n*\207" [comment token start-comment prev-comment kind 0 comment-single-line space nil delphi-previous-token] 3])
(defalias 'delphi-comment-block-end #[(comment) "\211\205		\305H)\306=\204\207\211\211\211\205	\305H)\211\307=\2063\f\306=\2032\211\2023\310)\203?\311!\211\202\n*\207" [comment token end-comment next-comment kind 0 comment-single-line space nil delphi-next-token] 3])
(defalias 'delphi-on-first-comment-line #[(comment) "\212\211\203
	\304H\202e)`\211b\210\305\210\nX\205!\n`X+\207" [comment token current-point comment-start 1 nil] 3])
(defalias 'delphi-comment-indent-of #[(comment) "\305!\211=\203\306!\203\307!\202G\212\211\205 \n\310H)\311 \210\312=\2031\313	!\202F\314\f\315!P!\203A\313!\202F\316\317!!*)\207" [comment start-comment token kind delphi-leading-spaces-re delphi-comment-block-start delphi-on-first-comment-line delphi-enclosing-indent-of 0 beginning-of-line comment-single-line delphi-indent-of looking-at delphi-literal-stop-pattern delphi-column-of delphi-comment-content-start] 5])
(defalias 'delphi-is-use-clause-end #[(at-token last-token last-colon from-kind) "\205(	?\205(\n\211\205\306H)\307=\205(\f\310=\205(\311\n!\312\313\314\215*\207" [last-token last-colon at-token token from-kind token-kind 0 comma semicolon delphi-previous-token nil done (byte-code "\203Q\211\205
\306H)\211\n\211>*\203\"\307\310\311\"\210\202I	\312\211>*\204I	
\211>*\204I	
\211>*\204I\307\310\313\"\210\314!\211\204\313\207" [token token-kind delphi-use-clauses in-set element delphi-whitespace 0 throw done t (word comma in newline) nil delphi-previous-token delphi-strings] 4)] 3])
(defalias 'delphi-is-block-after-expr-statement #[(token) "\211\205	\306H)	\211\n>*\205C\307!\310\211\211\205#\306H)\211\311=\2033\307
!\211\202\f\211\n>*\206B\f\312=*\207" [token delphi-block-statements in-set element previous-kind previous 0 delphi-previous-token nil space else delphi-expr-delimiters] 3])
(defalias 'delphi-previous-indent-of #[(from-token) "\306!\307\211\205
	\310H)\307\211\211\311\312\215.\207" [from-token token last-token last-of last-colon from-kind delphi-previous-token nil 0 done (byte-code "\203\220
\211\205
\306H)\211\307=\203 \310\311\312\n\"\"\210\202z
	\313=\203-\314!\202z
	\211\f>*\203X\315!\211\205C\306H)\316=\203Q\310\311\306\"\210\202z
\317!\202z
\320\n$\203k\310\311\306\"\210\202z
\n\203\233	\211\f>*\203\233\n\211\205\204\306H)\211\f>*\204\233\310\311\321\n\306\"\"\210\202z
	\211\f>*\204z
	\322=\203\263 \202z
	\323=\203\304 \204z
\202z
	\324=\203\342\310\311\203\330\325!\202\335\325!\"\"\210\202z
	\"\211\f>*\203
\310\311\326=\203	
\n\203

\327\n!\202\f
\325#\"\202\f
\325!\"\210\202z
	\330=\203#
\310\311\321#\"\"\210\202z
	$\211\f>*\203E
\310\311\n\203;
\325\n!\202@
\325#\"\"\210\202z
\331\n\"\203f
\310\311\332\n%\"\203\\
\325!\202a
\325\n#\"\"\210\202z
	&\211\f>*\203z
\310\311\321\306\"\"\210	\211\f>*\204\210
\315!\211\204\306\207" [token token-kind last-token delphi-end-block-statements in-set element 0 open-group throw done delphi-open-group-indent close-group delphi-group-start delphi-previous-token newline delphi-block-start delphi-is-use-clause-end delphi-stmt-line-indent-of of colon case delphi-line-indent-of comma delphi-indent-of asm delphi-composite-type-start delphi-is-simple-class-type last-colon from-kind delphi-previous-terminators delphi-directives delphi-whitespace last-of delphi-case-label-indent delphi-use-clauses delphi-indent-level delphi-previous-enclosing-statements from-token delphi-previous-statements] 6) token-kind] 7])
(defalias 'delphi-section-indent-of #[(section-token) "\306!\307\211\310\307\211\311\312\215.\207" [section-token token token-kind last-token nested-block-count expr-delimited delphi-previous-token nil 0 done (byte-code "\203_
\211\205
\306H)\211\307=\203 \310\311\312\n\"\"\210\202I
	\313=\203-\314!\202I
	\211\f>*\203]\315!\211\205C\306H)\316=\203Q\310\311\306\"\210\202I
\317!T\202I
	\320=\203kT\202I
	\211\f>*\203\206\306V\203\206S\202I
	\321=\203\222\202I
	\211\f>*\203\244\202I
\204\301	\211\f>*\203\301\310\311\322\"\"\210\202I
	\323=\203
\211\205\321\306H)\211\f>*\203
\204
\204
\n\211\205\360\306H)\324=\204
\310\311\322\"\"\210\202I
	 \211\f>*\203
\310\311\322\"\"\210\202I
	!\211\f>*\2038
\306U\2038
\310\311\325\306\"\"\210\202I
	\"\211\f>*\203I
\310\311\306\"\210	#\211\f>*\204W
\315!\211\204\306\207" [token token-kind last-token delphi-end-block-statements in-set element 0 open-group throw done delphi-open-group-indent close-group delphi-group-start delphi-previous-token newline delphi-block-start forward semicolon delphi-stmt-line-indent-of colon equals delphi-line-indent-of nested-block-count delphi-routine-statements last-terminator delphi-expr-delimiters expr-delimited delphi-body-statements delphi-compound-block-indent section-token delphi-block-statements delphi-indent-level delphi-begin-enclosing-tokens delphi-decl-delimiters delphi-unit-statements delphi-whitespace] 6) last-terminator] 3])
(defalias 'delphi-enclosing-indent-of #[(from-token) "\306!\211\205\f	\307H)\310\211\211\211\211\211\f
\311\312\215.\207" [from-token token expr-delimited before-equals equals-encountered last-token delphi-previous-token 0 nil done (byte-code "\203\267\211\205
\306H)\211\307=\2032\310\311\312\n\f\211
>*\203*\306\202,#\"\210\202\240	\313=\203?\314!\202\240	\211
>*\203S\315!\202\240	 \211
>*\203i!\n\"\202\240!\204\275	#\211
>*\203\275\310\311 \211
>*\203\221\316\306\"\202\270\n\203\247\f\211
>*\203\247\317\n!\202\270\n\203\263\317\n\"\202\270\317\"\"\210\202\240	\320=\203\335\310\311\"\203\323\316\"\"\202\330\316$\"\"\210\202\240	%\211
>*\203\373\310\311\316\"\206\363\"\"\210\202\240	\321=\203
\310\311\316\n\206	
\"\"\210\202\240	&\211
>*\2032
\310\311\317\n\203)
\n\202*
\"\"\210\202\240	'\211
>*\203\214
\310\311	(\211
>*\203\206
\322!\211\211\205]
\306H)\203p
	)\211
>*\204N
\203\202
	\323=\203\202
\324\n\"\202\207
\306\202\207
\306\"\210\202\240	*\211
>*\203\313
\310\311\n\203\267
	\325=\203\267
\f\211
>*\203\267
\317\n!\202\306
\n\203\303
\317\n\"\202\306
\326!\"\210\202\240\327!\203\352
\310\311\n\203\337
\317\n\"\202\345
\330!\\\"\210\202\240	\331=\203\374
\310\311\316\"\"\210\202\240	+\211
>*\203\310\311\316\n\206\"\"\210\202\240\332\n\"\203,\310\311\324\n\"\"\210\202\240	\333=\203h!\204h \211
>*\204h,\204h\323=\204h\310\311\n\203]\317\n\"\202c\324\334#\"\210\202\240	\333=\203\224,\203\224-\203\224\n\211\205\201\306H)\323=\204\240\310\311\317-\"\"\210\202\240	\323=\203\240,\n-	)\211
>*\204\257\322!\211\204\306\207" [token token-kind last-token from-kind delphi-binary-ops in-set 0 open-group throw done delphi-open-group-indent close-group delphi-group-start delphi-block-start delphi-stmt-line-indent-of delphi-indent-of case else delphi-previous-token equals delphi-line-indent-of comma delphi-previous-indent-of delphi-is-block-after-expr-statement delphi-section-indent-of asm delphi-composite-type-start colon semicolon element delphi-indent-level delphi-end-block-statements delphi-expr-delimiters expr-delimited stmt-start delphi-expr-statements delphi-case-label-indent delphi-body-expr-statements delphi-decl-sections delphi-unit-sections delphi-interface-types delphi-whitespace delphi-previous-terminators delphi-enclosing-statements equals-encountered before-equals] 8) stmt-start token-kind from-kind] 9])
(defalias 'delphi-corrected-indentation #[nil "\212\306 \307\216\310\311\312 \210\313 \210\311w\210\314 \211\211\205 \f\315H)\211\316=\2030\317\320\f!!\202\266
\211>*\203C\315\202\266
\211>*\203X\321\f!\202\266
 \211>*\203m\322\f!\202\266
!\211>*\203\231\323\f\324\"\"\325\"!\203\220\322\"!\202\225\326\"\315\")\202\266
\327=\203\250\326\330\f!\315\"\202\266\331\f\203\261\f\202\265\332`S!!#\333 \210#.\207" [data deactivate-mark inhibit-point-motion-hooks delphi-space-chars token token-kind match-data ((set-match-data data)) t nil delphi-progress-start beginning-of-line delphi-current-token 0 close-group delphi-indent-of delphi-group-start delphi-comment-indent-of delphi-section-indent-of delphi-block-start stop-on-class delphi-is-block-after-expr-statement delphi-stmt-line-indent-of else delphi-else-start delphi-enclosing-indent-of delphi-token-at delphi-progress-done delphi-unit-statements in-set element delphi-comments delphi-decl-matchers delphi-match-block-statements block-start indent] 4])
#@126 Indent the current line according to the current language construct.
If before the indent, the point is moved to the indent.
(defalias 'delphi-indent-line #[nil "\306 \307\216\310 \311\312\211\313 \210`
\311w\210i\314 \f`W\203'\f`\311\223\210\315\f\316\"\210\n	U\204<`|\210\317	\320\"c\210\fb\210\f\311\211\223.\207" [data new-indent old-indent line-start marked-point delphi-space-chars match-data ((set-match-data data)) point-marker nil 0 beginning-of-line delphi-corrected-indentation set-marker-insertion-type t make-string 32] 4 (#$ . 35701) nil])
#@45 Abbrev table in use in Delphi mode buffers.
(defvar delphi-mode-abbrev-table nil (#$ . 36273))
(define-abbrev-table 'delphi-mode-abbrev-table nil)
(defalias 'delphi-ensure-buffer '(macro . #[(buffer-var buffer-name) "\302\303\304DD\305\306	DEE\207" [buffer-var buffer-name when not buffer-live-p setq get-buffer-create] 6]))
(defalias 'delphi-log-msg #[(to-buffer the-msg) "rq\210\303 r\304\216\305!\210db\210\306\307!`\"\210\nc,\207" [to-buffer save-selected-window--state the-msg internal--before-save-selected-window ((internal--after-save-selected-window save-selected-window--state)) switch-to-buffer-other-window set-window-point get-buffer-window] 3])
#@68 Buffer to write Delphi mode debug messages to.  Created on demand.
(defvar delphi-debug-buffer nil (#$ . 36944))
(defalias 'delphi-debug-log #[(format-string &rest args) "\205\304	!\204\305\306!\307	\310\311\312 \"\313\314\nB\"\315Q\"\207" [delphi-debug delphi-debug-buffer format-string args buffer-live-p get-buffer-create "*Delphi Debug Log*" delphi-log-msg format-time-string "%H:%M:%S " current-time apply format "\n"] 7])
(defalias 'delphi-debug-token-string #[(token) "\303!\304\305	\"\211\203\306\307	\"\310\224\205\311P	*\207" [token image has-newline delphi-token-string string-match "^\\([^\n]*\\)\n\\(.+\\)?$" match-string 1 2 "..."] 4])
(defalias 'delphi-debug-show-current-token #[nil "\301 \302\303\304!#)\207" [token delphi-current-token delphi-debug-log "Token: %S %S" delphi-debug-token-string] 5 nil nil])
(defalias 'delphi-debug-goto-point #[(p) "b\207" [p] 1 nil "NGoto char: "])
(defalias 'delphi-debug-goto-next-token #[nil "\301\302 !\211\203\303H\202e)b\207" [token delphi-next-token delphi-current-token 1] 3 nil nil])
(defalias 'delphi-debug-goto-previous-token #[nil "\301\302 !\211\203\303H\202e)b\207" [token delphi-previous-token delphi-current-token 1] 3 nil nil])
(defalias 'delphi-debug-show-current-string #[(from to) "\302\303	{\"\207" [from to delphi-debug-log "String: %S"] 4 nil "r"])
(defalias 'delphi-debug-show-is-stable #[nil "\300\301\302`!\303`S!\303`!$\207" [delphi-debug-log "stable: %S prev: %S next: %S" delphi-is-stable-literal delphi-literal-kind] 6 nil nil])
(defalias 'delphi-debug-unparse-buffer #[nil "\300ed\301#\207" [delphi-set-text-properties nil] 4 nil nil])
(defalias 'delphi-debug-parse-region #[(from to) "\306\212\307 \310\216\306\311\312 \210\313\f
\"\210\314\315!.\207" [delphi-verbose data deactivate-mark inhibit-point-motion-hooks from to t match-data ((set-match-data data)) nil delphi-progress-start delphi-parse-region delphi-progress-done "Parsing done"] 3 nil "r"])
(defalias 'delphi-debug-parse-window #[nil "\300\301 \302 \"\207" [delphi-debug-parse-region window-start window-end] 3 nil nil])
(defalias 'delphi-debug-parse-buffer #[nil "\300ed\"\207" [delphi-debug-parse-region] 3 nil nil])
(defalias 'delphi-debug-fontify-window #[nil "\300\301 \302 \303#\207" [delphi-fontify-region window-start window-end t] 4 nil nil])
(defalias 'delphi-debug-fontify-buffer #[nil "\300ed\301#\207" [delphi-fontify-region t] 4 nil nil])
(defalias 'delphi-debug-tokenize-region #[(from to) "\212\306 \307\216\310\311\312 \210b\210`\fW\2031\313 \211\203#
\314H\202$e)b\210\315`\316#\210\202\317\320!-\207" [data deactivate-mark inhibit-point-motion-hooks from to token match-data ((set-match-data data)) t nil delphi-progress-start delphi-current-token 2 delphi-step-progress "Tokenizing" delphi-progress-done "Tokenizing done" delphi-scanning-progress-step] 5 nil nil])
(defalias 'delphi-debug-tokenize-buffer #[nil "\300ed\"\207" [delphi-debug-tokenize-region] 3 nil nil])
(defalias 'delphi-debug-tokenize-window #[nil "\300\301 \302 \"\207" [delphi-debug-tokenize-region window-start window-end] 3 nil nil])
#@148 Terminate the current line with a newline and indent the next, unless
`delphi-newline-always-indents' is nil, in which case no reindenting occurs.
(defalias 'delphi-newline #[nil "\301 \210\302 \210\205\212\303y\210\304 \210)\304 \207" [delphi-newline-always-indents delete-horizontal-space newline -1 delphi-indent-line] 1 (#$ . 40074) nil])
#@220 Indent the region, when Transient Mark mode is enabled and the region is
active.  Otherwise, indent the current line or insert a TAB, depending on the
value of `delphi-tab-always-indents' and the current line position.
(defalias 'delphi-tab #[nil "\302 \203\f\303\304 \305 \"\207\204\212	\306x\210n)\203\307 \207\310c\207" [delphi-tab-always-indents delphi-space-chars use-region-p indent-region region-beginning region-end nil delphi-indent-line "	"] 3 (#$ . 40427) nil])
(defalias 'delphi-is-directory #[(path) "\302!\211\205\n	@)\207" [path attributes file-attributes] 3])
(defalias 'delphi-is-file #[(path) "\302!\211\205	@?)\207" [path attributes file-attributes] 3])
(defalias 'delphi-search-directory #[(unit dir &optional recurse) "\304!\205\305!	\227\306\307\215*\207" [dir unit unit-file files delphi-is-directory directory-files done (byte-code "\302\303\"\210	\203\302\304\"\210\305\207" [files recurse mapc #[(file) "\304	Q	\227\230\205\305\n!\205\306\307\n\")\207" [dir file path unit-file "/" delphi-is-file throw done] 3] #[(subdir) "\305\235?\205\306	\n\307Q#\211\205\310\311\f\")\207" [subdir unit dir recurse path ("." "..") delphi-search-directory "/" throw done] 6] nil] 3)] 2])
(defalias 'delphi-find-unit-in-directory #[(unit dir) "\304\305\306\n\"\203\307\310\n\"\311\305\312\n\"\203\307\310\n\"\313\n	#*\207" [dir recurse dir-name unit nil string-match "^\\(.+\\)\\.\\.\\.$" match-string 1 t "^\\(.+\\)[\\\\/]$" delphi-search-directory] 4])
(defalias 'delphi-find-unit-file #[(unit) "\300\301\215\207" [done (byte-code "\204\f\302	\303\"\210\202;\203\302	\"\210\202\304\305\"\210\306\207" [delphi-search-path unit delphi-find-unit-in-directory "." mapc #[(dir) "\303	\"\211\205
\304\305\n\")\207" [unit dir file delphi-find-unit-in-directory throw done] 4] nil] 3)] 2])
#@153 Find the specified Delphi source file according to `delphi-search-path'.
If no extension is specified, .pas is assumed.  Creates a buffer for the unit.
(defalias 'delphi-find-unit #[(unit) "\303\304\"\203\202\305P\306	!\211\204\307\310	\"\210\202,\311\n!\210\312\313!\204,\313 \210\n*\207" [unit unit-file file string-match "^\\(.*\\)\\.[a-z]+$" ".pas" delphi-find-unit-file error "unit not found: %s" find-file derived-mode-p delphi-mode] 4 (#$ . 42292) "sDelphi unit name: "])
#@64 Find the definition of the identifier under the current point.
(defalias 'delphi-find-current-def #[nil "\300\301!\207" [error "delphi-find-current-def: not implemented yet"] 2 (#$ . 42790) nil])
#@253 Find the definition of the identifier under the current point, searching
in external units if necessary (as listed in the current unit's use clause).
The set of directories to search for a unit is specified by the global variable
`delphi-search-path'.
(defalias 'delphi-find-current-xdef #[nil "\300\301!\207" [error "delphi-find-current-xdef: not implemented yet"] 2 (#$ . 42993) nil])
#@84 Find the body of the identifier under the current point, assuming
it is a routine.
(defalias 'delphi-find-current-body #[nil "\300\301!\207" [error "delphi-find-current-body: not implemented yet"] 2 (#$ . 43386) nil])
#@107 Fill the text of the current comment, according to `fill-column'.
An error is raised if not in a comment.
(defalias 'delphi-fill-comment #[nil "\212\214\306 \211\211\205	\307H)\211\211\f>*\204!\310\311!\202@
\312!&\313!'&\211\2038	\314H\2029e)('\211\203I	\315H\202Je))\316&!*\317*!+\320+\321\",-.\322/\323 0\n\324=\203\244\317(!1\3201\321\"\325\320\326+1\315#\321\"Q),-\3252Q.\327)!\203\240)S\202\242))\3300\331\"\210*b\210\332c\210\333\334!\210*)}\210e\211/dW\203\337/b\210\335.\322\331#\203\337\336\337\322\211#\210`T\211/\202\277db\210\340c\2103+Z3\341ed\"\210)db\210\333\334!\210eb\210\322\210`\211/dW\203#
/b\210\335\342\322\331#\203#
\336,\322\211#\210`T\211/\202
d)~\2100b\2100\322\211\223\210\343 \210\344()\"\210\345 .\n,\207" [comment token comment-kind delphi-comments in-set element delphi-current-token 0 error "Not in a comment" delphi-comment-block-start delphi-comment-block-end 1 2 delphi-comment-content-start delphi-column-of make-string 32 nil point-marker comment-single-line "//" - delphi-is-literal-end set-marker-insertion-type t " " delete-char -1 re-search-forward replace-match "" "\n" fill-region "^" delphi-progress-start delphi-parse-region delphi-progress-done start-comment end-comment comment-start comment-end content-start content-indent content-prefix delphi-leading-spaces-re content-prefix-re p marked-point comment-indent delphi-spaces-re fill-column] 8 (#$ . 43611) nil])
#@142 If in a // comment, do a newline, indented such that one is still in the
comment block.  If not in a // comment, just does a normal newline.
(defalias 'delphi-new-comment-line #[nil "\306 \211\211\205\f	\307H)\310=\204\311 \202H\312!\211\211\203'	\313H\202(e)\314\n!\315\316!\317\"\320\315\321\f\322#\317\"Q\323 \210\324 \210
c,)\207" [comment token start-comment comment-start content-start prefix delphi-current-token 0 comment-single-line delphi-newline delphi-comment-block-start 1 delphi-comment-content-start make-string delphi-column-of 32 "//" - 2 delete-horizontal-space newline] 8 (#$ . 45104) nil])
(defalias 'delphi-match-token #[(token limit) "\303\304!\210\2051\211\203\305H\202e)	^\303\211\203&\306H\202'e)\nD!\210\nb\210)\207" [token limit end set-match-data nil 2 1] 4])
#@70 Delphi mode font-lock defaults.  Syntactic fontification is ignored.
(defconst delphi-font-lock-defaults '(nil t nil nil nil (font-lock-fontify-region-function . delphi-fontify-region) (font-lock-verbose . delphi-fontifying-progress-step)) (#$ . 45930))
#@44 Keystrokes for Delphi mode debug commands.
(defvar delphi-debug-mode-map (byte-code "\301 \302\303\304\"\210)\207" [kmap make-sparse-keymap mapc #[(binding) "\303	@	\211A@)#\207" [kmap binding x define-key] 5] (("n" delphi-debug-goto-next-token) ("p" delphi-debug-goto-previous-token) ("t" delphi-debug-show-current-token) ("T" delphi-debug-tokenize-buffer) ("W" delphi-debug-tokenize-window) ("g" delphi-debug-goto-point) ("s" delphi-debug-show-current-string) ("a" delphi-debug-parse-buffer) ("w" delphi-debug-parse-window) ("f" delphi-debug-fontify-window) ("F" delphi-debug-fontify-buffer) ("r" delphi-debug-parse-region) ("c" delphi-debug-unparse-buffer) ("x" delphi-debug-show-is-stable))] 3) (#$ . 46190))
#@29 Keymap used in Delphi mode.
(defvar delphi-mode-map (byte-code "\302 \303\304\305\306\307\310\311\312\313	D\257\"\210)\207" [kmap delphi-debug-mode-map make-sparse-keymap mapc #[(binding) "\303	@	\211A@)#\207" [kmap binding x define-key] 5] ("
" delphi-newline) ("	" delphi-tab) ("" backward-delete-char-untabify) ("u" delphi-find-unit) ("\361" delphi-fill-comment) ("\352" delphi-new-comment-line) ""] 10) (#$ . 46913))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [delphi-mode-hook variable-documentation put purecopy "Hook run when entering Delphi mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp delphi-mode-map definition-name delphi-mode] 5)
(defvar delphi-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [delphi-mode-map variable-documentation put purecopy "Keymap for `delphi-mode'." boundp delphi-mode-syntax-table definition-name delphi-mode] 5)
(defvar delphi-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [delphi-mode-syntax-table variable-documentation put purecopy "Syntax table for `delphi-mode'." delphi-mode-abbrev-table definition-name delphi-mode] 5)
(defvar delphi-mode-abbrev-table (progn (define-abbrev-table 'delphi-mode-abbrev-table nil) delphi-mode-abbrev-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [delphi-mode-abbrev-table variable-documentation put purecopy "Abbrev table for `delphi-mode'." delphi-mode derived-mode-parent prog-mode] 5)
#@1971 Major mode for editing Delphi code. \<delphi-mode-map>
\[delphi-tab]	- Indents the current line (or region, if Transient Mark mode
	  is enabled and the region is active) of Delphi code.
\[delphi-find-unit]	- Search for a Delphi source file.
\[delphi-fill-comment]	- Fill the current comment.
\[delphi-new-comment-line]	- If in a // comment, do a new comment line.

\[indent-region] also works for indenting a whole region.

Customization:

 `delphi-indent-level'                (default 3)
    Indentation of Delphi statements with respect to containing block.
 `delphi-compound-block-indent'       (default 0)
    Extra indentation for blocks in compound statements.
 `delphi-case-label-indent'           (default 0)
    Extra indentation for case statement labels.
 `delphi-tab-always-indents'          (default t)
    Non-nil means TAB in Delphi mode should always reindent the current line,
    regardless of where in the line point is when the TAB command is used.
 `delphi-newline-always-indents'      (default t)
    Non-nil means NEWLINE in Delphi mode should always reindent the current
    line, insert a blank line and move to the default indent column of the
    blank line.
 `delphi-search-path'                 (default .)
    Directories to search when finding external units.
 `delphi-verbose'                     (default nil)
    If true then Delphi token processing progress is reported to the user.

Coloring:

 `delphi-comment-face'                (default font-lock-comment-face)
    Face used to color Delphi comments.
 `delphi-string-face'                 (default font-lock-string-face)
    Face used to color Delphi strings.
 `delphi-keyword-face'                (default font-lock-keyword-face)
    Face used to color Delphi keywords.
 `delphi-other-face'                  (default nil)
    Face used to color everything else.

Turning on Delphi mode calls the value of the variable `delphi-mode-hook'
with no args, if that value is non-nil.
(defalias 'delphi-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324,\325\"\204V,-=\204V\326,\325-C#\210\327!\210\330\f!\210,-\331\332\333\334\335\336\337\340.D\257\"\210\341\342\343\344\307$\210~\210\212\345 /\346\216\307\34401\3072\347 \210\350ed\"\210\351 \210.\352\353!\210)\352\353!\207" [delay-mode-hooks major-mode mode-name delphi-mode-map delphi-mode-syntax-table parent make-local-variable t prog-mode delphi-mode "Delphi" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table abbrev-table-get :parents abbrev-table-put use-local-map set-syntax-table mapc #[(var) "@\211A@)\304!\nL*\207" [var x var-val var-symb make-local-variable] 3] (indent-line-function delphi-indent-line) (comment-indent-function delphi-indent-line) (case-fold-search t) (delphi-progress-last-reported-point nil) (delphi-ignore-changes nil) font-lock-defaults add-hook after-change-functions delphi-after-change nil match-data ((set-match-data data)) delphi-progress-start delphi-parse-region delphi-progress-done run-mode-hooks delphi-mode-hook delphi-mode-abbrev-table local-abbrev-table delphi-font-lock-defaults data deactivate-mark inhibit-point-motion-hooks delphi-verbose] 10 (#$ . 48634) nil])