server/OLD/parser.c

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

Generated on Mon Jul 17 01:36:11 2006 for IILC by  doxygen 1.4.6