Variable: antlr-v3-options-alists
antlr-v3-options-alists is a variable defined in antlr-mode.el.gz.
Value
(nil
(("language" antlr-language-option-extra antlr-read-language
"Generated language: ")
("tokenVocab" nil antlr-read-value "Token vocabulary: ")
("output" nil antlr-read-value "Output type (AST or template): ")
("TokenLabelType" nil antlr-read-value "Token type: ")
("superClass" nil antlr-read-value "Super class: ")
("filter" nil antlr-read-boolean "Lexical filter? ")
("rewrite" nil antlr-read-value "Template rewrite: ")
("k" nil antlr-read-value "Lookahead depth: ")
("backtrack" nil antlr-read-boolean
"Use automatic backtracking if necessary? ")
("memoize" nil antlr-read-boolean
"Store backtracking calculations? "))
(("backtrack" nil antlr-read-boolean
"Use automatic backtracking if necessary? ")
("memoize" nil antlr-read-boolean
"Store backtracking calculations? "))
(("k" nil antlr-read-value "Lookahead depth: ")
("greedy" nil antlr-read-boolean
"Make this optional/loop subrule greedy? ")))
Documentation
Value for antlr-options-alists when using ANTLR v3.
Source Code
;; Defined in /usr/src/emacs/lisp/progmodes/antlr-mode.el.gz
;;; v3:
;; https://theantlrguy.atlassian.net/wiki/display/ANTLR3/ANTLR+3+Wiki+Home
;; $ANTLR3/tool/src/main/java/org/antlr/tool/Grammar.java
;; https://theantlrguy.atlassian.net/wiki/display/ANTLR3/Grammar+options
;; https://theantlrguy.atlassian.net/wiki/display/ANTLR3/Rule+and+subrule+options
(defvar antlr-v3-options-alists
'(() ; no file options
(;; grammar options ------------------------------------------------------
("language"
;; The target language for code generation. Default is Java. See Code
;; Generation Targets for list of currently supported target languages.
antlr-language-option-extra antlr-read-language "Generated language: ")
("tokenVocab"
;; Where ANTLR should get predefined tokens and token types. Tree
;; grammars need it to get the token types from the parser that creates
;; its trees. Default value: Do not import token vocab.
nil antlr-read-value "Token vocabulary: ")
("output" ; parser and tree only
;; The type of output the generated parser should return. Valid values
;; are AST and template. TODO: Briefly, what are the interpretations of
;; these values? Default value: nothing
nil antlr-read-value "Output type (AST or template): ") ; TODO: completion
("TokenLabelType" ; parser and tree only
;; Set the type of all tree labels and tree-valued expressions. Without
;; this option, trees are of type Object. TODO: Cross-reference default
;; impl (org.antlr.runtime.tree.CommonTree in Java)?
nil antlr-read-value "Token type: ")
("superClass" ; in combined grammar: for parser
;; Set the superclass of the generated recognizer. Default value
;; Lexer/Parser/TreeParser (org.antlr.runtime.Parser in Java)?
nil antlr-read-value "Super class: ")
("filter" ; lexer only
;; In the lexer, this allows you to try a list of lexer rules in
;; order. The first one that matches, wins. This is the token that
;; nextToken() returns. If nothing matches, the lexer consumes a single
;; character and tries the list of rules again. See Lexical filters for
;; more., Default: false
nil antlr-read-boolean "Lexical filter? ")
("rewrite" ; parser and tree only
;; Valid values are true and false. Default is false. Use this option
;; when your translator output looks very much like the input. Your
;; actions can modify the TokenRewriteStream to insert, delete, or
;; replace ranges of tokens with another object. Used in conjunction with
;; output=template, you can very easily build translators that tweak
;; input files.
nil antlr-read-value "Template rewrite: ")
("k" ; parser and tree only
;; Limit the lookahead depth for the recognizer to at most k
;; symbols. This prevents the decision from using acyclic LL* DFA.
nil antlr-read-value "Lookahead depth: ")
("backtrack" ; parser and tree only
;; Valid values are true and false. Default is false. Taken from
;; http://www.antlr.org:8080/pipermail/antlr-interest/2006-July/016818.html
;; : The new feature (a big one) is the backtrack=true option for
;; grammar, rule, and block that lets you type in any old crap and ANTLR
;; will backtrack if it can't figure out what you meant. No errors are
;; reported by antlr during analysis. It implicitly adds a syn pred in
;; front of every production, using them only if static grammar LL*
;; analysis fails. Syn pred code is not generated if the pred is not used
;; in a decision. This is essentially a rapid prototyping mode. It is
;; what I have used on the java.g. Oh, it doesn't memoize partial parses
;; (i.e. rule parsing results) during backtracking automatically now. You
;; must also say memoize=true. Can make a HUGE difference to turn on.
nil antlr-read-boolean "Use automatic backtracking if necessary? ")
("memoize" ; parser and tree only
;; Valid values are true and false. When backtracking, remember whether
;; or not rule references succeed so that the same input position cannot
;; be parsed more than once by the same rule. This effectively guarantees
;; linear parsing when backtracking at the cost of more memory. TODO:
;; Default value: false
nil antlr-read-boolean "Store backtracking calculations? "))
(;; rule options ---------------------------------------------------------
("backtrack"
nil antlr-read-boolean "Use automatic backtracking if necessary? ")
("memoize"
nil antlr-read-boolean "Store backtracking calculations? "))
(;; subrule options ------------------------------------------------------
("k"
nil antlr-read-value "Lookahead depth: ")
("greedy" ; default true
nil antlr-read-boolean "Make this optional/loop subrule greedy? ")))
"Value for `antlr-options-alists' when using ANTLR v3.")