| blob | dd8d267683c04586e371dc1a6d6024aceb861c68 |
1 ;;; delphi.el --- major mode for editing Delphi source (Object Pascal) in Emacs
3 ;; Copyright (C) 1998-1999, 2001-2012 Free Software Foundation, Inc.
5 ;; Authors: Ray Blaak <blaak@infomatch.com>,
6 ;; Simon South <ssouth@member.fsf.org>
7 ;; Maintainer: Simon South <ssouth@member.fsf.org>
8 ;; Keywords: languages
10 ;; This file is part of GNU Emacs.
12 ;; GNU Emacs is free software: you can redistribute it and/or modify
13 ;; it under the terms of the GNU General Public License as published by
14 ;; the Free Software Foundation, either version 3 of the License, or
15 ;; (at your option) any later version.
17 ;; GNU Emacs is distributed in the hope that it will be useful,
18 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
19 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 ;; GNU General Public License for more details.
22 ;; You should have received a copy of the GNU General Public License
23 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
25 ;;; Commentary:
27 ;; To enter Delphi mode when you find a Delphi source file, one must override
28 ;; the auto-mode-alist to associate Delphi with .pas (and .dpr and .dpk)
29 ;; files. Emacs, by default, will otherwise enter Pascal mode. E.g.
30 ;;
31 ;; (autoload 'delphi-mode "delphi")
32 ;; (setq auto-mode-alist
33 ;; (cons '("\\.\\(pas\\|dpr\\|dpk\\)$" . delphi-mode) auto-mode-alist))
35 ;; To get keyword, comment, and string literal coloring, be sure that font-lock
36 ;; is running. One can manually do M-x font-lock-mode in a Delphi buffer, or
37 ;; one can put in .emacs:
38 ;;
39 ;; (add-hook 'delphi-mode-hook 'turn-on-font-lock)
41 ;; If font-lock is not loaded by default, you might have to do:
42 ;;
43 ;; (autoload 'font-lock-mode "font-lock")
44 ;; (autoload 'turn-on-font-lock "font-lock")
45 ;; (setq font-lock-support-mode 'lazy-lock-mode)
46 ;;
47 ;; Lazy lock is very necessary for faster screen updates.
49 ;; For good performance, be sure to byte-compile delphi.el, e.g.
50 ;;
51 ;; M-x byte-compile-file <give the path to delphi.el when prompted>
53 ;; This will generate delphi.elc, which will be loaded instead of delphi.el
54 ;; when delphi-mode is autoloaded.
56 ;; When you have entered Delphi mode, you may get more info by pressing
57 ;; C-h m.
59 ;; This Delphi mode implementation is fairly tolerant of syntax errors, relying
60 ;; as much as possible on the indentation of the previous statement. This also
61 ;; makes it faster and simpler, since there is less searching for properly
62 ;; constructed beginnings.
64 ;;; Code:
69 "Major mode for editing Delphi source in Emacs."
77 "*Directories to search when finding external units.
78 It is a list of directory strings. If only a single directory,
79 it can be a single string instead of a list. If a directory
85 "*Indentation of Delphi statements with respect to containing block.
86 E.g.
88 begin
89 // This is an indent of 3.
90 end;"
95 "*Extra indentation for blocks in compound statements. E.g.
97 // block indent = 0 vs // block indent = 2
98 if b then if b then
99 begin begin
100 end else begin end
101 end; else
102 begin
103 end;"
108 "*Extra indentation for case statement labels. E.g.
110 // case indent = 0 vs // case indent = 3
111 case value of case value of
112 v1: process_v1; v1: process_v1;
113 v2: process_v2; v2: process_v2;
114 else else
115 process_else; process_else;
116 end; end;"
121 "*If true then Delphi token processing progress is reported to the user."
126 "*Non-nil means TAB in Delphi mode should always reindent the current line,
127 regardless of where in the line point is when the TAB command is used."
132 "*Non-nil means NEWLINE in Delphi mode should always reindent the current
133 line, insert a blank line and move to the default indent column of the blank
134 line. If nil, then no indentation occurs, and NEWLINE does the usual
135 behavior. This is useful when one needs to do customized indentation that
136 differs from the default."
141 "*Face used to color Delphi comments."
146 "*Face used to color Delphi strings."
151 "*Face used to color Delphi keywords."
156 "*Face used to color everything else."
162 export external far forward index inline message name near nodefault
163 overload override pascal private protected public published read readonly
164 register reintroduce resident resourcestring safecall stdcall stored
165 virtual write writeonly)
171 and array as asm at begin case class const constructor contains
172 destructor dispinterface div do downto else end except exports
173 file finalization finally for function goto if implementation implements
174 in inherited initialization interface is label library mod nil not
175 of object on or out package packed procedure program property
176 raise record repeat requires result self set shl shr then threadvar
177 to try type unit uses until var while with xor
179 ;; These routines should be keywords, if Borland had the balls.
180 break exit)
182 ;; We want directives to look like keywords.
183 delphi-directives)
205 "Statements that have either a single statement or a block as a body and also
292 "Tokens that a begin token aligns with, but only if not part of a nested
302 ;; Executes the forms such that the current match data is preserved, so as
303 ;; not to disturb any existing search results.
310 ;; Executes the forms such that any movements have no effect, including
311 ;; searches.
319 ;; Executes the forms such that any buffer modifications do not have any side
320 ;; effects beyond the buffer's actual content changes.
330 ;; Disable any queries about editing obsolete files.
338 ;; If the element is in the set, the element cdr is returned, otherwise nil.
342 ;; Returns the buffer string from start to end.
346 ;; True if point p marks the start of string s. s is not a regular
347 ;; expression.
353 ;; Constructs a token from a kind symbol and its start/end points.
357 ;; Returns the kind symbol of the token.
361 ;; Sets the kind symbol of the token.
365 ;; Returns the start point of the token.
369 ;; Returns the end point of the token.
373 ;; Sets the start point of the token.
377 ;; Sets the end point of the token.
381 ;; Returns the string image of the token.
387 ;; Returns true if the point p is within the token's start/end points.
391 ;; Returns the column of the point p.
395 ;; Returns the face property appropriate for the token kind.
412 ;; Initializes progress reporting.
416 ;; Finalizes progress reporting.
424 ;; If enough distance has elapsed since the last reported point, then report
425 ;; the current progress to the user.
427 ;; This is the first progress step.
432 ;; Report the percentage complete.
438 ;; Returns the first point of the next line.
445 next))
448 "Internal flag to control if the Delphi mode responds to buffer changes.
449 Defaults to t in case the `delphi-after-change' function is called on a
450 non-Delphi buffer. Set to nil in a Delphi buffer. To override, just do:
454 ;; Like `set-text-properties', except we do not consider this to be a buffer
455 ;; modification.
460 ;; Returns the literal kind the point p is in (or nil if not in a literal).
465 ;; Returns the start pattern of the literal kind.
474 ;; Returns the end pattern of the literal kind.
483 ;; Returns the pattern that delimits end of the search for the literal kind.
484 ;; These are regular expressions.
489 ;; Strings cannot span lines.
494 ;; True if the point p is at the start point of a (completed) literal.
501 ;; True if the point p is at the end point of a (completed) literal.
508 ;; Special case: string delimiters are start/end ambiguous.
509 ;; We have an end only if there is some string content (at
510 ;; least a starting delimiter).
513 ;; Special case: strings cannot span lines.
517 ;; True if the point p marks a stable point. That is, a point outside of a
518 ;; literal region, inside of a literal region, or adjacent to completed
519 ;; literal regions.
528 ;; Continues the search for a literal's true end point and returns the
529 ;; point past the end pattern (if found) or the limit (if not found).
533 ;; Search up to the limit.
538 ;; Creates a list of text properties for the literal kind.
540 font-lock-mode)
545 ;; Searches for the next literal region (i.e. comment or string) and sets the
546 ;; the point to its end (or the limit, if not found). The literal region is
547 ;; marked as such with a text property, to speed up tokenizing during face
548 ;; coloring and indentation scanning.
551 ;; We are completing an incomplete literal.
560 ;; We found the start of a new literal. Find its end and mark it.
572 ;; Nothing found. Mark it as a non-literal.
577 ;; Returns the literal token surrounding the point p, or nil if none.
585 ;; Returns the single character token at the point p.
589 ;; Returns the token at the point p that describes the specified character.
590 ;; If not actually over such a character, nil is returned.
595 ;; Returns the token surrounding point p that contains only members of the
596 ;; character set.
607 token))
610 ;; If point p is surrounded by space characters, then return the token of the
611 ;; contiguous spaces.
615 ;; If point p is over a word (i.e. identifier characters), then return a word
616 ;; token. If the word is actually a keyword, then return the keyword token.
624 word))))
627 ;; If point p is anywhere in the token string then returns the resulting
628 ;; token.
631 token)))
634 ;; Returns the token from parsing text at point p.
663 ;; Returns the delphi source token under the current point.
667 ;; Returns the token after the specified token.
672 delphi-scanning-progress-step))
673 next)))
676 ;; Returns the token before the specified token.
681 delphi-scanning-progress-step))
682 previous)))
685 ;; Returns the first non-space token after the specified token.
690 next-token))
693 ;; Parses the literal tokens in the region. The point is set to "to".
701 ;; Parses at least the literal tokens in the region. After that, parsing
702 ;; continues as long as obsolete literal regions are encountered. The point
703 ;; is set to the encountered stable point.
711 ;; Colors the text in the region according to Delphi rules.
719 ;; Color the token and move past it.
729 ;; Called when the buffer has changed. Reparses the changed region.
734 ;; Reparse at least from the token previous to the change to the end of
735 ;; line after the change.
742 ;; Returns the token that denotes the start of the ()/[] group.
749 ;; Skip over nested groups.
753 ;; Start not found.
754 nil)))
757 ;; Returns the token that denotes the end of the ()/[] group.
764 ;; Skip over nested groups.
768 ;; end not found.
769 nil)))
772 ;; Returns the start column of the token, plus any offset.
782 indent))
785 ;; Returns the column of first non-space character on the token's line, plus
786 ;; any offset. We also stop if one of the terminators or an open ( or [ is
787 ;; encountered.
795 ;; Skip over ()/[] groups.
798 ;; Stop at the beginning of the line or an open group.
801 ;; Stop at one of the specified terminators.
808 ;; Like `delphi-line-indent-of' except is also stops on a use clause, and
809 ;; colons that precede statements (i.e. case labels).
819 `(,@delphi-block-statements
821 ;; We hit a label followed by a statement. Indent to the statement.
824 ;; Skip over ()/[] groups.
828 ;; Stop at the beginning of the line, an open group, or a use clause
835 ;; Returns the indent relative to an unmatched ( or [.
839 ;; There is nothing following the ( or [. Indent from its line.
843 ;; Returns true (actually the last-token) if the pair equals (= class), (=
844 ;; dispinterface), (= interface), (= object), or (= record), and nil
845 ;; otherwise.
848 last-token))
851 ;; True if at-token is the start of a simple class type. E.g.
852 ;; class of TClass;
853 ;; class (TBaseClass);
854 ;; class;
857 ;; Scan until the semi colon.
864 ;; A semicolon delimits the search.
867 ;; Skip over the inheritance list.
870 ;; Only allow "of" and whitespace, and an identifier
873 ;; Otherwise we are not in a simple class declaration.
878 ;; Returns the token that denotes the start of the block.
886 ;; Skip over nested blocks.
890 ;; Regular block start found.
893 ;; As a special case, when a "case" block appears
894 ;; within a record declaration (to denote a variant
895 ;; part), the record declaration should be considered
896 ;; the enclosing block.
905 enclosing-token
907 token))
908 token)))
910 ;; A class/record start also begins a block.
913 )
917 ;; Start not found.
918 nil)))
921 ;; Returns the token of the if or case statement.
929 ;; Skip over nested groups.
932 ;; Skip over any nested blocks.
937 ;; Semicolon means we are looking for an enclosing if, unless we
938 ;; are in a case statement. Keep counts of the semicolons and decide
939 ;; later.
943 ;; We only can match an if when there have been no intervening
944 ;; semicolons.
948 ;; We have hit a case statement start.
951 ;; No if or case statement found.
952 nil)))
955 ;; Returns the point of the first non-space character in the comment.
965 ;; Returns the starting comment token of a contiguous // comment block. If
966 ;; the comment is multiline (i.e. {...} or (*...*)), the original comment is
967 ;; returned.
969 comment
970 ;; Scan until we run out of // comments.
979 start-comment)))
982 ;; Returns the end comment token of a contiguous // comment block. If the
983 ;; comment is multiline (i.e. {...} or (*...*)), the original comment is
984 ;; returned.
986 comment
987 ;; Scan until we run out of // comments.
996 end-comment)))
999 ;; Returns true if the current point is on the first line of the comment.
1008 ;; Returns the correct indentation for the comment.
1012 ;; Indent as a statement.
1018 ;; Indent to the first comment in the // block.
1023 ;; Indent multi-line comment terminators to the comment start.
1026 ;; Indent according to the comment's content start.
1028 ))
1031 ;; True if we are after the end of a uses type clause.
1036 ;; Scan for the uses statement, just to be sure.
1045 ;; Whitespace, identifiers, strings, "in" keyword, and commas
1046 ;; are allowed in use clauses.
1051 ;; Nothing else is.
1054 nil))))
1057 ;; Returns true if we have a block token trailing an expression delimiter (of
1058 ;; presumably an expression statement).
1070 ;; Returns the indentation of the previous statement of the token.
1081 ;; An open ( or [ always is an indent point.
1085 ;; Skip over any ()/[] groups.
1090 ;; We can stop at an end token that is right up against the
1091 ;; margin.
1093 ;; Otherwise, skip over any nested blocks.
1096 ;; Special case: if we encounter a ", word;" then we assume that we
1097 ;; are in some kind of uses clause, and thus indent to column 0. This
1098 ;; works because no other constructs are known to have that form.
1099 ;; This fixes the irritating case of having indents after a uses
1100 ;; clause look like:
1101 ;; uses
1102 ;; someUnit,
1103 ;; someOtherUnit;
1104 ;; // this should be at column 0!
1108 ;; A previous terminator means we can stop. If we are on a directive,
1109 ;; however, then we are not actually encountering a new statement.
1113 delphi-directives)))
1116 ;; Ignore whitespace.
1119 ;; Remember any "of" we encounter, since that affects how we
1120 ;; indent to a case statement within a record declaration
1121 ;; (i.e. a variant part).
1125 ;; Remember any ':' we encounter (until we reach an "of"),
1126 ;; since that affects how we indent to case statements in
1127 ;; general.
1131 ;; A case statement delimits a previous statement. We indent labels
1132 ;; specially.
1138 ;; If we are in a use clause then commas mark an enclosing rather than
1139 ;; a previous statement.
1144 ;; Indent to first unit in use clause.
1146 ;; Indent from use clause keyword.
1148 ;; Indent to use clause keyword.
1151 ;; Assembly sections always indent in from the asm keyword.
1155 ;; An enclosing statement delimits a previous statement.
1156 ;; We try to use the existing indent of the previous statement,
1157 ;; otherwise we calculate from the enclosing statement.
1160 ;; Otherwise indent to the last token
1162 ;; Just indent from the enclosing keyword
1165 ;; A class or record declaration also delimits a previous statement.
1168 'done
1170 ;; c = class; or c = class of T; are previous statements.
1172 ;; Otherwise c = class ... or r = record ... are enclosing
1173 ;; statements.
1176 ;; We have a definite previous statement delimiter.
1179 )
1183 ;; We ran out of tokens. Indent to column 0.
1187 ;; Returns the indentation appropriate for begin/var/const/type/label
1188 ;; tokens.
1199 ;; Always stop at unmatched ( or [.
1203 ;; Skip over any ()/[] groups.
1208 ;; We can stop at an end token that is right up against the
1209 ;; margin.
1211 ;; Otherwise, skip over any nested blocks.
1215 ;; Remember if we have encountered any forward routine declarations.
1219 ;; Mark the completion of a nested routine traversal.
1224 ;; Remember if we have encountered any statement terminators.
1227 ;; Remember if we have encountered any expression delimiters.
1231 ;; Enclosing body statements are delimiting. We indent the compound
1232 ;; bodies specially.
1238 ;; An enclosing ":" means a label.
1241 delphi-block-statements)
1248 ;; Block and mid block tokens are always enclosing
1253 ;; Declaration sections and routines are delimiters, unless they
1254 ;; are part of a nested routine.
1259 ;; Unit statements mean we indent right to the left.
1261 )
1265 ;; We ran out of tokens. Indent to column 0.
1269 ;; Returns the indentation offset from the enclosing statement of the token.
1282 ;; An open ( or [ always is an indent point.
1286 token last-token
1288 ;; Keep binary operations aligned with the open group.
1289 0
1290 delphi-indent-level))))
1292 ;; Skip over any ()/[] groups.
1295 ;; Skip over any nested blocks.
1299 ;; An expression delimiter affects indentation depending on whether
1300 ;; the point is before or after it. Remember that we encountered one.
1301 ;; Also remember the last encountered token, since if it exists it
1302 ;; should be the actual indent point.
1306 ;; With a non-delimited expression statement we indent after the
1307 ;; statement's keyword, unless we are on the delimiter itself.
1312 ;; We are indenting a delimiter. Indent to the statement.
1316 ;; Align binary ops with the expression.
1320 ;; Indent in from the expression.
1323 ;; Indent in from the statement's keyword.
1326 ;; A delimited case statement indents the label according to
1327 ;; a special rule.
1331 ;; We are not actually indenting to the case statement,
1332 ;; but are within a label expression.
1334 stmt-start delphi-indent-level)
1335 ;; Indent from the case keyword.
1337 token delphi-case-label-indent))))
1339 ;; Body expression statements are enclosing. Indent from the
1340 ;; statement's keyword, unless we have a non-block statement following
1341 ;; it.
1347 ;; An else statement is enclosing, but it doesn't have an expression.
1348 ;; Thus we take into account last-token instead of stmt-start.
1353 ;; We indent relative to an enclosing declaration section.
1356 delphi-indent-level)))
1358 ;; In unit sections we indent right to the left.
1361 ;; Handle specially the case of "interface", which can be used
1362 ;; to start either a unit section or an interface definition.
1365 ;; Find the previous non-whitespace token.
1372 delphi-whitespace))))
1373 ;; If this token is an equals sign, "interface" is being
1374 ;; used to start an interface definition and we should
1375 ;; treat it as a composite type; otherwise, we should
1376 ;; consider it the start of a unit section.
1379 delphi-indent-level)
1383 ;; A previous terminator means we can stop.
1389 ;; Align binary ops with the expression.
1393 ;; Indent in from the expression.
1396 ;; No enclosing expression; use the previous statement's
1397 ;; indent.
1400 ;; A block statement after an expression delimiter has its start
1401 ;; column as the expression statement. E.g.
1402 ;; if (a = b)
1403 ;; and (a != c) then begin
1404 ;; //...
1405 ;; end;
1406 ;; Remember it for when we encounter the expression statement start.
1413 ;; Assembly sections always indent in from the asm keyword.
1417 ;; Stop at an enclosing statement and indent from it.
1422 ;; A class/record declaration is also enclosing.
1427 ;; A ":" we indent relative to its line beginning. If we are in a
1428 ;; parameter list, then stop also if we hit a ";".
1439 ;; If the ":" was not processed above and we have token after the "=",
1440 ;; then indent from the "=". Ignore :=, however.
1443 ;; Ignore binary ops for now. It would do, for example:
1444 ;; val := 1 + 2
1445 ;; + 3;
1446 ;; which is good, but also
1447 ;; val := Foo
1448 ;; (foo, args)
1449 ;; + 2;
1450 ;; which doesn't look right.
1451 ;;;; Align binary ops with the before token.
1452 ;;((delphi-is from-kind delphi-binary-ops)
1453 ;;(throw 'done (delphi-indent-of before-equals 0)))
1455 ;; Assignments (:=) we skip over to get a normal indent.
1458 ;; Otherwise indent in from the equals.
1462 ;; Remember any "=" we encounter if it has not already been processed.
1465 before-equals last-token))
1466 )
1470 ;; We ran out of tokens. Indent to column 0.
1474 ;; Returns the corrected indentation for the current line.
1477 ;; Move to the first token on the line.
1484 ;; Indent to the matching start ( or [.
1490 ;; In a comment.
1494 ;; Use a previous section/routine's indent.
1498 ;; Use the block's indentation.
1502 ;; When trailing a body statement, indent to
1503 ;; the statement's keyword.
1507 ;; Otherwise just indent to the block start.
1511 ;; Find the start of the if or case statement.
1514 ;; Otherwise indent in from enclosing statement.
1518 indent)))
1521 "Indent the current line according to the current language construct.
1522 If before the indent, the point is moved to the indent."
1535 ;; If before the indent column, then move to it.
1537 ;; Advance our marked point after inserted spaces.
1550 ;; Ensures there exists a buffer of the specified name in the specified
1551 ;; variable.
1556 ;; Writes a message to the end of the specified buffer.
1564 ;; Debugging helpers:
1570 ;; Writes a message to the log buffer.
1584 image))
1662 "Terminate the current line with a newline and indent the next, unless
1663 `delphi-newline-always-indents' is nil, in which case no reindenting occurs."
1665 ;; Remove trailing spaces
1669 ;; Indent both the (now) previous and current line first.
1677 "Indent the region, when Transient Mark mode is enabled and the region is
1678 active. Otherwise, indent the current line or insert a TAB, depending on the
1679 value of `delphi-tab-always-indents' and the current line position."
1682 ;; If Transient Mark mode is enabled and the region is active, indent
1683 ;; the entire region.
1687 ;; Otherwise, if we are configured always to indent (regardless of the
1688 ;; point's position in the line) or we are before the first non-space
1689 ;; character on the line, indent the line.
1692 ;; Otherwise, insert a tab character.
1697 ;; True if the specified path is an existing directory.
1702 ;; True if the specified file exists as a file.
1707 ;; Searches for the unit in the specified directory. If recurse is true, then
1708 ;; the directory is recursively searched. File name comparison is done in a
1709 ;; case insensitive manner.
1714 ;; Search for the file.
1720 files)
1722 ;; Not found. Search subdirectories.
1729 files))
1731 ;; Not found.
1732 nil))))
1736 ;; Searches for the unit in the specified directory. If the directory ends
1737 ;; in \"...\", then it is recursively searched.
1740 ;; Check if we need to recursively search the directory.
1743 recurse t))
1744 ;; Ensure the trailing slash is removed.
1750 ;; Finds the specified delphi source file according to `delphi-search-path'.
1751 ;; If found, the full path is returned, otherwise nil is returned.
1763 delphi-search-path)))
1764 nil))
1767 "Find the specified Delphi source file according to `delphi-search-path'.
1768 If no extension is specified, .pas is assumed. Creates a buffer for the unit."
1771 unit
1779 file))
1782 "Find the definition of the identifier under the current point."
1787 "Find the definition of the identifier under the current point, searching
1788 in external units if necessary (as listed in the current unit's use clause).
1789 The set of directories to search for a unit is specified by the global variable
1790 `delphi-search-path'."
1795 "Find the body of the identifier under the current point, assuming
1796 it is a routine."
1801 "Fill the text of the current comment, according to `fill-column'.
1802 An error is raised if not in a comment."
1821 ;; // style comments need more work.
1826 ?\s)))
1828 "//"
1829 delphi-spaces-re)
1831 ;; Don't include the trailing newline.
1833 comment-end)))
1835 ;; Advance our marked point after inserted spaces.
1838 ;; Ensure we can modify the buffer
1845 ;; Strip off the comment prefixes
1853 ;; add an extra line to prevent the fill from doing it for us.
1857 ;; Fill the comment contents.
1864 ;; Restore comment prefixes.
1877 ;; Restore our position
1881 ;; React to the entire fill change as a whole.
1887 "If in a // comment, do a newline, indented such that one is still in the
1888 comment block. If not in a // comment, just does a normal newline."
1892 ;; Not in a // comment. Just do the normal newline.
1905 ;; Sets the match region used by (match-string 0) and friends to the token's
1906 ;; region. Sets the current point to the end of the token (or limit).
1912 token)))
1916 t ; Syntactic fontification doesn't apply.
1917 nil ; Don't care about case since we don't use regexps to find tokens.
1918 nil ; Syntax alists don't apply.
1919 nil ; Syntax begin movement doesn't apply
1941 ))
1942 kmap)
1951 ;; '("\C-cd" delphi-find-current-def)
1952 ;; '("\C-cx" delphi-find-current-xdef)
1953 ;; '("\C-cb" delphi-find-current-body)
1957 ;; Debug bindings:
1959 kmap)
1962 ;;;###autoload
1973 Customization:
1975 `delphi-indent-level' (default 3)
1976 Indentation of Delphi statements with respect to containing block.
1977 `delphi-compound-block-indent' (default 0)
1978 Extra indentation for blocks in compound statements.
1979 `delphi-case-label-indent' (default 0)
1980 Extra indentation for case statement labels.
1981 `delphi-tab-always-indents' (default t)
1982 Non-nil means TAB in Delphi mode should always reindent the current line,
1983 regardless of where in the line point is when the TAB command is used.
1984 `delphi-newline-always-indents' (default t)
1985 Non-nil means NEWLINE in Delphi mode should always reindent the current
1986 line, insert a blank line and move to the default indent column of the
1987 blank line.
1988 `delphi-search-path' (default .)
1989 Directories to search when finding external units.
1990 `delphi-verbose' (default nil)
1991 If true then Delphi token processing progress is reported to the user.
1993 Coloring:
1995 `delphi-comment-face' (default font-lock-comment-face)
1996 Face used to color Delphi comments.
1997 `delphi-string-face' (default font-lock-string-face)
1998 Face used to color Delphi strings.
1999 `delphi-keyword-face' (default font-lock-keyword-face)
2000 Face used to color Delphi keywords.
2001 `delphi-other-face' (default nil)
2002 Face used to color everything else.
2004 Turning on Delphi mode calls the value of the variable `delphi-mode-hook'
2005 with no args, if that value is non-nil."
2007 ;; Buffer locals:
2019 ;; We need to keep track of changes to the buffer to determine if we need
2020 ;; to retokenize changed text.
2033 ;;; delphi.el ends here