Return to bison.rnh CVS log

Up to [Apple XNU] / GNUtools / bison

Annotation of GNUtools/bison/bison.rnh, revision 1.1

1.1     ! root        1: .!
        !             2: .!     RUNOFF source file for BISON.HLP 
        !             3: .!
        !             4: .!     This is a RUNOFF input file which will produce a VMS help file
        !             5: .!     for the VMS HELP library.
        !             6: .!
        !             7: .!     Date of last revision: June 21, 1992
        !             8: .!
        !             9: .!
        !            10: .!     Eric Youngdale
        !            11: .!
        !            12: .literal
        !            13: .end literal
        !            14: .no paging
        !            15: .no flags all
        !            16: .right margin 70
        !            17: .left margin 1
        !            18: 
        !            19: .indent -1
        !            20: 1 BISON
        !            21: .skip
        !            22:  The BISON command invokes the GNU BISON parser generator.
        !            23: .skip
        !            24: .literal
        !            25:       BISON file-spec
        !            26: .end literal
        !            27: .skip
        !            28: .indent -1
        !            29: 2 Parameters
        !            30: .skip
        !            31:  file-spec
        !            32: .skip
        !            33: Here file-spec is the grammar file name, which usually ends in
        !            34: .y.  The parser file's name is made by replacing the .y
        !            35: with _tab.c.  Thus, the command bison foo.y yields
        !            36: foo_tab.c.
        !            37: 
        !            38: .skip
        !            39: .indent -1
        !            40: 2 Qualifiers
        !            41: .skip
        !            42:  The following is the list of available qualifiers for BISON:
        !            43: .literal
        !            44:        /DEBUG
        !            45:        /DEFINES
        !            46:        /FILE_PREFIX=prefix
        !            47:        /FIXED_OUTFILES
        !            48:        /NAME_PREFIX=prefix
        !            49:        /NOLINES
        !            50:        /OUTPUT=outfilefile
        !            51:        /VERBOSE
        !            52:        /VERSION
        !            53:        /YACC
        !            54: .end literal
        !            55: .skip
        !            56: .indent -1
        !            57: 2 /DEBUG
        !            58: .skip
        !            59: Output a definition of the macro YYDEBUG into the parser file,
        !            60: so that the debugging facilities are compiled.
        !            61: .skip
        !            62: .indent -1
        !            63: 2 /DEFINES
        !            64: .skip
        !            65: Write an extra output file containing macro definitions for the token
        !            66: type names defined in the grammar and the semantic value type
        !            67: YYSTYPE, as well as a extern variable declarations.
        !            68: .skip
        !            69: If the parser output file is named "name.c" then this file
        !            70: is named "name.h".
        !            71: .skip
        !            72: This output file is essential if you wish to put the definition of
        !            73: yylex in a separate source file, because yylex needs to
        !            74: be able to refer to token type codes and the variable
        !            75: yylval.
        !            76: .skip
        !            77: .indent -1
        !            78: 2 /FILE_PREFIX
        !            79: .skip
        !            80: .literal
        !            81:   /FILIE_PREFIX=prefix
        !            82: .end literal
        !            83: .skip
        !            84:        Specify a prefix to use for all Bison output file names.  The names are
        !            85: chosen as if the input file were named prefix.c
        !            86: 
        !            87: .skip
        !            88: .indent -1
        !            89: 2 /FIXED_OUTFILES
        !            90: .skip
        !            91: Equivalent to /OUTPUT=y_tab.c; the parser output file is called
        !            92: y_tab.c, and the other outputs are called y.output and
        !            93: y_tab.h.  The purpose of this switch is to imitate Yacc's output
        !            94: file name conventions.  The /YACC qualifier is functionally equivalent
        !            95: to /FIXED_OUTFILES.  The following command definition will
        !            96: work as a substitute for Yacc:
        !            97: 
        !            98: .literal
        !            99: $YACC:==BISON/FIXED_OUTFILES
        !           100: .end literal
        !           101: .skip
        !           102: .indent -1
        !           103: 2 /NAME_PREFIX
        !           104: .skip
        !           105: .literal
        !           106:   /NAME_PREFIX=prefix
        !           107: .end literal
        !           108: .skip
        !           109: Rename the external symbols used in the parser so that they start with
        !           110: "prefix" instead of "yy".  The precise list of symbols renamed
        !           111: is yyparse, yylex, yyerror, yylval, yychar and yydebug.
        !           112: 
        !           113: For example, if you use /NAME_PREFIX="c", the names become cparse,
        !           114: clex, and so on.
        !           115: 
        !           116: .skip
        !           117: .indent -1
        !           118: 2 /NOLINES
        !           119: .skip
        !           120: Don't put any "#line" preprocessor commands in the parser file.
        !           121: Ordinarily Bison puts them in the parser file so that the C compiler
        !           122: and debuggers will associate errors with your source file, the
        !           123: grammar file.  This option causes them to associate errors with the
        !           124: parser file, treating it an independent source file in its own right.
        !           125: 
        !           126: .skip
        !           127: .indent -1
        !           128: 2 /OUTPUT
        !           129: .skip
        !           130: .literal
        !           131:   /OUTPUT=outfile
        !           132: .end literal
        !           133: .skip
        !           134: Specify the name "outfile" for the parser file.
        !           135: .skip
        !           136: .indent -1
        !           137: 2 /VERBOSE
        !           138: .skip
        !           139: Write an extra output file containing verbose descriptions of the
        !           140: parser states and what is done for each type of look-ahead token in
        !           141: that state.
        !           142: .skip
        !           143: This file also describes all the conflicts, both those resolved by
        !           144: operator precedence and the unresolved ones.
        !           145: .skip
        !           146: The file's name is made by removing _tab.c or .c from
        !           147: the parser output file name, and adding .output instead.
        !           148: .skip
        !           149: Therefore, if the input file is foo.y, then the parser file is
        !           150: called foo_tab.c by default.  As a consequence, the verbose
        !           151: output file is called foo.output.
        !           152: .skip
        !           153: .indent -1
        !           154: 2 /VERSION
        !           155: .skip
        !           156: Print the version number of Bison.
        !           157: 
        !           158: .skip
        !           159: .indent -1
        !           160: 2 /YACC
        !           161: .skip
        !           162: See /FIXED_OUTFILES.
        !           163: .skip
        !           164: .indent -1
        !           165: 
        !           166: 
        !           167: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.