home *** CD-ROM | disk | FTP | other *** search
/ GEMini Atari / GEMini_Atari_CD-ROM_Walnut_Creek_December_1993.iso / files / gnu / gccsrc1 / cexp.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-07-23  |  34.8 KB  |  1,316 lines
  1.  
  2. /*  A Bison parser, made from ../gcc-1.37/cexp.y  */
  3.  
  4. #define    INT    258
  5. #define    CHAR    259
  6. #define    NAME    260
  7. #define    ERROR    261
  8. #define    OR    262
  9. #define    AND    263
  10. #define    EQUAL    264
  11. #define    NOTEQUAL    265
  12. #define    LEQ    266
  13. #define    GEQ    267
  14. #define    LSH    268
  15. #define    RSH    269
  16. #define    UNARY    270
  17.  
  18. #line 26 "../gcc-1.37/cexp.y"
  19.  
  20. #include "config.h"
  21. #include <setjmp.h>
  22. /* #define YYDEBUG 1 */
  23.  
  24.   int yylex ();
  25.   void yyerror ();
  26.   int expression_value;
  27.  
  28.   static jmp_buf parse_return_error;
  29.  
  30.   /* some external tables of character types */
  31.   extern unsigned char is_idstart[], is_idchar[];
  32.  
  33. #ifndef CHAR_TYPE_SIZE
  34. #define CHAR_TYPE_SIZE BITS_PER_UNIT
  35. #endif
  36.  
  37. #line 45 "../gcc-1.37/cexp.y"
  38. typedef union {
  39.   struct constant {long value; int unsignedp;} integer;
  40.   int voidval;
  41.   char *sval;
  42. } YYSTYPE;
  43.  
  44. #ifndef YYLTYPE
  45. typedef
  46.   struct yyltype
  47.     {
  48.       int timestamp;
  49.       int first_line;
  50.       int first_column;
  51.       int last_line;
  52.       int last_column;
  53.       char *text;
  54.    }
  55.   yyltype;
  56.  
  57. #define YYLTYPE yyltype
  58. #endif
  59.  
  60. #include <stdio.h>
  61.  
  62. #ifndef __STDC__
  63. #define const
  64. #endif
  65.  
  66.  
  67.  
  68. #define    YYFINAL        61
  69. #define    YYFLAG        -32768
  70. #define    YYNTBASE    33
  71.  
  72. #define YYTRANSLATE(x) ((unsigned)(x) <= 270 ? yytranslate[x] : 36)
  73.  
  74. static const char yytranslate[] = {     0,
  75.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  76.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  77.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  78.      2,     2,    29,     2,     2,     2,    27,    14,     2,    31,
  79.     32,    25,    23,     9,    24,     2,    26,     2,     2,     2,
  80.      2,     2,     2,     2,     2,     2,     2,     8,     2,    17,
  81.      2,    18,     7,     2,     2,     2,     2,     2,     2,     2,
  82.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  83.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  84.      2,     2,     2,    13,     2,     2,     2,     2,     2,     2,
  85.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  86.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  87.      2,     2,     2,    12,     2,    30,     2,     2,     2,     2,
  88.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  89.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  90.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  91.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  92.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  93.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  94.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  95.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  96.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  97.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  98.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  99.      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
  100.      2,     2,     2,     2,     2,     1,     2,     3,     4,     5,
  101.      6,    10,    11,    15,    16,    19,    20,    21,    22,    28
  102. };
  103.  
  104. static const short yyrline[] = {     0,
  105.     74,    79,    80,    85,    88,    91,    93,    96,   101,   107,
  106.    118,   129,   132,   135,   141,   147,   150,   153,   159,   165,
  107.    171,   177,   180,   183,   186,   189,   192,   195,   197,   199
  108. };
  109.  
  110. static const char * const yytname[] = {     0,
  111. "error","$illegal.","INT","CHAR","NAME","ERROR","'?'","':'","','","OR",
  112. "AND","'|'","'^'","'&'","EQUAL","NOTEQUAL","'<'","'>'","LEQ","GEQ",
  113. "LSH","RSH","'+'","'-'","'*'","'/'","'%'","UNARY","'!'","'~'",
  114. "'('","')'","start"
  115. };
  116.  
  117. static const short yyr1[] = {     0,
  118.     33,    34,    34,    35,    35,    35,    35,    35,    35,    35,
  119.     35,    35,    35,    35,    35,    35,    35,    35,    35,    35,
  120.     35,    35,    35,    35,    35,    35,    35,    35,    35,    35
  121. };
  122.  
  123. static const short yyr2[] = {     0,
  124.      1,     1,     3,     2,     2,     2,     2,     3,     3,     3,
  125.      3,     3,     3,     3,     3,     3,     3,     3,     3,     3,
  126.      3,     3,     3,     3,     3,     3,     5,     1,     1,     1
  127. };
  128.  
  129. static const short yydefact[] = {     0,
  130.     28,    29,    30,     0,     0,     0,     0,     0,     1,     2,
  131.      6,     4,     5,     7,     0,     0,     0,     0,     0,     0,
  132.      0,     0,     0,     0,     0,     0,     0,     0,     0,     0,
  133.      0,     0,     0,     0,     0,     8,     3,     0,    26,    25,
  134.     24,    23,    22,    16,    17,    20,    21,    18,    19,    14,
  135.     15,    12,    13,     9,    10,    11,     0,    27,     0,     0,
  136.      0
  137. };
  138.  
  139. static const short yydefgoto[] = {    59,
  140.      9,    10
  141. };
  142.  
  143. static const short yypact[] = {    31,
  144. -32768,-32768,-32768,    31,    31,    31,    31,    31,     1,    77,
  145. -32768,-32768,-32768,-32768,     0,    31,    31,    31,    31,    31,
  146.     31,    31,    31,    31,    31,    31,    31,    31,    31,    31,
  147.     31,    31,    31,    31,    31,-32768,    77,    56,    94,    25,
  148.    109,   123,   136,   147,   147,   154,   154,   154,   154,   -19,
  149.    -19,    32,    32,-32768,-32768,-32768,    31,    77,    11,    33,
  150. -32768
  151. };
  152.  
  153. static const short yypgoto[] = {-32768,
  154.     48,    -4
  155. };
  156.  
  157.  
  158. #define    YYLAST        181
  159.  
  160.  
  161. static const short yytable[] = {    11,
  162.     12,    13,    14,    31,    32,    33,    34,    35,    16,    16,
  163.     60,    37,    38,    39,    40,    41,    42,    43,    44,    45,
  164.     46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
  165.     56,    36,    61,     1,     2,     3,    20,    21,    22,    23,
  166.     24,    25,    26,    27,    28,    29,    30,    31,    32,    33,
  167.     34,    35,    58,     4,     5,    15,    33,    34,    35,     6,
  168.      7,     8,    17,    57,     0,    18,    19,    20,    21,    22,
  169.     23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
  170.     33,    34,    35,    17,     0,     0,    18,    19,    20,    21,
  171.     22,    23,    24,    25,    26,    27,    28,    29,    30,    31,
  172.     32,    33,    34,    35,    19,    20,    21,    22,    23,    24,
  173.     25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
  174.     35,    21,    22,    23,    24,    25,    26,    27,    28,    29,
  175.     30,    31,    32,    33,    34,    35,    22,    23,    24,    25,
  176.     26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
  177.     23,    24,    25,    26,    27,    28,    29,    30,    31,    32,
  178.     33,    34,    35,    25,    26,    27,    28,    29,    30,    31,
  179.     32,    33,    34,    35,    29,    30,    31,    32,    33,    34,
  180.     35
  181. };
  182.  
  183. static const short yycheck[] = {     4,
  184.      5,     6,     7,    23,    24,    25,    26,    27,     9,     9,
  185.      0,    16,    17,    18,    19,    20,    21,    22,    23,    24,
  186.     25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
  187.     35,    32,     0,     3,     4,     5,    12,    13,    14,    15,
  188.     16,    17,    18,    19,    20,    21,    22,    23,    24,    25,
  189.     26,    27,    57,    23,    24,     8,    25,    26,    27,    29,
  190.     30,    31,     7,     8,    -1,    10,    11,    12,    13,    14,
  191.     15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
  192.     25,    26,    27,     7,    -1,    -1,    10,    11,    12,    13,
  193.     14,    15,    16,    17,    18,    19,    20,    21,    22,    23,
  194.     24,    25,    26,    27,    11,    12,    13,    14,    15,    16,
  195.     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
  196.     27,    13,    14,    15,    16,    17,    18,    19,    20,    21,
  197.     22,    23,    24,    25,    26,    27,    14,    15,    16,    17,
  198.     18,    19,    20,    21,    22,    23,    24,    25,    26,    27,
  199.     15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
  200.     25,    26,    27,    17,    18,    19,    20,    21,    22,    23,
  201.     24,    25,    26,    27,    21,    22,    23,    24,    25,    26,
  202.     27
  203. };
  204. #define YYPURE 1
  205.  
  206. /* -*-C-*-  Note some compilers choke on comments on `#line' lines.  */
  207. #line 3 "bison.simple"
  208.  
  209. /* Skeleton output parser for bison,
  210.    Copyright (C) 1984 Bob Corbett and Richard Stallman
  211.  
  212.    This program is free software; you can redistribute it and/or modify
  213.    it under the terms of the GNU General Public License as published by
  214.    the Free Software Foundation; either version 1, or (at your option)
  215.    any later version.
  216.  
  217.    This program is distributed in the hope that it will be useful,
  218.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  219.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  220.    GNU General Public License for more details.
  221.  
  222.    You should have received a copy of the GNU General Public License
  223.    along with this program; if not, write to the Free Software
  224.    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.  */
  225.  
  226.  
  227. #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__)
  228. #include <alloca.h>
  229. #endif
  230.  
  231. /* This is the parser code that is written into each bison parser
  232.   when the %semantic_parser declaration is not specified in the grammar.
  233.   It was written by Richard Stallman by simplifying the hairy parser
  234.   used when %semantic_parser is specified.  */
  235.  
  236. /* Note: there must be only one dollar sign in this file.
  237.    It is replaced by the list of actions, each action
  238.    as one case of the switch.  */
  239.  
  240. #define yyerrok        (yyerrstatus = 0)
  241. #define yyclearin    (yychar = YYEMPTY)
  242. #define YYEMPTY        -2
  243. #define YYEOF        0
  244. #define YYFAIL        goto yyerrlab;
  245. #define YYACCEPT    return(0)
  246. #define YYABORT     return(1)
  247. #define YYERROR        goto yyerrlab
  248.  
  249. #define YYTERROR    1
  250. #define YYERRCODE    256
  251.  
  252. #ifndef YYIMPURE
  253. #define YYLEX        yylex()
  254. #endif
  255.  
  256. #ifndef YYPURE
  257. #define YYLEX        yylex(&yylval, &yylloc)
  258. #endif
  259.  
  260. /* If nonreentrant, generate the variables here */
  261.  
  262. #ifndef YYIMPURE
  263.  
  264. int    yychar;            /*  the lookahead symbol        */
  265. YYSTYPE    yylval;            /*  the semantic value of the        */
  266.                 /*  lookahead symbol            */
  267.  
  268. YYLTYPE yylloc;            /*  location data for the lookahead    */
  269.                 /*  symbol                */
  270.  
  271. int yynerrs;            /*  number of parse errors so far       */
  272. #endif  /* YYIMPURE */
  273.  
  274. #if YYDEBUG != 0
  275. int yydebug;            /*  nonzero means print parse trace    */
  276. /* Since this is uninitialized, it does not stop multiple parsers
  277.    from coexisting.  */
  278. #endif
  279.  
  280. /*  YYMAXDEPTH indicates the initial size of the parser's stacks    */
  281.  
  282. #ifndef    YYMAXDEPTH
  283. #define YYMAXDEPTH 200
  284. #endif
  285.  
  286. /*  YYMAXLIMIT is the maximum size the stacks can grow to
  287.     (effective only if the built-in stack extension method is used).  */
  288.  
  289. #ifndef YYMAXLIMIT
  290. #define YYMAXLIMIT 10000
  291. #endif
  292.  
  293.  
  294. #line 90 "bison.simple"
  295. int
  296. yyparse()
  297. {
  298.   register int yystate;
  299.   register int yyn;
  300.   register short *yyssp;
  301.   register YYSTYPE *yyvsp;
  302.   YYLTYPE *yylsp;
  303.   int yyerrstatus;    /*  number of tokens to shift before error messages enabled */
  304.   int yychar1;        /*  lookahead token as an internal (translated) token number */
  305.  
  306.   short    yyssa[YYMAXDEPTH];    /*  the state stack            */
  307.   YYSTYPE yyvsa[YYMAXDEPTH];    /*  the semantic value stack        */
  308.   YYLTYPE yylsa[YYMAXDEPTH];    /*  the location stack            */
  309.  
  310.   short *yyss = yyssa;        /*  refer to the stacks thru separate pointers */
  311.   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
  312.   YYLTYPE *yyls = yylsa;
  313.  
  314.   int yymaxdepth = YYMAXDEPTH;
  315.  
  316. #ifndef YYPURE
  317.   int yychar;
  318.   YYSTYPE yylval;
  319.   YYLTYPE yylloc;
  320.   int yynerrs;
  321. #endif
  322.  
  323.   YYSTYPE yyval;        /*  the variable used to return        */
  324.                 /*  semantic values from the action    */
  325.                 /*  routines                */
  326.  
  327.   int yylen;
  328.  
  329. #if YYDEBUG != 0
  330.   if (yydebug)
  331.     fprintf(stderr, "Starting parse\n");
  332. #endif
  333.  
  334.   yystate = 0;
  335.   yyerrstatus = 0;
  336.   yynerrs = 0;
  337.   yychar = YYEMPTY;        /* Cause a token to be read.  */
  338.  
  339.   /* Initialize stack pointers.
  340.      Waste one element of value and location stack
  341.      so that they stay on the same level as the state stack.  */
  342.  
  343.   yyssp = yyss - 1;
  344.   yyvsp = yyvs;
  345.   yylsp = yyls;
  346.  
  347. /* Push a new state, which is found in  yystate  .  */
  348. /* In all cases, when you get here, the value and location stacks
  349.    have just been pushed. so pushing a state here evens the stacks.  */
  350. yynewstate:
  351.  
  352.   *++yyssp = yystate;
  353.  
  354.   if (yyssp >= yyss + yymaxdepth - 1)
  355.     {
  356.       /* Give user a chance to reallocate the stack */
  357.       /* Use copies of these so that the &'s don't force the real ones into memory. */
  358.       YYSTYPE *yyvs1 = yyvs;
  359.       YYLTYPE *yyls1 = yyls;
  360.       short *yyss1 = yyss;
  361.  
  362.       /* Get the current used size of the three stacks, in elements.  */
  363.       int size = yyssp - yyss + 1;
  364.  
  365. #ifdef yyoverflow
  366.       /* Each stack pointer address is followed by the size of
  367.      the data in use in that stack, in bytes.  */
  368.       yyoverflow("parser stack overflow",
  369.          &yyss1, size * sizeof (*yyssp),
  370.          &yyvs1, size * sizeof (*yyvsp),
  371.          &yyls1, size * sizeof (*yylsp),
  372.          &yymaxdepth);
  373.  
  374.       yyss = yyss1; yyvs = yyvs1; yyls = yyls1;
  375. #else /* no yyoverflow */
  376.       /* Extend the stack our own way.  */
  377.       if (yymaxdepth >= YYMAXLIMIT)
  378.     yyerror("parser stack overflow");
  379.       yymaxdepth *= 2;
  380.       if (yymaxdepth > YYMAXLIMIT)
  381.     yymaxdepth = YYMAXLIMIT;
  382.       yyss = (short *) alloca (yymaxdepth * sizeof (*yyssp));
  383.       bcopy ((char *)yyss1, (char *)yyss, size * sizeof (*yyssp));
  384.       yyvs = (YYSTYPE *) alloca (yymaxdepth * sizeof (*yyvsp));
  385.       bcopy ((char *)yyvs1, (char *)yyvs, size * sizeof (*yyvsp));
  386. #ifdef YYLSP_NEEDED
  387.       yyls = (YYLTYPE *) alloca (yymaxdepth * sizeof (*yylsp));
  388.       bcopy ((char *)yyls1, (char *)yyls, size * sizeof (*yylsp));
  389. #endif
  390. #endif /* no yyoverflow */
  391.  
  392.       yyssp = yyss + size - 1;
  393.       yyvsp = yyvs + size - 1;
  394. #ifdef YYLSP_NEEDED
  395.       yylsp = yyls + size - 1;
  396. #endif
  397.  
  398. #if YYDEBUG != 0
  399.       if (yydebug)
  400.     fprintf(stderr, "Stack size increased to %d\n", yymaxdepth);
  401. #endif
  402.  
  403.       if (yyssp >= yyss + yymaxdepth - 1)
  404.     YYABORT;
  405.     }
  406.  
  407. #if YYDEBUG != 0
  408.   if (yydebug)
  409.     fprintf(stderr, "Entering state %d\n", yystate);
  410. #endif
  411.  
  412. /* Do appropriate processing given the current state.  */
  413. /* Read a lookahead token if we need one and don't already have one.  */
  414. yyresume:
  415.  
  416.   /* First try to decide what to do without reference to lookahead token.  */
  417.  
  418.   yyn = yypact[yystate];
  419.   if (yyn == YYFLAG)
  420.     goto yydefault;
  421.  
  422.   /* Not known => get a lookahead token if don't already have one.  */
  423.  
  424.   /* yychar is either YYEMPTY or YYEOF
  425.      or a valid token in external form.  */
  426.  
  427.   if (yychar == YYEMPTY)
  428.     {
  429. #if YYDEBUG != 0
  430.       if (yydebug)
  431.     fprintf(stderr, "Reading a token: ");
  432. #endif
  433.       yychar = YYLEX;
  434.     }
  435.  
  436.   /* Convert token to internal form (in yychar1) for indexing tables with */
  437.  
  438.   if (yychar <= 0)        /* This means end of input. */
  439.     {
  440.       yychar1 = 0;
  441.       yychar = YYEOF;        /* Don't call YYLEX any more */
  442.  
  443. #if YYDEBUG != 0
  444.       if (yydebug)
  445.     fprintf(stderr, "Now at end of input.\n");
  446. #endif
  447.     }
  448.   else
  449.     {
  450.       yychar1 = YYTRANSLATE(yychar);
  451.  
  452. #if YYDEBUG != 0
  453.       if (yydebug)
  454.     fprintf(stderr, "Next token is %d (%s)\n", yychar, yytname[yychar1]);
  455. #endif
  456.     }
  457.  
  458.   yyn += yychar1;
  459.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
  460.     goto yydefault;
  461.  
  462.   yyn = yytable[yyn];
  463.  
  464.   /* yyn is what to do for this token type in this state.
  465.      Negative => reduce, -yyn is rule number.
  466.      Positive => shift, yyn is new state.
  467.        New state is final state => don't bother to shift,
  468.        just return success.
  469.      0, or most negative number => error.  */
  470.  
  471.   if (yyn < 0)
  472.     {
  473.       if (yyn == YYFLAG)
  474.     goto yyerrlab;
  475.       yyn = -yyn;
  476.       goto yyreduce;
  477.     }
  478.   else if (yyn == 0)
  479.     goto yyerrlab;
  480.  
  481.   if (yyn == YYFINAL)
  482.     YYACCEPT;
  483.  
  484.   /* Shift the lookahead token.  */
  485.  
  486. #if YYDEBUG != 0
  487.   if (yydebug)
  488.     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
  489. #endif
  490.  
  491.   /* Discard the token being shifted unless it is eof.  */
  492.   if (yychar != YYEOF)
  493.     yychar = YYEMPTY;
  494.  
  495.   *++yyvsp = yylval;
  496. #ifdef YYLSP_NEEDED
  497.   *++yylsp = yylloc;
  498. #endif
  499.  
  500.   /* count tokens shifted since error; after three, turn off error status.  */
  501.   if (yyerrstatus) yyerrstatus--;
  502.  
  503.   yystate = yyn;
  504.   goto yynewstate;
  505.  
  506. /* Do the default action for the current state.  */
  507. yydefault:
  508.  
  509.   yyn = yydefact[yystate];
  510.   if (yyn == 0)
  511.     goto yyerrlab;
  512.  
  513. /* Do a reduction.  yyn is the number of a rule to reduce with.  */
  514. yyreduce:
  515.   yylen = yyr2[yyn];
  516.   yyval = yyvsp[1-yylen]; /* implement default value of the action */
  517.  
  518. #if YYDEBUG != 0
  519.   if (yydebug)
  520.     {
  521.       if (yylen == 1)
  522.     fprintf (stderr, "Reducing 1 value via line %d, ",
  523.          yyrline[yyn]);
  524.       else
  525.     fprintf (stderr, "Reducing %d values via line %d, ",
  526.          yylen, yyrline[yyn]);
  527.     }
  528. #endif
  529.  
  530.  
  531.   switch (yyn) {
  532.  
  533. case 1:
  534. #line 75 "../gcc-1.37/cexp.y"
  535. { expression_value = yyvsp[0].integer.value; ;
  536.     break;}
  537. case 3:
  538. #line 81 "../gcc-1.37/cexp.y"
  539. { yyval.integer = yyvsp[0].integer; ;
  540.     break;}
  541. case 4:
  542. #line 86 "../gcc-1.37/cexp.y"
  543. { yyval.integer.value = - yyvsp[0].integer.value;
  544.               yyval.integer.unsignedp = yyvsp[0].integer.unsignedp; ;
  545.     break;}
  546. case 5:
  547. #line 89 "../gcc-1.37/cexp.y"
  548. { yyval.integer.value = ! yyvsp[0].integer.value;
  549.               yyval.integer.unsignedp = 0; ;
  550.     break;}
  551. case 6:
  552. #line 92 "../gcc-1.37/cexp.y"
  553. { yyval.integer = yyvsp[0].integer; ;
  554.     break;}
  555. case 7:
  556. #line 94 "../gcc-1.37/cexp.y"
  557. { yyval.integer.value = ~ yyvsp[0].integer.value;
  558.               yyval.integer.unsignedp = yyvsp[0].integer.unsignedp; ;
  559.     break;}
  560. case 8:
  561. #line 97 "../gcc-1.37/cexp.y"
  562. { yyval.integer = yyvsp[-1].integer; ;
  563.     break;}
  564. case 9:
  565. #line 102 "../gcc-1.37/cexp.y"
  566. { yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp;
  567.               if (yyval.integer.unsignedp)
  568.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value * yyvsp[0].integer.value;
  569.               else
  570.                 yyval.integer.value = yyvsp[-2].integer.value * yyvsp[0].integer.value; ;
  571.     break;}
  572. case 10:
  573. #line 108 "../gcc-1.37/cexp.y"
  574. { if (yyvsp[0].integer.value == 0)
  575.                 {
  576.                   error ("division by zero in #if");
  577.                   yyvsp[0].integer.value = 1;
  578.                 }
  579.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp;
  580.               if (yyval.integer.unsignedp)
  581.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value / yyvsp[0].integer.value;
  582.               else
  583.                 yyval.integer.value = yyvsp[-2].integer.value / yyvsp[0].integer.value; ;
  584.     break;}
  585. case 11:
  586. #line 119 "../gcc-1.37/cexp.y"
  587. { if (yyvsp[0].integer.value == 0)
  588.                 {
  589.                   error ("division by zero in #if");
  590.                   yyvsp[0].integer.value = 1;
  591.                 }
  592.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp;
  593.               if (yyval.integer.unsignedp)
  594.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value % yyvsp[0].integer.value;
  595.               else
  596.                 yyval.integer.value = yyvsp[-2].integer.value % yyvsp[0].integer.value; ;
  597.     break;}
  598. case 12:
  599. #line 130 "../gcc-1.37/cexp.y"
  600. { yyval.integer.value = yyvsp[-2].integer.value + yyvsp[0].integer.value;
  601.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  602.     break;}
  603. case 13:
  604. #line 133 "../gcc-1.37/cexp.y"
  605. { yyval.integer.value = yyvsp[-2].integer.value - yyvsp[0].integer.value;
  606.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  607.     break;}
  608. case 14:
  609. #line 136 "../gcc-1.37/cexp.y"
  610. { yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp;
  611.               if (yyval.integer.unsignedp)
  612.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value << yyvsp[0].integer.value;
  613.               else
  614.                 yyval.integer.value = yyvsp[-2].integer.value << yyvsp[0].integer.value; ;
  615.     break;}
  616. case 15:
  617. #line 142 "../gcc-1.37/cexp.y"
  618. { yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp;
  619.               if (yyval.integer.unsignedp)
  620.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value >> yyvsp[0].integer.value;
  621.               else
  622.                 yyval.integer.value = yyvsp[-2].integer.value >> yyvsp[0].integer.value; ;
  623.     break;}
  624. case 16:
  625. #line 148 "../gcc-1.37/cexp.y"
  626. { yyval.integer.value = (yyvsp[-2].integer.value == yyvsp[0].integer.value);
  627.               yyval.integer.unsignedp = 0; ;
  628.     break;}
  629. case 17:
  630. #line 151 "../gcc-1.37/cexp.y"
  631. { yyval.integer.value = (yyvsp[-2].integer.value != yyvsp[0].integer.value);
  632.               yyval.integer.unsignedp = 0; ;
  633.     break;}
  634. case 18:
  635. #line 154 "../gcc-1.37/cexp.y"
  636. { yyval.integer.unsignedp = 0;
  637.               if (yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp)
  638.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value <= yyvsp[0].integer.value;
  639.               else
  640.                 yyval.integer.value = yyvsp[-2].integer.value <= yyvsp[0].integer.value; ;
  641.     break;}
  642. case 19:
  643. #line 160 "../gcc-1.37/cexp.y"
  644. { yyval.integer.unsignedp = 0;
  645.               if (yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp)
  646.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value >= yyvsp[0].integer.value;
  647.               else
  648.                 yyval.integer.value = yyvsp[-2].integer.value >= yyvsp[0].integer.value; ;
  649.     break;}
  650. case 20:
  651. #line 166 "../gcc-1.37/cexp.y"
  652. { yyval.integer.unsignedp = 0;
  653.               if (yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp)
  654.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value < yyvsp[0].integer.value;
  655.               else
  656.                 yyval.integer.value = yyvsp[-2].integer.value < yyvsp[0].integer.value; ;
  657.     break;}
  658. case 21:
  659. #line 172 "../gcc-1.37/cexp.y"
  660. { yyval.integer.unsignedp = 0;
  661.               if (yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp)
  662.                 yyval.integer.value = (unsigned) yyvsp[-2].integer.value > yyvsp[0].integer.value;
  663.               else
  664.                 yyval.integer.value = yyvsp[-2].integer.value > yyvsp[0].integer.value; ;
  665.     break;}
  666. case 22:
  667. #line 178 "../gcc-1.37/cexp.y"
  668. { yyval.integer.value = yyvsp[-2].integer.value & yyvsp[0].integer.value;
  669.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  670.     break;}
  671. case 23:
  672. #line 181 "../gcc-1.37/cexp.y"
  673. { yyval.integer.value = yyvsp[-2].integer.value ^ yyvsp[0].integer.value;
  674.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  675.     break;}
  676. case 24:
  677. #line 184 "../gcc-1.37/cexp.y"
  678. { yyval.integer.value = yyvsp[-2].integer.value | yyvsp[0].integer.value;
  679.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  680.     break;}
  681. case 25:
  682. #line 187 "../gcc-1.37/cexp.y"
  683. { yyval.integer.value = (yyvsp[-2].integer.value && yyvsp[0].integer.value);
  684.               yyval.integer.unsignedp = 0; ;
  685.     break;}
  686. case 26:
  687. #line 190 "../gcc-1.37/cexp.y"
  688. { yyval.integer.value = (yyvsp[-2].integer.value || yyvsp[0].integer.value);
  689.               yyval.integer.unsignedp = 0; ;
  690.     break;}
  691. case 27:
  692. #line 193 "../gcc-1.37/cexp.y"
  693. { yyval.integer.value = yyvsp[-4].integer.value ? yyvsp[-2].integer.value : yyvsp[0].integer.value;
  694.               yyval.integer.unsignedp = yyvsp[-2].integer.unsignedp || yyvsp[0].integer.unsignedp; ;
  695.     break;}
  696. case 28:
  697. #line 196 "../gcc-1.37/cexp.y"
  698. { yyval.integer = yylval.integer; ;
  699.     break;}
  700. case 29:
  701. #line 198 "../gcc-1.37/cexp.y"
  702. { yyval.integer = yylval.integer; ;
  703.     break;}
  704. case 30:
  705. #line 200 "../gcc-1.37/cexp.y"
  706. { yyval.integer.value = 0;
  707.               yyval.integer.unsignedp = 0; ;
  708.     break;}
  709. }
  710.    /* the action file gets copied in in place of this dollarsign */
  711. #line 327 "bison.simple"
  712.  
  713.   yyvsp -= yylen;
  714.   yyssp -= yylen;
  715. #ifdef YYLSP_NEEDED
  716.   yylsp -= yylen;
  717. #endif
  718.  
  719. #if YYDEBUG != 0
  720.   if (yydebug)
  721.     {
  722.       short *ssp1 = yyss - 1;
  723.       fprintf (stderr, "state stack now");
  724.       while (ssp1 != yyssp)
  725.     fprintf (stderr, " %d", *++ssp1);
  726.       fprintf (stderr, "\n");
  727.     }
  728. #endif
  729.  
  730.   *++yyvsp = yyval;
  731.  
  732. #ifdef YYLSP_NEEDED
  733.   yylsp++;
  734.   if (yylen == 0)
  735.     {
  736.       yylsp->first_line = yylloc.first_line;
  737.       yylsp->first_column = yylloc.first_column;
  738.       yylsp->last_line = (yylsp-1)->last_line;
  739.       yylsp->last_column = (yylsp-1)->last_column;
  740.       yylsp->text = 0;
  741.     }
  742.   else
  743.     {
  744.       yylsp->last_line = (yylsp+yylen-1)->last_line;
  745.       yylsp->last_column = (yylsp+yylen-1)->last_column;
  746.     }
  747. #endif
  748.  
  749.   /* Now "shift" the result of the reduction.
  750.      Determine what state that goes to,
  751.      based on the state we popped back to
  752.      and the rule number reduced by.  */
  753.  
  754.   yyn = yyr1[yyn];
  755.  
  756.   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
  757.   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
  758.     yystate = yytable[yystate];
  759.   else
  760.     yystate = yydefgoto[yyn - YYNTBASE];
  761.  
  762.   goto yynewstate;
  763.  
  764. yyerrlab:   /* here on detecting error */
  765.  
  766.   if (! yyerrstatus)
  767.     /* If not already recovering from an error, report this error.  */
  768.     {
  769.       ++yynerrs;
  770.       yyerror("parse error");
  771.     }
  772.  
  773.   if (yyerrstatus == 3)
  774.     {
  775.       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
  776.  
  777.       /* return failure if at end of input */
  778.       if (yychar == YYEOF)
  779.     YYABORT;
  780.  
  781. #if YYDEBUG != 0
  782.       if (yydebug)
  783.     fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
  784. #endif
  785.  
  786.       yychar = YYEMPTY;
  787.     }
  788.  
  789.   /* Else will try to reuse lookahead token
  790.      after shifting the error token.  */
  791.  
  792.   yyerrstatus = 3;        /* Each real token shifted decrements this */
  793.  
  794.   goto yyerrhandle;
  795.  
  796. yyerrdefault:  /* current state does not do anything special for the error token. */
  797.  
  798. #if 0
  799.   /* This is wrong; only states that explicitly want error tokens
  800.      should shift them.  */
  801.   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
  802.   if (yyn) goto yydefault;
  803. #endif
  804.  
  805. yyerrpop:   /* pop the current state because it cannot handle the error token */
  806.  
  807.   if (yyssp == yyss) YYABORT;
  808.   yyvsp--;
  809.   yystate = *--yyssp;
  810. #ifdef YYLSP_NEEDED
  811.   yylsp--;
  812. #endif
  813.  
  814. #if YYDEBUG != 0
  815.   if (yydebug)
  816.     {
  817.       short *ssp1 = yyss - 1;
  818.       fprintf (stderr, "Error: state stack now");
  819.       while (ssp1 != yyssp)
  820.     fprintf (stderr, " %d", *++ssp1);
  821.       fprintf (stderr, "\n");
  822.     }
  823. #endif
  824.  
  825. yyerrhandle:
  826.  
  827.   yyn = yypact[yystate];
  828.   if (yyn == YYFLAG)
  829.     goto yyerrdefault;
  830.  
  831.   yyn += YYTERROR;
  832.   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
  833.     goto yyerrdefault;
  834.  
  835.   yyn = yytable[yyn];
  836.   if (yyn < 0)
  837.     {
  838.       if (yyn == YYFLAG)
  839.     goto yyerrpop;
  840.       yyn = -yyn;
  841.       goto yyreduce;
  842.     }
  843.   else if (yyn == 0)
  844.     goto yyerrpop;
  845.  
  846.   if (yyn == YYFINAL)
  847.     YYACCEPT;
  848.  
  849. #if YYDEBUG != 0
  850.   if (yydebug)
  851.     fprintf(stderr, "Shifting error token, ");
  852. #endif
  853.  
  854.   *++yyvsp = yylval;
  855. #ifdef YYLSP_NEEDED
  856.   *++yylsp = yylloc;
  857. #endif
  858.  
  859.   yystate = yyn;
  860.   goto yynewstate;
  861. }
  862. #line 203 "../gcc-1.37/cexp.y"
  863.  
  864.  
  865. /* During parsing of a C expression, the pointer to the next character
  866.    is in this variable.  */
  867.  
  868. static char *lexptr;
  869.  
  870. /* Take care of parsing a number (anything that starts with a digit).
  871.    Set yylval and return the token type; update lexptr.
  872.    LEN is the number of characters in it.  */
  873.  
  874. /* maybe needs to actually deal with floating point numbers */
  875.  
  876. int
  877. parse_number (olen)
  878.      int olen;
  879. {
  880.   register char *p = lexptr;
  881.   register long n = 0;
  882.   register int c;
  883.   register int base = 10;
  884.   register int len = olen;
  885.  
  886.   for (c = 0; c < len; c++)
  887.     if (p[c] == '.') {
  888.       /* It's a float since it contains a point.  */
  889.       yyerror ("floating point numbers not allowed in #if expressions");
  890.       return ERROR;
  891.     }
  892.  
  893.   yylval.integer.unsignedp = 0;
  894.  
  895.   if (len >= 3 && (!strncmp (p, "0x", 2) || !strncmp (p, "0X", 2))) {
  896.     p += 2;
  897.     base = 16;
  898.     len -= 2;
  899.   }
  900.   else if (*p == '0')
  901.     base = 8;
  902.  
  903.   while (len > 0) {
  904.     c = *p++;
  905.     len--;
  906.     if (c >= 'A' && c <= 'Z') c += 'a' - 'A';
  907.  
  908.     if (c >= '0' && c <= '9') {
  909.       n *= base;
  910.       n += c - '0';
  911.     } else if (base == 16 && c >= 'a' && c <= 'f') {
  912.       n *= base;
  913.       n += c - 'a' + 10;
  914.     } else {
  915.       /* `l' means long, and `u' means unsigned.  */
  916.       while (1) {
  917.     if (c == 'l' || c == 'L')
  918.       ;
  919.     else if (c == 'u' || c == 'U')
  920.       yylval.integer.unsignedp = 1;
  921.     else
  922.       break;
  923.  
  924.     if (len == 0)
  925.       break;
  926.     c = *p++;
  927.     len--;
  928.       }
  929.       /* Don't look for any more digits after the suffixes.  */
  930.       break;
  931.     }
  932.   }
  933.  
  934.   if (len != 0) {
  935.     yyerror ("Invalid number in #if expression");
  936.     return ERROR;
  937.   }
  938.  
  939.   /* If too big to be signed, consider it unsigned.  */
  940.   if (n < 0)
  941.     yylval.integer.unsignedp = 1;
  942.  
  943.   lexptr = p;
  944.   yylval.integer.value = n;
  945.   return INT;
  946. }
  947.  
  948. struct token {
  949.   char *operator;
  950.   int token;
  951. };
  952.  
  953. #ifndef NULL
  954. #define NULL 0
  955. #endif
  956.  
  957. static struct token tokentab2[] = {
  958.   {"&&", AND},
  959.   {"||", OR},
  960.   {"<<", LSH},
  961.   {">>", RSH},
  962.   {"==", EQUAL},
  963.   {"!=", NOTEQUAL},
  964.   {"<=", LEQ},
  965.   {">=", GEQ},
  966.   {NULL, ERROR}
  967. };
  968.  
  969. /* Read one token, getting characters through lexptr.  */
  970.  
  971. int
  972. yylex ()
  973. {
  974.   register int c;
  975.   register int namelen;
  976.   register char *tokstart;
  977.   register struct token *toktab;
  978.  
  979.  retry:
  980.  
  981.   tokstart = lexptr;
  982.   c = *tokstart;
  983.   /* See if it is a special token of length 2.  */
  984.   for (toktab = tokentab2; toktab->operator != NULL; toktab++)
  985.     if (c == *toktab->operator && tokstart[1] == toktab->operator[1]) {
  986.       lexptr += 2;
  987.       return toktab->token;
  988.     }
  989.  
  990.   switch (c) {
  991.   case 0:
  992.     return 0;
  993.     
  994.   case ' ':
  995.   case '\t':
  996.   case '\n':
  997.     lexptr++;
  998.     goto retry;
  999.     
  1000.   case '\'':
  1001.     lexptr++;
  1002.     c = *lexptr++;
  1003.     if (c == '\\')
  1004.       c = parse_escape (&lexptr);
  1005.  
  1006.     /* Sign-extend the constant if chars are signed on target machine.  */
  1007.     {
  1008.       if (lookup ("__CHAR_UNSIGNED__", sizeof ("__CHAR_UNSIGNED__")-1, -1)
  1009.       || ((c >> (CHAR_TYPE_SIZE - 1)) & 1) == 0)
  1010.     yylval.integer.value = c & ((1 << CHAR_TYPE_SIZE) - 1);
  1011.       else
  1012.     yylval.integer.value = c | ~((1 << CHAR_TYPE_SIZE) - 1);
  1013.     }
  1014.  
  1015.     yylval.integer.unsignedp = 0;
  1016.     c = *lexptr++;
  1017.     if (c != '\'') {
  1018.       yyerror ("Invalid character constant in #if");
  1019.       return ERROR;
  1020.     }
  1021.     
  1022.     return CHAR;
  1023.  
  1024.     /* some of these chars are invalid in constant expressions;
  1025.        maybe do something about them later */
  1026.   case '/':
  1027.   case '+':
  1028.   case '-':
  1029.   case '*':
  1030.   case '%':
  1031.   case '|':
  1032.   case '&':
  1033.   case '^':
  1034.   case '~':
  1035.   case '!':
  1036.   case '@':
  1037.   case '<':
  1038.   case '>':
  1039.   case '(':
  1040.   case ')':
  1041.   case '[':
  1042.   case ']':
  1043.   case '.':
  1044.   case '?':
  1045.   case ':':
  1046.   case '=':
  1047.   case '{':
  1048.   case '}':
  1049.   case ',':
  1050.     lexptr++;
  1051.     return c;
  1052.     
  1053.   case '"':
  1054.     yyerror ("double quoted strings not allowed in #if expressions");
  1055.     return ERROR;
  1056.   }
  1057.   if (c >= '0' && c <= '9') {
  1058.     /* It's a number */
  1059.     for (namelen = 0;
  1060.      c = tokstart[namelen], is_idchar[c] || c == '.'; 
  1061.      namelen++)
  1062.       ;
  1063.     return parse_number (namelen);
  1064.   }
  1065.   
  1066.   if (!is_idstart[c]) {
  1067.     yyerror ("Invalid token in expression");
  1068.     return ERROR;
  1069.   }
  1070.   
  1071.   /* It is a name.  See how long it is.  */
  1072.   
  1073.   for (namelen = 0; is_idchar[tokstart[namelen]]; namelen++)
  1074.     ;
  1075.   
  1076.   lexptr += namelen;
  1077.   return NAME;
  1078. }
  1079.  
  1080.  
  1081. /* Parse a C escape sequence.  STRING_PTR points to a variable
  1082.    containing a pointer to the string to parse.  That pointer
  1083.    is updated past the characters we use.  The value of the
  1084.    escape sequence is returned.
  1085.  
  1086.    A negative value means the sequence \ newline was seen,
  1087.    which is supposed to be equivalent to nothing at all.
  1088.  
  1089.    If \ is followed by a null character, we return a negative
  1090.    value and leave the string pointer pointing at the null character.
  1091.  
  1092.    If \ is followed by 000, we return 0 and leave the string pointer
  1093.    after the zeros.  A value of 0 does not mean end of string.  */
  1094.  
  1095. int
  1096. parse_escape (string_ptr)
  1097.      char **string_ptr;
  1098. {
  1099.   register int c = *(*string_ptr)++;
  1100.   switch (c)
  1101.     {
  1102.     case 'a':
  1103.       return TARGET_BELL;
  1104.     case 'b':
  1105.       return TARGET_BS;
  1106.     case 'e':
  1107.       return 033;
  1108.     case 'f':
  1109.       return TARGET_FF;
  1110.     case 'n':
  1111.       return TARGET_NEWLINE;
  1112.     case 'r':
  1113.       return TARGET_CR;
  1114.     case 't':
  1115.       return TARGET_TAB;
  1116.     case 'v':
  1117.       return TARGET_VT;
  1118.     case '\n':
  1119.       return -2;
  1120.     case 0:
  1121.       (*string_ptr)--;
  1122.       return 0;
  1123.     case '^':
  1124.       c = *(*string_ptr)++;
  1125.       if (c == '\\')
  1126.     c = parse_escape (string_ptr);
  1127.       if (c == '?')
  1128.     return 0177;
  1129.       return (c & 0200) | (c & 037);
  1130.       
  1131.     case '0':
  1132.     case '1':
  1133.     case '2':
  1134.     case '3':
  1135.     case '4':
  1136.     case '5':
  1137.     case '6':
  1138.     case '7':
  1139.       {
  1140.     register int i = c - '0';
  1141.     register int count = 0;
  1142.     while (++count < 3)
  1143.       {
  1144.         c = *(*string_ptr)++;
  1145.         if (c >= '0' && c <= '7')
  1146.           i = (i << 3) + c - '0';
  1147.         else
  1148.           {
  1149.         (*string_ptr)--;
  1150.         break;
  1151.           }
  1152.       }
  1153.     if ((i & ~((1 << CHAR_TYPE_SIZE) - 1)) != 0)
  1154.       {
  1155.         i &= (1 << CHAR_TYPE_SIZE) - 1;
  1156.         warning ("octal character constant does not fit in a byte");
  1157.       }
  1158.     return i;
  1159.       }
  1160.     case 'x':
  1161.       {
  1162.     register int i = 0;
  1163.     register int count = 0;
  1164.     for (;;)
  1165.       {
  1166.         c = *(*string_ptr)++;
  1167.         if (c >= '0' && c <= '9')
  1168.           i = (i << 4) + c - '0';
  1169.         else if (c >= 'a' && c <= 'f')
  1170.           i = (i << 4) + c - 'a' + 10;
  1171.         else if (c >= 'A' && c <= 'F')
  1172.           i = (i << 4) + c - 'A' + 10;
  1173.         else
  1174.           {
  1175.         (*string_ptr)--;
  1176.         break;
  1177.           }
  1178.       }
  1179.     if ((i & ~((1 << BITS_PER_UNIT) - 1)) != 0)
  1180.       {
  1181.         i &= (1 << BITS_PER_UNIT) - 1;
  1182.         warning ("hex character constant does not fit in a byte");
  1183.       }
  1184.     return i;
  1185.       }
  1186.     default:
  1187.       return c;
  1188.     }
  1189. }
  1190.  
  1191. void
  1192. yyerror (s)
  1193.      char *s;
  1194. {
  1195.   error (s);
  1196.   longjmp (parse_return_error, 1);
  1197. }
  1198.  
  1199. /* This page contains the entry point to this file.  */
  1200.  
  1201. /* Parse STRING as an expression, and complain if this fails
  1202.    to use up all of the contents of STRING.  */
  1203. /* We do not support C comments.  They should be removed before
  1204.    this function is called.  */
  1205.  
  1206. int
  1207. parse_c_expression (string)
  1208.      char *string;
  1209. {
  1210.   lexptr = string;
  1211.   
  1212.   if (lexptr == 0 || *lexptr == 0) {
  1213.     error ("empty #if expression");
  1214.     return 0;            /* don't include the #if group */
  1215.   }
  1216.  
  1217.   /* if there is some sort of scanning error, just return 0 and assume
  1218.      the parsing routine has printed an error message somewhere.
  1219.      there is surely a better thing to do than this.     */
  1220.   if (setjmp (parse_return_error))
  1221.     return 0;
  1222.  
  1223.   if (yyparse ())
  1224.     return 0;            /* actually this is never reached
  1225.                    the way things stand. */
  1226.   if (*lexptr)
  1227.     error ("Junk after end of expression.");
  1228.  
  1229.   return expression_value;    /* set by yyparse () */
  1230. }
  1231.  
  1232. #ifdef TEST_EXP_READER
  1233. /* main program, for testing purposes. */
  1234. main ()
  1235. {
  1236.   int n, c;
  1237.   char buf[1024];
  1238.   extern int yydebug;
  1239. /*
  1240.   yydebug = 1;
  1241. */
  1242.   initialize_random_junk ();
  1243.  
  1244.   for (;;) {
  1245.     printf ("enter expression: ");
  1246.     n = 0;
  1247.     while ((buf[n] = getchar ()) != '\n' && buf[n] != EOF)
  1248.       n++;
  1249.     if (buf[n] == EOF)
  1250.       break;
  1251.     buf[n] = '\0';
  1252.     printf ("parser returned %d\n", parse_c_expression (buf));
  1253.   }
  1254. }
  1255.  
  1256. /* table to tell if char can be part of a C identifier. */
  1257. unsigned char is_idchar[256];
  1258. /* table to tell if char can be first char of a c identifier. */
  1259. unsigned char is_idstart[256];
  1260. /* table to tell if c is horizontal space.  isspace () thinks that
  1261.    newline is space; this is not a good idea for this program. */
  1262. char is_hor_space[256];
  1263.  
  1264. /*
  1265.  * initialize random junk in the hash table and maybe other places
  1266.  */
  1267. initialize_random_junk ()
  1268. {
  1269.   register int i;
  1270.  
  1271.   /*
  1272.    * Set up is_idchar and is_idstart tables.  These should be
  1273.    * faster than saying (is_alpha (c) || c == '_'), etc.
  1274.    * Must do set up these things before calling any routines tthat
  1275.    * refer to them.
  1276.    */
  1277.   for (i = 'a'; i <= 'z'; i++) {
  1278.     ++is_idchar[i - 'a' + 'A'];
  1279.     ++is_idchar[i];
  1280.     ++is_idstart[i - 'a' + 'A'];
  1281.     ++is_idstart[i];
  1282.   }
  1283.   for (i = '0'; i <= '9'; i++)
  1284.     ++is_idchar[i];
  1285.   ++is_idchar['_'];
  1286.   ++is_idstart['_'];
  1287. #if DOLLARS_IN_IDENTIFIERS
  1288.   ++is_idchar['$'];
  1289.   ++is_idstart['$'];
  1290. #endif
  1291.  
  1292.   /* horizontal space table */
  1293.   ++is_hor_space[' '];
  1294.   ++is_hor_space['\t'];
  1295. }
  1296.  
  1297. error (msg)
  1298. {
  1299.   printf ("error: %s\n", msg);
  1300. }
  1301.  
  1302. warning (msg)
  1303. {
  1304.   printf ("warning: %s\n", msg);
  1305. }
  1306.  
  1307. struct hashnode *
  1308. lookup (name, len, hash)
  1309.      char *name;
  1310.      int len;
  1311.      int hash;
  1312. {
  1313.   return (DEFAULT_SIGNED_CHAR) ? 0 : ((struct hashnode *) -1);
  1314. }
  1315. #endif
  1316.