Annotation of coherent/a/usr/man/COHERENT/lex, revision 1.1.1.1

1.1       root        1: 
                      2: 
                      3: lex                          Command                          lex
                      4: 
                      5: 
                      6: 
                      7: 
                      8: Lexical analyzer generator
                      9: 
                     10: lleexx [-tt][-vv][_f_i_l_e]
                     11: cccc lleexx.yyyy.cc -llll
                     12: 
                     13: Many programs,  e.g., compilers, process  highly structured input
                     14: according to  rules.  Two of  the most complicated  parts of such
                     15: programs  are lexical  analysis and  parsing (also  called syntax
                     16: analysis).   The  COHERENT  system  includes two  powerful  tools
                     17: called  lex and  yacc  to help  you  construct these  parts of  a
                     18: program.   lex converts  a set  of lexical  rules into  a lexical
                     19: analyzer, and yacc converts a set of parsing rules into a parser.
                     20: 
                     21: The output of lex may be  used directly, or may be used by a par-
                     22: ser generated by yacc.
                     23: 
                     24: lex reads a specification from  the given file (or from the stan-
                     25: dard input  if none), and generates a  C function called yylex().
                     26: lex writes  the generated  function in  the file lex.yy.c,  or on
                     27: standard output  if you use the -t option.   The -v option prints
                     28: some statistics about the generated tables.
                     29: 
                     30: The tutorial  on lex that appear in this  manual describes lex in
                     31: detail.  In  brief, the  generated function yylex()  matches por-
                     32: tions of  its input  to one  pattern (sometimes called  a regular
                     33: expression) from  a set  of rules,  or context, and  executes as-
                     34: sociated C commands.   Unmatched portions of the input are copied
                     35: to the  output stream.  yylex()  returns EOF when  input has been
                     36: exhausted.
                     37: 
                     38: lex  uses the  following  macros that  you may  replace with  the
                     39: preprocessor  directive #undef  if  you wish:  iinnppuutt() (read  the
                     40: standard input  stream), and oouuttppuutt(_c) (write  the character c to
                     41: the standard output  stream).  You may also replace the following
                     42: functions if you  wish: mmaaiinn() (main function), eerrrroorr(...) (print
                     43: error  messages; takes  same arguments  as printf),  and yyyywwrraapp()
                     44: (handle events at the end of a file).  If an action is desired on
                     45: end of  file, such as  arranging for more  input, yywrap() should
                     46: perform it, returning zero to keep going.
                     47: 
                     48: A full lex specification has the following format:
                     49: 
                     50: *  Macro definitions, of the form:       name    pattern
                     51: 
                     52: *  Start condition declarations: %S      NAME ...
                     53: 
                     54: *  Context declarations: %C      NAME ...
                     55: 
                     56: *  Code to be included in the header section:    %{
                     57:            anything
                     58:            %}
                     59:            <tab or space> anything
                     60: 
                     61: 
                     62: 
                     63: 
                     64: COHERENT Lexicon                                           Page 1
                     65: 
                     66: 
                     67: 
                     68: 
                     69: lex                          Command                          lex
                     70: 
                     71: 
                     72: 
                     73: *  Rules section delimiter (must always be present):     %%
                     74: 
                     75: *  Code to appear at the start of yyyylleexx():       <tab or space> anything
                     76: 
                     77: * Rulesfor initialcontext, inanyof theforms:       rule
                     78:    action;
                     79:            rule            | (means use next action)
                     80:            rule            {
                     81:            <tab or space>  action;
                     82:            <tab or space>  }
                     83: 
                     84: *  For each additional context:  %C      NAME
                     85:            ...rules for this context...
                     86: 
                     87: *  End of rules section delimiter:       %%
                     88: 
                     89: *  Code  to be  copied verbatim, such  as user  provided iinnppuutt(),
                     90:    oouuttppuutt(), yyyywwrraapp(), or other.
                     91: 
                     92: lex matches  the longest string possible; if  two rules match the
                     93: same length  string, the  rule specified first  takes precedence.
                     94: lex  puts  the  matched  string,  or  token, in  the  char  array
                     95: yytext[], and sets the variable yyleng to its length.
                     96: 
                     97: Actions may use the following:
                     98: 
                     99: 
                    100:      EECCHHOO           Output the token
                    101:      RREEJJEECCTT         Perform action for lower precedence match
                    102:      BBEEGGIINN _N_A_M_E     Set start condition to _N_A_M_E
                    103:      BBEEGGIINN 00        Clear start condition
                    104:      yyyysswwiittcchh(_N_A_M_E) Switch to context _N_A_M_E, return current
                    105:      yyyysswwiittcchh(00)    Switch to initial context
                    106:      yyyynneexxtt()       Steal next character from input
                    107:      yyyybbaacckk(_c)      Put character _c back into input
                    108:      yyyylleessss(_n)      Reduce token length to _n, put rest back
                    109:      yyyymmoorree()       Append next token to this one
                    110:      yyyyllooookk()       Returns number of chars in input buffer
                    111: 
                    112: 
                    113: lex rules are contiguous strings of the form
                    114: 
                    115: 
                    116:      [ <_N_A_M_E,...> ][ ^ ] _t_o_k_e_n [ /_l_o_o_k_a_h_e_a_d ][ $ ]
                    117: 
                    118: 
                    119: where brackets `[]' indicate optional items.
                    120: 
                    121: 
                    122:      <_N_A_M_E,...>     Match only under given start conditions
                    123:      ^              Match the beginning of a line
                    124:      $              Match the end of a line
                    125:      _t_o_k_e_n          Pattern that a given token is to match
                    126:      /_l_o_o_k_a_h_e_a_d     Pattern that given trailing text is to match
                    127: 
                    128: 
                    129: 
                    130: COHERENT Lexicon                                           Page 2
                    131: 
                    132: 
                    133: 
                    134: 
                    135: lex                          Command                          lex
                    136: 
                    137: 
                    138: 
                    139: 
                    140: Pattern elements:
                    141: 
                    142: 
                    143:      aa       The character aa
                    144:      \aa      The character aa, even if special
                    145:      .       Any character except newline
                    146:      [aabbxx-zz]  Any of aa, bb, or xx through zz
                    147:      [^aabbxx-zz]Any except aa, bb, or xx through zz
                    148:      aabbcc     The string aabbcc, even if any are special
                    149:      {_n_a_m_e}  The macro definition _n_a_m_e
                    150:      (_e_x_p)   The pattern _e_x_p (grouping operator)
                    151: 
                    152: 
                    153: Optional operators on elements:
                    154: 
                    155: 
                    156:      _e?      Zero or one occurrence of _e
                    157:      _e*      Zero or more consecutive _es
                    158:      _e+      One or more consecutive _es
                    159:      _e{_n}    _n (a decimal number) consecutive _es
                    160:      _e{_m,_n}  _m through _n consecutive _es
                    161: 
                    162: 
                    163: Patterns may be of the form:
                    164: 
                    165: 
                    166:      _e_1_e_2    Matches the sequence _e_1 _e_2
                    167:      _e_1|_e_2   Matches either _e_1 or _e_2
                    168: 
                    169: 
                    170: lex recognizes  the standard C  escapes: \nn, \tt, \rr,  \bb, \ff, and
                    171: \_o_o_o (octal representation).  The special characters
                    172: 
                    173: 
                    174:          \ ( ) < > { } % * + ? [ - ] ^ / $ . |
                    175: 
                    176: 
                    177: must be  prefixed with \ or enclosed  within quotation marks (ex-
                    178: cepting " and \) to  be normal.  Within classes, only the charac-
                    179: ters . ^ - \ and ] are special.
                    180: 
                    181: ***** Files *****
                    182: 
                    183: /usr/lib/libl.a
                    184: 
                    185: ***** See Also *****
                    186: 
                    187: commands, yacc
                    188: _I_n_t_r_o_d_u_c_t_i_o_n _t_o _l_e_x, _t_h_e _L_e_x_i_c_a_l _A_n_a_l_y_z_e_r
                    189: 
                    190: 
                    191: 
                    192: 
                    193: 
                    194: 
                    195: 
                    196: COHERENT Lexicon                                           Page 3
                    197: 
                    198: 

unix.superglobalmegacorp.com

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