home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 213b.lha / Flex / Flex1 / scan.c.dist < prev    next >
Text File  |  1996-02-14  |  42KB  |  1,316 lines
  1. #define YY_DEFAULT_ACTION YY_FATAL_ERROR( "flex scanner jammed" );
  2. #define FLEX_USE_ECS
  3. #define FLEX_USE_MECS
  4. /* A lexical scanner generated by flex */
  5.  
  6. #include "s:flexskeldef.h"
  7.  
  8. # line 1 "scan.l"
  9. #define INITIAL 0
  10. /* scan.l - scanner for flex input */
  11. /*
  12.  * Copyright (c) 1987, the University of California
  13.  *
  14.  * The United States Government has rights in this work pursuant to
  15.  * contract no. DE-AC03-76SF00098 between the United States Department of
  16.  * Energy and the University of California.
  17.  *
  18.  * This program may be redistributed.  Enhancements and derivative works
  19.  * may be created provided the new works, if made available to the general
  20.  * public, are made available for use by anyone.
  21.  */
  22. # line 16 "scan.l"
  23. #include "flexdef.h"
  24. #include "parse.h"
  25.  
  26. #define ACTION_ECHO fprintf( temp_action_file, "%s", yytext )
  27. #define MARK_END_OF_PROLOG fprintf( temp_action_file, "%%%% end of prolog\n" );
  28.  
  29. #undef YY_DECL
  30. #define YY_DECL \
  31.         int flexscan()
  32.  
  33. #define RETURNCHAR \
  34.         yylval = yytext[0]; \
  35.         return ( CHAR );
  36.  
  37. #define RETURNNAME \
  38.         (void) strcpy( nmstr, yytext ); \
  39.         return ( NAME );
  40.  
  41. #define PUT_BACK_STRING(str, start) \
  42.         for ( i = strlen( str ) - 1; i >= start; --i ) \
  43.             unput(str[i])
  44. #define SECT2 2
  45. #define SECT2PROLOG 4
  46. #define SECT3 6
  47. #define CODEBLOCK 8
  48. #define PICKUPDEF 10
  49. #define SC 12
  50. #define CARETISBOL 14
  51. #define NUM 16
  52. #define QUOTE 18
  53. #define FIRSTCCL 20
  54. #define CCL 22
  55. #define ACTION 24
  56. #define RECOVER 26
  57. #define BRACEERROR 28
  58. #define C_COMMENT 30
  59. #define C_COMMENT_2 32
  60. #define ACTION_COMMENT 34
  61. #define ACTION_STRING 36
  62. #define PERCENT_BRACE_ACTION 38
  63. # line 53 "scan.l"
  64. #define YY_JAM 226
  65. #define YY_JAM_BASE 800
  66. #define YY_TEMPLATE 227
  67. static char l[227] =
  68.     {   0,
  69.        -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,
  70.        -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,
  71.        -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,
  72.        -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,   -2,
  73.        14,    7,   13,   11,    7,   12,   14,   14,   14,   10,
  74.        46,   39,   40,   32,   46,   45,   30,   46,   46,   46,
  75.        39,   28,   46,   45,   31,    0,   27,   99,    0,   21,
  76.         0,   23,   22,   24,   52,   48,   49,   51,   53,   67,
  77.        68,   65,   64,   66,   54,   56,   55,   54,   60,   59,
  78.        60,   60,   62,   62,   62,   63,   76,   80,   79,   81,
  79.  
  80.        81,   74,   75,    0,   25,   70,   69,   17,   19,   18,
  81.        89,   91,   90,   83,   85,   84,   92,   94,   95,   96,
  82.        72,   72,   73,   72,    7,   11,    0,    7,    1,    0,
  83.         2,    0,    8,    4,    5,    0,    3,   10,   39,   40,
  84.         0,    0,   35,    0,    0,   97,   97,    0,   34,   33,
  85.        34,    0,   39,   28,    0,    0,    0,   42,   38,   26,
  86.         0,   23,   50,   51,   64,   98,   98,    0,   57,   58,
  87.        61,   76,    0,   78,    0,   77,   15,   87,   83,   82,
  88.        92,   93,   71,    1,    0,    9,    8,    0,    0,    6,
  89.        36,    0,   37,   43,    0,    0,   97,   34,   34,   44,
  90.  
  91.        29,    0,   36,    0,   29,    0,   42,    0,   20,   98,
  92.         0,   16,    0,   88,   71,    0,    0,   97,   98,    0,
  93.         0,   97,   98,    4,    0,    0
  94.     } ;
  95.  
  96. static char e[128] =
  97.     {   0,
  98.         1,    1,    1,    1,    1,    1,    1,    1,    2,    3,
  99.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  100.         1,    1,    1,    1,    1,    1,    1,    1,    1,    1,
  101.         1,    2,    1,    4,    5,    6,    7,    1,    8,    9,
  102.         9,   10,    9,   11,   12,    9,   13,   14,   15,   15,
  103.        15,   15,   15,   15,   15,   15,   15,    1,    1,   16,
  104.         1,   17,    9,    1,   23,   22,   22,   22,   22,   22,
  105.        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
  106.        22,   24,   25,   26,   22,   22,   22,   27,   22,   22,
  107.        18,   19,   20,   21,   22,    1,   23,   22,   22,   22,
  108.  
  109.        22,   22,   22,   22,   22,   22,   22,   22,   22,   22,
  110.        22,   22,   22,   24,   25,   26,   22,   22,   22,   27,
  111.        22,   22,   28,   29,   30,    1,    1
  112.     } ;
  113.  
  114. static char m[31] =
  115.     {   0,
  116.         1,    2,    3,    4,    1,    1,    1,    5,    1,    6,
  117.         1,    1,    5,    7,    7,    1,    1,    1,    8,    9,
  118.         1,    7,    7,    7,    7,    7,    7,    5,    1,   10
  119.     } ;
  120.  
  121. static short int b[276] =
  122.     {   0,
  123.         0,   26,   52,   80,  286,  285,    0,    0,  284,    1,
  124.         3,    7,   99,  116,  265,  264,  141,  169,   11,   13,
  125.         0,   22,   25,   47,  197,  225,  281,  280,    8,   10,
  126.        32,   54,   66,   69,   75,   85,   88,   99,  110,  112,
  127.       800,  280,  800,    0,   44,  800,  277,  104,  269,    0,
  128.       800,  144,  800,  800,   71,  800,  800,  259,   83,  242,
  129.       268,  800,  270,  266,  800,  271,    0,  800,  270,  800,
  130.        33,    0,  270,  800,  800,  800,  242,    0,  800,  800,
  131.       800,  800,   91,  800,  800,  800,  800,  114,  800,  800,
  132.       116,  250,  800,    0,  136,  800,    0,  800,  800,  126,
  133.  
  134.       251,  800,  800,  257,  800,  800,  800,  150,  800,  246,
  135.       151,  800,  245,    0,  800,  241,    0,  800,  800,    0,
  136.       249,  156,  800,  145,  249,    0,  247,  162,  800,  246,
  137.       800,  245,    0,  219,  800,  234,  800,    0,  167,  800,
  138.       206,  229,  800,  147,  165,  800,  162,    0,    0,  800,
  139.       284,  165,  313,  800,  178,  179,  184,    0,  800,  800,
  140.       218,    0,  800,    0,  178,  800,  180,    0,  800,  800,
  141.       800,    0,  190,  800,    0,  800,  216,  187,    0,  800,
  142.         0,  800,    0,  800,  185,  800,    0,  139,  146,  800,
  143.       800,  133,  800,  800,  188,  100,  197,    0,    0,  800,
  144.  
  145.       800,  210,  201,  213,  800,  212,    0,   97,  800,  203,
  146.        91,  800,   74,  800,    0,   51,  216,  209,  225,   34,
  147.       227,  800,  800,  800,  224,  800,  342,  352,  362,  372,
  148.       382,  392,  402,  412,  422,  432,  442,  452,  462,  472,
  149.       482,  492,  502,  512,   13,  522,  532,  542,   11,  552,
  150.       562,  572,  582,  592,  602,    0,  612,  622,  632,  642,
  151.       651,  661,  671,  681,  691,  701,  711,  721,  731,  740,
  152.       750,  760,  770,  780,  790
  153.     } ;
  154.  
  155. static short int d[276] =
  156.     {   0,
  157.       227,  227,  228,  228,  229,  229,  230,  230,  231,  231,
  158.       232,  232,  233,  233,  226,  226,  234,  234,  235,  235,
  159.       236,  236,  237,  237,  238,  238,  239,  239,  226,  226,
  160.       240,  240,  241,  241,  242,  242,  243,  243,  244,  244,
  161.       226,  226,  226,  245,  246,  226,  247,  248,  226,  249,
  162.       226,  226,  226,  226,  226,  226,  226,  250,  251,  252,
  163.       253,  226,  226,  226,  226,  229,  254,  226,  231,  226,
  164.       231,  255,  226,  226,  226,  226,  226,  256,  226,  226,
  165.       226,  226,  226,  226,  226,  226,  226,  251,  226,  226,
  166.       257,  258,  226,  259,  251,  226,  260,  226,  226,  261,
  167.  
  168.       226,  226,  226,  239,  226,  226,  226,  240,  226,  226,
  169.       241,  226,  226,  262,  226,  226,  263,  226,  226,  264,
  170.       244,  244,  226,  244,  226,  245,  246,  246,  226,  247,
  171.       226,  265,  266,  226,  226,  267,  226,  249,  226,  226,
  172.       226,  268,  226,  250,  250,  226,  226,  251,  269,  226,
  173.       269,  253,  253,  226,  253,  253,  270,  271,  226,  226,
  174.       272,  255,  226,  256,  226,  226,  226,  257,  226,  226,
  175.       226,  260,  261,  226,  261,  226,  273,  274,  262,  226,
  176.       263,  226,  275,  226,  265,  226,  266,  226,  267,  226,
  177.       226,  268,  226,  226,  250,  250,  226,  269,  151,  226,
  178.  
  179.       226,  253,  253,  270,  226,  270,  271,  272,  226,  226,
  180.       273,  226,  274,  226,  275,  226,  250,  226,  226,  226,
  181.       250,  226,  226,  226,  250,-32767,  226,  226,  226,  226,
  182.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  183.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  184.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  185.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  186.       226,  226,  226,  226,  226
  187.     } ;
  188.  
  189. static short int n[831] =
  190.     {   0,
  191.       226,   42,   43,   70,   73,   74,  164,   71,   73,   74,
  192.       106,   90,  106,   86,   87,   86,   87,  138,   91,  126,
  193.        92,   44,   44,   44,   44,   44,   44,   45,   46,   88,
  194.        47,   88,   48,   90,  109,   70,   94,  107,   49,  107,
  195.        91,  110,   92,   95,   96,  128,  129,   50,   50,   50,
  196.        50,   50,   50,   52,   53,   54,  109,   55,   94,  224,
  197.        56,   56,  161,  110,   56,   95,   96,   57,  112,   58,
  198.        59,  112,  143,  143,  220,  113,  214,  115,  113,   60,
  199.        56,   61,   62,   54,  116,   55,   63,  115,   56,   56,
  200.       118,  119,   64,  212,  116,   57,  147,   58,   59,  209,
  201.  
  202.        65,  118,  119,  148,  165,  165,  120,   60,   56,   76,
  203.       133,  122,  123,  122,  123,   77,  124,  120,  124,  144,
  204.        78,   78,   78,   78,   78,   78,   76,  147,  134,  167,
  205.       135,  136,   77,  174,  148,  193,  168,   78,   78,   78,
  206.        78,   78,   78,   81,  175,  139,  140,  226,  190,  147,
  207.       141,   82,  226,  226,   83,   83,  148,  122,  226,  226,
  208.       226,  216,  124,  128,  129,  145,  194,  201,  139,  140,
  209.        84,   81,  142,  141,  183,  197,  197,  202,  195,   82,
  210.       201,  201,   83,   83,  144,  196,  205,  186,  159,  214,
  211.       202,  165,  165,  210,  210,  142,  206,  174,   84,   98,
  212.  
  213.        99,  217,  217,  201,  100,  203,  145,  194,  175,  101,
  214.       218,  218,  201,  202,  205,  205,  219,  219,  212,  226,
  215.       209,  192,  222,  222,  102,  206,  103,   98,   99,  221,
  216.       221,  193,  100,  191,  145,  194,  190,  101,  223,  223,
  217.       225,  225,  145,  194,  188,  145,  194,  186,  131,  184,
  218.       125,  226,  102,  180,  103,  150,  150,  178,  177,  105,
  219.       176,  170,  163,  151,  151,  151,  151,  151,  151,  153,
  220.       154,   73,   70,   67,  155,  159,  158,  145,  137,  131,
  221.       156,  125,  105,  105,   79,   79,   70,   67,   67,  226,
  222.       226,  226,  226,  226,  226,  226,  157,  199,  199,  226,
  223.  
  224.       226,  226,  226,  226,  226,  199,  199,  199,  199,  199,
  225.       199,  226,  226,  200,  153,  154,  226,  226,  226,  155,
  226.       226,  226,  226,  226,  226,  156,  226,  226,  226,  226,
  227.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  228.       226,  157,   41,   41,   41,   41,   41,   41,   41,   41,
  229.        41,   41,   51,   51,   51,   51,   51,   51,   51,   51,
  230.        51,   51,   66,   66,   66,   66,   66,   66,   66,   66,
  231.        66,   66,   68,   68,   68,   68,   68,   68,   68,   68,
  232.        68,   68,   69,   69,   69,   69,   69,   69,   69,   69,
  233.        69,   69,   72,   72,   72,   72,   72,   72,   72,   72,
  234.  
  235.        72,   72,   75,   75,  226,   75,   75,   75,   75,   75,
  236.        75,   75,   80,   80,   80,   80,   80,   80,   80,   80,
  237.        80,   80,   85,   85,   85,   85,   85,   85,   85,   85,
  238.        85,   85,   89,   89,  226,   89,   89,   89,   89,   89,
  239.        89,   89,   93,   93,  226,   93,   93,   93,   93,   93,
  240.        93,   93,   97,   97,   97,   97,   97,   97,   97,   97,
  241.        97,   97,  104,  104,  104,  104,  104,  104,  104,  104,
  242.       104,  104,  108,  108,  108,  108,  108,  108,  108,  108,
  243.       108,  108,  111,  111,  111,  111,  111,  111,  111,  111,
  244.       111,  111,  114,  114,  114,  114,  114,  114,  114,  114,
  245.  
  246.       114,  114,  117,  117,  117,  117,  117,  117,  117,  117,
  247.       117,  117,  121,  121,  121,  121,  121,  121,  121,  121,
  248.       121,  121,  127,  127,  127,  127,  127,  127,  127,  127,
  249.       127,  127,  130,  130,  130,  130,  130,  130,  130,  130,
  250.       130,  130,  132,  132,  132,  132,  132,  132,  132,  132,
  251.       132,  132,  144,  144,  226,  144,  144,  144,  144,  144,
  252.       226,  144,  146,  146,  226,  146,  146,  146,  146,  146,
  253.       146,  146,  149,  149,  226,  149,  149,  149,  149,  149,
  254.       149,  149,  152,  152,  152,  152,  152,  152,  152,  152,
  255.       152,  152,  160,  226,  226,  160,  160,  160,  160,  160,
  256.  
  257.       160,  160,  162,  162,  226,  162,  162,  162,  162,  162,
  258.       162,  162,  166,  166,  226,  166,  166,  166,  166,  166,
  259.       166,  166,  169,  169,  226,  169,  169,  169,  169,  169,
  260.       169,  169,  171,  171,  226,  171,  171,  171,  171,  171,
  261.       226,  171,  172,  172,  226,  226,  226,  172,  172,  172,
  262.       172,  173,  173,  226,  173,  173,  173,  173,  173,  173,
  263.       173,  179,  179,  226,  179,  179,  226,  179,  179,  179,
  264.       179,  181,  181,  226,  226,  181,  181,  181,  226,  181,
  265.       181,  182,  182,  226,  182,  182,  182,  182,  182,  182,
  266.       182,  185,  185,  185,  185,  185,  185,  185,  185,  185,
  267.  
  268.       185,  187,  187,  226,  187,  187,  187,  187,  187,  187,
  269.       187,  189,  189,  189,  189,  189,  189,  189,  189,  189,
  270.       189,  192,  192,  192,  192,  192,  192,  192,  192,  192,
  271.       192,  198,  198,  226,  198,  198,  198,  198,  198,  198,
  272.       204,  204,  204,  204,  204,  204,  204,  204,  204,  204,
  273.       207,  207,  226,  207,  207,  207,  207,  207,  207,  207,
  274.       208,  208,  208,  208,  208,  208,  208,  208,  208,  208,
  275.       211,  211,  211,  211,  211,  211,  211,  211,  211,  211,
  276.       213,  213,  213,  213,  213,  213,  213,  213,  213,  213,
  277.       215,  215,  226,  215,  215,  215,  215,  215,  215,  215,
  278.  
  279.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  280.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  281.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226
  282.     } ;
  283.  
  284. static short int c[831] =
  285.     {   0,
  286.         0,    1,    1,   10,   11,   11,  256,   10,   12,   12,
  287.        29,   21,   30,   19,   19,   20,   20,  249,   21,  245,
  288.        21,    1,    1,    1,    1,    1,    1,    2,    2,   19,
  289.         2,   20,    2,   22,   31,   71,   23,   29,    2,   30,
  290.        22,   31,   22,   23,   23,   45,   45,    2,    2,    2,
  291.         2,    2,    2,    3,    3,    3,   32,    3,   24,  220,
  292.         3,    3,   71,   32,    3,   24,   24,    3,   33,    3,
  293.         3,   34,   55,   55,  216,   33,  213,   35,   34,    3,
  294.         3,    4,    4,    4,   35,    4,    4,   36,    4,    4,
  295.        37,   37,    4,  211,   36,    4,   59,    4,    4,  208,
  296.  
  297.         4,   38,   38,   59,   83,   83,   37,    4,    4,   13,
  298.        48,   39,   39,   40,   40,   13,   39,   38,   40,  196,
  299.        13,   13,   13,   13,   13,   13,   14,   88,   48,   91,
  300.        48,   48,   14,  100,   88,  192,   91,   14,   14,   14,
  301.        14,   14,   14,   17,  100,   52,   52,  124,  189,   95,
  302.        52,   17,  108,  111,   17,   17,   95,  122,  122,  108,
  303.       111,  188,  122,  128,  128,  144,  144,  152,  139,  139,
  304.        17,   18,   52,  139,  124,  147,  147,  152,  145,   18,
  305.       155,  156,   18,   18,  145,  145,  157,  185,  156,  178,
  306.       155,  165,  165,  167,  167,  139,  157,  173,   18,   25,
  307.  
  308.        25,  195,  195,  203,   25,  155,  195,  195,  173,   25,
  309.       197,  197,  202,  203,  206,  204,  210,  210,  177,  202,
  310.       161,  206,  218,  218,   25,  204,   25,   26,   26,  217,
  311.       217,  142,   26,  141,  217,  217,  136,   26,  219,  219,
  312.       221,  221,  225,  225,  134,  221,  221,  132,  130,  127,
  313.       125,  121,   26,  116,   26,   60,   60,  113,  110,  104,
  314.       101,   92,   77,   60,   60,   60,   60,   60,   60,   61,
  315.        61,   73,   69,   66,   61,   64,   63,   58,   49,   47,
  316.        61,   42,   28,   27,   16,   15,    9,    6,    5,    0,
  317.         0,    0,    0,    0,    0,    0,   61,  151,  151,    0,
  318.  
  319.         0,    0,    0,    0,    0,  151,  151,  151,  151,  151,
  320.       151,    0,    0,  151,  153,  153,    0,    0,    0,  153,
  321.         0,    0,    0,    0,    0,  153,    0,    0,    0,    0,
  322.         0,    0,    0,    0,    0,    0,    0,    0,    0,    0,
  323.         0,  153,  227,  227,  227,  227,  227,  227,  227,  227,
  324.       227,  227,  228,  228,  228,  228,  228,  228,  228,  228,
  325.       228,  228,  229,  229,  229,  229,  229,  229,  229,  229,
  326.       229,  229,  230,  230,  230,  230,  230,  230,  230,  230,
  327.       230,  230,  231,  231,  231,  231,  231,  231,  231,  231,
  328.       231,  231,  232,  232,  232,  232,  232,  232,  232,  232,
  329.  
  330.       232,  232,  233,  233,    0,  233,  233,  233,  233,  233,
  331.       233,  233,  234,  234,  234,  234,  234,  234,  234,  234,
  332.       234,  234,  235,  235,  235,  235,  235,  235,  235,  235,
  333.       235,  235,  236,  236,    0,  236,  236,  236,  236,  236,
  334.       236,  236,  237,  237,    0,  237,  237,  237,  237,  237,
  335.       237,  237,  238,  238,  238,  238,  238,  238,  238,  238,
  336.       238,  238,  239,  239,  239,  239,  239,  239,  239,  239,
  337.       239,  239,  240,  240,  240,  240,  240,  240,  240,  240,
  338.       240,  240,  241,  241,  241,  241,  241,  241,  241,  241,
  339.       241,  241,  242,  242,  242,  242,  242,  242,  242,  242,
  340.  
  341.       242,  242,  243,  243,  243,  243,  243,  243,  243,  243,
  342.       243,  243,  244,  244,  244,  244,  244,  244,  244,  244,
  343.       244,  244,  246,  246,  246,  246,  246,  246,  246,  246,
  344.       246,  246,  247,  247,  247,  247,  247,  247,  247,  247,
  345.       247,  247,  248,  248,  248,  248,  248,  248,  248,  248,
  346.       248,  248,  250,  250,    0,  250,  250,  250,  250,  250,
  347.         0,  250,  251,  251,    0,  251,  251,  251,  251,  251,
  348.       251,  251,  252,  252,    0,  252,  252,  252,  252,  252,
  349.       252,  252,  253,  253,  253,  253,  253,  253,  253,  253,
  350.       253,  253,  254,    0,    0,  254,  254,  254,  254,  254,
  351.  
  352.       254,  254,  255,  255,    0,  255,  255,  255,  255,  255,
  353.       255,  255,  257,  257,    0,  257,  257,  257,  257,  257,
  354.       257,  257,  258,  258,    0,  258,  258,  258,  258,  258,
  355.       258,  258,  259,  259,    0,  259,  259,  259,  259,  259,
  356.         0,  259,  260,  260,    0,    0,    0,  260,  260,  260,
  357.       260,  261,  261,    0,  261,  261,  261,  261,  261,  261,
  358.       261,  262,  262,    0,  262,  262,    0,  262,  262,  262,
  359.       262,  263,  263,    0,    0,  263,  263,  263,    0,  263,
  360.       263,  264,  264,    0,  264,  264,  264,  264,  264,  264,
  361.       264,  265,  265,  265,  265,  265,  265,  265,  265,  265,
  362.  
  363.       265,  266,  266,    0,  266,  266,  266,  266,  266,  266,
  364.       266,  267,  267,  267,  267,  267,  267,  267,  267,  267,
  365.       267,  268,  268,  268,  268,  268,  268,  268,  268,  268,
  366.       268,  269,  269,    0,  269,  269,  269,  269,  269,  269,
  367.       270,  270,  270,  270,  270,  270,  270,  270,  270,  270,
  368.       271,  271,    0,  271,  271,  271,  271,  271,  271,  271,
  369.       272,  272,  272,  272,  272,  272,  272,  272,  272,  272,
  370.       273,  273,  273,  273,  273,  273,  273,  273,  273,  273,
  371.       274,  274,  274,  274,  274,  274,  274,  274,  274,  274,
  372.       275,  275,    0,  275,  275,  275,  275,  275,  275,  275,
  373.  
  374.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  375.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226,
  376.       226,  226,  226,  226,  226,  226,  226,  226,  226,  226
  377.     } ;
  378.  
  379.  
  380. /* these declarations have to come after the section 1 code or lint gets
  381.  * confused about whether the variables are used
  382.  */
  383. FILE *yyin = stdin, *yyout = stdout;
  384.  
  385. /* these variables are all declared out here so that section 3 code can
  386.  * manipulate them
  387.  */
  388. static int yy_start, yy_b_buf_p, yy_c_buf_p, yy_e_buf_p;
  389. static int yy_saw_eof, yy_init = 1;
  390.  
  391. /* yy_ch_buf has to be 1 character longer than YY_BUF_SIZE, since when
  392.  * setting up yytext we can try to put a '\0' just past the end of the
  393.  * matched text
  394.  */
  395. static char yy_ch_buf[YY_BUF_SIZE + 1];
  396. static int yy_st_buf[YY_BUF_SIZE];
  397. static char yy_hold_char;
  398. char *yytext;
  399. static int yyleng;
  400.  
  401. YY_DECL
  402.     {
  403.     int yy_n_chars, yy_lp, yy_iii, yy_buf_pos, yy_act;
  404.  
  405.  
  406.     static int bracelevel, didadef;
  407.     int i, cclval;
  408.     char nmdef[MAXLINE], myesc();
  409.  
  410.  
  411.     if ( yy_init )
  412.         {
  413.         YY_INIT;
  414.         yy_start = 1;
  415.         yy_init = 0;
  416.         }
  417.  
  418.     goto get_next_token;
  419.  
  420. do_action:
  421.     for ( ; ; )
  422.         {
  423.         YY_DO_BEFORE_ACTION
  424.  
  425. #ifdef FLEX_DEBUG
  426.         fprintf( stderr, "--accepting rule #%d\n", yy_act );
  427. #endif
  428.         switch ( yy_act )
  429.             {
  430. case 1:
  431. # line 58 "scan.l"
  432. ++linenum; ECHO; /* indented code */
  433.         YY_BREAK
  434. case 2:
  435. # line 59 "scan.l"
  436. ++linenum; ECHO; /* treat as a comment */
  437.         YY_BREAK
  438. case 3:
  439. # line 60 "scan.l"
  440. ECHO; BEGIN(C_COMMENT);
  441.         YY_BREAK
  442. case 4:
  443. # line 61 "scan.l"
  444. return ( SCDECL );
  445.         YY_BREAK
  446. case 5:
  447. # line 62 "scan.l"
  448. return ( XSCDECL );
  449.         YY_BREAK
  450. case 6:
  451. # line 63 "scan.l"
  452. ++linenum; line_directive_out( stdout ); BEGIN(CODEBLOCK);
  453.         YY_BREAK
  454. case 7:
  455. # line 64 "scan.l"
  456. return ( WHITESPACE );
  457.         YY_BREAK
  458. case 8:
  459. # line 66 "scan.l"
  460. {
  461.                         sectnum = 2;
  462.                         line_directive_out( stdout );
  463.                         BEGIN(SECT2PROLOG);
  464.                         return ( SECTEND );
  465.                         }
  466.         YY_BREAK
  467. case 9:
  468. # line 73 "scan.l"
  469. {
  470.                         fprintf( stderr,
  471.                              "old-style lex command at line %d ignored:\n\t%s",
  472.                                  linenum, yytext );
  473.                         ++linenum;
  474.                         }
  475.         YY_BREAK
  476. case 10:
  477. # line 80 "scan.l"
  478. {
  479.                         (void) strcpy( nmstr, yytext );
  480.                         didadef = false;
  481.                         BEGIN(PICKUPDEF);
  482.                         }
  483.         YY_BREAK
  484. case 11:
  485. # line 86 "scan.l"
  486. RETURNNAME;
  487.         YY_BREAK
  488. case 12:
  489. # line 87 "scan.l"
  490. ++linenum; /* allows blank lines in section 1 */
  491.         YY_BREAK
  492. case 13:
  493. # line 88 "scan.l"
  494. ++linenum; return ( '\n' );
  495.         YY_BREAK
  496. case 14:
  497. # line 89 "scan.l"
  498. synerr( "illegal character" ); BEGIN(RECOVER);
  499.         YY_BREAK
  500. case 15:
  501. # line 92 "scan.l"
  502. ECHO; BEGIN(0);
  503.         YY_BREAK
  504. case 16:
  505. # line 93 "scan.l"
  506. ++linenum; ECHO; BEGIN(0);
  507.         YY_BREAK
  508. case 17:
  509. # line 94 "scan.l"
  510. ECHO;
  511.         YY_BREAK
  512. case 18:
  513. # line 95 "scan.l"
  514. ECHO;
  515.         YY_BREAK
  516. case 19:
  517. # line 96 "scan.l"
  518. ++linenum; ECHO;
  519.         YY_BREAK
  520. case 20:
  521. # line 98 "scan.l"
  522. ++linenum; BEGIN(0);
  523.         YY_BREAK
  524. case 21:
  525. # line 99 "scan.l"
  526. ++linenum; ECHO;
  527.         YY_BREAK
  528. case 22:
  529. # line 101 "scan.l"
  530. /* separates name and definition */
  531.         YY_BREAK
  532. case 23:
  533. # line 103 "scan.l"
  534. {
  535.                         (void) strcpy( nmdef, yytext );
  536.  
  537.                         for ( i = strlen( nmdef ) - 1;
  538.                               i >= 0 &&
  539.                               nmdef[i] == ' ' || nmdef[i] == '\t';
  540.                               --i )
  541.                             ;
  542.  
  543.                         nmdef[i + 1] = '\0';
  544.  
  545.                         ndinstal( nmstr, nmdef );
  546.                         didadef = true;
  547.                         }
  548.         YY_BREAK
  549. case 24:
  550. # line 118 "scan.l"
  551. {
  552.                         if ( ! didadef )
  553.                             synerr( "incomplete name definition" );
  554.                         BEGIN(0);
  555.                         ++linenum;
  556.                         }
  557.         YY_BREAK
  558. case 25:
  559. # line 125 "scan.l"
  560. ++linenum; BEGIN(0); RETURNNAME;
  561.         YY_BREAK
  562. case 26:
  563. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  564. yy_c_buf_p -= 1;
  565. YY_DO_BEFORE_ACTION; /* set up yytext again */
  566. # line 128 "scan.l"
  567. {
  568.                         ++linenum;
  569.                         ACTION_ECHO;
  570.                         MARK_END_OF_PROLOG;
  571.                         BEGIN(SECT2);
  572.                         }
  573.         YY_BREAK
  574. case 27:
  575. # line 135 "scan.l"
  576. ++linenum; ACTION_ECHO;
  577.         YY_BREAK
  578. case 28:
  579. # line 137 "scan.l"
  580. ++linenum; /* allow blank lines in section 2 */
  581.         YY_BREAK
  582.         /* this horrible mess of a rule matches indented lines which
  583.          * do not contain "/*".  We need to make the distinction because
  584.          * otherwise this rule will be taken instead of the rule which
  585.          * matches the beginning of comments like this one
  586.          */
  587. case 29:
  588. # line 144 "scan.l"
  589. {
  590.                         synerr( "indented code found outside of action" );
  591.                         ++linenum;
  592.                         }
  593.         YY_BREAK
  594. case 30:
  595. # line 149 "scan.l"
  596. BEGIN(SC); return ( '<' );
  597.         YY_BREAK
  598. case 31:
  599. # line 150 "scan.l"
  600. return ( '^' );
  601.         YY_BREAK
  602. case 32:
  603. # line 151 "scan.l"
  604. BEGIN(QUOTE); return ( '"' );
  605.         YY_BREAK
  606. case 33:
  607. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  608. yy_c_buf_p = yy_b_buf_p;
  609. YY_DO_BEFORE_ACTION; /* set up yytext again */
  610. # line 152 "scan.l"
  611. BEGIN(NUM); return ( '{' );
  612.         YY_BREAK
  613. case 34:
  614. # line 153 "scan.l"
  615. BEGIN(BRACEERROR);
  616.         YY_BREAK
  617. case 35:
  618. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  619. yy_c_buf_p = yy_b_buf_p;
  620. YY_DO_BEFORE_ACTION; /* set up yytext again */
  621. # line 154 "scan.l"
  622. return ( '$' );
  623.         YY_BREAK
  624. case 36:
  625. # line 156 "scan.l"
  626. {
  627.                         bracelevel = 1;
  628.                         BEGIN(PERCENT_BRACE_ACTION);
  629.                         return ( '\n' );
  630.                         }
  631.         YY_BREAK
  632. case 37:
  633. # line 161 "scan.l"
  634. ++linenum; return ( '\n' );
  635.         YY_BREAK
  636. case 38:
  637. # line 163 "scan.l"
  638. ACTION_ECHO; BEGIN(C_COMMENT_2);
  639.         YY_BREAK
  640. case 39:
  641. # line 165 "scan.l"
  642. { /* needs to be separate from following rule due to
  643.                            * bug with trailing context
  644.                            */
  645.                         bracelevel = 0;
  646.                         BEGIN(ACTION);
  647.                         return ( '\n' );
  648.                         }
  649.         YY_BREAK
  650. case 40:
  651. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  652. yy_c_buf_p -= 1;
  653. YY_DO_BEFORE_ACTION; /* set up yytext again */
  654. # line 173 "scan.l"
  655. {
  656.                         bracelevel = 0;
  657.                         BEGIN(ACTION);
  658.                         return ( '\n' );
  659.                         }
  660.         YY_BREAK
  661. case 41:
  662. # line 179 "scan.l"
  663. ++linenum; return ( '\n' );
  664.         YY_BREAK
  665. case 42:
  666. # line 181 "scan.l"
  667. {
  668.                         /* guarantee that the SECT3 rule will have something
  669.                          * to match
  670.                          */
  671.                         yyless(1);
  672.                         sectnum = 3;
  673.                         BEGIN(SECT3);
  674.                         return ( EOF ); /* to stop the parser */
  675.                         }
  676.         YY_BREAK
  677. case 43:
  678. # line 191 "scan.l"
  679. {
  680.                         (void) strcpy( nmstr, yytext );
  681.  
  682.                         /* check to see if we've already encountered this ccl */
  683.                         if ( (cclval = ccllookup( nmstr )) )
  684.                             {
  685.                             yylval = cclval;
  686.                             ++cclreuse;
  687.                             return ( PREVCCL );
  688.                             }
  689.                         else
  690.                             {
  691.                             /* we fudge a bit.  We know that this ccl will
  692.                              * soon be numbered as lastccl + 1 by cclinit
  693.                              */
  694.                             cclinstal( nmstr, lastccl + 1 );
  695.  
  696.                             /* push back everything but the leading bracket
  697.                              * so the ccl can be rescanned
  698.                              */
  699.                             PUT_BACK_STRING(nmstr, 1);
  700.  
  701.                             BEGIN(FIRSTCCL);
  702.                             return ( '[' );
  703.                             }
  704.                         }
  705.         YY_BREAK
  706. case 44:
  707. # line 218 "scan.l"
  708. {
  709.                         register char *nmdefptr;
  710.                         char *ndlookup();
  711.  
  712.                         (void) strcpy( nmstr, yytext );
  713.                         nmstr[yyleng - 1] = '\0';  /* chop trailing brace */
  714.  
  715.                         /* lookup from "nmstr + 1" to chop leading brace */
  716.                         if ( ! (nmdefptr = ndlookup( nmstr + 1 )) )
  717.                             synerr( "undefined {name}" );
  718.  
  719.                         else
  720.                             { /* push back name surrounded by ()'s */
  721.                             unput(')');
  722.                             PUT_BACK_STRING(nmdefptr, 0);
  723.                             unput('(');
  724.                             }
  725.                         }
  726.         YY_BREAK
  727. case 45:
  728. # line 237 "scan.l"
  729. return ( yytext[0] );
  730.         YY_BREAK
  731. case 46:
  732. # line 238 "scan.l"
  733. RETURNCHAR;
  734.         YY_BREAK
  735. case 47:
  736. # line 239 "scan.l"
  737. ++linenum; return ( '\n' );
  738.         YY_BREAK
  739. case 48:
  740. # line 242 "scan.l"
  741. return ( ',' );
  742.         YY_BREAK
  743. case 49:
  744. # line 243 "scan.l"
  745. BEGIN(SECT2); return ( '>' );
  746.         YY_BREAK
  747. case 50:
  748. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  749. yy_c_buf_p = yy_b_buf_p;
  750. YY_DO_BEFORE_ACTION; /* set up yytext again */
  751. # line 244 "scan.l"
  752. BEGIN(CARETISBOL); return ( '>' );
  753.         YY_BREAK
  754. case 51:
  755. # line 245 "scan.l"
  756. RETURNNAME;
  757.         YY_BREAK
  758. case 52:
  759. # line 246 "scan.l"
  760. synerr( "bad start condition name" );
  761.         YY_BREAK
  762. case 53:
  763. # line 248 "scan.l"
  764. BEGIN(SECT2); return ( '^' );
  765.         YY_BREAK
  766. case 54:
  767. # line 251 "scan.l"
  768. RETURNCHAR;
  769.         YY_BREAK
  770. case 55:
  771. # line 252 "scan.l"
  772. BEGIN(SECT2); return ( '"' );
  773.         YY_BREAK
  774. case 56:
  775. # line 254 "scan.l"
  776. {
  777.                         synerr( "missing quote" );
  778.                         BEGIN(SECT2);
  779.                         ++linenum;
  780.                         return ( '"' );
  781.                         }
  782.         YY_BREAK
  783. case 57:
  784. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  785. yy_c_buf_p = yy_b_buf_p;
  786. YY_DO_BEFORE_ACTION; /* set up yytext again */
  787. # line 262 "scan.l"
  788. BEGIN(CCL); return ( '^' );
  789.         YY_BREAK
  790. case 58:
  791. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  792. yy_c_buf_p = yy_b_buf_p;
  793. YY_DO_BEFORE_ACTION; /* set up yytext again */
  794. # line 263 "scan.l"
  795. return ( '^' );
  796.         YY_BREAK
  797. case 59:
  798. # line 264 "scan.l"
  799. BEGIN(CCL); yylval = '-'; return ( CHAR );
  800.         YY_BREAK
  801. case 60:
  802. # line 265 "scan.l"
  803. BEGIN(CCL); RETURNCHAR;
  804.         YY_BREAK
  805. case 61:
  806. YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  807. yy_c_buf_p = yy_b_buf_p;
  808. YY_DO_BEFORE_ACTION; /* set up yytext again */
  809. # line 267 "scan.l"
  810. return ( '-' );
  811.         YY_BREAK
  812. case 62:
  813. # line 268 "scan.l"
  814. RETURNCHAR;
  815.         YY_BREAK
  816. case 63:
  817. # line 269 "scan.l"
  818. BEGIN(SECT2); return ( ']' );
  819.         YY_BREAK
  820. case 64:
  821. # line 272 "scan.l"
  822. {
  823.                         yylval = myctoi( yytext );
  824.                         return ( NUMBER );
  825.                         }
  826.         YY_BREAK
  827. case 65:
  828. # line 277 "scan.l"
  829. return ( ',' );
  830.         YY_BREAK
  831. case 66:
  832. # line 278 "scan.l"
  833. BEGIN(SECT2); return ( '}' );
  834.         YY_BREAK
  835. case 67:
  836. # line 280 "scan.l"
  837. {
  838.                         synerr( "bad character inside {}'s" );
  839.                         BEGIN(SECT2);
  840.                         return ( '}' );
  841.                         }
  842.         YY_BREAK
  843. case 68:
  844. # line 286 "scan.l"
  845. {
  846.                         synerr( "missing }" );
  847.                         BEGIN(SECT2);
  848.                         ++linenum;
  849.                         return ( '}' );
  850.                         }
  851.         YY_BREAK
  852. case 69:
  853. # line 294 "scan.l"
  854. synerr( "bad name in {}'s" ); BEGIN(SECT2);
  855.         YY_BREAK
  856. case 70:
  857. # line 295 "scan.l"
  858. synerr( "missing }" ); ++linenum; BEGIN(SECT2);
  859.         YY_BREAK
  860. case 71:
  861. # line 298 "scan.l"
  862. bracelevel = 0;
  863.         YY_BREAK
  864. case 72:
  865. # line 299 "scan.l"
  866. ACTION_ECHO;
  867.         YY_BREAK
  868. case 73:
  869. # line 300 "scan.l"
  870. {
  871.                         ++linenum;
  872.                         ACTION_ECHO;
  873.                         if ( bracelevel == 0 )
  874.                             {
  875.                             fputs( "\tYY_BREAK\n", temp_action_file );
  876.                             BEGIN(SECT2);
  877.                             }
  878.                         }
  879.         YY_BREAK
  880. case 74:
  881. # line 310 "scan.l"
  882. ACTION_ECHO; ++bracelevel;
  883.         YY_BREAK
  884. case 75:
  885. # line 311 "scan.l"
  886. ACTION_ECHO; --bracelevel;
  887.         YY_BREAK
  888. case 76:
  889. # line 312 "scan.l"
  890. ACTION_ECHO;
  891.         YY_BREAK
  892. case 77:
  893. # line 313 "scan.l"
  894. ACTION_ECHO; BEGIN(ACTION_COMMENT);
  895.         YY_BREAK
  896. case 78:
  897. # line 314 "scan.l"
  898. ACTION_ECHO; /* character constant */
  899.         YY_BREAK
  900. case 79:
  901. # line 315 "scan.l"
  902. ACTION_ECHO; BEGIN(ACTION_STRING);
  903.         YY_BREAK
  904. case 80:
  905. # line 316 "scan.l"
  906. {
  907.                         ++linenum;
  908.                         ACTION_ECHO;
  909.                         if ( bracelevel == 0 )
  910.                             {
  911.                             fputs( "\tYY_BREAK\n", temp_action_file );
  912.                             BEGIN(SECT2);
  913.                             }
  914.                         }
  915.         YY_BREAK
  916. case 81:
  917. # line 325 "scan.l"
  918. ACTION_ECHO;
  919.         YY_BREAK
  920. case 82:
  921. # line 327 "scan.l"
  922. ACTION_ECHO; BEGIN(ACTION);
  923.         YY_BREAK
  924. case 83:
  925. # line 328 "scan.l"
  926. ACTION_ECHO;
  927.         YY_BREAK
  928. case 84:
  929. # line 329 "scan.l"
  930. ACTION_ECHO;
  931.         YY_BREAK
  932. case 85:
  933. # line 330 "scan.l"
  934. ++linenum; ACTION_ECHO;
  935.         YY_BREAK
  936. case 86:
  937. # line 331 "scan.l"
  938. ACTION_ECHO;
  939.         YY_BREAK
  940. case 87:
  941. # line 333 "scan.l"
  942. ACTION_ECHO; BEGIN(SECT2);
  943.         YY_BREAK
  944. case 88:
  945. # line 334 "scan.l"
  946. ++linenum; ACTION_ECHO; BEGIN(SECT2);
  947.         YY_BREAK
  948. case 89:
  949. # line 335 "scan.l"
  950. ACTION_ECHO;
  951.         YY_BREAK
  952. case 90:
  953. # line 336 "scan.l"
  954. ACTION_ECHO;
  955.         YY_BREAK
  956. case 91:
  957. # line 337 "scan.l"
  958. ++linenum; ACTION_ECHO;
  959.         YY_BREAK
  960. case 92:
  961. # line 339 "scan.l"
  962. ACTION_ECHO;
  963.         YY_BREAK
  964. case 93:
  965. # line 340 "scan.l"
  966. ACTION_ECHO;
  967.         YY_BREAK
  968. case 94:
  969. # line 341 "scan.l"
  970. ++linenum; ACTION_ECHO;
  971.         YY_BREAK
  972. case 95:
  973. # line 342 "scan.l"
  974. ACTION_ECHO; BEGIN(ACTION);
  975.         YY_BREAK
  976. case 96:
  977. # line 343 "scan.l"
  978. ACTION_ECHO;
  979.         YY_BREAK
  980. case 97:
  981. # line 346 "scan.l"
  982. {
  983.                         yylval = myesc( yytext );
  984.                         return ( CHAR );
  985.                         }
  986.         YY_BREAK
  987. case 98:
  988. # line 351 "scan.l"
  989. {
  990.                         yylval = myesc( yytext );
  991.                         BEGIN(CCL);
  992.                         return ( CHAR );
  993.                         }
  994.         YY_BREAK
  995. case 99:
  996. # line 358 "scan.l"
  997. {
  998.                         register int numchars;
  999.  
  1000.                         /* black magic - we know the names of a flex scanner's
  1001.                          * internal variables.  We cap the input buffer with
  1002.                          * an end-of-string and dump it to the output.
  1003.                          */
  1004.                         YY_DO_BEFORE_SCAN; /* recover from setting up yytext */
  1005.  
  1006. #ifdef FLEX_FAST_SKEL
  1007.                         fputs( yy_c_buf_p + 1, stdout );
  1008. #else
  1009.                         yy_ch_buf[yy_e_buf_p + 1] = '\0';
  1010.  
  1011.                         /* ignore the first character; it's the second '%'
  1012.                          * put back by the yyless(1) above
  1013.                          */
  1014.                         fputs( yy_ch_buf + yy_c_buf_p + 1, stdout );
  1015. #endif
  1016.  
  1017.                         /* if we don't do this, the data written by write()
  1018.                          * can get overwritten when stdout is finally flushed
  1019.                          */
  1020.                         (void) fflush( stdout );
  1021.  
  1022.                         while ( (numchars = read( fileno(yyin), yy_ch_buf,
  1023.                                                   YY_BUF_MAX )) > 0 )
  1024.                             (void) write( fileno(stdout), yy_ch_buf, numchars );
  1025.  
  1026.                         if ( numchars < 0 )
  1027.                             flexerror( "fatal read error in section 3" );
  1028.  
  1029.                         return ( EOF );
  1030.                         }
  1031.         YY_BREAK
  1032.  
  1033. case YY_NEW_FILE:
  1034. break; /* begin reading from new file */
  1035.  
  1036. case YY_DO_DEFAULT:
  1037. YY_DEFAULT_ACTION;
  1038. break;
  1039.  
  1040. case YY_END_TOK:
  1041. return ( YY_END_TOK );
  1042.  
  1043. default:
  1044. YY_FATAL_ERROR( "fatal flex scanner internal error" );
  1045.             }
  1046.  
  1047. get_next_token:
  1048.         {
  1049.         register int yy_curst;
  1050.         register char yy_sym;
  1051.  
  1052.         YY_DO_BEFORE_SCAN
  1053.  
  1054.         /* set up to begin running DFA */
  1055.  
  1056.         yy_curst = yy_start;
  1057.  
  1058.         if ( yy_ch_buf[yy_c_buf_p] == '\n' )
  1059.             ++yy_curst;
  1060.  
  1061.         /* yy_b_buf_p points to the position in yy_ch_buf
  1062.          * of the start of the current run.
  1063.          */
  1064.  
  1065.         yy_b_buf_p = yy_c_buf_p + 1;
  1066.  
  1067.         do /* until the machine jams */
  1068.             {
  1069.             if ( yy_c_buf_p == yy_e_buf_p )
  1070.                 { /* need more input */
  1071.                 if ( yy_e_buf_p >= YY_BUF_LIM )
  1072.                     { /* not enough room to do another read */
  1073.                     /* see if we can make some room for more chars */
  1074.  
  1075.                     yy_n_chars = yy_e_buf_p - yy_b_buf_p;
  1076.  
  1077.                     if ( yy_n_chars >= 0 )
  1078.                         /* shift down buffer to make room */
  1079.                         for ( yy_iii = 0; yy_iii <= yy_n_chars; ++yy_iii )
  1080.                             {
  1081.                             yy_buf_pos = yy_b_buf_p + yy_iii;
  1082.                             yy_ch_buf[yy_iii] = yy_ch_buf[yy_buf_pos];
  1083.                             yy_st_buf[yy_iii] = yy_st_buf[yy_buf_pos];
  1084.                             }
  1085.  
  1086.                     yy_b_buf_p = 0;
  1087.                     yy_e_buf_p = yy_n_chars;
  1088.  
  1089.                     if ( yy_e_buf_p >= YY_BUF_LIM )
  1090.                         YY_FATAL_ERROR( "flex input buffer overflowed" );
  1091.  
  1092.                     yy_c_buf_p = yy_e_buf_p;
  1093.                     }
  1094.  
  1095.                 else if ( yy_saw_eof )
  1096.                     {
  1097. saweof:             if ( yy_b_buf_p > yy_e_buf_p )
  1098.                         {
  1099.                         if ( yywrap() )
  1100.                             {
  1101.                             yy_act = YY_END_TOK;
  1102.                             goto do_action;
  1103.                             }
  1104.  
  1105.                         else
  1106.                             {
  1107.                             YY_INIT;
  1108.                             yy_act = YY_NEW_FILE;
  1109.                             goto do_action;
  1110.                             }
  1111.                         }
  1112.  
  1113.                     else /* do a jam to eat up more input */
  1114.                         {
  1115. #ifndef FLEX_INTERACTIVE_SCANNER
  1116.                         /* we're going to decrement yy_c_buf_p upon doing
  1117.                          * the jam.  In this case, that's wrong, since
  1118.                          * it points to the last non-jam character.  So
  1119.                          * we increment it now to counter the decrement.
  1120.                          */
  1121.                         ++yy_c_buf_p;
  1122. #endif
  1123.                         break;
  1124.                         }
  1125.                     }
  1126.  
  1127.                 YY_INPUT( (yy_ch_buf + yy_c_buf_p + 1), yy_n_chars,
  1128.                           YY_MAX_LINE );
  1129.  
  1130.                 if ( yy_n_chars == YY_NULL )
  1131.                     {
  1132.                     if ( yy_saw_eof )
  1133.         YY_FATAL_ERROR( "flex scanner saw EOF twice - shouldn't happen" );
  1134.                     yy_saw_eof = 1;
  1135.                     goto saweof;
  1136.                     }
  1137.  
  1138.                 yy_e_buf_p += yy_n_chars;
  1139.                 }
  1140.  
  1141.             ++yy_c_buf_p;
  1142.  
  1143. #ifdef FLEX_USE_ECS
  1144.             yy_sym = e[yy_ch_buf[yy_c_buf_p]];
  1145. #else
  1146.             yy_sym = yy_ch_buf[yy_c_buf_p];
  1147. #endif
  1148.  
  1149. #ifdef FLEX_FULL_TABLE
  1150.             yy_curst = n[yy_curst][yy_sym];
  1151.  
  1152. #else /* get next state from compressed table */
  1153.  
  1154.             while ( c[b[yy_curst] + yy_sym] != yy_curst )
  1155.                 {
  1156.                 yy_curst = d[yy_curst];
  1157.  
  1158. #ifdef FLEX_USE_MECS
  1159.                 /* we've arrange it so that templates are never chained
  1160.                  * to one another.  This means we can afford make a
  1161.                  * very simple test to see if we need to convert to
  1162.                  * yy_sym's meta-equivalence class without worrying
  1163.                  * about erroneously looking up the meta-equivalence
  1164.                  * class twice
  1165.                  */
  1166.  
  1167.                 if ( yy_curst >= YY_TEMPLATE )
  1168.                     yy_sym = m[yy_sym];
  1169. #endif
  1170.                 }
  1171.  
  1172.             yy_curst = n[b[yy_curst] + yy_sym];
  1173.  
  1174. #endif
  1175.  
  1176.             yy_st_buf[yy_c_buf_p] = yy_curst;
  1177.  
  1178.             }
  1179. #ifdef FLEX_INTERACTIVE_SCANNER
  1180.         while ( b[yy_curst] != YY_JAM_BASE );
  1181. #else
  1182.         while ( yy_curst != YY_JAM );
  1183.         --yy_c_buf_p; /* put back character we jammed on */
  1184.  
  1185. #endif
  1186.  
  1187.         if ( yy_c_buf_p >= yy_b_buf_p )
  1188.             { /* we matched some text */
  1189.             yy_curst = yy_st_buf[yy_c_buf_p];
  1190.             yy_lp = l[yy_curst];
  1191.  
  1192. #ifdef FLEX_REJECT_ENABLED
  1193. find_rule: /* we branch to this label when doing a REJECT */
  1194. #endif
  1195.  
  1196.             for ( ; ; ) /* until we find what rule we matched */
  1197.                 {
  1198. #ifdef FLEX_REJECT_ENABLED
  1199.                 if ( yy_lp && yy_lp < l[yy_curst + 1] )
  1200.                     {
  1201.                     yy_act = a[yy_lp];
  1202.                     goto do_action; /* "continue 2" */
  1203.                     }
  1204. #else
  1205.                 if ( yy_lp )
  1206.                     {
  1207.                     yy_act = yy_lp;
  1208.                     goto do_action; /* "continue 2" */
  1209.                     }
  1210. #endif
  1211.  
  1212.                 if ( --yy_c_buf_p < yy_b_buf_p )
  1213.                     break;
  1214.  
  1215.                 yy_curst = yy_st_buf[yy_c_buf_p];
  1216.                 yy_lp = l[yy_curst];
  1217.                 }
  1218.             }
  1219.  
  1220.         /* if we got this far, then we didn't find any accepting
  1221.          * states
  1222.          */
  1223.  
  1224.         /* so that the default applies to the first char read */
  1225.         ++yy_c_buf_p;
  1226.  
  1227.         yy_act = YY_DO_DEFAULT;
  1228.         }
  1229.         }
  1230.  
  1231.     /*NOTREACHED*/
  1232.     }
  1233.  
  1234.  
  1235. static int unput( c )
  1236. char c;
  1237.  
  1238.     {
  1239.     YY_DO_BEFORE_SCAN; /* undo effects of setting up yytext */
  1240.  
  1241.     if ( yy_c_buf_p == 0 )
  1242.         {
  1243.         register int i;
  1244.         register int yy_buf_pos = YY_BUF_MAX;
  1245.  
  1246.         for ( i = yy_e_buf_p; i >= yy_c_buf_p; --i )
  1247.             {
  1248.             yy_ch_buf[yy_buf_pos] = yy_ch_buf[i];
  1249.             yy_st_buf[yy_buf_pos] = yy_st_buf[i];
  1250.             --yy_buf_pos;
  1251.             }
  1252.  
  1253.         yy_c_buf_p = YY_BUF_MAX - yy_e_buf_p;
  1254.         yy_e_buf_p = YY_BUF_MAX;
  1255.         }
  1256.  
  1257.     if ( yy_c_buf_p <= 0 )
  1258.         YY_FATAL_ERROR( "flex scanner push-back overflow" );
  1259.  
  1260.     if ( yy_c_buf_p >= yy_b_buf_p && yy_ch_buf[yy_c_buf_p] == '\n' )
  1261.         yy_ch_buf[yy_c_buf_p - 1] = '\n';
  1262.  
  1263.     yy_ch_buf[yy_c_buf_p--] = c;
  1264.  
  1265.     YY_DO_BEFORE_ACTION; /* set up yytext again */
  1266.     }
  1267.  
  1268.  
  1269. static int input()
  1270.  
  1271.     {
  1272.     int c;
  1273.  
  1274.     YY_DO_BEFORE_SCAN
  1275.  
  1276.     if ( yy_c_buf_p == yy_e_buf_p )
  1277.         { /* need more input */
  1278.         int yy_n_chars;
  1279.  
  1280.         /* we can throw away the entire current buffer */
  1281.         if ( yy_saw_eof )
  1282.             {
  1283.             if ( yywrap() )
  1284.                 return ( EOF );
  1285.  
  1286.             YY_INIT;
  1287.             }
  1288.  
  1289.         yy_b_buf_p = 0;
  1290.         YY_INPUT( yy_ch_buf, yy_n_chars, YY_MAX_LINE );
  1291.  
  1292.         if ( yy_n_chars == YY_NULL )
  1293.             {
  1294.             yy_saw_eof = 1;
  1295.  
  1296.             if ( yywrap() )
  1297.                 return ( EOF );
  1298.  
  1299.             YY_INIT;
  1300.  
  1301.             return ( input() );
  1302.             }
  1303.  
  1304.         yy_c_buf_p = -1;
  1305.         yy_e_buf_p = yy_n_chars - 1;
  1306.         }
  1307.  
  1308.     c = yy_ch_buf[++yy_c_buf_p];
  1309.  
  1310.     YY_DO_BEFORE_ACTION;
  1311.  
  1312.     return ( c );
  1313.     }
  1314. # line 392 "scan.l"
  1315.  
  1316.