LCOV - code coverage report
Current view: top level - hwpfilter/source - grammar.cxx (source / functions) Hit Total Coverage
Test: commit e02a6cb2c3e2b23b203b422e4e0680877f232636 Lines: 0 284 0.0 %
Date: 2014-04-14 Functions: 0 6 0.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
       2             : /*
       3             :  * This file is part of the LibreOffice project.
       4             :  *
       5             :  * This Source Code Form is subject to the terms of the Mozilla Public
       6             :  * License, v. 2.0. If a copy of the MPL was not distributed with this
       7             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       8             :  *
       9             :  * This file incorporates work covered by the following license notice:
      10             :  *
      11             :  *   Licensed to the Apache Software Foundation (ASF) under one or more
      12             :  *   contributor license agreements. See the NOTICE file distributed
      13             :  *   with this work for additional information regarding copyright
      14             :  *   ownership. The ASF licenses this file to you under the Apache
      15             :  *   License, Version 2.0 (the "License"); you may not use this file
      16             :  *   except in compliance with the License. You may obtain a copy of
      17             :  *   the License at http://www.apache.org/licenses/LICENSE-2.0 .
      18             :  */
      19             : 
      20             : 
      21             : /*  A Bison parser, made from grammar.y
      22             :     by GNU Bison version 1.28  */
      23             : 
      24             : #ifndef YYDEBUG
      25             : #define YYDEBUG 0
      26             : #endif
      27             : #ifndef YYMAXDEPTH
      28             : #define YYMAXDEPTH 0
      29             : #endif
      30             : 
      31             : #include <list>
      32             : #include <stdlib.h>
      33             : #include <string.h>
      34             : 
      35             : #include "nodes.h"
      36             : 
      37           0 : std::list<Node*> nodelist;
      38             : 
      39             : Node *mainParse(const char *_code);
      40             : void yyerror(const char *);
      41             : int yylex();
      42             : void initFlex( const char *s );
      43             : void viewResult(Node *res);
      44             : 
      45             : Node *top=0L;
      46             : 
      47             : int Node::count = 0;
      48             : 
      49             : #define allocValue(x,y) \
      50             : x = (char *)malloc( strlen(y) +1 ); \
      51             : strcpy(x,y)
      52             : 
      53             : #define allocChar(x,y) \
      54             : x = (char *)malloc(2); \
      55             : sprintf(x,"%c",y)
      56             : #ifdef PARSE_DEBUG
      57             : #define debug printf
      58             : #else
      59             : int debug(const char *format, ...);
      60             : #endif
      61             : 
      62             : 
      63             : typedef union {
      64             :     char *dval;
      65             :     char *str;
      66             :     Node *ptr;
      67             : } YYSTYPE;
      68             : #include <stdio.h>
      69             : 
      70             : #ifndef __cplusplus
      71             : #ifndef __STDC__
      72             : #define const
      73             : #endif
      74             : #endif
      75             : 
      76             : 
      77             : 
      78             : #define YYFINAL     102
      79             : #define YYFLAG      -32768
      80             : #define YYNTBASE    43
      81             : 
      82             : #define YYTRANSLATE(x) ((unsigned)(x) <= 285 ? yytranslate[x] : 66)
      83             : 
      84             : static const char yytranslate[] = {     0,
      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,     2,     2,     2,     2,     2,     2,     2,
      88             :      2,     2,     2,     2,     2,     2,     2,     2,     2,    33,
      89             :     37,     2,     2,     2,     2,     2,     2,     2,     2,     2,
      90             :      2,     2,     2,     2,     2,     2,     2,     2,     2,    36,
      91             :      2,    40,     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             :     34,     2,    38,    42,    41,     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,    35,    32,    39,     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,     2,     2,     2,     2,     2,
     101             :      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     102             :      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     103             :      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     104             :      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     105             :      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     106             :      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     107             :      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     108             :      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     109             :      2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
     110             :      2,     2,     2,     2,     2,     1,     3,     4,     5,     6,
     111             :      7,     8,     9,    10,    11,    12,    13,    14,    15,    16,
     112             :     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     113             :     27,    28,    29,    30,    31
     114             : };
     115             : 
     116             : #if YYDEBUG != 0
     117             : static const short yyprhs[] = {     0,
     118             :      0,     2,     4,     6,     8,    10,    12,    14,    16,    18,
     119             :     20,    22,    24,    26,    28,    30,    32,    34,    36,    39,
     120             :     42,    45,    48,    51,    54,    58,    60,    63,    66,    69,
     121             :     72,    75,    79,    81,    85,    89,    92,    96,    99,   103,
     122             :    106,   110,   114,   120,   124,   130,   132,   135,   137,   140,
     123             :    143,   147,   150,   154,   157,   159,   161,   165,   167,   169,
     124             :    172,   174,   176,   178,   180,   182,   184,   186,   188,   190,
     125             :    192,   194
     126             : };
     127             : 
     128             : static const short yyrhs[] = {     4,
     129             :      0,     9,     0,    10,     0,     5,     0,    11,     0,    12,
     130             :      0,    20,     0,    21,     0,     7,     0,     6,     0,    23,
     131             :      0,    17,     0,    18,     0,     8,     0,    32,     0,    31,
     132             :      0,    22,     0,    43,     0,    44,    43,     0,    26,    33,
     133             :      0,    26,    34,     0,    26,    35,     0,    26,    36,     0,
     134             :     26,    32,     0,    26,    32,    32,     0,    29,     0,    27,
     135             :     37,     0,    27,    38,     0,    27,    39,     0,    27,    40,
     136             :      0,    27,    32,     0,    27,    32,    32,     0,    30,     0,
     137             :     45,    64,    46,     0,    33,    64,    37,     0,    33,    37,
     138             :      0,    35,    64,    39,     0,    35,    39,     0,    34,    64,
     139             :     38,     0,    34,    38,     0,    65,    41,    65,     0,    65,
     140             :     42,    65,     0,    65,    41,    49,    42,    49,     0,    14,
     141             :     49,    49,     0,    35,    64,    16,    64,    39,     0,     3,
     142             :      0,    54,    49,     0,    19,     0,    56,    49,     0,    13,
     143             :     49,     0,    13,    50,    49,     0,    24,    49,     0,    24,
     144             :     49,    49,     0,    25,    49,     0,    62,     0,    63,     0,
     145             :     62,    28,    63,     0,    64,     0,    65,     0,    64,    65,
     146             :      0,    49,     0,    48,     0,    47,     0,    51,     0,    52,
     147             :      0,    53,     0,    57,     0,    58,     0,    55,     0,    44,
     148             :      0,    59,     0,    60,     0
     149             : };
     150             : 
     151             : #endif
     152             : 
     153             : #if YYDEBUG != 0
     154             : static const short yyrline[] = { 0,
     155             :     59,    61,    62,    63,    64,    65,    66,    67,    68,    69,
     156             :     70,    71,    72,    73,    74,    75,    76,    79,    81,    84,
     157             :     86,    87,    88,    89,    90,    91,    94,    96,    97,    98,
     158             :     99,   100,   101,   104,   108,   110,   113,   115,   118,   120,
     159             :    123,   125,   126,   129,   133,   138,   142,   145,   149,   153,
     160             :    155,   158,   160,   163,   168,   172,   174,   177,   181,   183,
     161             :    186,   188,   189,   190,   191,   192,   193,   194,   195,   196,
     162             :    197,   198
     163             : };
     164             : #endif
     165             : 
     166             : 
     167             : #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
     168             : 
     169             : static const char * const yytname[] = {   "$","error","$undefined.","ACCENT",
     170             : "SMALL_GREEK","CAPITAL_GREEK","BINARY_OPERATOR","RELATION_OPERATOR","ARROW",
     171             : "GENERAL_IDEN","GENERAL_OPER","BIG_SYMBOL","FUNCTION","ROOT","FRACTION","SUBSUP",
     172             : "EQOVER","DELIMETER","LARGE_DELIM","DECORATION","SPACE_SYMBOL","CHARACTER","STRING",
     173             : "OPERATOR","EQBEGIN","EQEND","EQLEFT","EQRIGHT","NEWLINE","LEFT_DELIM","RIGHT_DELIM",
     174             : "DIGIT","'|'","'('","'['","'{'","'<'","')'","']'","'}'","'>'","'_'","'^'","Identifier",
     175             : "PrimaryExpr","EQLeft","EQRight","Fence","Parenth","Block","Bracket","SubSupExpr",
     176             : "FractionExpr","OverExpr","Accent","AccentExpr","Decoration","DecorationExpr",
     177             : "RootExpr","BeginExpr","EndExpr","MathML","Lines","Line","ExprList","Expr", NULL
     178             : };
     179             : #endif
     180             : 
     181             : static const short yyr1[] = {     0,
     182             :     43,    43,    43,    43,    43,    43,    43,    43,    43,    43,
     183             :     43,    43,    43,    43,    43,    43,    43,    44,    44,    45,
     184             :     45,    45,    45,    45,    45,    45,    46,    46,    46,    46,
     185             :     46,    46,    46,    47,    48,    48,    49,    49,    50,    50,
     186             :     51,    51,    51,    52,    53,    54,    55,    56,    57,    58,
     187             :     58,    59,    59,    60,    61,    62,    62,    63,    64,    64,
     188             :     65,    65,    65,    65,    65,    65,    65,    65,    65,    65,
     189             :     65,    65
     190             : };
     191             : 
     192             : static const short yyr2[] = {     0,
     193             :      1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     194             :      1,     1,     1,     1,     1,     1,     1,     1,     2,     2,
     195             :      2,     2,     2,     2,     3,     1,     2,     2,     2,     2,
     196             :      2,     3,     1,     3,     3,     2,     3,     2,     3,     2,
     197             :      3,     3,     5,     3,     5,     1,     2,     1,     2,     2,
     198             :      3,     2,     3,     2,     1,     1,     3,     1,     1,     2,
     199             :      1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
     200             :      1,     1
     201             : };
     202             : 
     203             : static const short yydefact[] = {     0,
     204             :     46,     1,     4,    10,     9,    14,     2,     3,     5,     6,
     205             :      0,     0,    12,    13,    48,     7,     8,    17,    11,     0,
     206             :      0,     0,    26,    16,    15,     0,     0,    18,    70,     0,
     207             :     63,    62,    61,    64,    65,    66,     0,    69,     0,    67,
     208             :     68,    71,    72,    55,    56,    58,    59,     0,     0,    50,
     209             :      0,     0,    52,    54,    24,    20,    21,    22,    23,    36,
     210             :      0,    38,     0,    19,     0,    47,    49,     0,    60,     0,
     211             :      0,    40,     0,     0,    51,    44,    53,    25,    35,     0,
     212             :     37,     0,    33,    34,    57,    61,    41,    42,    39,     0,
     213             :     31,    27,    28,    29,    30,     0,    45,    32,    43,     0,
     214             :      0,     0
     215             : };
     216             : 
     217             : static const short yydefgoto[] = {    28,
     218             :     29,    30,    84,    31,    32,    33,    51,    34,    35,    36,
     219             :     37,    38,    39,    40,    41,    42,    43,   100,    44,    45,
     220             :     46,    47
     221             : };
     222             : 
     223             : static const short yypact[] = {   393,
     224             : -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
     225             :    -30,   -19,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   -19,
     226             :    -19,    -3,-32768,-32768,-32768,   290,   107,-32768,   425,   393,
     227             : -32768,-32768,-32768,-32768,-32768,-32768,   -19,-32768,   -19,-32768,
     228             : -32768,-32768,-32768,   -20,-32768,   393,   -21,   218,   107,-32768,
     229             :    -19,   -19,   -19,-32768,   -15,-32768,-32768,-32768,-32768,-32768,
     230             :    325,-32768,    70,-32768,   360,-32768,-32768,   393,   -21,   393,
     231             :    393,-32768,   254,   144,-32768,-32768,-32768,-32768,-32768,   393,
     232             : -32768,   -25,-32768,-32768,-32768,   -31,   -21,   -21,-32768,   181,
     233             :    -14,-32768,-32768,-32768,-32768,   -19,-32768,-32768,-32768,    22,
     234             :     23,-32768
     235             : };
     236             : 
     237             : static const short yypgoto[] = {    -2,
     238             : -32768,-32768,-32768,-32768,-32768,   -11,-32768,-32768,-32768,-32768,
     239             : -32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,   -33,
     240             :    -24,   -27
     241             : };
     242             : 
     243             : 
     244             : #define YYLAST      457
     245             : 
     246             : 
     247             : static const short yytable[] = {    50,
     248             :     52,    61,    63,    48,    49,    65,    91,    68,    53,    54,
     249             :     96,    92,    93,    94,    95,    49,    78,    98,    69,    70,
     250             :     71,   101,   102,    73,    74,    66,    64,    67,    55,    56,
     251             :     57,    58,    59,    69,    85,    69,     0,    69,     0,    75,
     252             :     76,    77,    87,    88,     0,    69,    69,     0,     0,     0,
     253             :      0,     0,     0,     0,     0,    90,     0,     0,    86,     0,
     254             :      0,     0,    69,     0,     0,     0,     0,     0,     0,     0,
     255             :      0,     0,     1,     2,     3,     4,     5,     6,     7,     8,
     256             :      9,    10,    11,    12,    99,    80,    13,    14,    15,    16,
     257             :     17,    18,    19,    20,    21,    22,     0,     0,    23,     0,
     258             :     24,    25,    26,     0,    27,     0,     0,     0,    81,     1,
     259             :      2,     3,     4,     5,     6,     7,     8,     9,    10,    11,
     260             :     12,     0,     0,    13,    14,    15,    16,    17,    18,    19,
     261             :     20,    21,    22,     0,     0,    23,     0,    24,    25,    26,
     262             :      0,    27,     0,     0,     0,    62,     1,     2,     3,     4,
     263             :      5,     6,     7,     8,     9,    10,    11,    12,     0,     0,
     264             :     13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     265             :      0,     0,    23,     0,    24,    25,    26,     0,    27,     0,
     266             :      0,     0,    81,     1,     2,     3,     4,     5,     6,     7,
     267             :      8,     9,    10,    11,    12,     0,     0,    13,    14,    15,
     268             :     16,    17,    18,    19,    20,    21,    22,     0,     0,    23,
     269             :      0,    24,    25,    26,     0,    27,     0,     0,     0,    97,
     270             :      1,     2,     3,     4,     5,     6,     7,     8,     9,    10,
     271             :     11,    12,     0,     0,    13,    14,    15,    16,    17,    18,
     272             :     19,    20,    21,    22,     0,     0,    23,     0,    24,    25,
     273             :     26,     0,    27,     0,     0,    72,     1,     2,     3,     4,
     274             :      5,     6,     7,     8,     9,    10,    11,    12,     0,     0,
     275             :     13,    14,    15,    16,    17,    18,    19,    20,    21,    22,
     276             :      0,     0,    23,     0,    24,    25,    26,     0,    27,     0,
     277             :      0,    89,     1,     2,     3,     4,     5,     6,     7,     8,
     278             :      9,    10,    11,    12,     0,     0,    13,    14,    15,    16,
     279             :     17,    18,    19,    20,    21,    22,     0,     0,    23,     0,
     280             :     24,    25,    26,     0,    27,     0,    60,     1,     2,     3,
     281             :      4,     5,     6,     7,     8,     9,    10,    11,    12,     0,
     282             :      0,    13,    14,    15,    16,    17,    18,    19,    20,    21,
     283             :     22,     0,     0,    23,     0,    24,    25,    26,     0,    27,
     284             :      0,    79,     1,     2,     3,     4,     5,     6,     7,     8,
     285             :      9,    10,    11,    12,     0,     0,    13,    14,    15,    16,
     286             :     17,    18,    19,    20,    21,    22,    82,     0,    23,    83,
     287             :     24,    25,    26,     0,    27,     1,     2,     3,     4,     5,
     288             :      6,     7,     8,     9,    10,    11,    12,     0,     0,    13,
     289             :     14,    15,    16,    17,    18,    19,    20,    21,    22,     0,
     290             :      0,    23,     0,    24,    25,    26,     0,    27,     2,     3,
     291             :      4,     5,     6,     7,     8,     9,    10,     0,     0,     0,
     292             :      0,    13,    14,     0,    16,    17,    18,    19,     0,     0,
     293             :      0,     0,     0,     0,     0,    24,    25
     294             : };
     295             : 
     296             : static const short yycheck[] = {    11,
     297             :     12,    26,    27,    34,    35,    30,    32,    28,    20,    21,
     298             :     42,    37,    38,    39,    40,    35,    32,    32,    46,    41,
     299             :     42,     0,     0,    48,    49,    37,    29,    39,    32,    33,
     300             :     34,    35,    36,    61,    68,    63,    -1,    65,    -1,    51,
     301             :     52,    53,    70,    71,    -1,    73,    74,    -1,    -1,    -1,
     302             :     -1,    -1,    -1,    -1,    -1,    80,    -1,    -1,    70,    -1,
     303             :     -1,    -1,    90,    -1,    -1,    -1,    -1,    -1,    -1,    -1,
     304             :     -1,    -1,     3,     4,     5,     6,     7,     8,     9,    10,
     305             :     11,    12,    13,    14,    96,    16,    17,    18,    19,    20,
     306             :     21,    22,    23,    24,    25,    26,    -1,    -1,    29,    -1,
     307             :     31,    32,    33,    -1,    35,    -1,    -1,    -1,    39,     3,
     308             :      4,     5,     6,     7,     8,     9,    10,    11,    12,    13,
     309             :     14,    -1,    -1,    17,    18,    19,    20,    21,    22,    23,
     310             :     24,    25,    26,    -1,    -1,    29,    -1,    31,    32,    33,
     311             :     -1,    35,    -1,    -1,    -1,    39,     3,     4,     5,     6,
     312             :      7,     8,     9,    10,    11,    12,    13,    14,    -1,    -1,
     313             :     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     314             :     -1,    -1,    29,    -1,    31,    32,    33,    -1,    35,    -1,
     315             :     -1,    -1,    39,     3,     4,     5,     6,     7,     8,     9,
     316             :     10,    11,    12,    13,    14,    -1,    -1,    17,    18,    19,
     317             :     20,    21,    22,    23,    24,    25,    26,    -1,    -1,    29,
     318             :     -1,    31,    32,    33,    -1,    35,    -1,    -1,    -1,    39,
     319             :      3,     4,     5,     6,     7,     8,     9,    10,    11,    12,
     320             :     13,    14,    -1,    -1,    17,    18,    19,    20,    21,    22,
     321             :     23,    24,    25,    26,    -1,    -1,    29,    -1,    31,    32,
     322             :     33,    -1,    35,    -1,    -1,    38,     3,     4,     5,     6,
     323             :      7,     8,     9,    10,    11,    12,    13,    14,    -1,    -1,
     324             :     17,    18,    19,    20,    21,    22,    23,    24,    25,    26,
     325             :     -1,    -1,    29,    -1,    31,    32,    33,    -1,    35,    -1,
     326             :     -1,    38,     3,     4,     5,     6,     7,     8,     9,    10,
     327             :     11,    12,    13,    14,    -1,    -1,    17,    18,    19,    20,
     328             :     21,    22,    23,    24,    25,    26,    -1,    -1,    29,    -1,
     329             :     31,    32,    33,    -1,    35,    -1,    37,     3,     4,     5,
     330             :      6,     7,     8,     9,    10,    11,    12,    13,    14,    -1,
     331             :     -1,    17,    18,    19,    20,    21,    22,    23,    24,    25,
     332             :     26,    -1,    -1,    29,    -1,    31,    32,    33,    -1,    35,
     333             :     -1,    37,     3,     4,     5,     6,     7,     8,     9,    10,
     334             :     11,    12,    13,    14,    -1,    -1,    17,    18,    19,    20,
     335             :     21,    22,    23,    24,    25,    26,    27,    -1,    29,    30,
     336             :     31,    32,    33,    -1,    35,     3,     4,     5,     6,     7,
     337             :      8,     9,    10,    11,    12,    13,    14,    -1,    -1,    17,
     338             :     18,    19,    20,    21,    22,    23,    24,    25,    26,    -1,
     339             :     -1,    29,    -1,    31,    32,    33,    -1,    35,     4,     5,
     340             :      6,     7,     8,     9,    10,    11,    12,    -1,    -1,    -1,
     341             :     -1,    17,    18,    -1,    20,    21,    22,    23,    -1,    -1,
     342             :     -1,    -1,    -1,    -1,    -1,    31,    32
     343             : };
     344             : /* This file comes from bison-1.28.  */
     345             : 
     346             : /* Skeleton output parser for bison,
     347             :    Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
     348             : 
     349             :    This program is free software; you can redistribute it and/or modify
     350             :    it under the terms of the GNU General Public License as published by
     351             :    the Free Software Foundation; either version 2, or (at your option)
     352             :    any later version.
     353             : 
     354             :    This program is distributed in the hope that it will be useful,
     355             :    but WITHOUT ANY WARRANTY; without even the implied warranty of
     356             :    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
     357             :    GNU General Public License for more details.
     358             : 
     359             :    You should have received a copy of the GNU General Public License
     360             :    along with this program; if not, write to the Free Software
     361             :    Foundation, Inc., 59 Temple Place - Suite 330,
     362             :    Boston, MA 02111-1307, USA.  */
     363             : 
     364             : /* As a special exception, when this file is copied by Bison into a
     365             :    Bison output file, you may use that output file without restriction.
     366             :    This special exception was added by the Free Software Foundation
     367             :    in version 1.24 of Bison.  */
     368             : 
     369             : /* This is the parser code that is written into each bison parser
     370             :   when the %semantic_parser declaration is not specified in the grammar.
     371             :   It was written by Richard Stallman by simplifying the hairy parser
     372             :   used when %semantic_parser is specified.  */
     373             : 
     374             : #ifndef YYSTACK_USE_ALLOCA
     375             : #ifdef alloca
     376             : #define YYSTACK_USE_ALLOCA
     377             : #else /* alloca not defined */
     378             : #ifdef __GNUC__
     379             : #define YYSTACK_USE_ALLOCA
     380             : #define alloca __builtin_alloca
     381             : #else /* not GNU C.  */
     382             : #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || (defined (__sun) && defined (__i386))
     383             : #define YYSTACK_USE_ALLOCA
     384             : #include <sal/alloca.h>
     385             : #else /* not sparc */
     386             : #if defined(_AIX)
     387             :  #pragma alloca
     388             : #define YYSTACK_USE_ALLOCA
     389             : #endif /* not _AIX */
     390             : #endif /* not sparc */
     391             : #endif /* not GNU C */
     392             : #endif /* alloca not defined */
     393             : #endif /* YYSTACK_USE_ALLOCA not defined */
     394             : 
     395             : #ifdef YYSTACK_USE_ALLOCA
     396             : #define YYSTACK_ALLOC alloca
     397             : #else
     398             : #define YYSTACK_ALLOC malloc
     399             : #endif
     400             : 
     401             : /* Note: there must be only one dollar sign in this file.
     402             :    It is replaced by the list of actions, each action
     403             :    as one case of the switch.  */
     404             : 
     405             : #define YYEMPTY     -2
     406             : #define YYEOF       0
     407             : #define YYACCEPT    goto yyacceptlab
     408             : #define YYABORT     goto yyabortlab
     409             : 
     410             : #define YYTERROR    1
     411             : 
     412             : #ifndef YYPURE
     413             : #define YYLEX       yylex()
     414             : #endif
     415             : 
     416             : #ifdef YYPURE
     417             : #ifdef YYLSP_NEEDED
     418             : #ifdef YYLEX_PARAM
     419             : #define YYLEX       yylex(&yylval, &yylloc, YYLEX_PARAM)
     420             : #else
     421             : #define YYLEX       yylex(&yylval, &yylloc)
     422             : #endif
     423             : #else /* not YYLSP_NEEDED */
     424             : #ifdef YYLEX_PARAM
     425             : #define YYLEX       yylex(&yylval, YYLEX_PARAM)
     426             : #else
     427             : #define YYLEX       yylex(&yylval)
     428             : #endif
     429             : #endif /* not YYLSP_NEEDED */
     430             : #endif
     431             : 
     432             : /* If nonreentrant, generate the variables here */
     433             : 
     434             : #ifndef YYPURE
     435             : 
     436             : int yychar;         /*  the lookahead symbol        */
     437             : YYSTYPE yylval;         /*  the semantic value of the       */
     438             :                 /*  lookahead symbol            */
     439             : 
     440             : #ifdef YYLSP_NEEDED
     441             : YYLTYPE yylloc;         /*  location data for the lookahead */
     442             :                 /*  symbol              */
     443             : #endif
     444             : 
     445             : int yynerrs;            /*  number of parse errors so far       */
     446             : #endif  /* not YYPURE */
     447             : 
     448             : #if YYDEBUG != 0
     449             : int yydebug;            /*  nonzero means print parse trace */
     450             : /* Since this is uninitialized, it does not stop multiple parsers
     451             :    from coexisting.  */
     452             : #endif
     453             : 
     454             : /*  YYINITDEPTH indicates the initial size of the parser's stacks   */
     455             : 
     456             : #ifndef YYINITDEPTH
     457             : #define YYINITDEPTH 200
     458             : #endif
     459             : 
     460             : /*  YYMAXDEPTH is the maximum size the stacks can grow to
     461             :     (effective only if the built-in stack extension method is used).  */
     462             : 
     463             : #if YYMAXDEPTH == 0
     464             : #undef YYMAXDEPTH
     465             : #endif
     466             : 
     467             : #ifndef YYMAXDEPTH
     468             : #define YYMAXDEPTH 10000
     469             : #endif
     470             : 
     471             : /* Define __yy_memcpy.  Note that the size argument
     472             :    should be passed with type unsigned int, because that is what the non-GCC
     473             :    definitions require.  With GCC, __builtin_memcpy takes an arg
     474             :    of type size_t, but it can handle unsigned int.  */
     475             : 
     476             : #if defined(__GNUC__)
     477             : #define __yy_memcpy(TO,FROM,COUNT)  __builtin_memcpy(TO,FROM,COUNT)
     478             : #else
     479             : #ifndef __cplusplus
     480             : 
     481             : /* This is the most reliable way to avoid incompatibilities
     482             :    in available built-in functions on various systems.  */
     483             : static void
     484             : __yy_memcpy (to, from, count)
     485             :      char *to;
     486             :      char *from;
     487             :      unsigned int count;
     488             : {
     489             :   char *f = from;
     490             :   char *t = to;
     491             :   int i = count;
     492             : 
     493             :   while (i-- > 0)
     494             :     *t++ = *f++;
     495             : }
     496             : 
     497             : #else /* __cplusplus */
     498             : 
     499             : /* This is the most reliable way to avoid incompatibilities
     500             :    in available built-in functions on various systems.  */
     501             : static void
     502             : __yy_memcpy (char *to, char *from, unsigned int count)
     503             : {
     504             :   char *t = to;
     505             :   char *f = from;
     506             :   int i = count;
     507             : 
     508             :   while (i-- > 0)
     509             :     *t++ = *f++;
     510             : }
     511             : 
     512             : #endif
     513             : #endif
     514             : 
     515             : /* The user can define YYPARSE_PARAM as the name of an argument to be passed
     516             :    into yyparse.  The argument should have type void *.
     517             :    It should actually point to an object.
     518             :    Grammar actions can access the variable by casting it
     519             :    to the proper pointer type.  */
     520             : 
     521             : #ifdef YYPARSE_PARAM
     522             : #ifdef __cplusplus
     523             : #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
     524             : #define YYPARSE_PARAM_DECL
     525             : #else /* not __cplusplus */
     526             : #define YYPARSE_PARAM_ARG YYPARSE_PARAM
     527             : #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
     528             : #endif /* not __cplusplus */
     529             : #else /* not YYPARSE_PARAM */
     530             : #define YYPARSE_PARAM_ARG
     531             : #define YYPARSE_PARAM_DECL
     532             : #endif /* not YYPARSE_PARAM */
     533             : 
     534             : /* Prevent warning if -Wstrict-prototypes.  */
     535             : #ifdef __GNUC__
     536             : #ifdef YYPARSE_PARAM
     537             : int yyparse (void *);
     538             : #else
     539             : int yyparse (void);
     540             : #endif
     541             : #endif
     542             : 
     543             : int
     544           0 : yyparse(YYPARSE_PARAM_ARG)
     545             :      YYPARSE_PARAM_DECL
     546             : {
     547             :   int yystate;
     548             :   int yyn;
     549             :   short *yyssp;
     550             :   YYSTYPE *yyvsp;
     551             :   int yyerrstatus;  /*  number of tokens to shift before error messages enabled */
     552           0 :   int yychar1 = 0;      /*  lookahead token as an internal (translated) token number */
     553             : 
     554             :   short yyssa[YYINITDEPTH]; /*  the state stack         */
     555             :   YYSTYPE yyvsa[YYINITDEPTH];   /*  the semantic value stack        */
     556             : 
     557           0 :   short *yyss = yyssa;      /*  refer to the stacks thru separate pointers */
     558           0 :   YYSTYPE *yyvs = yyvsa;    /*  to allow yyoverflow to reallocate them elsewhere */
     559             : 
     560             : #ifdef YYLSP_NEEDED
     561             :   YYLTYPE yylsa[YYINITDEPTH];   /*  the location stack          */
     562             :   YYLTYPE *yyls = yylsa;
     563             :   YYLTYPE *yylsp;
     564             : 
     565             : #define YYPOPSTACK   (yyvsp--, yyssp--, yylsp--)
     566             : #endif
     567             : 
     568           0 :   int yystacksize = YYINITDEPTH;
     569           0 :   int yyfree_stacks = 0;
     570             : 
     571             : #ifdef YYPURE
     572             :   int yychar;
     573             :   YYSTYPE yylval;
     574             :   int yynerrs;
     575             : #ifdef YYLSP_NEEDED
     576             :   YYLTYPE yylloc;
     577             : #endif
     578             : #endif
     579             : 
     580             :   YYSTYPE yyval;        /*  the variable used to return     */
     581           0 :   yyval.dval = 0;
     582             :                 /*  semantic values from the action */
     583             :                 /*  routines                */
     584             : 
     585             :   int yylen;
     586             : 
     587             : #if YYDEBUG != 0
     588             :   if (yydebug)
     589             :     fprintf(stderr, "Starting parse\n");
     590             : #endif
     591             : 
     592           0 :   yystate = 0;
     593           0 :   yyerrstatus = 0;
     594           0 :   yynerrs = 0;
     595           0 :   yychar = YYEMPTY;     /* Cause a token to be read.  */
     596             : 
     597             :   /* Initialize stack pointers.
     598             :      Waste one element of value and location stack
     599             :      so that they stay on the same level as the state stack.
     600             :      The wasted elements are never initialized.  */
     601             : 
     602           0 :   yyssp = yyss - 1;
     603           0 :   yyvsp = yyvs;
     604             : #ifdef YYLSP_NEEDED
     605             :   yylsp = yyls;
     606             : #endif
     607             : 
     608             : /* Push a new state, which is found in  yystate  .  */
     609             : /* In all cases, when you get here, the value and location stacks
     610             :    have just been pushed. so pushing a state here evens the stacks.  */
     611             : yynewstate:
     612             : 
     613           0 :   *++yyssp = sal::static_int_cast<short>(yystate);
     614             : 
     615           0 :   if (yyssp >= yyss + yystacksize - 1)
     616             :     {
     617             :       /* Give user a chance to reallocate the stack */
     618             :       /* Use copies of these so that the &'s don't force the real ones into memory. */
     619           0 :       YYSTYPE *yyvs1 = yyvs;
     620           0 :       short *yyss1 = yyss;
     621             : #ifdef YYLSP_NEEDED
     622             :       YYLTYPE *yyls1 = yyls;
     623             : #endif
     624             : 
     625             :       /* Get the current used size of the three stacks, in elements.  */
     626           0 :       int size = yyssp - yyss + 1;
     627             : 
     628             : #ifdef yyoverflow
     629             :       /* Each stack pointer address is followed by the size of
     630             :      the data in use in that stack, in bytes.  */
     631             : #ifdef YYLSP_NEEDED
     632             :       /* This used to be a conditional around just the two extra args,
     633             :      but that might be undefined if yyoverflow is a macro.  */
     634             :       yyoverflow("parser stack overflow",
     635             :          &yyss1, size * sizeof (*yyssp),
     636             :          &yyvs1, size * sizeof (*yyvsp),
     637             :          &yyls1, size * sizeof (*yylsp),
     638             :          &yystacksize);
     639             : #else
     640             :       yyoverflow("parser stack overflow",
     641             :          &yyss1, size * sizeof (*yyssp),
     642             :          &yyvs1, size * sizeof (*yyvsp),
     643             :          &yystacksize);
     644             : #endif
     645             : 
     646             :       yyss = yyss1; yyvs = yyvs1;
     647             : #ifdef YYLSP_NEEDED
     648             :       yyls = yyls1;
     649             : #endif
     650             : #else /* no yyoverflow */
     651             :       /* Extend the stack our own way.  */
     652           0 :       if (yystacksize >= YYMAXDEPTH)
     653             :     {
     654           0 :       yyerror("parser stack overflow");
     655           0 :       if (yyfree_stacks)
     656             :         {
     657           0 :           free (yyss);
     658           0 :           free (yyvs);
     659             : #ifdef YYLSP_NEEDED
     660             :           free (yyls);
     661             : #endif
     662             :         }
     663           0 :       return 2;
     664             :     }
     665           0 :       yystacksize *= 2;
     666           0 :       if (yystacksize > YYMAXDEPTH)
     667           0 :     yystacksize = YYMAXDEPTH;
     668             : #ifndef YYSTACK_USE_ALLOCA
     669             :       yyfree_stacks = 1;
     670             : #endif
     671           0 :       yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
     672           0 :       __yy_memcpy ((char *)yyss, (char *)yyss1,
     673           0 :            size * (unsigned int) sizeof (*yyssp));
     674           0 :       yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
     675           0 :       __yy_memcpy ((char *)yyvs, (char *)yyvs1,
     676           0 :            size * (unsigned int) sizeof (*yyvsp));
     677             : #ifdef YYLSP_NEEDED
     678             :       yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
     679             :       __yy_memcpy ((char *)yyls, (char *)yyls1,
     680             :            size * (unsigned int) sizeof (*yylsp));
     681             : #endif
     682             : #endif /* no yyoverflow */
     683             : 
     684           0 :       yyssp = yyss + size - 1;
     685           0 :       yyvsp = yyvs + size - 1;
     686             : #ifdef YYLSP_NEEDED
     687             :       yylsp = yyls + size - 1;
     688             : #endif
     689             : 
     690             : #if YYDEBUG != 0
     691             :       if (yydebug)
     692             :     fprintf(stderr, "Stack size increased to %d\n", yystacksize);
     693             : #endif
     694             : 
     695           0 :       if (yyssp >= yyss + yystacksize - 1)
     696           0 :     YYABORT;
     697             :     }
     698             : 
     699             : #if YYDEBUG != 0
     700             :   if (yydebug)
     701             :     fprintf(stderr, "Entering state %d\n", yystate);
     702             : #endif
     703             : 
     704           0 :   goto yybackup;
     705             :  yybackup:
     706             : 
     707             : /* Do appropriate processing given the current state.  */
     708             : /* Read a lookahead token if we need one and don't already have one.  */
     709             : /* yyresume: */
     710             : 
     711             :   /* First try to decide what to do without reference to lookahead token.  */
     712             : 
     713           0 :   yyn = yypact[yystate];
     714           0 :   if (yyn == YYFLAG)
     715           0 :     goto yydefault;
     716             : 
     717             :   /* Not known => get a lookahead token if don't already have one.  */
     718             : 
     719             :   /* yychar is either YYEMPTY or YYEOF
     720             :      or a valid token in external form.  */
     721             : 
     722           0 :   if (yychar == YYEMPTY)
     723             :     {
     724             : #if YYDEBUG != 0
     725             :       if (yydebug)
     726             :     fprintf(stderr, "Reading a token: ");
     727             : #endif
     728           0 :       yychar = YYLEX;
     729             :     }
     730             : 
     731             :   /* Convert token to internal form (in yychar1) for indexing tables with */
     732             : 
     733           0 :   if (yychar <= 0)      /* This means end of input. */
     734             :     {
     735           0 :       yychar1 = 0;
     736           0 :       yychar = YYEOF;       /* Don't call YYLEX any more */
     737             : 
     738             : #if YYDEBUG != 0
     739             :       if (yydebug)
     740             :     fprintf(stderr, "Now at end of input.\n");
     741             : #endif
     742             :     }
     743             :   else
     744             :     {
     745           0 :       yychar1 = YYTRANSLATE(yychar);
     746             : 
     747             : #if YYDEBUG != 0
     748             :       if (yydebug)
     749             :     {
     750             :       fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
     751             :       /* Give the individual parser a way to print the precise meaning
     752             :          of a token, for further debugging info.  */
     753             : #ifdef YYPRINT
     754             :       YYPRINT (stderr, yychar, yylval);
     755             : #endif
     756             :       fprintf (stderr, ")\n");
     757             :     }
     758             : #endif
     759             :     }
     760             : 
     761           0 :   yyn += yychar1;
     762           0 :   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
     763             :     goto yydefault;
     764             : 
     765           0 :   yyn = yytable[yyn];
     766             : 
     767             :   /* yyn is what to do for this token type in this state.
     768             :      Negative => reduce, -yyn is rule number.
     769             :      Positive => shift, yyn is new state.
     770             :        New state is final state => don't bother to shift,
     771             :        just return success.
     772             :      0, or most negative number => error.  */
     773             : 
     774           0 :   if (yyn < 0)
     775             :     {
     776           0 :       if (yyn == YYFLAG)
     777           0 :     goto yyerrlab;
     778           0 :       yyn = -yyn;
     779           0 :       goto yyreduce;
     780             :     }
     781           0 :   else if (yyn == 0)
     782           0 :     goto yyerrlab;
     783             : 
     784           0 :   if (yyn == YYFINAL)
     785           0 :     YYACCEPT;
     786             : 
     787             :   /* Shift the lookahead token.  */
     788             : 
     789             : #if YYDEBUG != 0
     790             :   if (yydebug)
     791             :     fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
     792             : #endif
     793             : 
     794             :   /* Discard the token being shifted unless it is eof.  */
     795           0 :   if (yychar != YYEOF)
     796           0 :     yychar = YYEMPTY;
     797             : 
     798           0 :   *++yyvsp = yylval;
     799             : #ifdef YYLSP_NEEDED
     800             :   *++yylsp = yylloc;
     801             : #endif
     802             : 
     803             :   /* count tokens shifted since error; after three, turn off error status.  */
     804           0 :   if (yyerrstatus) yyerrstatus--;
     805             : 
     806           0 :   yystate = yyn;
     807           0 :   goto yynewstate;
     808             : 
     809             : /* Do the default action for the current state.  */
     810             : yydefault:
     811             : 
     812           0 :   yyn = yydefact[yystate];
     813           0 :   if (yyn == 0)
     814           0 :     goto yyerrlab;
     815             : 
     816             : /* Do a reduction.  yyn is the number of a rule to reduce with.  */
     817             : yyreduce:
     818           0 :   yylen = yyr2[yyn];
     819           0 :   if (yylen > 0)
     820           0 :     yyval = yyvsp[1-yylen]; /* implement default value of the action */
     821             : 
     822             : #if YYDEBUG != 0
     823             :   if (yydebug)
     824             :     {
     825             :       int i;
     826             : 
     827             :       fprintf (stderr, "Reducing via rule %d (line %d), ",
     828             :            yyn, yyrline[yyn]);
     829             : 
     830             :       /* Print the symbols being reduced, and their result.  */
     831             :       for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
     832             :     fprintf (stderr, "%s ", yytname[yyrhs[i]]);
     833             :       fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
     834             :     }
     835             : #endif
     836             : 
     837             : 
     838           0 :   switch (yyn) {
     839             : 
     840             : case 1:
     841           0 : { yyval.ptr = new Node(ID_IDENTIFIER); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     842           0 :     break;}
     843             : case 2:
     844           0 : { yyval.ptr = new Node(ID_IDENTIFIER); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     845           0 :     break;}
     846             : case 3:
     847           0 : { yyval.ptr = new Node(ID_IDENTIFIER); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     848           0 :     break;}
     849             : case 4:
     850           0 : { yyval.ptr = new Node(ID_IDENTIFIER); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     851           0 :     break;}
     852             : case 5:
     853           0 : { yyval.ptr = new Node(ID_IDENTIFIER); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     854           0 :     break;}
     855             : case 6:
     856           0 : { yyval.ptr = new Node(ID_IDENTIFIER); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     857           0 :     break;}
     858             : case 7:
     859           0 : { yyval.ptr = new Node(ID_IDENTIFIER); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     860           0 :     break;}
     861             : case 8:
     862           0 : { yyval.ptr = new Node(ID_CHARACTER); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     863           0 :     break;}
     864             : case 9:
     865           0 : { yyval.ptr = new Node(ID_OPERATOR); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     866           0 :     break;}
     867             : case 10:
     868           0 : { yyval.ptr = new Node(ID_OPERATOR); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     869           0 :     break;}
     870             : case 11:
     871           0 : { yyval.ptr = new Node(ID_IDENTIFIER); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     872           0 :     break;}
     873             : case 12:
     874           0 : { yyval.ptr = new Node(ID_DELIMETER); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     875           0 :     break;}
     876             : case 13:
     877           0 : { yyval.ptr = new Node(ID_DELIMETER); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     878           0 :     break;}
     879             : case 14:
     880           0 : { yyval.ptr = new Node(ID_IDENTIFIER); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Identifier : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     881           0 :     break;}
     882             : case 15:
     883           0 : { yyval.ptr = new Node(ID_CHARACTER); allocChar(yyval.ptr->value , '|'); debug("Identifier : '|'\n"); nodelist.push_back(yyval.ptr); ;
     884           0 :     break;}
     885             : case 16:
     886           0 : { yyval.ptr = new Node(ID_NUMBER); allocValue(yyval.ptr->value , yyvsp[0].dval); debug("Number : %s\n",yyvsp[0].dval); nodelist.push_back(yyval.ptr); ;
     887           0 :     break;}
     888             : case 17:
     889           0 : { yyval.ptr = new Node(ID_STRING); allocValue(yyval.ptr->value , yyvsp[0].str); debug("String : %s\n",yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     890           0 :     break;}
     891             : case 18:
     892           0 : { yyval.ptr = new Node(ID_PRIMARYEXPR); yyval.ptr->child = yyvsp[0].ptr; debug("PrimaryExpr\n"); nodelist.push_back(yyval.ptr); ;
     893           0 :     break;}
     894             : case 19:
     895           0 : { yyval.ptr = new Node(ID_PRIMARYEXPR); yyval.ptr->child = yyvsp[-1].ptr; yyval.ptr->next = yyvsp[0].ptr; debug("PrimaryExpr : PrimaryExpr Identifier\n"); nodelist.push_back(yyval.ptr); ;
     896           0 :     break;}
     897             : case 20:
     898           0 : { yyval.ptr = new Node(ID_LEFT); allocChar(yyval.ptr->value , '('); debug("EQLeft \n"); nodelist.push_back(yyval.ptr); ;
     899           0 :     break;}
     900             : case 21:
     901           0 : { yyval.ptr = new Node(ID_LEFT); allocChar(yyval.ptr->value , '['); debug("EQLeft \n"); nodelist.push_back(yyval.ptr); ;
     902           0 :     break;}
     903             : case 22:
     904           0 : {   yyval.ptr = new Node(ID_LEFT); allocChar(yyval.ptr->value , '{'); debug("EQLeft \n"); nodelist.push_back(yyval.ptr); ;
     905           0 :     break;}
     906             : case 23:
     907           0 : {   yyval.ptr = new Node(ID_LEFT); allocChar(yyval.ptr->value , '<'); debug("EQLeft \n"); nodelist.push_back(yyval.ptr); ;
     908           0 :     break;}
     909             : case 24:
     910           0 : { yyval.ptr = new Node(ID_LEFT); allocChar(yyval.ptr->value , '|'); debug("EQLeft \n"); nodelist.push_back(yyval.ptr); ;
     911           0 :     break;}
     912             : case 25:
     913           0 : { yyval.ptr = new Node(ID_LEFT); allocValue(yyval.ptr->value , "||"); debug("EQLeft \n"); nodelist.push_back(yyval.ptr); ;
     914           0 :     break;}
     915             : case 26:
     916           0 : { yyval.ptr = new Node(ID_LEFT); allocValue(yyval.ptr->value , yyvsp[0].str); debug("EQLeft \n"); nodelist.push_back(yyval.ptr); ;
     917           0 :     break;}
     918             : case 27:
     919           0 : { yyval.ptr = new Node(ID_RIGHT); allocChar(yyval.ptr->value , ')'); debug("EQRight \n"); nodelist.push_back(yyval.ptr); ;
     920           0 :     break;}
     921             : case 28:
     922           0 : { yyval.ptr = new Node(ID_RIGHT); allocChar(yyval.ptr->value , ']'); debug("EQRight \n"); nodelist.push_back(yyval.ptr); ;
     923           0 :     break;}
     924             : case 29:
     925           0 : { yyval.ptr = new Node(ID_RIGHT); allocChar(yyval.ptr->value , '}'); debug("EQRight \n"); nodelist.push_back(yyval.ptr); ;
     926           0 :     break;}
     927             : case 30:
     928           0 : { yyval.ptr = new Node(ID_RIGHT); allocChar(yyval.ptr->value , '>'); debug("EQRight \n"); nodelist.push_back(yyval.ptr); ;
     929           0 :     break;}
     930             : case 31:
     931           0 : { yyval.ptr = new Node(ID_RIGHT); allocChar(yyval.ptr->value , '|'); debug("EQRight \n"); nodelist.push_back(yyval.ptr); ;
     932           0 :     break;}
     933             : case 32:
     934           0 : { yyval.ptr = new Node(ID_RIGHT); allocValue(yyval.ptr->value , "||"); debug("EQRight \n"); nodelist.push_back(yyval.ptr); ;
     935           0 :     break;}
     936             : case 33:
     937           0 : { yyval.ptr = new Node(ID_RIGHT); allocValue(yyval.ptr->value , yyvsp[0].str); debug("EQRight \n"); nodelist.push_back(yyval.ptr); ;
     938           0 :     break;}
     939             : case 34:
     940           0 : { yyval.ptr = new Node(ID_FENCE); yyval.ptr->child=yyvsp[-2].ptr; yyvsp[-2].ptr->next=yyvsp[-1].ptr; yyvsp[-1].ptr->next=yyvsp[0].ptr; debug("Fence \n"); nodelist.push_back(yyval.ptr); ;
     941           0 :     break;}
     942             : case 35:
     943           0 : { yyval.ptr = new Node(ID_PARENTH); yyval.ptr->child = yyvsp[-1].ptr; debug("Parenth: '(' ExprList ')' \n"); nodelist.push_back(yyval.ptr); ;
     944           0 :     break;}
     945             : case 36:
     946           0 : { yyval.ptr = new Node(ID_PARENTH); debug("Parenth: '(' ')' \n"); nodelist.push_back(yyval.ptr); ;
     947           0 :     break;}
     948             : case 37:
     949           0 : { yyval.ptr = new Node(ID_BLOCK); yyval.ptr->child = yyvsp[-1].ptr; debug("Block: '{' ExprList '}' \n"); nodelist.push_back(yyval.ptr); ;
     950           0 :     break;}
     951             : case 38:
     952           0 : { yyval.ptr = new Node(ID_BLOCK); debug("Block: '{' '}' \n"); nodelist.push_back(yyval.ptr); ;
     953           0 :     break;}
     954             : case 39:
     955           0 : { yyval.ptr = new Node(ID_BRACKET); yyval.ptr->child = yyvsp[-1].ptr; debug("Bracket \n"); nodelist.push_back(yyval.ptr); ;
     956           0 :     break;}
     957             : case 40:
     958           0 : { yyval.ptr = new Node(ID_BRACKET); debug("Bracket \n"); nodelist.push_back(yyval.ptr); ;
     959           0 :     break;}
     960             : case 41:
     961           0 : { yyval.ptr = new Node(ID_SUBEXPR); yyval.ptr->child = yyvsp[-2].ptr; yyvsp[-2].ptr->next = yyvsp[0].ptr; debug("SubSupExpr : ID_SUBEXPR\n"); nodelist.push_back(yyval.ptr); ;
     962           0 :     break;}
     963             : case 42:
     964           0 : { yyval.ptr = new Node(ID_SUPEXPR); yyval.ptr->child = yyvsp[-2].ptr; yyvsp[-2].ptr->next = yyvsp[0].ptr; debug("SubSupExpr : ID_SUPEXPR\n"); nodelist.push_back(yyval.ptr); ;
     965           0 :     break;}
     966             : case 43:
     967           0 : { yyval.ptr = new Node(ID_SUBSUPEXPR); yyval.ptr->child=yyvsp[-4].ptr; yyvsp[-4].ptr->next=yyvsp[-2].ptr; yyvsp[-2].ptr->next=yyvsp[0].ptr; debug("SubSupExpr : ID_SUBSUPEXPR\n"); nodelist.push_back(yyval.ptr); ;
     968           0 :     break;}
     969             : case 44:
     970           0 : { yyval.ptr = new Node(ID_FRACTIONEXPR); yyval.ptr->child = yyvsp[-1].ptr; yyvsp[-1].ptr->next = yyvsp[0].ptr; debug("FractionExpr : %s\n",yyvsp[-2].str); nodelist.push_back(yyval.ptr); ;
     971           0 :     break;}
     972             : case 45:
     973           0 : { yyval.ptr = new Node(ID_OVER); yyval.ptr->child = yyvsp[-3].ptr; yyvsp[-3].ptr->next = yyvsp[-1].ptr; debug("OverExpr\n"); nodelist.push_back(yyval.ptr); ;
     974           0 :     break;}
     975             : case 46:
     976           0 : { yyval.ptr = new Node(ID_ACCENTEXPR); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Accent : %s\n", yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     977           0 :     break;}
     978             : case 47:
     979           0 : { yyval.ptr = new Node(ID_ACCENTEXPR); yyval.ptr->child=yyvsp[-1].ptr; yyvsp[-1].ptr->next = yyvsp[0].ptr; debug("AccentExpr \n"); nodelist.push_back(yyval.ptr); ;
     980           0 :     break;}
     981             : case 48:
     982           0 : { yyval.ptr = new Node(ID_DECORATIONEXPR); allocValue(yyval.ptr->value , yyvsp[0].str); debug("Decoration : %s\n", yyvsp[0].str); nodelist.push_back(yyval.ptr); ;
     983           0 :     break;}
     984             : case 49:
     985           0 : { yyval.ptr = new Node(ID_DECORATIONEXPR); yyval.ptr->child = yyvsp[-1].ptr; yyvsp[-1].ptr->next = yyvsp[0].ptr; debug("DecorationExpr \n"); nodelist.push_back(yyval.ptr); ;
     986           0 :     break;}
     987             : case 50:
     988           0 : { yyval.ptr = new Node(ID_SQRTEXPR); yyval.ptr->child = yyvsp[0].ptr; debug("RootExpr : %s\n", yyvsp[-1].str); nodelist.push_back(yyval.ptr); ;
     989           0 :     break;}
     990             : case 51:
     991           0 : { yyval.ptr = new Node(ID_ROOTEXPR); yyval.ptr->child = yyvsp[-1].ptr; yyvsp[-1].ptr->next= yyvsp[0].ptr; debug("RootExpr : %s\n", yyvsp[-2].str); nodelist.push_back(yyval.ptr); ;
     992           0 :     break;}
     993             : case 52:
     994           0 : { yyval.ptr = new Node(ID_BEGIN); yyval.ptr->child = yyvsp[0].ptr; nodelist.push_back(yyval.ptr);  debug("BeginExpr\n"); ;
     995           0 :     break;}
     996             : case 53:
     997           0 : { yyval.ptr = new Node(ID_BEGIN); yyval.ptr->child = yyvsp[-1].ptr; yyvsp[-1].ptr->next= yyvsp[0].ptr; nodelist.push_back(yyval.ptr); debug("BeginExpr\n"); ;
     998           0 :     break;}
     999             : case 54:
    1000           0 : { yyval.ptr = new Node(ID_END); yyval.ptr->child = yyvsp[0].ptr; nodelist.push_back(yyval.ptr); debug("EndExpr\n"); ;
    1001           0 :     break;}
    1002             : case 55:
    1003           0 : { yyval.ptr = new Node(ID_MATHML); yyval.ptr->child = yyvsp[0].ptr; nodelist.push_back(yyval.ptr); top = yyval.ptr; debug("MathML\n"); ;
    1004           0 :     break;}
    1005             : case 56:
    1006           0 : { yyval.ptr = new Node(ID_LINES); yyval.ptr->child = yyvsp[0].ptr; nodelist.push_back(yyval.ptr); debug("Lines\n"); ;
    1007           0 :     break;}
    1008             : case 57:
    1009           0 : { yyval.ptr = new Node(ID_LINES); yyval.ptr->child = yyvsp[-2].ptr; yyvsp[-2].ptr->next = yyvsp[0].ptr; nodelist.push_back(yyval.ptr); debug("Lines\n"); ;
    1010           0 :     break;}
    1011             : case 58:
    1012           0 : { yyval.ptr = new Node(ID_LINE); yyval.ptr->child = yyvsp[0].ptr; nodelist.push_back(yyval.ptr); debug("Line\n"); ;
    1013           0 :     break;}
    1014             : case 59:
    1015           0 : { yyval.ptr = new Node(ID_EXPRLIST); yyval.ptr->child = yyvsp[0].ptr; debug("ExprList : Expr\n"); nodelist.push_back(yyval.ptr); ;
    1016           0 :     break;}
    1017             : case 60:
    1018           0 : { yyval.ptr = new Node(ID_EXPRLIST); yyval.ptr->child = yyvsp[-1].ptr; yyvsp[-1].ptr->next = yyvsp[0].ptr;  debug("ExprList : ExprList Expr\n"); nodelist.push_back(yyval.ptr); ;
    1019           0 :     break;}
    1020             : case 61:
    1021           0 : { yyval.ptr = new Node(ID_EXPR); yyval.ptr->child = yyvsp[0].ptr; debug("Expr : Block\n"); nodelist.push_back(yyval.ptr);;
    1022           0 :     break;}
    1023             : case 62:
    1024           0 : { yyval.ptr = new Node(ID_EXPR); yyval.ptr->child = yyvsp[0].ptr; debug("Expr : Parenth\n");  nodelist.push_back(yyval.ptr);;
    1025           0 :     break;}
    1026             : case 63:
    1027           0 : { yyval.ptr = new Node(ID_EXPR); yyval.ptr->child = yyvsp[0].ptr; debug("Expr : Fence\n");  nodelist.push_back(yyval.ptr);;
    1028           0 :     break;}
    1029             : case 64:
    1030           0 : { yyval.ptr = new Node(ID_EXPR); yyval.ptr->child = yyvsp[0].ptr; debug("Expr : SubSupExpr\n"); nodelist.push_back(yyval.ptr);;
    1031           0 :     break;}
    1032             : case 65:
    1033           0 : { yyval.ptr = new Node(ID_EXPR); yyval.ptr->child = yyvsp[0].ptr; debug("Expr : FractionExpr\n"); nodelist.push_back(yyval.ptr);;
    1034           0 :     break;}
    1035             : case 66:
    1036           0 : { yyval.ptr = new Node(ID_EXPR); yyval.ptr->child = yyvsp[0].ptr; debug("Expr : OverExpr\n"); nodelist.push_back(yyval.ptr);;
    1037           0 :     break;}
    1038             : case 67:
    1039           0 : { yyval.ptr = new Node(ID_EXPR); yyval.ptr->child = yyvsp[0].ptr; debug("Expr : DecorationExpr\n"); nodelist.push_back(yyval.ptr);;
    1040           0 :     break;}
    1041             : case 68:
    1042           0 : { yyval.ptr = new Node(ID_EXPR); yyval.ptr->child = yyvsp[0].ptr; debug("Expr : RootExpr\n"); nodelist.push_back(yyval.ptr);;
    1043           0 :     break;}
    1044             : case 69:
    1045           0 : { yyval.ptr = new Node(ID_EXPR); yyval.ptr->child = yyvsp[0].ptr; debug("Expr : AccentExpr\n"); nodelist.push_back(yyval.ptr);;
    1046           0 :     break;}
    1047             : case 70:
    1048           0 : { yyval.ptr = new Node(ID_EXPR); yyval.ptr->child = yyvsp[0].ptr; debug("Expr : PrimaryExpr\n"); nodelist.push_back(yyval.ptr);;
    1049           0 :     break;}
    1050             : case 71:
    1051           0 : { yyval.ptr = new Node(ID_EXPR); yyval.ptr->child = yyvsp[0].ptr; debug("Expr : BeginExpr\n");  nodelist.push_back(yyval.ptr);;
    1052           0 :     break;}
    1053             : case 72:
    1054           0 : { yyval.ptr = new Node(ID_EXPR); yyval.ptr->child = yyvsp[0].ptr; debug("Expr : EndExpr\n");  nodelist.push_back(yyval.ptr);;
    1055           0 :     break;}
    1056             : }
    1057             :    /* the action file gets copied in in place of this dollarsign */
    1058             : 
    1059           0 :   yyvsp -= yylen;
    1060           0 :   yyssp -= yylen;
    1061             : #ifdef YYLSP_NEEDED
    1062             :   yylsp -= yylen;
    1063             : #endif
    1064             : 
    1065             : #if YYDEBUG != 0
    1066             :   if (yydebug)
    1067             :     {
    1068             :       short *ssp1 = yyss - 1;
    1069             :       fprintf (stderr, "state stack now");
    1070             :       while (ssp1 != yyssp)
    1071             :     fprintf (stderr, " %d", *++ssp1);
    1072             :       fprintf (stderr, "\n");
    1073             :     }
    1074             : #endif
    1075             : 
    1076           0 :   *++yyvsp = yyval;
    1077             : 
    1078             : #ifdef YYLSP_NEEDED
    1079             :   yylsp++;
    1080             :   if (yylen == 0)
    1081             :     {
    1082             :       yylsp->first_line = yylloc.first_line;
    1083             :       yylsp->first_column = yylloc.first_column;
    1084             :       yylsp->last_line = (yylsp-1)->last_line;
    1085             :       yylsp->last_column = (yylsp-1)->last_column;
    1086             :       yylsp->text = 0;
    1087             :     }
    1088             :   else
    1089             :     {
    1090             :       yylsp->last_line = (yylsp+yylen-1)->last_line;
    1091             :       yylsp->last_column = (yylsp+yylen-1)->last_column;
    1092             :     }
    1093             : #endif
    1094             : 
    1095             :   /* Now "shift" the result of the reduction.
    1096             :      Determine what state that goes to,
    1097             :      based on the state we popped back to
    1098             :      and the rule number reduced by.  */
    1099             : 
    1100           0 :   yyn = yyr1[yyn];
    1101             : 
    1102           0 :   yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
    1103           0 :   if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
    1104           0 :     yystate = yytable[yystate];
    1105             :   else
    1106           0 :     yystate = yydefgoto[yyn - YYNTBASE];
    1107             : 
    1108           0 :   goto yynewstate;
    1109             : 
    1110             : yyerrlab:   /* here on detecting error */
    1111             : 
    1112           0 :   if (! yyerrstatus)
    1113             :     /* If not already recovering from an error, report this error.  */
    1114             :     {
    1115           0 :       ++yynerrs;
    1116             : 
    1117             : #ifdef YYERROR_VERBOSE
    1118             :       yyn = yypact[yystate];
    1119             : 
    1120             :       if (yyn > YYFLAG && yyn < YYLAST)
    1121             :     {
    1122             :       int size = 0;
    1123             :       char *msg;
    1124             :       int x, count;
    1125             : 
    1126             :       count = 0;
    1127             :       /* Start X at -yyn if nec to avoid negative indexes in yycheck.  */
    1128             :       for (x = ((yyn < 0) ? -yyn : 0);
    1129             :            x < (sizeof(yytname) / sizeof(char *)); x++)
    1130             :         if (yycheck[x + yyn] == x)
    1131             :           size += strlen(yytname[x]) + 15, count++;
    1132             :       msg = (char *) malloc(size + 15);
    1133             :       if (msg != 0)
    1134             :         {
    1135             :           strcpy(msg, "parse error");
    1136             : 
    1137             :           if (count < 5)
    1138             :         {
    1139             :           count = 0;
    1140             :           for (x = ((yyn < 0) ? -yyn : 0);
    1141             :                x < (sizeof(yytname) / sizeof(char *)); x++)
    1142             :             if (yycheck[x + yyn] == x)
    1143             :               {
    1144             :             strcat(msg, count == 0 ? ", expecting `" : " or `");
    1145             :             strcat(msg, yytname[x]);
    1146             :             strcat(msg, "'");
    1147             :             count++;
    1148             :               }
    1149             :         }
    1150             :           yyerror(msg);
    1151             :           free(msg);
    1152             :         }
    1153             :       else
    1154             :         yyerror ("parse error; also virtual memory exceeded");
    1155             :     }
    1156             :       else
    1157             : #endif /* YYERROR_VERBOSE */
    1158           0 :     yyerror("parse error");
    1159             :     }
    1160             : 
    1161           0 :   goto yyerrlab1;
    1162             : yyerrlab1:   /* here on error raised explicitly by an action */
    1163             : 
    1164           0 :   if (yyerrstatus == 3)
    1165             :     {
    1166             :       /* if just tried and failed to reuse lookahead token after an error, discard it.  */
    1167             : 
    1168             :       /* return failure if at end of input */
    1169           0 :       if (yychar == YYEOF)
    1170           0 :     YYABORT;
    1171             : 
    1172             : #if YYDEBUG != 0
    1173             :       if (yydebug)
    1174             :     fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
    1175             : #endif
    1176             : 
    1177           0 :       yychar = YYEMPTY;
    1178             :     }
    1179             : 
    1180             :   /* Else will try to reuse lookahead token
    1181             :      after shifting the error token.  */
    1182             : 
    1183           0 :   yyerrstatus = 3;      /* Each real token shifted decrements this */
    1184             : 
    1185           0 :   goto yyerrhandle;
    1186             : 
    1187             : yyerrdefault:  /* current state does not do anything special for the error token. */
    1188             : 
    1189             : #if 0
    1190             :   /* This is wrong; only states that explicitly want error tokens
    1191             :      should shift them.  */
    1192             :   yyn = yydefact[yystate];  /* If its default is to accept any token, ok.  Otherwise pop it.*/
    1193             :   if (yyn) goto yydefault;
    1194             : #endif
    1195             : 
    1196             : yyerrpop:   /* pop the current state because it cannot handle the error token */
    1197             : 
    1198           0 :   if (yyssp == yyss) YYABORT;
    1199           0 :   yyvsp--;
    1200           0 :   yystate = *--yyssp;
    1201             : #ifdef YYLSP_NEEDED
    1202             :   yylsp--;
    1203             : #endif
    1204             : 
    1205             : #if YYDEBUG != 0
    1206             :   if (yydebug)
    1207             :     {
    1208             :       short *ssp1 = yyss - 1;
    1209             :       fprintf (stderr, "Error: state stack now");
    1210             :       while (ssp1 != yyssp)
    1211             :     fprintf (stderr, " %d", *++ssp1);
    1212             :       fprintf (stderr, "\n");
    1213             :     }
    1214             : #endif
    1215             : 
    1216             : yyerrhandle:
    1217             : 
    1218           0 :   yyn = yypact[yystate];
    1219           0 :   if (yyn == YYFLAG)
    1220           0 :     goto yyerrdefault;
    1221             : 
    1222           0 :   yyn += YYTERROR;
    1223           0 :   if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
    1224             :     goto yyerrdefault;
    1225             : 
    1226           0 :   yyn = yytable[yyn];
    1227           0 :   if (yyn < 0)
    1228             :     {
    1229           0 :       if (yyn == YYFLAG)
    1230           0 :     goto yyerrpop;
    1231           0 :       yyn = -yyn;
    1232           0 :       goto yyreduce;
    1233             :     }
    1234           0 :   else if (yyn == 0)
    1235           0 :     goto yyerrpop;
    1236             : 
    1237           0 :   if (yyn == YYFINAL)
    1238           0 :     YYACCEPT;
    1239             : 
    1240             : #if YYDEBUG != 0
    1241             :   if (yydebug)
    1242             :     fprintf(stderr, "Shifting error token, ");
    1243             : #endif
    1244             : 
    1245           0 :   *++yyvsp = yylval;
    1246             : #ifdef YYLSP_NEEDED
    1247             :   *++yylsp = yylloc;
    1248             : #endif
    1249             : 
    1250           0 :   yystate = yyn;
    1251           0 :   goto yynewstate;
    1252             : 
    1253             :  yyacceptlab:
    1254             :   /* YYACCEPT comes here.  */
    1255           0 :   if (yyfree_stacks)
    1256             :     {
    1257           0 :       free (yyss);
    1258           0 :       free (yyvs);
    1259             : #ifdef YYLSP_NEEDED
    1260             :       free (yyls);
    1261             : #endif
    1262             :     }
    1263           0 :   return 0;
    1264             : 
    1265             :  yyabortlab:
    1266             :   /* YYABORT comes here.  */
    1267           0 :   if (yyfree_stacks)
    1268             :     {
    1269           0 :       free (yyss);
    1270           0 :       free (yyvs);
    1271             : #ifdef YYLSP_NEEDED
    1272             :       free (yyls);
    1273             : #endif
    1274             :     }
    1275           0 :   return 1;
    1276             : }
    1277             : 
    1278             : 
    1279           0 : Node *mainParse(const char *_code)
    1280             : {
    1281           0 :     initFlex( _code );
    1282           0 :     top = 0L;
    1283           0 :     yyparse();
    1284           0 :     if( top )
    1285           0 :         return top;
    1286             :     else
    1287           0 :         return 0L;
    1288             : }
    1289             : 
    1290           0 : void yyerror(const char * /*err*/)
    1291             : {
    1292             : //  printf("REALKING ERR[%s]\n",err);
    1293             :     // if error, delete all nodes.
    1294           0 :     Node *pNode = 0L;
    1295           0 :     int ncount = nodelist.size();
    1296           0 :     for( int i = 0 ; i < ncount ; i++){
    1297           0 :         pNode = nodelist.front();
    1298           0 :         nodelist.pop_front();
    1299           0 :         delete pNode;
    1300             :     }
    1301           0 :     top = 0L;
    1302           0 : }
    1303             : 
    1304             : #ifndef PARSE_DEBUG
    1305           0 : int debug(const char * /*format*/, ...)
    1306             : {
    1307           0 :     return 0;
    1308           0 : }
    1309             : #endif
    1310             : 
    1311             : /* vim:set shiftwidth=4 softtabstop=4 expandtab: */

Generated by: LCOV version 1.10