xenocara/app/xedit/lisp/modules/progmodes/c.lsp

;;
;; Copyright (c) 2002 by The XFree86 Project, Inc.
;;
;; Permission is hereby granted, free of charge, to any person obtaining a
;; copy of this software and associated documentation files (the "Software"),
;; to deal in the Software without restriction, including without limitation
;; the rights to use, copy, modify, merge, publish, distribute, sublicense,
;; and/or sell copies of the Software, and to permit persons to whom the
;; Software is furnished to do so, subject to the following conditions:
;;
;; The above copyright notice and this permission notice shall be included in
;; all copies or substantial portions of the Software.
;;
;; THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
;; IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
;; FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
;; THE XFREE86 PROJECT BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
;; WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF
;; OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
;; SOFTWARE.
;;
;; Except as contained in this notice, the name of the XFree86 Project shall
;; not be used in advertising or otherwise to promote the sale, use or other
;; dealings in this Software without prior written authorization from the
;; XFree86 Project.
;;
;; Author: Paulo César Pereira de Andrade
;;
;;
;; $XFree86: xc/programs/xedit/lisp/modules/progmodes/c.lsp,v 1.27 2004/01/12 17:53:20 paulo Exp $
;;

(require "syntax")
(require "indent")
(in-package "XEDIT")

(defsynprop *prop-format*
    "format"
    :font	"*lucidatypewriter-medium-r*-12-*"
    :foreground	"RoyalBlue2"
    :underline	t
)

(defsynoptions *c-DEFAULT-style*
    ;; Positive number. Basic indentation.
    (:indentation		.	4)

    ;; Boolean. Support for GNU style indentation.
    (:brace-indent		.	nil)

    ;; Boolean. Add one indentation level to case and default?
    (:case-indent		.	t)

    ;; Boolean. Remove one indentation level for labels?
    (:label-dedent		.	t)

    ;; Boolean. Add one indentation level to continuations?
    (:cont-indent		.	t)

    ;; Boolean. Move cursor to the indent column after pressing <Enter>?
    (:newline-indent		.	t)

    ;; Boolean. Set to T if tabs shouldn't be used to fill indentation.
    (:emulate-tabs		.	nil)

    ;; Boolean. Force a newline before braces?
    (:newline-before-brace	.	nil)

    ;; Boolean. Force a newline after braces?
    (:newline-after-brace	.	nil)

    ;; Boolean. Force a newline after semicolons?
    (:newline-after-semi	.	nil)

    ;; Boolean. Only calculate indentation after pressing <Enter>?
    ;;		This may be useful if the parser does not always
    ;;		do what the user expects...
    (:only-newline-indent	.	nil)

    ;; Boolean. Remove extra spaces from previous line.
    ;;		This should default to T when newline-indent is not NIL.
    (:trim-blank-lines		.	t)

    ;; Boolean. If this hash-table entry is set, no indentation is done.
    ;;		Useful to temporarily disable indentation.
    (:disable-indent		.	nil)
)

;; BSD like style
(defsynoptions *c-BSD-style*
    (:indentation		.	8)
    (:brace-indent		.	nil)
    (:case-indent		.	nil)
    (:label-dedent		.	t)
    (:cont-indent		.	t)
    (:newline-indent		.	t)
    (:emulate-tabs		.	nil)
    (:newline-before-brace	.	nil)
    (:newline-after-brace	.	t)
    (:newline-after-semi	.	t)
    (:trim-blank-lines		.	t)
)

;; GNU like style
(defsynoptions *c-GNU-style*
    (:indentation		.	2)
    (:brace-indent		.	t)
    (:case-indent		.	nil)
    (:label-dedent		.	t)
    (:cont-indent		.	t)
    (:newline-indent		.	nil)
    (:emulate-tabs		.	nil)
    (:newline-before-brace	.	t)
    (:newline-after-brace	.	t)
    (:newline-after-semi	.	t)
    (:trim-blank-lines		.	nil)
)

;; K&R like style
(defsynoptions *c-K&R-style*
    (:indentation		.	5)
    (:brace-indent		.	nil)
    (:case-indent		.	nil)
    (:label-dedent		.	t)
    (:cont-indent		.	t)
    (:newline-indent		.	t)
    (:emulate-tabs		.	t)
    (:newline-before-brace	.	t)
    (:newline-after-brace	.	t)
    (:newline-after-semi	.	t)
    (:trim-blank-lines		.	t)
)

(defvar *c-styles* '(
    ("xedit"	.	*c-DEFAULT-style*)
    ("BSD"	.	*c-BSD-style*)
    ("GNU"	.	*c-GNU-style*)
    ("K&R"	.	*c-K&R-style*)
))

(defvar *c-mode-options* *c-DEFAULT-style*)
; (setq *c-mode-options* *c-gnu-style*)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; This is a very lazy "pattern matcher" for the C language.
;; If the syntax in the code is not correct, it may get confused, and
;; because it is "lazy" some wrong constructs will be recognized as
;; correct when reducing patterns.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defindent *c-mode-indent* :main
    ;; this must be the first token
    (indtoken "^\\s*"		:start-of-line)
    (indtoken "\\<case\\>"	:c-case)
    (indtoken "\\<default\\>"	:c-default)
    (indtoken "\\<do\\>"	:do)
    (indtoken "\\<if\\>"	:c-if)
    (indtoken "\\<else\\>"	:c-else)
    (indtoken "\\<for\\>"	:c-for)
    (indtoken "\\<switch\\>"	:c-switch)
    (indtoken "\\<while\\>"	:c-while)
    ;; Match identifiers and numbers as an expression
    (indtoken "\\w+"		:expression)
    (indtoken ";"		:semi		:nospec t)
    (indtoken ","		:comma		:nospec t)
    (indtoken ":"		:collon		:nospec t)
    ;;  Ignore spaces before collon, this avoids dedenting ternary
    ;; and bitfield definitions as the parser does not distinguish
    ;; labels from those, another option would be to use the pattern
    ;; "\\w+:", but this way should properly handle labels generated
    ;; by macros, example: `MACRO_LABEL(value):'
    (indtoken "\\s+:"		nil)

    (indinit			(c-braces 0))
    (indtoken "{"
	:obrace
	:nospec t
	:code	(decf c-braces)
    )
    (indtoken "}"
	:cbrace
	:nospec t
	:begin	:braces
	:code	(incf c-braces)
    )
    (indtable :braces
	(indtoken "{"
	    :obrace
	    :nospec t
	    :switch -1
	    :code   (decf c-braces)
	)
	(indtoken "}"
	    :cbrace
	    :nospec t
	    :begin  :braces
	    :code   (incf c-braces)
	)
    )

    (indinit			(c-bra 0))
    (indtoken ")"		:cparen		:nospec t :code (incf c-bra))
    (indtoken "("		:oparen		:nospec t :code (decf c-bra))
    (indtoken "]"		:cbrack		:nospec t :code (incf c-bra))
    (indtoken "["		:obrack		:nospec t :code (decf c-bra))
    (indtoken "\\\\$"		:continuation)

    ;; C++ style comment, disallow other tokens to match inside comment
    (indtoken "//.*$"		nil)

    (indtoken "#"		:hash		:nospec t)

    ;; if in the same line, reduce now, this must be done because the
    ;; delimiters are identical
    (indtoken "'([^\\']|\\\\.)*'"	:expression)
    (indtoken "\"([^\\\"]|\\\\.)*\""	:expression)

    (indtoken "\""		:cstring	:nospec t	:begin :string)

    (indtoken "'"		:cconstant	:nospec t	:begin :constant)

    (indtoken "*/"		:ccomment	:nospec t	:begin :comment)
    ;; this must be the last token
    (indtoken "$"		:end-of-line)

    (indtable :string
	;; Ignore escaped characters
	(indtoken "\\." 	nil)
	;; Return to the toplevel when the start of the string is found
	(indtoken "\""		:ostring	:nospec t	:switch -1)
    )
    (indtable :constant
	;; Ignore escaped characters
	(indtoken "\\." 	nil)
	;; Return to the toplevel when the start of the character is found
	(indtoken "'"		:oconstant	:nospec t	:switch -1)
    )
    (indtable :comment
	(indtoken "/*"		:ocomment	:nospec t	:switch -1)
    )

    ;; "Complex" statements
    (indinit		(c-complex 0) (c-cases 0))

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Order of reduce rules here is important, process comment,
    ;; continuations, preprocessor and set states when an eol is found.
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

    (indinit	(c-offset (point-max))
		(c-prev-offset c-offset)
    )
    (indreduce :indent
	t
	((:start-of-line))
	(and (= *ind-start* *ind-offset*)
	    (setq
		*offset* (+ *ind-offset* *ind-length*)
	    )
	)
	(setq
	    c-prev-offset   c-offset
	    c-offset	    *ind-offset*
	)
    )

    ;; Delete comments
    (indreduce nil
	t
	((:ocomment nil :ccomment))
    )

    ;; Join in a single token to simplify removal of possible multiline
    ;; preprocessor directives
    (indinit			c-continuation)
    (indreduce :continuation
	t
	((:continuation :end-of-line))
	(setq c-continuation t)
    )

    (indreduce :eol
	t
	((:end-of-line))
	;; Anything after the eol offset is safe to parse now
	(setq c-continuation nil)
    )

    ;; Delete blank lines
    (indreduce nil
	t
	((:indent :eol))
    )

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Preprocessor
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indreduce nil
	(>= *ind-offset* *ind-start*)
	((:indent :hash))
	(setq *indent* 0)
	(indent-macro-reject-left)
    )
    (indreduce nil
	t
	((:indent :hash nil :eol))
    )

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Expressions
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indreduce :expression
	t
	;; Reduce to a single expression
	((:expression :parens)
	 (:expression :bracks)
	 (:expression :expression)
	;; These may be multiline
	 (:ostring (not :ostring) :cstring)
	 (:oconstant (not :oconstant) :cconstant)
	)
    )

    (indreduce :expression
	t
	((:expression :eol :indent :expression)
	 (:expression :eol :expression)
	)
    )

    (indreduce :exp-comma
	t
	((:expression :comma)
	)
    )

    ;; A semicollon, start a statement
    (indreduce :stat
	t
	((:semi))
    )

    ;; Expression following (possibly empty) statement
    (indreduce :stat
	t
	(((or :expression :exp-comma) :stat))
    )

    ;; Multiline statements
    (indreduce :stat
	t
	(((or :expression :exp-comma) :eol :indent :stat)
	 ;; rule below may have removed the :indent
	 ((or :expression :exp-comma) :eol :stat)
	)
    )

    (indinit	c-exp-indent)
    ;; XXX This rule avoids parsing large amounts of code
    (indreduce :stat
	t
	;; Eat eol if following expression
	((:indent :stat :eol)
	 (:indent :stat)
	)
	(if
	    (or
		(null c-exp-indent)
		(/= (cdar c-exp-indent) (+ *ind-offset* *ind-length*))
	    )
	    ;; A new statement, i.e. not just joining a multiline one
	    (push
		(cons
		    (offset-indentation *ind-offset* :resolve t)
		    (+ *ind-offset* *ind-length*)
		)
		c-exp-indent
	    )
	    ;; Update start of statement
	    (rplaca
		(car c-exp-indent)
		(offset-indentation *ind-offset* :resolve t)
	    )
	)
	(when (consp (cdr c-exp-indent))
	    (if (and
		    (zerop c-complex)
		    (zerop c-cases)
		    (zerop c-bra)
		    (= (caar c-exp-indent) (caadr c-exp-indent))
		)
		;; Two statements with the same indentation
		(progn
		    (setq *indent* (caar c-exp-indent))
		    (indent-macro-reject-left)
		)
		;; Different indentation or complex state
		(progn
		    (rplacd c-exp-indent nil)
		    (setq c-complex 0)
		)
	    )
	)
    )

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Handle braces
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indreduce :stat
	;; If block finishes before current line, group as a statement
	(< (+ *ind-offset* *ind-length*) *ind-start*)
	((:obrace (not :obrace) :cbrace))
    )
    (indreduce :obrace
	;; If not in the first line
	(< *ind-offset* *ind-start*)
	;; If the opening { is the first non blank char in the line
	((:indent :obrace))
	(setq *indent* (offset-indentation (+ *ind-offset* *ind-length*)))

	;; XXX This may be the starting brace of a switch
	(setq c-case-flag nil)
	(indent-macro-reject-left)
    )

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Labels
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; XXX this frequently doesn't do what is expected, should redefine
    ;; some rules, as it frequently will dedent while typing something
    ;; like  test ? exp1 : exp2
    ;;                   ^ dedents here because it reduces everything
    ;;			   before ':' to a single :expression token.
    (indreduce :label
	t
	((:indent :expression :collon :eol))
	(when (and *label-dedent* (>= *ind-offset* *ind-start*))
	    (setq
		*indent*
		(- (offset-indentation *ind-offset* :resolve t) *base-indent*)
	    )
	    (indent-macro-reject-left)
	)
    )

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Handle if
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indreduce :if
	t
	((:c-if :parens)
	)
	(incf c-complex)
    )

    (indreduce :else
	t
	((:c-else))
	(incf c-complex)
    )

    ;; Join
    (indreduce :else-if
	t
	((:else :if)
	 (:else :eol :indent :if)
	)
	(incf c-complex)
    )

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Handle for
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Join with the parentheses
    (indreduce :for
	t
	((:c-for :parens)
	)
	(incf c-complex)
    )
    ;; Before current line, simplify
    (indreduce :stat
	(< (+ *ind-offset* *ind-length*) *ind-point*)
	((:for :stat)
	)
    )

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Handle while and do
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indreduce :while
	t
	((:c-while :parens)
	)
	(incf c-complex)
    )
    (indreduce :stat
	t
	((:do :stat :while)
	 (:while :stat)
	)
    )

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Handle switch
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indinit			c-case-flag)

    (indreduce :switch
	t
	((:c-switch :parens)
	)
    )
    ;; Transform in a statement
    (indreduce :stat
	(< (+ *ind-offset* *ind-length*) *ind-start*)
	((:switch :stat)
	 ;; Do it now or some rule may stop parsing, and calculate
	 ;; a wrong indentation for nested switches
	 (:switch :eol :indent :stat)
	)
    )
    ;; An open switch
    (indreduce :obrace
	(and
	    (<= c-braces 0)
	    (> *ind-start* *ind-offset*)
	)
	((:indent :switch :obrace)
	)
	(setq
	    *indent* (offset-indentation *ind-offset* :resolve t)
	    c-case-flag nil
	)
	(indent-macro-reject-left)
    )
    (indreduce :obrace
	(and
	    (<= c-braces 0)
	    (> *ind-start* *ind-offset*)
	)
	((:indent :switch :eol :indent :obrace)
	)
	(setq
	    *indent* (- (offset-indentation *ind-offset* :resolve t) *base-indent*)
	    c-case-flag nil
	)
	(and *brace-indent* (incf *indent* *base-indent*))
	(indent-macro-reject-left)
    )
    ;; Before current line
    (indreduce :case
	(and
	    (or
		(not *case-indent*)
		(prog1 c-case-flag (setq c-case-flag t))
	    )
	    (<= c-braces 0)
	    (< *ind-offset* *ind-start*)
	)
	((:indent :case)
	)
	(setq
	    *indent* (offset-indentation *ind-offset* :resolve t)
	    c-case-flag nil
	)
	(indent-macro-reject-left)
    )
    (indreduce :case
	t
	((:c-case :expression :collon)
	 (:c-default :collon)
	 ;; Assume that it is yet being edited, or adjusting indentation
	 (:c-case)
	 (:c-default)
	)
	(and (>= *ind-offset* *ind-start*)
	    (incf c-cases)
	)
    )

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Handle parentheses and brackets
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Reduce matches
    (indreduce :parens
	t
	((:oparen (not :oparen) :cparen))
	(when
	    (and
		(< *ind-offset* *ind-start*)
		(> (+ *ind-offset* *ind-length*) *ind-start*)
	    )
	    (setq *indent* (1+ (offset-indentation *ind-offset* :align t)))
	    (indent-macro-reject-left)
	)
    )
    (indreduce :bracks
	t
	((:obrack (not :obrack) :cbrack))
	(when
	    (and
		(< *ind-offset* *ind-start*)
		(> (+ *ind-offset* *ind-length*) *ind-start*)
	    )
	    (setq *indent* (1+ (offset-indentation *ind-offset* :align t)))
	    (indent-macro-reject-left)
	)
    )

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Assuming previous lines have correct indentation, this allows
    ;; resolving the indentation fastly
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Line ended with an open brace
    (indreduce :obrace
	(< *ind-offset* *ind-start*)
	((:indent (or :for :while :if :else-if :else :do) :obrace)
	)
	(setq *indent* (offset-indentation *ind-offset* :resolve t))
	(indent-macro-reject-left)
    )
    ;; Adjust indentation level if current line starts with an open brace
    (indreduce nil
	(< *ind-offset* *ind-start* (+ *ind-offset* *ind-length*))
	 ;; Just set initial indentation
	((:indent (or :for :while :if :else-if :else :do) :eol :indent :obrace)
	)
	(setq
	    *indent*
	    (- (offset-indentation *ind-offset* :resolve t) *base-indent*)
	)
	(and *brace-indent* (incf *indent* *base-indent*))
	(indent-macro-reject-left)
    )
    ;; Previous rule failed, current line does not start with an open brace
    (indreduce :flow
	;; first statement is in current line
	(and
	    (<= c-braces 0)
	    (> (+ *ind-offset* *ind-length*) *ind-start* *ind-offset*)
	)
	((:indent (or :for :while :if :else-if :else :do) :eol :indent)
	)
	(setq *indent* (offset-indentation *ind-offset* :resolve t))
	(indent-macro-reject-left)
    )

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Simplify, remove old (:eol :indent)
    ;; This must be the last rule, to avoid not matching the
    ;; rules for fast calculation of indentation above
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indreduce nil
	(> *ind-offset* c-prev-offset)
	((:eol :indent))
    )


    (indinit			(c-flow 0))

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; If
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indinit			c-if-flow)
    (indresolve :if
	(and (< *ind-offset* *ind-start*)
	    (push c-flow c-if-flow)
	    (incf *indent* *base-indent*)
	    (incf c-flow)
	)
    )
    (indresolve (:else-if :else)
	(when c-if-flow
	    (while (< c-flow (car c-if-flow))
		(incf *indent* *base-indent*)
		(incf c-flow)
	    )
	    (or (eq *ind-token* :else-if) (pop c-if-flow))
	)
	(and (< *ind-offset* *ind-start*)
	    (incf *indent* *base-indent*)
	    (incf c-flow)
	)
    )


    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; For/while/do
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indinit			c-do-flow)
    (indresolve (:for :while :do)
	(if (eq *ind-token* :do)
	    (and (< *ind-offset* *ind-start*) (push c-flow c-do-flow))
	    (when (and c-do-flow (eq *ind-token* :while))
		(while (< c-flow (car c-do-flow))
		    (incf *indent* *base-indent*)
		    (incf c-flow)
		)
		(pop c-do-flow)
	    )
	)
	(and (< *ind-offset* *ind-start*)
	    (incf *indent* *base-indent*)
	    (incf c-flow)
	)
    )


    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Switch
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indresolve :switch
	(setq c-case-flag nil)
    )
    (indresolve (:case :c-case)
	(if (< *ind-offset* *ind-start*)
	    (or c-case-flag
		(setq
		    *indent*
		    (+ (offset-indentation *ind-offset* :resolve t)
			*base-indent*
		    )
		)
	    )
	    (if c-case-flag
		(and (= (decf c-cases) 0)
		    (decf *indent* *base-indent*)
		)
		(or *case-indent*
		    (decf *indent* *base-indent*)
		)
	    )
	)
	(setq c-case-flag t)
    )


    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Braces/flow control
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indresolve :flow
	(incf *indent* *base-indent*)
    )
    (indresolve :obrace
	(and (< *ind-offset* *ind-start*)
	    (incf *indent* *base-indent*)
	)
    )
    (indresolve :cbrace
	(decf *indent* *base-indent*)
	(and *case-indent* c-case-flag
	    (decf *indent* *base-indent*)
	    (setq c-case-flag nil)
	)
	(and (not *offset*) (>= *ind-offset* *ind-start*)
	    (setq *offset* *ind-offset*)
	)
    )


    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Statements
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indresolve :stat
	(when (< *ind-offset* *ind-start*)
	    (while (> c-flow 0)
		(setq
		    *indent*	(- *indent* *base-indent*)
		    c-flow	(1- c-flow)
		)
	    )
	)
	(and
	    *cont-indent*
	    (< *ind-offset* *ind-start*)
	    (> (+ *ind-offset* *ind-length*) *ind-start*)
	    (incf *indent* *base-indent*)
	)
    )

    (indresolve :expression
	(and
	    *cont-indent*
	    (zerop c-bra)
	    (> *indent* 0)
	    (< *ind-offset* *ind-start*)
	    (> (+ *ind-offset* *ind-length*) *ind-start*)
	    (incf *indent* *base-indent*)
	)
    )

    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    ;; Open
    ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
    (indresolve (:oparen :obrack)
	(and (< *ind-offset* *ind-start*)
	    (setq *indent* (1+ (offset-indentation *ind-offset* :align t)))
	)
    )
)

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;; Find a "good" offset to start parsing backwards, so that it should
;; always generate the same results.
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
(defun c-offset-indent (&aux char (point (point)))
    ;; Skip spaces forward
    (while (member (setq char (char-after point)) indent-spaces)
	(incf point)
    )
    (or (characterp char) (return-from c-offset-indent point))

    ;;	Skip word chars
    (when (alphanumericp char)
	(while (and (setq char (char-after point)) (alphanumericp char))
	    (incf point)
	)
	(or (characterp char) (return-from c-offset-indent point))

	;; Skip spaces forward
	(while (member (setq char (char-after point)) indent-spaces)
	    (incf point)
	)
	(or (characterp char) (return-from c-offset-indent point))
    )

    ;; don't include " or ' to avoid parsing strings "inverted"
    (if (member char '(#\Newline #\" #\')) point (1+ point))
)
(compile 'c-offset-indent)

(defun c-should-indent (options)
    (when (hash-table-p options)
	;; check if previous line has extra spaces
	(and (gethash :trim-blank-lines options)
	    (indent-clear-empty-line)
	)

	;; indentation disabled?
	(and (gethash :disable-indent options)
	    (return-from c-should-indent)
	)

	(let*
	    (
	    (point (point))
	    (start (scan point :eol :left))
	    (char (char-before point))
	    offset
	    match
	    text
	    )

	    ;; at the start of an empty file
	    (or (characterp char)
		(return-from c-should-indent)
	    )

	    ;; if at bol and should indent only when starting a line
	    (and (gethash :only-newline-indent options)
		(return-from c-should-indent (= point start))
	    )

	    (and
		(char= char #\;)
		(gethash :newline-after-semi options)
		(return-from c-should-indent t)
	    )

	    ;; if one of these was typed, must check indentation
	    (and (member char '(#\{ #\} #\: #\] #\) #\#))
		(return-from c-should-indent t)
	    )

	    ;; at the start of a line
	    (and (= point start)
		(return-from c-should-indent (gethash :newline-indent options))
	    )

	    ;; if first character
	    (and (= point (1+ start))
		(return-from c-should-indent t)
	    )

	    ;; check if is the first non-blank character in a new line
	    (when
		(and
		    (gethash :cont-indent options)
		    (= point (scan point :eol :right))
		    (alphanumericp char)
		)
		(setq offset (1- point))
		(while
		    (and
			(> offset start)
			(member (char-before offset) indent-spaces)
		    )
		    (decf offset)
		)
		;; line has only one character with possible spaces before it
		(and (<= offset start)
		    (return-from c-should-indent t)
		)
	    )

	    ;; check for keywords that change indentation
	    (when (alphanumericp char)
		(setq offset (1- point))
		(while
		    (and
			(alphanumericp (char-before offset))
			(> offset start)
		    )
		    (decf offset)
		)
		(setq
		    text	(read-text offset (- point offset))
		    match	(re-exec #.(re-comp "(case|else|while)\\w?\\>")
				    text)
		)
		(and
		    (consp match)
		    (return-from c-should-indent (<= (- (caar match) offset) 2))
		)
	    )
	)
    )
    ;; Should not indent
    nil
)
(compile 'c-should-indent)


(defun c-indent-check (syntax syntable options
		       &aux start point char left brace change)
    (setq
	point	(point)
	char	(char-before point)
	left	point
	brace	(member char '(#\{ #\}))
    )

    (when
	(and brace (gethash :newline-before-brace options))
	(setq start (scan point :eol :left))
	(while
	    (and
		(> (decf left) start)
		(member (char-before left) indent-spaces)
	    )
	    ;; skip blanks
	)
	(when (> left start)
	    (replace-text left left (string #\Newline))
	    (c-indent syntax syntable)
	    (setq change t)
	)
    )

    (when
	(or
	    (and brace (not change) (gethash :newline-after-brace options))
	    (and (char= char #\;) (gethash :newline-after-semi options))
	)
	(setq left (point))
	(replace-text left left (string #\Newline))
	(goto-char (1+ left))
	(c-indent syntax syntable)
    )
)

(defun c-indent (syntax syntable)
    (let*
	(
	(options (syntax-options syntax))
	*base-indent*
	*brace-indent*
	*case-indent*
	*label-dedent*
	*cont-indent*
	)

	(or (c-should-indent options) (return-from c-indent))

	(setq
	    *base-indent*	(gethash :indentation options 4)
	    *brace-indent*	(gethash :brace-indent options nil)
	    *case-indent*	(gethash :case-indent options t)
	    *label-dedent*	(gethash :label-dedent options t)
	    *cont-indent*	(gethash :cont-indent options t)
	)

	(indent-macro
	    *c-mode-indent*
	    (c-offset-indent)
	    (gethash :emulate-tabs options)
	)

	(c-indent-check syntax syntable options)
    )
)
(compile 'c-indent)

(defsyntax *c-mode* :main nil #'c-indent *c-mode-options*
    ;;  All recognized C keywords.
    (syntoken
	(string-concat
	    "\\<("
	    "asm|auto|break|case|catch|char|class|const|continue|default|"
	    "delete|do|double|else|enum|extern|float|for|friend|goto|if|"
	    "inline|int|long|new|operator|private|protected|public|register|"
	    "return|short|signed|sizeof|static|struct|switch|template|this|"
	    "throw|try|typedef|union|unsigned|virtual|void|volatile|while"
	    ")\\>")
	:property *prop-keyword*)

    ;; Numbers, this is optional, comment this rule if xedit is
    ;; too slow to load c files.
    (syntoken
	(string-concat
	    "\\<("
	    ;; Integers
	    "(\\d+|0x\\x+)(u|ul|ull|l|ll|lu|llu)?|"
	    ;; Floats
	    "\\d+\\.?\\d*(e[+-]?\\d+)?[lf]?"
	    ")\\>")
	:icase t
	:property *prop-number*
    )

    ;; String start rule.
    (syntoken "\"" :nospec t :begin :string :contained t)

    ;; Character start rule.
    (syntoken "'" :nospec t :begin :character :contained t)

    ;; Preprocessor start rule.
    (syntoken "^\\s*#\\s*\\w+" :begin :preprocessor :contained t)

    ;; Comment start rule.
    (syntoken "/*" :nospec t :begin :comment :contained t)

    ;; C++ style comments.
    (syntoken "//.*" :property *prop-comment*)

    ;; Punctuation, this is also optional, comment this rule if xedit is
    ;; too slow to load c files.
    (syntoken "[][(){}/*+:;=<>,&.!%|^~?-][][(){}*+:;=<>,&.!%|^~?-]?"
	:property *prop-punctuation*)


    ;; Rules for comments.
    (syntable :comment *prop-comment* #'default-indent
	;; Match nested comments as an error.
	(syntoken "/*" :nospec t :property *prop-error*)

	(syntoken "XXX|TODO|FIXME" :property *prop-annotation*)

	;;  Rule to finish a comment.
	(syntoken "*/" :nospec t :switch -1)
    )

    ;; Rules for strings.
    (syntable :string *prop-string* #'default-indent
	;; Ignore escaped characters, this includes \".
	(syntoken "\\\\.")

	;; Match, most, printf arguments.
	(syntoken "%%|%([+-]?\\d+)?(l?[deEfgiouxX]|[cdeEfgiopsuxX])"
	    :property *prop-format*)

	;; Ignore continuation in the next line.
	(syntoken "\\\\$")

	;; Rule to finish a string.
	(syntoken "\"" :nospec t :switch -1)

	;; Don't allow strings continuing in the next line.
	(syntoken ".?$" :begin :error)
    )

    ;; Rules for characters.
    (syntable :character *prop-constant* nil
	;; Ignore escaped characters, this includes \'.
	(syntoken "\\\\.")

	;; Ignore continuation in the next line.
	(syntoken "\\\\$")

	;; Rule to finish a character constant.
	(syntoken "'" :nospec t :switch -1)

	;; Don't allow constants continuing in the next line.
	(syntoken ".?$" :begin :error)
    )

    ;;  Rules for preprocessor.
    (syntable :preprocessor *prop-preprocessor* #'default-indent
	;;  Preprocessor includes comments.
	(syntoken "/*" :nospec t :begin :comment :contained t)

	;;  Ignore strings and constants in the same line and finishes table
	;; This is kind hackish, but must be done because the current parser
	;; will not flag eol. Maybe it could be extended to properly handle
	;; and have an internal flag to tell it to pass again if there
	;; is a regex that can match eol on an empty string.
	;;  A test is already done (but at compile time) to not allow patterns
	;; that match an empty string (but allow patterns matching
	;; bol, eol or both on an empty string).
	(syntoken "\"([^\\\"]|\\\\.)*\"$" :property *prop-string* :switch -1)
	(syntoken "'([^']|\\\\.)*'$" :property *prop-constant* :switch -1)

	;;  Ignore strings and constants in the same line
	(syntoken "\"([^\\\"]|\\\\.)*\"" :property *prop-string*)
	(syntoken "'([^']|\\\\.)*'" :property *prop-constant*)

	;;  Ignore lines finishing with a backslash.
	(syntoken "\\\\$")

	;; multiline strings
	(syntoken "\"" :nospec t :begin :string)

	;; multiline constants
	(syntoken "'" :nospec t :begin :character)

	;;  C++ style comments
	(syntoken "//.*$" :property *prop-comment* :switch -1)

	;; Return to previous state if end of line found.
	(syntoken ".?$" :switch -1)
    )

    (syntable :error *prop-error* nil
	(syntoken "^.*$" :switch -2)
    )

    ;;  You may also want to comment this rule if the parsing is
    ;; noticeably slow.
    (syntoken "\\c" :property *prop-control*)
)