ematch_syntax.c

00001 
00002 /* A Bison parser, made by GNU Bison 2.4.1.  */
00003 
00004 /* Skeleton implementation for Bison's Yacc-like parsers in C
00005    
00006       Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
00007    Free Software Foundation, Inc.
00008    
00009    This program is free software: you can redistribute it and/or modify
00010    it under the terms of the GNU General Public License as published by
00011    the Free Software Foundation, either version 3 of the License, or
00012    (at your option) any later version.
00013    
00014    This program is distributed in the hope that it will be useful,
00015    but WITHOUT ANY WARRANTY; without even the implied warranty of
00016    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00017    GNU General Public License for more details.
00018    
00019    You should have received a copy of the GNU General Public License
00020    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
00021 
00022 /* As a special exception, you may create a larger work that contains
00023    part or all of the Bison parser skeleton and distribute that work
00024    under terms of your choice, so long as that work isn't itself a
00025    parser generator using the skeleton or a modified version thereof
00026    as a parser skeleton.  Alternatively, if you modify or redistribute
00027    the parser skeleton itself, you may (at your option) remove this
00028    special exception, which will cause the skeleton and the resulting
00029    Bison output files to be licensed under the GNU General Public
00030    License without this special exception.
00031    
00032    This special exception was added by the Free Software Foundation in
00033    version 2.2 of Bison.  */
00034 
00035 /* C LALR(1) parser skeleton written by Richard Stallman, by
00036    simplifying the original so-called "semantic" parser.  */
00037 
00038 /* All symbols defined below should begin with yy or YY, to avoid
00039    infringing on user name space.  This should be done even for local
00040    variables, as they might otherwise be expanded by user macros.
00041    There are some unavoidable exceptions within include files to
00042    define necessary library symbols; they are noted "INFRINGES ON
00043    USER NAME SPACE" below.  */
00044 
00045 /* Identify Bison output.  */
00046 #define YYBISON 1
00047 
00048 /* Bison version.  */
00049 #define YYBISON_VERSION "2.4.1"
00050 
00051 /* Skeleton name.  */
00052 #define YYSKELETON_NAME "yacc.c"
00053 
00054 /* Pure parsers.  */
00055 #define YYPURE 1
00056 
00057 /* Push parsers.  */
00058 #define YYPUSH 0
00059 
00060 /* Pull parsers.  */
00061 #define YYPULL 1
00062 
00063 /* Using locations.  */
00064 #define YYLSP_NEEDED 0
00065 
00066 /* Substitute the variable and function names.  */
00067 #define yyparse         ematch_parse
00068 #define yylex           ematch_lex
00069 #define yyerror         ematch_error
00070 #define yylval          ematch_lval
00071 #define yychar          ematch_char
00072 #define yydebug         ematch_debug
00073 #define yynerrs         ematch_nerrs
00074 
00075 
00076 /* Copy the first part of user declarations.  */
00077 
00078 /* Line 189 of yacc.c  */
00079 #line 12 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_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 #include <netlink/route/cls/ematch.h>
00087 #include <netlink/route/cls/ematch/cmp.h>
00088 #include <netlink/route/cls/ematch/nbyte.h>
00089 #include <netlink/route/cls/ematch/text.h>
00090 #include <netlink/route/cls/ematch/meta.h>
00091 
00092 #define META_ALLOC rtnl_meta_value_alloc_id
00093 #define META_ID(name) TCF_META_ID_##name
00094 #define META_INT TCF_META_TYPE_INT
00095 #define META_VAR TCF_META_TYPE_VAR
00096 
00097 
00098 /* Line 189 of yacc.c  */
00099 #line 100 "route/cls/ematch_syntax.c"
00100 
00101 /* Enabling traces.  */
00102 #ifndef YYDEBUG
00103 # define YYDEBUG 0
00104 #endif
00105 
00106 /* Enabling verbose error messages.  */
00107 #ifdef YYERROR_VERBOSE
00108 # undef YYERROR_VERBOSE
00109 # define YYERROR_VERBOSE 1
00110 #else
00111 # define YYERROR_VERBOSE 1
00112 #endif
00113 
00114 /* Enabling the token table.  */
00115 #ifndef YYTOKEN_TABLE
00116 # define YYTOKEN_TABLE 0
00117 #endif
00118 
00119 
00120 /* Tokens.  */
00121 #ifndef YYTOKENTYPE
00122 # define YYTOKENTYPE
00123    /* Put the tokens into the symbol table, so that GDB and other debuggers
00124       know about them.  */
00125    enum yytokentype {
00126      ERROR = 258,
00127      LOGIC = 259,
00128      NOT = 260,
00129      OPERAND = 261,
00130      NUMBER = 262,
00131      ALIGN = 263,
00132      LAYER = 264,
00133      KW_OPEN = 265,
00134      KW_CLOSE = 266,
00135      KW_PLUS = 267,
00136      KW_MASK = 268,
00137      KW_SHIFT = 269,
00138      KW_AT = 270,
00139      EMATCH_CMP = 271,
00140      EMATCH_NBYTE = 272,
00141      EMATCH_TEXT = 273,
00142      EMATCH_META = 274,
00143      KW_EQ = 275,
00144      KW_GT = 276,
00145      KW_LT = 277,
00146      KW_FROM = 278,
00147      KW_TO = 279,
00148      META_RANDOM = 280,
00149      META_LOADAVG_0 = 281,
00150      META_LOADAVG_1 = 282,
00151      META_LOADAVG_2 = 283,
00152      META_DEV = 284,
00153      META_PRIO = 285,
00154      META_PROTO = 286,
00155      META_PKTTYPE = 287,
00156      META_PKTLEN = 288,
00157      META_DATALEN = 289,
00158      META_MACLEN = 290,
00159      META_MARK = 291,
00160      META_TCINDEX = 292,
00161      META_RTCLASSID = 293,
00162      META_RTIIF = 294,
00163      META_SK_FAMILY = 295,
00164      META_SK_STATE = 296,
00165      META_SK_REUSE = 297,
00166      META_SK_REFCNT = 298,
00167      META_SK_RCVBUF = 299,
00168      META_SK_SNDBUF = 300,
00169      META_SK_SHUTDOWN = 301,
00170      META_SK_PROTO = 302,
00171      META_SK_TYPE = 303,
00172      META_SK_RMEM_ALLOC = 304,
00173      META_SK_WMEM_ALLOC = 305,
00174      META_SK_WMEM_QUEUED = 306,
00175      META_SK_RCV_QLEN = 307,
00176      META_SK_SND_QLEN = 308,
00177      META_SK_ERR_QLEN = 309,
00178      META_SK_FORWARD_ALLOCS = 310,
00179      META_SK_ALLOCS = 311,
00180      META_SK_ROUTE_CAPS = 312,
00181      META_SK_HASH = 313,
00182      META_SK_LINGERTIME = 314,
00183      META_SK_ACK_BACKLOG = 315,
00184      META_SK_MAX_ACK_BACKLOG = 316,
00185      META_SK_PRIO = 317,
00186      META_SK_RCVLOWAT = 318,
00187      META_SK_RCVTIMEO = 319,
00188      META_SK_SNDTIMEO = 320,
00189      META_SK_SENDMSG_OFF = 321,
00190      META_SK_WRITE_PENDING = 322,
00191      META_VLAN = 323,
00192      META_RXHASH = 324,
00193      META_DEVNAME = 325,
00194      META_SK_BOUND_IF = 326,
00195      STR = 327,
00196      QUOTED = 328
00197    };
00198 #endif
00199 /* Tokens.  */
00200 #define ERROR 258
00201 #define LOGIC 259
00202 #define NOT 260
00203 #define OPERAND 261
00204 #define NUMBER 262
00205 #define ALIGN 263
00206 #define LAYER 264
00207 #define KW_OPEN 265
00208 #define KW_CLOSE 266
00209 #define KW_PLUS 267
00210 #define KW_MASK 268
00211 #define KW_SHIFT 269
00212 #define KW_AT 270
00213 #define EMATCH_CMP 271
00214 #define EMATCH_NBYTE 272
00215 #define EMATCH_TEXT 273
00216 #define EMATCH_META 274
00217 #define KW_EQ 275
00218 #define KW_GT 276
00219 #define KW_LT 277
00220 #define KW_FROM 278
00221 #define KW_TO 279
00222 #define META_RANDOM 280
00223 #define META_LOADAVG_0 281
00224 #define META_LOADAVG_1 282
00225 #define META_LOADAVG_2 283
00226 #define META_DEV 284
00227 #define META_PRIO 285
00228 #define META_PROTO 286
00229 #define META_PKTTYPE 287
00230 #define META_PKTLEN 288
00231 #define META_DATALEN 289
00232 #define META_MACLEN 290
00233 #define META_MARK 291
00234 #define META_TCINDEX 292
00235 #define META_RTCLASSID 293
00236 #define META_RTIIF 294
00237 #define META_SK_FAMILY 295
00238 #define META_SK_STATE 296
00239 #define META_SK_REUSE 297
00240 #define META_SK_REFCNT 298
00241 #define META_SK_RCVBUF 299
00242 #define META_SK_SNDBUF 300
00243 #define META_SK_SHUTDOWN 301
00244 #define META_SK_PROTO 302
00245 #define META_SK_TYPE 303
00246 #define META_SK_RMEM_ALLOC 304
00247 #define META_SK_WMEM_ALLOC 305
00248 #define META_SK_WMEM_QUEUED 306
00249 #define META_SK_RCV_QLEN 307
00250 #define META_SK_SND_QLEN 308
00251 #define META_SK_ERR_QLEN 309
00252 #define META_SK_FORWARD_ALLOCS 310
00253 #define META_SK_ALLOCS 311
00254 #define META_SK_ROUTE_CAPS 312
00255 #define META_SK_HASH 313
00256 #define META_SK_LINGERTIME 314
00257 #define META_SK_ACK_BACKLOG 315
00258 #define META_SK_MAX_ACK_BACKLOG 316
00259 #define META_SK_PRIO 317
00260 #define META_SK_RCVLOWAT 318
00261 #define META_SK_RCVTIMEO 319
00262 #define META_SK_SNDTIMEO 320
00263 #define META_SK_SENDMSG_OFF 321
00264 #define META_SK_WRITE_PENDING 322
00265 #define META_VLAN 323
00266 #define META_RXHASH 324
00267 #define META_DEVNAME 325
00268 #define META_SK_BOUND_IF 326
00269 #define STR 327
00270 #define QUOTED 328
00271 
00272 
00273 
00274 
00275 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
00276 typedef union YYSTYPE
00277 {
00278 
00279 /* Line 214 of yacc.c  */
00280 #line 39 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
00281 
00282         struct tcf_em_cmp       cmp;
00283         struct ematch_quoted    q;
00284         struct rtnl_ematch *    e;
00285         struct rtnl_pktloc *    loc;
00286         struct rtnl_meta_value *mv;
00287         uint32_t                i;
00288         uint64_t                i64;
00289         char *                  s;
00290 
00291 
00292 
00293 /* Line 214 of yacc.c  */
00294 #line 295 "route/cls/ematch_syntax.c"
00295 } YYSTYPE;
00296 # define YYSTYPE_IS_TRIVIAL 1
00297 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
00298 # define YYSTYPE_IS_DECLARED 1
00299 #endif
00300 
00301 
00302 /* Copy the second part of user declarations.  */
00303 
00304 /* Line 264 of yacc.c  */
00305 #line 50 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
00306 
00307 extern int ematch_lex(YYSTYPE *, void *);
00308 
00309 static void yyerror(void *scanner, char **errp, struct nl_list_head *root, const char *msg)
00310 {
00311         if (msg)
00312                 asprintf(errp, "%s", msg);
00313 }
00314 
00315 
00316 /* Line 264 of yacc.c  */
00317 #line 318 "route/cls/ematch_syntax.c"
00318 
00319 #ifdef short
00320 # undef short
00321 #endif
00322 
00323 #ifdef YYTYPE_UINT8
00324 typedef YYTYPE_UINT8 yytype_uint8;
00325 #else
00326 typedef unsigned char yytype_uint8;
00327 #endif
00328 
00329 #ifdef YYTYPE_INT8
00330 typedef YYTYPE_INT8 yytype_int8;
00331 #elif (defined __STDC__ || defined __C99__FUNC__ \
00332      || defined __cplusplus || defined _MSC_VER)
00333 typedef signed char yytype_int8;
00334 #else
00335 typedef short int yytype_int8;
00336 #endif
00337 
00338 #ifdef YYTYPE_UINT16
00339 typedef YYTYPE_UINT16 yytype_uint16;
00340 #else
00341 typedef unsigned short int yytype_uint16;
00342 #endif
00343 
00344 #ifdef YYTYPE_INT16
00345 typedef YYTYPE_INT16 yytype_int16;
00346 #else
00347 typedef short int yytype_int16;
00348 #endif
00349 
00350 #ifndef YYSIZE_T
00351 # ifdef __SIZE_TYPE__
00352 #  define YYSIZE_T __SIZE_TYPE__
00353 # elif defined size_t
00354 #  define YYSIZE_T size_t
00355 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
00356      || defined __cplusplus || defined _MSC_VER)
00357 #  include <stddef.h> /* INFRINGES ON USER NAME SPACE */
00358 #  define YYSIZE_T size_t
00359 # else
00360 #  define YYSIZE_T unsigned int
00361 # endif
00362 #endif
00363 
00364 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
00365 
00366 #ifndef YY_
00367 # if YYENABLE_NLS
00368 #  if ENABLE_NLS
00369 #   include <libintl.h> /* INFRINGES ON USER NAME SPACE */
00370 #   define YY_(msgid) dgettext ("bison-runtime", msgid)
00371 #  endif
00372 # endif
00373 # ifndef YY_
00374 #  define YY_(msgid) msgid
00375 # endif
00376 #endif
00377 
00378 /* Suppress unused-variable warnings by "using" E.  */
00379 #if ! defined lint || defined __GNUC__
00380 # define YYUSE(e) ((void) (e))
00381 #else
00382 # define YYUSE(e) /* empty */
00383 #endif
00384 
00385 /* Identity function, used to suppress warnings about constant conditions.  */
00386 #ifndef lint
00387 # define YYID(n) (n)
00388 #else
00389 #if (defined __STDC__ || defined __C99__FUNC__ \
00390      || defined __cplusplus || defined _MSC_VER)
00391 static int
00392 YYID (int yyi)
00393 #else
00394 static int
00395 YYID (yyi)
00396     int yyi;
00397 #endif
00398 {
00399   return yyi;
00400 }
00401 #endif
00402 
00403 #if ! defined yyoverflow || YYERROR_VERBOSE
00404 
00405 /* The parser invokes alloca or malloc; define the necessary symbols.  */
00406 
00407 # ifdef YYSTACK_USE_ALLOCA
00408 #  if YYSTACK_USE_ALLOCA
00409 #   ifdef __GNUC__
00410 #    define YYSTACK_ALLOC __builtin_alloca
00411 #   elif defined __BUILTIN_VA_ARG_INCR
00412 #    include <alloca.h> /* INFRINGES ON USER NAME SPACE */
00413 #   elif defined _AIX
00414 #    define YYSTACK_ALLOC __alloca
00415 #   elif defined _MSC_VER
00416 #    include <malloc.h> /* INFRINGES ON USER NAME SPACE */
00417 #    define alloca _alloca
00418 #   else
00419 #    define YYSTACK_ALLOC alloca
00420 #    if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00421      || defined __cplusplus || defined _MSC_VER)
00422 #     include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00423 #     ifndef _STDLIB_H
00424 #      define _STDLIB_H 1
00425 #     endif
00426 #    endif
00427 #   endif
00428 #  endif
00429 # endif
00430 
00431 # ifdef YYSTACK_ALLOC
00432    /* Pacify GCC's `empty if-body' warning.  */
00433 #  define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
00434 #  ifndef YYSTACK_ALLOC_MAXIMUM
00435     /* The OS might guarantee only one guard page at the bottom of the stack,
00436        and a page size can be as small as 4096 bytes.  So we cannot safely
00437        invoke alloca (N) if N exceeds 4096.  Use a slightly smaller number
00438        to allow for a few compiler-allocated temporary stack slots.  */
00439 #   define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
00440 #  endif
00441 # else
00442 #  define YYSTACK_ALLOC YYMALLOC
00443 #  define YYSTACK_FREE YYFREE
00444 #  ifndef YYSTACK_ALLOC_MAXIMUM
00445 #   define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
00446 #  endif
00447 #  if (defined __cplusplus && ! defined _STDLIB_H \
00448        && ! ((defined YYMALLOC || defined malloc) \
00449              && (defined YYFREE || defined free)))
00450 #   include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
00451 #   ifndef _STDLIB_H
00452 #    define _STDLIB_H 1
00453 #   endif
00454 #  endif
00455 #  ifndef YYMALLOC
00456 #   define YYMALLOC malloc
00457 #   if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00458      || defined __cplusplus || defined _MSC_VER)
00459 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
00460 #   endif
00461 #  endif
00462 #  ifndef YYFREE
00463 #   define YYFREE free
00464 #   if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
00465      || defined __cplusplus || defined _MSC_VER)
00466 void free (void *); /* INFRINGES ON USER NAME SPACE */
00467 #   endif
00468 #  endif
00469 # endif
00470 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
00471 
00472 
00473 #if (! defined yyoverflow \
00474      && (! defined __cplusplus \
00475          || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
00476 
00477 /* A type that is properly aligned for any stack member.  */
00478 union yyalloc
00479 {
00480   yytype_int16 yyss_alloc;
00481   YYSTYPE yyvs_alloc;
00482 };
00483 
00484 /* The size of the maximum gap between one aligned stack and the next.  */
00485 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
00486 
00487 /* The size of an array large to enough to hold all stacks, each with
00488    N elements.  */
00489 # define YYSTACK_BYTES(N) \
00490      ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
00491       + YYSTACK_GAP_MAXIMUM)
00492 
00493 /* Copy COUNT objects from FROM to TO.  The source and destination do
00494    not overlap.  */
00495 # ifndef YYCOPY
00496 #  if defined __GNUC__ && 1 < __GNUC__
00497 #   define YYCOPY(To, From, Count) \
00498       __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
00499 #  else
00500 #   define YYCOPY(To, From, Count)              \
00501       do                                        \
00502         {                                       \
00503           YYSIZE_T yyi;                         \
00504           for (yyi = 0; yyi < (Count); yyi++)   \
00505             (To)[yyi] = (From)[yyi];            \
00506         }                                       \
00507       while (YYID (0))
00508 #  endif
00509 # endif
00510 
00511 /* Relocate STACK from its old location to the new one.  The
00512    local variables YYSIZE and YYSTACKSIZE give the old and new number of
00513    elements in the stack, and YYPTR gives the new location of the
00514    stack.  Advance YYPTR to a properly aligned location for the next
00515    stack.  */
00516 # define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
00517     do                                                                  \
00518       {                                                                 \
00519         YYSIZE_T yynewbytes;                                            \
00520         YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
00521         Stack = &yyptr->Stack_alloc;                                    \
00522         yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
00523         yyptr += yynewbytes / sizeof (*yyptr);                          \
00524       }                                                                 \
00525     while (YYID (0))
00526 
00527 #endif
00528 
00529 /* YYFINAL -- State number of the termination state.  */
00530 #define YYFINAL  26
00531 /* YYLAST -- Last index in YYTABLE.  */
00532 #define YYLAST   138
00533 
00534 /* YYNTOKENS -- Number of terminals.  */
00535 #define YYNTOKENS  74
00536 /* YYNNTS -- Number of nonterminals.  */
00537 #define YYNNTS  18
00538 /* YYNRULES -- Number of rules.  */
00539 #define YYNRULES  84
00540 /* YYNRULES -- Number of states.  */
00541 #define YYNSTATES  118
00542 
00543 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX.  */
00544 #define YYUNDEFTOK  2
00545 #define YYMAXUTOK   328
00546 
00547 #define YYTRANSLATE(YYX)                                                \
00548   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
00549 
00550 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX.  */
00551 static const yytype_uint8 yytranslate[] =
00552 {
00553        0,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00554        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00555        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00556        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00557        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00558        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00559        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00560        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00561        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00562        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00563        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00564        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00565        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00566        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00567        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00568        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00569        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00570        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00571        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00572        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00573        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00574        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00575        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00576        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00577        2,     2,     2,     2,     2,     2,     2,     2,     2,     2,
00578        2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
00579        5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
00580       15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
00581       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
00582       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
00583       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
00584       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
00585       65,    66,    67,    68,    69,    70,    71,    72,    73
00586 };
00587 
00588 #if YYDEBUG
00589 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
00590    YYRHS.  */
00591 static const yytype_uint8 yyprhs[] =
00592 {
00593        0,     0,     3,     4,     6,     8,    12,    15,    17,    19,
00594       26,    34,    41,    45,    50,    52,    56,    57,    60,    61,
00595       64,    66,    68,    72,    75,    77,    79,    81,    83,    85,
00596       87,    89,    91,    93,    95,    97,    99,   101,   103,   105,
00597      107,   109,   111,   113,   115,   117,   119,   121,   123,   125,
00598      127,   129,   131,   133,   135,   137,   139,   141,   143,   145,
00599      147,   149,   151,   153,   155,   157,   159,   161,   163,   165,
00600      167,   169,   171,   173,   175,   181,   182,   185,   188,   189,
00601      192,   193,   196,   198,   200
00602 };
00603 
00604 /* YYRHS -- A `-1'-separated list of the rules' RHS.  */
00605 static const yytype_int8 yyrhs[] =
00606 {
00607       75,     0,    -1,    -1,    76,    -1,    77,    -1,    77,     4,
00608       76,    -1,     5,    78,    -1,    78,    -1,    79,    -1,    17,
00609       10,    87,    20,    86,    11,    -1,    18,    10,    72,    73,
00610       81,    82,    11,    -1,    19,    10,    83,    91,    83,    11,
00611       -1,    10,    76,    11,    -1,    16,    10,    80,    11,    -1,
00612       80,    -1,    87,    91,     7,    -1,    -1,    23,    87,    -1,
00613       -1,    24,    87,    -1,    73,    -1,     7,    -1,    84,    90,
00614       89,    -1,    85,    90,    -1,    25,    -1,    26,    -1,    27,
00615       -1,    28,    -1,    29,    -1,    30,    -1,    31,    -1,    32,
00616       -1,    33,    -1,    34,    -1,    35,    -1,    36,    -1,    37,
00617       -1,    38,    -1,    39,    -1,    40,    -1,    41,    -1,    42,
00618       -1,    43,    -1,    44,    -1,    45,    -1,    46,    -1,    47,
00619       -1,    48,    -1,    49,    -1,    50,    -1,    51,    -1,    52,
00620       -1,    53,    -1,    54,    -1,    55,    -1,    56,    -1,    57,
00621       -1,    58,    -1,    59,    -1,    60,    -1,    61,    -1,    62,
00622       -1,    63,    -1,    64,    -1,    65,    -1,    66,    -1,    67,
00623       -1,    68,    -1,    69,    -1,    70,    -1,    71,    -1,    73,
00624       -1,    72,    -1,    72,    -1,    88,     9,    12,     7,    89,
00625       -1,    -1,     8,    15,    -1,     7,    15,    -1,    -1,    13,
00626        7,    -1,    -1,    14,     7,    -1,    20,    -1,    21,    -1,
00627       22,    -1
00628 };
00629 
00630 /* YYRLINE[YYN] -- source line where rule number YYN was defined.  */
00631 static const yytype_uint16 yyrline[] =
00632 {
00633        0,   146,   146,   148,   155,   159,   171,   176,   184,   199,
00634      217,   244,   263,   291,   293,   298,   319,   320,   326,   327,
00635      332,   334,   336,   338,   343,   344,   345,   346,   347,   348,
00636      349,   350,   351,   352,   353,   354,   355,   356,   357,   358,
00637      359,   360,   361,   362,   363,   364,   365,   366,   367,   368,
00638      369,   370,   371,   372,   373,   374,   375,   376,   377,   378,
00639      379,   380,   381,   382,   383,   384,   385,   386,   387,   391,
00640      392,   399,   403,   431,   443,   469,   470,   472,   478,   479,
00641      485,   486,   491,   493,   495
00642 };
00643 #endif
00644 
00645 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
00646 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
00647    First, the terminals, then, starting at YYNTOKENS, nonterminals.  */
00648 static const char *const yytname[] =
00649 {
00650   "$end", "error", "$undefined", "ERROR", "LOGIC", "NOT", "OPERAND",
00651   "NUMBER", "ALIGN", "LAYER", "\"(\"", "\")\"", "\"+\"", "\"mask\"",
00652   "\">>\"", "\"at\"", "\"cmp\"", "\"pattern\"", "\"text\"", "\"meta\"",
00653   "\"=\"", "\">\"", "\"<\"", "\"from\"", "\"to\"", "\"random\"",
00654   "\"loadavg_0\"", "\"loadavg_1\"", "\"loadavg_2\"", "\"dev\"", "\"prio\"",
00655   "\"proto\"", "\"pkttype\"", "\"pktlen\"", "\"datalen\"", "\"maclen\"",
00656   "\"mark\"", "\"tcindex\"", "\"rtclassid\"", "\"rtiif\"", "\"sk_family\"",
00657   "\"sk_state\"", "\"sk_reuse\"", "\"sk_refcnt\"", "\"sk_rcvbuf\"",
00658   "\"sk_sndbuf\"", "\"sk_shutdown\"", "\"sk_proto\"", "\"sk_type\"",
00659   "\"sk_rmem_alloc\"", "\"sk_wmem_alloc\"", "\"sk_wmem_queued\"",
00660   "\"sk_rcv_qlen\"", "\"sk_snd_qlen\"", "\"sk_err_qlen\"",
00661   "\"sk_forward_allocs\"", "\"sk_allocs\"", "\"sk_route_caps\"",
00662   "\"sk_hash\"", "\"sk_lingertime\"", "\"sk_ack_backlog\"",
00663   "\"sk_max_ack_backlog\"", "\"sk_prio\"", "\"sk_rcvlowat\"",
00664   "\"sk_rcvtimeo\"", "\"sk_sndtimeo\"", "\"sk_sendmsg_off\"",
00665   "\"sk_write_pending\"", "\"vlan\"", "\"rxhash\"", "\"devname\"",
00666   "\"sk_bound_if\"", "STR", "QUOTED", "$accept", "input", "expr", "match",
00667   "ematch", "cmp_match", "cmp_expr", "text_from", "text_to", "meta_value",
00668   "meta_int_id", "meta_var_id", "pattern", "pktloc", "align", "mask",
00669   "shift", "operand", 0
00670 };
00671 #endif
00672 
00673 # ifdef YYPRINT
00674 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
00675    token YYLEX-NUM.  */
00676 static const yytype_uint16 yytoknum[] =
00677 {
00678        0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
00679      265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
00680      275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
00681      285,   286,   287,   288,   289,   290,   291,   292,   293,   294,
00682      295,   296,   297,   298,   299,   300,   301,   302,   303,   304,
00683      305,   306,   307,   308,   309,   310,   311,   312,   313,   314,
00684      315,   316,   317,   318,   319,   320,   321,   322,   323,   324,
00685      325,   326,   327,   328
00686 };
00687 # endif
00688 
00689 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
00690 static const yytype_uint8 yyr1[] =
00691 {
00692        0,    74,    75,    75,    76,    76,    77,    77,    78,    78,
00693       78,    78,    78,    79,    79,    80,    81,    81,    82,    82,
00694       83,    83,    83,    83,    84,    84,    84,    84,    84,    84,
00695       84,    84,    84,    84,    84,    84,    84,    84,    84,    84,
00696       84,    84,    84,    84,    84,    84,    84,    84,    84,    84,
00697       84,    84,    84,    84,    84,    84,    84,    84,    84,    84,
00698       84,    84,    84,    84,    84,    84,    84,    84,    84,    85,
00699       85,    86,    86,    87,    87,    88,    88,    88,    89,    89,
00700       90,    90,    91,    91,    91
00701 };
00702 
00703 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN.  */
00704 static const yytype_uint8 yyr2[] =
00705 {
00706        0,     2,     0,     1,     1,     3,     2,     1,     1,     6,
00707        7,     6,     3,     4,     1,     3,     0,     2,     0,     2,
00708        1,     1,     3,     2,     1,     1,     1,     1,     1,     1,
00709        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
00710        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
00711        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
00712        1,     1,     1,     1,     1,     1,     1,     1,     1,     1,
00713        1,     1,     1,     1,     5,     0,     2,     2,     0,     2,
00714        0,     2,     1,     1,     1
00715 };
00716 
00717 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
00718    STATE-NUM when YYTABLE doesn't specify something else to do.  Zero
00719    means the default is an error.  */
00720 static const yytype_uint8 yydefact[] =
00721 {
00722        2,    75,     0,     0,    75,     0,     0,     0,     0,    73,
00723        0,     3,     4,     7,     8,    14,     0,     0,     6,    77,
00724       76,     0,    75,    75,     0,     0,     1,    75,    82,    83,
00725       84,     0,     0,    12,     0,     0,     0,    21,    24,    25,
00726       26,    27,    28,    29,    30,    31,    32,    33,    34,    35,
00727       36,    37,    38,    39,    40,    41,    42,    43,    44,    45,
00728       46,    47,    48,    49,    50,    51,    52,    53,    54,    55,
00729       56,    57,    58,    59,    60,    61,    62,    63,    64,    65,
00730       66,    67,    68,    69,    70,    20,     0,    80,    80,     5,
00731       15,     0,    13,     0,    16,     0,     0,    78,    23,    78,
00732       72,    71,     0,    75,    18,     0,    81,     0,    22,    74,
00733        9,    17,    75,     0,    11,    79,    19,    10
00734 };
00735 
00736 /* YYDEFGOTO[NTERM-NUM].  */
00737 static const yytype_int8 yydefgoto[] =
00738 {
00739       -1,    10,    11,    12,    13,    14,    15,   104,   113,    86,
00740       87,    88,   102,    16,    17,   108,    97,    31
00741 };
00742 
00743 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
00744    STATE-NUM.  */
00745 #define YYPACT_NINF -63
00746 static const yytype_int8 yypact[] =
00747 {
00748       -4,    15,   -13,    -8,    11,    10,    14,    25,    29,   -63,
00749       26,   -63,    37,   -63,   -63,   -63,    16,    33,   -63,   -63,
00750      -63,    32,     1,     1,   -28,    65,   -63,    11,   -63,   -63,
00751      -63,    38,    34,   -63,    36,    28,   -24,   -63,   -63,   -63,
00752      -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,
00753      -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,
00754      -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,
00755      -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,   -63,
00756      -63,   -63,   -63,   -63,   -63,   -63,    16,    39,    39,   -63,
00757      -63,    43,   -63,   -62,    31,    65,    44,    42,   -63,    42,
00758      -63,   -63,    41,     1,    35,    45,   -63,    50,   -63,   -63,
00759      -63,   -63,     1,    47,   -63,   -63,   -63,   -63
00760 };
00761 
00762 /* YYPGOTO[NTERM-NUM].  */
00763 static const yytype_int8 yypgoto[] =
00764 {
00765      -63,   -63,    13,   -63,    59,   -63,    40,   -63,   -63,   -34,
00766      -63,   -63,   -63,   -23,   -63,   -36,   -22,   -21
00767 };
00768 
00769 /* YYTABLE[YYPACT[STATE-NUM]].  What to do in state STATE-NUM.  If
00770    positive, shift that token.  If negative, reduce the rule which
00771    number is the opposite.  If zero, do what YYDEFACT says.
00772    If YYTABLE_NINF, syntax error.  */
00773 #define YYTABLE_NINF -76
00774 static const yytype_int8 yytable[] =
00775 {
00776       35,     1,    19,     2,     3,   -75,     4,    20,     2,     3,
00777      100,   101,     5,     6,     7,     8,     1,    21,     2,     3,
00778       22,     4,     2,     3,    23,     4,    26,     5,     6,     7,
00779        8,     5,     6,     7,     8,    24,    28,    29,    30,    25,
00780       89,    27,    32,    33,    36,    90,    91,    92,    93,    94,
00781       99,   106,   110,    96,   103,   107,   114,   115,   117,   112,
00782       18,   105,    34,   109,     0,    95,    98,     0,     9,     0,
00783        0,     0,    37,     9,     0,     0,     0,     0,     0,     0,
00784      111,     0,     0,     9,     0,     0,     0,     9,     0,   116,
00785       38,    39,    40,    41,    42,    43,    44,    45,    46,    47,
00786       48,    49,    50,    51,    52,    53,    54,    55,    56,    57,
00787       58,    59,    60,    61,    62,    63,    64,    65,    66,    67,
00788       68,    69,    70,    71,    72,    73,    74,    75,    76,    77,
00789       78,    79,    80,    81,    82,    83,    84,     0,    85
00790 };
00791 
00792 static const yytype_int8 yycheck[] =
00793 {
00794       23,     5,    15,     7,     8,     9,    10,    15,     7,     8,
00795       72,    73,    16,    17,    18,    19,     5,     4,     7,     8,
00796       10,    10,     7,     8,    10,    10,     0,    16,    17,    18,
00797       19,    16,    17,    18,    19,    10,    20,    21,    22,    10,
00798       27,     4,     9,    11,    72,     7,    12,    11,    20,    73,
00799        7,     7,    11,    14,    23,    13,    11,     7,    11,    24,
00800        1,    95,    22,    99,    -1,    86,    88,    -1,    72,    -1,
00801       -1,    -1,     7,    72,    -1,    -1,    -1,    -1,    -1,    -1,
00802      103,    -1,    -1,    72,    -1,    -1,    -1,    72,    -1,   112,
00803       25,    26,    27,    28,    29,    30,    31,    32,    33,    34,
00804       35,    36,    37,    38,    39,    40,    41,    42,    43,    44,
00805       45,    46,    47,    48,    49,    50,    51,    52,    53,    54,
00806       55,    56,    57,    58,    59,    60,    61,    62,    63,    64,
00807       65,    66,    67,    68,    69,    70,    71,    -1,    73
00808 };
00809 
00810 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
00811    symbol of state STATE-NUM.  */
00812 static const yytype_uint8 yystos[] =
00813 {
00814        0,     5,     7,     8,    10,    16,    17,    18,    19,    72,
00815       75,    76,    77,    78,    79,    80,    87,    88,    78,    15,
00816       15,    76,    10,    10,    10,    10,     0,     4,    20,    21,
00817       22,    91,     9,    11,    80,    87,    72,     7,    25,    26,
00818       27,    28,    29,    30,    31,    32,    33,    34,    35,    36,
00819       37,    38,    39,    40,    41,    42,    43,    44,    45,    46,
00820       47,    48,    49,    50,    51,    52,    53,    54,    55,    56,
00821       57,    58,    59,    60,    61,    62,    63,    64,    65,    66,
00822       67,    68,    69,    70,    71,    73,    83,    84,    85,    76,
00823        7,    12,    11,    20,    73,    91,    14,    90,    90,     7,
00824       72,    73,    86,    23,    81,    83,     7,    13,    89,    89,
00825       11,    87,    24,    82,    11,     7,    87,    11
00826 };
00827 
00828 #define yyerrok         (yyerrstatus = 0)
00829 #define yyclearin       (yychar = YYEMPTY)
00830 #define YYEMPTY         (-2)
00831 #define YYEOF           0
00832 
00833 #define YYACCEPT        goto yyacceptlab
00834 #define YYABORT         goto yyabortlab
00835 #define YYERROR         goto yyerrorlab
00836 
00837 
00838 /* Like YYERROR except do call yyerror.  This remains here temporarily
00839    to ease the transition to the new meaning of YYERROR, for GCC.
00840    Once GCC version 2 has supplanted version 1, this can go.  */
00841 
00842 #define YYFAIL          goto yyerrlab
00843 
00844 #define YYRECOVERING()  (!!yyerrstatus)
00845 
00846 #define YYBACKUP(Token, Value)                                  \
00847 do                                                              \
00848   if (yychar == YYEMPTY && yylen == 1)                          \
00849     {                                                           \
00850       yychar = (Token);                                         \
00851       yylval = (Value);                                         \
00852       yytoken = YYTRANSLATE (yychar);                           \
00853       YYPOPSTACK (1);                                           \
00854       goto yybackup;                                            \
00855     }                                                           \
00856   else                                                          \
00857     {                                                           \
00858       yyerror (scanner, errp, root, YY_("syntax error: cannot back up")); \
00859       YYERROR;                                                  \
00860     }                                                           \
00861 while (YYID (0))
00862 
00863 
00864 #define YYTERROR        1
00865 #define YYERRCODE       256
00866 
00867 
00868 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
00869    If N is 0, then set CURRENT to the empty location which ends
00870    the previous symbol: RHS[0] (always defined).  */
00871 
00872 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
00873 #ifndef YYLLOC_DEFAULT
00874 # define YYLLOC_DEFAULT(Current, Rhs, N)                                \
00875     do                                                                  \
00876       if (YYID (N))                                                    \
00877         {                                                               \
00878           (Current).first_line   = YYRHSLOC (Rhs, 1).first_line;        \
00879           (Current).first_column = YYRHSLOC (Rhs, 1).first_column;      \
00880           (Current).last_line    = YYRHSLOC (Rhs, N).last_line;         \
00881           (Current).last_column  = YYRHSLOC (Rhs, N).last_column;       \
00882         }                                                               \
00883       else                                                              \
00884         {                                                               \
00885           (Current).first_line   = (Current).last_line   =              \
00886             YYRHSLOC (Rhs, 0).last_line;                                \
00887           (Current).first_column = (Current).last_column =              \
00888             YYRHSLOC (Rhs, 0).last_column;                              \
00889         }                                                               \
00890     while (YYID (0))
00891 #endif
00892 
00893 
00894 /* YY_LOCATION_PRINT -- Print the location on the stream.
00895    This macro was not mandated originally: define only if we know
00896    we won't break user code: when these are the locations we know.  */
00897 
00898 #ifndef YY_LOCATION_PRINT
00899 # if YYLTYPE_IS_TRIVIAL
00900 #  define YY_LOCATION_PRINT(File, Loc)                  \
00901      fprintf (File, "%d.%d-%d.%d",                      \
00902               (Loc).first_line, (Loc).first_column,     \
00903               (Loc).last_line,  (Loc).last_column)
00904 # else
00905 #  define YY_LOCATION_PRINT(File, Loc) ((void) 0)
00906 # endif
00907 #endif
00908 
00909 
00910 /* YYLEX -- calling `yylex' with the right arguments.  */
00911 
00912 #ifdef YYLEX_PARAM
00913 # define YYLEX yylex (&yylval, YYLEX_PARAM)
00914 #else
00915 # define YYLEX yylex (&yylval, scanner)
00916 #endif
00917 
00918 /* Enable debugging if requested.  */
00919 #if YYDEBUG
00920 
00921 # ifndef YYFPRINTF
00922 #  include <stdio.h> /* INFRINGES ON USER NAME SPACE */
00923 #  define YYFPRINTF fprintf
00924 # endif
00925 
00926 # define YYDPRINTF(Args)                        \
00927 do {                                            \
00928   if (yydebug)                                  \
00929     YYFPRINTF Args;                             \
00930 } while (YYID (0))
00931 
00932 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)                    \
00933 do {                                                                      \
00934   if (yydebug)                                                            \
00935     {                                                                     \
00936       YYFPRINTF (stderr, "%s ", Title);                                   \
00937       yy_symbol_print (stderr,                                            \
00938                   Type, Value, scanner, errp, root); \
00939       YYFPRINTF (stderr, "\n");                                           \
00940     }                                                                     \
00941 } while (YYID (0))
00942 
00943 
00944 /*--------------------------------.
00945 | Print this symbol on YYOUTPUT.  |
00946 `--------------------------------*/
00947 
00948 /*ARGSUSED*/
00949 #if (defined __STDC__ || defined __C99__FUNC__ \
00950      || defined __cplusplus || defined _MSC_VER)
00951 static void
00952 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, void *scanner, char **errp, struct nl_list_head *root)
00953 #else
00954 static void
00955 yy_symbol_value_print (yyoutput, yytype, yyvaluep, scanner, errp, root)
00956     FILE *yyoutput;
00957     int yytype;
00958     YYSTYPE const * const yyvaluep;
00959     void *scanner;
00960     char **errp;
00961     struct nl_list_head *root;
00962 #endif
00963 {
00964   if (!yyvaluep)
00965     return;
00966   YYUSE (scanner);
00967   YYUSE (errp);
00968   YYUSE (root);
00969 # ifdef YYPRINT
00970   if (yytype < YYNTOKENS)
00971     YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
00972 # else
00973   YYUSE (yyoutput);
00974 # endif
00975   switch (yytype)
00976     {
00977       default:
00978         break;
00979     }
00980 }
00981 
00982 
00983 /*--------------------------------.
00984 | Print this symbol on YYOUTPUT.  |
00985 `--------------------------------*/
00986 
00987 #if (defined __STDC__ || defined __C99__FUNC__ \
00988      || defined __cplusplus || defined _MSC_VER)
00989 static void
00990 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep, void *scanner, char **errp, struct nl_list_head *root)
00991 #else
00992 static void
00993 yy_symbol_print (yyoutput, yytype, yyvaluep, scanner, errp, root)
00994     FILE *yyoutput;
00995     int yytype;
00996     YYSTYPE const * const yyvaluep;
00997     void *scanner;
00998     char **errp;
00999     struct nl_list_head *root;
01000 #endif
01001 {
01002   if (yytype < YYNTOKENS)
01003     YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
01004   else
01005     YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
01006 
01007   yy_symbol_value_print (yyoutput, yytype, yyvaluep, scanner, errp, root);
01008   YYFPRINTF (yyoutput, ")");
01009 }
01010 
01011 /*------------------------------------------------------------------.
01012 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
01013 | TOP (included).                                                   |
01014 `------------------------------------------------------------------*/
01015 
01016 #if (defined __STDC__ || defined __C99__FUNC__ \
01017      || defined __cplusplus || defined _MSC_VER)
01018 static void
01019 yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
01020 #else
01021 static void
01022 yy_stack_print (yybottom, yytop)
01023     yytype_int16 *yybottom;
01024     yytype_int16 *yytop;
01025 #endif
01026 {
01027   YYFPRINTF (stderr, "Stack now");
01028   for (; yybottom <= yytop; yybottom++)
01029     {
01030       int yybot = *yybottom;
01031       YYFPRINTF (stderr, " %d", yybot);
01032     }
01033   YYFPRINTF (stderr, "\n");
01034 }
01035 
01036 # define YY_STACK_PRINT(Bottom, Top)                            \
01037 do {                                                            \
01038   if (yydebug)                                                  \
01039     yy_stack_print ((Bottom), (Top));                           \
01040 } while (YYID (0))
01041 
01042 
01043 /*------------------------------------------------.
01044 | Report that the YYRULE is going to be reduced.  |
01045 `------------------------------------------------*/
01046 
01047 #if (defined __STDC__ || defined __C99__FUNC__ \
01048      || defined __cplusplus || defined _MSC_VER)
01049 static void
01050 yy_reduce_print (YYSTYPE *yyvsp, int yyrule, void *scanner, char **errp, struct nl_list_head *root)
01051 #else
01052 static void
01053 yy_reduce_print (yyvsp, yyrule, scanner, errp, root)
01054     YYSTYPE *yyvsp;
01055     int yyrule;
01056     void *scanner;
01057     char **errp;
01058     struct nl_list_head *root;
01059 #endif
01060 {
01061   int yynrhs = yyr2[yyrule];
01062   int yyi;
01063   unsigned long int yylno = yyrline[yyrule];
01064   YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
01065              yyrule - 1, yylno);
01066   /* The symbols being reduced.  */
01067   for (yyi = 0; yyi < yynrhs; yyi++)
01068     {
01069       YYFPRINTF (stderr, "   $%d = ", yyi + 1);
01070       yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
01071                        &(yyvsp[(yyi + 1) - (yynrhs)])
01072                                        , scanner, errp, root);
01073       YYFPRINTF (stderr, "\n");
01074     }
01075 }
01076 
01077 # define YY_REDUCE_PRINT(Rule)          \
01078 do {                                    \
01079   if (yydebug)                          \
01080     yy_reduce_print (yyvsp, Rule, scanner, errp, root); \
01081 } while (YYID (0))
01082 
01083 /* Nonzero means print parse trace.  It is left uninitialized so that
01084    multiple parsers can coexist.  */
01085 int yydebug;
01086 #else /* !YYDEBUG */
01087 # define YYDPRINTF(Args)
01088 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
01089 # define YY_STACK_PRINT(Bottom, Top)
01090 # define YY_REDUCE_PRINT(Rule)
01091 #endif /* !YYDEBUG */
01092 
01093 
01094 /* YYINITDEPTH -- initial size of the parser's stacks.  */
01095 #ifndef YYINITDEPTH
01096 # define YYINITDEPTH 200
01097 #endif
01098 
01099 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
01100    if the built-in stack extension method is used).
01101 
01102    Do not make this value too large; the results are undefined if
01103    YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
01104    evaluated with infinite-precision integer arithmetic.  */
01105 
01106 #ifndef YYMAXDEPTH
01107 # define YYMAXDEPTH 10000
01108 #endif
01109 
01110 
01111 
01112 #if YYERROR_VERBOSE
01113 
01114 # ifndef yystrlen
01115 #  if defined __GLIBC__ && defined _STRING_H
01116 #   define yystrlen strlen
01117 #  else
01118 /* Return the length of YYSTR.  */
01119 #if (defined __STDC__ || defined __C99__FUNC__ \
01120      || defined __cplusplus || defined _MSC_VER)
01121 static YYSIZE_T
01122 yystrlen (const char *yystr)
01123 #else
01124 static YYSIZE_T
01125 yystrlen (yystr)
01126     const char *yystr;
01127 #endif
01128 {
01129   YYSIZE_T yylen;
01130   for (yylen = 0; yystr[yylen]; yylen++)
01131     continue;
01132   return yylen;
01133 }
01134 #  endif
01135 # endif
01136 
01137 # ifndef yystpcpy
01138 #  if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
01139 #   define yystpcpy stpcpy
01140 #  else
01141 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
01142    YYDEST.  */
01143 #if (defined __STDC__ || defined __C99__FUNC__ \
01144      || defined __cplusplus || defined _MSC_VER)
01145 static char *
01146 yystpcpy (char *yydest, const char *yysrc)
01147 #else
01148 static char *
01149 yystpcpy (yydest, yysrc)
01150     char *yydest;
01151     const char *yysrc;
01152 #endif
01153 {
01154   char *yyd = yydest;
01155   const char *yys = yysrc;
01156 
01157   while ((*yyd++ = *yys++) != '\0')
01158     continue;
01159 
01160   return yyd - 1;
01161 }
01162 #  endif
01163 # endif
01164 
01165 # ifndef yytnamerr
01166 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
01167    quotes and backslashes, so that it's suitable for yyerror.  The
01168    heuristic is that double-quoting is unnecessary unless the string
01169    contains an apostrophe, a comma, or backslash (other than
01170    backslash-backslash).  YYSTR is taken from yytname.  If YYRES is
01171    null, do not copy; instead, return the length of what the result
01172    would have been.  */
01173 static YYSIZE_T
01174 yytnamerr (char *yyres, const char *yystr)
01175 {
01176   if (*yystr == '"')
01177     {
01178       YYSIZE_T yyn = 0;
01179       char const *yyp = yystr;
01180 
01181       for (;;)
01182         switch (*++yyp)
01183           {
01184           case '\'':
01185           case ',':
01186             goto do_not_strip_quotes;
01187 
01188           case '\\':
01189             if (*++yyp != '\\')
01190               goto do_not_strip_quotes;
01191             /* Fall through.  */
01192           default:
01193             if (yyres)
01194               yyres[yyn] = *yyp;
01195             yyn++;
01196             break;
01197 
01198           case '"':
01199             if (yyres)
01200               yyres[yyn] = '\0';
01201             return yyn;
01202           }
01203     do_not_strip_quotes: ;
01204     }
01205 
01206   if (! yyres)
01207     return yystrlen (yystr);
01208 
01209   return yystpcpy (yyres, yystr) - yyres;
01210 }
01211 # endif
01212 
01213 /* Copy into YYRESULT an error message about the unexpected token
01214    YYCHAR while in state YYSTATE.  Return the number of bytes copied,
01215    including the terminating null byte.  If YYRESULT is null, do not
01216    copy anything; just return the number of bytes that would be
01217    copied.  As a special case, return 0 if an ordinary "syntax error"
01218    message will do.  Return YYSIZE_MAXIMUM if overflow occurs during
01219    size calculation.  */
01220 static YYSIZE_T
01221 yysyntax_error (char *yyresult, int yystate, int yychar)
01222 {
01223   int yyn = yypact[yystate];
01224 
01225   if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
01226     return 0;
01227   else
01228     {
01229       int yytype = YYTRANSLATE (yychar);
01230       YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
01231       YYSIZE_T yysize = yysize0;
01232       YYSIZE_T yysize1;
01233       int yysize_overflow = 0;
01234       enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
01235       char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
01236       int yyx;
01237 
01238 # if 0
01239       /* This is so xgettext sees the translatable formats that are
01240          constructed on the fly.  */
01241       YY_("syntax error, unexpected %s");
01242       YY_("syntax error, unexpected %s, expecting %s");
01243       YY_("syntax error, unexpected %s, expecting %s or %s");
01244       YY_("syntax error, unexpected %s, expecting %s or %s or %s");
01245       YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
01246 # endif
01247       char *yyfmt;
01248       char const *yyf;
01249       static char const yyunexpected[] = "syntax error, unexpected %s";
01250       static char const yyexpecting[] = ", expecting %s";
01251       static char const yyor[] = " or %s";
01252       char yyformat[sizeof yyunexpected
01253                     + sizeof yyexpecting - 1
01254                     + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
01255                        * (sizeof yyor - 1))];
01256       char const *yyprefix = yyexpecting;
01257 
01258       /* Start YYX at -YYN if negative to avoid negative indexes in
01259          YYCHECK.  */
01260       int yyxbegin = yyn < 0 ? -yyn : 0;
01261 
01262       /* Stay within bounds of both yycheck and yytname.  */
01263       int yychecklim = YYLAST - yyn + 1;
01264       int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
01265       int yycount = 1;
01266 
01267       yyarg[0] = yytname[yytype];
01268       yyfmt = yystpcpy (yyformat, yyunexpected);
01269 
01270       for (yyx = yyxbegin; yyx < yyxend; ++yyx)
01271         if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
01272           {
01273             if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
01274               {
01275                 yycount = 1;
01276                 yysize = yysize0;
01277                 yyformat[sizeof yyunexpected - 1] = '\0';
01278                 break;
01279               }
01280             yyarg[yycount++] = yytname[yyx];
01281             yysize1 = yysize + yytnamerr (0, yytname[yyx]);
01282             yysize_overflow |= (yysize1 < yysize);
01283             yysize = yysize1;
01284             yyfmt = yystpcpy (yyfmt, yyprefix);
01285             yyprefix = yyor;
01286           }
01287 
01288       yyf = YY_(yyformat);
01289       yysize1 = yysize + yystrlen (yyf);
01290       yysize_overflow |= (yysize1 < yysize);
01291       yysize = yysize1;
01292 
01293       if (yysize_overflow)
01294         return YYSIZE_MAXIMUM;
01295 
01296       if (yyresult)
01297         {
01298           /* Avoid sprintf, as that infringes on the user's name space.
01299              Don't have undefined behavior even if the translation
01300              produced a string with the wrong number of "%s"s.  */
01301           char *yyp = yyresult;
01302           int yyi = 0;
01303           while ((*yyp = *yyf) != '\0')
01304             {
01305               if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
01306                 {
01307                   yyp += yytnamerr (yyp, yyarg[yyi++]);
01308                   yyf += 2;
01309                 }
01310               else
01311                 {
01312                   yyp++;
01313                   yyf++;
01314                 }
01315             }
01316         }
01317       return yysize;
01318     }
01319 }
01320 #endif /* YYERROR_VERBOSE */
01321 
01322 
01323 /*-----------------------------------------------.
01324 | Release the memory associated to this symbol.  |
01325 `-----------------------------------------------*/
01326 
01327 /*ARGSUSED*/
01328 #if (defined __STDC__ || defined __C99__FUNC__ \
01329      || defined __cplusplus || defined _MSC_VER)
01330 static void
01331 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep, void *scanner, char **errp, struct nl_list_head *root)
01332 #else
01333 static void
01334 yydestruct (yymsg, yytype, yyvaluep, scanner, errp, root)
01335     const char *yymsg;
01336     int yytype;
01337     YYSTYPE *yyvaluep;
01338     void *scanner;
01339     char **errp;
01340     struct nl_list_head *root;
01341 #endif
01342 {
01343   YYUSE (yyvaluep);
01344   YYUSE (scanner);
01345   YYUSE (errp);
01346   YYUSE (root);
01347 
01348   if (!yymsg)
01349     yymsg = "Deleting";
01350   YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
01351 
01352   switch (yytype)
01353     {
01354       case 72: /* "STR" */
01355 
01356 /* Line 1000 of yacc.c  */
01357 #line 137 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01358         { free((yyvaluep->s)); NL_DBG(2, "string destructor\n"); };
01359 
01360 /* Line 1000 of yacc.c  */
01361 #line 1362 "route/cls/ematch_syntax.c"
01362         break;
01363       case 73: /* "QUOTED" */
01364 
01365 /* Line 1000 of yacc.c  */
01366 #line 139 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01367         { free((yyvaluep->q).data); NL_DBG(2, "quoted destructor\n"); };
01368 
01369 /* Line 1000 of yacc.c  */
01370 #line 1371 "route/cls/ematch_syntax.c"
01371         break;
01372       case 81: /* "text_from" */
01373 
01374 /* Line 1000 of yacc.c  */
01375 #line 138 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01376         { rtnl_pktloc_put((yyvaluep->loc)); NL_DBG(2, "pktloc destructor\n"); };
01377 
01378 /* Line 1000 of yacc.c  */
01379 #line 1380 "route/cls/ematch_syntax.c"
01380         break;
01381       case 82: /* "text_to" */
01382 
01383 /* Line 1000 of yacc.c  */
01384 #line 138 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01385         { rtnl_pktloc_put((yyvaluep->loc)); NL_DBG(2, "pktloc destructor\n"); };
01386 
01387 /* Line 1000 of yacc.c  */
01388 #line 1389 "route/cls/ematch_syntax.c"
01389         break;
01390       case 83: /* "meta_value" */
01391 
01392 /* Line 1000 of yacc.c  */
01393 #line 140 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01394         { rtnl_meta_value_put((yyvaluep->mv)); NL_DBG(2, "meta value destructor\n"); };
01395 
01396 /* Line 1000 of yacc.c  */
01397 #line 1398 "route/cls/ematch_syntax.c"
01398         break;
01399       case 86: /* "pattern" */
01400 
01401 /* Line 1000 of yacc.c  */
01402 #line 139 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01403         { free((yyvaluep->q).data); NL_DBG(2, "quoted destructor\n"); };
01404 
01405 /* Line 1000 of yacc.c  */
01406 #line 1407 "route/cls/ematch_syntax.c"
01407         break;
01408       case 87: /* "pktloc" */
01409 
01410 /* Line 1000 of yacc.c  */
01411 #line 138 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01412         { rtnl_pktloc_put((yyvaluep->loc)); NL_DBG(2, "pktloc destructor\n"); };
01413 
01414 /* Line 1000 of yacc.c  */
01415 #line 1416 "route/cls/ematch_syntax.c"
01416         break;
01417 
01418       default:
01419         break;
01420     }
01421 }
01422 
01423 /* Prevent warnings from -Wmissing-prototypes.  */
01424 #ifdef YYPARSE_PARAM
01425 #if defined __STDC__ || defined __cplusplus
01426 int yyparse (void *YYPARSE_PARAM);
01427 #else
01428 int yyparse ();
01429 #endif
01430 #else /* ! YYPARSE_PARAM */
01431 #if defined __STDC__ || defined __cplusplus
01432 int yyparse (void *scanner, char **errp, struct nl_list_head *root);
01433 #else
01434 int yyparse ();
01435 #endif
01436 #endif /* ! YYPARSE_PARAM */
01437 
01438 
01439 
01440 
01441 
01442 /*-------------------------.
01443 | yyparse or yypush_parse.  |
01444 `-------------------------*/
01445 
01446 #ifdef YYPARSE_PARAM
01447 #if (defined __STDC__ || defined __C99__FUNC__ \
01448      || defined __cplusplus || defined _MSC_VER)
01449 int
01450 yyparse (void *YYPARSE_PARAM)
01451 #else
01452 int
01453 yyparse (YYPARSE_PARAM)
01454     void *YYPARSE_PARAM;
01455 #endif
01456 #else /* ! YYPARSE_PARAM */
01457 #if (defined __STDC__ || defined __C99__FUNC__ \
01458      || defined __cplusplus || defined _MSC_VER)
01459 int
01460 yyparse (void *scanner, char **errp, struct nl_list_head *root)
01461 #else
01462 int
01463 yyparse (scanner, errp, root)
01464     void *scanner;
01465     char **errp;
01466     struct nl_list_head *root;
01467 #endif
01468 #endif
01469 {
01470 /* The lookahead symbol.  */
01471 int yychar;
01472 
01473 /* The semantic value of the lookahead symbol.  */
01474 YYSTYPE yylval;
01475 
01476     /* Number of syntax errors so far.  */
01477     int yynerrs;
01478 
01479     int yystate;
01480     /* Number of tokens to shift before error messages enabled.  */
01481     int yyerrstatus;
01482 
01483     /* The stacks and their tools:
01484        `yyss': related to states.
01485        `yyvs': related to semantic values.
01486 
01487        Refer to the stacks thru separate pointers, to allow yyoverflow
01488        to reallocate them elsewhere.  */
01489 
01490     /* The state stack.  */
01491     yytype_int16 yyssa[YYINITDEPTH];
01492     yytype_int16 *yyss;
01493     yytype_int16 *yyssp;
01494 
01495     /* The semantic value stack.  */
01496     YYSTYPE yyvsa[YYINITDEPTH];
01497     YYSTYPE *yyvs;
01498     YYSTYPE *yyvsp;
01499 
01500     YYSIZE_T yystacksize;
01501 
01502   int yyn;
01503   int yyresult;
01504   /* Lookahead token as an internal (translated) token number.  */
01505   int yytoken;
01506   /* The variables used to return semantic value and location from the
01507      action routines.  */
01508   YYSTYPE yyval;
01509 
01510 #if YYERROR_VERBOSE
01511   /* Buffer for error messages, and its allocated size.  */
01512   char yymsgbuf[128];
01513   char *yymsg = yymsgbuf;
01514   YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
01515 #endif
01516 
01517 #define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
01518 
01519   /* The number of symbols on the RHS of the reduced rule.
01520      Keep to zero when no symbol should be popped.  */
01521   int yylen = 0;
01522 
01523   yytoken = 0;
01524   yyss = yyssa;
01525   yyvs = yyvsa;
01526   yystacksize = YYINITDEPTH;
01527 
01528   YYDPRINTF ((stderr, "Starting parse\n"));
01529 
01530   yystate = 0;
01531   yyerrstatus = 0;
01532   yynerrs = 0;
01533   yychar = YYEMPTY; /* Cause a token to be read.  */
01534 
01535   /* Initialize stack pointers.
01536      Waste one element of value and location stack
01537      so that they stay on the same level as the state stack.
01538      The wasted elements are never initialized.  */
01539   yyssp = yyss;
01540   yyvsp = yyvs;
01541 
01542   goto yysetstate;
01543 
01544 /*------------------------------------------------------------.
01545 | yynewstate -- Push a new state, which is found in yystate.  |
01546 `------------------------------------------------------------*/
01547  yynewstate:
01548   /* In all cases, when you get here, the value and location stacks
01549      have just been pushed.  So pushing a state here evens the stacks.  */
01550   yyssp++;
01551 
01552  yysetstate:
01553   *yyssp = yystate;
01554 
01555   if (yyss + yystacksize - 1 <= yyssp)
01556     {
01557       /* Get the current used size of the three stacks, in elements.  */
01558       YYSIZE_T yysize = yyssp - yyss + 1;
01559 
01560 #ifdef yyoverflow
01561       {
01562         /* Give user a chance to reallocate the stack.  Use copies of
01563            these so that the &'s don't force the real ones into
01564            memory.  */
01565         YYSTYPE *yyvs1 = yyvs;
01566         yytype_int16 *yyss1 = yyss;
01567 
01568         /* Each stack pointer address is followed by the size of the
01569            data in use in that stack, in bytes.  This used to be a
01570            conditional around just the two extra args, but that might
01571            be undefined if yyoverflow is a macro.  */
01572         yyoverflow (YY_("memory exhausted"),
01573                     &yyss1, yysize * sizeof (*yyssp),
01574                     &yyvs1, yysize * sizeof (*yyvsp),
01575                     &yystacksize);
01576 
01577         yyss = yyss1;
01578         yyvs = yyvs1;
01579       }
01580 #else /* no yyoverflow */
01581 # ifndef YYSTACK_RELOCATE
01582       goto yyexhaustedlab;
01583 # else
01584       /* Extend the stack our own way.  */
01585       if (YYMAXDEPTH <= yystacksize)
01586         goto yyexhaustedlab;
01587       yystacksize *= 2;
01588       if (YYMAXDEPTH < yystacksize)
01589         yystacksize = YYMAXDEPTH;
01590 
01591       {
01592         yytype_int16 *yyss1 = yyss;
01593         union yyalloc *yyptr =
01594           (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
01595         if (! yyptr)
01596           goto yyexhaustedlab;
01597         YYSTACK_RELOCATE (yyss_alloc, yyss);
01598         YYSTACK_RELOCATE (yyvs_alloc, yyvs);
01599 #  undef YYSTACK_RELOCATE
01600         if (yyss1 != yyssa)
01601           YYSTACK_FREE (yyss1);
01602       }
01603 # endif
01604 #endif /* no yyoverflow */
01605 
01606       yyssp = yyss + yysize - 1;
01607       yyvsp = yyvs + yysize - 1;
01608 
01609       YYDPRINTF ((stderr, "Stack size increased to %lu\n",
01610                   (unsigned long int) yystacksize));
01611 
01612       if (yyss + yystacksize - 1 <= yyssp)
01613         YYABORT;
01614     }
01615 
01616   YYDPRINTF ((stderr, "Entering state %d\n", yystate));
01617 
01618   if (yystate == YYFINAL)
01619     YYACCEPT;
01620 
01621   goto yybackup;
01622 
01623 /*-----------.
01624 | yybackup.  |
01625 `-----------*/
01626 yybackup:
01627 
01628   /* Do appropriate processing given the current state.  Read a
01629      lookahead token if we need one and don't already have one.  */
01630 
01631   /* First try to decide what to do without reference to lookahead token.  */
01632   yyn = yypact[yystate];
01633   if (yyn == YYPACT_NINF)
01634     goto yydefault;
01635 
01636   /* Not known => get a lookahead token if don't already have one.  */
01637 
01638   /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
01639   if (yychar == YYEMPTY)
01640     {
01641       YYDPRINTF ((stderr, "Reading a token: "));
01642       yychar = YYLEX;
01643     }
01644 
01645   if (yychar <= YYEOF)
01646     {
01647       yychar = yytoken = YYEOF;
01648       YYDPRINTF ((stderr, "Now at end of input.\n"));
01649     }
01650   else
01651     {
01652       yytoken = YYTRANSLATE (yychar);
01653       YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
01654     }
01655 
01656   /* If the proper action on seeing token YYTOKEN is to reduce or to
01657      detect an error, take that action.  */
01658   yyn += yytoken;
01659   if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
01660     goto yydefault;
01661   yyn = yytable[yyn];
01662   if (yyn <= 0)
01663     {
01664       if (yyn == 0 || yyn == YYTABLE_NINF)
01665         goto yyerrlab;
01666       yyn = -yyn;
01667       goto yyreduce;
01668     }
01669 
01670   /* Count tokens shifted since error; after three, turn off error
01671      status.  */
01672   if (yyerrstatus)
01673     yyerrstatus--;
01674 
01675   /* Shift the lookahead token.  */
01676   YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
01677 
01678   /* Discard the shifted token.  */
01679   yychar = YYEMPTY;
01680 
01681   yystate = yyn;
01682   *++yyvsp = yylval;
01683 
01684   goto yynewstate;
01685 
01686 
01687 /*-----------------------------------------------------------.
01688 | yydefault -- do the default action for the current state.  |
01689 `-----------------------------------------------------------*/
01690 yydefault:
01691   yyn = yydefact[yystate];
01692   if (yyn == 0)
01693     goto yyerrlab;
01694   goto yyreduce;
01695 
01696 
01697 /*-----------------------------.
01698 | yyreduce -- Do a reduction.  |
01699 `-----------------------------*/
01700 yyreduce:
01701   /* yyn is the number of a rule to reduce with.  */
01702   yylen = yyr2[yyn];
01703 
01704   /* If YYLEN is nonzero, implement the default value of the action:
01705      `$$ = $1'.
01706 
01707      Otherwise, the following line sets YYVAL to garbage.
01708      This behavior is undocumented and Bison
01709      users should not rely upon it.  Assigning to YYVAL
01710      unconditionally makes the parser a bit smaller, and it avoids a
01711      GCC warning that YYVAL may be used uninitialized.  */
01712   yyval = yyvsp[1-yylen];
01713 
01714 
01715   YY_REDUCE_PRINT (yyn);
01716   switch (yyn)
01717     {
01718         case 3:
01719 
01720 /* Line 1455 of yacc.c  */
01721 #line 149 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01722     {
01723                         nl_list_add_tail(root, &(yyvsp[(1) - (1)].e)->e_list);
01724                 }
01725     break;
01726 
01727   case 4:
01728 
01729 /* Line 1455 of yacc.c  */
01730 #line 156 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01731     {
01732                         (yyval.e) = (yyvsp[(1) - (1)].e);
01733                 }
01734     break;
01735 
01736   case 5:
01737 
01738 /* Line 1455 of yacc.c  */
01739 #line 160 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01740     {
01741                         rtnl_ematch_set_flags((yyvsp[(1) - (3)].e), (yyvsp[(2) - (3)].i));
01742 
01743                         /* make ematch new head */
01744                         nl_list_add_tail(&(yyvsp[(1) - (3)].e)->e_list, &(yyvsp[(3) - (3)].e)->e_list);
01745 
01746                         (yyval.e) = (yyvsp[(1) - (3)].e);
01747                 }
01748     break;
01749 
01750   case 6:
01751 
01752 /* Line 1455 of yacc.c  */
01753 #line 172 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01754     {
01755                         rtnl_ematch_set_flags((yyvsp[(2) - (2)].e), TCF_EM_INVERT);
01756                         (yyval.e) = (yyvsp[(2) - (2)].e);
01757                 }
01758     break;
01759 
01760   case 7:
01761 
01762 /* Line 1455 of yacc.c  */
01763 #line 177 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01764     {
01765                         (yyval.e) = (yyvsp[(1) - (1)].e);
01766                 }
01767     break;
01768 
01769   case 8:
01770 
01771 /* Line 1455 of yacc.c  */
01772 #line 185 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01773     {
01774                         struct rtnl_ematch *e;
01775 
01776                         if (!(e = rtnl_ematch_alloc())) {
01777                                 asprintf(errp, "Unable to allocate ematch object");
01778                                 YYABORT;
01779                         }
01780 
01781                         if (rtnl_ematch_set_kind(e, TCF_EM_CMP) < 0)
01782                                 BUG();
01783 
01784                         rtnl_ematch_cmp_set(e, &(yyvsp[(1) - (1)].cmp));
01785                         (yyval.e) = e;
01786                 }
01787     break;
01788 
01789   case 9:
01790 
01791 /* Line 1455 of yacc.c  */
01792 #line 200 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01793     {
01794                         struct rtnl_ematch *e;
01795 
01796                         if (!(e = rtnl_ematch_alloc())) {
01797                                 asprintf(errp, "Unable to allocate ematch object");
01798                                 YYABORT;
01799                         }
01800 
01801                         if (rtnl_ematch_set_kind(e, TCF_EM_NBYTE) < 0)
01802                                 BUG();
01803 
01804                         rtnl_ematch_nbyte_set_offset(e, (yyvsp[(3) - (6)].loc)->layer, (yyvsp[(3) - (6)].loc)->offset);
01805                         rtnl_pktloc_put((yyvsp[(3) - (6)].loc));
01806                         rtnl_ematch_nbyte_set_pattern(e, (uint8_t *) (yyvsp[(5) - (6)].q).data, (yyvsp[(5) - (6)].q).index);
01807 
01808                         (yyval.e) = e;
01809                 }
01810     break;
01811 
01812   case 10:
01813 
01814 /* Line 1455 of yacc.c  */
01815 #line 218 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01816     {
01817                         struct rtnl_ematch *e;
01818 
01819                         if (!(e = rtnl_ematch_alloc())) {
01820                                 asprintf(errp, "Unable to allocate ematch object");
01821                                 YYABORT;
01822                         }
01823 
01824                         if (rtnl_ematch_set_kind(e, TCF_EM_TEXT) < 0)
01825                                 BUG();
01826 
01827                         rtnl_ematch_text_set_algo(e, (yyvsp[(3) - (7)].s));
01828                         rtnl_ematch_text_set_pattern(e, (yyvsp[(4) - (7)].q).data, (yyvsp[(4) - (7)].q).index);
01829 
01830                         if ((yyvsp[(5) - (7)].loc)) {
01831                                 rtnl_ematch_text_set_from(e, (yyvsp[(5) - (7)].loc)->layer, (yyvsp[(5) - (7)].loc)->offset);
01832                                 rtnl_pktloc_put((yyvsp[(5) - (7)].loc));
01833                         }
01834 
01835                         if ((yyvsp[(6) - (7)].loc)) {
01836                                 rtnl_ematch_text_set_to(e, (yyvsp[(6) - (7)].loc)->layer, (yyvsp[(6) - (7)].loc)->offset);
01837                                 rtnl_pktloc_put((yyvsp[(6) - (7)].loc));
01838                         }
01839 
01840                         (yyval.e) = e;
01841                 }
01842     break;
01843 
01844   case 11:
01845 
01846 /* Line 1455 of yacc.c  */
01847 #line 245 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01848     {
01849                         struct rtnl_ematch *e;
01850 
01851                         if (!(e = rtnl_ematch_alloc())) {
01852                                 asprintf(errp, "Unable to allocate ematch object");
01853                                 YYABORT;
01854                         }
01855 
01856                         if (rtnl_ematch_set_kind(e, TCF_EM_META) < 0)
01857                                 BUG();
01858 
01859                         rtnl_ematch_meta_set_lvalue(e, (yyvsp[(3) - (6)].mv));
01860                         rtnl_ematch_meta_set_rvalue(e, (yyvsp[(5) - (6)].mv));
01861                         rtnl_ematch_meta_set_operand(e, (yyvsp[(4) - (6)].i));
01862 
01863                         (yyval.e) = e;
01864                 }
01865     break;
01866 
01867   case 12:
01868 
01869 /* Line 1455 of yacc.c  */
01870 #line 264 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01871     {
01872                         struct rtnl_ematch *e;
01873 
01874                         if (!(e = rtnl_ematch_alloc())) {
01875                                 asprintf(errp, "Unable to allocate ematch object");
01876                                 YYABORT;
01877                         }
01878 
01879                         if (rtnl_ematch_set_kind(e, TCF_EM_CONTAINER) < 0)
01880                                 BUG();
01881 
01882                         /* Make e->childs the list head of a the ematch sequence */
01883                         nl_list_add_tail(&e->e_childs, &(yyvsp[(2) - (3)].e)->e_list);
01884 
01885                         (yyval.e) = e;
01886                 }
01887     break;
01888 
01889   case 13:
01890 
01891 /* Line 1455 of yacc.c  */
01892 #line 292 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01893     { (yyval.cmp) = (yyvsp[(3) - (4)].cmp); }
01894     break;
01895 
01896   case 14:
01897 
01898 /* Line 1455 of yacc.c  */
01899 #line 294 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01900     { (yyval.cmp) = (yyvsp[(1) - (1)].cmp); }
01901     break;
01902 
01903   case 15:
01904 
01905 /* Line 1455 of yacc.c  */
01906 #line 299 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01907     {
01908                         if ((yyvsp[(1) - (3)].loc)->align == TCF_EM_ALIGN_U16 ||
01909                             (yyvsp[(1) - (3)].loc)->align == TCF_EM_ALIGN_U32)
01910                                 (yyval.cmp).flags = TCF_EM_CMP_TRANS;
01911 
01912                         memset(&(yyval.cmp), 0, sizeof((yyval.cmp)));
01913 
01914                         (yyval.cmp).mask = (yyvsp[(1) - (3)].loc)->mask;
01915                         (yyval.cmp).off = (yyvsp[(1) - (3)].loc)->offset;
01916                         (yyval.cmp).align = (yyvsp[(1) - (3)].loc)->align;
01917                         (yyval.cmp).layer = (yyvsp[(1) - (3)].loc)->layer;
01918                         (yyval.cmp).opnd = (yyvsp[(2) - (3)].i);
01919                         (yyval.cmp).val = (yyvsp[(3) - (3)].i);
01920 
01921                         rtnl_pktloc_put((yyvsp[(1) - (3)].loc));
01922                 }
01923     break;
01924 
01925   case 16:
01926 
01927 /* Line 1455 of yacc.c  */
01928 #line 319 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01929     { (yyval.loc) = NULL; }
01930     break;
01931 
01932   case 17:
01933 
01934 /* Line 1455 of yacc.c  */
01935 #line 321 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01936     { (yyval.loc) = (yyvsp[(2) - (2)].loc); }
01937     break;
01938 
01939   case 18:
01940 
01941 /* Line 1455 of yacc.c  */
01942 #line 326 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01943     { (yyval.loc) = NULL; }
01944     break;
01945 
01946   case 19:
01947 
01948 /* Line 1455 of yacc.c  */
01949 #line 328 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01950     { (yyval.loc) = (yyvsp[(2) - (2)].loc); }
01951     break;
01952 
01953   case 20:
01954 
01955 /* Line 1455 of yacc.c  */
01956 #line 333 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01957     { (yyval.mv) = rtnl_meta_value_alloc_var((yyvsp[(1) - (1)].q).data, (yyvsp[(1) - (1)].q).len); }
01958     break;
01959 
01960   case 21:
01961 
01962 /* Line 1455 of yacc.c  */
01963 #line 335 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01964     { (yyval.mv) = rtnl_meta_value_alloc_int((yyvsp[(1) - (1)].i)); }
01965     break;
01966 
01967   case 22:
01968 
01969 /* Line 1455 of yacc.c  */
01970 #line 337 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01971     { (yyval.mv) = META_ALLOC(META_INT, (yyvsp[(1) - (3)].i), (yyvsp[(2) - (3)].i), (yyvsp[(3) - (3)].i64)); }
01972     break;
01973 
01974   case 23:
01975 
01976 /* Line 1455 of yacc.c  */
01977 #line 339 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01978     { (yyval.mv) = META_ALLOC(META_VAR, (yyvsp[(1) - (2)].i), (yyvsp[(2) - (2)].i), 0); }
01979     break;
01980 
01981   case 24:
01982 
01983 /* Line 1455 of yacc.c  */
01984 #line 343 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01985     { (yyval.i) = META_ID(RANDOM); }
01986     break;
01987 
01988   case 25:
01989 
01990 /* Line 1455 of yacc.c  */
01991 #line 344 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01992     { (yyval.i) = META_ID(LOADAVG_0); }
01993     break;
01994 
01995   case 26:
01996 
01997 /* Line 1455 of yacc.c  */
01998 #line 345 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
01999     { (yyval.i) = META_ID(LOADAVG_1); }
02000     break;
02001 
02002   case 27:
02003 
02004 /* Line 1455 of yacc.c  */
02005 #line 346 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02006     { (yyval.i) = META_ID(LOADAVG_2); }
02007     break;
02008 
02009   case 28:
02010 
02011 /* Line 1455 of yacc.c  */
02012 #line 347 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02013     { (yyval.i) = META_ID(DEV); }
02014     break;
02015 
02016   case 29:
02017 
02018 /* Line 1455 of yacc.c  */
02019 #line 348 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02020     { (yyval.i) = META_ID(PRIORITY); }
02021     break;
02022 
02023   case 30:
02024 
02025 /* Line 1455 of yacc.c  */
02026 #line 349 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02027     { (yyval.i) = META_ID(PROTOCOL); }
02028     break;
02029 
02030   case 31:
02031 
02032 /* Line 1455 of yacc.c  */
02033 #line 350 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02034     { (yyval.i) = META_ID(PKTTYPE); }
02035     break;
02036 
02037   case 32:
02038 
02039 /* Line 1455 of yacc.c  */
02040 #line 351 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02041     { (yyval.i) = META_ID(PKTLEN); }
02042     break;
02043 
02044   case 33:
02045 
02046 /* Line 1455 of yacc.c  */
02047 #line 352 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02048     { (yyval.i) = META_ID(DATALEN); }
02049     break;
02050 
02051   case 34:
02052 
02053 /* Line 1455 of yacc.c  */
02054 #line 353 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02055     { (yyval.i) = META_ID(MACLEN); }
02056     break;
02057 
02058   case 35:
02059 
02060 /* Line 1455 of yacc.c  */
02061 #line 354 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02062     { (yyval.i) = META_ID(NFMARK); }
02063     break;
02064 
02065   case 36:
02066 
02067 /* Line 1455 of yacc.c  */
02068 #line 355 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02069     { (yyval.i) = META_ID(TCINDEX); }
02070     break;
02071 
02072   case 37:
02073 
02074 /* Line 1455 of yacc.c  */
02075 #line 356 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02076     { (yyval.i) = META_ID(RTCLASSID); }
02077     break;
02078 
02079   case 38:
02080 
02081 /* Line 1455 of yacc.c  */
02082 #line 357 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02083     { (yyval.i) = META_ID(RTIIF); }
02084     break;
02085 
02086   case 39:
02087 
02088 /* Line 1455 of yacc.c  */
02089 #line 358 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02090     { (yyval.i) = META_ID(SK_FAMILY); }
02091     break;
02092 
02093   case 40:
02094 
02095 /* Line 1455 of yacc.c  */
02096 #line 359 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02097     { (yyval.i) = META_ID(SK_STATE); }
02098     break;
02099 
02100   case 41:
02101 
02102 /* Line 1455 of yacc.c  */
02103 #line 360 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02104     { (yyval.i) = META_ID(SK_REUSE); }
02105     break;
02106 
02107   case 42:
02108 
02109 /* Line 1455 of yacc.c  */
02110 #line 361 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02111     { (yyval.i) = META_ID(SK_REFCNT); }
02112     break;
02113 
02114   case 43:
02115 
02116 /* Line 1455 of yacc.c  */
02117 #line 362 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02118     { (yyval.i) = META_ID(SK_RCVBUF); }
02119     break;
02120 
02121   case 44:
02122 
02123 /* Line 1455 of yacc.c  */
02124 #line 363 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02125     { (yyval.i) = META_ID(SK_SNDBUF); }
02126     break;
02127 
02128   case 45:
02129 
02130 /* Line 1455 of yacc.c  */
02131 #line 364 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02132     { (yyval.i) = META_ID(SK_SHUTDOWN); }
02133     break;
02134 
02135   case 46:
02136 
02137 /* Line 1455 of yacc.c  */
02138 #line 365 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02139     { (yyval.i) = META_ID(SK_PROTO); }
02140     break;
02141 
02142   case 47:
02143 
02144 /* Line 1455 of yacc.c  */
02145 #line 366 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02146     { (yyval.i) = META_ID(SK_TYPE); }
02147     break;
02148 
02149   case 48:
02150 
02151 /* Line 1455 of yacc.c  */
02152 #line 367 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02153     { (yyval.i) = META_ID(SK_RMEM_ALLOC); }
02154     break;
02155 
02156   case 49:
02157 
02158 /* Line 1455 of yacc.c  */
02159 #line 368 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02160     { (yyval.i) = META_ID(SK_WMEM_ALLOC); }
02161     break;
02162 
02163   case 50:
02164 
02165 /* Line 1455 of yacc.c  */
02166 #line 369 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02167     { (yyval.i) = META_ID(SK_WMEM_QUEUED); }
02168     break;
02169 
02170   case 51:
02171 
02172 /* Line 1455 of yacc.c  */
02173 #line 370 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02174     { (yyval.i) = META_ID(SK_RCV_QLEN); }
02175     break;
02176 
02177   case 52:
02178 
02179 /* Line 1455 of yacc.c  */
02180 #line 371 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02181     { (yyval.i) = META_ID(SK_SND_QLEN); }
02182     break;
02183 
02184   case 53:
02185 
02186 /* Line 1455 of yacc.c  */
02187 #line 372 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02188     { (yyval.i) = META_ID(SK_ERR_QLEN); }
02189     break;
02190 
02191   case 54:
02192 
02193 /* Line 1455 of yacc.c  */
02194 #line 373 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02195     { (yyval.i) = META_ID(SK_FORWARD_ALLOCS); }
02196     break;
02197 
02198   case 55:
02199 
02200 /* Line 1455 of yacc.c  */
02201 #line 374 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02202     { (yyval.i) = META_ID(SK_ALLOCS); }
02203     break;
02204 
02205   case 56:
02206 
02207 /* Line 1455 of yacc.c  */
02208 #line 375 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02209     { (yyval.i) = META_ID(SK_ROUTE_CAPS); }
02210     break;
02211 
02212   case 57:
02213 
02214 /* Line 1455 of yacc.c  */
02215 #line 376 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02216     { (yyval.i) = META_ID(SK_HASH); }
02217     break;
02218 
02219   case 58:
02220 
02221 /* Line 1455 of yacc.c  */
02222 #line 377 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02223     { (yyval.i) = META_ID(SK_LINGERTIME); }
02224     break;
02225 
02226   case 59:
02227 
02228 /* Line 1455 of yacc.c  */
02229 #line 378 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02230     { (yyval.i) = META_ID(SK_ACK_BACKLOG); }
02231     break;
02232 
02233   case 60:
02234 
02235 /* Line 1455 of yacc.c  */
02236 #line 379 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02237     { (yyval.i) = META_ID(SK_MAX_ACK_BACKLOG); }
02238     break;
02239 
02240   case 61:
02241 
02242 /* Line 1455 of yacc.c  */
02243 #line 380 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02244     { (yyval.i) = META_ID(SK_PRIO); }
02245     break;
02246 
02247   case 62:
02248 
02249 /* Line 1455 of yacc.c  */
02250 #line 381 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02251     { (yyval.i) = META_ID(SK_RCVLOWAT); }
02252     break;
02253 
02254   case 63:
02255 
02256 /* Line 1455 of yacc.c  */
02257 #line 382 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02258     { (yyval.i) = META_ID(SK_RCVTIMEO); }
02259     break;
02260 
02261   case 64:
02262 
02263 /* Line 1455 of yacc.c  */
02264 #line 383 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02265     { (yyval.i) = META_ID(SK_SNDTIMEO); }
02266     break;
02267 
02268   case 65:
02269 
02270 /* Line 1455 of yacc.c  */
02271 #line 384 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02272     { (yyval.i) = META_ID(SK_SENDMSG_OFF); }
02273     break;
02274 
02275   case 66:
02276 
02277 /* Line 1455 of yacc.c  */
02278 #line 385 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02279     { (yyval.i) = META_ID(SK_WRITE_PENDING); }
02280     break;
02281 
02282   case 67:
02283 
02284 /* Line 1455 of yacc.c  */
02285 #line 386 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02286     { (yyval.i) = META_ID(VLAN_TAG); }
02287     break;
02288 
02289   case 68:
02290 
02291 /* Line 1455 of yacc.c  */
02292 #line 387 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02293     { (yyval.i) = META_ID(RXHASH); }
02294     break;
02295 
02296   case 69:
02297 
02298 /* Line 1455 of yacc.c  */
02299 #line 391 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02300     { (yyval.i) = META_ID(DEV); }
02301     break;
02302 
02303   case 70:
02304 
02305 /* Line 1455 of yacc.c  */
02306 #line 392 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02307     { (yyval.i) = META_ID(SK_BOUND_IF); }
02308     break;
02309 
02310   case 71:
02311 
02312 /* Line 1455 of yacc.c  */
02313 #line 400 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02314     {
02315                         (yyval.q) = (yyvsp[(1) - (1)].q);
02316                 }
02317     break;
02318 
02319   case 72:
02320 
02321 /* Line 1455 of yacc.c  */
02322 #line 404 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02323     {
02324                         struct nl_addr *addr;
02325 
02326                         if (nl_addr_parse((yyvsp[(1) - (1)].s), AF_UNSPEC, &addr) == 0) {
02327                                 (yyval.q).len = nl_addr_get_len(addr);
02328 
02329                                 (yyval.q).index = min_t(int, (yyval.q).len, nl_addr_get_prefixlen(addr)/8);
02330 
02331                                 if (!((yyval.q).data = calloc(1, (yyval.q).len))) {
02332                                         nl_addr_put(addr);
02333                                         YYABORT;
02334                                 }
02335 
02336                                 memcpy((yyval.q).data, nl_addr_get_binary_addr(addr), (yyval.q).len);
02337                                 nl_addr_put(addr);
02338                         } else {
02339                                 asprintf(errp, "invalid pattern \"%s\"", (yyvsp[(1) - (1)].s));
02340                                 YYABORT;
02341                         }
02342                 }
02343     break;
02344 
02345   case 73:
02346 
02347 /* Line 1455 of yacc.c  */
02348 #line 432 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02349     {
02350                         struct rtnl_pktloc *loc;
02351 
02352                         if (rtnl_pktloc_lookup((yyvsp[(1) - (1)].s), &loc) < 0) {
02353                                 asprintf(errp, "Packet location \"%s\" not found", (yyvsp[(1) - (1)].s));
02354                                 YYABORT;
02355                         }
02356 
02357                         (yyval.loc) = loc;
02358                 }
02359     break;
02360 
02361   case 74:
02362 
02363 /* Line 1455 of yacc.c  */
02364 #line 444 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02365     {
02366                         struct rtnl_pktloc *loc;
02367 
02368                         if ((yyvsp[(5) - (5)].i64) && (!(yyvsp[(1) - (5)].i) || (yyvsp[(1) - (5)].i) > TCF_EM_ALIGN_U32)) {
02369                                 asprintf(errp, "mask only allowed for alignments u8|u16|u32");
02370                                 YYABORT;
02371                         }
02372 
02373                         if (!(loc = rtnl_pktloc_alloc())) {
02374                                 asprintf(errp, "Unable to allocate packet location object");
02375                                 YYABORT;
02376                         }
02377 
02378                         loc->name = strdup("<USER-DEFINED>");
02379                         loc->align = (yyvsp[(1) - (5)].i);
02380                         loc->layer = (yyvsp[(2) - (5)].i);
02381                         loc->offset = (yyvsp[(4) - (5)].i);
02382                         loc->mask = (yyvsp[(5) - (5)].i64);
02383 
02384                         (yyval.loc) = loc;
02385                 }
02386     break;
02387 
02388   case 75:
02389 
02390 /* Line 1455 of yacc.c  */
02391 #line 469 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02392     { (yyval.i) = 0; }
02393     break;
02394 
02395   case 76:
02396 
02397 /* Line 1455 of yacc.c  */
02398 #line 471 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02399     { (yyval.i) = (yyvsp[(1) - (2)].i); }
02400     break;
02401 
02402   case 77:
02403 
02404 /* Line 1455 of yacc.c  */
02405 #line 473 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02406     { (yyval.i) = (yyvsp[(1) - (2)].i); }
02407     break;
02408 
02409   case 78:
02410 
02411 /* Line 1455 of yacc.c  */
02412 #line 478 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02413     { (yyval.i64) = 0; }
02414     break;
02415 
02416   case 79:
02417 
02418 /* Line 1455 of yacc.c  */
02419 #line 480 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02420     { (yyval.i64) = (yyvsp[(2) - (2)].i); }
02421     break;
02422 
02423   case 80:
02424 
02425 /* Line 1455 of yacc.c  */
02426 #line 485 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02427     { (yyval.i) = 0; }
02428     break;
02429 
02430   case 81:
02431 
02432 /* Line 1455 of yacc.c  */
02433 #line 487 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02434     { (yyval.i) = (yyvsp[(2) - (2)].i); }
02435     break;
02436 
02437   case 82:
02438 
02439 /* Line 1455 of yacc.c  */
02440 #line 492 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02441     { (yyval.i) = TCF_EM_OPND_EQ; }
02442     break;
02443 
02444   case 83:
02445 
02446 /* Line 1455 of yacc.c  */
02447 #line 494 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02448     { (yyval.i) = TCF_EM_OPND_GT; }
02449     break;
02450 
02451   case 84:
02452 
02453 /* Line 1455 of yacc.c  */
02454 #line 496 "/root/build/iw/libnl3/libnl3-3.0/./lib/route/cls/ematch_syntax.y"
02455     { (yyval.i) = TCF_EM_OPND_LT; }
02456     break;
02457 
02458 
02459 
02460 /* Line 1455 of yacc.c  */
02461 #line 2462 "route/cls/ematch_syntax.c"
02462       default: break;
02463     }
02464   YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
02465 
02466   YYPOPSTACK (yylen);
02467   yylen = 0;
02468   YY_STACK_PRINT (yyss, yyssp);
02469 
02470   *++yyvsp = yyval;
02471 
02472   /* Now `shift' the result of the reduction.  Determine what state
02473      that goes to, based on the state we popped back to and the rule
02474      number reduced by.  */
02475 
02476   yyn = yyr1[yyn];
02477 
02478   yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
02479   if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
02480     yystate = yytable[yystate];
02481   else
02482     yystate = yydefgoto[yyn - YYNTOKENS];
02483 
02484   goto yynewstate;
02485 
02486 
02487 /*------------------------------------.
02488 | yyerrlab -- here on detecting error |
02489 `------------------------------------*/
02490 yyerrlab:
02491   /* If not already recovering from an error, report this error.  */
02492   if (!yyerrstatus)
02493     {
02494       ++yynerrs;
02495 #if ! YYERROR_VERBOSE
02496       yyerror (scanner, errp, root, YY_("syntax error"));
02497 #else
02498       {
02499         YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
02500         if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
02501           {
02502             YYSIZE_T yyalloc = 2 * yysize;
02503             if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
02504               yyalloc = YYSTACK_ALLOC_MAXIMUM;
02505             if (yymsg != yymsgbuf)
02506               YYSTACK_FREE (yymsg);
02507             yymsg = (char *) YYSTACK_ALLOC (yyalloc);
02508             if (yymsg)
02509               yymsg_alloc = yyalloc;
02510             else
02511               {
02512                 yymsg = yymsgbuf;
02513                 yymsg_alloc = sizeof yymsgbuf;
02514               }
02515           }
02516 
02517         if (0 < yysize && yysize <= yymsg_alloc)
02518           {
02519             (void) yysyntax_error (yymsg, yystate, yychar);
02520             yyerror (scanner, errp, root, yymsg);
02521           }
02522         else
02523           {
02524             yyerror (scanner, errp, root, YY_("syntax error"));
02525             if (yysize != 0)
02526               goto yyexhaustedlab;
02527           }
02528       }
02529 #endif
02530     }
02531 
02532 
02533 
02534   if (yyerrstatus == 3)
02535     {
02536       /* If just tried and failed to reuse lookahead token after an
02537          error, discard it.  */
02538 
02539       if (yychar <= YYEOF)
02540         {
02541           /* Return failure if at end of input.  */
02542           if (yychar == YYEOF)
02543             YYABORT;
02544         }
02545       else
02546         {
02547           yydestruct ("Error: discarding",
02548                       yytoken, &yylval, scanner, errp, root);
02549           yychar = YYEMPTY;
02550         }
02551     }
02552 
02553   /* Else will try to reuse lookahead token after shifting the error
02554      token.  */
02555   goto yyerrlab1;
02556 
02557 
02558 /*---------------------------------------------------.
02559 | yyerrorlab -- error raised explicitly by YYERROR.  |
02560 `---------------------------------------------------*/
02561 yyerrorlab:
02562 
02563   /* Pacify compilers like GCC when the user code never invokes
02564      YYERROR and the label yyerrorlab therefore never appears in user
02565      code.  */
02566   if (/*CONSTCOND*/ 0)
02567      goto yyerrorlab;
02568 
02569   /* Do not reclaim the symbols of the rule which action triggered
02570      this YYERROR.  */
02571   YYPOPSTACK (yylen);
02572   yylen = 0;
02573   YY_STACK_PRINT (yyss, yyssp);
02574   yystate = *yyssp;
02575   goto yyerrlab1;
02576 
02577 
02578 /*-------------------------------------------------------------.
02579 | yyerrlab1 -- common code for both syntax error and YYERROR.  |
02580 `-------------------------------------------------------------*/
02581 yyerrlab1:
02582   yyerrstatus = 3;      /* Each real token shifted decrements this.  */
02583 
02584   for (;;)
02585     {
02586       yyn = yypact[yystate];
02587       if (yyn != YYPACT_NINF)
02588         {
02589           yyn += YYTERROR;
02590           if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
02591             {
02592               yyn = yytable[yyn];
02593               if (0 < yyn)
02594                 break;
02595             }
02596         }
02597 
02598       /* Pop the current state because it cannot handle the error token.  */
02599       if (yyssp == yyss)
02600         YYABORT;
02601 
02602 
02603       yydestruct ("Error: popping",
02604                   yystos[yystate], yyvsp, scanner, errp, root);
02605       YYPOPSTACK (1);
02606       yystate = *yyssp;
02607       YY_STACK_PRINT (yyss, yyssp);
02608     }
02609 
02610   *++yyvsp = yylval;
02611 
02612 
02613   /* Shift the error token.  */
02614   YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
02615 
02616   yystate = yyn;
02617   goto yynewstate;
02618 
02619 
02620 /*-------------------------------------.
02621 | yyacceptlab -- YYACCEPT comes here.  |
02622 `-------------------------------------*/
02623 yyacceptlab:
02624   yyresult = 0;
02625   goto yyreturn;
02626 
02627 /*-----------------------------------.
02628 | yyabortlab -- YYABORT comes here.  |
02629 `-----------------------------------*/
02630 yyabortlab:
02631   yyresult = 1;
02632   goto yyreturn;
02633 
02634 #if !defined(yyoverflow) || YYERROR_VERBOSE
02635 /*-------------------------------------------------.
02636 | yyexhaustedlab -- memory exhaustion comes here.  |
02637 `-------------------------------------------------*/
02638 yyexhaustedlab:
02639   yyerror (scanner, errp, root, YY_("memory exhausted"));
02640   yyresult = 2;
02641   /* Fall through.  */
02642 #endif
02643 
02644 yyreturn:
02645   if (yychar != YYEMPTY)
02646      yydestruct ("Cleanup: discarding lookahead",
02647                  yytoken, &yylval, scanner, errp, root);
02648   /* Do not reclaim the symbols of the rule which action triggered
02649      this YYABORT or YYACCEPT.  */
02650   YYPOPSTACK (yylen);
02651   YY_STACK_PRINT (yyss, yyssp);
02652   while (yyssp != yyss)
02653     {
02654       yydestruct ("Cleanup: popping",
02655                   yystos[*yyssp], yyvsp, scanner, errp, root);
02656       YYPOPSTACK (1);
02657     }
02658 #ifndef yyoverflow
02659   if (yyss != yyssa)
02660     YYSTACK_FREE (yyss);
02661 #endif
02662 #if YYERROR_VERBOSE
02663   if (yymsg != yymsgbuf)
02664     YYSTACK_FREE (yymsg);
02665 #endif
02666   /* Make sure YYID is used.  */
02667   return YYID (yyresult);
02668 }
02669 
02670 
02671