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
00038
00039
00040
00041
00042
00043
00044
00045
00046 #define YYBISON 1
00047
00048
00049 #define YYBISON_VERSION "2.4.1"
00050
00051
00052 #define YYSKELETON_NAME "yacc.c"
00053
00054
00055 #define YYPURE 1
00056
00057
00058 #define YYPUSH 0
00059
00060
00061 #define YYPULL 1
00062
00063
00064 #define YYLSP_NEEDED 1
00065
00066
00067 #define yyparse pktloc_parse
00068 #define yylex pktloc_lex
00069 #define yyerror pktloc_error
00070 #define yylval pktloc_lval
00071 #define yychar pktloc_char
00072 #define yydebug pktloc_debug
00073 #define yynerrs pktloc_nerrs
00074 #define yylloc pktloc_lloc
00075
00076
00077
00078
00079 #line 1 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
00080
00081 #include <netlink-local.h>
00082 #include <netlink-tc.h>
00083 #include <netlink/netlink.h>
00084 #include <netlink/utils.h>
00085 #include <netlink/route/pktloc.h>
00086
00087
00088
00089 #line 90 "route/pktloc_syntax.c"
00090
00091
00092 #ifndef YYDEBUG
00093 # define YYDEBUG 0
00094 #endif
00095
00096
00097 #ifdef YYERROR_VERBOSE
00098 # undef YYERROR_VERBOSE
00099 # define YYERROR_VERBOSE 1
00100 #else
00101 # define YYERROR_VERBOSE 1
00102 #endif
00103
00104
00105 #ifndef YYTOKEN_TABLE
00106 # define YYTOKEN_TABLE 0
00107 #endif
00108
00109
00110
00111 #ifndef YYTOKENTYPE
00112 # define YYTOKENTYPE
00113
00114
00115 enum yytokentype {
00116 ERROR = 258,
00117 NUMBER = 259,
00118 LAYER = 260,
00119 ALIGN = 261,
00120 NAME = 262
00121 };
00122 #endif
00123
00124 #define ERROR 258
00125 #define NUMBER 259
00126 #define LAYER 260
00127 #define ALIGN 261
00128 #define NAME 262
00129
00130
00131
00132
00133 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00134 typedef union YYSTYPE
00135 {
00136
00137
00138 #line 18 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
00139
00140 struct rtnl_pktloc *l;
00141 uint32_t i;
00142 char *s;
00143
00144
00145
00146
00147 #line 148 "route/pktloc_syntax.c"
00148 } YYSTYPE;
00149 # define YYSTYPE_IS_TRIVIAL 1
00150 # define yystype YYSTYPE
00151 # define YYSTYPE_IS_DECLARED 1
00152 #endif
00153
00154 #if ! defined YYLTYPE && ! defined YYLTYPE_IS_DECLARED
00155 typedef struct YYLTYPE
00156 {
00157 int first_line;
00158 int first_column;
00159 int last_line;
00160 int last_column;
00161 } YYLTYPE;
00162 # define yyltype YYLTYPE
00163 # define YYLTYPE_IS_DECLARED 1
00164 # define YYLTYPE_IS_TRIVIAL 1
00165 #endif
00166
00167
00168
00169
00170
00171 #line 24 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
00172
00173 extern int pktloc_lex(YYSTYPE *, YYLTYPE *, void *);
00174
00175 static void yyerror(YYLTYPE *locp, void *scanner, const char *msg)
00176 {
00177 NL_DBG(1, "Error while parsing packet location file: %s\n", msg);
00178 }
00179
00180
00181
00182 #line 183 "route/pktloc_syntax.c"
00183
00184 #ifdef short
00185 # undef short
00186 #endif
00187
00188 #ifdef YYTYPE_UINT8
00189 typedef YYTYPE_UINT8 yytype_uint8;
00190 #else
00191 typedef unsigned char yytype_uint8;
00192 #endif
00193
00194 #ifdef YYTYPE_INT8
00195 typedef YYTYPE_INT8 yytype_int8;
00196 #elif (defined __STDC__ || defined __C99__FUNC__ \
00197 || defined __cplusplus || defined _MSC_VER)
00198 typedef signed char yytype_int8;
00199 #else
00200 typedef short int yytype_int8;
00201 #endif
00202
00203 #ifdef YYTYPE_UINT16
00204 typedef YYTYPE_UINT16 yytype_uint16;
00205 #else
00206 typedef unsigned short int yytype_uint16;
00207 #endif
00208
00209 #ifdef YYTYPE_INT16
00210 typedef YYTYPE_INT16 yytype_int16;
00211 #else
00212 typedef short int yytype_int16;
00213 #endif
00214
00215 #ifndef YYSIZE_T
00216 # ifdef __SIZE_TYPE__
00217 # define YYSIZE_T __SIZE_TYPE__
00218 # elif defined size_t
00219 # define YYSIZE_T size_t
00220 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00221 || defined __cplusplus || defined _MSC_VER)
00222 # include <stddef.h>
00223 # define YYSIZE_T size_t
00224 # else
00225 # define YYSIZE_T unsigned int
00226 # endif
00227 #endif
00228
00229 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00230
00231 #ifndef YY_
00232 # if YYENABLE_NLS
00233 # if ENABLE_NLS
00234 # include <libintl.h>
00235 # define YY_(msgid) dgettext ("bison-runtime", msgid)
00236 # endif
00237 # endif
00238 # ifndef YY_
00239 # define YY_(msgid) msgid
00240 # endif
00241 #endif
00242
00243
00244 #if ! defined lint || defined __GNUC__
00245 # define YYUSE(e) ((void) (e))
00246 #else
00247 # define YYUSE(e)
00248 #endif
00249
00250
00251 #ifndef lint
00252 # define YYID(n) (n)
00253 #else
00254 #if (defined __STDC__ || defined __C99__FUNC__ \
00255 || defined __cplusplus || defined _MSC_VER)
00256 static int
00257 YYID (int yyi)
00258 #else
00259 static int
00260 YYID (yyi)
00261 int yyi;
00262 #endif
00263 {
00264 return yyi;
00265 }
00266 #endif
00267
00268 #if ! defined yyoverflow || YYERROR_VERBOSE
00269
00270
00271
00272 # ifdef YYSTACK_USE_ALLOCA
00273 # if YYSTACK_USE_ALLOCA
00274 # ifdef __GNUC__
00275 # define YYSTACK_ALLOC __builtin_alloca
00276 # elif defined __BUILTIN_VA_ARG_INCR
00277 # include <alloca.h>
00278 # elif defined _AIX
00279 # define YYSTACK_ALLOC __alloca
00280 # elif defined _MSC_VER
00281 # include <malloc.h>
00282 # define alloca _alloca
00283 # else
00284 # define YYSTACK_ALLOC alloca
00285 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00286 || defined __cplusplus || defined _MSC_VER)
00287 # include <stdlib.h>
00288 # ifndef _STDLIB_H
00289 # define _STDLIB_H 1
00290 # endif
00291 # endif
00292 # endif
00293 # endif
00294 # endif
00295
00296 # ifdef YYSTACK_ALLOC
00297
00298 # define YYSTACK_FREE(Ptr) do { ; } while (YYID (0))
00299 # ifndef YYSTACK_ALLOC_MAXIMUM
00300
00301
00302
00303
00304 # define YYSTACK_ALLOC_MAXIMUM 4032
00305 # endif
00306 # else
00307 # define YYSTACK_ALLOC YYMALLOC
00308 # define YYSTACK_FREE YYFREE
00309 # ifndef YYSTACK_ALLOC_MAXIMUM
00310 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
00311 # endif
00312 # if (defined __cplusplus && ! defined _STDLIB_H \
00313 && ! ((defined YYMALLOC || defined malloc) \
00314 && (defined YYFREE || defined free)))
00315 # include <stdlib.h>
00316 # ifndef _STDLIB_H
00317 # define _STDLIB_H 1
00318 # endif
00319 # endif
00320 # ifndef YYMALLOC
00321 # define YYMALLOC malloc
00322 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00323 || defined __cplusplus || defined _MSC_VER)
00324 void *malloc (YYSIZE_T);
00325 # endif
00326 # endif
00327 # ifndef YYFREE
00328 # define YYFREE free
00329 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00330 || defined __cplusplus || defined _MSC_VER)
00331 void free (void *);
00332 # endif
00333 # endif
00334 # endif
00335 #endif
00336
00337
00338 #if (! defined yyoverflow \
00339 && (! defined __cplusplus \
00340 || (defined YYLTYPE_IS_TRIVIAL && YYLTYPE_IS_TRIVIAL \
00341 && defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
00342
00343
00344 union yyalloc
00345 {
00346 yytype_int16 yyss_alloc;
00347 YYSTYPE yyvs_alloc;
00348 YYLTYPE yyls_alloc;
00349 };
00350
00351
00352 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00353
00354
00355
00356 # define YYSTACK_BYTES(N) \
00357 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
00358 + 2 * YYSTACK_GAP_MAXIMUM)
00359
00360
00361
00362 # ifndef YYCOPY
00363 # if defined __GNUC__ && 1 < __GNUC__
00364 # define YYCOPY(To, From, Count) \
00365 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00366 # else
00367 # define YYCOPY(To, From, Count) \
00368 do \
00369 { \
00370 YYSIZE_T yyi; \
00371 for (yyi = 0; yyi < (Count); yyi++) \
00372 (To)[yyi] = (From)[yyi]; \
00373 } \
00374 while (YYID (0))
00375 # endif
00376 # endif
00377
00378
00379
00380
00381
00382
00383 # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
00384 do \
00385 { \
00386 YYSIZE_T yynewbytes; \
00387 YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
00388 Stack = &yyptr->Stack_alloc; \
00389 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00390 yyptr += yynewbytes / sizeof (*yyptr); \
00391 } \
00392 while (YYID (0))
00393
00394 #endif
00395
00396
00397 #define YYFINAL 7
00398
00399 #define YYLAST 10
00400
00401
00402 #define YYNTOKENS 9
00403
00404 #define YYNNTS 7
00405
00406 #define YYNRULES 12
00407
00408 #define YYNSTATES 17
00409
00410
00411 #define YYUNDEFTOK 2
00412 #define YYMAXUTOK 262
00413
00414 #define YYTRANSLATE(YYX) \
00415 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00416
00417
00418 static const yytype_uint8 yytranslate[] =
00419 {
00420 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00421 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00422 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00423 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00424 2, 2, 2, 8, 2, 2, 2, 2, 2, 2,
00425 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00426 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00427 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00428 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00429 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00430 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00431 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00432 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00433 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00434 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00435 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00436 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00437 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00438 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00439 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00440 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00441 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00442 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00443 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00444 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
00445 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
00446 5, 6, 7
00447 };
00448
00449 #if YYDEBUG
00450
00451
00452 static const yytype_uint8 yyprhs[] =
00453 {
00454 0, 0, 3, 4, 7, 14, 16, 18, 19, 22,
00455 23, 25, 26
00456 };
00457
00458
00459 static const yytype_int8 yyrhs[] =
00460 {
00461 10, 0, -1, -1, 11, 10, -1, 7, 12, 13,
00462 4, 14, 15, -1, 6, -1, 4, -1, -1, 5,
00463 8, -1, -1, 4, -1, -1, 4, -1
00464 };
00465
00466
00467 static const yytype_uint8 yyrline[] =
00468 {
00469 0, 45, 45, 47, 51, 78, 80, 86, 87, 93,
00470 94, 100, 101
00471 };
00472 #endif
00473
00474 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
00475
00476
00477 static const char *const yytname[] =
00478 {
00479 "$end", "error", "$undefined", "ERROR", "NUMBER", "LAYER", "ALIGN",
00480 "NAME", "'+'", "$accept", "input", "location", "align", "layer", "mask",
00481 "shift", 0
00482 };
00483 #endif
00484
00485 # ifdef YYPRINT
00486
00487
00488 static const yytype_uint16 yytoknum[] =
00489 {
00490 0, 256, 257, 258, 259, 260, 261, 262, 43
00491 };
00492 # endif
00493
00494
00495 static const yytype_uint8 yyr1[] =
00496 {
00497 0, 9, 10, 10, 11, 12, 12, 13, 13, 14,
00498 14, 15, 15
00499 };
00500
00501
00502 static const yytype_uint8 yyr2[] =
00503 {
00504 0, 2, 0, 2, 6, 1, 1, 0, 2, 0,
00505 1, 0, 1
00506 };
00507
00508
00509
00510
00511 static const yytype_uint8 yydefact[] =
00512 {
00513 2, 0, 0, 2, 6, 5, 7, 1, 3, 0,
00514 0, 8, 9, 10, 11, 12, 4
00515 };
00516
00517
00518 static const yytype_int8 yydefgoto[] =
00519 {
00520 -1, 2, 3, 6, 10, 14, 16
00521 };
00522
00523
00524
00525 #define YYPACT_NINF -7
00526 static const yytype_int8 yypact[] =
00527 {
00528 -6, -4, 3, -6, -7, -7, -1, -7, -7, -3,
00529 2, -7, 4, -7, 5, -7, -7
00530 };
00531
00532
00533 static const yytype_int8 yypgoto[] =
00534 {
00535 -7, 7, -7, -7, -7, -7, -7
00536 };
00537
00538
00539
00540
00541
00542 #define YYTABLE_NINF -1
00543 static const yytype_uint8 yytable[] =
00544 {
00545 4, 1, 5, 7, 9, 11, 12, 0, 13, 15,
00546 8
00547 };
00548
00549 static const yytype_int8 yycheck[] =
00550 {
00551 4, 7, 6, 0, 5, 8, 4, -1, 4, 4,
00552 3
00553 };
00554
00555
00556
00557 static const yytype_uint8 yystos[] =
00558 {
00559 0, 7, 10, 11, 4, 6, 12, 0, 10, 5,
00560 13, 8, 4, 4, 14, 4, 15
00561 };
00562
00563 #define yyerrok (yyerrstatus = 0)
00564 #define yyclearin (yychar = YYEMPTY)
00565 #define YYEMPTY (-2)
00566 #define YYEOF 0
00567
00568 #define YYACCEPT goto yyacceptlab
00569 #define YYABORT goto yyabortlab
00570 #define YYERROR goto yyerrorlab
00571
00572
00573
00574
00575
00576
00577 #define YYFAIL goto yyerrlab
00578
00579 #define YYRECOVERING() (!!yyerrstatus)
00580
00581 #define YYBACKUP(Token, Value) \
00582 do \
00583 if (yychar == YYEMPTY && yylen == 1) \
00584 { \
00585 yychar = (Token); \
00586 yylval = (Value); \
00587 yytoken = YYTRANSLATE (yychar); \
00588 YYPOPSTACK (1); \
00589 goto yybackup; \
00590 } \
00591 else \
00592 { \
00593 yyerror (&yylloc, scanner, YY_("syntax error: cannot back up")); \
00594 YYERROR; \
00595 } \
00596 while (YYID (0))
00597
00598
00599 #define YYTERROR 1
00600 #define YYERRCODE 256
00601
00602
00603
00604
00605
00606
00607 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
00608 #ifndef YYLLOC_DEFAULT
00609 # define YYLLOC_DEFAULT(Current, Rhs, N) \
00610 do \
00611 if (YYID (N)) \
00612 { \
00613 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
00614 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
00615 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
00616 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
00617 } \
00618 else \
00619 { \
00620 (Current).first_line = (Current).last_line = \
00621 YYRHSLOC (Rhs, 0).last_line; \
00622 (Current).first_column = (Current).last_column = \
00623 YYRHSLOC (Rhs, 0).last_column; \
00624 } \
00625 while (YYID (0))
00626 #endif
00627
00628
00629
00630
00631
00632
00633 #ifndef YY_LOCATION_PRINT
00634 # if YYLTYPE_IS_TRIVIAL
00635 # define YY_LOCATION_PRINT(File, Loc) \
00636 fprintf (File, "%d.%d-%d.%d", \
00637 (Loc).first_line, (Loc).first_column, \
00638 (Loc).last_line, (Loc).last_column)
00639 # else
00640 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
00641 # endif
00642 #endif
00643
00644
00645
00646
00647 #ifdef YYLEX_PARAM
00648 # define YYLEX yylex (&yylval, &yylloc, YYLEX_PARAM)
00649 #else
00650 # define YYLEX yylex (&yylval, &yylloc, scanner)
00651 #endif
00652
00653
00654 #if YYDEBUG
00655
00656 # ifndef YYFPRINTF
00657 # include <stdio.h>
00658 # define YYFPRINTF fprintf
00659 # endif
00660
00661 # define YYDPRINTF(Args) \
00662 do { \
00663 if (yydebug) \
00664 YYFPRINTF Args; \
00665 } while (YYID (0))
00666
00667 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
00668 do { \
00669 if (yydebug) \
00670 { \
00671 YYFPRINTF (stderr, "%s ", Title); \
00672 yy_symbol_print (stderr, \
00673 Type, Value, Location, scanner); \
00674 YYFPRINTF (stderr, "\n"); \
00675 } \
00676 } while (YYID (0))
00677
00678
00679
00680
00681
00682
00683
00684 #if (defined __STDC__ || defined __C99__FUNC__ \
00685 || defined __cplusplus || defined _MSC_VER)
00686 static void
00687 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, void *scanner)
00688 #else
00689 static void
00690 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, scanner)
00691 FILE *yyoutput;
00692 int yytype;
00693 YYSTYPE const * const yyvaluep;
00694 YYLTYPE const * const yylocationp;
00695 void *scanner;
00696 #endif
00697 {
00698 if (!yyvaluep)
00699 return;
00700 YYUSE (yylocationp);
00701 YYUSE (scanner);
00702 # ifdef YYPRINT
00703 if (yytype < YYNTOKENS)
00704 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
00705 # else
00706 YYUSE (yyoutput);
00707 # endif
00708 switch (yytype)
00709 {
00710 default:
00711 break;
00712 }
00713 }
00714
00715
00716
00717
00718
00719
00720 #if (defined __STDC__ || defined __C99__FUNC__ \
00721 || defined __cplusplus || defined _MSC_VER)
00722 static void
00723 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, YYLTYPE const * const yylocationp, void *scanner)
00724 #else
00725 static void
00726 yy_symbol_print (yyoutput, yytype, yyvaluep, yylocationp, scanner)
00727 FILE *yyoutput;
00728 int yytype;
00729 YYSTYPE const * const yyvaluep;
00730 YYLTYPE const * const yylocationp;
00731 void *scanner;
00732 #endif
00733 {
00734 if (yytype < YYNTOKENS)
00735 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
00736 else
00737 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
00738
00739 YY_LOCATION_PRINT (yyoutput, *yylocationp);
00740 YYFPRINTF (yyoutput, ": ");
00741 yy_symbol_value_print (yyoutput, yytype, yyvaluep, yylocationp, scanner);
00742 YYFPRINTF (yyoutput, ")");
00743 }
00744
00745
00746
00747
00748
00749
00750 #if (defined __STDC__ || defined __C99__FUNC__ \
00751 || defined __cplusplus || defined _MSC_VER)
00752 static void
00753 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
00754 #else
00755 static void
00756 yy_stack_print (yybottom, yytop)
00757 yytype_int16 *yybottom;
00758 yytype_int16 *yytop;
00759 #endif
00760 {
00761 YYFPRINTF (stderr, "Stack now");
00762 for (; yybottom <= yytop; yybottom++)
00763 {
00764 int yybot = *yybottom;
00765 YYFPRINTF (stderr, " %d", yybot);
00766 }
00767 YYFPRINTF (stderr, "\n");
00768 }
00769
00770 # define YY_STACK_PRINT(Bottom, Top) \
00771 do { \
00772 if (yydebug) \
00773 yy_stack_print ((Bottom), (Top)); \
00774 } while (YYID (0))
00775
00776
00777
00778
00779
00780
00781 #if (defined __STDC__ || defined __C99__FUNC__ \
00782 || defined __cplusplus || defined _MSC_VER)
00783 static void
00784 yy_reduce_print (YYSTYPE *yyvsp, YYLTYPE *yylsp, int yyrule, void *scanner)
00785 #else
00786 static void
00787 yy_reduce_print (yyvsp, yylsp, yyrule, scanner)
00788 YYSTYPE *yyvsp;
00789 YYLTYPE *yylsp;
00790 int yyrule;
00791 void *scanner;
00792 #endif
00793 {
00794 int yynrhs = yyr2[yyrule];
00795 int yyi;
00796 unsigned long int yylno = yyrline[yyrule];
00797 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
00798 yyrule - 1, yylno);
00799
00800 for (yyi = 0; yyi < yynrhs; yyi++)
00801 {
00802 YYFPRINTF (stderr, " $%d = ", yyi + 1);
00803 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
00804 &(yyvsp[(yyi + 1) - (yynrhs)])
00805 , &(yylsp[(yyi + 1) - (yynrhs)]) , scanner);
00806 YYFPRINTF (stderr, "\n");
00807 }
00808 }
00809
00810 # define YY_REDUCE_PRINT(Rule) \
00811 do { \
00812 if (yydebug) \
00813 yy_reduce_print (yyvsp, yylsp, Rule, scanner); \
00814 } while (YYID (0))
00815
00816
00817
00818 int yydebug;
00819 #else
00820 # define YYDPRINTF(Args)
00821 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
00822 # define YY_STACK_PRINT(Bottom, Top)
00823 # define YY_REDUCE_PRINT(Rule)
00824 #endif
00825
00826
00827
00828 #ifndef YYINITDEPTH
00829 # define YYINITDEPTH 200
00830 #endif
00831
00832
00833
00834
00835
00836
00837
00838
00839 #ifndef YYMAXDEPTH
00840 # define YYMAXDEPTH 10000
00841 #endif
00842
00843
00844
00845 #if YYERROR_VERBOSE
00846
00847 # ifndef yystrlen
00848 # if defined __GLIBC__ && defined _STRING_H
00849 # define yystrlen strlen
00850 # else
00851
00852 #if (defined __STDC__ || defined __C99__FUNC__ \
00853 || defined __cplusplus || defined _MSC_VER)
00854 static YYSIZE_T
00855 yystrlen (const char *yystr)
00856 #else
00857 static YYSIZE_T
00858 yystrlen (yystr)
00859 const char *yystr;
00860 #endif
00861 {
00862 YYSIZE_T yylen;
00863 for (yylen = 0; yystr[yylen]; yylen++)
00864 continue;
00865 return yylen;
00866 }
00867 # endif
00868 # endif
00869
00870 # ifndef yystpcpy
00871 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
00872 # define yystpcpy stpcpy
00873 # else
00874
00875
00876 #if (defined __STDC__ || defined __C99__FUNC__ \
00877 || defined __cplusplus || defined _MSC_VER)
00878 static char *
00879 yystpcpy (char *yydest, const char *yysrc)
00880 #else
00881 static char *
00882 yystpcpy (yydest, yysrc)
00883 char *yydest;
00884 const char *yysrc;
00885 #endif
00886 {
00887 char *yyd = yydest;
00888 const char *yys = yysrc;
00889
00890 while ((*yyd++ = *yys++) != '\0')
00891 continue;
00892
00893 return yyd - 1;
00894 }
00895 # endif
00896 # endif
00897
00898 # ifndef yytnamerr
00899
00900
00901
00902
00903
00904
00905
00906 static YYSIZE_T
00907 yytnamerr (char *yyres, const char *yystr)
00908 {
00909 if (*yystr == '"')
00910 {
00911 YYSIZE_T yyn = 0;
00912 char const *yyp = yystr;
00913
00914 for (;;)
00915 switch (*++yyp)
00916 {
00917 case '\'':
00918 case ',':
00919 goto do_not_strip_quotes;
00920
00921 case '\\':
00922 if (*++yyp != '\\')
00923 goto do_not_strip_quotes;
00924
00925 default:
00926 if (yyres)
00927 yyres[yyn] = *yyp;
00928 yyn++;
00929 break;
00930
00931 case '"':
00932 if (yyres)
00933 yyres[yyn] = '\0';
00934 return yyn;
00935 }
00936 do_not_strip_quotes: ;
00937 }
00938
00939 if (! yyres)
00940 return yystrlen (yystr);
00941
00942 return yystpcpy (yyres, yystr) - yyres;
00943 }
00944 # endif
00945
00946
00947
00948
00949
00950
00951
00952
00953 static YYSIZE_T
00954 yysyntax_error (char *yyresult, int yystate, int yychar)
00955 {
00956 int yyn = yypact[yystate];
00957
00958 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
00959 return 0;
00960 else
00961 {
00962 int yytype = YYTRANSLATE (yychar);
00963 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
00964 YYSIZE_T yysize = yysize0;
00965 YYSIZE_T yysize1;
00966 int yysize_overflow = 0;
00967 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
00968 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
00969 int yyx;
00970
00971 # if 0
00972
00973
00974 YY_("syntax error, unexpected %s");
00975 YY_("syntax error, unexpected %s, expecting %s");
00976 YY_("syntax error, unexpected %s, expecting %s or %s");
00977 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
00978 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
00979 # endif
00980 char *yyfmt;
00981 char const *yyf;
00982 static char const yyunexpected[] = "syntax error, unexpected %s";
00983 static char const yyexpecting[] = ", expecting %s";
00984 static char const yyor[] = " or %s";
00985 char yyformat[sizeof yyunexpected
00986 + sizeof yyexpecting - 1
00987 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
00988 * (sizeof yyor - 1))];
00989 char const *yyprefix = yyexpecting;
00990
00991
00992
00993 int yyxbegin = yyn < 0 ? -yyn : 0;
00994
00995
00996 int yychecklim = YYLAST - yyn + 1;
00997 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
00998 int yycount = 1;
00999
01000 yyarg[0] = yytname[yytype];
01001 yyfmt = yystpcpy (yyformat, yyunexpected);
01002
01003 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01004 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01005 {
01006 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
01007 {
01008 yycount = 1;
01009 yysize = yysize0;
01010 yyformat[sizeof yyunexpected - 1] = '\0';
01011 break;
01012 }
01013 yyarg[yycount++] = yytname[yyx];
01014 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
01015 yysize_overflow |= (yysize1 < yysize);
01016 yysize = yysize1;
01017 yyfmt = yystpcpy (yyfmt, yyprefix);
01018 yyprefix = yyor;
01019 }
01020
01021 yyf = YY_(yyformat);
01022 yysize1 = yysize + yystrlen (yyf);
01023 yysize_overflow |= (yysize1 < yysize);
01024 yysize = yysize1;
01025
01026 if (yysize_overflow)
01027 return YYSIZE_MAXIMUM;
01028
01029 if (yyresult)
01030 {
01031
01032
01033
01034 char *yyp = yyresult;
01035 int yyi = 0;
01036 while ((*yyp = *yyf) != '\0')
01037 {
01038 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
01039 {
01040 yyp += yytnamerr (yyp, yyarg[yyi++]);
01041 yyf += 2;
01042 }
01043 else
01044 {
01045 yyp++;
01046 yyf++;
01047 }
01048 }
01049 }
01050 return yysize;
01051 }
01052 }
01053 #endif
01054
01055
01056
01057
01058
01059
01060
01061 #if (defined __STDC__ || defined __C99__FUNC__ \
01062 || defined __cplusplus || defined _MSC_VER)
01063 static void
01064 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, YYLTYPE *yylocationp, void *scanner)
01065 #else
01066 static void
01067 yydestruct (yymsg, yytype, yyvaluep, yylocationp, scanner)
01068 const char *yymsg;
01069 int yytype;
01070 YYSTYPE *yyvaluep;
01071 YYLTYPE *yylocationp;
01072 void *scanner;
01073 #endif
01074 {
01075 YYUSE (yyvaluep);
01076 YYUSE (yylocationp);
01077 YYUSE (scanner);
01078
01079 if (!yymsg)
01080 yymsg = "Deleting";
01081 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
01082
01083 switch (yytype)
01084 {
01085 case 7:
01086
01087
01088 #line 39 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
01089 { free((yyvaluep->s)); };
01090
01091
01092 #line 1093 "route/pktloc_syntax.c"
01093 break;
01094
01095 default:
01096 break;
01097 }
01098 }
01099
01100
01101 #ifdef YYPARSE_PARAM
01102 #if defined __STDC__ || defined __cplusplus
01103 int yyparse (void *YYPARSE_PARAM);
01104 #else
01105 int yyparse ();
01106 #endif
01107 #else
01108 #if defined __STDC__ || defined __cplusplus
01109 int yyparse (void *scanner);
01110 #else
01111 int yyparse ();
01112 #endif
01113 #endif
01114
01115
01116
01117
01118
01119
01120
01121
01122
01123 #ifdef YYPARSE_PARAM
01124 #if (defined __STDC__ || defined __C99__FUNC__ \
01125 || defined __cplusplus || defined _MSC_VER)
01126 int
01127 yyparse (void *YYPARSE_PARAM)
01128 #else
01129 int
01130 yyparse (YYPARSE_PARAM)
01131 void *YYPARSE_PARAM;
01132 #endif
01133 #else
01134 #if (defined __STDC__ || defined __C99__FUNC__ \
01135 || defined __cplusplus || defined _MSC_VER)
01136 int
01137 yyparse (void *scanner)
01138 #else
01139 int
01140 yyparse (scanner)
01141 void *scanner;
01142 #endif
01143 #endif
01144 {
01145
01146 int yychar;
01147
01148
01149 YYSTYPE yylval;
01150
01151
01152 YYLTYPE yylloc;
01153
01154
01155 int yynerrs;
01156
01157 int yystate;
01158
01159 int yyerrstatus;
01160
01161
01162
01163
01164
01165
01166
01167
01168
01169
01170 yytype_int16 yyssa[YYINITDEPTH];
01171 yytype_int16 *yyss;
01172 yytype_int16 *yyssp;
01173
01174
01175 YYSTYPE yyvsa[YYINITDEPTH];
01176 YYSTYPE *yyvs;
01177 YYSTYPE *yyvsp;
01178
01179
01180 YYLTYPE yylsa[YYINITDEPTH];
01181 YYLTYPE *yyls;
01182 YYLTYPE *yylsp;
01183
01184
01185 YYLTYPE yyerror_range[2];
01186
01187 YYSIZE_T yystacksize;
01188
01189 int yyn;
01190 int yyresult;
01191
01192 int yytoken;
01193
01194
01195 YYSTYPE yyval;
01196 YYLTYPE yyloc;
01197
01198 #if YYERROR_VERBOSE
01199
01200 char yymsgbuf[128];
01201 char *yymsg = yymsgbuf;
01202 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
01203 #endif
01204
01205 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
01206
01207
01208
01209 int yylen = 0;
01210
01211 yytoken = 0;
01212 yyss = yyssa;
01213 yyvs = yyvsa;
01214 yyls = yylsa;
01215 yystacksize = YYINITDEPTH;
01216
01217 YYDPRINTF ((stderr, "Starting parse\n"));
01218
01219 yystate = 0;
01220 yyerrstatus = 0;
01221 yynerrs = 0;
01222 yychar = YYEMPTY;
01223
01224
01225
01226
01227
01228 yyssp = yyss;
01229 yyvsp = yyvs;
01230 yylsp = yyls;
01231
01232 #if YYLTYPE_IS_TRIVIAL
01233
01234 yylloc.first_line = yylloc.last_line = 1;
01235 yylloc.first_column = yylloc.last_column = 1;
01236 #endif
01237
01238 goto yysetstate;
01239
01240
01241
01242
01243 yynewstate:
01244
01245
01246 yyssp++;
01247
01248 yysetstate:
01249 *yyssp = yystate;
01250
01251 if (yyss + yystacksize - 1 <= yyssp)
01252 {
01253
01254 YYSIZE_T yysize = yyssp - yyss + 1;
01255
01256 #ifdef yyoverflow
01257 {
01258
01259
01260
01261 YYSTYPE *yyvs1 = yyvs;
01262 yytype_int16 *yyss1 = yyss;
01263 YYLTYPE *yyls1 = yyls;
01264
01265
01266
01267
01268
01269 yyoverflow (YY_("memory exhausted"),
01270 &yyss1, yysize * sizeof (*yyssp),
01271 &yyvs1, yysize * sizeof (*yyvsp),
01272 &yyls1, yysize * sizeof (*yylsp),
01273 &yystacksize);
01274
01275 yyls = yyls1;
01276 yyss = yyss1;
01277 yyvs = yyvs1;
01278 }
01279 #else
01280 # ifndef YYSTACK_RELOCATE
01281 goto yyexhaustedlab;
01282 # else
01283
01284 if (YYMAXDEPTH <= yystacksize)
01285 goto yyexhaustedlab;
01286 yystacksize *= 2;
01287 if (YYMAXDEPTH < yystacksize)
01288 yystacksize = YYMAXDEPTH;
01289
01290 {
01291 yytype_int16 *yyss1 = yyss;
01292 union yyalloc *yyptr =
01293 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01294 if (! yyptr)
01295 goto yyexhaustedlab;
01296 YYSTACK_RELOCATE (yyss_alloc, yyss);
01297 YYSTACK_RELOCATE (yyvs_alloc, yyvs);
01298 YYSTACK_RELOCATE (yyls_alloc, yyls);
01299 # undef YYSTACK_RELOCATE
01300 if (yyss1 != yyssa)
01301 YYSTACK_FREE (yyss1);
01302 }
01303 # endif
01304 #endif
01305
01306 yyssp = yyss + yysize - 1;
01307 yyvsp = yyvs + yysize - 1;
01308 yylsp = yyls + yysize - 1;
01309
01310 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01311 (unsigned long int) yystacksize));
01312
01313 if (yyss + yystacksize - 1 <= yyssp)
01314 YYABORT;
01315 }
01316
01317 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01318
01319 if (yystate == YYFINAL)
01320 YYACCEPT;
01321
01322 goto yybackup;
01323
01324
01325
01326
01327 yybackup:
01328
01329
01330
01331
01332
01333 yyn = yypact[yystate];
01334 if (yyn == YYPACT_NINF)
01335 goto yydefault;
01336
01337
01338
01339
01340 if (yychar == YYEMPTY)
01341 {
01342 YYDPRINTF ((stderr, "Reading a token: "));
01343 yychar = YYLEX;
01344 }
01345
01346 if (yychar <= YYEOF)
01347 {
01348 yychar = yytoken = YYEOF;
01349 YYDPRINTF ((stderr, "Now at end of input.\n"));
01350 }
01351 else
01352 {
01353 yytoken = YYTRANSLATE (yychar);
01354 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
01355 }
01356
01357
01358
01359 yyn += yytoken;
01360 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01361 goto yydefault;
01362 yyn = yytable[yyn];
01363 if (yyn <= 0)
01364 {
01365 if (yyn == 0 || yyn == YYTABLE_NINF)
01366 goto yyerrlab;
01367 yyn = -yyn;
01368 goto yyreduce;
01369 }
01370
01371
01372
01373 if (yyerrstatus)
01374 yyerrstatus--;
01375
01376
01377 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
01378
01379
01380 yychar = YYEMPTY;
01381
01382 yystate = yyn;
01383 *++yyvsp = yylval;
01384 *++yylsp = yylloc;
01385 goto yynewstate;
01386
01387
01388
01389
01390
01391 yydefault:
01392 yyn = yydefact[yystate];
01393 if (yyn == 0)
01394 goto yyerrlab;
01395 goto yyreduce;
01396
01397
01398
01399
01400
01401 yyreduce:
01402
01403 yylen = yyr2[yyn];
01404
01405
01406
01407
01408
01409
01410
01411
01412
01413 yyval = yyvsp[1-yylen];
01414
01415
01416 YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
01417 YY_REDUCE_PRINT (yyn);
01418 switch (yyn)
01419 {
01420 case 4:
01421
01422
01423 #line 52 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
01424 {
01425 struct rtnl_pktloc *loc;
01426
01427 if (!(loc = rtnl_pktloc_alloc())) {
01428 NL_DBG(1, "Allocating a packet location "
01429 "object failed.\n");
01430 YYABORT;
01431 }
01432
01433 loc->name = (yyvsp[(1) - (6)].s);
01434 loc->align = (yyvsp[(2) - (6)].i);
01435 loc->layer = (yyvsp[(3) - (6)].i);
01436 loc->offset = (yyvsp[(4) - (6)].i);
01437 loc->mask = (yyvsp[(5) - (6)].i);
01438 loc->shift = (yyvsp[(6) - (6)].i);
01439
01440 if (rtnl_pktloc_add(loc) < 0) {
01441 NL_DBG(1, "Duplicate packet location entry "
01442 "\"%s\"\n", (yyvsp[(1) - (6)].s));
01443 }
01444
01445 (yyval.l) = loc;
01446 }
01447 break;
01448
01449 case 5:
01450
01451
01452 #line 79 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
01453 { (yyval.i) = (yyvsp[(1) - (1)].i); }
01454 break;
01455
01456 case 6:
01457
01458
01459 #line 81 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
01460 { (yyval.i) = (yyvsp[(1) - (1)].i); }
01461 break;
01462
01463 case 7:
01464
01465
01466 #line 86 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
01467 { (yyval.i) = TCF_LAYER_NETWORK; }
01468 break;
01469
01470 case 8:
01471
01472
01473 #line 88 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
01474 { (yyval.i) = (yyvsp[(1) - (2)].i); }
01475 break;
01476
01477 case 9:
01478
01479
01480 #line 93 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
01481 { (yyval.i) = 0; }
01482 break;
01483
01484 case 10:
01485
01486
01487 #line 95 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
01488 { (yyval.i) = (yyvsp[(1) - (1)].i); }
01489 break;
01490
01491 case 11:
01492
01493
01494 #line 100 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
01495 { (yyval.i) = 0; }
01496 break;
01497
01498 case 12:
01499
01500
01501 #line 102 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/pktloc_syntax.y"
01502 { (yyval.i) = (yyvsp[(1) - (1)].i); }
01503 break;
01504
01505
01506
01507
01508 #line 1509 "route/pktloc_syntax.c"
01509 default: break;
01510 }
01511 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
01512
01513 YYPOPSTACK (yylen);
01514 yylen = 0;
01515 YY_STACK_PRINT (yyss, yyssp);
01516
01517 *++yyvsp = yyval;
01518 *++yylsp = yyloc;
01519
01520
01521
01522
01523
01524 yyn = yyr1[yyn];
01525
01526 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
01527 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
01528 yystate = yytable[yystate];
01529 else
01530 yystate = yydefgoto[yyn - YYNTOKENS];
01531
01532 goto yynewstate;
01533
01534
01535
01536
01537
01538 yyerrlab:
01539
01540 if (!yyerrstatus)
01541 {
01542 ++yynerrs;
01543 #if ! YYERROR_VERBOSE
01544 yyerror (&yylloc, scanner, YY_("syntax error"));
01545 #else
01546 {
01547 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
01548 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
01549 {
01550 YYSIZE_T yyalloc = 2 * yysize;
01551 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
01552 yyalloc = YYSTACK_ALLOC_MAXIMUM;
01553 if (yymsg != yymsgbuf)
01554 YYSTACK_FREE (yymsg);
01555 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
01556 if (yymsg)
01557 yymsg_alloc = yyalloc;
01558 else
01559 {
01560 yymsg = yymsgbuf;
01561 yymsg_alloc = sizeof yymsgbuf;
01562 }
01563 }
01564
01565 if (0 < yysize && yysize <= yymsg_alloc)
01566 {
01567 (void) yysyntax_error (yymsg, yystate, yychar);
01568 yyerror (&yylloc, scanner, yymsg);
01569 }
01570 else
01571 {
01572 yyerror (&yylloc, scanner, YY_("syntax error"));
01573 if (yysize != 0)
01574 goto yyexhaustedlab;
01575 }
01576 }
01577 #endif
01578 }
01579
01580 yyerror_range[0] = yylloc;
01581
01582 if (yyerrstatus == 3)
01583 {
01584
01585
01586
01587 if (yychar <= YYEOF)
01588 {
01589
01590 if (yychar == YYEOF)
01591 YYABORT;
01592 }
01593 else
01594 {
01595 yydestruct ("Error: discarding",
01596 yytoken, &yylval, &yylloc, scanner);
01597 yychar = YYEMPTY;
01598 }
01599 }
01600
01601
01602
01603 goto yyerrlab1;
01604
01605
01606
01607
01608
01609 yyerrorlab:
01610
01611
01612
01613
01614 if ( 0)
01615 goto yyerrorlab;
01616
01617 yyerror_range[0] = yylsp[1-yylen];
01618
01619
01620 YYPOPSTACK (yylen);
01621 yylen = 0;
01622 YY_STACK_PRINT (yyss, yyssp);
01623 yystate = *yyssp;
01624 goto yyerrlab1;
01625
01626
01627
01628
01629
01630 yyerrlab1:
01631 yyerrstatus = 3;
01632
01633 for (;;)
01634 {
01635 yyn = yypact[yystate];
01636 if (yyn != YYPACT_NINF)
01637 {
01638 yyn += YYTERROR;
01639 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
01640 {
01641 yyn = yytable[yyn];
01642 if (0 < yyn)
01643 break;
01644 }
01645 }
01646
01647
01648 if (yyssp == yyss)
01649 YYABORT;
01650
01651 yyerror_range[0] = *yylsp;
01652 yydestruct ("Error: popping",
01653 yystos[yystate], yyvsp, yylsp, scanner);
01654 YYPOPSTACK (1);
01655 yystate = *yyssp;
01656 YY_STACK_PRINT (yyss, yyssp);
01657 }
01658
01659 *++yyvsp = yylval;
01660
01661 yyerror_range[1] = yylloc;
01662
01663
01664 YYLLOC_DEFAULT (yyloc, (yyerror_range - 1), 2);
01665 *++yylsp = yyloc;
01666
01667
01668 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
01669
01670 yystate = yyn;
01671 goto yynewstate;
01672
01673
01674
01675
01676
01677 yyacceptlab:
01678 yyresult = 0;
01679 goto yyreturn;
01680
01681
01682
01683
01684 yyabortlab:
01685 yyresult = 1;
01686 goto yyreturn;
01687
01688 #if !defined(yyoverflow) || YYERROR_VERBOSE
01689
01690
01691
01692 yyexhaustedlab:
01693 yyerror (&yylloc, scanner, YY_("memory exhausted"));
01694 yyresult = 2;
01695
01696 #endif
01697
01698 yyreturn:
01699 if (yychar != YYEMPTY)
01700 yydestruct ("Cleanup: discarding lookahead",
01701 yytoken, &yylval, &yylloc, scanner);
01702
01703
01704 YYPOPSTACK (yylen);
01705 YY_STACK_PRINT (yyss, yyssp);
01706 while (yyssp != yyss)
01707 {
01708 yydestruct ("Cleanup: popping",
01709 yystos[*yyssp], yyvsp, yylsp, scanner);
01710 YYPOPSTACK (1);
01711 }
01712 #ifndef yyoverflow
01713 if (yyss != yyssa)
01714 YYSTACK_FREE (yyss);
01715 #endif
01716 #if YYERROR_VERBOSE
01717 if (yymsg != yymsgbuf)
01718 YYSTACK_FREE (yymsg);
01719 #endif
01720
01721 return YYID (yyresult);
01722 }
01723
01724
01725