;ELC
;;; Compiled by mockbuild@buildfarm06-new.corp.cloudlinux.com on Fri Oct 11 10:09:16 2024
;;; from file /builddir/build/BUILD/emacs-24.3/lisp/progmodes/antlr-mode.el
;;; in Emacs version 24.3.1
;;; with all optimizations.

;;; This file uses dynamic docstrings, first added in Emacs 19.29.

;;; This file does not contain utf-8 non-ASCII characters,
;;; and so can be loaded in Emacs versions earlier than 23.

;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;


(byte-code "\300\301!\210\300\302!\210\303\304\305\306#\210\307\310\311\"\210\312\313\314\315\316\317\320\321\320\322\323\324&\207" [require easymenu cc-mode put save-buffer-state-x lisp-indent-function 0 defalias antlr-c-forward-sws c-forward-sws custom-declare-group antlr nil "Major mode for ANTLR grammar files." :group languages :link (emacs-commentary-link "antlr-mode.el") (url-link "http://antlr-mode.sourceforge.net/") :prefix "antlr-"] 12)
#@93 ANTLR major mode version number.
Check <http://antlr-mode.sourceforge.net/> for the newest.
(defconst antlr-version "2.2c" (#$ . 1014))
#@269 Major mode corresponding to ANTLR's "language" option.
Set via `antlr-language-alist'.  The only useful place to change this
buffer-local variable yourself is in `antlr-mode-hook' or in the "local
variable list" near the end of the file, see
`enable-local-variables'.
(defvar antlr-language nil (#$ . 1157))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\305\306\313&\210\300\314\315\316\304\305\306\317&\210\300\320\321\322\304\305\306\323&\210\300\324\325\326\304\305\306\327&\210\300\330\331\332\304\305\306\333&\210\300\334\335\336\304\305\306\337&\210\300\340\341\342\304\305\306\343&\207" [custom-declare-variable antlr-language-alist '((java-mode "Java" nil "\"Java\"" "Java") (c++-mode "C++" "\"Cpp\"" "Cpp")) "List of ANTLR's supported languages.\nEach element in this list looks like\n  (MAJOR-MODE MODELINE-STRING OPTION-VALUE...)\n\nMAJOR-MODE, the major mode of the code in the grammar's actions, is the\nvalue of `antlr-language' if the first group in the string matched by\nREGEXP in `antlr-language-limit-n-regexp' is one of the OPTION-VALUEs.\nAn OPTION-VALUE of nil denotes the fallback element.  MODELINE-STRING is\nalso displayed in the mode line next to \"Antlr\"." :group antlr :type (repeat (group :value (java-mode "") (function :tag "Major mode") (string :tag "Mode line string") (repeat :tag "ANTLR language option" :inline t (choice (const :tag "Default" nil) string)))) antlr-language-limit-n-regexp '(8192 . "language[ 	]*=[ 	]*\\(\"?[A-Z][A-Za-z_]*\"?\\)") "Used to set a reasonable value for `antlr-language'.\nLooks like (LIMIT . REGEXP).  Search for REGEXP from the beginning of\nthe buffer to LIMIT and use the first group in the matched string to set\nthe language according to `antlr-language-alist'." (cons (choice :tag "Limit" (const :tag "No" nil) (integer :value 0)) regexp) antlr-action-visibility 3 "Visibility of actions when command `antlr-hide-actions' is used.\nIf nil, the actions with their surrounding braces are hidden.  If a\nnumber, do not hide the braces, only hide the contents if its length is\ngreater than this number." (choice (const :tag "Completely hidden" nil) (integer :tag "Hidden if longer than" :value 3)) antlr-indent-comment 'tab "Non-nil, if the indentation should touch lines in block comments.\nIf nil, no continuation line of a block comment is changed.  If t, they\nare changed according to `c-indentation-line'.  When not nil and not t,\nthey are only changed by \\[antlr-indent-command]." (radio (const :tag "No" nil) (const :tag "Always" t) (sexp :tag "With TAB" :format "%t" :value tab)) antlr-tab-offset-alist '((antlr-mode nil 4 nil) (java-mode "antlr" 4 nil)) "Alist to determine whether to use ANTLR's convention for TABs.\nEach element looks like (MAJOR-MODE REGEXP TAB-WIDTH INDENT-TABS-MODE).\nThe first element whose MAJOR-MODE is nil or equal to `major-mode' and\nwhose REGEXP is nil or matches variable `buffer-file-name' is used to\nset `tab-width' and `indent-tabs-mode'.  This is useful to support both\nANTLR's and Java's indentation styles.  Used by `antlr-set-tabs'." (repeat (group :value (antlr-mode nil 8 nil) (choice (const :tag "All" nil) (function :tag "Major mode")) (choice (const :tag "All" nil) regexp) (integer :tag "Tab width") (boolean :tag "Indent-tabs-mode"))) antlr-indent-style "java" "If non-nil, cc-mode indentation style used for `antlr-mode'.\nSee `c-set-style' and for details, where the most interesting part in\n`c-style-alist' is the value of `c-basic-offset'." (choice (const nil) regexp) antlr-indent-item-regexp "[]}):;|&]" "Regexp matching lines which should be indented by one TAB less.\nSee `antlr-indent-line' and command \\[antlr-indent-command]." regexp antlr-indent-at-bol-alist '((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.\nEach element in this list looks like (MODE . REGEXP) where MODE is a\nfunction and REGEXP is a regular expression.\n\nIf `antlr-language' equals to a MODE, the line starting at the first\nnon-whitespace is matched by the corresponding REGEXP, and the line is\npart of a header action, indent the line at column 0 instead according\nto the normal rules of `antlr-indent-line'." (repeat (cons (function :tag "Major mode") regexp))] 8)
(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))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\305\306\313&\210\300\314\302\315\304\305\306\307&\210\300\316\317\320\304\305\306\321&\210\300\322\302\323\304\305\306\324&\210\300\325\326\327\304\305\306\330&\207" [custom-declare-variable antlr-options-use-submenus t "Non-nil, if the major mode menu should include option submenus.\nIf nil, the menu just includes a command to insert options.  Otherwise,\nit includes four submenus to insert file/grammar/rule/subrule options." :group antlr :type boolean antlr-tool-version 20701 "The version number of the Antlr tool.\nThe value is an integer of the form XYYZZ which stands for vX.YY.ZZ.\nThis variable is used to warn about non-supported options and to supply\nversion correct option values when using \\[antlr-insert-option].\n\nDon't use a number smaller than 20600 since the stored history of\nAntlr's options starts with v2.06.00, see `antlr-options-alists'.  You\ncan make this variable buffer-local." integer antlr-options-auto-colon "Non-nil, if `:' is inserted with a rule or subrule options section.\nA `:' is only inserted if this value is non-nil, if a rule or subrule\noption is inserted with \\[antlr-insert-option], if there was no rule or\nsubrule options section before, and if a `:' is not already present\nafter the section, ignoring whitespace, comments and the init action." antlr-options-style nil "List of symbols which determine the style of option values.\nIf a style symbol is present, the corresponding option value is put into\nquotes, i.e., represented as a string, otherwise it is represented as an\nidentifier.\n\nThe only style symbol used in the default value of `antlr-options-alist'\nis `language-as-string'.  See also `antlr-read-value'." (repeat (symbol :tag "Style symbol")) antlr-options-push-mark "Non-nil, if inserting an option should set & push mark.\nIf nil, never set mark when inserting an option with command\n\\[antlr-insert-option].  If t, always set mark via `push-mark'.  If a\nnumber, only set mark if point was outside the options area before and\nthe number of lines between point and the insert position is greater\nthan this value.  Otherwise, only set mark if point was outside the\noptions area before." (radio (const :tag "No" nil) (const :tag "Always" t) (integer :tag "Lines between" :value 10) (sexp :tag "If outside options" :format "%t" :value outside)) antlr-options-assign-string " = " "String containing `=' to use between option name and value.\nThis string is only used if the option to insert did not exist before\nor if there was no `=' after it.  In other words, the spacing around an\nexisting `=' won't be changed when changing an option value." string] 8)
#@134 Headings for the four different option kinds.
The standard value is ("file" "grammar" "rule" "subrule").  See
`antlr-options-alists'
(defvar antlr-options-headings '("file" "grammar" "rule" "subrule") (#$ . 8690))
#@2088 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 if
AS-STRING is non-nil and is either t or a symbol which is a member of
`antlr-options-style'.
(defvar antlr-options-alists '((("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? "))) (("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 (20600 antlr-read-boolean "Test each token against literals table? ")) ("defaultErrorHandler" nil (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 (20600 antlr-read-boolean "Use automatic AST construction/transformation? ")) ("ASTLabelType" nil (20600 antlr-read-value "Class of user-defined AST node: " t)) ("charVocabulary" nil (20600 nil "Insert character vocabulary")) ("interactive" nil (20600 antlr-read-boolean "Generate interactive lexer/parser? ")) ("caseSensitive" nil (20600 antlr-read-boolean "Case significant when matching characters? ")) ("caseSensitiveLiterals" nil (20600 antlr-read-boolean "Case significant when testing literals table? ")) ("classHeaderSuffix" nil (20600 nil "Additional string for grammar class definition")) ("filter" nil (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? "))) (("testLiterals" nil (20600 antlr-read-boolean "Test this token against literals table? ")) ("defaultErrorHandler" nil (20600 antlr-read-boolean "Generate default exception handler for this rule? ")) ("ignore" nil (20600 antlr-read-value "In this rule, ignore tokens of type: " nil antlr-grammar-tokens)) ("paraphrase" nil (20600 antlr-read-value "In messages, replace name of this token by: " t))) (("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? ")))) (#$ . 8912))
(byte-code "\300\301\302\303\304\305\306\307&\210\300\310\311\312\304\305\306\313&\210\300\314\315\316\304\305\306\317&\207" [custom-declare-variable antlr-tool-command "java antlr.Tool" "Command used in \\[antlr-run-tool] to run the Antlr tool.\nThis variable should include all options passed to Antlr except the\noption \"-glib\" which is automatically suggested if necessary." :group antlr :type string antlr-ask-about-save t "If not nil, \\[antlr-run-tool] asks which buffers to save.\nOtherwise, it saves all modified buffers before running without asking." boolean antlr-makefile-specification '("\n" ("GENS" "GENS%d" " \\\n	") "$(ANTLR)") "Variable to specify the appearance of the generated makefile rules.\nThis variable influences the output of \\[antlr-show-makefile-rules].\nIt looks like (RULE-SEP GEN-VAR-SPEC COMMAND).\n\nRULE-SEP is the string to separate different makefile rules.  COMMAND is\na string with the command which runs the Antlr tool, it should include\nall options except the option \"-glib\" which is automatically added\nif necessary.\n\nIf GEN-VAR-SPEC is nil, each target directly consists of a list of\nfiles.  If GEN-VAR-SPEC looks like (GEN-VAR GEN-VAR-FORMAT GEN-SEP), a\nMakefile variable is created for each rule target.\n\nThen, GEN-VAR is a string with the name of the variable which contains\nthe file names of all makefile rules.  GEN-VAR-FORMAT is a format string\nproducing the variable of each target with substitution COUNT/%d where\nCOUNT starts with 1.  GEN-SEP is used to separate long variable values." (list (string :tag "Rule separator") (choice (const :tag "Direct targets" nil) (list :tag "Variables for targets" (string :tag "Variable for all targets") (string :tag "Format for each target variable") (string :tag "Variable separator"))) (string :tag "ANTLR command"))] 8)
#@626 Language dependent formats which specify generated files.
Each element in this list looks looks like
  (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
`antlr-special-file-formats' for language independent files.

VOCAB-FILE-FORMAT is a format string, it specifies with substitution
VOCAB/%s the generated file for each export vocabulary VOCAB.
CLASS-FILE-FORMAT is a format string, it specifies with substitution
CLASS/%s the generated file for each grammar class CLASS.
(defvar antlr-file-formats-alist '((java-mode ("%sTokenTypes.java") ("%s.java")) (c++-mode ("%sTokenTypes.hpp") ("%s.cpp" "%s.hpp"))) (#$ . 16313))
#@596 Language independent formats which specify generated files.
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
vocabulary VOCAB, respectively.  EXPANDED-GRAMMAR-FORMAT is a format
string, it specifies with substitution GRAMMAR/%s the constructed
grammar file if the file GRAMMAR.g contains a grammar class which
extends a class other than "Lexer", "Parser" or "TreeParser".

See variable `antlr-file-formats-alist' for language dependent
formats.
(defvar antlr-special-file-formats '("%sTokenTypes.txt" "expanded%s.g") (#$ . 17093))
#@509 Formats which specify the names of unknown files.
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
grammar file in the current directory defines the class SUPER or if it
is defined more than once.  SUPER-EVOCAB-FORMAT is a format string, it
specifies with substitution SUPER/%s the name for the export vocabulary
of above mentioned class SUPER.
(defvar antlr-unknown-file-formats '("?%s?.g" "?%s?") (#$ . 17781))
#@134 String indicating the existence of unknown files in the Makefile.
See \[antlr-show-makefile-rules] and `antlr-unknown-file-formats'.
(defvar antlr-help-unknown-file-text "## The following rules contain filenames of the form\n##  \"?SUPERCLASS?.g\" (and \"?SUPERCLASS?TokenTypes.txt\")\n## where SUPERCLASS is not found to be defined in any grammar file of\n## the current directory or is defined more than once.  Please replace\n## these filenames by the grammar files (and their exportVocab).\n\n" (#$ . 18364))
#@172 Introduction to use with \[antlr-show-makefile-rules].
It is a format string and used with substitution DIRECTORY/%s where
DIRECTORY is the name of the current directory.
(defvar antlr-help-rules-intro "The following Makefile rules define the dependencies for all (non-\nexpanded) grammars in directory \"%s\".\n\nThey are stored in the kill-ring, i.e., you can insert them with C-y\ninto your Makefile.  You can also invoke M-x antlr-show-makefile-rules\nfrom within a Makefile to insert them directly.\n\n\n" (#$ . 18884))
#@132 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.
(custom-declare-variable 'antlr-imenu-name t '(#$ . 19416) :group 'antlr :type '(choice (const :tag "No menu" nil) (const :tag "Index menu" t) (string :tag "Other menu name")))
#@38 Keymap used in `antlr-mode' buffers.
(defvar antlr-mode-map (byte-code "\301 \302\303\304#\210\302\305\306#\210\302\307\310#\210\302\311\312#\210\302\313\314#\210\302\315\316#\210\302\317\320#\210\302\321\322#\210\302\323\324#\210\302\325\326#\210\302\327\330#\210\302\331\332#\210\302\333\334#\210\302\335\336#\210\302\337\336#\210\302\340\336#\210\302\341\336#\210\302\342\336#\210\302\343\336#\210\302\344\336#\210\302\345\336#\210)\207" [map make-sparse-keymap define-key "	" antlr-indent-command "
" antlr-beginning-of-rule "" antlr-end-of-rule "
" antlr-beginning-of-body "" antlr-end-of-body "" c-forward-into-nomenclature "" c-backward-into-nomenclature "" comment-region "" antlr-hide-actions "" antlr-run-tool "" antlr-insert-option "a" c-beginning-of-statement "e" c-end-of-statement ":" antlr-electric-character ";" "|" "&" "(" ")" "{" "}"] 4) (#$ . 19730))
#@18 Major mode menu.
(defvar antlr-mode-menu nil (#$ . 20649))
(byte-code "\303\304\305\306\307	\203(\n\310Y\203(\311\312\313E\314\312\315E\316\312\317E\320\312\321E\322BBBB\202)\323\324\"B$\210\325\326\327\330\331\332\333\334&\207" [antlr-mode-map antlr-options-use-submenus emacs-major-version easy-menu-do-define antlr-mode-menu "Major mode menu." "Antlr" append 21 "Insert File Option" :filter #[(x) "\301\302\"\207" [x antlr-options-menu-filter 1] 3] "Insert Grammar Option" #[(x) "\301\302\"\207" [x antlr-options-menu-filter 2] 3] "Insert Rule Option" #[(x) "\301\302\"\207" [x antlr-options-menu-filter 3] 3] "Insert Subrule Option" #[(x) "\301\302\"\207" [x antlr-options-menu-filter 4] 3] ("---") (["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]) custom-declare-variable antlr-font-lock-maximum-decoration 'inherit "The maximum decoration level for fontifying actions.\nValue `none' means, do not fontify actions, just normal grammar code\naccording to `antlr-font-lock-additional-keywords'.  Value `inherit'\nmeans, use value of `font-lock-maximum-decoration'.  Any other value is\ninterpreted as in `font-lock-maximum-decoration' with no level-0\nfontification, see `antlr-font-lock-keywords-alist'.\n\nWhile calculating the decoration level for actions, `major-mode' is\nbound to `antlr-language'.  For example, with value\n  ((java-mode . 2) (c++-mode . 0))\nJava actions are fontified with level 2 and C++ actions are not\nfontified at all." :group antlr :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")) (radio :tag "Decoration" (const :tag "Default" nil) (const :tag "Maximum" t) (integer :tag "Level" 1)))))] 12)
#@81 Empty font-lock keywords for actions.
Do not change the value of this constant.
(defconst antlr-no-action-keywords nil (#$ . 23665))
#@348 List of font-lock keywords for actions in the grammar.
Each element in this list looks like
  (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-keywords-alist '((java-mode antlr-no-action-keywords java-font-lock-keywords-1 java-font-lock-keywords-2 java-font-lock-keywords-3) (c++-mode antlr-no-action-keywords c++-font-lock-keywords-1 c++-font-lock-keywords-2 c++-font-lock-keywords-3)) (#$ . 23805))
(defvar antlr-default-face 'antlr-default)
(byte-code "\300\301\302\303\304\305%\210\306\307\310\301#\210\306\307\311\312#\207" [custom-declare-face antlr-default ((t nil)) "Face to prevent strings from language dependent highlighting.\nDo not change." :group antlr put antlr-font-lock-default-face face-alias obsolete-face "22.1"] 6)
(defvar antlr-keyword-face 'antlr-keyword)
(byte-code "\300\301\302\303\304\305%\210\306\307\310\301#\210\306\307\311\312#\207" [custom-declare-face antlr-keyword ((((class color) (background light)) (:foreground "black" :weight bold)) (t :inherit font-lock-keyword-face)) "ANTLR keywords." :group antlr put antlr-font-lock-keyword-face face-alias obsolete-face "22.1"] 6)
(defvar antlr-syntax-face 'antlr-keyword)
(byte-code "\300\301\302\303\304\305%\210\306\307\310\301#\210\306\307\311\312#\207" [custom-declare-face antlr-syntax ((((class color) (background light)) (:foreground "black" :weight bold)) (t :inherit font-lock-constant-face)) "ANTLR syntax symbols like :, |, (, ), ...." :group antlr put antlr-font-lock-syntax-face face-alias obsolete-face "22.1"] 6)
(defvar antlr-ruledef-face 'antlr-ruledef)
(byte-code "\300\301\302\303\304\305%\210\306\307\310\301#\210\306\307\311\312#\207" [custom-declare-face antlr-ruledef ((((class color) (background light)) (:foreground "blue" :weight bold)) (t :inherit font-lock-function-name-face)) "ANTLR rule references (definition)." :group antlr put antlr-font-lock-ruledef-face face-alias obsolete-face "22.1"] 6)
(defvar antlr-tokendef-face 'antlr-tokendef)
(byte-code "\300\301\302\303\304\305%\210\306\307\310\301#\210\306\307\311\312#\207" [custom-declare-face antlr-tokendef ((((class color) (background light)) (:foreground "blue" :weight bold)) (t :inherit font-lock-function-name-face)) "ANTLR token references (definition)." :group antlr put antlr-font-lock-tokendef-face face-alias obsolete-face "22.1"] 6)
(defvar antlr-ruleref-face 'antlr-ruleref)
(byte-code "\300\301\302\303\304\305%\210\306\307\310\301#\210\306\307\311\312#\207" [custom-declare-face antlr-ruleref ((((class color) (background light)) (:foreground "blue4")) (t :inherit font-lock-type-face)) "ANTLR rule references (usage)." :group antlr put antlr-font-lock-ruleref-face face-alias obsolete-face "22.1"] 6)
(defvar antlr-tokenref-face 'antlr-tokenref)
(byte-code "\300\301\302\303\304\305%\210\306\307\310\301#\210\306\307\311\312#\207" [custom-declare-face antlr-tokenref ((((class color) (background light)) (:foreground "orange4")) (t :inherit font-lock-type-face)) "ANTLR token references (usage)." :group antlr put antlr-font-lock-tokenref-face face-alias obsolete-face "22.1"] 6)
(defvar antlr-literal-face 'antlr-literal)
(byte-code "\300\301\302\303\304\305%\210\306\307\310\301#\210\306\307\311\312#\210\313\314\315\316\304\305\317\320&\207" [custom-declare-face antlr-literal ((((class color) (background light)) (:foreground "brown4" :weight bold)) (t :inherit font-lock-string-face)) "ANTLR special literal tokens.\nIt is used to highlight strings matched by the first regexp group of\n`antlr-font-lock-literal-regexp'." :group antlr put antlr-font-lock-literal-face face-alias obsolete-face "22.1" custom-declare-variable antlr-font-lock-literal-regexp "\"\\(\\sw\\(\\sw\\|-\\)*\\)\"" "Regexp matching literals with special syntax highlighting, or nil.\nIf nil, there is no special syntax highlighting for some literals.\nOtherwise, it should be a regular expression which must contain a regexp\ngroup.  The string matched by the first group is highlighted with\n`antlr-font-lock-literal-face'." :type (choice (const :tag "None" nil) regexp)] 8)
#@32 Regexp matching class headers.
(defvar antlr-class-header-regexp "\\(class\\)[ 	]+\\([A-Za-z\300-\326\330-\337]\\sw*\\)[ 	]+\\(extends\\)[ 	]+\\([A-Za-z\300-\326\330-\337]\\sw*\\)[ 	]*;" (#$ . 28072))
#@119 Font-lock keywords for ANTLR's normal grammar code.
See `antlr-font-lock-keywords-alist' for the keywords of actions.
(defvar antlr-font-lock-additional-keywords (byte-code "\300\301\302\303\304B\305\306B\307\310B\311\312B\313\314B\315\316B\317\320B\257\n\207" [(antlr-invalidate-context-cache) ("\\$setType[ 	]*(\\([A-Za-z\300-\326\330-\337]\\sw*\\))" (1 antlr-tokendef-face)) ("\\$\\sw+" (0 antlr-keyword-face)) #[(limit) "\205\302	\"\207" [antlr-font-lock-literal-regexp limit antlr-re-search-forward] 3] ((1 antlr-literal-face t)) #[(limit) "\302	\"\207" [antlr-class-header-regexp limit antlr-re-search-forward] 3] ((1 antlr-keyword-face) (2 antlr-ruledef-face) (3 antlr-keyword-face) (4 (if (member (match-string 4) '("Lexer" "Parser" "TreeParser")) antlr-keyword-face font-lock-type-face))) #[(limit) "\301\302\"\207" [limit antlr-re-search-forward "\\<\\(header\\|options\\|tokens\\|exception\\|catch\\|returns\\)\\>"] 3] ((1 antlr-keyword-face)) #[(limit) "\301\302\"\207" [limit antlr-re-search-forward "^\\(private\\|public\\|protected\\)\\>[ 	]*\\(\\(\\sw+[ 	]*\\(:\\)?\\)\\)?"] 3] ((1 font-lock-type-face) (3 (if (antlr-upcase-p (char-after (match-beginning 3))) antlr-tokendef-face antlr-ruledef-face) nil t) (4 antlr-syntax-face nil t)) #[(limit) "\301\302\"\207" [limit antlr-re-search-forward "^\\(\\sw+\\)[ 	]*\\(:\\)?"] 3] ((1 (if (antlr-upcase-p (char-after (match-beginning 0))) antlr-tokendef-face antlr-ruledef-face) nil t) (2 antlr-syntax-face nil t)) #[(limit) "\301\302\"\207" [limit antlr-re-search-forward "\\(\\sw+\\)[ 	]*\\([=:]\\)?"] 3] ((1 (if (match-beginning 2) (if (eq (char-after (match-beginning 2)) 61) antlr-default-face font-lock-variable-name-face) (if (antlr-upcase-p (char-after (match-beginning 1))) antlr-tokenref-face antlr-ruleref-face))) (2 antlr-default-face nil t)) #[(limit) "\301\302\"\207" [limit antlr-re-search-forward "[|&:;(~]\\|)\\([*+?]\\|=>\\)?"] 3] ((0 antlr-syntax-face))] 11) (#$ . 28280))
#@137 Font-lock defaults used for ANTLR syntax highlighting.
The SYNTAX-ALIST element is also used to initialize
`antlr-action-syntax-table'.
(defvar antlr-font-lock-defaults '(antlr-font-lock-keywords nil nil ((95 . "w") (40 . ".") (41 . ".")) beginning-of-defun) (#$ . 30250))
#@30 Hook called by `antlr-mode'.
(defvar antlr-mode-hook nil (#$ . 30529))
#@96 Syntax table used in `antlr-mode' buffers.
If non-nil, it will be initialized in `antlr-mode'.
(defvar antlr-mode-syntax-table (byte-code "\301 \302!\210)\207" [st make-syntax-table c-populate-syntax-table] 2) (#$ . 30606))
#@293 Syntax table used for ANTLR action parsing.
Initialized by `antlr-mode-syntax-table', changed by SYNTAX-ALIST in
`antlr-font-lock-defaults'.  This table should be selected if you use
`buffer-syntactic-context' and `buffer-syntactic-context-depth' in order
not to confuse their context_cache.
(defvar antlr-action-syntax-table (byte-code "\305!\306	8\n\203#\307\n\211@@)\n\211@A)#\210\nA\211\204\f*\207" [antlr-mode-syntax-table antlr-font-lock-defaults slist st x copy-syntax-table 3 modify-syntax-entry] 5) (#$ . 30840))
#@50 Abbreviation table used in `antlr-mode' buffers.
(defvar antlr-mode-abbrev-table nil (#$ . 31378))
(define-abbrev-table 'antlr-mode-abbrev-table nil)
#@138 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-enabling-symbol 'loudly (#$ . 31535))
#@109 Maximum distance between `point' and cache position for cache use.
Used for `antlr-slow-syntactic-context'.
(defvar antlr-slow-cache-diff-threshold 5000 (#$ . 31742))
#@45 Evaluate BODY with the syntax table SYNTAB.
(defalias 'antlr-with-syntax-table '(macro . #[(syntab &rest body) "\302\303\304\305\306D	BB\307BBE\207" [syntab body let ((stab (syntax-table))) unwind-protect progn set-syntax-table ((set-syntax-table stab))] 6 (#$ . 31915)]))
(byte-code "\300\301\302\303#\210\300\301\304\305#\210\306\307\310\311!\203\311\202\312\"\210\306\313\310\314!\203'\314\202(\315\"\210\306\316\310\317!\2036\317\2027\320\"\207" [put antlr-with-syntax-table lisp-indent-function 1 edebug-form-spec (form body) defalias antlr-default-directory fboundp default-directory #[nil "\207" [default-directory] 1 "Return `default-directory'."] antlr-read-shell-command read-shell-command #[(prompt &optional initial-input history) "\303	\304\211\n\206\n\305%\207" [prompt initial-input history read-from-minibuffer nil shell-command-history] 6 "Read a string from the minibuffer, using `shell-command-history'."] antlr-with-displaying-help-buffer with-displaying-help-buffer #[(thunk &optional _name) "r\306\307!q\210p\310 \210	\311\211\312\211\312\313 \210\314\315!\210+\211\212 )\316!\210+\207" [default-directory #:old-dir buffer-read-only buffer-file-name buffer-undo-list inhibit-modification-hooks get-buffer-create "*Help*" kill-all-local-variables nil t erase-buffer run-hooks temp-buffer-setup-hook internal-temp-output-buffer-show inhibit-read-only #:buf standard-output thunk] 4 "Make a help buffer and call `thunk' there."]] 4)
#@11 Internal.
(defvar antlr-slow-context-cache nil (#$ . 33402))
#@63 Invalidate context cache for syntactical context information.
(defalias 'antlr-invalidate-context-cache #[(&rest _dummies) "\301\211\207" [antlr-slow-context-cache nil] 2 (#$ . 33469)])
#@259 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'.
(defalias 'antlr-syntactic-context #[nil "`\306\211\307!\206\310 
A\203Z\f
\211A@)Z\211\311Y\203ZW\203Zp
\211@@)=\203Z	
\211@A)=\203Z\312
\211A@)\f\306\211
\211AA)%\202o\fY\203g\313 \210\202jeb\210\312`\f\"\fb\210
\203
\f\nB\241\210\202\207p	B\f\nBB\314\n8\203\221\315\202\235\316\n8\203\233\317\202\235\n@,\207" [antlr-slow-cache-enabling-symbol tick state diff orig antlr-slow-context-cache nil boundp buffer-modified-tick 0 parse-partial-sexp beginning-of-defun 3 string 4 comment x antlr-slow-cache-diff-threshold] 7 (#$ . 33663)])
#@66 Non-nil, if CHAR is an uppercase character (if CHAR was a char).
(defalias 'antlr-upcase-p #[(char) "\301X\203\f\302X\206\303X\205\304X\207" [char 65 90 192 223] 2 (#$ . 34504)])
#@362 Search forward from point for regular expression REGEXP.
Set point to the end of the occurrence found, and return point.  Return
nil if no occurrence was found.  Do not search within comments, strings
and actions/semantic predicates.  BOUND bounds the search; it is a
buffer position.  See also the functions `match-beginning', `match-end'
and `replace-match'.
(defalias 'antlr-re-search-forward #[(regexp bound) "\304\305	\n\306#\203!\307 \310\216\311 \312=\203\313\211\202\304*\204?\205'`)\207" [continue regexp bound save-match-data-internal t re-search-forward limit match-data ((byte-code "\301\302\"\207" [save-match-data-internal set-match-data evaporate] 3)) antlr-syntactic-context 0 nil] 4 (#$ . 34699)])
#@216 Search forward from point for STRING.
Set point to the end of the occurrence found, and return point.  Return
nil if no occurrence was found.  Do not search within comments, strings
and actions/semantic predicates.
(defalias 'antlr-search-forward #[(string) "\302\303	\304\305#\203\306 \307=\203\304\211\202\302\204?\205!`)\207" [continue string t search-forward nil limit antlr-syntactic-context 0] 4 (#$ . 35434)])
#@222 Search backward from point for STRING.
Set point to the beginning of the occurrence found, and return point.
Return nil if no occurrence was found.  Do not search within comments,
strings and actions/semantic predicates.
(defalias 'antlr-search-backward #[(string) "\302\303	\304\305#\203\306 \307=\203\304\211\202\302\204?\205!`)\207" [continue string t search-backward nil limit antlr-syntactic-context 0] 4 (#$ . 35870)])
#@132 Skip the next COUNT balanced expressions and the comments after it.
Return position before the comments after the last expression.
(defalias 'antlr-skip-sexps #[(count) "\300\301\302\217\206db\210`\303 \210\207" [nil (byte-code "\301`\"\207" [count scan-sexps] 3) ((error)) antlr-c-forward-sws] 3 (#$ . 36314)])
(put 'antlr-skip-sexps 'byte-optimizer 'byte-compile-inline-expand)
#@149 Return font-lock keywords for current buffer.
See `antlr-font-lock-additional-keywords', `antlr-language' and
`antlr-font-lock-maximum-decoration'.
(defalias 'antlr-font-lock-keywords #[nil "\306=\203	\207\307	\310\n\311\n\f\236A\312=\203
\202\")!\"\207" [antlr-font-lock-maximum-decoration antlr-font-lock-additional-keywords antlr-language major-mode antlr-font-lock-keywords-alist font-lock-maximum-decoration none append eval font-lock-choose-keywords inherit] 7 (#$ . 36704)])
#@52 Return alist for tokens defined in current buffer.
(defalias 'antlr-grammar-tokens #[nil "\212\300\301!)\207" [antlr-imenu-create-index-function t] 2 (#$ . 37202)])
#@120 Return imenu index-alist for ANTLR grammar files.
IF TOKENREFS-ONLY is non-nil, just return alist with tokenref names.
(defalias 'antlr-imenu-create-index-function #[(&optional tokenrefs-only) "\306\211\307\310 \311\216\312\f!\210\313 \210eb\210\314\307!\210\203\261\315\316!\2035\317\306\320\321\217\206-db\210`\322 \210)\210\315!\203Y\204\242\323\324! \203P\325\324\224!\202R\324\224B	B\202\242\315\326!\203q\317\306\320\321\217\206idb\210`\322 \210)\210\315\327!\203\242\203\215\330`f!\203\242\323\331!C\nB\202\242\323\331! \203\234\325\331\224!\202\236\331\224B\nB\332\333!\211\203\334\307!\210\202*	\203\300\335	\237B\n\237B\202\302\n\237+\207" [continue classes items stab antlr-action-syntax-table count nil t syntax-table ((set-syntax-table stab)) set-syntax-table antlr-invalidate-context-cache antlr-skip-file-prelude looking-at "{" 1 (byte-code "\301`\"\207" [count scan-sexps] 3) ((error)) antlr-c-forward-sws match-string 2 copy-marker "p\\(ublic\\|rotected\\|rivate\\)" "\\sw+" antlr-upcase-p 0 antlr-search-forward ";" antlr-skip-exception-part "Classes" antlr-class-header-regexp tokenrefs-only imenu-use-markers] 3 (#$ . 37374)])
#@208 Skip exception part of current rule, i.e., everything after `;'.
This also includes the options and tokens part of a grammar class
header.  If SKIP-COMMENT is non-nil, also skip the comment after that
part.
(defalias 'antlr-skip-exception-part #[(skip-comment) "`\304\305 \210\306\307!\203$\310\311\304\312\313\217\206db\210`\305 \210)\202\203C\306\314!\203\216\315\304\312\313\217\2068db\210`\305 \210)\202\216\306\316!\203\216\315\304\312\313\217\206Sdb\210`\305 \210)\306\317!\203s\315\304\312\313\217\206kdb\210`\305 \210)\306\320!\203C\321\304\312\313\217\206\203db\210`\305 \210)\202s\206\224	b*\207" [class pos count skip-comment nil antlr-c-forward-sws looking-at "options\\>\\|tokens\\>" t 2 (byte-code "\301`\"\207" [count scan-sexps] 3) ((error)) "{" 1 "exception\\>" "\\[" "catch\\>" 3] 3 (#$ . 38570)])
#@281 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.

Hack: if SKIP-COMMENT is `header-only' only skip header and return
position before the comment after the header.
(defalias 'antlr-skip-file-prelude #[(skip-comment) "`\211\304 \210\n\203
`\305\306!\2031\307\224\203\310\202\311\312\313\314\217\206&db\210`\304 \210)\202
\n\315=\203;\202[\305\316!\203S\311\312\313\314\217\206Kdb\210`\304 \210)\n\204Zb\210	*\207" [pos pos0 skip-comment count antlr-c-forward-sws looking-at "header\\>[ 	]*\\(\"\\)?" 1 3 2 nil (byte-code "\301`\"\207" [count scan-sexps] 3) ((error)) header-only "options\\>"] 4 (#$ . 39426)])
#@311 Move forward to next end 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 back to ARGth preceding end of
rule.  The behavior is not defined when ARG is zero.  If SKIP-COMMENT
is non-nil, move to beginning of the rule.
(defalias 'antlr-next-rule #[(arg skip-comment) "``\304\305!\203`\306u\210\307\n!\210\202\310\n!\210\311W\203\227`	W\205,\312T\211!?\205\300b\210\203\212T\211\311X\203\212\304\305!\203K`\2023\313Y\203\204\310\n!\312!\203q`Y\203\204	Y\203ke\202l	b\210\202\204`Y\204}`	U\203\201e\202\202	b\210\306\211\2047\205\300\306u\210\307\n!\202\300`	X\203\243	b\210\202\246S\312!?\205\300S\211\311Y\203\275\314\305!\210\202\255\307\n!*\207" [beg pos skip-comment arg antlr-search-backward ";" nil antlr-skip-exception-part antlr-skip-file-prelude 0 zerop -1 antlr-search-forward] 4 (#$ . 40181)])
#@114 Non-nil if point is outside a grammar rule.
Move to the beginning of the current rule if point is inside a rule.
(defalias 'antlr-outside-rule-p #[nil "`\302\303\304\"\210o\206`W\305 \210	\205`V\205b*\207" [pos between antlr-next-rule -1 nil antlr-c-forward-sws] 3 (#$ . 41135)])
#@119 Non-nil if point is inside a grammar rule.
A grammar class header and the file prelude are also considered as a
rule.
(defalias 'antlr-inside-rule-p #[nil "\212\302 \303\216\304	!\210\305 +?\207" [stab antlr-action-syntax-table syntax-table ((set-syntax-table stab)) set-syntax-table antlr-outside-rule-p] 2 (#$ . 41433)])
#@259 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'.
(defalias 'antlr-end-of-rule #[(&optional arg) "\303!\203	\304 \207\305 \306\216\307\n!\210\310\311\"*\207" [arg stab antlr-action-syntax-table zerop antlr-end-of-body syntax-table ((set-syntax-table stab)) set-syntax-table antlr-next-rule nil] 3 (#$ . 41764) "p"])
#@268 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'.
(defalias 'antlr-beginning-of-rule #[(&optional arg) "\303!\203	\304 \207\305 \306\216\307\n!\210\310[\311\"*\207" [arg stab antlr-action-syntax-table zerop antlr-beginning-of-body syntax-table ((set-syntax-table stab)) set-syntax-table antlr-next-rule t] 3 (#$ . 42299) "p"])
#@150 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 `:'.
(defalias 'antlr-end-of-body #[(&optional msg) "\305 \306\216\307	!\210`\310 \203\311\312!\210`\313\314!`W\203)\nb\210\311\f\206'\315!\210\316\317!\210\f\205I`b\210\316\320!\206<dW\203G\nb\210\311\f!\210\321 ,\207" [stab antlr-action-syntax-table orig bor msg syntax-table ((set-syntax-table stab)) set-syntax-table antlr-outside-rule-p error "Outside an ANTLR rule" antlr-skip-file-prelude t "The file prelude is without `;'" antlr-search-forward ";" ":" antlr-c-forward-sws] 3 (#$ . 42854) nil])
#@62 Move to the first element after the `:' of the current rule.
(defalias 'antlr-beginning-of-body #[nil "\300\301!\207" [antlr-end-of-body "Class headers and the file prelude are without `:'"] 2 (#$ . 43518) nil])
#@119 Convert all literals in buffer to lower case.
If non-nil, TRANSFORM is used on literals instead of `downcase-region'.
(defalias 'antlr-downcase-literals #[(&optional transform) "\204\304\305\212eb\210\306 \307\216\310!\210\311 \210\312\313\314\"\203,\305\224\305\225\"\210	T\202+\315\316	\")\207" [transform literals stab antlr-action-syntax-table downcase-region 0 syntax-table ((set-syntax-table stab)) set-syntax-table antlr-invalidate-context-cache antlr-re-search-forward "\"\\(\\sw\\(\\sw\\|-\\)*\\)\"" nil message "Transformed %d literals"] 3 (#$ . 43737) nil])
#@47 Convert all literals in buffer to upper case.
(defalias 'antlr-upcase-literals #[nil "\300\301!\207" [antlr-downcase-literals upcase-region] 2 (#$ . 44324) nil])
#@365 Hide or unhide all actions in buffer.
Hide all actions including arguments in brackets if ARG is 1 or if
called interactively without prefix argument.  Hide all actions
excluding arguments in brackets if ARG is 2 or higher.  Unhide all
actions if ARG is 0 or negative.  See `antlr-action-visibility'.

Display a message unless optional argument SILENT is non-nil.
(defalias 'antlr-hide-actions #[(arg &optional silent) "\306 \307\216\310\211\211\311\211\211\211\211%&'(\312V\203\301(\313U\203*\314\202+\315)\2056)\312]\316\\*+\317\312\310\"\210\212eb\210\320 ,\321\216\322-!\210\323 \210\324+\311\"\203\250\311\325\326\217\211.\203\244*\203~`.*\\V\203\244\327.T`S\330#\210\202\244\331\332!\203\235\212.b\210\333\311x\210n\205\225`\211.)\203\235\334\316!\210\327.`\335#\210)\202Q+/\206\275\336\337(\313U\203\273\340\202\274\341\"*\202\317\342ed\343#\210/\206\317\336\344!.\n\207" [#1=#:save-buffer-state-x-modified-54000 buffer-file-truename buffer-file-name after-change-functions before-change-functions deactivate-mark buffer-modified-p ((byte-code "\204
\301 \203
\302\303!\210\303\207" [#1# buffer-modified-p set-buffer-modified-p nil] 2)) t nil 0 1 "[]}]" "}" 2 antlr-hide-actions syntax-table ((set-syntax-table stab)) set-syntax-table antlr-invalidate-context-cache antlr-re-search-forward (byte-code "\300`\301\"\207" [scan-sexps -1] 3) ((error)) add-text-properties (invisible t intangible t) looking-at "[ 	]*$" " 	" beginning-of-line (invisible t intangible t) message "Hide all actions (%s arguments)...done" "including" "excluding" remove-text-properties (invisible nil intangible nil) "Unhide all actions (including arguments)...done" inhibit-point-motion-hooks inhibit-read-only buffer-undo-list arg antlr-action-visibility diff regexp stab antlr-action-syntax-table beg silent] 9 (#$ . 44493) "p"])
#@2886 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-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.

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'.
(defalias 'antlr-insert-option #[(level option &optional location) "\306 \210\204\f\307	!A	\204\310\311!\210\202$:\204$\310\312\n	S\234\"\210@A\204C\310\f\2037\313\2028\314\n	S\234\315\316!#\202\236\f\204T\317	
\320A?@%\202\236\212e\f@]b\210\321\322\323
!\324Qd\fA^\325#)\203\220\317	
\326\224\206v\327\224\326\225BA?\205\200\f\326\224\206\214\330\225\206\214\331\225%\202\236\317	
\325A?\205\233\f@%*\207" [location level antlr-options-headings place area option barf-if-buffer-read-only antlr-option-kind error "Cannot deduce what kind of option to insert" "Cannot insert any %s options around here" "Invisible %s options, use %s to make them visible" "Invisible area for %s options, use %s to make it visible" substitute-command-keys "\\[widen]" antlr-insert-option-do nil re-search-forward "\\(^\\|;\\)[ 	]*\\(\\<" regexp-quote "\\>\\)[ 	\n]*\\(\\(=[ 	]?\\)[ 	]*\\(\\(\\sw\\|\\s_\\)+\\|\"\\([^\n\"\\]\\|[\\][^\n]\\)*\"\\)?\\)?" t 5 3 4 2] 6 (#$ . 46366) (antlr-insert-option-interactive current-prefix-arg)])
#@86 Interactive specification for `antlr-insert-option'.
Return (LEVEL OPTION LOCATION).
(defalias 'antlr-insert-option-interactive #[(arg) "\306 \210\203\307!\310>\204\311\312!\210\313!\211@	A:\204*\n\314	AE\202E\nS\234\315\316\317\320\nS\234\"\f\"\n	AE+*\207" [arg kind level antlr-options-alists table completion-ignore-case barf-if-buffer-read-only prefix-numeric-value (nil 1 2 3 4) error "Valid prefix args: no=auto, 1=file, 2=grammar, 3=rule, 4=subrule" antlr-option-kind nil t completing-read format "Insert %s option: " antlr-options-headings input] 6 (#$ . 50301)])
#@50 Return items for options submenu of level LEVEL.
(defalias 'antlr-options-menu-filter #[(level _menu-items) "?\205\304	!A\243:\305\306\307\305\310	S\234\"\311\"\")\207" [buffer-read-only level active antlr-options-alists antlr-option-kind mapcar #[(option) "\303\304	E\305\n$\207" [option level active vector antlr-insert-option :active] 5] sort car string-lessp] 7 (#$ . 50901)])
#@312 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'.
(defalias 'antlr-option-kind #[(requested) "\212\214ed`\306!\307\n\204\202~\n\310=\203'eb\210\311\312!\202~\n\313=\2045`\314 \210\202~\315\316!\203~\317\225\206B\313\225b\210\320\225\203M\310\202N\321\307\322\323\217\206Xdb\210`\314 \210)\315\324!\203~\321\225Sb\210\310\307\322\323\217\206vdb\210`\314 \210)\n	\204\207\325\202\264\315\326!\203\253\321\225b\210\307\327\330\217\331
\f`	\203\244	S\202\245d\332&\202\264\331
\f	`\307&.B\207" [requested pos level orig max0 min0 antlr-option-level nil 1 antlr-skip-file-prelude header-only 3 antlr-c-forward-sws looking-at "^\\(private[ 	\n]\\|public[ 	\n]\\|protected[ 	\n]\\)?[ 	\n]*\\(\\(\\sw\\|\\s_\\)+\\)[ 	\n]*\\(!\\)?[ 	\n]*\\(\\[\\)?" 4 5 0 (byte-code "\301`\"\207" [count scan-sexps] 3) ((error)) "returns[ 	\n]*\\[" error "options[ 	\n]*{" (byte-code "\300`\301\211#\207" [scan-lists 1] 4) ((error)) antlr-option-location t count] 8 (#$ . 51296)])
#@610 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.
(defalias 'antlr-option-level #[(requested) "~\210\306=\203\n\306\207\307 \310\216\311\n!\210\312 \210`\313 \314\211\314f\315=\203:\306\314\316\317\217\2062db\210`\320 \210)\210`\321=\203r\314eb\210`
X\203d\322 \314\"\203d\323\224
X\203H\323\225\202H\205nb\210\321)\202\362\212eb\210\324\325!\210`W)\203\212?\205\362\306\202\362\f\203\222\314\202\362\326 !\203\246\323\225b\210?\205\362\321\202\362\327=\203\263
b\210\327\202\362\330
\"\211\205\362\323V\203\314\331`\332#b\210\311!!\210\312 \210\333 \323=\203\351\334=?\205\362
b\210\327\202\362\331`\332\306#Tb\210\334.\207" [requested stab antlr-action-syntax-table orig outsidep bor 1 syntax-table ((set-syntax-table stab)) set-syntax-table antlr-invalidate-context-cache antlr-outside-rule-p nil 123 (byte-code "\301`\"\207" [count scan-sexps] 3) ((error)) antlr-c-forward-sws 2 antlr-re-search-forward 0 antlr-skip-file-prelude t looking-at 3 antlr-syntactic-grammar-depth scan-lists -1 antlr-syntactic-context 4 depth count boc antlr-class-header-regexp antlr-mode-syntax-table] 5 (#$ . 52562)])
#@744 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.
(defalias 'antlr-option-location #[(orig min-vis max-vis min-area max-area withp) "\205	\nB	X\203$\nX\203$\212b\210\306 \307>)\204$C\202_\204:\f	X\203:	
X\203:	\310B\202_\f\nX\203L\n
X\203L\n\311B\202_\205_\f	X\205_	
X\205_	\310BB\207" [withp min-area max-area orig min-vis max-vis antlr-syntactic-context (comment block-comment) beginning end] 3 (#$ . 54291)])
#@279 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'.
(defalias 'antlr-syntactic-grammar-depth #[(pos beg) "b\210\303 \206	\304	\203Q	\250\204Q	\305=\2032\306\307\310\311#\205-`\nY\205-\303 \206-\304\211\202	\312>\203\n\313\314\310\311#\205L`\nY\205L\303 \206L\304\211\204	)\207" [pos context beg antlr-syntactic-context 0 string search-backward "\"" nil t (comment block-comment) re-search-backward "/[/*]"] 5 (#$ . 55426)])
#@557 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.
(defalias 'antlr-insert-option-do #[(level option old area pos) "\306	\nS\234\"A\307\nA\f:$\310@!\203@\311\"\210\"\203+#\312=\202C#\247\203A\313`$^`$]\"#V\202C#\203I\314 \210$b\210
\204y\315\316\317%\nS\234#!\203l\320\321%\nS\234#\210\202\305\322\323%\nS\234#\210\202\305
A\211@\203\264\f:\205\220\fA\205\220\f@\fA{&\324
@&\205\254&\325H\326=\203\252\327&!\202\254&
A#)\202\305\320\330
\211'A@)\206\301\331\"\210\332\f:\203\322\333\f
\"\210\202\374\":\203\337\334`\"@\"\210\335\"\f\"\210\f\204\355\336\n!\210\337\261\210\340u\210
\203\374
c\210\310@!\205
@\341\"*\207" [option antlr-options-alists level spec old value assoc antlr-option-spec fboundp before-input t count-lines push-mark y-or-n-p format "Insert unknown %s option %s? " message "Insert value for %s option %s" error "Didn't insert unknown %s option %s" apply 0 34 read "%s" "" nil antlr-insert-option-existing antlr-syntactic-grammar-depth antlr-insert-option-space antlr-insert-option-area " = ;" -1 after-insertion area antlr-options-push-mark pos antlr-options-headings initial x] 6 (#$ . 56102)])
#@238 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.
(defalias 'antlr-option-spec #[(level option specs existsp) "\306	\203\n	\211@@)Y\203	\211A@\202\206c	\204&\306\202c\f\203/	@\202c\307\310\311\312	\211@@)!

S\234\312\n!%!\203N	@\202c\313\314\312	\211@@)!

S\234\312\n!%)\207" [value specs antlr-tool-version x existsp antlr-options-headings nil y-or-n-p format "Insert v%s %s option %s in v%s? " antlr-version-string error "Didn't insert v%s %s option %s in v%s" level option] 9 (#$ . 57796)])
#@68 Format the Antlr version number VERSION, see `antlr-tool-version'.
(defalias 'antlr-version-string #[(version) "\302\245\303\304	\302\245\305	\302\"\305\302\"$)\207" [version version100 100 format "%d.%d.%d" mod] 7 (#$ . 58509)])
#@96 Insert option value VALUE at point for existing option.
For OLD, see `antlr-insert-option-do'.
(defalias 'antlr-insert-option-existing #[(old value) "@\204	c\210\n\2031A\203.\n@A{\230\203\"Ab\210\2021@A|\210\nc\210\2021\nc\210\303\304!?\205=\305c\210\306u\207" [old antlr-options-assign-string value looking-at "\\([^\n=;{}/'\"]\\|'\\([^\n'\\]\\|\\\\.\\)*'\\|\"\\([^\n\"\\]\\|\\\\.\\)*\"\\)*;" ";" -1] 3 (#$ . 58748)])
#@114 Find appropriate place to insert option, insert newlines/spaces.
For AREA and OLD, see `antlr-insert-option-do'.
(defalias 'antlr-insert-option-space #[(area old) "`\306\307\310x\210n\204\272`Sf	b\210\203A\f:\203A\n\311=\204A\312\313\fA\306#\203>\314 \211?\2065
\247)\203>`\202A	b\210\307\310w\210\315\316!\203\217\317\225\317\224V\205Ti\320\321!\210n\204a\322c\210\203\213\f\204\213\315\323!\203\213\324\224b\203\213iU\203\213\320\321!\210n\204j\322c\210\202j)\202\271	b\210\204\237\322c\210\325 \210\202\271`Sf\326=\204\252\327c\210`f\326=\204\267\327c\210\330u\210\310)\205\312\320\324!\210\322c\210\330u\210\325 *\207" [open orig before old area context t " 	" nil 59 search-forward ";" antlr-syntactic-context looking-at "$\\|//" 0 beginning-of-line 2 "\n" "[ 	]*\\(//\\)" 1 antlr-indent-line 32 " " -1 same] 5 (#$ . 59189)])
#@87 Insert new options area for options of level LEVEL.
Used by `antlr-insert-option-do'.
(defalias 'antlr-insert-option-area #[(level) "\303c\210\203;	\304>\203;\212\305 \210`f\306=\203*\307\310\311\312\217\206\"db\210`\305 \210)\210`f)\313=\204;\314c\210\315 \210\316\210\317u\210\315 \210\320\316!\210\315 \207" [antlr-options-auto-colon level count "options {\n\n}" (3 4) antlr-c-forward-sws 123 1 nil (byte-code "\301`\"\207" [count scan-sexps] 3) ((error)) 58 "\n:" antlr-indent-line 0 -1 beginning-of-line] 3 (#$ . 60065)])
#@619 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'.
(defalias 'antlr-read-value #[(initial-contents prompt &optional as-string table table-x) "\306	\204\n\n\205\307\n\310	!\203	 \202	\"\211\203(\311\f\312\211
%\202,\313\f
\"\203K\306=\204C\236A\203K\314\315\"\202M+\207" [completion-ignore-case table table-x table0 prompt initial-contents t append functionp completing-read nil read-from-minibuffer format "%S" input as-string antlr-options-style] 7 (#$ . 60608)])
#@396 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'.
(defalias 'antlr-read-boolean #[(initial-contents prompt &optional table) "\303	\203\n\n\202
\n\304P\305	\306%\207" [initial-contents table prompt antlr-read-value "(true or false) " nil (("false") ("true"))] 6 (#$ . 61677)])
#@275 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'.
(defalias 'antlr-language-option-extra #[(phase &rest _dummies) "\305=\2056\306\307!\211?\2065	\n=\2065\310\303!\205\211\203%\303\311!\210\312 \210\f\2054?\2054\303\313!))\207" [phase new-language antlr-language font-lock-mode font-lock after-insertion antlr-language-option t boundp 0 antlr-mode 1] 3 (#$ . 62308)])
#@231 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'.
(defalias 'antlr-c++-mode-extra #[(phase option &rest _dummies) "\305=\205#	\306=?\205#\307\310\311\n\"!?\205#\312\313\n	\236\211A@)#\207" [phase antlr-language option antlr-language-alist x before-input c++-mode y-or-n-p format "Insert C++ %s option? " error "Didn't insert C++ %s option with language %s"] 6 (#$ . 62919)])
#@676 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 ...))

FILE is the current buffer's file-name without directory part and
LANGUAGE is the value of `antlr-language' in the current buffer.  Each
EVOCAB is an export vocabulary and each IVOCAB is an import vocabulary.

Each CLASS is a grammar class with its export vocabulary CLASS-EVOCAB.
Each SUPER is a super-grammar class where USE-EVOCAB-P indicates whether
its export vocabulary is used as an import vocabulary.
(defalias 'antlr-file-dependencies #[nil "\204\306\307!\210\310\211\211\211\211\311 \312\216\313 !\210eb\210\314!\310\"\203
\315\316!\"\315\317!#	\2068\"$\310%\320\225b\210\321 \210\322\323!\203\273\324\224\203e\316&\310\325\326\217\206Zdb\210`\321 \210)\210\202D\320\225b\210\321 \210`f\327=\203D`T'\324&\310\325\326\217\206\202db\210`\321 \210)S(`)'b\210\330\331(\332#\203\241\315\324!$'b\210\330\333(\332#\203\263\315\324!%)b\210+\202D#\334\235\204\344\335#\n\"\211*\203\332%\204\343*\332\241\210\202\343#%?B\nB)\"$B
B	\204\363$$\f\235\204\377$\fB%\203
%\235\204
%B,\202 *
\205+
\336!
\237\n\237B\f\237\237B+BBB-\207" [buffer-file-name default-vocab superclasses import-vocabs export-vocabs classes error "Grammar buffer does not visit a file" nil syntax-table ((set-syntax-table stab)) set-syntax-table antlr-re-search-forward match-string 2 4 0 antlr-c-forward-sws looking-at "options\\>\\|\\(tokens\\)\\>" 1 (byte-code "\301`\"\207" [count scan-sexps] 3) ((error)) 123 re-search-forward "\\<exportVocab[ 	]*=[ 	]*\\([A-Za-z\300-\326\330-\337]\\sw*\\)" t "\\<importVocab[ 	]*=[ 	]*\\([A-Za-z\300-\326\330-\337]\\sw*\\)" ("Parser" "Lexer" "TreeParser") assoc file-name-nondirectory stab antlr-action-syntax-table antlr-class-header-regexp class sclass evocab ivocab count beg end cont super antlr-language] 6 (#$ . 63487)])
#@421 Return dependencies for all grammar files in directory DIRNAME.
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
grammar file in which CLASS is defined and EVOCAB is the name of the
export vocabulary specified in that file.
(defalias 'antlr-directory-dependencies #[(dirname) "\306\307\310#\211\205\310\311\312\313\n\211A@)!\314\"\315P\311\211\316\317!rq\210\320\216	\311\211\203\301@\321!\203\270\322\"\204\270\323\307\311\211\307%\210\324\307!\210\325\326!\203\270\327 \211@\203\267A@@\311\211\203\261@AB\330@
\" ! \203\236 A!C\244\210\202\247@!D
B*A\211\204y*\fB*A\211\2046-
\237\f\237,B)\207" [dirname grammar antlr-special-file-formats x dependencies classes directory-files t "\\.g\\'" nil format regexp-quote ".+" "\\'" generate-new-buffer " *temp*" ((byte-code "\301!\203\n\302!\210\301\207" [#1=#:temp-buffer buffer-name kill-buffer] 2)) file-regular-p string-match insert-file-contents normal-mode derived-mode-p antlr-mode antlr-file-dependencies assoc expanded-regexp antlr-imenu-name #1# file --dolist-tail-- file-deps class-def class-spec file-evocab] 7 (#$ . 65572)])
#@672 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'.

The result looks like (OPTION WITH-UNKNOWN GLIB ...).  OPTION is the
complete "-glib" option.  WITH-UNKNOWN is t if 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
vocabulary of the super-grammar or nil if it is not needed.
(defalias 'antlr-superclasses-glibs #[(supers classes) "\306\211\n\203U\n\211A@\307@\f\"A\211\205!
A?\205!
@\211\204)\310@\2066\311@@\"A\205MA\206M\311\211A@)@\"B	B+\202	\203c\312\313\314	\315#P\202d\316	*BB\207" [unknown glibs supers super classes sup-files nil assoc t format " -glib " mapconcat car ";" "" file antlr-unknown-file-formats x] 6 (#$ . 66943)])
#@350 Run Antlr took COMMAND on grammar FILE.
When called interactively, COMMAND is read from the minibuffer and
defaults to `antlr-tool-command' with a computed "-glib" option if
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'.
(defalias 'antlr-run-tool #[(command file &optional saved) "\204	\305	?!\210\306\n!\307\f\310\311\n!Q\312\313#)\207" [saved antlr-ask-about-save file default-directory command save-some-buffers file-name-directory compilation-start " " file-name-nondirectory nil #[(_mode-name) "\300\207" [#1="*Antlr-Run*"] 1 #1#]] 5 (#$ . 68017) (antlr-run-tool-interactive)])
#@105 Interactive specification for `antlr-run-tool'.
Use prefix argument ARG to return (COMMAND FILE SAVED).
(defalias 'antlr-run-tool-interactive #[nil "\212\214~\210\305 *A@A\306\203!\307\n?\310\"\210\311\312\313 !@\"@\314\315	\316Q\"\fE*\207" [supers glibs antlr-ask-about-save antlr-tool-command buffer-file-name antlr-file-dependencies "" save-some-buffers nil antlr-superclasses-glibs antlr-directory-dependencies antlr-default-directory antlr-read-shell-command "Run Antlr on current file with: " " "] 5 (#$ . 68738)])
#@134 Insert Makefile variable numbered NUMBER according to specification.
Also insert strings PRE and POST before and after the variable.
(defalias 'antlr-makefile-insert-variable #[(number pre post) "\211A@)\211\205!\f\203\306\n\211A@)\f\"\202\n@
\261)\207" [antlr-makefile-specification x spec pre number post format] 5 (#$ . 69274)])
#@171 Insert Makefile rules in the current buffer at point.
IN-MAKEFILE is non-nil, if the current buffer is the Makefile.  See
command `antlr-show-makefile-rules' for detail.
(defalias 'antlr-insert-makefile-rules #[(&optional in-makefile) "\306 \307!\211@	A\310
\211A@)AA@\206\311A\205/
\211A@)\205/\312 \204:!q\210\310\"\211#\203\276
#@\211\"A@A\313\"AAA$\"A%&\203eT\314\315\316#\210&\203\204\311\317'\211A@)\320\"@!\"\261\210\"A@@\310(\211#\203\323#@()%\211A@)\310*\211#\203\311#@*)\317*(@\"\261\210\311)#A\211#\204\254+#A\211#\204\222*\"AA@@\310+\211#\203\"
#@+)'@%@B\310,\211#\203
#@,)\317,+\"\261\210\311)#A\211#\204\374+#A\211#\204\343*\314\321\322#\210\323\"@\261\210\"AA@A\310-\211#\203Y
#@-\311\317'@-\"\261\210#A\211#\204@
*\324&\n\"\211.\211A@)\203m
\325.\211AA)\310/\211#\203\245
#@/\311/@\261\210/A\203\234
\311\317'@/A\"\261\210#A\211#\204~
*\326
AA@.@\327
@\261\210+#A\211#\204D*\203\352
\3120\314\310\315\316#\2100T\2110X\203\343
\3140\330\322#\210\202\315
\331
@\261\210)
@\331\230\203\365
\332\333!\210\f\203eb\2101c\210 ?\205\334ed\"\210eb\210\3172\"c.\207" [dirname deps0 classes deps with-error antlr-makefile-specification antlr-default-directory antlr-directory-dependencies nil " " 0 assoc antlr-makefile-insert-variable "" " =" format file-name-sans-extension "\n$(" ")" ": " antlr-superclasses-glibs t "\n	" " $<\n" " $(" "\n" backward-delete-char 1 copy-region-as-kill x gen-sep n in-makefile standard-output dep --dolist-tail-- antlr-file-formats-alist lang supers antlr-special-file-formats class-def sep class-file evocab vocab-file ivocab glibs super i antlr-help-unknown-file-text antlr-help-rules-intro] 6 (#$ . 69624)])
#@785 Show Makefile rules for all grammar files in the current directory.
If the `major-mode' of the current buffer has the value `makefile-mode',
the rules are directory inserted at point.  Otherwise, a *Help* buffer
is shown with the rules which are also put into the `kill-ring' for
\[yank].

This command considers import/export vocabularies and grammar
inheritance and provides a value for the "-glib" option if necessary.
Customize variable `antlr-makefile-specification' for the appearance of
the rules.

If the file for a super-grammar cannot be determined, special file names
are used according to variable `antlr-unknown-file-formats' and a
commentary with value `antlr-help-unknown-file-text' is added.  The
*Help* buffer always starts with the text in `antlr-help-rules-intro'.
(defalias 'antlr-show-makefile-rules #[nil "\300\301!\204\n\302\303!\207\304 \210\303\305!\207" [derived-mode-p makefile-mode antlr-with-displaying-help-buffer antlr-insert-makefile-rules push-mark t] 2 (#$ . 71439) nil])
#@924 Indent the current line as ANTLR grammar code.
The indentation of grammar lines are calculated by `c-basic-offset',
multiplied by:
 - the level of the paren/brace/bracket depth,
 - 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-whitespace.

Lines inside block comments are indented by `c-indent-line' according to
`antlr-indent-comment'.

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'.
(defalias 'antlr-indent-line #[nil "\214`e\306\211\211\211\211~\210\307 \210`\211
W\203!\310\311!\210\312\306w\210`\313 \314\216\315 !\210\316 \210\317 \2119\203B\306\202\205\320\321\322\"\210\323\324!\203T`SW\202U\322\203]\325\202\205\323\326!\203i`W\202j\322\203r\327\202\205\306u\210\330\306!\210`V\203\203\331\202\204\325*\316 \210b\210\n\203\362	\325V\203\362	\331V\203\241\306\202\362\n\325U\203\277!\"\236\203\277\332!\"\236A!\203\277\304\202\362\333 \211\203\362\306#$$\211A$@\211#\203\361#A\203\314#@%>\204\352\306\306\211$\202\316*\n\204
b\210	\247\204

	\334=?\205Y
&\322=\205Y
\335!\202Y
b\210	9\2045
\n\317 \\\211\325V\2030
\332'!\2030
\nS\n(_dZi\nU\204K
\f|\210\307 \210\nj\210dZ`V\205Y
dZb.\207" [cc-syntax syntax indent boi bol min0 nil beginning-of-line error "Beginning of current line not visible" " 	" syntax-table ((set-syntax-table stab)) set-syntax-table antlr-invalidate-context-cache antlr-syntactic-context antlr-next-rule -1 t antlr-search-forward ":" 0 ";" 2 antlr-skip-exception-part 1 looking-at c-guess-basic-syntax string c-indent-line orig stab antlr-action-syntax-table antlr-language antlr-indent-at-bol-alist symbol cc antlr-disabling-cc-syntactic-symbols antlr-indent-comment antlr-indent-item-regexp c-basic-offset] 8 (#$ . 72453)])
#@247 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'.
(defalias 'antlr-indent-command #[(&optional arg) "\204\n	\303=\203\304!\207\n\205\305\306 )\207" [arg last-command antlr-indent-comment antlr-indent-command insert-tab t antlr-indent-line] 2 (#$ . 74741) "*P"])
#@583 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'.
(defalias 'antlr-electric-character #[(&optional arg) "\204/\212\305\306x\210n)\203/\307 \310\216\311\n!\210\312 \210\313 \211\247\205+\314!\206+\f\315>+\2045\316\317!!\207\316\317!!\210\320 \207" [arg stab antlr-action-syntax-table context last-command-event " 	" nil syntax-table ((set-syntax-table stab)) set-syntax-table antlr-invalidate-context-cache antlr-syntactic-context zerop (123 125) self-insert-command prefix-numeric-value antlr-indent-line] 4 (#$ . 75214) "*P"])
#@66 Like `c-init-language-vars-for' when using cc-mode before v5.29.
(defalias 'antlr-c-init-language-vars #[nil "\303=\203\n\304\202\305\211\205(\306	@!\203\307\310\311\217\210	\211AA)\211\204\307)\207" [antlr-language settings x c++-mode (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) (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 c-inexpr-class-key c-Java-inexpr-class-key) boundp nil (byte-code "@\302\211A@)!L\207" [settings x eval] 4) ((error))] 4 (#$ . 76291)])
#@157 Find language in `antlr-language-alist' for language option.
If SEARCH is non-nil, find element for language option.  Otherwise, find
the default language.
(defalias 'antlr-language-option #[(search) "\205\212eb\210\306	A`	@\\\307#)\205\310\311!\n\312\f\203>\f\211A@
\211AA)\235\2039\312\211\202\312\202@+\207" [search antlr-language-limit-n-regexp antlr-language-alist r seq value re-search-forward t match-string 1 nil x] 5 (#$ . 77236)])
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [antlr-mode-hook variable-documentation put purecopy "Hook run when entering Antlr mode.\nNo problems result if this variable is not bound.\n`add-hook' automatically binds it.  (This is true for all hook variables.)" boundp antlr-mode-map definition-name antlr-mode] 5)
(defvar antlr-mode-map (make-sparse-keymap))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\305\306!\204\302\306\307\310#\210\300\207" [antlr-mode-map variable-documentation put purecopy "Keymap for `antlr-mode'." boundp antlr-mode-syntax-table definition-name antlr-mode] 5)
(defvar antlr-mode-syntax-table (make-syntax-table))
(byte-code "\300\301N\204\302\300\301\303\304!#\210\302\305\306\307#\207" [antlr-mode-syntax-table variable-documentation put purecopy "Syntax table for `antlr-mode'." antlr-mode derived-mode-parent prog-mode] 5)
#@218 Major mode for editing ANTLR grammar files.

In addition to any hooks its parent mode `prog-mode' might have run,
this mode runs the hook `antlr-mode-hook', as the final step
during initialization.

\{antlr-mode-map}
(defalias 'antlr-mode #[nil "\306\300!\210\307\310 \210\311\312\310\313N\203\314\311\313\310\313N#\210\315!\204'\316\317 \"\210\320\f!\211\2036
\321 =\203<\322\f\323 \"\210)\324!\210\325\f!\2109:\326 \210\327\330!\204V\331\332M\210\204j\306\333!\210\334\307!\206h\334\335!;\236\211<A@);\203\207\336;\236\211<A@)P=\327\337!\203\231\337!\210\202\273\327\340!\203\250\340 \210\335>\202\273\327\341!\203\270\341\211? \210)\202\273\342 \210\343@\206\304\344\"\210\306\345!\210\346%\306\347!\210\350'\306\351!\210\352)\306\353!\210\335+\354A\355B\356C\306\357!\210D/\360E!\210\306\361!\210\3621\306\363!\210\3073F\203 
\327\364!\203 
\364F;\203
F\202
\365!\210\366 \210)\367\370!\207" [delay-mode-hooks major-mode mode-name antlr-mode-map antlr-mode-syntax-table parent make-local-variable t prog-mode antlr-mode "Antlr" mode-class put keymap-parent set-keymap-parent current-local-map char-table-parent standard-syntax-table set-char-table-parent syntax-table use-local-map set-syntax-table c-initialize-cc-mode fboundp c-forward-sws antlr-c-forward-sws c-forward-syntactic-ws antlr-language antlr-language-option nil "Antlr." c-init-language-vars-for c-init-c-language-vars c-init-language-vars antlr-c-init-language-vars c-basic-common-init "gnu" outline-regexp "[^#\n
]" outline-level c-outline-level indent-line-function antlr-indent-line indent-region-function "// " "" "/\\*+ *\\|// *" font-lock-defaults easy-menu-add imenu-create-index-function antlr-imenu-create-index-function imenu-generic-expression imenu-add-to-menubar "Index" antlr-set-tabs run-mode-hooks antlr-mode-hook antlr-mode-abbrev-table local-abbrev-table antlr-language-alist x c-buffer-is-cc-mode c-recognize-knr-p init-fn antlr-indent-style comment-start comment-end comment-start-skip antlr-font-lock-defaults antlr-mode-menu antlr-imenu-name] 6 (#$ . 78628) nil])
(put 'antlr-mode 'mode-name "Antlr")
#@139 Use ANTLR's convention for TABs according to `antlr-tab-offset-alist'.
Used in `antlr-mode'.  Also a useful function in `java-mode-hook'.
(defalias 'antlr-set-tabs #[nil "\205H	\306\205G\211A@\211@\203\n@\f=\203\n\211A@)\2033\307\n\211A@)\"\203\nAA@\nAAA@	\306\211\204\f\306*\207" [buffer-file-name antlr-tab-offset-alist elem alist major-mode x nil string-match tab-width indent-tabs-mode] 4 (#$ . 80792)])
(provide 'antlr-mode)