00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025
00026
00027
00028
00029
00030
00031
00032
00033
00034
00035
00036
00037 #define YYBISON 1
00038
00039
00040 #define YYSKELETON_NAME "yacc.c"
00041
00042
00043 #define YYPURE 0
00044
00045
00046 #define YYLSP_NEEDED 0
00047
00048
00049
00050
00051 #ifndef YYTOKENTYPE
00052 # define YYTOKENTYPE
00053
00054
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
00113 #line 1 "parser.y"
00114
00115 #include <stdio.h>
00116
00117 #include "config.h"
00118
00119
00120
00121
00122 #ifndef YYDEBUG
00123 # define YYDEBUG 1
00124 #endif
00125
00126
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
00141 #line 142 "y.tab.c"
00142 # define yystype YYSTYPE
00143 # define YYSTYPE_IS_DECLARED 1
00144 # define YYSTYPE_IS_TRIVIAL 1
00145 #endif
00146
00147
00148
00149
00150
00151
00152
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
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
00178 # define YYSTACK_FREE(Ptr) do { ; } while (0)
00179 # else
00180 # if defined (__STDC__) || defined (__cplusplus)
00181 # include <stdlib.h>
00182 # define YYSIZE_T size_t
00183 # endif
00184 # define YYSTACK_ALLOC YYMALLOC
00185 # define YYSTACK_FREE YYFREE
00186 # endif
00187 #endif
00188
00189
00190 #if (! defined (yyoverflow) \
00191 && (! defined (__cplusplus) \
00192 || (defined (YYSTYPE_IS_TRIVIAL) && YYSTYPE_IS_TRIVIAL)))
00193
00194
00195 union yyalloc
00196 {
00197 short int yyss;
00198 YYSTYPE yyvs;
00199 };
00200
00201
00202 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00203
00204
00205
00206 # define YYSTACK_BYTES(N) \
00207 ((N) * (sizeof (short int) + sizeof (YYSTYPE)) \
00208 + YYSTACK_GAP_MAXIMUM)
00209
00210
00211
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
00229
00230
00231
00232
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
00253 #define YYFINAL 2
00254
00255 #define YYLAST 71
00256
00257
00258 #define YYNTOKENS 28
00259
00260 #define YYNNTS 15
00261
00262 #define YYNRULES 31
00263
00264 #define YYNSTATES 84
00265
00266
00267 #define YYUNDEFTOK 2
00268 #define YYMAXUTOK 282
00269
00270 #define YYTRANSLATE(YYX) \
00271 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00272
00273
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
00309
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
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
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
00349
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
00363
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
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
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
00391
00392
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
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
00414
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
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
00437
00438
00439
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
00466
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>
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
00507
00508
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
00537
00538
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
00563
00564
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
00579
00580 #ifdef YYLEX_PARAM
00581 # define YYLEX yylex (YYLEX_PARAM)
00582 #else
00583 # define YYLEX yylex ()
00584 #endif
00585
00586
00587 #if YYDEBUG
00588
00589 # ifndef YYFPRINTF
00590 # include <stdio.h>
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
00613
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 (; 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
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
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
00669
00670 int yydebug;
00671 #else
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
00677
00678
00679
00680 #ifndef YYINITDEPTH
00681 # define YYINITDEPTH 200
00682 #endif
00683
00684
00685
00686
00687
00688
00689
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
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
00727
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
00749
00750
00751
00752 #if YYDEBUG
00753
00754
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
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
00790
00791
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
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
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
00830 #if defined (__STDC__) || defined (__cplusplus)
00831 int yyparse (void);
00832 #else
00833 int yyparse ();
00834 #endif
00835 #endif
00836
00837
00838
00839
00840 int yychar;
00841
00842
00843 YYSTYPE yylval;
00844
00845
00846 int yynerrs;
00847
00848
00849
00850
00851
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
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
00877 int yyerrstatus;
00878
00879 int yytoken = 0;
00880
00881
00882
00883
00884
00885
00886
00887
00888
00889
00890 short int yyssa[YYINITDEPTH];
00891 short int *yyss = yyssa;
00892 register short int *yyssp;
00893
00894
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
00906
00907 YYSTYPE yyval;
00908
00909
00910
00911
00912 int yylen;
00913
00914 YYDPRINTF ((stderr, "Starting parse\n"));
00915
00916 yystate = 0;
00917 yyerrstatus = 0;
00918 yynerrs = 0;
00919 yychar = YYEMPTY;
00920
00921
00922
00923
00924
00925
00926 yyssp = yyss;
00927 yyvsp = yyvs;
00928
00929
00930 yyvsp[0] = yylval;
00931
00932 goto yysetstate;
00933
00934
00935
00936
00937 yynewstate:
00938
00939
00940
00941 yyssp++;
00942
00943 yysetstate:
00944 *yyssp = yystate;
00945
00946 if (yyss + yystacksize - 1 <= yyssp)
00947 {
00948
00949 YYSIZE_T yysize = yyssp - yyss + 1;
00950
00951 #ifdef yyoverflow
00952 {
00953
00954
00955
00956 YYSTYPE *yyvs1 = yyvs;
00957 short int *yyss1 = yyss;
00958
00959
00960
00961
00962
00963
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
00974 # ifndef YYSTACK_RELOCATE
00975 goto yyoverflowlab;
00976 # else
00977
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
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
01017
01018 yybackup:
01019
01020
01021
01022
01023
01024
01025
01026 yyn = yypact[yystate];
01027 if (yyn == YYPACT_NINF)
01028 goto yydefault;
01029
01030
01031
01032
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
01051
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
01068 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
01069
01070
01071 if (yychar != YYEOF)
01072 yychar = YYEMPTY;
01073
01074 *++yyvsp = yylval;
01075
01076
01077
01078
01079 if (yyerrstatus)
01080 yyerrstatus--;
01081
01082 yystate = yyn;
01083 goto yynewstate;
01084
01085
01086
01087
01088
01089 yydefault:
01090 yyn = yydefact[yystate];
01091 if (yyn == 0)
01092 goto yyerrlab;
01093 goto yyreduce;
01094
01095
01096
01097
01098
01099 yyreduce:
01100
01101 yylen = yyr2[yyn];
01102
01103
01104
01105
01106
01107
01108
01109
01110
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
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
01218
01219
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
01234
01235 yyerrlab:
01236
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
01252
01253 int yyxbegin = yyn < 0 ? -yyn : 0;
01254
01255
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
01299 yyerror ("syntax error");
01300 }
01301
01302
01303
01304 if (yyerrstatus == 3)
01305 {
01306
01307
01308
01309 if (yychar <= YYEOF)
01310 {
01311
01312
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
01332
01333 goto yyerrlab1;
01334
01335
01336
01337
01338
01339 yyerrorlab:
01340
01341 #ifdef __GNUC__
01342
01343
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
01356
01357 yyerrlab1:
01358 yyerrstatus = 3;
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
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
01392 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
01393
01394 yystate = yyn;
01395 goto yynewstate;
01396
01397
01398
01399
01400
01401 yyacceptlab:
01402 yyresult = 0;
01403 goto yyreturn;
01404
01405
01406
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
01418
01419 yyoverflowlab:
01420 yyerror ("parser stack overflow");
01421 yyresult = 2;
01422
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