;; (add-hook 'delphi-mode-hook 'turn-on-font-lock)
;; If font-lock is not loaded by default, you might have to do:
-;;
+;;
;; (autoload 'font-lock-mode "font-lock")
;; (autoload 'turn-on-font-lock "font-lock")
;; (setq font-lock-support-mode 'lazy-lock-mode)
(provide 'delphi)
(defconst delphi-version
- (let ((revision "$Revision: 3.7 $"))
+ (let ((revision "$Revision: 3.8 $"))
(string-match ": \\([^ ]+\\)" revision)
(match-string 1 revision))
"Version of this delphi mode.")
(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
+ overload override pascal private protected public published read readonly
register reintroduce resident resourcestring safecall stdcall stored
virtual write writeonly)
"Delphi4 directives.")
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
+ 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
+ raise record repeat requires result self set shl shr then threadvar
to try type unit uses until var while with xor
;; These routines should be keywords, if Borland had the balls.
(defconst delphi-visibilities '(public private protected published automated)
"Class visibilities.")
-(defconst delphi-block-statements
+(defconst delphi-block-statements
'(begin try case repeat initialization finalization asm)
"Statements that contain multiple substatements.")
;; We have an end only if there is some string content (at
;; least a starting delimiter).
(not (delphi-is-literal-end (1- p)))))
-
+
;; Special case: strings cannot span lines.
(and (delphi-is kind delphi-strings) (eq ?\n (char-after (1- p)))))))
;; We are completing an incomplete literal.
(let ((kind (delphi-literal-kind (1- search-start))))
(delphi-complete-literal kind limit)
- (delphi-set-text-properties
+ (delphi-set-text-properties
search-start (point) (delphi-literal-text-properties kind))))
((re-search-forward
(start (match-beginning 0)))
(delphi-set-text-properties search-start start nil)
(delphi-complete-literal kind limit)
- (delphi-set-text-properties
+ (delphi-set-text-properties
start (point) (delphi-literal-text-properties kind))))
;; Nothing found. Mark it as a non-literal.
(while (< p to)
;; Color the token and move past it.
(setq token (delphi-token-at p))
- (add-text-properties
+ (add-text-properties
(delphi-token-start token) (delphi-token-end token)
(list 'face (delphi-face-of (delphi-token-kind token)) 'lazy-lock t))
(setq p (delphi-token-end token))
(delphi-progress-start)
;; Reparse at least from the token previous to the change to the end of
;; line after the change.
- (delphi-parse-region-until-stable
+ (delphi-parse-region-until-stable
(delphi-token-start (delphi-token-at (1- change-start)))
(progn (goto-char change-end) (end-of-line) (point)))
(delphi-progress-done)))))
(catch 'done
(while token
(setq kind (delphi-token-kind token))
- (cond
+ (cond
;; Skip over ()/[] groups.
((eq 'close-group kind) (setq token (delphi-group-start token)))
(catch 'done
(while token
(setq kind (delphi-token-kind token))
- (cond
+ (cond
((and (eq 'colon kind)
(delphi-is (delphi-token-kind last-token)
- `(,@delphi-block-statements
+ `(,@delphi-block-statements
,@delphi-expr-statements)))
;; We hit a label followed by a statement. Indent to the statement.
(throw 'done nil))
((delphi-composite-type-start token last-token)
(throw 'done (if stop-on-class last-token token)))
)
- (unless (delphi-is token-kind delphi-whitespace)
+ (unless (delphi-is token-kind delphi-whitespace)
(setq last-token token))
(setq token (delphi-previous-token token)))
;; Start not found.
(defun delphi-is-use-clause-end (at-token last-token last-colon from-kind)
;; True if we are after the end of a uses type clause.
- (when (and last-token
+ (when (and last-token
(not last-colon)
(eq 'comma (delphi-token-kind at-token))
(eq 'semicolon from-kind))
(delphi-line-indent-of token))))
;; Assembly sections always indent in from the asm keyword.
- ((eq token-kind 'asm)
+ ((eq token-kind 'asm)
(throw 'done (delphi-stmt-line-indent-of token delphi-indent-level)))
;; An enclosing statement delimits a previous statement.
;; An enclosing ":" means a label.
((and (eq 'colon token-kind)
- (delphi-is (delphi-token-kind section-token)
+ (delphi-is (delphi-token-kind section-token)
delphi-block-statements)
(not last-terminator)
(not expr-delimited)
(from-kind (delphi-token-kind from-token))
(token-kind nil)
(stmt-start nil)
- (last-token nil)
+ (last-token nil)
(equals-encountered nil)
(before-equals nil)
(expr-delimited nil))
(if stmt-start
;; We are not actually indenting to the case statement,
;; but are within a label expression.
- (delphi-stmt-line-indent-of
+ (delphi-stmt-line-indent-of
stmt-start delphi-indent-level)
;; Indent from the case keyword.
- (delphi-stmt-line-indent-of
+ (delphi-stmt-line-indent-of
token delphi-case-label-indent))))
;; Body expression statements are enclosing. Indent from the
;; it.
((delphi-is token-kind delphi-body-expr-statements)
(throw 'done
- (delphi-stmt-line-indent-of
+ (delphi-stmt-line-indent-of
(or stmt-start token) delphi-indent-level)))
;; An else statement is enclosing, but it doesn't have an expression.
((+ (delphi-section-indent-of token) delphi-indent-level)))))
;; Assembly sections always indent in from the asm keyword.
- ((eq token-kind 'asm)
+ ((eq token-kind 'asm)
(throw 'done (delphi-stmt-line-indent-of token delphi-indent-level)))
;; Stop at an enclosing statement and indent from it.
;; + 2;
;; which doesn't look right.
;;;; Align binary ops with the before token.
- ;;((delphi-is from-kind delphi-binary-ops)
+ ;;((delphi-is from-kind delphi-binary-ops)
;;(throw 'done (delphi-indent-of before-equals 0)))
;; Assignments (:=) we skip over to get a normal indent.
((eq (delphi-token-kind last-token) 'equals))
;; Otherwise indent in from the equals.
- ((throw 'done
+ ((throw 'done
(delphi-indent-of before-equals delphi-indent-level)))))
;; Remember any "=" we encounter if it has not already been processed.
- ((eq token-kind 'equals)
+ ((eq token-kind 'equals)
(setq equals-encountered token
before-equals last-token))
)
((delphi-is token-kind delphi-match-block-statements)
;; Use the block's indentation.
- (let ((block-start
+ (let ((block-start
(delphi-block-start token 'stop-on-class)))
(cond
;; When trailing a body statement, indent to
HCoop / bpt / emacs.git / blobdiff