| blob | c5a38607b3844663824ab0221bc489f8add1c9b2 |
1 ;;; delphi.el --- major mode for editing Delphi source (Object Pascal) in Emacs
3 ;; Copyright (C) 1998, 1999, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
4 ;; 2008, 2009 Free Software Foundation, Inc.
6 ;; Authors: Ray Blaak <blaak@infomatch.com>,
7 ;; Simon South <ssouth@member.fsf.org>
8 ;; Maintainer: Simon South <ssouth@member.fsf.org>
9 ;; Keywords: languages
11 ;; This file is part of GNU Emacs.
13 ;; GNU Emacs is free software: you can redistribute it and/or modify
14 ;; it under the terms of the GNU General Public License as published by
15 ;; the Free Software Foundation, either version 3 of the License, or
16 ;; (at your option) any later version.
18 ;; GNU Emacs is distributed in the hope that it will be useful,
19 ;; but WITHOUT ANY WARRANTY; without even the implied warranty of
20 ;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 ;; GNU General Public License for more details.
23 ;; You should have received a copy of the GNU General Public License
24 ;; along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>.
26 ;;; Commentary:
28 ;; To enter Delphi mode when you find a Delphi source file, one must override
29 ;; the auto-mode-alist to associate Delphi with .pas (and .dpr and .dpk)
30 ;; files. Emacs, by default, will otherwise enter Pascal mode. E.g.
31 ;;
32 ;; (autoload 'delphi-mode "delphi")
33 ;; (setq auto-mode-alist
34 ;; (cons '("\\.\\(pas\\|dpr\\|dpk\\)$" . delphi-mode) auto-mode-alist))
36 ;; To get keyword, comment, and string literal coloring, be sure that font-lock
37 ;; is running. One can manually do M-x font-lock-mode in a Delphi buffer, or
38 ;; one can put in .emacs:
39 ;;
40 ;; (add-hook 'delphi-mode-hook 'turn-on-font-lock)
42 ;; If font-lock is not loaded by default, you might have to do:
43 ;;
44 ;; (autoload 'font-lock-mode "font-lock")
45 ;; (autoload 'turn-on-font-lock "font-lock")
46 ;; (setq font-lock-support-mode 'lazy-lock-mode)
47 ;;
48 ;; Lazy lock is very necessary for faster screen updates.
50 ;; For good performance, be sure to byte-compile delphi.el, e.g.
51 ;;
52 ;; M-x byte-compile-file <give the path to delphi.el when prompted>
54 ;; This will generate delphi.elc, which will be loaded instead of delphi.el
55 ;; when delphi-mode is autoloaded.
57 ;; When you have entered Delphi mode, you may get more info by pressing
58 ;; C-h m.
60 ;; This delphi mode implementation is fairly tolerant of syntax errors, relying
61 ;; as much as possible on the indentation of the previous statement. This also
62 ;; makes it faster and simpler, since there is less searching for properly
63 ;; constructed beginnings.
65 ;;; Code:
70 "Major mode for editing Delphi source in Emacs."
78 "*Directories to search when finding external units. It is a list of
79 directory strings. If only a single directory, it can be a single
81 directory is recursively searched."
86 "*Indentation of Delphi statements with respect to containing block. 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 ;; Like `set-text-properties', except we do not consider this to be a buffer
449 ;; modification.
454 ;; Returns the literal kind the point p is in (or nil if not in a literal).
459 ;; Returns the start pattern of the literal kind.
468 ;; Returns the end pattern of the literal kind.
477 ;; Returns the pattern that delimits end of the search for the literal kind.
478 ;; These are regular expressions.
483 ;; Strings cannot span lines.
488 ;; True if the point p is at the start point of a (completed) literal.
495 ;; True if the point p is at the end point of a (completed) literal.
502 ;; Special case: string delimiters are start/end ambiguous.
503 ;; We have an end only if there is some string content (at
504 ;; least a starting delimiter).
507 ;; Special case: strings cannot span lines.
511 ;; True if the point p marks a stable point. That is, a point outside of a
512 ;; literal region, inside of a literal region, or adjacent to completed
513 ;; literal regions.
522 ;; Continues the search for a literal's true end point and returns the
523 ;; point past the end pattern (if found) or the limit (if not found).
527 ;; Search up to the limit.
532 ;; Creates a list of text properties for the literal kind.
534 font-lock-mode)
539 ;; Searches for the next literal region (i.e. comment or string) and sets the
540 ;; the point to its end (or the limit, if not found). The literal region is
541 ;; marked as such with a text property, to speed up tokenizing during face
542 ;; coloring and indentation scanning.
545 ;; We are completing an incomplete literal.
554 ;; We found the start of a new literal. Find its end and mark it.
566 ;; Nothing found. Mark it as a non-literal.
571 ;; Returns the literal token surrounding the point p, or nil if none.
579 ;; Returns the single character token at the point p.
583 ;; Returns the token at the point p that describes the specified character.
584 ;; If not actually over such a character, nil is returned.
589 ;; Returns the token surrounding point p that contains only members of the
590 ;; character set.
602 token))
605 ;; If point p is surrounded by space characters, then return the token of the
606 ;; contiguous spaces.
610 ;; If point p is over a word (i.e. identifier characters), then return a word
611 ;; token. If the word is actually a keyword, then return the keyword token.
619 word))))
622 ;; If point p is anywhere in the token string then returns the resulting
623 ;; token.
626 token)))
629 ;; Returns the token from parsing text at point p.
657 ;; Returns the delphi source token under the current point.
661 ;; Returns the token after the specified token.
666 delphi-scanning-progress-step))
667 next)))
670 ;; Returns the token before the specified token.
675 delphi-scanning-progress-step))
676 previous)))
679 ;; Returns the first non-space token after the specified token.
684 next-token))
687 ;; Parses the literal tokens in the region. The point is set to "to".
695 ;; Parses at least the literal tokens in the region. After that, parsing
696 ;; continues as long as obsolete literal regions are encountered. The point
697 ;; is set to the encountered stable point.
705 ;; Colors the text in the region according to Delphi rules.
713 ;; Color the token and move past it.
723 "Internal flag to control if the delphi-mode responds to buffer changes.
724 Defaults to t in case the delphi-after-change function is called on a
725 non-delphi buffer. Set to nil in a delphi buffer. To override, just do:
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 ;; A class/record start also begins a block.
896 )
900 ;; Start not found.
901 nil)))
904 ;; Returns the token of the if or case statement.
913 ;; Skip over nested groups.
916 ;; Skip over any nested blocks.
921 ;; Semicolon means we are looking for an enclosing if, unless we
922 ;; are in a case statement. Keep counts of the semicolons and decide
923 ;; later.
927 ;; We only can match an if when there have been no intervening
928 ;; semicolons.
932 ;; We have hit a case statement start.
935 ;; No if or case statement found.
936 nil)))
939 ;; Returns the point of the first non-space character in the comment.
949 ;; Returns the starting comment token of a contiguous // comment block. If
950 ;; the comment is multiline (i.e. {...} or (*...*)), the original comment is
951 ;; returned.
953 comment
954 ;; Scan until we run out of // comments.
964 start-comment)))
967 ;; Returns the end comment token of a contiguous // comment block. If the
968 ;; comment is multiline (i.e. {...} or (*...*)), the original comment is
969 ;; returned.
971 comment
972 ;; Scan until we run out of // comments.
982 end-comment)))
985 ;; Returns true if the current point is on the first line of the comment.
994 ;; Returns the correct indentation for the comment.
998 ;; Indent as a statement.
1004 ;; Indent to the first comment in the // block.
1009 ;; Indent multi-line comment terminators to the comment start.
1012 ;; Indent according to the comment's content start.
1014 ))
1017 ;; True if we are after the end of a uses type clause.
1022 ;; Scan for the uses statement, just to be sure.
1031 ;; Whitespace, identifiers, strings, "in" keyword, and commas
1032 ;; are allowed in use clauses.
1037 ;; Nothing else is.
1040 nil))))
1043 ;; Returns true if we have a block token trailing an expression delimiter (of
1044 ;; presumably an expression statement).
1056 ;; Returns the indentation of the previous statement of the token.
1066 ;; An open ( or [ always is an indent point.
1070 ;; Skip over any ()/[] groups.
1075 ;; We can stop at an end token that is right up against the
1076 ;; margin.
1078 ;; Otherwise, skip over any nested blocks.
1081 ;; Special case: if we encounter a ", word;" then we assume that we
1082 ;; are in some kind of uses clause, and thus indent to column 0. This
1083 ;; works because no other constructs are known to have that form.
1084 ;; This fixes the irritating case of having indents after a uses
1085 ;; clause look like:
1086 ;; uses
1087 ;; someUnit,
1088 ;; someOtherUnit;
1089 ;; // this should be at column 0!
1093 ;; A previous terminator means we can stop. If we are on a directive,
1094 ;; however, then we are not actually encountering a new statement.
1098 delphi-directives)))
1101 ;; Ignore whitespace.
1104 ;; Remember any ':' we encounter, since that affects how we indent to
1105 ;; a case statement.
1108 ;; A case statement delimits a previous statement. We indent labels
1109 ;; specially.
1115 ;; If we are in a use clause then commas mark an enclosing rather than
1116 ;; a previous statement.
1121 ;; Indent to first unit in use clause.
1123 ;; Indent from use clause keyword.
1125 ;; Indent to use clause keyword.
1128 ;; Assembly sections always indent in from the asm keyword.
1132 ;; An enclosing statement delimits a previous statement.
1133 ;; We try to use the existing indent of the previous statement,
1134 ;; otherwise we calculate from the enclosing statement.
1137 ;; Otherwise indent to the last token
1139 ;; Just indent from the enclosing keyword
1142 ;; A class or record declaration also delimits a previous statement.
1145 'done
1147 ;; c = class; or c = class of T; are previous statements.
1149 ;; Otherwise c = class ... or r = record ... are enclosing
1150 ;; statements.
1153 ;; We have a definite previous statement delimiter.
1156 )
1160 ;; We ran out of tokens. Indent to column 0.
1164 ;; Returns the indentation appropriate for begin/var/const/type/label
1165 ;; tokens.
1176 ;; Always stop at unmatched ( or [.
1180 ;; Skip over any ()/[] groups.
1185 ;; We can stop at an end token that is right up against the
1186 ;; margin.
1188 ;; Otherwise, skip over any nested blocks.
1192 ;; Remember if we have encountered any forward routine declarations.
1196 ;; Mark the completion of a nested routine traversal.
1201 ;; Remember if we have encountered any statement terminators.
1204 ;; Remember if we have encountered any expression delimiters.
1208 ;; Enclosing body statements are delimiting. We indent the compound
1209 ;; bodies specially.
1215 ;; An enclosing ":" means a label.
1218 delphi-block-statements)
1225 ;; Block and mid block tokens are always enclosing
1230 ;; Declaration sections and routines are delimiters, unless they
1231 ;; are part of a nested routine.
1236 ;; Unit statements mean we indent right to the left.
1238 )
1242 ;; We ran out of tokens. Indent to column 0.
1246 ;; Returns the indentation offset from the enclosing statement of the token.
1259 ;; An open ( or [ always is an indent point.
1263 token last-token
1265 ;; Keep binary operations aligned with the open group.
1266 0
1267 delphi-indent-level))))
1269 ;; Skip over any ()/[] groups.
1272 ;; Skip over any nested blocks.
1276 ;; An expression delimiter affects indentation depending on whether
1277 ;; the point is before or after it. Remember that we encountered one.
1278 ;; Also remember the last encountered token, since if it exists it
1279 ;; should be the actual indent point.
1283 ;; With a non-delimited expression statement we indent after the
1284 ;; statement's keyword, unless we are on the delimiter itself.
1289 ;; We are indenting a delimiter. Indent to the statement.
1293 ;; Align binary ops with the expression.
1297 ;; Indent in from the expression.
1300 ;; Indent in from the statement's keyword.
1303 ;; A delimited case statement indents the label according to
1304 ;; a special rule.
1308 ;; We are not actually indenting to the case statement,
1309 ;; but are within a label expression.
1311 stmt-start delphi-indent-level)
1312 ;; Indent from the case keyword.
1314 token delphi-case-label-indent))))
1316 ;; Body expression statements are enclosing. Indent from the
1317 ;; statement's keyword, unless we have a non-block statement following
1318 ;; it.
1324 ;; An else statement is enclosing, but it doesn't have an expression.
1325 ;; Thus we take into account last-token instead of stmt-start.
1330 ;; We indent relative to an enclosing declaration section.
1333 delphi-indent-level)))
1335 ;; In unit sections we indent right to the left.
1338 ;; Handle specially the case of "interface", which can be used
1339 ;; to start either a unit section or an interface definition.
1342 ;; Find the previous non-whitespace token.
1349 delphi-whitespace))))
1350 ;; If this token is an equals sign, "interface" is being
1351 ;; used to start an interface definition and we should
1352 ;; treat it as a composite type; otherwise, we should
1353 ;; consider it the start of a unit section.
1356 delphi-indent-level)
1360 ;; A previous terminator means we can stop.
1366 ;; Align binary ops with the expression.
1370 ;; Indent in from the expression.
1373 ;; No enclosing expression; use the previous statment's
1374 ;; indent.
1377 ;; A block statement after an expression delimiter has its start
1378 ;; column as the expression statement. E.g.
1379 ;; if (a = b)
1380 ;; and (a != c) then begin
1381 ;; //...
1382 ;; end;
1383 ;; Remember it for when we encounter the expression statement start.
1390 ;; Assembly sections always indent in from the asm keyword.
1394 ;; Stop at an enclosing statement and indent from it.
1399 ;; A class/record declaration is also enclosing.
1404 ;; A ":" we indent relative to its line beginning. If we are in a
1405 ;; parameter list, then stop also if we hit a ";".
1416 ;; If the ":" was not processed above and we have token after the "=",
1417 ;; then indent from the "=". Ignore :=, however.
1420 ;; Ignore binary ops for now. It would do, for example:
1421 ;; val := 1 + 2
1422 ;; + 3;
1423 ;; which is good, but also
1424 ;; val := Foo
1425 ;; (foo, args)
1426 ;; + 2;
1427 ;; which doesn't look right.
1428 ;;;; Align binary ops with the before token.
1429 ;;((delphi-is from-kind delphi-binary-ops)
1430 ;;(throw 'done (delphi-indent-of before-equals 0)))
1432 ;; Assignments (:=) we skip over to get a normal indent.
1435 ;; Otherwise indent in from the equals.
1439 ;; Remember any "=" we encounter if it has not already been processed.
1442 before-equals last-token))
1443 )
1447 ;; We ran out of tokens. Indent to column 0.
1451 ;; Returns the corrected indentation for the current line.
1454 ;; Move to the first token on the line.
1461 ;; Indent to the matching start ( or [.
1467 ;; In a comment.
1471 ;; Use a previous section/routine's indent.
1475 ;; Use the block's indentation.
1479 ;; When trailing a body statement, indent to
1480 ;; the statement's keyword.
1484 ;; Otherwise just indent to the block start.
1488 ;; Find the start of the if or case statement.
1491 ;; Otherwise indent in from enclosing statement.
1495 indent)))
1498 "Indent the current line according to the current language construct. If
1499 before the indent, the point is moved to the indent."
1513 ;; If before the indent column, then move to it.
1515 ;; Advance our marked point after inserted spaces.
1528 ;; Ensures there exists a buffer of the specified name in the specified
1529 ;; variable.
1534 ;; Writes a message to the end of the specified buffer.
1542 ;; Debugging helpers:
1548 ;; Writes a message to the log buffer.
1562 image))
1640 "Terminate the current line with a newline and indent the next, unless
1641 `delphi-newline-always-indents' is nil, in which case no reindenting occurs."
1643 ;; Remove trailing spaces
1647 ;; Indent both the (now) previous and current line first.
1655 "Indent the region, when Transient Mark mode is enabled and the region is
1656 active. Otherwise, indent the current line or insert a TAB, depending on the
1657 value of `delphi-tab-always-indents' and the current line position."
1660 ;; If Transient Mark mode is enabled and the region is active, indent
1661 ;; the entire region.
1665 ;; Otherwise, if we are configured always to indent (regardless of the
1666 ;; point's position in the line) or we are before the first non-space
1667 ;; character on the line, indent the line.
1670 ;; Otherwise, insert a tab character.
1675 ;; True if the specified path is an existing directory.
1680 ;; True if the specified file exists as a file.
1685 ;; Searches for the unit in the specified directory. If recurse is true, then
1686 ;; the directory is recursively searched. File name comparison is done in a
1687 ;; case insensitive manner.
1692 ;; Search for the file.
1698 files)
1700 ;; Not found. Search subdirectories.
1707 files))
1709 ;; Not found.
1710 nil))))
1714 ;; Searches for the unit in the specified directory. If the directory ends
1715 ;; in \"...\", then it is recursively searched.
1718 ;; Check if we need to recursively search the directory.
1721 recurse t))
1722 ;; Ensure the trailing slash is removed.
1728 ;; Finds the specified delphi source file according to `delphi-search-path'.
1729 ;; If found, the full path is returned, otherwise nil is returned.
1741 delphi-search-path)))
1742 nil))
1745 "Finds the specified delphi source file according to `delphi-search-path'.
1746 If no extension is specified, .pas is assumed. Creates a buffer for the unit."
1749 unit
1757 file))
1760 "Find the definition of the identifier under the current point."
1765 "Find the definition of the identifier under the current point, searching
1766 in external units if necessary (as listed in the current unit's use clause).
1767 The set of directories to search for a unit is specified by the global variable
1768 delphi-search-path."
1773 "Find the body of the identifier under the current point, assuming
1774 it is a routine."
1779 "Fills the text of the current comment, according to `fill-column'.
1780 An error is raised if not in a comment."
1799 ;; // style comments need more work.
1804 ?\s)))
1806 "//"
1807 delphi-spaces-re)
1809 ;; Don't include the trailing newline.
1811 comment-end)))
1813 ;; Advance our marked point after inserted spaces.
1816 ;; Ensure we can modify the buffer
1823 ;; Strip off the comment prefixes
1831 ;; add an extra line to prevent the fill from doing it for us.
1835 ;; Fill the comment contents.
1842 ;; Restore comment prefixes.
1855 ;; Restore our position
1859 ;; React to the entire fill change as a whole.
1865 "If in a // comment, does a newline, indented such that one is still in the
1866 comment block. If not in a // comment, just does a normal newline."
1870 ;; Not in a // comment. Just do the normal newline.
1883 ;; Sets the match region used by (match-string 0) and friends to the token's
1884 ;; region. Sets the current point to the end of the token (or limit).
1890 token)))
1894 t ; Syntactic fontification doesn't apply.
1895 nil ; Don't care about case since we don't use regexps to find tokens.
1896 nil ; Syntax alists don't apply.
1897 nil ; Syntax begin movement doesn't apply
1919 ))
1920 kmap)
1929 ;; '("\C-cd" delphi-find-current-def)
1930 ;; '("\C-cx" delphi-find-current-xdef)
1931 ;; '("\C-cb" delphi-find-current-body)
1935 ;; Debug bindings:
1937 kmap)
1941 "Delphi mode's syntax table. It is just a standard syntax table.
1944 ;;;###autoload
1953 M-x indent-region also works for indenting a whole region.
1955 Customization:
1957 `delphi-indent-level' (default 3)
1958 Indentation of Delphi statements with respect to containing block.
1959 `delphi-compound-block-indent' (default 0)
1960 Extra indentation for blocks in compound statements.
1961 `delphi-case-label-indent' (default 0)
1962 Extra indentation for case statement labels.
1963 `delphi-tab-always-indents' (default t)
1964 Non-nil means TAB in Delphi mode should always reindent the current line,
1965 regardless of where in the line point is when the TAB command is used.
1966 `delphi-newline-always-indents' (default t)
1967 Non-nil means NEWLINE in Delphi mode should always reindent the current
1968 line, insert a blank line and move to the default indent column of the
1969 blank line.
1970 `delphi-search-path' (default .)
1971 Directories to search when finding external units.
1972 `delphi-verbose' (default nil)
1973 If true then delphi token processing progress is reported to the user.
1975 Coloring:
1977 `delphi-comment-face' (default font-lock-comment-face)
1978 Face used to color delphi comments.
1979 `delphi-string-face' (default font-lock-string-face)
1980 Face used to color delphi strings.
1981 `delphi-keyword-face' (default font-lock-keyword-face)
1982 Face used to color delphi keywords.
1983 `delphi-other-face' (default nil)
1984 Face used to color everything else.
1986 Turning on Delphi mode calls the value of the variable delphi-mode-hook with
1987 no args, if that value is non-nil."
1997 ;; Buffer locals:
2010 ;; We need to keep track of changes to the buffer to determine if we need
2011 ;; to retokenize changed text.
2024 ;; arch-tag: 410e192d-e9b5-4397-ad62-12340fc3fa41
2025 ;;; delphi.el ends here