Version 2.2b

2 files changed, 575 insertions, 320 deletions

diff --git a/lisp/ChangeLog b/lisp/ChangeLog
index 45dae9f96dd..8d3617561ab 100644
--- a/lisp/ChangeLog
+++ b/lisp/ChangeLog
@@ -1,3 +1,108 @@
+2003-01-31  Christoph Wedler  <Christoph.Wedler@sap.com>
+
+        * antlr-mode.el: Bug fixes, miscellaneous.
+        (antlr-mode): Make major mode work with cc-mode-5.29 or higher,
+        make it more rubust against changes in cc-mode's style variables
+        by using `boundp' and function `c-init-language-vars' if defined.
+        (antlr-c++-mode-extra): Only ask if language is not "Cpp".
+        (antlr-read-value): With completion, ignore case.
+        (antlr-run-tool-interactive): New function.
+        (antlr-run-tool): Use it for `interactive' specification.
+
+        * antlr-mode.el: Simplify Emacs/XEmacs compatibility.
+        (cond-emacs-xemacs): New compile-time macro.
+        (defunx): New compile-time macro.
+        (ignore-errors-x): New compile-time macro.
+        (save-buffer-state-x): New compile-time macro.
+
+        (antlr-scan-sexps, antlr-simple-scan-sexps): Deletia.
+        (antlr-scan-lists, antlr-simple-scan-sexps): Deletia.
+        (antlr-simple-default-directory): Deletia.
+        (antlr-default-directory): Define directly.
+        (antlr-simple-read-shell-command): Deletia.
+        (antlr-read-shell-command): Define directly.
+        (antlr-simple-with-displaying-help-buffer): Deletia.
+        (antlr-with-displaying-help-buffer): Define directly.
+        (antlr-fast-invalidate-context-cache): Deletia.
+        (antlr-slow-invalidate-context-cache): Deletia.
+        (antlr-invalidate-context-cache): Define directly.
+        (antlr-fast-syntactic-context): Deletia.
+        (antlr-slow-syntactic-context): Deletia.
+        (antlr-syntactic-context): Define directly.
+
+        (antlr-mode-menu): Use new macros.
+        (antlr-font-lock-additional-keywords): Ditto.
+        (antlr-skip-sexps): Ditto.
+        (antlr-end-of-rule): Ditto.
+        (antlr-beginning-of-rule): Ditto.
+        (antlr-end-of-body): Ditto.
+        (antlr-beginning-of-body): Ditto.
+        (antlr-hide-actions): Ditto.
+        (antlr-option-kind): Ditto.
+
+        * antlr-mode.el: In Emacs, use face attribute :weight, not :bold.
+        (antlr-font-lock-keyword-face): Use new macros.
+        (antlr-font-lock-syntax-face): Ditto.
+        (antlr-font-lock-ruledef-face): Ditto.
+        (antlr-font-lock-tokendef-face): Ditto.
+        (antlr-font-lock-literal-face): Ditto.
+
+        Changes from 2002-05-24:
+
+        * antlr-mode.el: Version 2.2a.
+
+        Changes from 2002-05-03:
+
+        * antlr-mode.el: Make context parsing faster on Emacs, for faster
+        syntax highlighting, indentation and imenu support.
+        Suggested by Aaron Davies <adavies42@users.sourceforge.net>.
+        (antlr-slow-context-cache): New variable.
+        (antlr-slow-syntactic-context): Use cache.
+        (antlr-slow-cache-enabling-symbol): New internal variable.
+        (antlr-slow-cache-diff-threshold): New variable.
+        (antlr-fast-invalidate-context-cache): Renamed from
+        antlr-xemacs-bug-workaround.
+        (antlr-imenu-create-index-function): Search from beginning.
+
+        * antlr-mode.el: More sophisticated indentation, i.e., use the
+        indentation engine of cc-mode for most actions.
+        (antlr-c-common-init): Allow nil for `antlr-indent-style'.
+        (antlr-indent-line): Use indentation engine of cc-mode more often.
+        (antlr-indent-at-bol-alist): Only used for header actions.
+        (antlr-disabling-cc-syntactic-symbols): New variable.
+        (antlr-indent-item-regexp): Delete stuff for actions.
+        (antlr-indent-at-bol-alist): With language "Java", indent
+        "package" and "import" at column 0 in header part.
+
+        * antlr-mode.el (antlr-simple-default-directory): Define.
+        (antlr-simple-read-shell-command): Define.
+        (antlr-simple-with-displaying-help-buffer): Define.
+        (antlr-simple-scan-sexps, antlr-simple-scan-lists):
+        Renamed from antlr-scan-{sexps,lists}-internal.
+
+        Changes from 2002-02-28:
+
+        * antlr-mode: Version 2.2 is released.
+
+        * antlr-mode.el (antlr): Moved to SourceForge.net
+
+        Changes from 2002-02-28:
+
+        * antlr-mode.el: Minor bug fixes: insert options and indentation.
+        (antlr-option-location): Don't use point as position where to
+        insert options if point is in comment.
+        (antlr-mode): Don't set style here.
+        (antlr-c-common-init): Set style here.  If boundp, set
+        `c-current-comment-prefix' to not break indentation in comments.
+        Hm, I should probably split `c-common-init' from cc-mode into two
+        parts, one of which I could use for antlr-mode.el.
+
+        Changes from 2002-01-31:
+
+        * antlr-mode.el (antlr-font-lock-additional-keywords): Also
+        hightlight `~' with `antlr-font-lock-syntax-face'.
+        Suggested by Helmut Neukirchen <neukirchen@itm.mu-luebeck.de>.
+
 2003-01-31  Joe Buehler  <jhpb@draco.hekimian.com>
 
         * comint.el:
diff --git a/lisp/progmodes/antlr-mode.el b/lisp/progmodes/antlr-mode.el
index b87c7c52b39..1d1fbfab252 100644
--- a/lisp/progmodes/antlr-mode.el
+++ b/lisp/progmodes/antlr-mode.el
@@ -1,11 +1,11 @@
 ;;; antlr-mode.el --- major mode for ANTLR grammar files
 
-;; Copyright (C) 1999, 2000, 2001 Free Software Foundation, Inc.
+;; Copyright (C) 1999, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
 ;;
 ;; Author: Christoph.Wedler@sap.com
 ;; Keywords: languages
-;; Version: 2.1
-;; X-URL: http://antlr-mode.sf.net
+;; Version: (see `antlr-version' below)
+;; X-URL: http://antlr-mode.sourceforge.net/
 
 ;; This file is part of GNU Emacs.
 
@@ -26,60 +26,22 @@
 
 ;;; Commentary:
 
-;; 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 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.
-;;  * Support to insert/change file/grammar/rule/subrule options.
-;;  * Run ANTLR from within Emacs, create Makefile dependencies.
-
-;; 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.  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.
-
-;; 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
-;; 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:
+;; The Emacs package ANTLR-Mode provides: syntax highlighting for ANTLR grammar
+;; files, automatic indentation, menus containing rule/token definitions and
+;; supported options and various other things like running ANTLR from within
+;; Emacs.
 
+;; For details, check <http://antlr-mode.sourceforge.net/> or, if you prefer
+;; the manual style, follow all commands mentioned in the documentation of
+;; `antlr-mode'.  ANTLR is a LL(k)-based recognition tool which generates
+;; lexers, parsers and tree transformers in Java, C++ or Sather and can be
+;; found at <http://www.antlr.org/>.
+
+;; Bug fixes, bug reports, improvements, and suggestions for the newest version
+;; are strongly appreciated.
+
+;; To-do/Wish-list:
+;;
 ;;  * 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
@@ -89,7 +51,7 @@
 ;;  * 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
@@ -101,10 +63,6 @@
 ;;    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:
-;;   http://antlr-mode.sf.net
-
 ;;; Installation:
 
 ;; This file requires Emacs-20.3, XEmacs-20.4 or higher and package cc-mode.
@@ -116,10 +74,6 @@
 ;;   (add-hook 'speedbar-load-hook  ; would be too late in antlr-mode.el
 ;;             (lambda () (speedbar-add-supported-extension ".g")))
 
-;; If you edit ANTLR's source files, you might also want to use
-;;   (autoload 'antlr-set-tabs "antlr-mode")
-;;   (add-hook 'java-mode-hook 'antlr-set-tabs)
-
 ;; 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).
 
@@ -128,48 +82,103 @@
 ;;; Code:
 
 (provide 'antlr-mode)
+(require 'easymenu)
+
+;; General Emacs/XEmacs-compatibility compile-time macros
+(eval-when-compile
+  (require 'cl)
+  (defmacro cond-emacs-xemacs (&rest args)
+    (cond-emacs-xemacs-macfn 
+     args "`cond-emacs-xemacs' must return exactly one element"))
+  (defun cond-emacs-xemacs-macfn (args &optional msg)
+    (if (atom args) args
+      (and (eq (car args) :@) (null msg) ; (:@ ...spliced...)
+           (setq args (cdr args)
+                 msg "(:@ ....) must return exactly one element"))
+      (let ((ignore (if (string-match "XEmacs" emacs-version) :EMACS :XEMACS))
+            (mode :BOTH) code)
+        (while (consp args)
+          (if (memq (car args) '(:EMACS :XEMACS :BOTH)) (setq mode (pop args)))
+          (if (atom args)
+              (or args (error "Used selector %s without elements" mode))
+            (or (eq ignore mode)
+                (push (cond-emacs-xemacs-macfn (car args)) code))
+            (pop args)))
+        (cond (msg (if (or args (cdr code)) (error msg) (car code)))
+              ((or (null args) (eq ignore mode)) (nreverse code))
+              (t (nconc (nreverse code) args))))))
+  ;; Emacs/XEmacs-compatibility `defun': remove interactive "_" for Emacs, use
+  ;; existing functions when they are `fboundp', provide shortcuts if they are
+  ;; known to be defined in a specific Emacs branch (for short .elc)
+  (defmacro defunx (name arglist &rest definition)
+    (let ((xemacsp (string-match "XEmacs" emacs-version)) reuses)
+      (while (memq (car definition)
+                   '(:try :emacs-and-try :xemacs-and-try))
+        (if (eq (pop definition) (if xemacsp :xemacs-and-try :emacs-and-try))
+            (setq reuses (car definition)
+                  definition nil)
+          (push (pop definition) reuses)))
+      (if (and reuses (symbolp reuses))
+          `(defalias ',name ',reuses)
+        (let* ((docstring (if (stringp (car definition)) (pop definition)))
+               (spec (and (not xemacsp)
+                          (eq (car-safe (car definition)) 'interactive)
+                          (null (cddar definition))
+                          (cadar definition))))
+          (if (and (stringp spec)
+                   (not (string-equal spec ""))
+                   (eq (aref spec 0) ?_))
+              (setq definition
+                    (cons (if (string-equal spec "_")
+                              '(interactive)
+                            `(interactive ,(substring spec 1)))
+                          (cdr definition))))
+          (if (null reuses)
+              `(defun ,name ,arglist ,docstring
+                 ,@(cond-emacs-xemacs-macfn definition))
+            ;; no dynamic docstring in this case
+            `(eval-and-compile          ; no warnings in Emacs
+               (defalias ',name
+                 (cond ,@(mapcar (lambda (func) `((fboundp ',func) ',func))
+                                 (nreverse reuses))
+                       (t ,(if definition
+                               `(lambda ,arglist ,docstring
+                                  ,@(cond-emacs-xemacs-macfn definition))
+                             'ignore))))))))))
+  (defmacro ignore-errors-x (&rest body)
+    (let ((specials '((scan-sexps . 4) (scan-lists . 5)))
+          spec nils)
+      (if (and (string-match "XEmacs" emacs-version)
+               (null (cdr body)) (consp (car body))
+               (setq spec (assq (caar body) specials))
+               (>= (setq nils (- (cdr spec) (length (car body)))) 0))
+          `(,@(car body) ,@(make-list nils nil) t)
+        `(ignore-errors ,@body)))))
+
+;; More compile-time-macros
+(eval-when-compile
+  (defmacro save-buffer-state-x (&rest body) ; similar to EMACS/lazy-lock.el
+    (let ((modified (gensym "save-buffer-state-x-modified-")))
+      `(let ((,modified (buffer-modified-p)))
+         (unwind-protect
+             (let ((buffer-undo-list t) (inhibit-read-only t)
+                   ,@(unless (string-match "XEmacs" emacs-version)
+                       '((inhibit-point-motion-hooks t) deactivate-mark))
+                   before-change-functions after-change-functions
+                   buffer-file-name buffer-file-truename)
+               ,@body)
+           (and (not ,modified) (buffer-modified-p)
+                (set-buffer-modified-p nil)))))))
+(put 'save-buffer-state-x 'lisp-indent-function 0)
+
+;; get rid of byte-compile warnings
 (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))
+  (ignore-errors (require 'cc-mode))
+  (ignore-errors (require 'font-lock))
+  (ignore-errors (require 'compile))
   (defvar outline-level) (defvar imenu-use-markers)
-  (defvar imenu-create-index-function))
-(eval-when-compile                      ; Emacs: cl, easymenu, XEmacs vars
-  (require 'cl)
-  (require 'easymenu)
-  (defvar zmacs-region-stays))
-(eval-when-compile                      ; XEmacs: Emacs vars
-  (defvar inhibit-point-motion-hooks) (defvar deactivate-mark))
-
-(eval-and-compile                       ; XEmacs functions, simplified
-  (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))
-  (if (fboundp 'read-shell-command)
-      (defalias 'antlr-read-shell-command 'read-shell-command)
-    (defun antlr-read-shell-command (prompt &optional initial-input history)
-      (read-from-minibuffer prompt initial-input nil nil
-                            (or history 'shell-command-history))))
-  (if (fboundp 'with-displaying-help-buffer)
-      (defalias 'antlr-with-displaying-help-buffer 'with-displaying-help-buffer)
-    (defun antlr-with-displaying-help-buffer (thunk &optional name)
-      (with-output-to-temp-buffer "*Help*"
-        (save-excursion (funcall thunk)))))
-  (if (and (fboundp 'buffer-syntactic-context)
-           (fboundp 'buffer-syntactic-context-depth))
-      (progn
-        (defalias 'antlr-invalidate-context-cache 'antlr-xemacs-bug-workaround)
-        (defalias 'antlr-syntactic-context 'antlr-fast-syntactic-context))
-    (defalias 'antlr-invalidate-context-cache 'ignore)
-    (defalias 'antlr-syntactic-context 'antlr-slow-syntactic-context)))
-
+  (defvar imenu-create-index-function)
+  (ignore-errors (defun c-init-language-vars)))
 
 
 ;;;;##########################################################################
@@ -181,11 +190,12 @@
   "Major mode for ANTLR grammar files."
   :group 'languages
   :link '(emacs-commentary-link "antlr-mode.el")
-  :link '(url-link "http://antlr-mode.sf.net")
+  :link '(url-link "http://antlr-mode.sourceforge.net/")
   :prefix "antlr-")
 
-(defconst antlr-version "2.1"
-  "ANTLR major mode version number.")
+(defconst antlr-version "2.2b"
+  "ANTLR major mode version number.
+Check <http://antlr-mode.sourceforge.net/> for the newest.")
 
 
 ;;;===========================================================================
@@ -272,12 +282,13 @@ ANTLR's and Java's indentation styles.  Used by `antlr-set-tabs'."
 
 (defcustom antlr-indent-style "java"
   "*If non-nil, cc-mode indentation style used for `antlr-mode'.
-See `c-set-style' for details."
+See `c-set-style' and for details, where the most interesting part in
+`c-style-alist' is the value of `c-basic-offset'."
   :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)
+  "[]}):;|&]" ; & is local ANTLR extension (SGML's and-connector)
   "Regexp matching lines which should be indented by one TAB less.
 See `antlr-indent-line' and command \\[antlr-indent-command]."
   :group 'antlr
@@ -285,17 +296,28 @@ See `antlr-indent-line' and command \\[antlr-indent-command]."
 
 (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\\)\\>"))
+  '((java-mode . "\\(package\\|import\\)\\>")
+    (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'."
+If `antlr-language' equals to a MODE, the line starting at the first
+non-whitespace is matched by the corresponding REGEXP, and the line is
+part of an header action, 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)))
 
+;; adopt indentation to cc-engine
+(defvar antlr-disabling-cc-syntactic-symbols
+  '(statement-block-intro
+    defun-block-intro topmost-intro statement-case-intro member-init-intro
+    arglist-intro brace-list-intro knr-argdecl-intro inher-intro
+    objc-method-intro
+    block-close defun-close class-close brace-list-close arglist-close
+    inline-close extern-lang-close namespace-close))
+
 
 ;;;===========================================================================
 ;;;  Options: customization
@@ -647,7 +669,7 @@ DIRECTORY is the name of the current directory.")
 ;;;  Menu
 ;;;===========================================================================
 
-(defcustom antlr-imenu-name t
+(defcustom antlr-imenu-name t ; (featurep 'xemacs) ; TODO: Emacs-21 bug?
   "*Non-nil, if a \"Index\" menu should be added to the menubar.
 If it is a string, it is used instead \"Index\".  Requires package
 imenu."
@@ -687,9 +709,10 @@ imenu."
 (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)))
+    ,@(if (cond-emacs-xemacs
+           :EMACS (and antlr-options-use-submenus
+                       (>= emacs-major-version 21))
+           :XEMACS antlr-options-use-submenus)
           `(("Insert File Option"
              :filter ,(lambda (x) (antlr-options-menu-filter 1 x)))
             ("Insert Grammar Option"
@@ -797,25 +820,33 @@ Do not change."
 
 (defvar antlr-font-lock-keyword-face 'antlr-font-lock-keyword-face)
 (defface antlr-font-lock-keyword-face
-  '((((class color) (background light)) (:foreground "black" :weight bold)))
+  (cond-emacs-xemacs
+   '((((class color) (background light))
+      (:foreground "black" :EMACS :weight bold :XEMACS :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" :weight bold)))
+  (cond-emacs-xemacs
+   '((((class color) (background light))
+      (:foreground "black" :EMACS :weight bold :XEMACS :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" :weight bold)))
+  (cond-emacs-xemacs
+   '((((class color) (background light))
+      (:foreground "blue" :EMACS :weight bold :XEMACS :bold t))))
   "ANTLR rule references (definition)."
   :group 'antlr)
 
 (defvar antlr-font-lock-tokendef-face 'antlr-font-lock-tokendef-face)
 (defface antlr-font-lock-tokendef-face
-  '((((class color) (background light)) (:foreground "blue" :weight bold)))
+  (cond-emacs-xemacs
+   '((((class color) (background light))
+      (:foreground "blue" :EMACS :weight bold :XEMACS :bold t))))
   "ANTLR token references (definition)."
   :group 'antlr)
 
@@ -833,7 +864,9 @@ Do not change."
 
 (defvar antlr-font-lock-literal-face 'antlr-font-lock-literal-face)
 (defface antlr-font-lock-literal-face
-  '((((class color) (background light)) (:foreground "brown4" :weight bold)))
+  (cond-emacs-xemacs
+   '((((class color) (background light))
+      (:foreground "brown4" :EMACS :weight bold :XEMACS :bold t))))
   "ANTLR special literal tokens.
 It is used to highlight strings matched by the first regexp group of
 `antlr-font-lock-literal-regexp'."
@@ -853,47 +886,48 @@ group.  The string matched by the first group is highlighted with
   "Regexp matching class headers.")
 
 (defvar antlr-font-lock-additional-keywords
-  `((antlr-invalidate-context-cache)
-    ("\\$setType[ \t]*(\\([A-Za-z\300-\326\330-\337]\\sw*\\))"
-     (1 antlr-font-lock-tokendef-face))
-    ("\\$\\sw+" (0 font-lock-keyword-face))
-    ;; the tokens are already fontified as string/docstrings:
-    (,(lambda (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 (featurep 'xemacs) '((0 nil)))) ; XEmacs bug workaround
-    (,(lambda (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)
-     (4 (if (member (match-string 4) '("Lexer" "Parser" "TreeParser"))
-            'antlr-font-lock-keyword-face
-          'font-lock-type-face)))
-    (,(lambda (limit)
-        (antlr-re-search-forward
-         "\\<\\(header\\|options\\|tokens\\|exception\\|catch\\|returns\\)\\>"
-         limit))
+  (cond-emacs-xemacs
+   `((antlr-invalidate-context-cache)
+     ("\\$setType[ \t]*(\\([A-Za-z\300-\326\330-\337]\\sw*\\))"
+      (1 antlr-font-lock-tokendef-face))
+     ("\\$\\sw+" (0 font-lock-keyword-face))
+     ;; the tokens are already fontified as string/docstrings:
+     (,(lambda (limit)
+         (if antlr-font-lock-literal-regexp
+             (antlr-re-search-forward antlr-font-lock-literal-regexp limit)))
+      (1 antlr-font-lock-literal-face t)
+      :XEMACS (0 nil))                  ; XEmacs bug workaround
+     (,(lambda (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)
+      (4 (if (member (match-string 4) '("Lexer" "Parser" "TreeParser"))
+             'antlr-font-lock-keyword-face
+           'font-lock-type-face)))
+     (,(lambda (limit)
+         (antlr-re-search-forward
+          "\\<\\(header\\|options\\|tokens\\|exception\\|catch\\|returns\\)\\>"
+          limit))
      (1 antlr-font-lock-keyword-face))
-    (,(lambda (limit)
-        (antlr-re-search-forward
-         "^\\(private\\|public\\|protected\\)\\>[ \t]*\\(\\(\\sw+[ \t]*\\(:\\)?\\)\\)?"
-         limit))
+     (,(lambda (limit)
+         (antlr-re-search-forward
+          "^\\(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)
      (4 antlr-font-lock-syntax-face nil t))
-    (,(lambda (limit)
-        (antlr-re-search-forward "^\\(\\sw+\\)[ \t]*\\(:\\)?" limit))
+     (,(lambda (limit)
+         (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)
      (2 antlr-font-lock-syntax-face nil t))
-    (,(lambda (limit)
-        ;; v:ruleref and v:"literal" is allowed...
-        (antlr-re-search-forward "\\(\\sw+\\)[ \t]*\\([=:]\\)?" limit))
+     (,(lambda (limit)
+         ;; 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
@@ -902,9 +936,9 @@ group.  The string matched by the first group is highlighted with
               'antlr-font-lock-tokenref-face
             'antlr-font-lock-ruleref-face)))
      (2 antlr-font-lock-default-face nil t))
-    (,(lambda (limit)
-        (antlr-re-search-forward "[|&:;(]\\|)\\([*+?]\\|=>\\)?" limit))
-     (0 'antlr-font-lock-syntax-face)))
+     (,(lambda (limit)
+         (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.")
 
@@ -939,6 +973,16 @@ not to confuse their context_cache.")
   "Abbreviation table used in `antlr-mode' buffers.")
 (define-abbrev-table 'antlr-mode-abbrev-table ())
 
+(defvar antlr-slow-cache-enabling-symbol 'loudly
+;; Emacs' font-lock changes buffer's tick counter, therefore this value should
+;; be a parameter of a font-lock function, but not any other variable of
+;; functions which call `antlr-slow-syntactic-context'.
+  "If value is a bound symbol, cache will be used even with text changes.
+This is no user option.  Used for `antlr-slow-syntactic-context'.")
+
+(defvar antlr-slow-cache-diff-threshold 5000
+  "Maximum distance between `point' and cache position for cache use.
+Used for `antlr-slow-syntactic-context'.")
 
 
 ;;;;##########################################################################
@@ -948,7 +992,7 @@ not to confuse their context_cache.")
 
 
 ;;;===========================================================================
-;;;  Syntax functions -- Emacs vs XEmacs dependent
+;;;  Syntax functions -- Emacs vs XEmacs dependent, part 1
 ;;;===========================================================================
 
 ;; From help.el (XEmacs-21.1), without `copy-syntax-table'
@@ -961,62 +1005,140 @@ not to confuse their context_cache.")
 (put 'antlr-with-syntax-table 'lisp-indent-function 1)
 (put 'antlr-with-syntax-table 'edebug-form-spec '(form body))
 
-(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, `antlr-scan-sexps-internal' will
-return nil instead of signaling an error."
-  (if no-error
-      (condition-case nil
-          (scan-sexps from count)
-        (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)
+(defunx antlr-default-directory ()
+  :xemacs-and-try default-directory
+  "Return `default-directory'."
+  default-directory)
+
+;; Check Emacs-21.1 simple.el, `shell-command'.
+(defunx antlr-read-shell-command (prompt &optional initial-input history)
+  :xemacs-and-try read-shell-command
+  "Read a string from the minibuffer, using `shell-command-history'."
+  (read-from-minibuffer prompt initial-input nil nil
+                        (or history 'shell-command-history)))
+
+(defunx antlr-with-displaying-help-buffer (thunk &optional name)
+  :xemacs-and-try with-displaying-help-buffer
+  "Make a help buffer and call `thunk' there."
+  (with-output-to-temp-buffer "*Help*"
+    (save-excursion (funcall thunk))))
+
+
+;;;===========================================================================
+;;;  Context cache
+;;;===========================================================================
+
+(defvar antlr-slow-context-cache nil "Internal.")
+
+;;;(defvar antlr-statistics-full-neg 0)
+;;;(defvar antlr-statistics-full-diff 0)
+;;;(defvar antlr-statistics-full-other 0)
+;;;(defvar antlr-statistics-cache 0)
+;;;(defvar antlr-statistics-inval 0)
+
+(defunx antlr-invalidate-context-cache (&rest dummies)
 ;; checkdoc-params: (dummies)
-  "Invalidate context_cache for syntactical context information."
-  ;; XEmacs bug workaround
+  "Invalidate context cache for syntactical context information."
+  :XEMACS                               ; XEmacs bug workaround
   (save-excursion
     (set-buffer (get-buffer-create " ANTLR XEmacs bug workaround"))
-    (buffer-syntactic-context-depth))
-  nil)
+    (buffer-syntactic-context-depth)
+    nil)
+  :EMACS
+;;;  (incf antlr-statistics-inval)
+  (setq antlr-slow-context-cache nil))
 
-(defun antlr-fast-syntactic-context ()
+(defunx antlr-syntactic-context ()
   "Return some syntactic context information.
 Return `string' if point is within a string, `block-comment' or
 `comment' is point is within a comment or the depth within all
 parenthesis-syntax delimiters at point otherwise.
 WARNING: this may alter `match-data'."
-  (or (buffer-syntactic-context) (buffer-syntactic-context-depth)))
-
-(defun antlr-slow-syntactic-context ()
-  "Return some syntactic context information.
-Return `string' if point is within a string, `block-comment' or
-`comment' is point is within a comment or the depth within all
-parenthesis-syntax delimiters at point otherwise.
-WARNING: this may alter `match-data'."
-  (let ((orig (point)))
-    (beginning-of-defun)
-    (let ((state (parse-partial-sexp (point) orig)))
-      (goto-char orig)
-      (cond ((nth 3 state) 'string)
-            ((nth 4 state) 'comment)    ; block-comment? -- we don't care
-            (t (car state))))))
+  :XEMACS
+  (or (buffer-syntactic-context) (buffer-syntactic-context-depth))
+  :EMACS
+  (let ((orig (point)) diff state
+        ;; Arg, Emacs' (buffer-modified-tick) changes with font-lock.  Use
+        ;; hack that `loudly' is bound during font-locking => cache use will
+        ;; increase from 7% to 99.99% during font-locking.
+        (tick (or (boundp antlr-slow-cache-enabling-symbol)
+                  (buffer-modified-tick))))
+    (if (and (cdr antlr-slow-context-cache)
+             (>= (setq diff (- orig (cadr antlr-slow-context-cache))) 0)
+             (< diff antlr-slow-cache-diff-threshold)
+             (eq (current-buffer) (caar antlr-slow-context-cache))
+             (eq tick (cdar antlr-slow-context-cache)))
+        ;; (setq antlr-statistics-cache (1+ antlr-statistics-cache) ...)
+        (setq state (parse-partial-sexp (cadr antlr-slow-context-cache) orig
+                                        nil nil
+                                        (cddr antlr-slow-context-cache)))
+      (if (>= orig antlr-slow-cache-diff-threshold)
+          (beginning-of-defun)
+        (goto-char (point-min)))
+;;;      (cond ((and diff (< diff 0)) (incf antlr-statistics-full-neg))
+;;;         ((and diff (>= diff 3000)) (incf antlr-statistics-full-diff))
+;;;         (t (incf antlr-statistics-full-other)))
+      (setq state (parse-partial-sexp (point) orig)))
+    (goto-char orig)
+    (if antlr-slow-context-cache
+        (setcdr antlr-slow-context-cache (cons orig state))
+      (setq antlr-slow-context-cache
+            (cons (cons (current-buffer) tick)
+                  (cons orig state))))
+    (cond ((nth 3 state) 'string)
+          ((nth 4 state) 'comment)      ; block-comment? -- we don't care
+          (t (car state)))))
+
+;;;  (incf (aref antlr-statistics 2))
+;;;  (unless (and (eq (current-buffer)
+;;;                (caar antlr-slow-context-cache))
+;;;            (eq (buffer-modified-tick)
+;;;                (cdar antlr-slow-context-cache)))
+;;;    (incf (aref antlr-statistics 1))
+;;;    (setq antlr-slow-context-cache nil))
+;;;  (let* ((orig (point))
+;;;      (base (cadr antlr-slow-context-cache))
+;;;      (curr (cddr antlr-slow-context-cache))
+;;;      (state (cond ((eq orig (car curr)) (cdr curr))
+;;;                   ((eq orig (car base)) (cdr base))))
+;;;      diff diff2)
+;;;    (unless state
+;;;      (incf (aref antlr-statistics 3))
+;;;      (when curr
+;;;     (if (< (setq diff  (abs (- orig (car curr))))
+;;;            (setq diff2 (abs (- orig (car base)))))
+;;;         (setq state curr)
+;;;       (setq state base
+;;;             diff  diff2))
+;;;     (if (or (>= (1+ diff) (point)) (>= diff 3000))
+;;;         (setq state nil)))          ; start from bod/bob
+;;;      (if state
+;;;       (setq state
+;;;             (parse-partial-sexp (car state) orig nil nil (cdr state)))
+;;;     (if (>= orig 3000) (beginning-of-defun) (goto-char (point-min)))
+;;;     (incf (aref antlr-statistics 4))
+;;;     (setq cw (list orig (point) base curr))
+;;;     (setq state (parse-partial-sexp (point) orig)))
+;;;      (goto-char orig)
+;;;      (if antlr-slow-context-cache
+;;;       (setcdr (cdr antlr-slow-context-cache) (cons orig state))
+;;;     (setq antlr-slow-context-cache
+;;;           (cons (cons (current-buffer) (buffer-modified-tick))
+;;;                 (cons (cons orig state) (cons orig state))))))
+;;;    (cond ((nth 3 state) 'string)
+;;;       ((nth 4 state) 'comment)      ; block-comment? -- we don't care
+;;;       (t (car state)))))
+
+;;;    (beginning-of-defun)
+;;;    (let ((state (parse-partial-sexp (point) orig)))
+;;;      (goto-char orig)
+;;;      (cond ((nth 3 state) 'string)
+;;;         ((nth 4 state) 'comment)    ; block-comment? -- we don't care
+;;;         (t (car state))))))
 
 
 ;;;===========================================================================
-;;;  Misc functions
+;;;  Miscellaneous functions
 ;;;===========================================================================
 
 (defun antlr-upcase-p (char)
@@ -1066,7 +1188,7 @@ strings and actions/semantic predicates."
 (defsubst antlr-skip-sexps (count)
   "Skip the next COUNT balanced expressions and the comments after it.
 Return position before the comments after the last expression."
-  (goto-char (or (antlr-scan-sexps (point) count nil t) (point-max)))
+  (goto-char (or (ignore-errors-x (scan-sexps (point) count)) (point-max)))
   (prog1 (point)
     (c-forward-syntactic-ws)))
 
@@ -1104,19 +1226,15 @@ See `antlr-font-lock-additional-keywords', `antlr-language' and
 IF TOKENREFS-ONLY is non-nil, just return alist with tokenref names."
   (let ((items nil)
         (classes nil)
-        (semi (point-max)))
-    ;; Using `imenu-progress-message' would require imenu for compilation --
-    ;; nobody is missing these messages...
+        (continue t))
+    ;; Using `imenu-progress-message' would require imenu for compilation, but
+    ;; nobody is missing these messages.  The generic imenu function searches
+    ;; backward, which is slower and more likely not to work during editing.
     (antlr-with-syntax-table antlr-action-syntax-table
-      ;; We stick to the imenu standard and search backwards, although I don't
-      ;; think this is right.  It is slower and more likely not to work during
-      ;; editing (you are more likely to add functions to the end of the file).
-      (while semi
-        (goto-char semi)
-        (setq semi (antlr-search-backward ";"))
-        (if semi
-            (progn (forward-char) (antlr-skip-exception-part t))
-          (antlr-skip-file-prelude t))
+      (antlr-invalidate-context-cache)
+      (goto-char (point-min))
+      (antlr-skip-file-prelude t)
+      (while continue
         (if (looking-at "{") (antlr-skip-sexps 1))
         (if (looking-at antlr-class-header-regexp)
             (or tokenrefs-only
@@ -1135,8 +1253,12 @@ IF TOKENREFS-ONLY is non-nil, just return alist with tokenref names."
                           (if imenu-use-markers
                               (copy-marker (match-beginning 0))
                             (match-beginning 0)))
-                    items))))))
-    (if classes (cons (cons "Classes" classes) items) items)))
+                    items))))
+        (if (setq continue (antlr-search-forward ";"))
+            (antlr-skip-exception-part t))))
+    (if classes
+        (cons (cons "Classes" (nreverse classes)) (nreverse items))
+      (nreverse items))))
 
 
 ;;;===========================================================================
@@ -1255,35 +1377,33 @@ rule."
     (antlr-with-syntax-table antlr-action-syntax-table
       (not (antlr-outside-rule-p)))))
 
-(defun antlr-end-of-rule (&optional arg)
+(defunx antlr-end-of-rule (&optional arg)
   "Move forward to next end of rule.  Do it ARG [default: 1] many times.
 A grammar class header and the file prelude are also considered as a
 rule.  Negative argument ARG means move back to ARGth preceding end of
 rule.  If ARG is zero, run `antlr-end-of-body'."
-  (interactive "p")
+  (interactive "_p")
   (if (zerop arg)
       (antlr-end-of-body)
     (antlr-with-syntax-table antlr-action-syntax-table
-      (antlr-next-rule arg nil))
-    (setq zmacs-region-stays t)))
+      (antlr-next-rule arg nil))))
 
-(defun antlr-beginning-of-rule (&optional arg)
+(defunx antlr-beginning-of-rule (&optional arg)
   "Move backward to preceding beginning of rule.  Do it ARG many times.
 A grammar class header and the file prelude are also considered as a
 rule.  Negative argument ARG means move forward to ARGth next beginning
 of rule.  If ARG is zero, run `antlr-beginning-of-body'."
-  (interactive "p")
+  (interactive "_p")
   (if (zerop arg)
       (antlr-beginning-of-body)
     (antlr-with-syntax-table antlr-action-syntax-table
-      (antlr-next-rule (- arg) t))
-    (setq zmacs-region-stays t)))
+      (antlr-next-rule (- arg) t))))
 
-(defun antlr-end-of-body (&optional msg)
+(defunx antlr-end-of-body (&optional msg)
   "Move to position after the `;' of the current rule.
 A grammar class header is also considered as a rule.  With optional
 prefix arg MSG, move to `:'."
-  (interactive)
+  (interactive "_")
   (antlr-with-syntax-table antlr-action-syntax-table
     (let ((orig (point)))
       (if (antlr-outside-rule-p)
@@ -1300,12 +1420,11 @@ prefix arg MSG, move to `:'."
                           (or (antlr-search-forward ":") (point-max))))
             (goto-char orig)
             (error msg))
-          (c-forward-syntactic-ws)))))
-  (setq zmacs-region-stays t))
+          (c-forward-syntactic-ws))))))
 
-(defun antlr-beginning-of-body ()
+(defunx antlr-beginning-of-body ()
   "Move to the first element after the `:' of the current rule."
-  (interactive)
+  (interactive "_")
   (antlr-end-of-body "Class headers and the file prelude are without `:'"))
 
 
@@ -1342,12 +1461,7 @@ actions if ARG is 0 or negative.  See `antlr-action-visibility'.
 
 Display a message unless optional argument SILENT is non-nil."
   (interactive "p")
-  ;; from Emacs/lazy-lock: `save-buffer-state'
-  (let ((modified (buffer-modified-p))
-        (buffer-undo-list t) (inhibit-read-only t)
-        (inhibit-point-motion-hooks t) deactivate-mark ; Emacs only
-        before-change-functions after-change-functions
-        buffer-file-name buffer-file-truename)
+  (save-buffer-state-x
     (if (> arg 0)
         (let ((regexp (if (= arg 1) "[]}]" "}"))
               (diff (and antlr-action-visibility
@@ -1358,7 +1472,7 @@ Display a message unless optional argument SILENT is non-nil."
             (antlr-with-syntax-table antlr-action-syntax-table
               (antlr-invalidate-context-cache)
               (while (antlr-re-search-forward regexp nil)
-                (let ((beg (antlr-scan-sexps (point) -1 nil t)))
+                (let ((beg (ignore-errors-x (scan-sexps (point) -1))))
                   (when beg
                     (if diff            ; braces are visible
                         (if (> (point) (+ beg diff))
@@ -1379,9 +1493,7 @@ Display a message unless optional argument SILENT is non-nil."
       (remove-text-properties (point-min) (point-max)
                               '(invisible nil intangible nil))
       (or silent
-          (message "Unhide all actions (including arguments)...done")))
-    (and (not modified) (buffer-modified-p)
-         (set-buffer-modified-p nil))))
+          (message "Unhide all actions (including arguments)...done")))))
 
 
 ;;;===========================================================================
@@ -1416,7 +1528,7 @@ Inserting an option with this command works as follows:
     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
+in `antlr-options-alists'.  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.
@@ -1553,7 +1665,7 @@ like \(AREA \. PLACE), see `antlr-option-location'."
               (cond ((null pos) 'error)
                     ((looking-at "options[ \t\n]*{")
                      (goto-char (match-end 0))
-                     (setq pos (antlr-scan-lists (point) 1 1 nil t))
+                     (setq pos (ignore-errors-x (scan-lists (point) 1 1)))
                      (antlr-option-location orig min0 max0
                                             (point)
                                             (if pos (1- pos) (point-max))
@@ -1636,8 +1748,12 @@ 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
+        (cond ((and (<= min-area orig) (<= orig max-area)
+                    (save-excursion
+                      (goto-char orig)
+                      (not (memq (antlr-syntactic-context)
+                                 '(comment block-comment)))))
+               ;; point in options area and not in comment
                (list orig))
               ((and (null withp) (<= min-vis min-area) (<= min-area max-vis))
                ;; use start of options area (only if not `withp')
@@ -1873,7 +1989,8 @@ 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)
+  (let* ((completion-ignore-case t)     ; dynamic
+         (table0 (and (or table table-x)
                       (append table-x
                               (if (functionp table) (funcall table) table))))
          (input (if table0
@@ -1924,6 +2041,7 @@ Ask user \(\"y or n\"), if a C++ only option is going to be inserted but
 
 Called in PHASE `before-input', see `antlr-options-alists'."
   (and (eq phase 'before-input)
+       (not (eq antlr-language 'c++-mode))
        (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)))))
@@ -1949,7 +2067,7 @@ Each SUPER is a super-grammar class where USE-EVOCAB-P indicates whether
 its export vocabulary is used as an import vocabulary."
   (unless buffer-file-name
     (error "Grammar buffer does not visit a file"))
-  (let (classes exportVocabs importVocabs superclasses default-vocab)
+  (let (classes export-vocabs import-vocabs superclasses default-vocab)
     (antlr-with-syntax-table antlr-action-syntax-table
       (goto-char (point-min))
       (while (antlr-re-search-forward antlr-class-header-regexp nil)
@@ -1988,13 +2106,13 @@ its export vocabulary is used as an import vocabulary."
           (push (cons class evocab) classes)
           ;; default export vocab is export vocab of first grammar in file:
           (or default-vocab (setq default-vocab evocab))
-          (or (member evocab exportVocabs) (push evocab exportVocabs))
+          (or (member evocab export-vocabs) (push evocab export-vocabs))
           (or (null ivocab)
-              (member ivocab importVocabs) (push ivocab importVocabs)))))
+              (member ivocab import-vocabs) (push ivocab import-vocabs)))))
     (if classes
         (list* (file-name-nondirectory buffer-file-name)
                (cons (nreverse classes) (nreverse superclasses))
-               (cons (nreverse exportVocabs) (nreverse importVocabs))
+               (cons (nreverse export-vocabs) (nreverse import-vocabs))
                antlr-language))))
 
 (defun antlr-directory-dependencies (dirname)
@@ -2088,29 +2206,33 @@ necessary.
 Save all buffers first unless optional value SAVED is non-nil.  When
 called interactively, the buffers are always saved, see also variable
 `antlr-ask-about-save'."
-  (interactive
-   ;; code in `interactive' is not compiled: do not use cl macros (`cdadr')
-   (let* ((supers (cdr (cadr (save-excursion
-                               (save-restriction
-                                 (widen)
-                                 (antlr-file-dependencies))))))
-          (glibs ""))
-     (when supers
-       (save-some-buffers (not antlr-ask-about-save) nil)
-       (setq glibs (car (antlr-superclasses-glibs
-                         supers
-                         (car (antlr-directory-dependencies
-                               (antlr-default-directory)))))))
-     (list (antlr-read-shell-command "Run Antlr on current file with: "
-                                     (concat antlr-tool-command glibs " "))
-           buffer-file-name
-           supers)))
+  (interactive (antlr-run-tool-interactive))
   (or saved (save-some-buffers (not antlr-ask-about-save)))
   (let ((default-directory (file-name-directory file)))
     (require 'compile)                  ; only `compile' autoload
     (compile-internal (concat command " " (file-name-nondirectory file))
                       "No more errors" "Antlr-Run")))
 
+(defun antlr-run-tool-interactive ()
+  ;; code in `interactive' is not compiled
+  "Interactive specification for `antlr-run-tool'.
+Use prefix argument ARG to return \(COMMAND FILE SAVED)."
+  (let* ((supers (cdadr (save-excursion
+                          (save-restriction
+                            (widen)
+                            (antlr-file-dependencies)))))
+         (glibs ""))
+    (when supers
+      (save-some-buffers (not antlr-ask-about-save) nil)
+      (setq glibs (car (antlr-superclasses-glibs
+                        supers
+                        (car (antlr-directory-dependencies
+                              (antlr-default-directory)))))))
+    (list (antlr-read-shell-command "Run Antlr on current file with: "
+                                    (concat antlr-tool-command glibs " "))
+          buffer-file-name
+          supers)))
+
 
 ;;;===========================================================================
 ;;;  Makefile creation
@@ -2230,16 +2352,19 @@ multiplied by:
 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 in actions except top-level actions in a header part or an option
+area are indented by `c-indent-line'.
+
+Lines in header actions are indented at column 0 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.
 
 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)
+          bol boi indent syntax cc-syntax)
       (widen)
       (beginning-of-line)
       (setq bol (point))
@@ -2253,11 +2378,6 @@ to a lesser extent, `antlr-tab-offset-alist'."
         (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))
@@ -2268,20 +2388,45 @@ to a lesser extent, `antlr-tab-offset-alist'."
                (forward-char)
                (antlr-skip-exception-part nil)
                (setq indent (if (> (point) boi) 1 0))))) ; in exception part?
-      ;; compute the corresponding indentation and indent --------------------
+      ;; check whether to use indentation engine of cc-mode ------------------
+      (antlr-invalidate-context-cache)
+      (goto-char boi)
+      (when (and indent (> syntax 0))
+        (cond ((> syntax 1)             ; block in action => use cc-mode
+               (setq indent nil))
+              ((and (= indent 0)
+                    (assq antlr-language antlr-indent-at-bol-alist)
+                    (looking-at (cdr (assq antlr-language
+                                           antlr-indent-at-bol-alist))))
+               (setq syntax 'bol))
+              ((setq cc-syntax (c-guess-basic-syntax))
+               (let ((cc cc-syntax) symbol)
+                 (while (setq symbol (pop cc))
+                   (when (cdr symbol)
+                     (or (memq (car symbol)
+                               antlr-disabling-cc-syntactic-symbols)
+                         (setq indent nil))
+                     (setq cc nil)))))))
+;;;             ((= indent 1)           ; exception part => use cc-mode
+;;;              (setq indent nil))
+;;;             ((save-restriction      ; not in option part => cc-mode
+;;;                (goto-char (scan-lists (point) -1 1))
+;;;                (skip-chars-backward " \t\n")
+;;;                (narrow-to-region (point-min) (point))
+;;;                (not (re-search-backward "\\<options\\'" nil t)))
+;;;              (setq indent nil)))))
+        ;; 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.
+          ;; Use the indentation engine of cc-mode
           (progn
             (goto-char orig)
-            (and (eq antlr-indent-comment t)
-                 (not (eq syntax 'string))
-                 (c-indent-line)))
+            (if (or (numberp syntax)
+                    (if (eq syntax 'string) nil (eq antlr-indent-comment t)))
+                (c-indent-line cc-syntax)))
         ;; do it ourselves
         (goto-char boi)
         (unless (symbolp syntax)                ; direct indentation
-          (antlr-invalidate-context-cache)
+          ;;(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)))
@@ -2382,6 +2527,13 @@ ANTLR's syntax and influences the auto indentation, see
         comment-line-break-function 'c-comment-line-break-function
         adaptive-fill-regexp nil
         adaptive-fill-mode nil)
+  (c-set-style (or antlr-indent-style "gnu"))
+  (and (boundp 'c-current-comment-prefix) (boundp 'c-comment-prefix-regexp)
+       (setq c-current-comment-prefix
+             (if (listp c-comment-prefix-regexp)
+                 (cdr-safe (or (assoc major-mode c-comment-prefix-regexp)
+                               (assoc 'other c-comment-prefix-regexp)))
+               c-comment-prefix-regexp)))
   ;; we have to do something special for c-offsets-alist so that the
   ;; buffer local value has its own alist structure.
   (setq c-offsets-alist (copy-alist c-offsets-alist))
@@ -2403,7 +2555,7 @@ the default language."
                     (match-string 1)))
         (seq antlr-language-alist)
         r)
-    ;; Like (find-VALUE antlr-language-alist :key 'cddr :test 'member)
+    ;; Like (find VALUE antlr-language-alist :key 'cddr :test 'member)
     (while seq
       (setq r (pop seq))
       (if (member value (cddr r))
@@ -2417,7 +2569,7 @@ the default language."
   "Major mode for editing ANTLR grammar files.
 \\{antlr-mode-map}"
   (interactive)
-  (c-initialize-cc-mode)                ; for java syntax table
+  (c-initialize-cc-mode)                ; required when depending on cc-mode
   (kill-all-local-variables)
   ;; ANTLR specific ----------------------------------------------------------
   (setq major-mode 'antlr-mode
@@ -2448,25 +2600,39 @@ the default language."
   (antlr-c-common-init)
   (setq indent-line-function 'antlr-indent-line
         indent-region-function nil)     ; too lazy
+  (setq c-buffer-is-cc-mode antlr-language)
+  (if (fboundp 'c-init-language-vars)
+      (c-init-language-vars)            ; cc-mode >= v5.29
+    (let ((settings                     ; (cdr '(setq...)) will be optimized
+           (if (eq antlr-language 'c++-mode)
+               (cdr '(setq              ;' from `c++-mode' v5.20, v5.28
+                      c-keywords (c-identifier-re c-C++-keywords)
+                      c-conditional-key c-C++-conditional-key
+                      c-comment-start-regexp c-C++-comment-start-regexp
+                      c-class-key c-C++-class-key
+                      c-extra-toplevel-key c-C++-extra-toplevel-key
+                      c-access-key c-C++-access-key
+                      c-recognize-knr-p nil
+                      c-bitfield-key c-C-bitfield-key ; v5.28
+                      ))
+             (cdr '(setq                ; from `java-mode' v5.20, v5.28
+                    c-keywords (c-identifier-re c-Java-keywords)
+                    c-conditional-key c-Java-conditional-key
+                    c-comment-start-regexp c-Java-comment-start-regexp
+                    c-class-key c-Java-class-key
+                    c-method-key nil
+                    c-baseclass-key nil
+                    c-recognize-knr-p nil
+                    c-access-key c-Java-access-key ; v5.20
+                    c-inexpr-class-key c-Java-inexpr-class-key ; v5.28
+                    )))))
+      (while settings
+        (when (boundp (car settings))
+          (ignore-errors
+            (set (car settings) (eval (cadr settings)))))
+        (setq settings (cddr settings)))))
   (setq comment-start "// "
         comment-end "")
-  (c-set-style "java")
-  (if (eq antlr-language 'c++-mode)
-      (setq c-conditional-key c-C++-conditional-key
-            c-comment-start-regexp c-C++-comment-start-regexp
-            c-class-key c-C++-class-key
-            c-extra-toplevel-key c-C++-extra-toplevel-key
-            c-access-key c-C++-access-key
-            c-recognize-knr-p nil)
-    (setq c-conditional-key c-Java-conditional-key
-          c-comment-start-regexp c-Java-comment-start-regexp
-          c-class-key c-Java-class-key
-          c-method-key nil
-          c-baseclass-key nil
-          c-recognize-knr-p nil
-          c-access-key (and (boundp 'c-Java-access-key) c-Java-access-key))
-    (and (boundp 'c-inexpr-class-key) (boundp 'c-Java-inexpr-class-key)
-         (setq c-inexpr-class-key c-Java-inexpr-class-key)))
   ;; various -----------------------------------------------------------------
   (make-local-variable 'font-lock-defaults)
   (setq font-lock-defaults antlr-font-lock-defaults)
@@ -2502,21 +2668,5 @@ Used in `antlr-mode'.  Also a useful function in `java-mode-hook'."
                      indent-tabs-mode (cadddr elem)
                      alist nil))))))
 
-; LocalWords:  antlr ANother ANTLR's Cpp Lexer TreeParser esp refs VALUEs ea ee
-; LocalWords:  Java's Nomencl ruledef tokendef ruleref tokenref setType ader ev
-; LocalWords:  ivate syntab lexer treeparser lic rotected rivate bor boi AFAIK
-; LocalWords:  slist knr inexpr unhide jit GENS SEP GEN sTokenTypes hpp cpp DEP
-; 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
-
+;;; Local IspellPersDict: .ispell_antlr
 ;;; antlr-mode.el ends here