Mercurial > emacs

--- a/lisp/progmodes/antlr-mode.el	Fri Dec 21 23:55:01 2001 +0000
+++ b/lisp/progmodes/antlr-mode.el	Fri Dec 21 23:55:39 2001 +0000
@@ -1,10 +1,10 @@
 ;;; antlr-mode.el --- major mode for ANTLR grammar files

-;; Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+;; Copyright (C) 1999-2001 Free Software Foundation, Inc.
 ;;
 ;; Author: Christoph.Wedler@sap.com
 ;; Keywords: languages
-;; Version: 1.4
+;; Version: 2.1
 ;; X-URL: http://www.fmi.uni-passau.de/~wedler/antlr-mode/

 ;; This file is part of GNU Emacs.
@@ -26,54 +26,80 @@

 ;;; Commentary:

-;; Major mode for editing ANTLR grammar files, i.e., files ending with `.g'.
-;; ANTLR is ANother Tool for Language Recognition (an excellent alternative to
-;; lex/yacc), see <http://www.ANTLR.org> and <news:comp.compilers.tools.pccts>.
+;; This Emacs extension (major mode) provides various features for editing
+;; ANTLR grammar files.  ANTLR is a tool for LL(k)-based language recognition
+;; and an excellent alternative to lex & yacc, see <http://www.ANTLR.org>.
+;; Some features depend on the value of ANTLR's "language" option (check the
+;; modeline for "Antlr.Java" or "Antlr.C++").

 ;; This package provides the following features:
-;;  * Syntax coloring (via font-lock) for grammar symbols and the code in
-;;    actions.  The latter depends on the language settings.
-;;  * Indentation for the current line (TAB) and selected region (C-M-\).
-;;  * Support for imenu/speedbar: menu "Index" (Parser, Lexer, TreeParser).
+;;  * Syntax highlighting for grammar symbols and the code in actions.
+;;  * Indentation (pretty-print) for the current line (TAB) and lines in the
+;;    selected region (C-M-\).  Inserting an ANTLR syntax symbol (one of
+;;    ":;|&(){}") might also indent the current line.
+;;  * Menu "Index" and Speedbar tags with all class, token and rule
+;;    definitions.  Jump to corresponding position by selecting an entry.
 ;;  * Commands to move to previous/next rule, beginning/end of rule body etc.
-;;  * Commands to hide/unhide actions, upcase/downcase literals.
+;;  * Commands to hide/unhide actions.
+;;  * Support to insert/change file/grammar/rule/subrule options.
 ;;  * Run ANTLR from within Emacs, create Makefile dependencies.

-;; LANGUAGE SETTINGS.  This mode needs to know which language is used in
-;; actions and semantic predicated of the grammar.  This information is used
-;; for syntax coloring and the creation of the Makefile dependencies.  It is
-;; stored in variable `antlr-language' and automatically set according to
-;; ANTLR's file option "language", see `antlr-language-alist'.  The supported
-;; languages are "Java" (java-mode) and "Cpp" (c++-mode).
+;; SYNTAX HIGHLIGHTING comes in three phases.  First, comments and strings are
+;; highlighted.  Second, the grammar code is highlighted according to
+;; `antlr-font-lock-additional-keywords' (rule refs: dark blue, token refs:
+;; dark orange, definition: bold blue).  Third, actions, semantic predicates
+;; and arguments are highlighted according to the usual font-lock keywords of
+;; the major-mode corresponding to ANTLR's "language" option, see also
+;; `antlr-font-lock-maximum-decoration'.  We define special font-lock faces for
+;; the grammar code to allow you to distinguish ANTLR keywords from Java/C++
+;; keywords.

 ;; INDENTATION.  This package supports ANTLR's (intended) indentation style
 ;; which is based on a simple paren/brace/bracket depth-level calculation, see
 ;; `antlr-indent-line'.  The indentation engine of cc-mode is only used inside
-;; block comments (it is not easy to use it for actions, esp if they come early
-;; in the rule body).  By default, this package defines a tab width of 4 to be
+;; block comments.  By default, this package defines a tab width of 4 to be
 ;; consistent to both ANTLR's conventions (TABs usage) and the
 ;; `c-indentation-style' "java" which sets `c-basic-offset' to 4, see
 ;; `antlr-tab-offset-alist'.  You might want to set this variable to nil.

-;; SYNTAX COLORING comes in three phases.  First, comments and strings are
-;; highlighted.  Second, the grammar code is highlighted according to
-;; `antlr-font-lock-additional-keywords' (rule refs: dark blue, token refs:
-;; dark orange, definition: bold blue).  Third, actions, semantic predicates
-;; and arguments are highlighted according to the usual font-lock keywords of
-;; `antlr-language', see also `antlr-font-lock-maximum-decoration'.  We define
-;; special font-lock faces for the grammar code to allow you to distinguish
-;; ANTLR keywords from Java/C++ keywords.
+;; OPTION SUPPORT.  This package provides special support to insert or change
+;; file, grammar, rule and subrule options via the menu or via the keyboard
+;; with completion.  For most options, you can also insert the value with
+;; completion (or select a value from a list by pressing `?').  You get a
+;; warning if an option is not supported by the version of ANTLR you are using
+;; (`antlr-tool-version' defaults to 2.7.1), or if the option shouldn't be
+;; inserted for other reasons.  This package knows the correct position where
+;; to insert the option and inserts "options {...}" if it is not already
+;; present.  For details, see the docstring of command \\[antlr-insert-option].

 ;; MAKEFILE CREATION.  Command \\[antlr-show-makefile-rules] shows/inserts the
 ;; dependencies for all grammar files in the current directory.  It considers
-;; import/export vocabularies and grammar inheritance and provides a value for
-;; the -glib option if necessary (which you have to edit if the super-grammar
-;; is not in the same directory).
+;; ANTLR's "language" option, import/export vocabularies and grammar
+;; inheritance, and provides a value for the -glib option if necessary (which
+;; you have to edit if the super-grammar is not in the same directory).
+
+;; TODO/WISH-LIST.  Things which might be supported in future versions:

-;; TODO.  Support to insert/change file/grammar/rule/subrule options.  imenu
-;; support for method definitions in actions is not really planned (you can
-;; send be a patch, though).  This mode would become too dependent on cc-mode
-;; or I would have to do a lot of language-dependent things myself...
+;;  * Next Version [C-c C-w].  Produce HTML document with syntax highlighted
+;;    and hyper-links (using htmlize).
+;;  * Next Version [C-c C-u].  Insert/update special comments: each rule lists
+;;    all rules which use the current rule.  With font-lock update.
+;;  * Next Version.  Make hiding much more customizable.
+;;  * Planned [C-c C-j].  Jump to generated coding.
+;;  * Planned.  Further support for imenu, i.e., include entries for method
+;;    definitions at beginning of grammar class.
+;;  * Planned [C-c C-p].  Pack/unpack rule/subrule & options (one/multi-line).
+
+;;  * Probably.  Show rules/dependencies for ANT like for Makefile (does ANT
+;;    support vocabularies and grammar inheritance?), I have to look at
+;;    jde-ant.el: http://jakarta.apache.org/ant/manual/OptionalTasks/antlr.html
+;;  * Unlikely.  Sather as generated language with syntax highlighting etc/.
+;;    Questions/problems: is sather-mode.el the standard mode for sather, is it
+;;    still supported, what is its relationship to eiffel3.el?  Requirement:
+;;    this mode must not depend on a Sather mode.
+;;  * Unlikely.  Faster syntax highlighting: sectionize the buffer into Antlr
+;;    and action code and run special highlighting functions on these regions.
+;;    Problems: code size, this mode would depend on font-lock internals.

 ;; Bug fixes, bug reports, improvements, and suggestions are strongly
 ;; appreciated.  Please check the newest version first:
@@ -97,19 +123,22 @@
 ;; I strongly recommend to use font-lock with a support mode like fast-lock,
 ;; lazy-lock or better jit-lock (Emacs-21.1+) / lazy-shot (XEmacs).

-;; To customize, use `M-x customize-group RET antlr RET' or the custom browser
-;; (Emacs->Programming->Languages->Antlr).
+;; To customize, use menu item "Antlr" -> "Customize Antlr".

 ;;; Code:

 (provide 'antlr-mode)
 (eval-when-compile			; required and optional libraries
   (require 'cc-mode)
+  (defvar c-Java-access-key)		; former cc-mode variable
+  (condition-case nil (require 'font-lock) (error nil))
+  (condition-case nil (require 'compile) (error nil))
   (defvar outline-level) (defvar imenu-use-markers)
   (defvar imenu-create-index-function))
-(eval-when-compile			; Emacs: cl, easymenu
+(eval-when-compile			; Emacs: cl, easymenu, XEmacs vars
   (require 'cl)
-  (require 'easymenu))
+  (require 'easymenu)
+  (defvar zmacs-region-stays))
 (eval-when-compile			; XEmacs: Emacs vars
   (defvar inhibit-point-motion-hooks) (defvar deactivate-mark))

@@ -117,6 +146,9 @@
   (if (featurep 'xemacs)
       (defalias 'antlr-scan-sexps 'scan-sexps)
     (defalias 'antlr-scan-sexps 'antlr-scan-sexps-internal))
+  (if (featurep 'xemacs)
+      (defalias 'antlr-scan-lists 'scan-lists)
+    (defalias 'antlr-scan-lists 'antlr-scan-lists-internal))
   (if (fboundp 'default-directory)
       (defalias 'antlr-default-directory 'default-directory)
     (defun antlr-default-directory () default-directory))
@@ -152,7 +184,7 @@
   :link '(url-link "http://www.fmi.uni-passau.de/~wedler/antlr-mode/")
   :prefix "antlr-")

-(defconst antlr-version "1.4"
+(defconst antlr-version "2.1"
   "ANTLR major mode version number.")


@@ -172,7 +204,7 @@
     (c++-mode "C++" "\"Cpp\"" "Cpp"))
   "List of ANTLR's supported languages.
 Each element in this list looks like
-  (MAJOR-MODE MODELINE-STRING OPTION-VALUE...)
+  \(MAJOR-MODE MODELINE-STRING OPTION-VALUE...)

 MAJOR-MODE, the major mode of the code in the grammar's actions, is the
 value of `antlr-language' if the first group in the string matched by
@@ -188,9 +220,9 @@
 					string )))))

 (defcustom antlr-language-limit-n-regexp
-  '(3000 . "language[ \t]*=[ \t]*\\(\"?[A-Z][A-Za-z_]*\"?\\)")
+  '(8192 . "language[ \t]*=[ \t]*\\(\"?[A-Z][A-Za-z_]*\"?\\)")
   "Used to set a reasonable value for `antlr-language'.
-Looks like (LIMIT . REGEXP).  Search for REGEXP from the beginning of
+Looks like \(LIMIT \. REGEXP).  Search for REGEXP from the beginning of
 the buffer to LIMIT and use the first group in the matched string to set
 the language according to `antlr-language-alist'."
   :group 'antlr
@@ -225,10 +257,10 @@
   '((antlr-mode nil 4 nil)
     (java-mode "antlr" 4 nil))
   "Alist to determine whether to use ANTLR's convention for TABs.
-Each element looks like (MAJOR-MODE REGEXP TAB-WIDTH INDENT-TABS-MODE).
+Each element looks like \(MAJOR-MODE REGEXP TAB-WIDTH INDENT-TABS-MODE).
 The first element whose MAJOR-MODE is nil or equal to `major-mode' and
-whose REGEXP is nil or matches `buffer-file-name' is used to set
-`tab-width' and `indent-tabs-mode'.  This is useful to support both
+whose REGEXP is nil or matches variable `buffer-file-name' is used to
+set `tab-width' and `indent-tabs-mode'.  This is useful to support both
 ANTLR's and Java's indentation styles.  Used by `antlr-set-tabs'."
   :group 'antlr
   :type '(repeat (group :value (antlr-mode nil 8 nil)
@@ -238,10 +270,270 @@
 			(integer :tag "Tab width")
 			(boolean :tag "Indent-tabs-mode"))))

-(defvar antlr-indent-item-regexp
-  "[]}):;|&]\\|default[ \t]*:\\|case[ \t]+\\('\\\\?.'\\|[0-9]+\\|[A-Za-z_][A-Za-z_0-9]*\\)[ \t]*:" ; & is local ANTLR extension
+(defcustom antlr-indent-style "java"
+  "*If non-nil, cc-mode indentation style used for `antlr-mode'.
+See `c-set-style' for details."
+  :group 'antlr
+  :type '(choice (const nil) regexp))
+
+(defcustom antlr-indent-item-regexp
+  "[]}):;|&]\\|default[ \t]*:\\|case[ \t]+\\('\\\\?.'\\|[0-9]+\\|[A-Za-z_][A-Za-z_0-9]*\\)[ \t]*:" ; & is local ANTLR extension (SGML's and-connector)
   "Regexp matching lines which should be indented by one TAB less.
-See command \\[antlr-indent-command].")
+See `antlr-indent-line' and command \\[antlr-indent-command]."
+  :group 'antlr
+  :type 'regexp)
+
+(defcustom antlr-indent-at-bol-alist
+  ;; eval-when-compile not usable with defcustom...
+  '((c++-mode . "#\\(assert\\|cpu\\|define\\|endif\\|el\\(if\\|se\\)\\|i\\(dent\\|f\\(def\\|ndef\\)?\\|mport\\|nclude\\(_next\\)?\\)\\|line\\|machine\\|pragma\\|system\\|un\\(assert\\|def\\)\\|warning\\)\\>"))
+  "Alist of regexps matching lines are indented at column 0.
+Each element in this list looks like (MODE . REGEXP) where MODE is a
+function and REGEXP is a regular expression.
+
+If `antlr-language' equals to a MODE and the line starting at the first
+non-whitespace is matched by the corresponding REGEXP, indent the line
+at column 0 instead according to the normal rules of `antlr-indent-line'."
+  :group 'antlr
+  :type '(repeat (cons (function :tag "Major mode") regexp)))
+
+
+;;;===========================================================================
+;;;  Options: customization
+;;;===========================================================================
+
+(defcustom antlr-options-use-submenus t
+  "*Non-nil, if the major mode menu should include option submenus.
+If nil, the menu just includes a command to insert options.  Otherwise,
+it includes four submenus to insert file/grammar/rule/subrule options."
+  :group 'antlr
+  :type 'boolean)
+
+(defcustom antlr-tool-version 20701
+  "*The version number of the Antlr tool.
+The value is an integer of the form XYYZZ which stands for vX.YY.ZZ.
+This variable is used to warn about non-supported options and to supply
+version correct option values when using \\[antlr-insert-option].
+
+Don't use a number smaller than 20600 since the stored history of
+Antlr's options starts with v2.06.00, see `antlr-options-alists'.  You
+can make this variable buffer-local."
+  :group 'antlr
+  :type 'integer)
+
+(defcustom antlr-options-auto-colon t
+  "*Non-nil, if `:' is inserted with a rule or subrule options section.
+A `:' is only inserted if this value is non-nil, if a rule or subrule
+option is inserted with \\[antlr-insert-option], if there was no rule or
+subrule options section before, and if a `:' is not already present
+after the section, ignoring whitespace, comments and the init action."
+  :group 'antlr
+  :type 'boolean)
+
+(defcustom antlr-options-style nil
+  "List of symbols which determine the style of option values.
+If a style symbol is present, the corresponding option value is put into
+quotes, i.e., represented as a string, otherwise it is represented as an
+identifier.
+
+The only style symbol used in the default value of `antlr-options-alist'
+is `language-as-string'.  See also `antlr-read-value'."
+  :group 'antlr
+  :type '(repeat (symbol :tag "Style symbol")))
+
+(defcustom antlr-options-push-mark t
+  "*Non-nil, if inserting an option should set & push mark.
+If nil, never set mark when inserting an option with command
+\\[antlr-insert-option].  If t, always set mark via `push-mark'.  If a
+number, only set mark if point was outside the options area before and
+the number of lines between point and the insert position is greater
+than this value.  Otherwise, only set mark if point was outside the
+options area before."
+  :group 'antlr
+  :type '(radio (const :tag "No" nil)
+		(const :tag "Always" t)
+		(integer :tag "Lines between" :value 10)
+		(sexp :tag "If outside options" :format "%t" :value outside)))
+
+(defcustom antlr-options-assign-string " = "
+  "*String containing `=' to use between option name and value.
+This string is only used if the option to insert did not exist before
+or if there was no `=' after it.  In other words, the spacing around an
+existing `=' won't be changed when changing an option value."
+  :group 'antlr
+  :type 'string)
+
+
+;;;===========================================================================
+;;;  Options: definitions
+;;;===========================================================================
+
+(defvar antlr-options-headings '("file" "grammar" "rule" "subrule")
+  "Headings for the four different option kinds.
+The standard value is (\"file\" \"grammar\" \"rule\" \"subrule\").  See
+`antlr-options-alists'")
+
+(defvar antlr-options-alists
+  '(;; file options ----------------------------------------------------------
+    (("language" antlr-language-option-extra
+      (20600 antlr-read-value
+	     "Generated language: " language-as-string
+	     (("Java") ("Cpp") ("HTML") ("Diagnostic")))
+      (20700 antlr-read-value
+	     "Generated language: " language-as-string
+	     (("Java") ("Cpp") ("HTML") ("Diagnostic") ("Sather"))))
+     ("mangleLiteralPrefix" nil
+      (20600 antlr-read-value
+	     "Prefix for literals (default LITERAL_): " t))
+     ("namespace" antlr-c++-mode-extra
+      (20700 antlr-read-value
+	     "Wrap generated C++ code in namespace: " t))
+     ("namespaceStd" antlr-c++-mode-extra
+      (20701 antlr-read-value
+	     "Replace ANTLR_USE_NAMESPACE(std) by: " t))
+     ("namespaceAntlr" antlr-c++-mode-extra
+      (20701 antlr-read-value
+	     "Replace ANTLR_USE_NAMESPACE(antlr) by: " t))
+     ("genHashLines" antlr-c++-mode-extra
+      (20701 antlr-read-boolean
+	     "Include #line in generated C++ code? "))
+     )
+    ;; grammar options --------------------------------------------------------
+    (("k" nil
+      (20600 antlr-read-value
+	     "Lookahead depth: "))
+     ("importVocab" nil
+      (20600 antlr-read-value
+	     "Import vocabulary: "))
+     ("exportVocab" nil
+      (20600 antlr-read-value
+	     "Export vocabulary: "))
+     ("testLiterals" nil		; lexer only
+      (20600 antlr-read-boolean
+	     "Test each token against literals table? "))
+     ("defaultErrorHandler" nil		; not for lexer
+      (20600 antlr-read-boolean
+	     "Generate default exception handler for each rule? "))
+     ("codeGenMakeSwitchThreshold" nil
+      (20600 antlr-read-value
+	     "Min number of alternatives for 'switch': "))
+     ("codeGenBitsetTestThreshold" nil
+      (20600 antlr-read-value
+	     "Min size of lookahead set for bitset test: "))
+     ("analyzerDebug" nil
+      (20600 antlr-read-boolean
+	     "Display debugging info during grammar analysis? "))
+     ("codeGenDebug" nil
+      (20600 antlr-read-boolean
+	     "Display debugging info during code generation? "))
+     ("buildAST" nil			; not for lexer
+      (20600 antlr-read-boolean
+	     "Use automatic AST construction/transformation? "))
+     ("ASTLabelType" nil		; not for lexer
+      (20600 antlr-read-value
+	     "Class of user-defined AST node: " t))
+     ("charVocabulary" nil		; lexer only
+      (20600 nil
+	     "Insert character vocabulary"))
+     ("interactive" nil
+      (20600 antlr-read-boolean
+	     "Generate interactive lexer/parser? "))
+     ("caseSensitive" nil		; lexer only
+      (20600 antlr-read-boolean
+	     "Case significant when matching characters? "))
+     ("caseSensitiveLiterals" nil	; lexer only
+      (20600 antlr-read-boolean
+	     "Case significant when testing literals table? "))
+     ("classHeaderSuffix" nil
+      (20600 nil
+	     "Additional string for grammar class definition"))
+     ("filter" nil			; lexer only
+      (20600 antlr-read-boolean
+	     "Skip rule (the name, true or false): "
+	     antlr-grammar-tokens))
+     ("namespace" antlr-c++-mode-extra
+      (20700 antlr-read-value
+	     "Wrap generated C++ code for grammar in namespace: " t))
+     ("namespaceStd" antlr-c++-mode-extra
+      (20701 antlr-read-value
+	     "Replace ANTLR_USE_NAMESPACE(std) by: " t))
+     ("namespaceAntlr" antlr-c++-mode-extra
+      (20701 antlr-read-value
+	     "Replace ANTLR_USE_NAMESPACE(antlr) by: " t))
+     ("genHashLines" antlr-c++-mode-extra
+      (20701 antlr-read-boolean
+	     "Include #line in generated C++ code? "))
+;;;     ("autoTokenDef" nil		; parser only
+;;;      (80000 antlr-read-boolean		; default: true
+;;;	     "Automatically define referenced token? "))
+;;;     ("keywordsMeltTo" nil		; parser only
+;;;      (80000 antlr-read-value
+;;;	     "Change non-matching keywords to token type: "))
+     )
+    ;; rule options ----------------------------------------------------------
+    (("testLiterals" nil		; lexer only
+      (20600 antlr-read-boolean
+	     "Test this token against literals table? "))
+     ("defaultErrorHandler" nil		; not for lexer
+      (20600 antlr-read-boolean
+	     "Generate default exception handler for this rule? "))
+     ("ignore" nil			; lexer only
+      (20600 antlr-read-value
+	     "In this rule, ignore tokens of type: " nil
+	     antlr-grammar-tokens))
+     ("paraphrase" nil			; lexer only
+      (20600 antlr-read-value
+	     "In messages, replace name of this token by: " t))
+     )
+    ;; subrule options -------------------------------------------------------
+    (("warnWhenFollowAmbig" nil
+      (20600 antlr-read-boolean
+	     "Display warnings for ambiguities with FOLLOW? "))
+     ("generateAmbigWarnings" nil
+      (20600 antlr-read-boolean
+	     "Display warnings for ambiguities? "))
+     ("greedy" nil
+      (20700 antlr-read-boolean
+	     "Make this optional/loop subrule greedy? "))
+     ))
+  "Definitions for Antlr's options of all four different kinds.
+
+The value looks like \(FILE GRAMMAR RULE SUBRULE) where each FILE,
+GRAMMAR, RULE, and SUBRULE is a list of option definitions of the
+corresponding kind, i.e., looks like \(OPTION-DEF...).
+
+Each OPTION-DEF looks like \(OPTION-NAME EXTRA-FN VALUE-SPEC...) which
+defines a file/grammar/rule/subrule option with name OPTION-NAME.  The
+OPTION-NAMEs are used for the creation of the \"Insert XXX Option\"
+submenus, see `antlr-options-use-submenus', and to allow to insert the
+option name with completion when using \\[antlr-insert-option].
+
+If EXTRA-FN is a function, it is called at different phases of the
+insertion with arguments \(PHASE OPTION-NAME).  PHASE can have the
+values `before-input' or `after-insertion', additional phases might be
+defined in future versions of this mode.  The phase `before-input'
+occurs before the user is asked to insert a value.  The phase
+`after-insertion' occurs after the option value has been inserted.
+EXTRA-FN might be called with additional arguments in future versions of
+this mode.
+
+Each specification VALUE-SPEC looks like \(VERSION READ-FN ARG...).  The
+last VALUE-SPEC in an OPTION-DEF whose VERSION is smaller or equal to
+`antlr-tool-version' specifies how the user is asked for the value of
+the option.
+
+If READ-FN is nil, the only ARG is a string which is printed at the echo
+area to guide the user what to insert at point.  Otherwise, READ-FN is
+called with arguments \(INIT-VALUE ARG...) to get the new value of the
+option.  INIT-VALUE is the old value of the option or nil.
+
+The standard value contains the following functions as READ-FN:
+`antlr-read-value' with ARGs = \(PROMPT AS-STRING TABLE) which reads a
+general value, or `antlr-read-boolean' with ARGs = \(PROMPT TABLE) which
+reads a boolean value or a member of TABLE.  PROMPT is the prompt when
+asking for a new value.  If non-nil, TABLE is a table for completion or
+a function evaluating to such a table.  The return value is quoted iff
+AS-STRING is non-nil and is either t or a symbol which is a member of
+`antlr-options-style'.")


 ;;;===========================================================================
@@ -265,7 +557,7 @@
   '("\n" ("GENS" "GENS%d" " \\\n\t") "$(ANTLR)")
   "*Variable to specify the appearance of the generated makefile rules.
 This variable influences the output of \\[antlr-show-makefile-rules].
-It looks like (RULE-SEP GEN-VAR-SPEC COMMAND).
+It looks like \(RULE-SEP GEN-VAR-SPEC COMMAND).

 RULE-SEP is the string to separate different makefile rules.  COMMAND is
 a string with the command which runs the Antlr tool, it should include
@@ -273,7 +565,7 @@
 if necessary.

 If GEN-VAR-SPEC is nil, each target directly consists of a list of
-files.  If GEN-VAR-SPEC looks like (GEN-VAR GEN-VAR-FORMAT GEN-SEP), a
+files.  If GEN-VAR-SPEC looks like \(GEN-VAR GEN-VAR-FORMAT GEN-SEP), a
 Makefile variable is created for each rule target.

 Then, GEN-VAR is a string with the name of the variable which contains
@@ -295,7 +587,7 @@
     (c++-mode ("%sTokenTypes.hpp") ("%s.cpp" "%s.hpp")))
   "Language dependent formats which specify generated files.
 Each element in this list looks looks like
-  (MAJOR-MODE (VOCAB-FILE-FORMAT...) (CLASS-FILE-FORMAT...)).
+  \(MAJOR-MODE (VOCAB-FILE-FORMAT...) (CLASS-FILE-FORMAT...)).

 The element whose MAJOR-MODE is equal to `antlr-language' is used to
 specify the generated files which are language dependent.  See variable
@@ -308,7 +600,7 @@

 (defvar antlr-special-file-formats '("%sTokenTypes.txt" "expanded%s.g")
   "Language independent formats which specify generated files.
-The value looks like (VOCAB-FILE-FORMAT EXPANDED-GRAMMAR-FORMAT).
+The value looks like \(VOCAB-FILE-FORMAT EXPANDED-GRAMMAR-FORMAT).

 VOCAB-FILE-FORMAT is a format string, it specifies with substitution
 VOCAB/%s the generated or input file for each export or import
@@ -322,7 +614,7 @@

 (defvar antlr-unknown-file-formats '("?%s?.g" "?%s?")
   "*Formats which specify the names of unknown files.
-The value looks like (SUPER-GRAMMAR-FILE-FORMAT SUPER-EVOCAB-FORMAT).
+The value looks like \(SUPER-GRAMMAR-FILE-FORMAT SUPER-EVOCAB-FORMAT).

 SUPER-GRAMMAR-FORMAT is a format string, it specifies with substitution
 SUPER/%s the name of a grammar file for Antlr's option \"-glib\" if no
@@ -376,46 +668,67 @@
     (define-key map "\C-c\C-c" 'comment-region)
     (define-key map "\C-c\C-v" 'antlr-hide-actions)
     (define-key map "\C-c\C-r" 'antlr-run-tool)
+    (define-key map "\C-c\C-o" 'antlr-insert-option)
     ;; I'm too lazy to define my own:
     (define-key map "\ea" 'c-beginning-of-statement)
     (define-key map "\ee" 'c-end-of-statement)
+    ;; electric keys:
+    (define-key map ":" 'antlr-electric-character)
+    (define-key map ";" 'antlr-electric-character)
+    (define-key map "|" 'antlr-electric-character)
+    (define-key map "&" 'antlr-electric-character)
+    (define-key map "(" 'antlr-electric-character)
+    (define-key map ")" 'antlr-electric-character)
+    (define-key map "{" 'antlr-electric-character)
+    (define-key map "}" 'antlr-electric-character)
     map)
   "Keymap used in `antlr-mode' buffers.")

-(easy-menu-define antlr-mode-menu
-		  antlr-mode-map
-		  "Major mode menu."
-		  '("Antlr"
-		    ["Indent Line" antlr-indent-command
-		     :active (not buffer-read-only)]
-		    ["Indent for Comment" indent-for-comment
-		     :active (not buffer-read-only)]
-		    ["Comment Out Region" comment-region
-		     :active (and (not buffer-read-only)
-				  (c-region-is-active-p))]
-		    ["Uncomment Region"
-		     (comment-region (region-beginning) (region-end) '(4))
-		     :active (and (not buffer-read-only)
-				  (c-region-is-active-p))]
-		    "---"
-		    ["Backward Rule" antlr-beginning-of-rule t]
-		    ["Forward Rule" antlr-end-of-rule t]
-		    ["Start of Rule Body" antlr-beginning-of-body
-		     :active (antlr-inside-rule-p)]
-		    ["End of Rule Body" antlr-end-of-body
-		     :active (antlr-inside-rule-p)]
-		    "---"
-		    ["Backward Statement" c-beginning-of-statement t]
-		    ["Forward Statement" c-end-of-statement t]
-		    ["Backward Into Nomencl." c-backward-into-nomenclature t]
-		    ["Forward Into Nomencl." c-forward-into-nomenclature t]
-		    "---"
-		    ["Hide Actions (incl. Args)" antlr-hide-actions t]
-		    ["Hide Actions (excl. Args)" (antlr-hide-actions 2) t]
-		    ["Unhide All Actions" (antlr-hide-actions 0) t]
-		    "---"
-		    ["Run Tool on Grammar" antlr-run-tool t]
-		    ["Show Makefile Rules" antlr-show-makefile-rules t]))
+(easy-menu-define antlr-mode-menu antlr-mode-map
+  "Major mode menu."
+  `("Antlr"
+    ,@(if (and antlr-options-use-submenus
+	       (boundp 'emacs-major-version)
+	       (or (featurep 'xemacs) (>= emacs-major-version 21)))
+	  `(("Insert File Option"
+	     :filter ,(lambda (x) (antlr-options-menu-filter 1 x)))
+	    ("Insert Grammar Option"
+	     :filter ,(lambda (x) (antlr-options-menu-filter 2 x)))
+	    ("Insert Rule Option"
+	     :filter ,(lambda (x) (antlr-options-menu-filter 3 x)))
+	    ("Insert Subrule Option"
+	     :filter ,(lambda (x) (antlr-options-menu-filter 4 x)))
+	    "---")
+	'(["Insert Option" antlr-insert-option
+	   :active (not buffer-read-only)]))
+    ("Forward/Backward"
+     ["Backward Rule" antlr-beginning-of-rule t]
+     ["Forward Rule" antlr-end-of-rule t]
+     ["Start of Rule Body" antlr-beginning-of-body
+      :active (antlr-inside-rule-p)]
+     ["End of Rule Body" antlr-end-of-body
+      :active (antlr-inside-rule-p)]
+     "---"
+     ["Backward Statement" c-beginning-of-statement t]
+     ["Forward Statement" c-end-of-statement t]
+     ["Backward Into Nomencl." c-backward-into-nomenclature t]
+     ["Forward Into Nomencl." c-forward-into-nomenclature t])
+    ["Indent Region" indent-region
+     :active (and (not buffer-read-only) (c-region-is-active-p))]
+    ["Comment Out Region" comment-region
+     :active (and (not buffer-read-only) (c-region-is-active-p))]
+    ["Uncomment Region"
+     (comment-region (region-beginning) (region-end) '(4))
+     :active (and (not buffer-read-only) (c-region-is-active-p))]
+    "---"
+    ["Hide Actions (incl. Args)" antlr-hide-actions t]
+    ["Hide Actions (excl. Args)" (antlr-hide-actions 2) t]
+    ["Unhide All Actions" (antlr-hide-actions 0) t]
+    "---"
+    ["Run Tool on Grammar" antlr-run-tool t]
+    ["Show Makefile Rules" antlr-show-makefile-rules t]
+    "---"
+    ["Customize Antlr" (customize-group 'antlr) t]))


 ;;;===========================================================================
@@ -432,24 +745,24 @@

 While calculating the decoration level for actions, `major-mode' is
 bound to `antlr-language'.  For example, with value
-  ((java-mode . 2) (c++-mode . 0))
+  \((java-mode \. 2) (c++-mode \. 0))
 Java actions are fontified with level 2 and C++ actions are not
 fontified at all."
-  :type '(choice (const :tag "none" none)
-		 (const :tag "inherit" inherit)
-		 (const :tag "default" nil)
-		 (const :tag "maximum" t)
-		 (integer :tag "level" 1)
-		 (repeat :menu-tag "mode specific" :tag "mode specific"
+  :type '(choice (const :tag "None" none)
+		 (const :tag "Inherit" inherit)
+		 (const :tag "Default" nil)
+		 (const :tag "Maximum" t)
+		 (integer :tag "Level" 1)
+		 (repeat :menu-tag "Mode specific" :tag "Mode specific"
 			 :value ((t . t))
 			 (cons :tag "Instance"
 			       (radio :tag "Mode"
-				      (const :tag "all" t)
-				      (symbol :tag "name"))
+				      (const :tag "All" t)
+				      (symbol :tag "Name"))
 			       (radio :tag "Decoration"
-				      (const :tag "default" nil)
-				      (const :tag "maximum" t)
-				      (integer :tag "level" 1))))))
+				      (const :tag "Default" nil)
+				      (const :tag "Maximum" t)
+				      (integer :tag "Level" 1))))))

 (defconst antlr-no-action-keywords nil
   ;; Using nil directly won't work (would use highest level, see
@@ -469,19 +782,31 @@
      c++-font-lock-keywords-3))
   "List of font-lock keywords for actions in the grammar.
 Each element in this list looks like
-  (MAJOR-MODE KEYWORD...)
+  \(MAJOR-MODE KEYWORD...)

 If `antlr-language' is equal to MAJOR-MODE, the KEYWORDs are the
 font-lock keywords according to `font-lock-defaults' used for the code
 in the grammar's actions and semantic predicates, see
 `antlr-font-lock-maximum-decoration'.")

+(defvar antlr-font-lock-default-face 'antlr-font-lock-default-face)
+(defface antlr-font-lock-default-face nil
+  "Face to prevent strings from language dependent highlighting.
+Do not change."
+  :group 'antlr)
+
 (defvar antlr-font-lock-keyword-face 'antlr-font-lock-keyword-face)
 (defface antlr-font-lock-keyword-face
   '((((class color) (background light)) (:foreground "black" :bold t)))
   "ANTLR keywords."
   :group 'antlr)

+(defvar antlr-font-lock-syntax-face 'antlr-font-lock-keyword-face)
+(defface antlr-font-lock-syntax-face
+  '((((class color) (background light)) (:foreground "black" :bold t)))
+  "ANTLR syntax symbols like :, |, (, ), ...."
+  :group 'antlr)
+
 (defvar antlr-font-lock-ruledef-face 'antlr-font-lock-ruledef-face)
 (defface antlr-font-lock-ruledef-face
   '((((class color) (background light)) (:foreground "blue" :bold t)))
@@ -509,9 +834,24 @@
 (defvar antlr-font-lock-literal-face 'antlr-font-lock-literal-face)
 (defface antlr-font-lock-literal-face
   '((((class color) (background light)) (:foreground "brown4" :bold t)))
-  "ANTLR literal tokens consisting merely of letter-like characters."
+  "ANTLR special literal tokens.
+It is used to highlight strings matched by the first regexp group of
+`antlr-font-lock-literal-regexp'."
   :group 'antlr)

+(defcustom antlr-font-lock-literal-regexp "\"\\(\\sw\\(\\sw\\|-\\)*\\)\""
+  "Regexp matching literals with special syntax highlighting, or nil.
+If nil, there is no special syntax highlighting for some literals.
+Otherwise, it should be a regular expression which must contain a regexp
+group.  The string matched by the first group is highlighted with
+`antlr-font-lock-literal-face'."
+  :group 'antlr
+  :type '(choice (const :tag "None" nil) regexp))
+
+(defvar antlr-class-header-regexp
+  "\\(class\\)[ \t]+\\([A-Za-z\300-\326\330-\337]\\sw*\\)[ \t]+\\(extends\\)[ \t]+\\([A-Za-z\300-\326\330-\337]\\sw*\\)[ \t]*;"
+  "Regexp matching class headers.")
+
 (defvar antlr-font-lock-additional-keywords
   `((antlr-invalidate-context-cache)
     ("\\$setType[ \t]*(\\([A-Za-z\300-\326\330-\337]\\sw*\\))"
@@ -519,13 +859,12 @@
     ("\\$\\sw+" (0 font-lock-keyword-face))
     ;; the tokens are already fontified as string/docstrings:
     (,(lambda (limit)
-	(antlr-re-search-forward "\"\\(\\sw\\(\\sw\\|-\\)*\\)\"" limit))
+	(if antlr-font-lock-literal-regexp
+	    (antlr-re-search-forward antlr-font-lock-literal-regexp limit)))
      (1 antlr-font-lock-literal-face t)
-     ,@(and (string-match "XEmacs" emacs-version)
-	    '((0 nil))))		; XEmacs bug workaround
+     ,@(and (featurep 'xemacs) '((0 nil)))) ; XEmacs bug workaround
     (,(lambda (limit)
-	(antlr-re-search-forward
-	 "^\\(class\\)[ \t]+\\([A-Za-z\300-\326\330-\337]\\sw*\\)[ \t]+\\(extends\\)[ \t]+\\([A-Za-z\300-\326\330-\337]\\sw*\\)[ \t]*;" limit))
+	(antlr-re-search-forward antlr-class-header-regexp limit))
      (1 antlr-font-lock-keyword-face)
      (2 antlr-font-lock-ruledef-face)
      (3 antlr-font-lock-keyword-face)
@@ -539,34 +878,40 @@
      (1 antlr-font-lock-keyword-face))
     (,(lambda (limit)
 	(antlr-re-search-forward
-	 "^\\(private\\|public\\|protected\\)\\>\\([ \t]+\\(\\sw+\\)\\)?"
+	 "^\\(private\\|public\\|protected\\)\\>[ \t]*\\(\\(\\sw+[ \t]*\\(:\\)?\\)\\)?"
 	 limit))
      (1 font-lock-type-face)		; not XEmacs' java level-3 fruit salad
      (3 (if (antlr-upcase-p (char-after (match-beginning 3)))
 	    'antlr-font-lock-tokendef-face
-	  'antlr-font-lock-ruledef-face) nil t))
+	  'antlr-font-lock-ruledef-face) nil t)
+     (4 antlr-font-lock-syntax-face nil t))
     (,(lambda (limit)
-	(antlr-re-search-forward "^\\sw+" limit))
-     (0 (if (antlr-upcase-p (char-after (match-beginning 0)))
+	(antlr-re-search-forward "^\\(\\sw+\\)[ \t]*\\(:\\)?" limit))
+     (1 (if (antlr-upcase-p (char-after (match-beginning 0)))
 	    'antlr-font-lock-tokendef-face
-	  'antlr-font-lock-ruledef-face) nil t))
+	  'antlr-font-lock-ruledef-face) nil t)
+     (2 antlr-font-lock-syntax-face nil t))
     (,(lambda (limit)
-	;; not only before a rule ref, also before a literal
-	(antlr-re-search-forward "\\<\\(\\sw+\\)[ \t]*:" limit))
-     (1 font-lock-variable-name-face))
+	;; v:ruleref and v:"literal" is allowed...
+	(antlr-re-search-forward "\\(\\sw+\\)[ \t]*\\([=:]\\)?" limit))
+     (1 (if (match-beginning 2)
+	    (if (eq (char-after (match-beginning 2)) ?=)
+		'antlr-font-lock-default-face
+	      'font-lock-variable-name-face)
+	  (if (antlr-upcase-p (char-after (match-beginning 1)))
+	      'antlr-font-lock-tokenref-face
+	    'antlr-font-lock-ruleref-face)))
+     (2 antlr-font-lock-default-face nil t))
     (,(lambda (limit)
-	(antlr-re-search-forward "\\<\\(\\sw+[ \t]*=[ \t]*\\)?\\(\\sw+[ \t]*:[ \t]*\\)?\\(\\sw+\\)" limit))
-     ;;(1 antlr-font-lock-default-face nil t) ; fool java-font-lock-keywords
-     (3 (if (antlr-upcase-p (char-after (match-beginning 3)))
-	    'antlr-font-lock-tokenref-face
-	  'antlr-font-lock-ruleref-face))))
+	(antlr-re-search-forward "[|&:;(]\\|)\\([*+?]\\|=>\\)?" limit))
+     (0 'antlr-font-lock-syntax-face)))
   "Font-lock keywords for ANTLR's normal grammar code.
 See `antlr-font-lock-keywords-alist' for the keywords of actions.")

 (defvar antlr-font-lock-defaults
   '(antlr-font-lock-keywords
     nil nil ((?_ . "w") (?\( . ".") (?\) . ".")) beginning-of-defun)
-  "Font-lock defaults used for ANTLR syntax coloring.
+  "Font-lock defaults used for ANTLR syntax highlighting.
 The SYNTAX-ALIST element is also used to initialize
 `antlr-action-syntax-table'.")

@@ -601,6 +946,7 @@
 ;;;;##########################################################################


+
 ;;;===========================================================================
 ;;;  Syntax functions -- Emacs vs XEmacs dependent
 ;;;===========================================================================
@@ -618,14 +964,25 @@
 (defun antlr-scan-sexps-internal (from count &optional dummy no-error)
 ;; checkdoc-params: (from count dummy)
   "Like `scan-sexps' but with additional arguments.
-When optional arg NO-ERROR is non-nil, `scan-sexps' will return nil
-instead of signaling an error."
+When optional arg NO-ERROR is non-nil, `antlr-scan-sexps-internal' will
+return nil instead of signaling an error."
   (if no-error
       (condition-case nil
 	  (scan-sexps from count)
-	(t nil))
+	(error nil))
     (scan-sexps from count)))

+(defun antlr-scan-lists-internal (from count depth &optional dummy no-error)
+;; checkdoc-params: (from count depth dummy)
+  "Like `scan-lists' but with additional arguments.
+When optional arg NO-ERROR is non-nil, `antlr-scan-lists-internal' will
+return nil instead of signaling an error."
+  (if no-error
+      (condition-case nil
+	  (scan-lists from count depth)
+	(error nil))
+    (scan-lists from count depth)))
+
 (defun antlr-xemacs-bug-workaround (&rest dummies)
 ;; checkdoc-params: (dummies)
   "Invalidate context_cache for syntactical context information."
@@ -738,8 +1095,13 @@
 ;;;  imenu support
 ;;;===========================================================================

-(defun antlr-imenu-create-index-function ()
-  "Return imenu index-alist for ANTLR grammar files."
+(defun antlr-grammar-tokens ()
+  "Return alist for tokens defined in current buffer."
+  (save-excursion (antlr-imenu-create-index-function t)))
+
+(defun antlr-imenu-create-index-function (&optional tokenrefs-only)
+  "Return imenu index-alist for ANTLR grammar files.
+IF TOKENREFS-ONLY is non-nil, just return alist with tokenref names."
   (let ((items nil)
 	(classes nil)
 	(semi (point-max)))
@@ -751,24 +1113,29 @@
       ;; editing (you are more likely to add functions to the end of the file).
       (while semi
 	(goto-char semi)
-	(if (setq semi (antlr-search-backward ";"))
+	(setq semi (antlr-search-backward ";"))
+	(if semi
 	    (progn (forward-char) (antlr-skip-exception-part t))
 	  (antlr-skip-file-prelude t))
 	(if (looking-at "{") (antlr-skip-sexps 1))
-	(if (looking-at "class[ \t]+\\([A-Za-z\300-\326\330-\337]\\sw*\\)[ \t]+extends[ \t]+\\([A-Za-z\300-\326\330-\337]\\sw*\\)[ \t]*;")
-	    (push (cons (match-string 1)
-			(if imenu-use-markers
-			    (copy-marker (match-beginning 1))
-			  (match-beginning 1)))
-		  classes)
+	(if (looking-at antlr-class-header-regexp)
+	    (or tokenrefs-only
+		(push (cons (match-string 2)
+			    (if imenu-use-markers
+				(copy-marker (match-beginning 2))
+			      (match-beginning 2)))
+		      classes))
 	  (if (looking-at "p\\(ublic\\|rotected\\|rivate\\)")
 	      (antlr-skip-sexps 1))
 	  (when (looking-at "\\sw+")
-	    (push (cons (match-string 0)
-			(if imenu-use-markers
-			    (copy-marker (match-beginning 0))
-			  (match-beginning 0)))
-		  items)))))
+	    (if tokenrefs-only
+		(if (antlr-upcase-p (char-after (point)))
+		    (push (list (match-string 0)) items))
+	      (push (cons (match-string 0)
+			  (if imenu-use-markers
+			      (copy-marker (match-beginning 0))
+			    (match-beginning 0)))
+		    items))))))
     (if classes (cons (cons "Classes" classes) items) items)))


@@ -794,7 +1161,8 @@
 	(if (looking-at "{") (setq pos (antlr-skip-sexps 1)))
       (while (looking-at "exception\\>")
 	(setq pos (antlr-skip-sexps 1))
-	(if (looking-at "\\[") (setq pos (antlr-skip-sexps 1)))
+	(when (looking-at "\\[")
+	  (setq pos (antlr-skip-sexps 1)))
 	(while (looking-at "catch\\>")
 	  (setq pos (antlr-skip-sexps 3)))))
     (or skip-comment (goto-char pos))))
@@ -802,16 +1170,22 @@
 (defun antlr-skip-file-prelude (skip-comment)
   "Skip the file prelude: the header and file options.
 If SKIP-COMMENT is non-nil, also skip the comment after that part.
-Return the start position of the file prelude."
+Return the start position of the file prelude.
+
+Hack: if SKIP-COMMENT is `header-only' only skip header and return
+position before the comment after the header."
   (let* ((pos (point))
 	 (pos0 pos))
     (c-forward-syntactic-ws)
     (if skip-comment (setq pos0 (point)))
     (while (looking-at "header\\>[ \t]*\\(\"\\)?")
       (setq pos (antlr-skip-sexps (if (match-beginning 1) 3 2))))
-    (if (looking-at "options\\>") (setq pos (antlr-skip-sexps 2)))
-    (or skip-comment (goto-char pos))
-    pos0))
+    (if (eq skip-comment 'header-only)	; a hack...
+	pos
+      (when (looking-at "options\\>")
+	(setq pos (antlr-skip-sexps 2)))
+      (or skip-comment (goto-char pos))
+      pos0)))

 (defun antlr-next-rule (arg skip-comment)
   "Move forward to next end of rule.  Do it ARG many times.
@@ -1011,15 +1385,560 @@


 ;;;===========================================================================
+;;;  Insert option: command
+;;;===========================================================================
+
+(defun antlr-insert-option (level option &optional location)
+  "Insert file/grammar/rule/subrule option near point.
+LEVEL determines option kind to insert: 1=file, 2=grammar, 3=rule,
+4=subrule.  OPTION is a string with the name of the option to insert.
+LOCATION can be specified for not calling `antlr-option-kind' twice.
+
+Inserting an option with this command works as follows:
+
+ 1. When called interactively, LEVEL is determined by the prefix
+    argument or automatically deduced without prefix argument.
+ 2. Signal an error if no option of that level could be inserted, e.g.,
+    if the buffer is read-only, the option area is outside the visible
+    part of the buffer or a subrule/rule option should be inserted with
+    point outside a subrule/rule.
+ 3. When called interactively, OPTION is read from the minibuffer with
+    completion over the known options of the given LEVEL.
+ 4. Ask user for confirmation if the given OPTION does not seem to be a
+    valid option to insert into the current file.
+ 5. Find a correct position to insert the option.
+ 6. Depending on the option, insert it the following way \(inserting an
+    option also means inserting the option section if necessary\):
+     - Insert the option and let user insert the value at point.
+     - Read a value (with completion) from the minibuffer, using a
+       previous value as initial contents, and insert option with value.
+ 7. Final action depending on the option.  For example, set the language
+    according to a newly inserted language option.
+
+The name of all options with a specification for their values are stored
+in `antlr-options-alist'.  The used specification also depends on the
+value of `antlr-tool-version', i.e., step 4 will warn you if you use an
+option that has been introduced in newer version of ANTLR, and step 5
+will offer completion using version-correct values.
+
+If the option already exists inside the visible part of the buffer, this
+command can be used to change the value of that option.  Otherwise, find
+a correct position where the option can be inserted near point.
+
+The search for a correct position is as follows:
+
+  * If search is within an area where options can be inserted, use the
+    position of point.  Inside the options section and if point is in
+    the middle of a option definition, skip the rest of it.
+  * If an options section already exists, insert the options at the end.
+    If only the beginning of the area is visible, insert at the
+    beginning.
+  * Otherwise, find the position where an options section can be
+    inserted and insert a new section before any comments.  If the
+    position before the comments is not visible, insert the new section
+    after the comments.
+
+This function also inserts \"options {...}\" and the \":\" if necessary,
+see `antlr-options-auto-colon'.  See also `antlr-options-assign-string'.
+
+This command might also set the mark like \\[set-mark-command] does, see
+`antlr-options-push-mark'."
+  (interactive (antlr-insert-option-interactive current-prefix-arg))
+  (barf-if-buffer-read-only)
+  (or location (setq location (cdr (antlr-option-kind level))))
+  (cond ((null level)
+	 (error "Cannot deduce what kind of option to insert"))
+	((atom location)
+	 (error "Cannot insert any %s options around here"
+		(elt antlr-options-headings (1- level)))))
+  (let ((area (car location))
+	(place (cdr location)))
+    (cond ((null place)		; invisible
+	   (error (if area
+		      "Invisible %s options, use %s to make them visible"
+		    "Invisible area for %s options, use %s to make it visible")
+		  (elt antlr-options-headings (1- level))
+		  (substitute-command-keys "\\[widen]")))
+	  ((null area)			; without option part
+	   (antlr-insert-option-do level option nil
+				   (null (cdr place))
+				   (car place)))
+	  ((save-excursion		; with option part, option visible
+	     (goto-char (max (point-min) (car area)))
+	     (re-search-forward (concat "\\(^\\|;\\)[ \t]*\\(\\<"
+					(regexp-quote option)
+					"\\>\\)[ \t\n]*\\(\\(=[ \t]?\\)[ \t]*\\(\\(\\sw\\|\\s_\\)+\\|\"\\([^\n\"\\]\\|[\\][^\n]\\)*\"\\)?\\)?")
+				;; 2=name, 3=4+5, 4="=", 5=value
+				(min (point-max) (cdr area))
+				t))
+	   (antlr-insert-option-do level option
+				   (cons (or (match-beginning 5)
+					     (match-beginning 3))
+					 (match-end 5))
+				   (and (null (cdr place)) area)
+				   (or (match-beginning 5)
+				       (match-end 4)
+				       (match-end 2))))
+	  (t				; with option part, option not yet
+	   (antlr-insert-option-do level option t
+				   (and (null (cdr place)) area)
+				   (car place))))))
+
+(defun antlr-insert-option-interactive (arg)
+  "Interactive specification for `antlr-insert-option'.
+Use prefix argument ARG to return \(LEVEL OPTION LOCATION)."
+  (barf-if-buffer-read-only)
+  (if arg (setq arg (prefix-numeric-value arg)))
+  (unless (memq arg '(nil 1 2 3 4))
+    (error "Valid prefix args: no=auto, 1=file, 2=grammar, 3=rule, 4=subrule"))
+  (let* ((kind (antlr-option-kind arg))
+	 (level (car kind)))
+    (if (atom (cdr kind))
+	(list level nil (cdr kind))
+      (let* ((table (elt antlr-options-alists (1- level)))
+	     (completion-ignore-case t)	;dynamic
+	     (input (completing-read (format "Insert %s option: "
+					     (elt antlr-options-headings
+						  (1- level)))
+				     table)))
+	(list level input (cdr kind))))))
+
+(defun antlr-options-menu-filter (level menu-items)
+  "Return items for options submenu of level LEVEL."
+  ;; checkdoc-params: (menu-items)
+  (let ((active (if buffer-read-only
+		    nil
+		  (consp (cdr-safe (cdr (antlr-option-kind level)))))))
+    (mapcar (lambda (option)
+	      (vector option
+		      (list 'antlr-insert-option level option)
+		      :active active))
+	    (sort (mapcar 'car (elt antlr-options-alists (1- level)))
+		  'string-lessp))))
+
+
+;;;===========================================================================
+;;;  Insert option: determine section-kind
+;;;===========================================================================
+
+(defun antlr-option-kind (requested)
+  "Return level and location for option to insert near point.
+Call function `antlr-option-level' with argument REQUESTED.  If the
+result is nil, return \(REQUESTED \. error).  If the result has the
+non-nil value LEVEL, return \(LEVEL \. LOCATION) where LOCATION looks
+like \(AREA \. PLACE), see `antlr-option-location'."
+  (save-excursion
+    (save-restriction
+      (let ((min0 (point-min))		; before `widen'!
+	    (max0 (point-max))
+	    (orig (point))
+	    (level (antlr-option-level requested)) ; calls `widen'!
+	    pos)
+	(cond ((null level)
+	       (setq level requested))
+	      ((eq level 1)		; file options
+	       (goto-char (point-min))
+	       (setq pos (antlr-skip-file-prelude 'header-only)))
+	      ((not (eq level 3))	; grammar or subrule options
+	       (setq pos (point))
+	       (c-forward-syntactic-ws))
+	      ((looking-at "^\\(private[ \t\n]\\|public[ \t\n]\\|protected[ \t\n]\\)?[ \t\n]*\\(\\(\\sw\\|\\s_\\)+\\)[ \t\n]*\\(!\\)?[ \t\n]*\\(\\[\\)?")
+	       ;; rule options, with complete rule header
+	       (goto-char (or (match-end 4) (match-end 3)))
+	       (setq pos (antlr-skip-sexps (if (match-end 5) 1 0)))
+	       (when (looking-at "returns[ \t\n]*\\[")
+		 (goto-char (1- (match-end 0)))
+		 (setq pos (antlr-skip-sexps 1)))))
+	(cons level
+	      (cond ((null pos) 'error)
+		    ((looking-at "options[ \t\n]*{")
+		     (goto-char (match-end 0))
+		     (setq pos (antlr-scan-lists (point) 1 1 nil t))
+		     (antlr-option-location orig min0 max0
+					    (point)
+					    (if pos (1- pos) (point-max))
+					    t))
+		    (t
+		     (antlr-option-location orig min0 max0
+					    pos (point)
+					    nil))))))))
+
+(defun antlr-option-level (requested)
+  "Return level for option to insert near point.
+Remove any restrictions from current buffer and return level for the
+option to insert near point, i.e., 1, 2, 3, 4, or nil if no such option
+can be inserted.  If REQUESTED is non-nil, it is the only possible value
+to return except nil.  If REQUESTED is nil, return level for the nearest
+option kind, i.e., the highest number possible.
+
+If the result is 2, point is at the beginning of the class after the
+class definition.  If the result is 3 or 4, point is at the beginning of
+the rule/subrule after the init action.  Otherwise, the point position
+is undefined."
+  (widen)
+  (if (eq requested 1)
+      1
+    (antlr-with-syntax-table antlr-action-syntax-table
+      (antlr-invalidate-context-cache)
+      (let* ((orig (point))
+	     (outsidep (antlr-outside-rule-p))
+	     bor depth)
+	(if (eq (char-after) ?\{) (antlr-skip-sexps 1))
+	(setq bor (point))		; beginning of rule (after init action)
+	(cond ((eq requested 2)		; grammar options required?
+	       (let (boc)		; beginning of class
+		 (goto-char (point-min))
+		 (while (and (<= (point) bor)
+			     (antlr-re-search-forward antlr-class-header-regexp
+						      nil))
+		   (if (<= (match-beginning 0) bor)
+		       (setq boc (match-end 0))))
+		 (when boc
+		   (goto-char boc)
+		   2)))
+	      ((save-excursion		; in region of file options?
+		 (goto-char (point-min))
+		 (antlr-skip-file-prelude t) ; ws/comment after: OK
+		 (< orig (point)))
+	       (and (null requested) 1))
+	      (outsidep			; outside rule not OK
+	       nil)
+	      ((looking-at antlr-class-header-regexp) ; rule = class def?
+	       (goto-char (match-end 0))
+	       (and (null requested) 2))
+	      ((eq requested 3)		; rule options required?
+	       (goto-char bor)
+	       3)
+	      ((setq depth (antlr-syntactic-grammar-depth orig bor))
+	       (if (> depth 0)		; move out of actions
+		   (goto-char (scan-lists (point) -1 depth)))
+	       (set-syntax-table antlr-mode-syntax-table)
+	       (antlr-invalidate-context-cache)
+	       (if (eq (antlr-syntactic-context) 0) ; not in subrule?
+		   (unless (eq requested 4)
+		     (goto-char bor)
+		     3)
+		 (goto-char (1+ (scan-lists (point) -1 1)))
+		 4)))))))
+
+(defun antlr-option-location (orig min-vis max-vis min-area max-area withp)
+  "Return location for the options area.
+ORIG is the original position of `point', MIN-VIS is `point-min' and
+MAX-VIS is `point-max'.  If WITHP is non-nil, there exists an option
+specification and it starts after the brace at MIN-AREA and stops at
+MAX-AREA.  If WITHP is nil, there is no area and the region where it
+could be inserted starts at MIN-AREA and stops at MAX-AREA.
+
+The result has the form (AREA . PLACE).  AREA is (MIN-AREA . MAX-AREA)
+if WITHP is non-nil, and nil otherwise.  PLACE is nil if the area is
+invisible, (ORIG) if ORIG is inside the area, (MIN-AREA . beginning) for
+a visible start position and (MAX-AREA . end) for a visible end position
+where the beginning is preferred if WITHP is nil and the end if WITHP is
+non-nil."
+  (cons (and withp (cons min-area max-area))
+	(cond ((and (<= min-area orig) (<= orig max-area))
+	       ;; point in options area
+	       (list orig))
+	      ((and (null withp) (<= min-vis min-area) (<= min-area max-vis))
+	       ;; use start of options area (only if not `withp')
+	       (cons min-area 'beginning))
+	      ((and (<= min-vis max-area) (<= max-area max-vis))
+	       ;; use end of options area
+	       (cons max-area 'end))
+	      ((and withp (<= min-vis min-area) (<= min-area max-vis))
+	       ;; use start of options area (only if `withp')
+	       (cons min-area 'beginning)))))
+
+(defun antlr-syntactic-grammar-depth (pos beg)
+  "Return syntactic context depth at POS.
+Move to POS and from there on to the beginning of the string or comment
+if POS is inside such a construct.  Then, return the syntactic context
+depth at point if the point position is smaller than BEG.
+WARNING: this may alter `match-data'."
+  (goto-char pos)
+  (let ((context (or (antlr-syntactic-context) 0)))
+    (while (and context (not (integerp context)))
+      (cond ((eq context 'string)
+	     (setq context
+		   (and (search-backward "\"" nil t)
+			(>= (point) beg)
+			(or (antlr-syntactic-context) 0))))
+	    ((memq context '(comment block-comment))
+	     (setq context
+		   (and (re-search-backward "/[/*]" nil t)
+			(>= (point) beg)
+			(or (antlr-syntactic-context) 0))))))
+    context))
+
+
+;;;===========================================================================
+;;;  Insert options: do the insertion
+;;;===========================================================================
+
+(defun antlr-insert-option-do (level option old area pos)
+  "Insert option into buffer at position POS.
+Insert option of level LEVEL and name OPTION.  If OLD is non-nil, an
+options area is already exists.  If OLD looks like \(BEG \. END), the
+option already exists.  Then, BEG is the start position of the option
+value, the position of the `=' or nil, and END is the end position of
+the option value or nil.
+
+If the original point position was outside an options area, AREA is nil.
+Otherwise, and if an option specification already exists, AREA is a cons
+cell where the two values determine the area inside the braces."
+  (let* ((spec (cdr (assoc option (elt antlr-options-alists (1- level)))))
+	 (value (antlr-option-spec level option (cdr spec) (consp old))))
+    (if (fboundp (car spec)) (funcall (car spec) 'before-input option))
+    ;; set mark (unless point was inside options area before)
+    (if (cond (area (eq antlr-options-push-mark t))
+	      ((numberp antlr-options-push-mark)
+	       (> (count-lines (min (point) pos) (max (point) pos))
+		  antlr-options-push-mark))
+	      (antlr-options-push-mark))
+	(push-mark))
+    ;; read option value -----------------------------------------------------
+    (goto-char pos)
+    (if (null value)
+	;; no option specification found
+	(if (y-or-n-p (format "Insert unknown %s option %s? "
+			      (elt antlr-options-headings (1- level))
+			      option))
+	    (message "Insert value for %s option %s"
+		     (elt antlr-options-headings (1- level))
+		     option)
+	  (error "Didn't insert unknown %s option %s"
+		 (elt antlr-options-headings (1- level))
+		 option))
+      ;; option specification found
+      (setq value (cdr value))
+      (if (car value)
+	  (let ((initial (and (consp old) (cdr old)
+			      (buffer-substring (car old) (cdr old)))))
+	    (setq value (apply (car value)
+			       (and initial
+				    (if (eq (aref initial 0) ?\")
+					(read initial)
+				      initial))
+			       (cdr value))))
+	(message (cadr value))
+	(setq value nil)))
+    ;; insert value ----------------------------------------------------------
+    (if (consp old)
+	(antlr-insert-option-existing old value)
+      (if (consp area)
+	  ;; Move outside string/comment if point is inside option spec
+	  (antlr-syntactic-grammar-depth (point) (car area)))
+      (antlr-insert-option-space area old)
+      (or old (antlr-insert-option-area level))
+      (insert option " = ;")
+      (backward-char)
+      (if value (insert value)))
+    ;; final -----------------------------------------------------------------
+    (if (fboundp (car spec)) (funcall (car spec) 'after-insertion option))))
+
+(defun antlr-option-spec (level option specs existsp)
+  "Return version correct option value specification.
+Return specification for option OPTION of kind level LEVEL.  SPECS
+should correspond to the VALUE-SPEC... in `antlr-option-alists'.
+EXISTSP determines whether the option already exists."
+  (let (value)
+    (while (and specs (>= antlr-tool-version (caar specs)))
+      (setq value (pop specs)))
+    (cond (value)			; found correct spec
+	  ((null specs) nil)		; didn't find any specs
+	  (existsp (car specs))	; wrong version, but already present
+	  ((y-or-n-p (format "Insert v%s %s option %s in v%s? "
+			     (antlr-version-string (caar specs))
+			     (elt antlr-options-headings (1- level))
+			     option
+			     (antlr-version-string antlr-tool-version)))
+	   (car specs))
+	  (t
+	   (error "Didn't insert v%s %s option %s in v%s"
+		  (antlr-version-string (caar specs))
+		  (elt antlr-options-headings (1- level))
+		  option
+		  (antlr-version-string antlr-tool-version))))))
+
+(defun antlr-version-string (version)
+  "Format the Antlr version number VERSION, see `antlr-tool-version'."
+  (let ((version100 (/ version 100)))
+    (format "%d.%d.%d"
+	    (/ version100 100) (mod version100 100) (mod version 100))))
+
+
+;;;===========================================================================
+;;;  Insert options: the details (used by `antlr-insert-option-do')
+;;;===========================================================================
+
+(defun antlr-insert-option-existing (old value)
+  "Insert option value VALUE at point for existing option.
+For OLD, see `antlr-insert-option-do'."
+  ;; no = => insert =
+  (unless (car old) (insert antlr-options-assign-string))
+  ;; with user input => insert if necessary
+  (when value
+    (if (cdr old)		; with value
+	(if (string-equal value (buffer-substring (car old) (cdr old)))
+	    (goto-char (cdr old))
+	  (delete-region (car old) (cdr old))
+	  (insert value))
+      (insert value)))
+  (unless (looking-at "\\([^\n=;{}/'\"]\\|'\\([^\n'\\]\\|\\\\.\\)*'\\|\"\\([^\n\"\\]\\|\\\\.\\)*\"\\)*;")
+    ;; stuff (no =, {, } or /) at point is not followed by ";"
+    (insert ";")
+    (backward-char)))
+
+(defun antlr-insert-option-space (area old)
+  "Find appropriate place to insert option, insert newlines/spaces.
+For AREA and OLD, see `antlr-insert-option-do'."
+  (let ((orig (point))
+	(open t))
+    (skip-chars-backward " \t")
+    (unless (bolp)
+      (let ((before (char-after (1- (point)))))
+	(goto-char orig)
+	(and old			; with existing options area
+	     (consp area)		; if point inside existing area
+	     (not (eq before ?\;))	; if not at beginning of option
+					; => skip to end of option
+	     (if (and (search-forward ";" (cdr area) t)
+		      (let ((context (antlr-syntactic-context)))
+			(or (null context) (numberp context))))
+		 (setq orig (point))
+	       (goto-char orig)))
+	(skip-chars-forward " \t")
+
+	(if (looking-at "$\\|//")
+	    ;; just comment after point => skip (+ lines w/ same col comment)
+	    (let ((same (if (> (match-end 0) (match-beginning 0))
+			    (current-column))))
+	      (beginning-of-line 2)
+	      (or (bolp) (insert "\n"))
+	      (when (and same (null area)) ; or (consp area)?
+		(while (and (looking-at "[ \t]*\\(//\\)")
+			    (goto-char (match-beginning 1))
+			    (= (current-column) same))
+		  (beginning-of-line 2)
+		  (or (bolp) (insert "\n")))))
+	  (goto-char orig)
+	  (if (null old)
+	      (progn (insert "\n") (antlr-indent-line))
+	    (unless (eq (char-after (1- (point))) ?\ )
+	      (insert " "))
+	    (unless (eq (char-after (point)) ?\ )
+	      (insert " ")
+	      (backward-char))
+	    (setq open nil)))))
+    (when open
+      (beginning-of-line 1)
+      (insert "\n")
+      (backward-char)
+      (antlr-indent-line))))
+
+(defun antlr-insert-option-area (level)
+  "Insert new options area for options of level LEVEL.
+Used by `antlr-insert-option-do'."
+  (insert "options {\n\n}")
+  (when (and antlr-options-auto-colon
+	     (memq level '(3 4))
+	     (save-excursion
+	       (c-forward-syntactic-ws)
+	       (if (eq (char-after (point)) ?\{) (antlr-skip-sexps 1))
+	       (not (eq (char-after (point)) ?\:))))
+    (insert "\n:")
+    (antlr-indent-line)
+    (end-of-line 0))
+  (backward-char 1)
+  (antlr-indent-line)
+  (beginning-of-line 0)
+  (antlr-indent-line))
+
+
+;;;===========================================================================
+;;;  Insert options: in `antlr-options-alists'
+;;;===========================================================================
+
+(defun antlr-read-value (initial-contents prompt
+					  &optional as-string table table-x)
+  "Read a string from the minibuffer, possibly with completion.
+If INITIAL-CONTENTS is non-nil, insert it in the minibuffer initially.
+PROMPT is a string to prompt with, normally it ends in a colon and a
+space.  If AS-STRING is t or is a member \(comparison done with `eq') of
+`antlr-options-style', return printed representation of the user input,
+otherwise return the user input directly.
+
+If TABLE or TABLE-X is non-nil, read with completion.  The completion
+table is the resulting alist of TABLE-X concatenated with TABLE where
+TABLE can also be a function evaluation to an alist.
+
+Used inside `antlr-options-alists'."
+  (let* ((table0 (and (or table table-x)
+		      (append table-x
+			      (if (functionp table) (funcall table) table))))
+	 (input (if table0
+		    (completing-read prompt table0 nil nil initial-contents)
+		  (read-from-minibuffer prompt initial-contents))))
+    (if (and as-string
+	     (or (eq as-string t)
+		 (cdr (assq as-string antlr-options-style))))
+	(format "%S" input)
+      input)))
+
+(defun antlr-read-boolean (initial-contents prompt &optional table)
+  "Read a boolean value from the minibuffer, with completion.
+If INITIAL-CONTENTS is non-nil, insert it in the minibuffer initially.
+PROMPT is a string to prompt with, normally it ends in a question mark
+and a space.  \"(true or false) \" is appended if TABLE is nil.
+
+Read with completion over \"true\", \"false\" and the keys in TABLE, see
+also `antlr-read-value'.
+
+Used inside `antlr-options-alists'."
+  (antlr-read-value initial-contents
+		    (if table prompt (concat prompt "(true or false) "))
+		    nil
+		    table '(("false") ("true"))))
+
+(defun antlr-language-option-extra (phase &rest dummies)
+;; checkdoc-params: (dummies)
+  "Change language according to the new value of the \"language\" option.
+Call `antlr-mode' if the new language would be different from the value
+of `antlr-language', keeping the value of variable `font-lock-mode'.
+
+Called in PHASE `after-insertion', see `antlr-options-alists'."
+  (when (eq phase 'after-insertion)
+    (let ((new-language (antlr-language-option t)))
+      (or (null new-language)
+	  (eq new-language antlr-language)
+	  (let ((font-lock (and (boundp 'font-lock-mode) font-lock-mode)))
+	    (if font-lock (font-lock-mode 0))
+	    (antlr-mode)
+	    (and font-lock (null font-lock-mode) (font-lock-mode 1)))))))
+
+(defun antlr-c++-mode-extra (phase option &rest dummies)
+;; checkdoc-params: (option dummies)
+  "Warn if C++ option is used with the wrong language.
+Ask user \(\"y or n\"), if a C++ only option is going to be inserted but
+`antlr-language' has not the value `c++-mode'.
+
+Called in PHASE `before-input', see `antlr-options-alists'."
+  (and (eq phase 'before-input)
+       (not (y-or-n-p (format "Insert C++ %s option? " option)))
+       (error "Didn't insert C++ %s option with language %s"
+	      option (cadr (assq antlr-language antlr-language-alist)))))
+
+
+;;;===========================================================================
 ;;;  Compute dependencies
 ;;;===========================================================================

 (defun antlr-file-dependencies ()
   "Return dependencies for grammar in current buffer.
-The result looks like (FILE (CLASSES . SUPERS) VOCABS . LANGUAGE)
-where CLASSES = ((CLASS . CLASS-EVOCAB) ...),
-      SUPERS  = ((SUPER . USE-EVOCAB-P) ...), and
-      VOCABS  = ((EVOCAB ...) . (IVOCAB ...))
+The result looks like \(FILE \(CLASSES \. SUPERS) VOCABS \. LANGUAGE)
+  where CLASSES = ((CLASS . CLASS-EVOCAB) ...),
+        SUPERS  = ((SUPER . USE-EVOCAB-P) ...), and
+        VOCABS  = ((EVOCAB ...) . (IVOCAB ...))

 FILE is the current buffer's file-name without directory part and
 LANGUAGE is the value of `antlr-language' in the current buffer.  Each
@@ -1033,10 +1952,10 @@
   (let (classes exportVocabs importVocabs superclasses default-vocab)
     (antlr-with-syntax-table antlr-action-syntax-table
       (goto-char (point-min))
-      (while (antlr-re-search-forward "class[ \t]+\\([A-Za-z\300-\326\330-\337]\\sw*\\)[ \t]+extends[ \t]+\\([A-Za-z\300-\326\330-\337]\\sw*\\)[ \t]*;" nil)
+      (while (antlr-re-search-forward antlr-class-header-regexp nil)
 	;; parse class definition --------------------------------------------
-	(let* ((class (match-string 1))
-	       (sclass (match-string 2))
+	(let* ((class (match-string 2))
+	       (sclass (match-string 4))
 	       ;; export vocab defaults to class name (first grammar in file)
 	       ;; or to the export vocab of the first grammar in file:
 	       (evocab (or default-vocab class))
@@ -1048,7 +1967,7 @@
 		(antlr-skip-sexps 2)
 	      (goto-char (match-end 0))
 	      (c-forward-syntactic-ws)
-	      ;; parse grammar option section --------------------------------
+	      ;; parse grammar option sections -------------------------------
 	      (when (eq (char-after (point)) ?\{)
 		(let* ((beg (1+ (point)))
 		       (end (1- (antlr-skip-sexps 1)))
@@ -1080,8 +1999,8 @@

 (defun antlr-directory-dependencies (dirname)
   "Return dependencies for all grammar files in directory DIRNAME.
-The result looks like ((CLASS-SPEC ...) . (FILE-DEP ...))
-where CLASS-SPEC = (CLASS (FILE . EVOCAB) ...).
+The result looks like \((CLASS-SPEC ...) \. \(FILE-DEP ...))
+  where CLASS-SPEC = (CLASS (FILE \. EVOCAB) ...).

 FILE-DEP are the dependencies for each grammar file in DIRNAME, see
 `antlr-file-dependencies'.  For each grammar class CLASS, FILE is a
@@ -1131,14 +2050,14 @@
   "Compute the grammar lib option for the super grammars SUPERS.
 Look in CLASSES for the right grammar lib files for SUPERS.  SUPERS is
 part SUPER in the result of `antlr-file-dependencies'.  CLASSES is the
-part (CLASS-SPEC ...) in the result of `antlr-directory-dependencies'.
+part \(CLASS-SPEC ...) in the result of `antlr-directory-dependencies'.

-The result looks like (OPTION WITH-UNKNOWN GLIB ...).  OPTION is the
+The result looks like \(OPTION WITH-UNKNOWN GLIB ...).  OPTION is the
 complete \"-glib\" option.  WITH-UNKNOWN has value t iff there is none
 or more than one grammar file for at least one super grammar.

-Each GLIB looks like (GRAMMAR-FILE . EVOCAB).  GRAMMAR-FILE is a file in
-which a super-grammar is defined.  EVOCAB is the value of the export
+Each GLIB looks like \(GRAMMAR-FILE \. EVOCAB).  GRAMMAR-FILE is a file
+in which a super-grammar is defined.  EVOCAB is the value of the export
 vocabulary of the super-grammar or nil if it is not needed."
   ;; If the superclass is defined in the same file, that file will be included
   ;; with -glib again.  This will lead to a redefinition.  But defining a
@@ -1306,69 +2225,115 @@
  - plus 0/2/1, depending on the position inside the rule: header, body,
    exception part,
  - minus 1 if `antlr-indent-item-regexp' matches the beginning of the
-   line starting from the first non-blank.
+   line starting from the first non-whitespace.
+
+Lines inside block comments are indented by `c-indent-line' according to
+`antlr-indent-comment'.
+
+If `antlr-language' equals to a key in `antlr-indent-at-bol-alist' and
+the line starting at the first non-whitespace is matched by the
+corresponding value, indent the line at column 0.

-Lines inside block comments are not changed or indented by
-`c-indent-line', see `antlr-indent-comment'."
-  (let ((orig (point)) bol boi indent syntax)
-    (beginning-of-line)
-    (setq bol (point))
-    (skip-chars-forward " \t")
-    (setq boi (point))
-    ;; check syntax at beginning of indentation ------------------------------
-    (antlr-with-syntax-table antlr-action-syntax-table
-      (antlr-invalidate-context-cache)
-      (cond ((symbolp (setq syntax (antlr-syntactic-context)))
-	     (setq indent nil))		; block-comments, strings, (comments)
-	    ((eq (char-after) ?#)	; cpp directive
-	     (setq syntax 'cpp)
-	     (setq indent 0))		; indentation at 0
-	    ((progn
-	       (antlr-next-rule -1 t)
-	       (if (antlr-search-forward ":") (< boi (1- (point))) t))
-	     (setq indent 0))		; in rule header
-	    ((if (antlr-search-forward ";") (< boi (point)) t)
-	     (setq indent 2))		; in rule body
-	    (t
-	     (forward-char)
-	     (antlr-skip-exception-part nil)
-	     (setq indent (if (> (point) boi) 1 0))))) ; in exception part?
-    ;; compute the corresponding indentation and indent ----------------------
-    (if (null indent)
-	(progn
-	  (goto-char orig)
-	  (and (eq antlr-indent-comment t)
-	       (not (eq syntax 'string))
-	       (c-indent-line)))
-      ;; do it ourselves
-      (goto-char boi)
-      (unless (symbolp syntax)		; direct indentation
+For the initialization of `c-basic-offset', see `antlr-indent-style' and,
+to a lesser extent, `antlr-tab-offset-alist'."
+  (save-restriction
+    (let ((orig (point))
+	  (min0 (point-min))
+	  bol boi indent syntax)
+      (widen)
+      (beginning-of-line)
+      (setq bol (point))
+      (if (< bol min0)
+	  (error "Beginning of current line not visible"))
+      (skip-chars-forward " \t")
+      (setq boi (point))
+      ;; check syntax at beginning of indentation ----------------------------
+      (antlr-with-syntax-table antlr-action-syntax-table
 	(antlr-invalidate-context-cache)
-	(incf indent (antlr-syntactic-context))
-	(and (> indent 0) (looking-at antlr-indent-item-regexp) (decf indent))
-	(setq indent (* indent c-basic-offset)))
-      ;; the usual major-mode indent stuff -----------------------------------
-      (setq orig (- (point-max) orig))
-      (unless (= (current-column) indent)
-	(delete-region bol boi)
-	(beginning-of-line)
-	(indent-to indent))
-      ;; If initial point was within line's indentation,
-      ;; position after the indentation.  Else stay at same point in text.
-      (if (> (- (point-max) orig) (point))
-	  (goto-char (- (point-max) orig))))))
+	(setq syntax (antlr-syntactic-context))
+	(cond ((symbolp syntax)
+	       (setq indent nil))	; block-comments, strings, (comments)
+	      ((and (assq antlr-language antlr-indent-at-bol-alist)
+		    (looking-at (cdr (assq antlr-language
+					   antlr-indent-at-bol-alist))))
+	       (setq syntax 'bol)
+	       (setq indent 0))		; indentation at 0
+	      ((progn
+		 (antlr-next-rule -1 t)
+		 (if (antlr-search-forward ":") (< boi (1- (point))) t))
+	       (setq indent 0))		; in rule header
+	      ((if (antlr-search-forward ";") (< boi (point)) t)
+	       (setq indent 2))		; in rule body
+	      (t
+	       (forward-char)
+	       (antlr-skip-exception-part nil)
+	       (setq indent (if (> (point) boi) 1 0))))) ; in exception part?
+      ;; compute the corresponding indentation and indent --------------------
+      (if (null indent)
+	  ;; Use the indentation engine of cc-mode for block comments.  Using
+	  ;; it-mode for actions is not easy, especially if the actions come
+	  ;; early in the rule body.
+	  (progn
+	    (goto-char orig)
+	    (and (eq antlr-indent-comment t)
+		 (not (eq syntax 'string))
+		 (c-indent-line)))
+	;; do it ourselves
+	(goto-char boi)
+	(unless (symbolp syntax)		; direct indentation
+	  (antlr-invalidate-context-cache)
+	  (incf indent (antlr-syntactic-context))
+	  (and (> indent 0) (looking-at antlr-indent-item-regexp) (decf indent))
+	  (setq indent (* indent c-basic-offset)))
+	;; the usual major-mode indent stuff ---------------------------------
+	(setq orig (- (point-max) orig))
+	(unless (= (current-column) indent)
+	  (delete-region bol boi)
+	  (beginning-of-line)
+	  (indent-to indent))
+	;; If initial point was within line's indentation,
+	;; position after the indentation.  Else stay at same point in text.
+	(if (> (- (point-max) orig) (point))
+	    (goto-char (- (point-max) orig)))))))

 (defun antlr-indent-command (&optional arg)
   "Indent the current line or insert tabs/spaces.
 With optional prefix argument ARG or if the previous command was this
 command, insert ARG tabs or spaces according to `indent-tabs-mode'.
 Otherwise, indent the current line with `antlr-indent-line'."
-  (interactive "P")
+  (interactive "*P")
   (if (or arg (eq last-command 'antlr-indent-command))
       (insert-tab arg)
     (let ((antlr-indent-comment (and antlr-indent-comment t))) ; dynamic
       (antlr-indent-line))))

+(defun antlr-electric-character (&optional arg)
+  "Insert the character you type and indent the current line.
+Insert the character like `self-insert-command' and indent the current
+line as `antlr-indent-command' does.  Do not indent the line if
+
+ * this command is called with a prefix argument ARG,
+ * there are characters except whitespaces between point and the
+   beginning of the line, or
+ * point is not inside a normal grammar code, { and } are also OK in
+   actions.
+
+This command is useful for a character which has some special meaning in
+ANTLR's syntax and influences the auto indentation, see
+`antlr-indent-item-regexp'."
+  (interactive "*P")
+  (if (or arg
+	  (save-excursion (skip-chars-backward " \t") (not (bolp)))
+	  (antlr-with-syntax-table antlr-action-syntax-table
+	    (antlr-invalidate-context-cache)
+	    (let ((context (antlr-syntactic-context)))
+	      (not (and (numberp context)
+			(or (zerop context)
+			    (memq last-command-char '(?\{ ?\}))))))))
+      (self-insert-command (prefix-numeric-value arg))
+    (self-insert-command (prefix-numeric-value arg))
+    (antlr-indent-line)))
+

 ;;;===========================================================================
 ;;;  Mode entry
@@ -1425,17 +2390,27 @@
   (make-local-variable 'comment-indent-function)
   (setq comment-indent-function 'c-comment-indent))

-(defun antlr-language-for-option (option-value)
-  "Find element in `antlr-language-alist' for OPTION-VALUE."
-  ;; Like (find OPTION-VALUE antlr-language-alist :key 'cddr :test 'member)
-  (let ((seq antlr-language-alist)
+(defun antlr-language-option (search)
+  "Find language in `antlr-language-alist' for language option.
+If SEARCH is non-nil, find element for language option.  Otherwise, find
+the default language."
+  (let ((value (and search
+		    (save-excursion
+		      (goto-char (point-min))
+		      (re-search-forward (cdr antlr-language-limit-n-regexp)
+					 (car antlr-language-limit-n-regexp)
+					 t))
+		    (match-string 1)))
+	(seq antlr-language-alist)
 	r)
+    ;; Like (find-VALUE antlr-language-alist :key 'cddr :test 'member)
     (while seq
       (setq r (pop seq))
-      (if (member option-value (cddr r))
+      (if (member value (cddr r))
 	  (setq seq nil)		; stop
 	(setq r nil)))			; no result yet
-    r))
+    (car r)))
+

 ;;;###autoload
 (defun antlr-mode ()
@@ -1463,14 +2438,8 @@
   (use-local-map antlr-mode-map)
   (make-local-variable 'antlr-language)
   (unless antlr-language
-    (save-excursion
-      (goto-char (point-min))
-      (setq antlr-language
-	    (car (or (and (re-search-forward (cdr antlr-language-limit-n-regexp)
-					(car antlr-language-limit-n-regexp)
-					t)
-			  (antlr-language-for-option (match-string 1)))
-		     (antlr-language-for-option nil))))))
+    (setq antlr-language
+	  (or (antlr-language-option t) (antlr-language-option nil))))
   (if (stringp (cadr (assq antlr-language antlr-language-alist)))
       (setq mode-name
 	    (concat "Antlr."
@@ -1540,5 +2509,14 @@
 ; LocalWords:  VOCAB EVOCAB Antlr's TokenTypes exportVocab incl excl SUPERS gen
 ; LocalWords:  VOCABS IVOCAB exportVocabs importVocabs superclasses vocab kens
 ; LocalWords:  sclass evocab ivocab importVocab deps glibs supers sep dep lang
+; LocalWords:  htmlize subrule jde Sather sather eiffel SGML's XYYZZ namespace
+; LocalWords:  mangleLiteralPrefix namespaceStd namespaceAntlr genHashLines AST
+; LocalWords:  testLiterals defaultErrorHandler codeGenMakeSwitchThreshold XXX
+; LocalWords:  codeGenBitsetTestThreshold bitset analyzerDebug codeGenDebug boc
+; LocalWords:  buildAST ASTLabelType charVocabulary caseSensitive autoTokenDef
+; LocalWords:  caseSensitiveLiterals classHeaderSuffix keywordsMeltTo NAMEs LL
+; LocalWords:  warnWhenFollowAmbig generateAmbigWarnings ARGs tokenrefs withp
+; LocalWords:  outsidep existsp JOR sert endif se ndef mport nclude pragma LE
+; LocalWords:  TION ASE RSION OMPT ava serting VEL mparison AMMAR

 ;;; antlr-mode.el ends here