Home > antlr

antlr(1) - ANother Tool for Language Recognition
-ck n  Use  up  to  n  symbols of lookahead when using compressed (linear approximation) lookahead.  This
       type of lookahead is very cheap to compute and is attempted before full LL(k) lookahead, which  is
       of  exponential  complexity  in  the worst case.  In general, the compressed lookahead can be much
       deeper (e.g, -ck 10) than the full lookahead (which usually must be less than 4).
-CC    Generate C++ output from both ANTLR and DLG.
-cr    Generate a cross-reference for all rules.  For each rule, print a list of  all  other  rules  that
       reference it.
-e1    Ambiguities/errors shown in low detail (default).
-e2    Ambiguities/errors shown in more detail.
-e3    Ambiguities/errors shown in excruciating detail.
-fe file
       Rename err.c to file.
-fh file
       Rename stdpccts.h header (turns on -gh) to file.
-fl file
       Rename lexical output, parser.dlg, to file.
-fm file
       Rename file with lexical mode definitions, mode.h, to file.
-fr file
       Rename file which remaps globally visible symbols, remap.h, to file.
-ft file
       Rename tokens.h to file.
-ga    Generate ANSI-compatible code (default case).  This has not been rigorously tested to be ANSI XJ11
       C compliant, but it is close.  The normal output of antlr is currently compilable under both  K&R,
       ANSI  C,  and  C++—this  option does nothing because antlr generates a bunch of #ifdef's to do the
       right thing depending on the language.
-gc    Indicates that antlr should generate no C code, i.e., only perform analysis on the grammar.
-gd    C code is inserted in each of the antlr generated parsing functions to  provide  for  user-defined
       handling  of  a  detailed  parse  trace.  The inserted code consists of calls to the user-supplied
       macros or functions called zzTRACEIN and zzTRACEOUT.  The only argument is a char * pointing to  a
       C-style  string  which  is  the  grammar  rule  recognized by the current parsing function.  If no
       definition is given for the trace functions, upon rule entry and exit, a message will  be  printed
       indicating that a particular rule as been entered or exited.
-ge    Generate an error class for each non-terminal.
-gh    Generate  stdpccts.h  for  non-ANTLR-generated  files  to include.  This file contains all defines
       needed to describe the type of parser generated by antlr (e.g. how  much  lookahead  is  used  and
       whether or not trees are constructed) and contains the header action specified by the user.
-gk    Generate  parsers that delay lookahead fetches until needed.  Without this option, antlr generates
       parsers which always have k tokens of lookahead available.
-gl    Generate line info about grammar actions in C parser of the form # line "file" which  makes  error
       messages  from the C/C++ compiler make more sense as they will point into the grammar file not the
       resulting C file.  Debugging is easier as well, because you will step through the  grammar  not  C
-gs    Do  not  generate  sets  for  token  expression lists; instead generate a ||-separated sequence of
       LA(1)==token_number.  The default is to generate sets.
-gt    Generate code for Abstract-Syntax Trees.
-gx    Do not create the lexical analyzer files (dlg-related).  This option should be given when the user
       wishes  to  provide  a  customized lexical analyzer.  It may also be used in make scripts to cause
       only the parser to be rebuilt when a change not affecting the lexical structure  is  made  to  the
       input grammars.
-k n   Set k of LL(k) to n; i.e. set tokens of look-ahead (default==1).
-o dir Directory  where  output  files should go (default=".").  This is very nice for keeping the source
       directory clear of ANTLR and DLG spawn.
-p     The complete grammar, collected from all input grammar files and  stripped  of  all  comments  and
       embedded actions, is listed to stdout.  This is intended to aid in viewing the entire grammar as a
       whole and to eliminate the need to keep actions concisely stated so that the grammar is easier  to
       read.   Hence, it is preferable to embed even complex actions directly in the grammar, rather than
       to call them as subroutines, since the subroutine call overhead will be saved.
-pa    This option is the same as -p except that the output is annotated with the first  sets  determined
       from grammar analysis.
-prc on
       Turn on the computation and hoisting of predicate context.
-prc off
       Turn  off  the  computation and hoisting of predicate context.  This option makes 1.10 behave like
       the 1.06 release with option -pr on.  Context computation is off by default.

-rl n  Limit the maximum number of tree nodes used by grammar analysis  to  n.   Occasionally,  antlr  is
       unable  to  analyze  a grammar submitted by the user.  This rare situation can only occur when the
       grammar is large and the amount of lookahead is greater than one.  A nonlinear analysis  algorithm
       is used by PCCTS to handle the general case of LL(k) parsing.  The average complexity of analysis,
       however, is near linear due to some fancy footwork in the implementation which reduces the  number
       of  calls  to  the  full  LL(k)  algorithm.   An error message will be displayed, if this limit is
       reached, which indicates the grammar construct being analyzed when antlr hit a non-linearity.  Use
       this option if antlr seems to go out to lunch and your disk start thrashing; try n=10000 to start.
       Once the offending construct has been identified, try to  remove  the  ambiguity  that  antlr  was
       trying  to overcome with large lookahead analysis.  The introduction of (...)? backtracking blocks
       eliminates some of these problems — antlr does not analyze alternatives that begin with (...)? (it
       simply backtracks, if necessary, at run time).
-w1    Set  low  warning  level.   Do not warn if semantic predicates and/or (...)? blocks are assumed to
       cover ambiguous alternatives.
-w2    Ambiguous parsing decisions yield warnings even if semantic predicates or (...)? blocks are  used.
       Warn  if  predicate context computed and semantic predicates incompletely disambiguate alternative

Tips or Questions?

Powered by ExplainShell