Main Page | Class List | File List | Class Members | File Members

server/y.tab.c

00001 /* A Bison parser, made by GNU Bison 2.0.  */
00002 
00003 /* Skeleton parser for Yacc-like parsing with Bison,
00004    Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc.
00005 
00006    This program is free software; you can redistribute it and/or modify
00007    it under the terms of the GNU General Public License as published by
00008    the Free Software Foundation; either version 2, or (at your option)
00009    any later version.
00010 
00011    This program is distributed in the hope that it will be useful,
00012    but WITHOUT ANY WARRANTY; without even the implied warranty of
00013    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014    GNU General Public License for more details.
00015 
00016    You should have received a copy of the GNU General Public License
00017    along with this program; if not, write to the Free Software
00018    Foundation, Inc., 59 Temple Place - Suite 330,
00019    Boston, MA 02111-1307, USA.  */
00020 
00021 /* As a special exception, when this file is copied by Bison into a
00022    Bison output file, you may use that output file without restriction.
00023    This special exception was added by the Free Software Foundation
00024    in version 1.24 of Bison.  */
00025 
00026 /* Written by Richard Stallman by simplifying the original so called
00027    ``semantic'' parser.  */
00028 
00029 /* All symbols defined below should begin with yy or YY, to avoid
00030    infringing on user name space.  This should be done even for local
00031    variables, as they might otherwise be expanded by user macros.
00032    There are some unavoidable exceptions within include files to
00033    define necessary library symbols; they are noted "INFRINGES ON
00034    USER NAME SPACE" below.  */
00035 
00036 /* Identify Bison output.  */
00037 #define YYBISON 1
00038 
00039 /* Skeleton name.  */
00040 #define YYSKELETON_NAME "yacc.c"
00041 
00042 /* Pure parsers.  */
00043 #define YYPURE 0
00044 
00045 /* Using locations.  */
00046 #define YYLSP_NEEDED 0
00047 
00048 
00049 
00050 /* Tokens.  */
00051 #ifndef YYTOKENTYPE
00052 # define YYTOKENTYPE
00053    /* Put the tokens into the symbol table, so that GDB and other debuggers
00054       know about them.  */
00055    enum yytokentype {
00056      OBRACE = 258,
00057      EBRACE = 259,
00058      QUOTE = 260,
00059      SEMICOLON = 261,
00060      DISPLAY = 262,
00061      DEVICE = 263,
00062      MODULE = 264,
00063      LIBRARY = 265,
00064      CONTROL = 266,
00065      LED = 267,
00066      TEMP = 268,
00067      CLASS = 269,
00068      PORT = 270,
00069      REPORT = 271,
00070      USE = 272,
00071      FAN = 273,
00072      AS = 274,
00073      SCREEN = 275,
00074      AT = 276,
00075      SHOW = 277,
00076      SIZE_KW = 278,
00077      COMMA = 279,
00078      VIRTUAL = 280,
00079      STRING = 281,
00080      INTEGER = 282
00081    };
00082 #endif
00083 #define OBRACE 258
00084 #define EBRACE 259
00085 #define QUOTE 260
00086 #define SEMICOLON 261
00087 #define DISPLAY 262
00088 #define DEVICE 263
00089 #define MODULE 264
00090 #define LIBRARY 265
00091 #define CONTROL 266
00092 #define LED 267
00093 #define TEMP 268
00094 #define CLASS 269
00095 #define PORT 270
00096 #define REPORT 271
00097 #define USE 272
00098 #define FAN 273
00099 #define AS 274
00100 #define SCREEN 275
00101 #define AT 276
00102 #define SHOW 277
00103 #define SIZE_KW 278
00104 #define COMMA 279
00105 #define VIRTUAL 280
00106 #define STRING 281
00107 #define INTEGER 282
00108 
00109 
00110 
00111 
00112 /* Copy the first part of user declarations.  */
00113 #line 1 "parser.y"
00114 
00115 #include <stdio.h>
00116 
00117 #include "config.h"
00118 
00119 
00120 
00121 /* Enabling traces.  */
00122 #ifndef YYDEBUG
00123 # define YYDEBUG 1
00124 #endif
00125 
00126 /* Enabling verbose error messages.  */
00127 #ifdef YYERROR_VERBOSE
00128 # undef YYERROR_VERBOSE
00129 # define YYERROR_VERBOSE 1
00130 #else
00131 # define YYERROR_VERBOSE 1
00132 #endif
00133 
00134 #if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
00135 #line 9 "parser.y"
00136 typedef union YYSTYPE {
00137     int number;
00138     char * str;
00139 } YYSTYPE;
00140 /* Line 190 of yacc.c.  */
00141 #line 142 "y.tab.c"
00142 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00143 # define YYSTYPE_IS_DECLARED 1
00144 # define YYSTYPE_IS_TRIVIAL 1
00145 #endif
00146 
00147 
00148 
00149 /* Copy the second part of user declarations.  */
00150 
00151 
00152 /* Line 213 of yacc.c.  */
00153 #line 154 "y.tab.c"
00154 
00155 #if ! defined (yyoverflow) || YYERROR_VERBOSE
00156 
00157 # ifndef YYFREE
00158 #  define YYFREE free
00159 # endif
00160 # ifndef YYMALLOC
00161 #  define YYMALLOC malloc
00162 # endif
00163 
00164 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00165 
00166 # ifdef YYSTACK_USE_ALLOCA
00167 #  if YYSTACK_USE_ALLOCA
00168 #   ifdef __GNUC__
00169 #    define YYSTACK_ALLOC __builtin_alloca
00170 #   else
00171 #    define YYSTACK_ALLOC alloca
00172 #   endif
00173 #  endif
00174 # endif
00175 
00176 # ifdef YYSTACK_ALLOC
00177    /* Pacify GCC's `empty if-body' warning. */
00178 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
00179 # else
00180 #  if defined (__STDC__) || defined (__cplusplus)
00181 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00182 #   define YYSIZE_T size_t
00183 #  endif
00184 #  define YYSTACK_ALLOC YYMALLOC
00185 #  define YYSTACK_FREE YYFREE
00186 # endif
00187 #endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
00188 
00189 
00190 #if (! defined (yyoverflow) \
00191      && (! defined (__cplusplus) \
00192      || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
00193 
00194 /* A type that is properly aligned for any stack member.  */
00195 union yyalloc
00196 {
00197   short int yyss;
00198   YYSTYPE yyvs;
00199   };
00200 
00201 /* The size of the maximum gap between one aligned stack and the next.  */
00202 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00203 
00204 /* The size of an array large to enough to hold all stacks, each with
00205    N elements.  */
00206 # define YYSTACK_BYTES(N) \
00207      ((N) * (sizeof (short int) + sizeof (YYSTYPE))         \
00208       + YYSTACK_GAP_MAXIMUM)
00209 
00210 /* Copy COUNT objects from FROM to TO.  The source and destination do
00211    not overlap.  */
00212 # ifndef YYCOPY
00213 #  if defined (__GNUC__) && 1 < __GNUC__
00214 #   define YYCOPY(To, From, Count) \
00215       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00216 #  else
00217 #   define YYCOPY(To, From, Count)      \
00218       do                    \
00219     {                   \
00220       register YYSIZE_T yyi;        \
00221       for (yyi = 0; yyi < (Count); yyi++)   \
00222         (To)[yyi] = (From)[yyi];        \
00223     }                   \
00224       while (0)
00225 #  endif
00226 # endif
00227 
00228 /* Relocate STACK from its old location to the new one.  The
00229    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00230    elements in the stack, and YYPTR gives the new location of the
00231    stack.  Advance YYPTR to a properly aligned location for the next
00232    stack.  */
00233 # define YYSTACK_RELOCATE(Stack)                    \
00234     do                                  \
00235       {                                 \
00236     YYSIZE_T yynewbytes;                        \
00237     YYCOPY (&yyptr->Stack, Stack, yysize);              \
00238     Stack = &yyptr->Stack;                      \
00239     yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00240     yyptr += yynewbytes / sizeof (*yyptr);              \
00241       }                                 \
00242     while (0)
00243 
00244 #endif
00245 
00246 #if defined (__STDC__) || defined (__cplusplus)
00247    typedef signed char yysigned_char;
00248 #else
00249    typedef short int yysigned_char;
00250 #endif
00251 
00252 /* YYFINAL -- State number of the termination state. */
00253 #define YYFINAL  2
00254 /* YYLAST -- Last index in YYTABLE.  */
00255 #define YYLAST   71
00256 
00257 /* YYNTOKENS -- Number of terminals. */
00258 #define YYNTOKENS  28
00259 /* YYNNTS -- Number of nonterminals. */
00260 #define YYNNTS  15
00261 /* YYNRULES -- Number of rules. */
00262 #define YYNRULES  31
00263 /* YYNRULES -- Number of states. */
00264 #define YYNSTATES  84
00265 
00266 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
00267 #define YYUNDEFTOK  2
00268 #define YYMAXUTOK   282
00269 
00270 #define YYTRANSLATE(YYX)                        \
00271   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00272 
00273 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
00274 static const unsigned char yytranslate[] =
00275 {
00276        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00277        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00278        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00279        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00280        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00281        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00282        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00283        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00284        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00285        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00286        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00287        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00288        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00289        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00290        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00291        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00292        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00293        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00294        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00295        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00296        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00297        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00298        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00299        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00300        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00301        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
00302        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00303       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
00304       25,    26,    27
00305 };
00306 
00307 #if YYDEBUG
00308 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
00309    YYRHS.  */
00310 static const unsigned char yyprhs[] =
00311 {
00312        0,     0,     3,     4,     7,     8,    15,    16,    19,    22,
00313       25,    26,    33,    34,    39,    44,    52,    60,    68,    69,
00314       76,    77,    84,    85,    89,    95,   103,   107,   108,   113,
00315      120,   127
00316 };
00317 
00318 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
00319 static const yysigned_char yyrhs[] =
00320 {
00321       29,     0,    -1,    -1,    29,    30,    -1,    -1,     7,    26,
00322       31,     3,    32,     4,    -1,    -1,    32,    38,    -1,    32,
00323       36,    -1,    32,    33,    -1,    -1,     8,    26,    34,     3,
00324       35,     4,    -1,    -1,    35,    14,    26,     6,    -1,    35,
00325       15,    26,     6,    -1,    35,    17,    12,    27,    19,    26,
00326        6,    -1,    35,    17,    13,    27,    19,    26,     6,    -1,
00327       35,    17,    18,    27,    19,    26,     6,    -1,    -1,     9,
00328       26,    37,     3,    42,     4,    -1,    -1,    20,    26,    39,
00329        3,    40,     4,    -1,    -1,    22,    26,     6,    -1,    22,
00330       26,    23,    41,     6,    -1,    22,    26,    23,    41,    21,
00331       41,     6,    -1,    27,    24,    27,    -1,    -1,    42,    10,
00332       26,     6,    -1,    42,    11,    26,    19,    27,     6,    -1,
00333       42,    16,    26,    19,    27,     6,    -1,    42,    25,    13,
00334       27,    19,    26,     6,    -1
00335 };
00336 
00337 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
00338 static const unsigned char yyrline[] =
00339 {
00340        0,    47,    47,    49,    55,    54,    60,    62,    63,    64,
00341       69,    68,    74,    76,    78,    80,    82,    84,    90,    89,
00342       97,    96,   102,   106,   109,   112,   116,   119,   121,   123,
00343      125,   127
00344 };
00345 #endif
00346 
00347 #if YYDEBUG || YYERROR_VERBOSE
00348 /* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00349    First, the terminals, then, starting at YYNTOKENS, nonterminals. */
00350 static const char *const yytname[] =
00351 {
00352   "$end", "error", "$undefined", "OBRACE", "EBRACE", "QUOTE", "SEMICOLON",
00353   "DISPLAY", "DEVICE", "MODULE", "LIBRARY", "CONTROL", "LED", "TEMP",
00354   "CLASS", "PORT", "REPORT", "USE", "FAN", "AS", "SCREEN", "AT", "SHOW",
00355   "SIZE_KW", "COMMA", "VIRTUAL", "STRING", "INTEGER", "$accept", "file",
00356   "display", "@1", "display_body", "device", "@2", "device_body", "module",
00357   "@3", "screen", "@4", "screen_body", "point", "module_body", 0
00358 };
00359 #endif
00360 
00361 # ifdef YYPRINT
00362 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
00363    token YYLEX-NUM.  */
00364 static const unsigned short int yytoknum[] =
00365 {
00366        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
00367      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
00368      275,   276,   277,   278,   279,   280,   281,   282
00369 };
00370 # endif
00371 
00372 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
00373 static const unsigned char yyr1[] =
00374 {
00375        0,    28,    29,    29,    31,    30,    32,    32,    32,    32,
00376       34,    33,    35,    35,    35,    35,    35,    35,    37,    36,
00377       39,    38,    40,    40,    40,    40,    41,    42,    42,    42,
00378       42,    42
00379 };
00380 
00381 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
00382 static const unsigned char yyr2[] =
00383 {
00384        0,     2,     0,     2,     0,     6,     0,     2,     2,     2,
00385        0,     6,     0,     4,     4,     7,     7,     7,     0,     6,
00386        0,     6,     0,     3,     5,     7,     3,     0,     4,     6,
00387        6,     7
00388 };
00389 
00390 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
00391    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
00392    means the default is an error.  */
00393 static const unsigned char yydefact[] =
00394 {
00395        2,     0,     1,     0,     3,     4,     0,     6,     0,     5,
00396        0,     0,     0,     9,     8,     7,    10,    18,    20,     0,
00397        0,     0,    12,    27,    22,     0,     0,     0,     0,    11,
00398        0,     0,     0,    19,     0,     0,     0,     0,     0,    21,
00399        0,     0,     0,     0,     0,     0,     0,     0,     0,    23,
00400        0,    13,    14,     0,     0,     0,    28,     0,     0,     0,
00401        0,     0,     0,     0,     0,     0,     0,     0,     0,    24,
00402        0,     0,     0,     0,    29,    30,     0,    26,     0,    15,
00403       16,    17,    31,    25
00404 };
00405 
00406 /* YYDEFGOTO[NTERM-NUM]. */
00407 static const yysigned_char yydefgoto[] =
00408 {
00409       -1,     1,     4,     6,     8,    13,    19,    25,    14,    20,
00410       15,    21,    28,    61,    26
00411 };
00412 
00413 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
00414    STATE-NUM.  */
00415 #define YYPACT_NINF -25
00416 static const yysigned_char yypact[] =
00417 {
00418      -25,    15,   -25,   -24,   -25,   -25,     2,   -25,     0,   -25,
00419      -15,    -9,    -7,   -25,   -25,   -25,   -25,   -25,   -25,    23,
00420       24,    25,   -25,   -25,     8,    -1,    -4,     5,    28,   -25,
00421        7,     9,    11,   -25,    10,    12,    13,    21,    -5,   -25,
00422       31,    34,    14,    16,    17,    36,    26,    27,    20,   -25,
00423       22,   -25,   -25,    29,    32,    33,   -25,    30,    35,    37,
00424       39,     4,    38,    40,    41,    44,    47,    42,    43,   -25,
00425       22,    48,    49,    52,   -25,   -25,    53,   -25,    54,   -25,
00426      -25,   -25,   -25,   -25
00427 };
00428 
00429 /* YYPGOTO[NTERM-NUM].  */
00430 static const yysigned_char yypgoto[] =
00431 {
00432      -25,   -25,   -25,   -25,   -25,   -25,   -25,   -25,   -25,   -25,
00433      -25,   -25,   -25,     1,   -25
00434 };
00435 
00436 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00437    positive, shift that token.  If negative, reduce the rule which
00438    number is the opposite.  If zero, do what YYDEFACT says.
00439    If YYTABLE_NINF, syntax error.  */
00440 #define YYTABLE_NINF -1
00441 static const unsigned char yytable[] =
00442 {
00443       33,    49,     5,    29,     9,     7,    34,    35,    10,    11,
00444       69,    16,    36,    30,    31,     2,    32,    17,    50,    18,
00445       12,    37,     3,    42,    43,    70,    22,    23,    24,    44,
00446       27,    38,    39,    40,    48,    41,    45,    51,    46,    47,
00447       52,    53,    56,    54,    55,    57,    58,    59,    62,    60,
00448       74,    63,    64,    75,    79,    80,    67,    65,    81,    82,
00449       83,     0,    66,    68,    71,     0,    72,    73,    76,     0,
00450       77,    78
00451 };
00452 
00453 static const yysigned_char yycheck[] =
00454 {
00455        4,     6,    26,     4,     4,     3,    10,    11,     8,     9,
00456        6,    26,    16,    14,    15,     0,    17,    26,    23,    26,
00457       20,    25,     7,    12,    13,    21,     3,     3,     3,    18,
00458       22,    26,     4,    26,    13,    26,    26,     6,    26,    26,
00459        6,    27,     6,    27,    27,    19,    19,    27,    19,    27,
00460        6,    19,    19,     6,     6,     6,    19,    27,     6,     6,
00461        6,    -1,    27,    24,    26,    -1,    26,    26,    26,    -1,
00462       27,    70
00463 };
00464 
00465 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
00466    symbol of state STATE-NUM.  */
00467 static const unsigned char yystos[] =
00468 {
00469        0,    29,     0,     7,    30,    26,    31,     3,    32,     4,
00470        8,     9,    20,    33,    36,    38,    26,    26,    26,    34,
00471       37,    39,     3,     3,     3,    35,    42,    22,    40,     4,
00472       14,    15,    17,     4,    10,    11,    16,    25,    26,     4,
00473       26,    26,    12,    13,    18,    26,    26,    26,    13,     6,
00474       23,     6,     6,    27,    27,    27,     6,    19,    19,    27,
00475       27,    41,    19,    19,    19,    27,    27,    19,    24,     6,
00476       21,    26,    26,    26,     6,     6,    26,    27,    41,     6,
00477        6,     6,     6,     6
00478 };
00479 
00480 #if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
00481 # define YYSIZE_T __SIZE_TYPE__
00482 #endif
00483 #if ! defined (YYSIZE_T) && defined (size_t)
00484 # define YYSIZE_T size_t
00485 #endif
00486 #if ! defined (YYSIZE_T)
00487 # if defined (__STDC__) || defined (__cplusplus)
00488 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00489 #  define YYSIZE_T size_t
00490 # endif
00491 #endif
00492 #if ! defined (YYSIZE_T)
00493 # define YYSIZE_T unsigned int
00494 #endif
00495 
00496 #define yyerrok     (yyerrstatus = 0)
00497 #define yyclearin   (yychar = YYEMPTY)
00498 #define YYEMPTY     (-2)
00499 #define YYEOF       0
00500 
00501 #define YYACCEPT    goto yyacceptlab
00502 #define YYABORT     goto yyabortlab
00503 #define YYERROR     goto yyerrorlab
00504 
00505 
00506 /* Like YYERROR except do call yyerror.  This remains here temporarily
00507    to ease the transition to the new meaning of YYERROR, for GCC.
00508    Once GCC version 2 has supplanted version 1, this can go.  */
00509 
00510 #define YYFAIL      goto yyerrlab
00511 
00512 #define YYRECOVERING()  (!!yyerrstatus)
00513 
00514 #define YYBACKUP(Token, Value)                  \
00515 do                              \
00516   if (yychar == YYEMPTY && yylen == 1)              \
00517     {                               \
00518       yychar = (Token);                     \
00519       yylval = (Value);                     \
00520       yytoken = YYTRANSLATE (yychar);               \
00521       YYPOPSTACK;                       \
00522       goto yybackup;                        \
00523     }                               \
00524   else                              \
00525     {                               \
00526       yyerror ("syntax error: cannot back up");\
00527       YYERROR;                          \
00528     }                               \
00529 while (0)
00530 
00531 
00532 #define YYTERROR    1
00533 #define YYERRCODE   256
00534 
00535 
00536 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
00537    If N is 0, then set CURRENT to the empty location which ends
00538    the previous symbol: RHS[0] (always defined).  */
00539 
00540 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
00541 #ifndef YYLLOC_DEFAULT
00542 # define YYLLOC_DEFAULT(Current, Rhs, N)                \
00543     do                                  \
00544       if (N)                                \
00545     {                               \
00546       (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;    \
00547       (Current).first_column = YYRHSLOC (Rhs, 1).first_column;  \
00548       (Current).last_line    = YYRHSLOC (Rhs, N).last_line;     \
00549       (Current).last_column  = YYRHSLOC (Rhs, N).last_column;   \
00550     }                               \
00551       else                              \
00552     {                               \
00553       (Current).first_line   = (Current).last_line   =      \
00554         YYRHSLOC (Rhs, 0).last_line;                \
00555       (Current).first_column = (Current).last_column =      \
00556         YYRHSLOC (Rhs, 0).last_column;              \
00557     }                               \
00558     while (0)
00559 #endif
00560 
00561 
00562 /* YY_LOCATION_PRINT -- Print the location on the stream.
00563    This macro was not mandated originally: define only if we know
00564    we won't break user code: when these are the locations we know.  */
00565 
00566 #ifndef YY_LOCATION_PRINT
00567 # if YYLTYPE_IS_TRIVIAL
00568 #  define YY_LOCATION_PRINT(File, Loc)          \
00569      fprintf (File, "%d.%d-%d.%d",          \
00570               (Loc).first_line, (Loc).first_column, \
00571               (Loc).last_line,  (Loc).last_column)
00572 # else
00573 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
00574 # endif
00575 #endif
00576 
00577 
00578 /* YYLEX -- calling `yylex' with the right arguments.  */
00579 
00580 #ifdef YYLEX_PARAM
00581 # define YYLEX yylex (YYLEX_PARAM)
00582 #else
00583 # define YYLEX yylex ()
00584 #endif
00585 
00586 /* Enable debugging if requested.  */
00587 #if YYDEBUG
00588 
00589 # ifndef YYFPRINTF
00590 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
00591 #  define YYFPRINTF fprintf
00592 # endif
00593 
00594 # define YYDPRINTF(Args)            \
00595 do {                        \
00596   if (yydebug)                  \
00597     YYFPRINTF Args;             \
00598 } while (0)
00599 
00600 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)      \
00601 do {                                \
00602   if (yydebug)                          \
00603     {                               \
00604       YYFPRINTF (stderr, "%s ", Title);             \
00605       yysymprint (stderr,                   \
00606                   Type, Value); \
00607       YYFPRINTF (stderr, "\n");                 \
00608     }                               \
00609 } while (0)
00610 
00611 /*------------------------------------------------------------------.
00612 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
00613 | TOP (included).                                                   |
00614 `------------------------------------------------------------------*/
00615 
00616 #if defined (__STDC__) || defined (__cplusplus)
00617 static void
00618 yy_stack_print (short int *bottom, short int *top)
00619 #else
00620 static void
00621 yy_stack_print (bottom, top)
00622     short int *bottom;
00623     short int *top;
00624 #endif
00625 {
00626   YYFPRINTF (stderr, "Stack now");
00627   for (/* Nothing. */; bottom <= top; ++bottom)
00628     YYFPRINTF (stderr, " %d", *bottom);
00629   YYFPRINTF (stderr, "\n");
00630 }
00631 
00632 # define YY_STACK_PRINT(Bottom, Top)                \
00633 do {                                \
00634   if (yydebug)                          \
00635     yy_stack_print ((Bottom), (Top));               \
00636 } while (0)
00637 
00638 
00639 /*------------------------------------------------.
00640 | Report that the YYRULE is going to be reduced.  |
00641 `------------------------------------------------*/
00642 
00643 #if defined (__STDC__) || defined (__cplusplus)
00644 static void
00645 yy_reduce_print (int yyrule)
00646 #else
00647 static void
00648 yy_reduce_print (yyrule)
00649     int yyrule;
00650 #endif
00651 {
00652   int yyi;
00653   unsigned int yylno = yyrline[yyrule];
00654   YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
00655              yyrule - 1, yylno);
00656   /* Print the symbols being reduced, and their result.  */
00657   for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
00658     YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
00659   YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
00660 }
00661 
00662 # define YY_REDUCE_PRINT(Rule)      \
00663 do {                    \
00664   if (yydebug)              \
00665     yy_reduce_print (Rule);     \
00666 } while (0)
00667 
00668 /* Nonzero means print parse trace.  It is left uninitialized so that
00669    multiple parsers can coexist.  */
00670 int yydebug;
00671 #else /* !YYDEBUG */
00672 # define YYDPRINTF(Args)
00673 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
00674 # define YY_STACK_PRINT(Bottom, Top)
00675 # define YY_REDUCE_PRINT(Rule)
00676 #endif /* !YYDEBUG */
00677 
00678 
00679 /* YYINITDEPTH -- initial size of the parser's stacks.  */
00680 #ifndef YYINITDEPTH
00681 # define YYINITDEPTH 200
00682 #endif
00683 
00684 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
00685    if the built-in stack extension method is used).
00686 
00687    Do not make this value too large; the results are undefined if
00688    SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
00689    evaluated with infinite-precision integer arithmetic.  */
00690 
00691 #ifndef YYMAXDEPTH
00692 # define YYMAXDEPTH 10000
00693 #endif
00694 
00695 
00696 
00697 #if YYERROR_VERBOSE
00698 
00699 # ifndef yystrlen
00700 #  if defined (__GLIBC__) && defined (_STRING_H)
00701 #   define yystrlen strlen
00702 #  else
00703 /* Return the length of YYSTR.  */
00704 static YYSIZE_T
00705 #   if defined (__STDC__) || defined (__cplusplus)
00706 yystrlen (const char *yystr)
00707 #   else
00708 yystrlen (yystr)
00709      const char *yystr;
00710 #   endif
00711 {
00712   register const char *yys = yystr;
00713 
00714   while (*yys++ != '\0')
00715     continue;
00716 
00717   return yys - yystr - 1;
00718 }
00719 #  endif
00720 # endif
00721 
00722 # ifndef yystpcpy
00723 #  if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
00724 #   define yystpcpy stpcpy
00725 #  else
00726 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
00727    YYDEST.  */
00728 static char *
00729 #   if defined (__STDC__) || defined (__cplusplus)
00730 yystpcpy (char *yydest, const char *yysrc)
00731 #   else
00732 yystpcpy (yydest, yysrc)
00733      char *yydest;
00734      const char *yysrc;
00735 #   endif
00736 {
00737   register char *yyd = yydest;
00738   register const char *yys = yysrc;
00739 
00740   while ((*yyd++ = *yys++) != '\0')
00741     continue;
00742 
00743   return yyd - 1;
00744 }
00745 #  endif
00746 # endif
00747 
00748 #endif /* !YYERROR_VERBOSE */
00749 
00750 
00751 
00752 #if YYDEBUG
00753 /*--------------------------------.
00754 | Print this symbol on YYOUTPUT.  |
00755 `--------------------------------*/
00756 
00757 #if defined (__STDC__) || defined (__cplusplus)
00758 static void
00759 yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
00760 #else
00761 static void
00762 yysymprint (yyoutput, yytype, yyvaluep)
00763     FILE *yyoutput;
00764     int yytype;
00765     YYSTYPE *yyvaluep;
00766 #endif
00767 {
00768   /* Pacify ``unused variable'' warnings.  */
00769   (void) yyvaluep;
00770 
00771   if (yytype < YYNTOKENS)
00772     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
00773   else
00774     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
00775 
00776 
00777 # ifdef YYPRINT
00778   if (yytype < YYNTOKENS)
00779     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
00780 # endif
00781   switch (yytype)
00782     {
00783       default:
00784         break;
00785     }
00786   YYFPRINTF (yyoutput, ")");
00787 }
00788 
00789 #endif /* ! YYDEBUG */
00790 /*-----------------------------------------------.
00791 | Release the memory associated to this symbol.  |
00792 `-----------------------------------------------*/
00793 
00794 #if defined (__STDC__) || defined (__cplusplus)
00795 static void
00796 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
00797 #else
00798 static void
00799 yydestruct (yymsg, yytype, yyvaluep)
00800     const char *yymsg;
00801     int yytype;
00802     YYSTYPE *yyvaluep;
00803 #endif
00804 {
00805   /* Pacify ``unused variable'' warnings.  */
00806   (void) yyvaluep;
00807 
00808   if (!yymsg)
00809     yymsg = "Deleting";
00810   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
00811 
00812   switch (yytype)
00813     {
00814 
00815       default:
00816         break;
00817     }
00818 }
00819 
00820 
00821 /* Prevent warnings from -Wmissing-prototypes.  */
00822 
00823 #ifdef YYPARSE_PARAM
00824 # if defined (__STDC__) || defined (__cplusplus)
00825 int yyparse (void *YYPARSE_PARAM);
00826 # else
00827 int yyparse ();
00828 # endif
00829 #else /* ! YYPARSE_PARAM */
00830 #if defined (__STDC__) || defined (__cplusplus)
00831 int yyparse (void);
00832 #else
00833 int yyparse ();
00834 #endif
00835 #endif /* ! YYPARSE_PARAM */
00836 
00837 
00838 
00839 /* The look-ahead symbol.  */
00840 int yychar;
00841 
00842 /* The semantic value of the look-ahead symbol.  */
00843 YYSTYPE yylval;
00844 
00845 /* Number of syntax errors so far.  */
00846 int yynerrs;
00847 
00848 
00849 
00850 /*----------.
00851 | yyparse.  |
00852 `----------*/
00853 
00854 #ifdef YYPARSE_PARAM
00855 # if defined (__STDC__) || defined (__cplusplus)
00856 int yyparse (void *YYPARSE_PARAM)
00857 # else
00858 int yyparse (YYPARSE_PARAM)
00859   void *YYPARSE_PARAM;
00860 # endif
00861 #else /* ! YYPARSE_PARAM */
00862 #if defined (__STDC__) || defined (__cplusplus)
00863 int
00864 yyparse (void)
00865 #else
00866 int
00867 yyparse ()
00868 
00869 #endif
00870 #endif
00871 {
00872   
00873   register int yystate;
00874   register int yyn;
00875   int yyresult;
00876   /* Number of tokens to shift before error messages enabled.  */
00877   int yyerrstatus;
00878   /* Look-ahead token as an internal (translated) token number.  */
00879   int yytoken = 0;
00880 
00881   /* Three stacks and their tools:
00882      `yyss': related to states,
00883      `yyvs': related to semantic values,
00884      `yyls': related to locations.
00885 
00886      Refer to the stacks thru separate pointers, to allow yyoverflow
00887      to reallocate them elsewhere.  */
00888 
00889   /* The state stack.  */
00890   short int yyssa[YYINITDEPTH];
00891   short int *yyss = yyssa;
00892   register short int *yyssp;
00893 
00894   /* The semantic value stack.  */
00895   YYSTYPE yyvsa[YYINITDEPTH];
00896   YYSTYPE *yyvs = yyvsa;
00897   register YYSTYPE *yyvsp;
00898 
00899 
00900 
00901 #define YYPOPSTACK   (yyvsp--, yyssp--)
00902 
00903   YYSIZE_T yystacksize = YYINITDEPTH;
00904 
00905   /* The variables used to return semantic value and location from the
00906      action routines.  */
00907   YYSTYPE yyval;
00908 
00909 
00910   /* When reducing, the number of symbols on the RHS of the reduced
00911      rule.  */
00912   int yylen;
00913 
00914   YYDPRINTF ((stderr, "Starting parse\n"));
00915 
00916   yystate = 0;
00917   yyerrstatus = 0;
00918   yynerrs = 0;
00919   yychar = YYEMPTY;     /* Cause a token to be read.  */
00920 
00921   /* Initialize stack pointers.
00922      Waste one element of value and location stack
00923      so that they stay on the same level as the state stack.
00924      The wasted elements are never initialized.  */
00925 
00926   yyssp = yyss;
00927   yyvsp = yyvs;
00928 
00929 
00930   yyvsp[0] = yylval;
00931 
00932   goto yysetstate;
00933 
00934 /*------------------------------------------------------------.
00935 | yynewstate -- Push a new state, which is found in yystate.  |
00936 `------------------------------------------------------------*/
00937  yynewstate:
00938   /* In all cases, when you get here, the value and location stacks
00939      have just been pushed. so pushing a state here evens the stacks.
00940      */
00941   yyssp++;
00942 
00943  yysetstate:
00944   *yyssp = yystate;
00945 
00946   if (yyss + yystacksize - 1 <= yyssp)
00947     {
00948       /* Get the current used size of the three stacks, in elements.  */
00949       YYSIZE_T yysize = yyssp - yyss + 1;
00950 
00951 #ifdef yyoverflow
00952       {
00953     /* Give user a chance to reallocate the stack. Use copies of
00954        these so that the &'s don't force the real ones into
00955        memory.  */
00956     YYSTYPE *yyvs1 = yyvs;
00957     short int *yyss1 = yyss;
00958 
00959 
00960     /* Each stack pointer address is followed by the size of the
00961        data in use in that stack, in bytes.  This used to be a
00962        conditional around just the two extra args, but that might
00963        be undefined if yyoverflow is a macro.  */
00964     yyoverflow ("parser stack overflow",
00965             &yyss1, yysize * sizeof (*yyssp),
00966             &yyvs1, yysize * sizeof (*yyvsp),
00967 
00968             &yystacksize);
00969 
00970     yyss = yyss1;
00971     yyvs = yyvs1;
00972       }
00973 #else /* no yyoverflow */
00974 # ifndef YYSTACK_RELOCATE
00975       goto yyoverflowlab;
00976 # else
00977       /* Extend the stack our own way.  */
00978       if (YYMAXDEPTH <= yystacksize)
00979     goto yyoverflowlab;
00980       yystacksize *= 2;
00981       if (YYMAXDEPTH < yystacksize)
00982     yystacksize = YYMAXDEPTH;
00983 
00984       {
00985     short int *yyss1 = yyss;
00986     union yyalloc *yyptr =
00987       (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
00988     if (! yyptr)
00989       goto yyoverflowlab;
00990     YYSTACK_RELOCATE (yyss);
00991     YYSTACK_RELOCATE (yyvs);
00992 
00993 #  undef YYSTACK_RELOCATE
00994     if (yyss1 != yyssa)
00995       YYSTACK_FREE (yyss1);
00996       }
00997 # endif
00998 #endif /* no yyoverflow */
00999 
01000       yyssp = yyss + yysize - 1;
01001       yyvsp = yyvs + yysize - 1;
01002 
01003 
01004       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01005           (unsigned long int) yystacksize));
01006 
01007       if (yyss + yystacksize - 1 <= yyssp)
01008     YYABORT;
01009     }
01010 
01011   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01012 
01013   goto yybackup;
01014 
01015 /*-----------.
01016 | yybackup.  |
01017 `-----------*/
01018 yybackup:
01019 
01020 /* Do appropriate processing given the current state.  */
01021 /* Read a look-ahead token if we need one and don't already have one.  */
01022 /* yyresume: */
01023 
01024   /* First try to decide what to do without reference to look-ahead token.  */
01025 
01026   yyn = yypact[yystate];
01027   if (yyn == YYPACT_NINF)
01028     goto yydefault;
01029 
01030   /* Not known => get a look-ahead token if don't already have one.  */
01031 
01032   /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
01033   if (yychar == YYEMPTY)
01034     {
01035       YYDPRINTF ((stderr, "Reading a token: "));
01036       yychar = YYLEX;
01037     }
01038 
01039   if (yychar <= YYEOF)
01040     {
01041       yychar = yytoken = YYEOF;
01042       YYDPRINTF ((stderr, "Now at end of input.\n"));
01043     }
01044   else
01045     {
01046       yytoken = YYTRANSLATE (yychar);
01047       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
01048     }
01049 
01050   /* If the proper action on seeing token YYTOKEN is to reduce or to
01051      detect an error, take that action.  */
01052   yyn += yytoken;
01053   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01054     goto yydefault;
01055   yyn = yytable[yyn];
01056   if (yyn <= 0)
01057     {
01058       if (yyn == 0 || yyn == YYTABLE_NINF)
01059     goto yyerrlab;
01060       yyn = -yyn;
01061       goto yyreduce;
01062     }
01063 
01064   if (yyn == YYFINAL)
01065     YYACCEPT;
01066 
01067   /* Shift the look-ahead token.  */
01068   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
01069 
01070   /* Discard the token being shifted unless it is eof.  */
01071   if (yychar != YYEOF)
01072     yychar = YYEMPTY;
01073 
01074   *++yyvsp = yylval;
01075 
01076 
01077   /* Count tokens shifted since error; after three, turn off error
01078      status.  */
01079   if (yyerrstatus)
01080     yyerrstatus--;
01081 
01082   yystate = yyn;
01083   goto yynewstate;
01084 
01085 
01086 /*-----------------------------------------------------------.
01087 | yydefault -- do the default action for the current state.  |
01088 `-----------------------------------------------------------*/
01089 yydefault:
01090   yyn = yydefact[yystate];
01091   if (yyn == 0)
01092     goto yyerrlab;
01093   goto yyreduce;
01094 
01095 
01096 /*-----------------------------.
01097 | yyreduce -- Do a reduction.  |
01098 `-----------------------------*/
01099 yyreduce:
01100   /* yyn is the number of a rule to reduce with.  */
01101   yylen = yyr2[yyn];
01102 
01103   /* If YYLEN is nonzero, implement the default value of the action:
01104      `$$ = $1'.
01105 
01106      Otherwise, the following line sets YYVAL to garbage.
01107      This behavior is undocumented and Bison
01108      users should not rely upon it.  Assigning to YYVAL
01109      unconditionally makes the parser a bit smaller, and it avoids a
01110      GCC warning that YYVAL may be used uninitialized.  */
01111   yyval = yyvsp[1-yylen];
01112 
01113 
01114   YY_REDUCE_PRINT (yyn);
01115   switch (yyn)
01116     {
01117         case 4:
01118 #line 55 "parser.y"
01119     { parserBeginDisplay((yyvsp[0].str)); }
01120     break;
01121 
01122   case 5:
01123 #line 57 "parser.y"
01124     { parserEndDisplay(); }
01125     break;
01126 
01127   case 10:
01128 #line 69 "parser.y"
01129     { parserDeviceBegin((yyvsp[0].str)); }
01130     break;
01131 
01132   case 11:
01133 #line 71 "parser.y"
01134     { parserDeviceEnd(); }
01135     break;
01136 
01137   case 13:
01138 #line 77 "parser.y"
01139     { parserSetDeviceClass((yyvsp[-1].str)); }
01140     break;
01141 
01142   case 14:
01143 #line 79 "parser.y"
01144     { parserSetDevicePort((yyvsp[-1].str)); }
01145     break;
01146 
01147   case 15:
01148 #line 81 "parser.y"
01149     { parserDeviceUseLED((yyvsp[-3].number), (yyvsp[-1].str)); }
01150     break;
01151 
01152   case 16:
01153 #line 83 "parser.y"
01154     { parserDeviceUseTemp((yyvsp[-3].number), (yyvsp[-1].str)); }
01155     break;
01156 
01157   case 17:
01158 #line 85 "parser.y"
01159     { parserDeviceUseFan((yyvsp[-3].number), (yyvsp[-1].str)); }
01160     break;
01161 
01162   case 18:
01163 #line 90 "parser.y"
01164     { parserBeginModule((yyvsp[0].str)); }
01165     break;
01166 
01167   case 19:
01168 #line 92 "parser.y"
01169     { parserEndModule(); }
01170     break;
01171 
01172   case 20:
01173 #line 97 "parser.y"
01174     { parserBeginScreen((yyvsp[0].str)); }
01175     break;
01176 
01177   case 21:
01178 #line 99 "parser.y"
01179     { parserEndScreen(); }
01180     break;
01181 
01182   case 28:
01183 #line 122 "parser.y"
01184     { parserSetModuleLibrary((yyvsp[-1].str)); }
01185     break;
01186 
01187   case 29:
01188 #line 124 "parser.y"
01189     { parserModuleControlObject((yyvsp[-3].str), (yyvsp[-1].number)); }
01190     break;
01191 
01192   case 30:
01193 #line 126 "parser.y"
01194     { parserModuleReportObject((yyvsp[-3].str), (yyvsp[-1].number)); }
01195     break;
01196 
01197   case 31:
01198 #line 128 "parser.y"
01199     { parserModuleVirtualObject((yyvsp[-3].number), (yyvsp[-1].str)); }
01200     break;
01201 
01202 
01203     }
01204 
01205 /* Line 1037 of yacc.c.  */
01206 #line 1207 "y.tab.c"
01207 
01208   yyvsp -= yylen;
01209   yyssp -= yylen;
01210 
01211 
01212   YY_STACK_PRINT (yyss, yyssp);
01213 
01214   *++yyvsp = yyval;
01215 
01216 
01217   /* Now `shift' the result of the reduction.  Determine what state
01218      that goes to, based on the state we popped back to and the rule
01219      number reduced by.  */
01220 
01221   yyn = yyr1[yyn];
01222 
01223   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
01224   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
01225     yystate = yytable[yystate];
01226   else
01227     yystate = yydefgoto[yyn - YYNTOKENS];
01228 
01229   goto yynewstate;
01230 
01231 
01232 /*------------------------------------.
01233 | yyerrlab -- here on detecting error |
01234 `------------------------------------*/
01235 yyerrlab:
01236   /* If not already recovering from an error, report this error.  */
01237   if (!yyerrstatus)
01238     {
01239       ++yynerrs;
01240 #if YYERROR_VERBOSE
01241       yyn = yypact[yystate];
01242 
01243       if (YYPACT_NINF < yyn && yyn < YYLAST)
01244     {
01245       YYSIZE_T yysize = 0;
01246       int yytype = YYTRANSLATE (yychar);
01247       const char* yyprefix;
01248       char *yymsg;
01249       int yyx;
01250 
01251       /* Start YYX at -YYN if negative to avoid negative indexes in
01252          YYCHECK.  */
01253       int yyxbegin = yyn < 0 ? -yyn : 0;
01254 
01255       /* Stay within bounds of both yycheck and yytname.  */
01256       int yychecklim = YYLAST - yyn;
01257       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
01258       int yycount = 0;
01259 
01260       yyprefix = ", expecting ";
01261       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01262         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01263           {
01264         yysize += yystrlen (yyprefix) + yystrlen (yytname [yyx]);
01265         yycount += 1;
01266         if (yycount == 5)
01267           {
01268             yysize = 0;
01269             break;
01270           }
01271           }
01272       yysize += (sizeof ("syntax error, unexpected ")
01273              + yystrlen (yytname[yytype]));
01274       yymsg = (char *) YYSTACK_ALLOC (yysize);
01275       if (yymsg != 0)
01276         {
01277           char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
01278           yyp = yystpcpy (yyp, yytname[yytype]);
01279 
01280           if (yycount < 5)
01281         {
01282           yyprefix = ", expecting ";
01283           for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01284             if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01285               {
01286             yyp = yystpcpy (yyp, yyprefix);
01287             yyp = yystpcpy (yyp, yytname[yyx]);
01288             yyprefix = " or ";
01289               }
01290         }
01291           yyerror (yymsg);
01292           YYSTACK_FREE (yymsg);
01293         }
01294       else
01295         yyerror ("syntax error; also virtual memory exhausted");
01296     }
01297       else
01298 #endif /* YYERROR_VERBOSE */
01299     yyerror ("syntax error");
01300     }
01301 
01302 
01303 
01304   if (yyerrstatus == 3)
01305     {
01306       /* If just tried and failed to reuse look-ahead token after an
01307      error, discard it.  */
01308 
01309       if (yychar <= YYEOF)
01310         {
01311           /* If at end of input, pop the error token,
01312          then the rest of the stack, then return failure.  */
01313       if (yychar == YYEOF)
01314          for (;;)
01315            {
01316 
01317          YYPOPSTACK;
01318          if (yyssp == yyss)
01319            YYABORT;
01320          yydestruct ("Error: popping",
01321                              yystos[*yyssp], yyvsp);
01322            }
01323         }
01324       else
01325     {
01326       yydestruct ("Error: discarding", yytoken, &yylval);
01327       yychar = YYEMPTY;
01328     }
01329     }
01330 
01331   /* Else will try to reuse look-ahead token after shifting the error
01332      token.  */
01333   goto yyerrlab1;
01334 
01335 
01336 /*---------------------------------------------------.
01337 | yyerrorlab -- error raised explicitly by YYERROR.  |
01338 `---------------------------------------------------*/
01339 yyerrorlab:
01340 
01341 #ifdef __GNUC__
01342   /* Pacify GCC when the user code never invokes YYERROR and the label
01343      yyerrorlab therefore never appears in user code.  */
01344   if (0)
01345      goto yyerrorlab;
01346 #endif
01347 
01348 yyvsp -= yylen;
01349   yyssp -= yylen;
01350   yystate = *yyssp;
01351   goto yyerrlab1;
01352 
01353 
01354 /*-------------------------------------------------------------.
01355 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
01356 `-------------------------------------------------------------*/
01357 yyerrlab1:
01358   yyerrstatus = 3;  /* Each real token shifted decrements this.  */
01359 
01360   for (;;)
01361     {
01362       yyn = yypact[yystate];
01363       if (yyn != YYPACT_NINF)
01364     {
01365       yyn += YYTERROR;
01366       if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
01367         {
01368           yyn = yytable[yyn];
01369           if (0 < yyn)
01370         break;
01371         }
01372     }
01373 
01374       /* Pop the current state because it cannot handle the error token.  */
01375       if (yyssp == yyss)
01376     YYABORT;
01377 
01378 
01379       yydestruct ("Error: popping", yystos[yystate], yyvsp);
01380       YYPOPSTACK;
01381       yystate = *yyssp;
01382       YY_STACK_PRINT (yyss, yyssp);
01383     }
01384 
01385   if (yyn == YYFINAL)
01386     YYACCEPT;
01387 
01388   *++yyvsp = yylval;
01389 
01390 
01391   /* Shift the error token. */
01392   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
01393 
01394   yystate = yyn;
01395   goto yynewstate;
01396 
01397 
01398 /*-------------------------------------.
01399 | yyacceptlab -- YYACCEPT comes here.  |
01400 `-------------------------------------*/
01401 yyacceptlab:
01402   yyresult = 0;
01403   goto yyreturn;
01404 
01405 /*-----------------------------------.
01406 | yyabortlab -- YYABORT comes here.  |
01407 `-----------------------------------*/
01408 yyabortlab:
01409   yydestruct ("Error: discarding lookahead",
01410               yytoken, &yylval);
01411   yychar = YYEMPTY;
01412   yyresult = 1;
01413   goto yyreturn;
01414 
01415 #ifndef yyoverflow
01416 /*----------------------------------------------.
01417 | yyoverflowlab -- parser overflow comes here.  |
01418 `----------------------------------------------*/
01419 yyoverflowlab:
01420   yyerror ("parser stack overflow");
01421   yyresult = 2;
01422   /* Fall through.  */
01423 #endif
01424 
01425 yyreturn:
01426 #ifndef yyoverflow
01427   if (yyss != yyssa)
01428     YYSTACK_FREE (yyss);
01429 #endif
01430   return yyresult;
01431 }
01432 
01433 
01434 #line 131 "parser.y"
01435 
01436 
01437 int yyerror(char * s)
01438 {
01439     fprintf (stdout, "%s\n", s);
01440     exit(1);
01441 }
01442 
01443 void startParse()
01444 {
01445     yyparse();
01446 }
01447 
01448 

Generated on Mon Jun 19 10:15:13 2006 for IILC by  doxygen 1.4.2