header
(-H)header
as the pathname to the file preincluded in the
parser's base-class header. This option is useful in situations
where the base class header file refers to types which might not
yet be known. E.g., with %union a std::string * field
might be used. Since the class std::string might not yet be
known to the compiler once it processes the base class header file
we need a way to inform the compiler about these classes and
types. The suggested procedure is to use a pre-include header file
declaring the required types. By default header
will be
surrounded by double quotes (using, e.g., #include "header"
).
When the argument is surrounded by pointed brackets
#include <header>
will be included. In the latter case,
quotes might be required to escape interpretation by the shell
(e.g., using -H '<header>'
).
header
(-b)header
as the pathname of the file containing the parser's
base class. This class defines, e.g., the parser's symbolic
tokens. Defaults to the name of the parser class plus the suffix
base.h
. It is generated, unless otherwise indicated (see
--no-baseclass-header and --dont-rewrite-baseclass-header
below).
skeleton
(-B)skeleton
as the pathname of the file containing the
skeleton of the parser's base class. Its filename defaults to
bisonc++base.h
.
header
(-c)header
as the pathname of the file containing the parser
class. Defaults to the name of the parser class plus the suffix
.h
skeleton
(-C)skeleton
as the pathname of the file containing the
skeleton of the parser class. Its filename defaults to
bisonc++.h
. The environment variable BISON_SIMPLE_H
is not inspected anymore.
parse()
and its support functions with debugging code,
showing the actual parsing process on the standard output
stream. When included, the debugging output is active by default,
but its activity may be controlled using the setDebug(bool
on-off) member. Note that no #ifdef DEBUG
macros are used
anymore. By rerunning bisonc++() without the --debug option an
equivalent parser is generated not containing the debugging
code.
filename
(-f)header
(-i)header
as the pathname of the file containing the
implementation header. Defaults to the name of the generated
parser class plus the suffix .ih
. The implementation header
should contain all directives and declarations only used by
the implementations of the parser's member functions. It is the
only header file that is included by the source file containing
parse()
's implementation . User defined implementation of
other class members may use the same convention, thus
concentrating all directives and declarations that are required
for the compilation of other source files belonging to the parser
class in one header file.
skeleton
(-I)skeleton
as the pathname of the file containing the
skeleton of the implementation header. Its filename defaults to
bisonc++.ih
.
ostreams
.
parse()
function. By including this option the
compiler and debuggers will associate errors with lines in your
grammar specification file, rather than with the source file
containing the parse()
function itself.
value
namespace
(-n)namespace
. By default
no namespace is defined. If this options is used the
implementation header will contain a commented out using
namespace
declaration for the requested namespace.
parse()
function. This option is primarily useful
in combination with the %lines directive, to suppress that
directive. It also overrides option --lines, though.
parse()
member function is
(re)written each time bisonc++() is called. Note that this option
should normally be avoided, as this file contains parsing
tables which are altered whenever the grammar definition is
modified.
skeleton
(-P)skeleton
as the pathname of the file containing the parsing
member function's skeleton. Its filename defaults to
bisonc++.cc
. The environment variable BISON_SIMPLE
is not
inspected anymore.
source
(-p)source
as the name of the source file containing the
parser member function parse()
. Defaults to parse.cc
.
value
--required-tokens
(as well
as the directive %requireed-tokens
) can be used to specify the number of
tokens that must have been successfully processed before the parsing function
reports another syntactic error. By default the number of required tokens is
initialized to 0.
header
(-s)header
as the pathname to the file defining a class
Scanner, offering a member int yylex()
producing the next
token from the input stream to be analyzed by the parser generated
by bisonc++(). When this option is used the parser's member int
lex() will be predefined as
int lex() { return d_scanner.yylex(); }and an object
Scanner d_scanner
will be composed into the
parser. The d_scanner
object will be constructed using its
default constructor. If another constructor is required, the
parser class may be provided with an appropriate (overloaded)
parser constructor after having constructed the default parser
class header file using bisonc++(). By default header
will be
surrounded by double quotes (using, e.g., #include "header"
).
When the argument is surrounded by pointed brackets #include
<header>
will be included. In the latter case, quotes might be
required to escape interpretation by the shell (e.g., using -s
'<header>'
).
directory
-B -C, -H,
and -I
).
<grammar>.output
, where <grammar>
is the name of the file containing the grammar definition (i.e,
the file passed as argument to bisonc++()).
bisonc++ by Frank B. Brokken (f.b.brokken@rug.nl) LALR(1) Parser Generator V 2.4.5 Copyright (c) GPL 2005-2008. NO WARRANTY. Designed after `bison++' (1.21.9-1) by Alain Coetmeur <coetmeur@icdc.fr> Usage: bisonc++ [OPTIONS] file Where: [OPTIONS] - zero or more optional arguments (int options between parentheses. Short options require arguments if their long option variants do too): --analyze-only (-A): only analyze the grammar; except for possibly the verbose grammar description file no files are written. --baseclass-preinclude=<header> (-H): preinclude header in the base-class header file. Use [header] to include <header>, otherwise "header" will be included. --baseclass-header=<header> (-b): filename holding the base class definition. --baseclass-skeleton=<skeleton> (-B): location of the baseclass header skeleton. --class-header=<header> (-c): filename holding the parser class definition. --class-skeleton=<skeleton> (-C): location of the class header skeleton. --construction: write details about the grammar analysis to stdout. --debug: generates debug output statements in the parse function's source. --error-verbose: the parse function will dump the parser's state stack to stdout when a syntactic error is reported --filenames=<filename> (-f): filename of output files (overruling the default filename). --force-class-header: overwrite an existing class header file. --force-implementation-header: overwrite an existing implementation header file. --help (-h): produce this information (and terminate). --implementation-header=<header> (-i): filename holding the implementation header. --implementation-skeleton=<skeleton> (-I): location of the implementation header skeleton. --include-only: catenate all grammar files in their order of processing to the standard output stream and terminate. --insert-stype: show selected semantic values in the output generated by --debug. Ignored unless --debug was specified. --lines (-l): put #line directives in generated output. --max-inclusion-depth=<value>: sets the maximum number of nested grammar files (default: 10). --namespace=<namespace>, (-n): define the parser in the mentioned namespace. --no-baseclass-header: don't create the parser's base class header. --no-lines: don't put #line directives in generated output, overruling the %lines directive. --no-parse-member: don't create the member parse(). --parser-skeleton=<parserskel> (-P): location of the parse function's skeleton. --parsefun-source=<source> (-p): filename holding the parse function's source. --required-tokens=<value>: minimum number of successfully processed tokens between errors (default: 0). --scanner=<header-file> (-s): include `header-file' declaring the class Scanner, and call d_scanner.yylex() from Parser::lex(). --scanner-debug: show de scanner's matched rules and returned tokens. --show-filenames: show the names of the used/generated files on the standard error stream. --skeleton-directory=<skeleton-directory> (-S): location of the skeleton directory. --thread-safe: no static data are modified, making bisonc++'s generated code thread-safe. --usage: produce this information (and terminate). --verbose (-V): generate verbose description of the analyzed grammar. --version (-v): display bisonc++'s version and terminate.