INET Framework for OMNeT++/OMNEST
Classes | Macros | Typedefs | Functions | Variables
parser.cc File Reference
#include "inet/common/INETDefs.h"
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdio.h>
#include <ctype.h>
#include <errno.h>
#include <fcntl.h>
#include <pthread.h>
#include <stdlib.h>
#include <string.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <unistd.h>
#include "PacketDrillUtils.h"
#include "PacketDrill.h"
#include "parser.h"
#include <stddef.h>

Classes

union  yyalloc
 

Macros

#define YYBISON   1
 
#define YYBISON_VERSION   "3.0.4"
 
#define YYSKELETON_NAME   "yacc.c"
 
#define YYPURE   0
 
#define YYPUSH   0
 
#define YYPULL   1
 
#define YYDEBUG   0
 
#define YY_NULLPTR   0
 
#define YYERROR_VERBOSE   0
 
#define YY_YY_PARSER_H_INCLUDED
 
#define YYSIZE_T   size_t
 
#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)
 
#define YY_(Msgid)   Msgid
 
#define YY_ATTRIBUTE(Spec)   /* empty */
 
#define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
 
#define YY_ATTRIBUTE_UNUSED   YY_ATTRIBUTE ((__unused__))
 
#define _Noreturn   YY_ATTRIBUTE ((__noreturn__))
 
#define YYUSE(E)   ((void) (E))
 
#define YY_INITIAL_VALUE(Value)   Value
 
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
 
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
 
#define YYSTACK_ALLOC   YYMALLOC
 
#define YYSTACK_FREE   YYFREE
 
#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM
 
#define YYMALLOC   malloc
 
#define YYFREE   free
 
#define YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)
 
#define YYSTACK_BYTES(N)
 
#define YYCOPY_NEEDED   1
 
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
 
#define YYCOPY(Dst, Src, Count)
 
#define YYFINAL   7
 
#define YYLAST   1206
 
#define YYNTOKENS   162
 
#define YYNNTS   161
 
#define YYNRULES   370
 
#define YYNSTATES   957
 
#define YYUNDEFTOK   2
 
#define YYMAXUTOK   398
 
#define YYTRANSLATE(YYX)   ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
 
#define YYPACT_NINF   -646
 
#define yypact_value_is_default(Yystate)   (!!((Yystate) == (-646)))
 
#define YYTABLE_NINF   -352
 
#define yytable_value_is_error(Yytable_value)   0
 
#define yyerrok   (yyerrstatus = 0)
 
#define yyclearin   (yychar = YYEMPTY)
 
#define YYEMPTY   (-2)
 
#define YYEOF   0
 
#define YYACCEPT   goto yyacceptlab
 
#define YYABORT   goto yyabortlab
 
#define YYERROR   goto yyerrorlab
 
#define YYRECOVERING()   (!!yyerrstatus)
 
#define YYBACKUP(Token, Value)
 
#define YYTERROR   1
 
#define YYERRCODE   256
 
#define YYLLOC_DEFAULT(Current, Rhs, N)
 
#define YYRHSLOC(Rhs, K)   ((Rhs)[K])
 
#define YYDPRINTF(Args)
 
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
 
#define YY_STACK_PRINT(Bottom, Top)
 
#define YY_REDUCE_PRINT(Rule)
 
#define YYINITDEPTH   200
 
#define YYMAXDEPTH   10000
 
#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
 

Typedefs

typedef unsigned char yytype_uint8
 
typedef signed char yytype_int8
 
typedef unsigned short int yytype_uint16
 
typedef short int yytype_int16
 

Functions

int yywrap (void)
 
int yylex (void)
 
int yyparse (void)
 
int parse_script (PacketDrillConfig *config, PacketDrillScript *script, struct invocation *callback_invocation)
 
void parse_and_finalize_config (struct invocation *invocation)
 
void * malloc (YYSIZE_T)
 
void free (void *)
 

Variables

FILE * yyin
 
int yylineno
 
char * yytext
 
struct invocation * invocation
 
YYSTYPE yylval
 
YYLTYPE yylloc = { 1, 1, 1, 1 }
 
int yychar
 
int yynerrs
 

Macro Definition Documentation

#define _Noreturn   YY_ATTRIBUTE ((__noreturn__))
#define YY_ (   Msgid)    Msgid

Referenced by yyparse().

#define YY_ATTRIBUTE (   Spec)    /* empty */
#define YY_ATTRIBUTE_PURE   YY_ATTRIBUTE ((__pure__))
#define YY_ATTRIBUTE_UNUSED   YY_ATTRIBUTE ((__unused__))
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

Referenced by yyparse().

#define YY_IGNORE_MAYBE_UNINITIALIZED_END

Referenced by yyparse().

#define YY_INITIAL_VALUE (   Value)    Value
#define YY_NULLPTR   0
#define YY_REDUCE_PRINT (   Rule)

Referenced by yyparse().

#define YY_STACK_PRINT (   Bottom,
  Top 
)

Referenced by yyparse().

#define YY_SYMBOL_PRINT (   Title,
  Type,
  Value,
  Location 
)

Referenced by yyparse().

#define YY_YY_PARSER_H_INCLUDED
#define YYABORT   goto yyabortlab

Referenced by yyparse().

#define YYACCEPT   goto yyacceptlab

Referenced by yyparse().

#define YYBACKUP (   Token,
  Value 
)
Value:
do \
if (yychar == YYEMPTY) \
{ \
yychar = (Token); \
yylval = (Value); \
YYPOPSTACK (yylen); \
yystate = *yyssp; \
goto yybackup; \
} \
else \
{ \
yyerror (YY_("syntax error: cannot back up")); \
YYERROR; \
} \
while (0)
YYERROR
#define YYERROR
Definition: parser.cc:1706
YYEMPTY
#define YYEMPTY
Definition: parser.cc:1701
YY_
#define YY_(Msgid)
Definition: parser.cc:585
yylval
YYSTYPE yylval
Definition: parser.cc:2196
yychar
int yychar
Definition: parser.cc:2193
YYPOPSTACK
#define YYPOPSTACK(N)
if
if(!(yy_init))
Definition: lexer.cc:1644
#define YYBISON   1
#define YYBISON_VERSION   "3.0.4"
#define yyclearin   (yychar = YYEMPTY)
#define YYCOPY (   Dst,
  Src,
  Count 
)
Value:
do \
{ \
YYSIZE_T yyi; \
for (yyi = 0; yyi < (Count); yyi++) \
(Dst)[yyi] = (Src)[yyi]; \
} \
while (0)
YYSIZE_T
#define YYSIZE_T
Definition: parser.cc:569
#define YYCOPY_NEEDED   1
#define YYDEBUG   0
#define YYDPRINTF (   Args)

Referenced by yyparse().

#define YYEMPTY   (-2)

Referenced by yyparse().

#define YYEOF   0

Referenced by yyparse().

#define YYERRCODE   256
#define yyerrok   (yyerrstatus = 0)
#define YYERROR   goto yyerrorlab
#define YYERROR_VERBOSE   0
#define YYFINAL   7

Referenced by yyparse().

#define YYFREE   free
#define YYINITDEPTH   200

Referenced by yyparse().

#define YYLAST   1206

Referenced by yyparse().

#define YYLLOC_DEFAULT (   Current,
  Rhs,
  N 
)
Value:
do \
if (N) \
{ \
(Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
(Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
(Current).last_line = YYRHSLOC (Rhs, N).last_line; \
(Current).last_column = YYRHSLOC (Rhs, N).last_column; \
} \
else \
{ \
(Current).first_line = (Current).last_line = \
YYRHSLOC (Rhs, 0).last_line; \
(Current).first_column = (Current).last_column = \
YYRHSLOC (Rhs, 0).last_column; \
} \
while (0)
YYRHSLOC
#define YYRHSLOC(Rhs, K)
Definition: parser.cc:1757
inet::units::value
Definition: Units.h:69
if
if(!(yy_init))
Definition: lexer.cc:1644

Referenced by yyparse().

#define YYMALLOC   malloc
#define YYMAXDEPTH   10000

Referenced by yyparse().

#define YYMAXUTOK   398
#define YYNNTS   161
#define YYNRULES   370
#define YYNSTATES   957
#define YYNTOKENS   162

Referenced by yyparse().

#define YYPACT_NINF   -646
#define yypact_value_is_default (   Yystate)    (!!((Yystate) == (-646)))

Referenced by yyparse().

#define YYPOPSTACK (   N)    (yyvsp -= (N), yyssp -= (N), yylsp -= (N))

Referenced by yyparse().

#define YYPULL   1
#define YYPURE   0
#define YYPUSH   0
#define YYRECOVERING ( )    (!!yyerrstatus)
#define YYRHSLOC (   Rhs,
  K 
)    ((Rhs)[K])
#define YYSIZE_MAXIMUM   ((YYSIZE_T) -1)
#define YYSIZE_T   size_t

Referenced by yyparse().

#define YYSKELETON_NAME   "yacc.c"
#define YYSTACK_ALLOC   YYMALLOC

Referenced by yyparse().

#define YYSTACK_ALLOC_MAXIMUM   YYSIZE_MAXIMUM
#define YYSTACK_BYTES (   N)
Value:
((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE) + sizeof (YYLTYPE)) \
+ 2 * YYSTACK_GAP_MAXIMUM)
YYLTYPE
Definition: parser.h:247
yytype_int16
short int yytype_int16
Definition: parser.cc:559
YYSTYPE
union YYSTYPE YYSTYPE
Definition: parser.h:239
inet::units::units::N
compose< m, compose< kg, pow< s,-2 > > > N
Definition: Units.h:767
YYSTACK_GAP_MAXIMUM
#define YYSTACK_GAP_MAXIMUM
Definition: parser.cc:725

Referenced by yyparse().

#define YYSTACK_FREE   YYFREE

Referenced by yyparse().

#define YYSTACK_GAP_MAXIMUM   (sizeof (union yyalloc) - 1)
#define YYSTACK_RELOCATE (   Stack_alloc,
  Stack 
)
Value:
do \
{ \
YYSIZE_T yynewbytes; \
YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
Stack = &yyptr->Stack_alloc; \
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
yyptr += yynewbytes / sizeof (*yyptr); \
} \
while (0)
YYCOPY
#define YYCOPY(Dst, Src, Count)
Definition: parser.cc:761
YYSIZE_T
#define YYSIZE_T
Definition: parser.cc:569
YYSTACK_GAP_MAXIMUM
#define YYSTACK_GAP_MAXIMUM
Definition: parser.cc:725

Referenced by yyparse().

#define YYTABLE_NINF   -352
#define yytable_value_is_error (   Yytable_value)    0

Referenced by yyparse().

#define YYTERROR   1

Referenced by yyparse().

#define YYTRANSLATE (   YYX)    ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)

Referenced by yyparse().

#define YYUNDEFTOK   2
#define YYUSE (   E)    ((void) (E))

Typedef Documentation

typedef short int yytype_int16
typedef signed char yytype_int8
typedef unsigned short int yytype_uint16
typedef unsigned char yytype_uint8

Function Documentation

void free ( void *  )

Referenced by inet::sctp::SCTPAssociation::cloneAssociation(), inet::serializer::SCTPSerializer::deserialize(), PacketDrill::evaluate(), inet::Macho::_MachineBase::getInstance(), if(), inet::sctp::SCTPAssociation::initAssociation(), inet::Macho::Machine< fsm::TopState >::Machine(), inet::serializer::SCTPSerializer::parse(), PacketDrillScript::readScript(), inet::PacketDrillApp::runSystemCallEvent(), PacketDrillOption::setName(), PacketDrillOption::setValue(), inet::Macho::StateHistory(), inet::PacketDrillApp::syscallSetsockopt(), yyparse(), inet::IntervalTree::~IntervalTree(), and inet::Macho::Machine< fsm::TopState >::~Machine().

void* malloc ( YYSIZE_T  )

Referenced by inet::sctp::SCTPAssociation::cloneAssociation(), inet::serializer::SCTPSerializer::deserialize(), PacketDrill::evaluate(), if(), inet::sctp::SCTPAssociation::initAssociation(), inet::IntervalTree::IntervalTree(), PacketDrillExpression::PacketDrillExpression(), inet::serializer::SCTPSerializer::parse(), PacketDrillScript::readScript(), PacketDrillExpression::unescapeCstringExpression(), and yyparse().

void parse_and_finalize_config ( struct invocation *  invocation)

Referenced by yyparse().

242 {
243  invocation->config->parseScriptOptions(invocation->script->getOptionList());
244 }
invocation::config
PacketDrillConfig * config
Definition: PacketDrillUtils.h:338
PacketDrillScript::getOptionList
cQueue * getOptionList()
Definition: PacketDrillUtils.h:622
PacketDrillConfig::parseScriptOptions
void parseScriptOptions(cQueue *options)
Definition: PacketDrillUtils.cc:104
invocation::script
PacketDrillScript * script
Definition: PacketDrillUtils.h:339
int parse_script ( PacketDrillConfig *  config,
PacketDrillScript *  script,
struct invocation *  callback_invocation 
)

Referenced by PacketDrillScript::parseScriptAndSetConfig().

206  {
207  /* This bison-generated parser is not multi-thread safe, so we
208  * have a lock to prevent more than one thread using the
209  * parser at the same time. This is useful in the wire server
210  * context, where in general we may have more than one test
211  * thread running at the same time.
212  */
213 
214 #if YYDEBUG
215  yydebug = 1;
216 #endif
217 
218  /* Now parse the script from our buffer. */
219  yyin = fopen(script->getScriptPath(), "r");
220  if (!yyin)
221  printf("fopen: parse error opening script buffer");
222  current_script_path = config->getScriptPath();
223  in_config = config;
224  out_script = script;
225  invocation = callback_invocation;
226 
227  /* We have to reset the line number here since the wire server
228  * can do more than one yyparse().
229  */
230  yylineno = 1;
231  int result = yyparse(); /* invoke bison-generated parser */
232  current_script_path = NULL;
233  if (fclose(yyin))
234  printf("fclose: error closing script buffer");
235 
236  /* Unlock parser. */
237 
238  return result ? -1 : 0;
239 }
yyparse
int yyparse(void)
Definition: parser.cc:2212
yyin
FILE * yyin
PacketDrillScript::getScriptPath
const char * getScriptPath()
Definition: PacketDrillUtils.h:620
invocation
Definition: PacketDrillUtils.h:337
yylineno
int yylineno
PacketDrillConfig::getScriptPath
const char * getScriptPath() const
Definition: PacketDrillUtils.h:456
int yylex ( void  )

Referenced by yyparse().

int yyparse ( void  )

Referenced by parse_script().

2213 {
2214  int yystate;
2215  /* Number of tokens to shift before error messages enabled. */
2216  int yyerrstatus;
2217 
2218  /* The stacks and their tools:
2219  'yyss': related to states.
2220  'yyvs': related to semantic values.
2221  'yyls': related to locations.
2222 
2223  Refer to the stacks through separate pointers, to allow yyoverflow
2224  to reallocate them elsewhere. */
2225 
2226  /* The state stack. */
2227  yytype_int16 yyssa[YYINITDEPTH];
2228  yytype_int16 *yyss;
2229  yytype_int16 *yyssp;
2230 
2231  /* The semantic value stack. */
2232  YYSTYPE yyvsa[YYINITDEPTH];
2233  YYSTYPE *yyvs;
2234  YYSTYPE *yyvsp;
2235 
2236  /* The location stack. */
2237  YYLTYPE yylsa[YYINITDEPTH];
2238  YYLTYPE *yyls;
2239  YYLTYPE *yylsp;
2240 
2241  /* The locations where the error started and ended. */
2242  YYLTYPE yyerror_range[3];
2243 
2244  YYSIZE_T yystacksize;
2245 
2246  int yyn;
2247  int yyresult;
2248  /* Lookahead token as an internal (translated) token number. */
2249  int yytoken = 0;
2250  /* The variables used to return semantic value and location from the
2251  action routines. */
2252  YYSTYPE yyval;
2253  YYLTYPE yyloc;
2254 
2255 #if YYERROR_VERBOSE
2256  /* Buffer for error messages, and its allocated size. */
2257  char yymsgbuf[128];
2258  char *yymsg = yymsgbuf;
2259  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2260 #endif
2261 
2262 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N), yylsp -= (N))
2263 
2264  /* The number of symbols on the RHS of the reduced rule.
2265  Keep to zero when no symbol should be popped. */
2266  int yylen = 0;
2267 
2268  yyssp = yyss = yyssa;
2269  yyvsp = yyvs = yyvsa;
2270  yylsp = yyls = yylsa;
2271  yystacksize = YYINITDEPTH;
2272 
2273  YYDPRINTF ((stderr, "Starting parse\n"));
2274 
2275  yystate = 0;
2276  yyerrstatus = 0;
2277  yynerrs = 0;
2278  yychar = YYEMPTY; /* Cause a token to be read. */
2279  yylsp[0] = yylloc;
2280  goto yysetstate;
2281 
2282 /*------------------------------------------------------------.
2283 | yynewstate -- Push a new state, which is found in yystate. |
2284 `------------------------------------------------------------*/
2285  yynewstate:
2286  /* In all cases, when you get here, the value and location stacks
2287  have just been pushed. So pushing a state here evens the stacks. */
2288  yyssp++;
2289 
2290  yysetstate:
2291  *yyssp = yystate;
2292 
2293  if (yyss + yystacksize - 1 <= yyssp)
2294  {
2295  /* Get the current used size of the three stacks, in elements. */
2296  YYSIZE_T yysize = yyssp - yyss + 1;
2297 
2298 #ifdef yyoverflow
2299  {
2300  /* Give user a chance to reallocate the stack. Use copies of
2301  these so that the &'s don't force the real ones into
2302  memory. */
2303  YYSTYPE *yyvs1 = yyvs;
2304  yytype_int16 *yyss1 = yyss;
2305  YYLTYPE *yyls1 = yyls;
2306 
2307  /* Each stack pointer address is followed by the size of the
2308  data in use in that stack, in bytes. This used to be a
2309  conditional around just the two extra args, but that might
2310  be undefined if yyoverflow is a macro. */
2311  yyoverflow (YY_("memory exhausted"),
2312  &yyss1, yysize * sizeof (*yyssp),
2313  &yyvs1, yysize * sizeof (*yyvsp),
2314  &yyls1, yysize * sizeof (*yylsp),
2315  &yystacksize);
2316 
2317  yyls = yyls1;
2318  yyss = yyss1;
2319  yyvs = yyvs1;
2320  }
2321 #else /* no yyoverflow */
2322 # ifndef YYSTACK_RELOCATE
2323  goto yyexhaustedlab;
2324 # else
2325  /* Extend the stack our own way. */
2326  if (YYMAXDEPTH <= yystacksize)
2327  goto yyexhaustedlab;
2328  yystacksize *= 2;
2329  if (YYMAXDEPTH < yystacksize)
2330  yystacksize = YYMAXDEPTH;
2331 
2332  {
2333  yytype_int16 *yyss1 = yyss;
2334  union yyalloc *yyptr =
2335  (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2336  if (! yyptr)
2337  goto yyexhaustedlab;
2338  YYSTACK_RELOCATE (yyss_alloc, yyss);
2339  YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2340  YYSTACK_RELOCATE (yyls_alloc, yyls);
2341 # undef YYSTACK_RELOCATE
2342  if (yyss1 != yyssa)
2343  YYSTACK_FREE (yyss1);
2344  }
2345 # endif
2346 #endif /* no yyoverflow */
2347 
2348  yyssp = yyss + yysize - 1;
2349  yyvsp = yyvs + yysize - 1;
2350  yylsp = yyls + yysize - 1;
2351 
2352  YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2353  (unsigned long int) yystacksize));
2354 
2355  if (yyss + yystacksize - 1 <= yyssp)
2356  YYABORT;
2357  }
2358 
2359  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2360 
2361  if (yystate == YYFINAL)
2362  YYACCEPT;
2363 
2364  goto yybackup;
2365 
2366 /*-----------.
2367 | yybackup. |
2368 `-----------*/
2369 yybackup:
2370 
2371  /* Do appropriate processing given the current state. Read a
2372  lookahead token if we need one and don't already have one. */
2373 
2374  /* First try to decide what to do without reference to lookahead token. */
2375  yyn = yypact[yystate];
2376  if (yypact_value_is_default (yyn))
2377  goto yydefault;
2378 
2379  /* Not known => get a lookahead token if don't already have one. */
2380 
2381  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2382  if (yychar == YYEMPTY)
2383  {
2384  YYDPRINTF ((stderr, "Reading a token: "));
2385  yychar = yylex ();
2386  }
2387 
2388  if (yychar <= YYEOF)
2389  {
2390  yychar = yytoken = YYEOF;
2391  YYDPRINTF ((stderr, "Now at end of input.\n"));
2392  }
2393  else
2394  {
2395  yytoken = YYTRANSLATE (yychar);
2396  YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2397  }
2398 
2399  /* If the proper action on seeing token YYTOKEN is to reduce or to
2400  detect an error, take that action. */
2401  yyn += yytoken;
2402  if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2403  goto yydefault;
2404  yyn = yytable[yyn];
2405  if (yyn <= 0)
2406  {
2407  if (yytable_value_is_error (yyn))
2408  goto yyerrlab;
2409  yyn = -yyn;
2410  goto yyreduce;
2411  }
2412 
2413  /* Count tokens shifted since error; after three, turn off error
2414  status. */
2415  if (yyerrstatus)
2416  yyerrstatus--;
2417 
2418  /* Shift the lookahead token. */
2419  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2420 
2421  /* Discard the shifted token. */
2422  yychar = YYEMPTY;
2423 
2424  yystate = yyn;
2425  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2426  *++yyvsp = yylval;
2427  YY_IGNORE_MAYBE_UNINITIALIZED_END
2428  *++yylsp = yylloc;
2429  goto yynewstate;
2430 
2431 
2432 /*-----------------------------------------------------------.
2433 | yydefault -- do the default action for the current state. |
2434 `-----------------------------------------------------------*/
2435 yydefault:
2436  yyn = yydefact[yystate];
2437  if (yyn == 0)
2438  goto yyerrlab;
2439  goto yyreduce;
2440 
2441 
2442 /*-----------------------------.
2443 | yyreduce -- Do a reduction. |
2444 `-----------------------------*/
2445 yyreduce:
2446  /* yyn is the number of a rule to reduce with. */
2447  yylen = yyr2[yyn];
2448 
2449  /* If YYLEN is nonzero, implement the default value of the action:
2450  '$$ = $1'.
2451 
2452  Otherwise, the following line sets YYVAL to garbage.
2453  This behavior is undocumented and Bison
2454  users should not rely upon it. Assigning to YYVAL
2455  unconditionally makes the parser a bit smaller, and it avoids a
2456  GCC warning that YYVAL may be used uninitialized. */
2457  yyval = yyvsp[1-yylen];
2458 
2459  /* Default location. */
2460  YYLLOC_DEFAULT (yyloc, (yylsp - yylen), yylen);
2461  YY_REDUCE_PRINT (yyn);
2462  switch (yyn)
2463  {
2464  case 2:
2465 #line 362 "parser.y" /* yacc.c:1646 */
2466  {
2467  (yyval.string) = NULL; /* The parser output is in out_script */
2468 }
2469 #line 2470 "parser.cc" /* yacc.c:1646 */
2470  break;
2471 
2472  case 3:
2473 #line 368 "parser.y" /* yacc.c:1646 */
2474  { (yyval.option) = NULL;
2475  parse_and_finalize_config(invocation);}
2476 #line 2477 "parser.cc" /* yacc.c:1646 */
2477  break;
2478 
2479  case 4:
2480 #line 370 "parser.y" /* yacc.c:1646 */
2481  {
2482  (yyval.option) = (yyvsp[0].option);
2483  parse_and_finalize_config(invocation);
2484 }
2485 #line 2486 "parser.cc" /* yacc.c:1646 */
2486  break;
2487 
2488  case 5:
2489 #line 377 "parser.y" /* yacc.c:1646 */
2490  {
2491  out_script->addOption((yyvsp[0].option));
2492  (yyval.option) = (yyvsp[0].option); /* return the tail so we can append to it */
2493 }
2494 #line 2495 "parser.cc" /* yacc.c:1646 */
2495  break;
2496 
2497  case 6:
2498 #line 381 "parser.y" /* yacc.c:1646 */
2499  {
2500  out_script->addOption((yyvsp[0].option));
2501  (yyval.option) = (yyvsp[0].option); /* return the tail so we can append to it */
2502 }
2503 #line 2504 "parser.cc" /* yacc.c:1646 */
2504  break;
2505 
2506  case 7:
2507 #line 388 "parser.y" /* yacc.c:1646 */
2508  {
2509  (yyval.option) = new PacketDrillOption((yyvsp[-2].string), (yyvsp[0].string));
2510 }
2511 #line 2512 "parser.cc" /* yacc.c:1646 */
2512  break;
2513 
2514  case 8:
2515 #line 393 "parser.y" /* yacc.c:1646 */
2516  { (yyval.string) = (yyvsp[0].reserved); }
2517 #line 2518 "parser.cc" /* yacc.c:1646 */
2518  break;
2519 
2520  case 9:
2521 #line 397 "parser.y" /* yacc.c:1646 */
2522  { (yyval.string) = strdup(yytext); }
2523 #line 2524 "parser.cc" /* yacc.c:1646 */
2524  break;
2525 
2526  case 10:
2527 #line 398 "parser.y" /* yacc.c:1646 */
2528  { (yyval.string) = (yyvsp[0].string); }
2529 #line 2530 "parser.cc" /* yacc.c:1646 */
2530  break;
2531 
2532  case 11:
2533 #line 399 "parser.y" /* yacc.c:1646 */
2534  { (yyval.string) = (yyvsp[0].string); }
2535 #line 2536 "parser.cc" /* yacc.c:1646 */
2536  break;
2537 
2538  case 12:
2539 #line 404 "parser.y" /* yacc.c:1646 */
2540  {
2541  out_script->addEvent((yyvsp[0].event)); /* save pointer to event list as output of parser */
2542  (yyval.event) = (yyvsp[0].event); /* return the tail so that we can append to it */
2543 }
2544 #line 2545 "parser.cc" /* yacc.c:1646 */
2545  break;
2546 
2547  case 13:
2548 #line 408 "parser.y" /* yacc.c:1646 */
2549  {
2550  out_script->addEvent((yyvsp[0].event));
2551  (yyval.event) = (yyvsp[0].event); /* return the tail so that we can append to it */
2552 }
2553 #line 2554 "parser.cc" /* yacc.c:1646 */
2554  break;
2555 
2556  case 14:
2557 #line 415 "parser.y" /* yacc.c:1646 */
2558  {
2559  (yyval.event) = (yyvsp[0].event);
2560  (yyval.event)->setLineNumber((yyvsp[-1].event)->getLineNumber()); /* use timestamp's line */
2561  (yyval.event)->setEventTime((yyvsp[-1].event)->getEventTime());
2562  (yyval.event)->setEventTimeEnd((yyvsp[-1].event)->getEventTimeEnd());
2563  (yyval.event)->setTimeType((yyvsp[-1].event)->getTimeType());
2564  (yyvsp[-1].event)->getLineNumber(),
2565  (yyvsp[-1].event)->getEventTime().dbl(),
2566  (yyvsp[-1].event)->getEventTimeEnd().dbl(),
2567  (yyvsp[-1].event)->getTimeType();
2568  if ((yyval.event)->getEventTimeEnd() != NO_TIME_RANGE) {
2569  if ((yyval.event)->getEventTimeEnd() < (yyval.event)->getEventTime())
2570  semantic_error("time range is backwards");
2571  }
2572  if ((yyval.event)->getTimeType() == ANY_TIME && ((yyval.event)->getType() != PACKET_EVENT ||
2573  ((yyval.event)->getPacket())->getDirection() != DIRECTION_OUTBOUND)) {
2574  yylineno = (yyval.event)->getLineNumber();
2575  semantic_error("event time <star> can only be used with outbound packets");
2576  } else if (((yyval.event)->getTimeType() == ABSOLUTE_RANGE_TIME ||
2577  (yyval.event)->getTimeType() == RELATIVE_RANGE_TIME) &&
2578  ((yyval.event)->getType() != PACKET_EVENT ||
2579  ((yyval.event)->getPacket())->getDirection() != DIRECTION_OUTBOUND)) {
2580  yylineno = (yyval.event)->getLineNumber();
2581  semantic_error("event time range can only be used with outbound packets");
2582  }
2583  delete((yyvsp[-1].event));
2584 }
2585 #line 2586 "parser.cc" /* yacc.c:1646 */
2586  break;
2587 
2588  case 15:
2589 #line 445 "parser.y" /* yacc.c:1646 */
2590  {
2591  (yyval.event) = new PacketDrillEvent(INVALID_EVENT);
2592  (yyval.event)->setLineNumber((yylsp[0]).first_line);
2593  (yyval.event)->setEventTime((yyvsp[0].time_usecs));
2594  (yyval.event)->setTimeType(RELATIVE_TIME);
2595 }
2596 #line 2597 "parser.cc" /* yacc.c:1646 */
2597  break;
2598 
2599  case 16:
2600 #line 451 "parser.y" /* yacc.c:1646 */
2601  {
2602  (yyval.event) = new PacketDrillEvent(INVALID_EVENT);
2603  (yyval.event)->setLineNumber((yylsp[0]).first_line);
2604  (yyval.event)->setEventTime((yyvsp[0].time_usecs));
2605  (yyval.event)->setTimeType(ABSOLUTE_TIME);
2606 }
2607 #line 2608 "parser.cc" /* yacc.c:1646 */
2608  break;
2609 
2610  case 17:
2611 #line 457 "parser.y" /* yacc.c:1646 */
2612  {
2613  (yyval.event) = new PacketDrillEvent(INVALID_EVENT);
2614  (yyval.event)->setLineNumber((yylsp[0]).first_line);
2615  (yyval.event)->setTimeType(ANY_TIME);
2616 }
2617 #line 2618 "parser.cc" /* yacc.c:1646 */
2618  break;
2619 
2620  case 18:
2621 #line 462 "parser.y" /* yacc.c:1646 */
2622  {
2623  (yyval.event) = new PacketDrillEvent(INVALID_EVENT);
2624  (yyval.event)->setLineNumber((yylsp[-2]).first_line);
2625  (yyval.event)->setTimeType(ABSOLUTE_RANGE_TIME);
2626  (yyval.event)->setEventTime((yyvsp[-2].time_usecs));
2627  (yyval.event)->setEventTimeEnd((yyvsp[0].time_usecs));
2628 }
2629 #line 2630 "parser.cc" /* yacc.c:1646 */
2630  break;
2631 
2632  case 19:
2633 #line 469 "parser.y" /* yacc.c:1646 */
2634  {
2635  (yyval.event) = new PacketDrillEvent(INVALID_EVENT);
2636  (yyval.event)->setLineNumber((yylsp[-4]).first_line);
2637  (yyval.event)->setTimeType(RELATIVE_RANGE_TIME);
2638  (yyval.event)->setEventTime((yyvsp[-3].time_usecs));
2639  (yyval.event)->setEventTimeEnd((yyvsp[0].time_usecs));
2640 }
2641 #line 2642 "parser.cc" /* yacc.c:1646 */
2642  break;
2643 
2644  case 20:
2645 #line 479 "parser.y" /* yacc.c:1646 */
2646  {
2647  if ((yyvsp[0].floating) < 0) {
2648  semantic_error("negative time");
2649  }
2650  (yyval.time_usecs) = (int64)((yyvsp[0].floating) * 1.0e6); /* convert float secs to s64 microseconds */
2651 }
2652 #line 2653 "parser.cc" /* yacc.c:1646 */
2653  break;
2654 
2655  case 21:
2656 #line 485 "parser.y" /* yacc.c:1646 */
2657  {
2658  if ((yyvsp[0].integer) < 0) {
2659  semantic_error("negative time");
2660  }
2661  (yyval.time_usecs) = (int64)((yyvsp[0].integer) * 1000000); /* convert int secs to s64 microseconds */
2662 }
2663 #line 2664 "parser.cc" /* yacc.c:1646 */
2664  break;
2665 
2666  case 22:
2667 #line 494 "parser.y" /* yacc.c:1646 */
2668  {
2669  if ((yyvsp[0].packet)) {
2670  (yyval.event) = new PacketDrillEvent(PACKET_EVENT); (yyval.event)->setPacket((yyvsp[0].packet));
2671  } else {
2672  (yyval.event) = NULL;
2673  }
2674 }
2675 #line 2676 "parser.cc" /* yacc.c:1646 */
2676  break;
2677 
2678  case 23:
2679 #line 501 "parser.y" /* yacc.c:1646 */
2680  {
2681  (yyval.event) = new PacketDrillEvent(SYSCALL_EVENT);
2682  (yyval.event)->setSyscall((yyvsp[0].syscall));
2683 }
2684 #line 2685 "parser.cc" /* yacc.c:1646 */
2685  break;
2686 
2687  case 24:
2688 #line 505 "parser.y" /* yacc.c:1646 */
2689  {
2690  (yyval.event) = new PacketDrillEvent(COMMAND_EVENT);
2691  (yyval.event)->setCommand((yyvsp[0].command));
2692 }
2693 #line 2694 "parser.cc" /* yacc.c:1646 */
2694  break;
2695 
2696  case 25:
2697 #line 512 "parser.y" /* yacc.c:1646 */
2698  {
2699  (yyval.command) = (struct command_spec *)calloc(1, sizeof(struct command_spec));
2700  (yyval.command)->command_line = (yyvsp[0].reserved);
2701 }
2702 #line 2703 "parser.cc" /* yacc.c:1646 */
2703  break;
2704 
2705  case 26:
2706 #line 519 "parser.y" /* yacc.c:1646 */
2707  {
2708  (yyval.packet) = (yyvsp[0].packet);
2709 }
2710 #line 2711 "parser.cc" /* yacc.c:1646 */
2711  break;
2712 
2713  case 27:
2714 #line 522 "parser.y" /* yacc.c:1646 */
2715  {
2716  (yyval.packet) = (yyvsp[0].packet);
2717 }
2718 #line 2719 "parser.cc" /* yacc.c:1646 */
2719  break;
2720 
2721  case 28:
2722 #line 525 "parser.y" /* yacc.c:1646 */
2723  {
2724  (yyval.packet) = (yyvsp[0].packet);
2725 }
2726 #line 2727 "parser.cc" /* yacc.c:1646 */
2727  break;
2728 
2729  case 29:
2730 #line 531 "parser.y" /* yacc.c:1646 */
2731  {
2732  char *error = NULL;
2733  PacketDrillPacket *outer = (yyvsp[-5].packet), *inner = NULL;
2734  enum direction_t direction = outer->getDirection();
2735 
2736  if (((yyvsp[0].tcp_options) == NULL) && (direction != DIRECTION_OUTBOUND)) {
2737  yylineno = (yylsp[0]).first_line;
2738  printf("<...> for TCP options can only be used with outbound packets");
2739  }
2740  cPacket* pkt = PacketDrill::buildTCPPacket(in_config->getWireProtocol(), direction,
2741  (yyvsp[-4].string),
2742  (yyvsp[-3].tcp_sequence_info).start_sequence, (yyvsp[-3].tcp_sequence_info).payload_bytes,
2743  (yyvsp[-2].sequence_number), (yyvsp[-1].window), (yyvsp[0].tcp_options), &error);
2744 
2745  free((yyvsp[-4].string));
2746 
2747  inner = new PacketDrillPacket();
2748  inner->setInetPacket(pkt);
2749 
2750  inner->setDirection(direction);
2751 
2752  (yyval.packet) = inner;
2753 }
2754 #line 2755 "parser.cc" /* yacc.c:1646 */
2755  break;
2756 
2757  case 30:
2758 #line 557 "parser.y" /* yacc.c:1646 */
2759  {
2760  char *error = NULL;
2761  PacketDrillPacket *outer = (yyvsp[-4].packet), *inner = NULL;
2762 
2763  enum direction_t direction = outer->getDirection();
2764  cPacket* pkt = PacketDrill::buildUDPPacket(in_config->getWireProtocol(), direction, (yyvsp[-1].integer), &error);
2765  if (direction == DIRECTION_INBOUND)
2766  pkt->setName("parserInbound");
2767  else
2768  pkt->setName("parserOutbound");
2769  inner = new PacketDrillPacket();
2770  inner->setInetPacket(pkt);
2771  inner->setDirection(direction);
2772 
2773  (yyval.packet) = inner;
2774 }
2775 #line 2776 "parser.cc" /* yacc.c:1646 */
2776  break;
2777 
2778  case 31:
2779 #line 576 "parser.y" /* yacc.c:1646 */
2780  {
2781  PacketDrillPacket *inner = NULL;
2782  enum direction_t direction = (yyvsp[-3].packet)->getDirection();
2783  cPacket* pkt = PacketDrill::buildSCTPPacket(in_config->getWireProtocol(), direction, (yyvsp[0].sctp_chunk_list));
2784  if (pkt) {
2785  if (direction == DIRECTION_INBOUND)
2786  pkt->setName("parserInbound");
2787  else
2788  pkt->setName("parserOutbound");
2789  inner = new PacketDrillPacket();
2790  inner->setInetPacket(pkt);
2791  inner->setDirection(direction);
2792  } else {
2793  semantic_error("inbound packets must be fully specified");
2794  }
2795  (yyval.packet) = inner;
2796 }
2797 #line 2798 "parser.cc" /* yacc.c:1646 */
2798  break;
2799 
2800  case 32:
2801 #line 596 "parser.y" /* yacc.c:1646 */
2802  { (yyval.sctp_chunk_list) = new cQueue("sctpChunkList");
2803  (yyval.sctp_chunk_list)->insert((cObject*)(yyvsp[0].sctp_chunk)); }
2804 #line 2805 "parser.cc" /* yacc.c:1646 */
2805  break;
2806 
2807  case 33:
2808 #line 598 "parser.y" /* yacc.c:1646 */
2809  { (yyval.sctp_chunk_list) = (yyvsp[-2].sctp_chunk_list);
2810  (yyval.sctp_chunk_list)->insert((yyvsp[0].sctp_chunk)); }
2811 #line 2812 "parser.cc" /* yacc.c:1646 */
2812  break;
2813 
2814  case 34:
2815 #line 604 "parser.y" /* yacc.c:1646 */
2816  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2817 #line 2818 "parser.cc" /* yacc.c:1646 */
2818  break;
2819 
2820  case 35:
2821 #line 605 "parser.y" /* yacc.c:1646 */
2822  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2823 #line 2824 "parser.cc" /* yacc.c:1646 */
2824  break;
2825 
2826  case 36:
2827 #line 606 "parser.y" /* yacc.c:1646 */
2828  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2829 #line 2830 "parser.cc" /* yacc.c:1646 */
2830  break;
2831 
2832  case 37:
2833 #line 607 "parser.y" /* yacc.c:1646 */
2834  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2835 #line 2836 "parser.cc" /* yacc.c:1646 */
2836  break;
2837 
2838  case 38:
2839 #line 608 "parser.y" /* yacc.c:1646 */
2840  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2841 #line 2842 "parser.cc" /* yacc.c:1646 */
2842  break;
2843 
2844  case 39:
2845 #line 609 "parser.y" /* yacc.c:1646 */
2846  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2847 #line 2848 "parser.cc" /* yacc.c:1646 */
2848  break;
2849 
2850  case 40:
2851 #line 610 "parser.y" /* yacc.c:1646 */
2852  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2853 #line 2854 "parser.cc" /* yacc.c:1646 */
2854  break;
2855 
2856  case 41:
2857 #line 611 "parser.y" /* yacc.c:1646 */
2858  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2859 #line 2860 "parser.cc" /* yacc.c:1646 */
2860  break;
2861 
2862  case 42:
2863 #line 612 "parser.y" /* yacc.c:1646 */
2864  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2865 #line 2866 "parser.cc" /* yacc.c:1646 */
2866  break;
2867 
2868  case 43:
2869 #line 613 "parser.y" /* yacc.c:1646 */
2870  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2871 #line 2872 "parser.cc" /* yacc.c:1646 */
2872  break;
2873 
2874  case 44:
2875 #line 614 "parser.y" /* yacc.c:1646 */
2876  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2877 #line 2878 "parser.cc" /* yacc.c:1646 */
2878  break;
2879 
2880  case 45:
2881 #line 615 "parser.y" /* yacc.c:1646 */
2882  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2883 #line 2884 "parser.cc" /* yacc.c:1646 */
2884  break;
2885 
2886  case 46:
2887 #line 616 "parser.y" /* yacc.c:1646 */
2888  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2889 #line 2890 "parser.cc" /* yacc.c:1646 */
2890  break;
2891 
2892  case 47:
2893 #line 617 "parser.y" /* yacc.c:1646 */
2894  { (yyval.sctp_chunk) = (yyvsp[0].sctp_chunk); }
2895 #line 2896 "parser.cc" /* yacc.c:1646 */
2896  break;
2897 
2898  case 48:
2899 #line 622 "parser.y" /* yacc.c:1646 */
2900  { (yyval.integer) = -1; }
2901 #line 2902 "parser.cc" /* yacc.c:1646 */
2902  break;
2903 
2904  case 49:
2905 #line 623 "parser.y" /* yacc.c:1646 */
2906  {
2907  if (!is_valid_u8((yyvsp[0].integer))) {
2908  semantic_error("flags value out of range");
2909  }
2910  (yyval.integer) = (yyvsp[0].integer);
2911 }
2912 #line 2913 "parser.cc" /* yacc.c:1646 */
2913  break;
2914 
2915  case 50:
2916 #line 629 "parser.y" /* yacc.c:1646 */
2917  {
2918  if (!is_valid_u8((yyvsp[0].integer))) {
2919  semantic_error("flags value out of range");
2920  }
2921  (yyval.integer) = (yyvsp[0].integer);
2922 }
2923 #line 2924 "parser.cc" /* yacc.c:1646 */
2924  break;
2925 
2926  case 51:
2927 #line 638 "parser.y" /* yacc.c:1646 */
2928  { (yyval.integer) = -1; }
2929 #line 2930 "parser.cc" /* yacc.c:1646 */
2930  break;
2931 
2932  case 52:
2933 #line 639 "parser.y" /* yacc.c:1646 */
2934  {
2935  if (!is_valid_u16((yyvsp[0].integer))) {
2936  semantic_error("length value out of range");
2937  }
2938  (yyval.integer) = (yyvsp[0].integer);
2939 }
2940 #line 2941 "parser.cc" /* yacc.c:1646 */
2941  break;
2942 
2943  case 53:
2944 #line 648 "parser.y" /* yacc.c:1646 */
2945  { (yyval.byte_list) = NULL; }
2946 #line 2947 "parser.cc" /* yacc.c:1646 */
2947  break;
2948 
2949  case 54:
2950 #line 649 "parser.y" /* yacc.c:1646 */
2951  { (yyval.byte_list) = NULL; }
2952 #line 2953 "parser.cc" /* yacc.c:1646 */
2953  break;
2954 
2955  case 55:
2956 #line 650 "parser.y" /* yacc.c:1646 */
2957  { (yyval.byte_list) = (yyvsp[-1].byte_list); }
2958 #line 2959 "parser.cc" /* yacc.c:1646 */
2959  break;
2960 
2961  case 56:
2962 #line 654 "parser.y" /* yacc.c:1646 */
2963  { (yyval.byte_list) = new PacketDrillBytes((yyvsp[0].byte)); }
2964 #line 2965 "parser.cc" /* yacc.c:1646 */
2965  break;
2966 
2967  case 57:
2968 #line 655 "parser.y" /* yacc.c:1646 */
2969  { (yyval.byte_list) = (yyvsp[-2].byte_list);
2970  (yyvsp[-2].byte_list)->appendByte((yyvsp[0].byte)); }
2971 #line 2972 "parser.cc" /* yacc.c:1646 */
2972  break;
2973 
2974  case 58:
2975 #line 660 "parser.y" /* yacc.c:1646 */
2976  { (yyval.byte_list) = new PacketDrillBytes();}
2977 #line 2978 "parser.cc" /* yacc.c:1646 */
2978  break;
2979 
2980  case 59:
2981 #line 661 "parser.y" /* yacc.c:1646 */
2982  { (yyval.byte_list) = new PacketDrillBytes((yyvsp[0].integer));}
2983 #line 2984 "parser.cc" /* yacc.c:1646 */
2984  break;
2985 
2986  case 60:
2987 #line 662 "parser.y" /* yacc.c:1646 */
2988  { (yyval.byte_list) = (yyvsp[-2].byte_list);
2989  (yyvsp[-2].byte_list)->appendByte((yyvsp[0].integer)); }
2990 #line 2991 "parser.cc" /* yacc.c:1646 */
2991  break;
2992 
2993  case 61:
2994 #line 667 "parser.y" /* yacc.c:1646 */
2995  {
2996  if (!is_valid_u8((yyvsp[0].integer))) {
2997  semantic_error("byte value out of range");
2998  }
2999  (yyval.byte) = (yyvsp[0].integer);
3000 }
3001 #line 3002 "parser.cc" /* yacc.c:1646 */
3002  break;
3003 
3004  case 62:
3005 #line 673 "parser.y" /* yacc.c:1646 */
3006  {
3007  if (!is_valid_u8((yyvsp[0].integer))) {
3008  semantic_error("byte value out of range");
3009  }
3010  (yyval.byte) = (yyvsp[0].integer);
3011 }
3012 #line 3013 "parser.cc" /* yacc.c:1646 */
3013  break;
3014 
3015  case 63:
3016 #line 682 "parser.y" /* yacc.c:1646 */
3017  {
3018  if (!is_valid_u8((yyvsp[0].integer))) {
3019  semantic_error("type value out of range");
3020  }
3021  (yyval.integer) = (yyvsp[0].integer);
3022 }
3023 #line 3024 "parser.cc" /* yacc.c:1646 */
3024  break;
3025 
3026  case 64:
3027 #line 688 "parser.y" /* yacc.c:1646 */
3028  {
3029  if (!is_valid_u8((yyvsp[0].integer))) {
3030  semantic_error("type value out of range");
3031  }
3032  (yyval.integer) = (yyvsp[0].integer);
3033 }
3034 #line 3035 "parser.cc" /* yacc.c:1646 */
3035  break;
3036 
3037  case 65:
3038 #line 694 "parser.y" /* yacc.c:1646 */
3039  {
3040  (yyval.integer) = SCTP_DATA_CHUNK_TYPE;
3041 }
3042 #line 3043 "parser.cc" /* yacc.c:1646 */
3043  break;
3044 
3045  case 66:
3046 #line 697 "parser.y" /* yacc.c:1646 */
3047  {
3048  (yyval.integer) = SCTP_INIT_CHUNK_TYPE;
3049 }
3050 #line 3051 "parser.cc" /* yacc.c:1646 */
3051  break;
3052 
3053  case 67:
3054 #line 700 "parser.y" /* yacc.c:1646 */
3055  {
3056  (yyval.integer) = SCTP_INIT_ACK_CHUNK_TYPE;
3057 }
3058 #line 3059 "parser.cc" /* yacc.c:1646 */
3059  break;
3060 
3061  case 68:
3062 #line 703 "parser.y" /* yacc.c:1646 */
3063  {
3064  (yyval.integer) = SCTP_SACK_CHUNK_TYPE;
3065 }
3066 #line 3067 "parser.cc" /* yacc.c:1646 */
3067  break;
3068 
3069  case 69:
3070 #line 706 "parser.y" /* yacc.c:1646 */
3071  {
3072  (yyval.integer) = SCTP_HEARTBEAT_CHUNK_TYPE;
3073 }
3074 #line 3075 "parser.cc" /* yacc.c:1646 */
3075  break;
3076 
3077  case 70:
3078 #line 709 "parser.y" /* yacc.c:1646 */
3079  {
3080  (yyval.integer) = SCTP_HEARTBEAT_ACK_CHUNK_TYPE;
3081 }
3082 #line 3083 "parser.cc" /* yacc.c:1646 */
3083  break;
3084 
3085  case 71:
3086 #line 712 "parser.y" /* yacc.c:1646 */
3087  {
3088  (yyval.integer) = SCTP_ABORT_CHUNK_TYPE;
3089 }
3090 #line 3091 "parser.cc" /* yacc.c:1646 */
3091  break;
3092 
3093  case 72:
3094 #line 715 "parser.y" /* yacc.c:1646 */
3095  {
3096  (yyval.integer) = SCTP_SHUTDOWN_CHUNK_TYPE;
3097 }
3098 #line 3099 "parser.cc" /* yacc.c:1646 */
3099  break;
3100 
3101  case 73:
3102 #line 718 "parser.y" /* yacc.c:1646 */
3103  {
3104  (yyval.integer) = SCTP_SHUTDOWN_ACK_CHUNK_TYPE;
3105 }
3106 #line 3107 "parser.cc" /* yacc.c:1646 */
3107  break;
3108 
3109  case 74:
3110 #line 721 "parser.y" /* yacc.c:1646 */
3111  {
3112  (yyval.integer) = SCTP_ERROR_CHUNK_TYPE;
3113 }
3114 #line 3115 "parser.cc" /* yacc.c:1646 */
3115  break;
3116 
3117  case 75:
3118 #line 724 "parser.y" /* yacc.c:1646 */
3119  {
3120  (yyval.integer) = SCTP_COOKIE_ECHO_CHUNK_TYPE;
3121 }
3122 #line 3123 "parser.cc" /* yacc.c:1646 */
3123  break;
3124 
3125  case 76:
3126 #line 727 "parser.y" /* yacc.c:1646 */
3127  {
3128  (yyval.integer) = SCTP_COOKIE_ACK_CHUNK_TYPE;
3129 }
3130 #line 3131 "parser.cc" /* yacc.c:1646 */
3131  break;
3132 
3133  case 77:
3134 #line 730 "parser.y" /* yacc.c:1646 */
3135  {
3136  (yyval.integer) = SCTP_SHUTDOWN_COMPLETE_CHUNK_TYPE;
3137 }
3138 #line 3139 "parser.cc" /* yacc.c:1646 */
3139  break;
3140 
3141  case 78:
3142 #line 733 "parser.y" /* yacc.c:1646 */
3143  {
3144  (yyval.integer) = SCTP_PAD_CHUNK_TYPE;
3145 }
3146 #line 3147 "parser.cc" /* yacc.c:1646 */
3147  break;
3148 
3149  case 79:
3150 #line 736 "parser.y" /* yacc.c:1646 */
3151  {
3152  (yyval.integer) = SCTP_RECONFIG_CHUNK_TYPE;
3153 }
3154 #line 3155 "parser.cc" /* yacc.c:1646 */
3155  break;
3156 
3157  case 80:
3158 #line 742 "parser.y" /* yacc.c:1646 */
3159  { (yyval.integer) = -1; }
3160 #line 3161 "parser.cc" /* yacc.c:1646 */
3161  break;
3162 
3163  case 81:
3164 #line 743 "parser.y" /* yacc.c:1646 */
3165  {
3166  if (!is_valid_u8((yyvsp[0].integer))) {
3167  semantic_error("flags value out of range");
3168  }
3169  (yyval.integer) = (yyvsp[0].integer);
3170 }
3171 #line 3172 "parser.cc" /* yacc.c:1646 */
3172  break;
3173 
3174  case 82:
3175 #line 749 "parser.y" /* yacc.c:1646 */
3176  {
3177  if (!is_valid_u8((yyvsp[0].integer))) {
3178  semantic_error("flags value out of range");
3179  }
3180  (yyval.integer) = (yyvsp[0].integer);
3181 }
3182 #line 3183 "parser.cc" /* yacc.c:1646 */
3183  break;
3184 
3185  case 83:
3186 #line 755 "parser.y" /* yacc.c:1646 */
3187  {
3188  uint64 flags;
3189  char *c;
3190 
3191  flags = 0;
3192  for (c = (yyvsp[0].string); *c != '\0'; c++) {
3193  switch (*c) {
3194  case 'I':
3195  if (flags & SCTP_DATA_CHUNK_I_BIT) {
3196  semantic_error("I-bit specified multiple times");
3197  } else {
3198  flags |= SCTP_DATA_CHUNK_I_BIT;
3199  }
3200  break;
3201  case 'U':
3202  if (flags & SCTP_DATA_CHUNK_U_BIT) {
3203  semantic_error("U-bit specified multiple times");
3204  } else {
3205  flags |= SCTP_DATA_CHUNK_U_BIT;
3206  }
3207  break;
3208  case 'B':
3209  if (flags & SCTP_DATA_CHUNK_B_BIT) {
3210  semantic_error("B-bit specified multiple times");
3211  } else {
3212  flags |= SCTP_DATA_CHUNK_B_BIT;
3213  }
3214  break;
3215  case 'E':
3216  if (flags & SCTP_DATA_CHUNK_E_BIT) {
3217  semantic_error("E-bit specified multiple times");
3218  } else {
3219  flags |= SCTP_DATA_CHUNK_E_BIT;
3220  }
3221  break;
3222  default:
3223  semantic_error("Only expecting IUBE as flags");
3224  }
3225  }
3226  (yyval.integer) = flags;
3227 }
3228 #line 3229 "parser.cc" /* yacc.c:1646 */
3229  break;
3230 
3231  case 84:
3232 #line 799 "parser.y" /* yacc.c:1646 */
3233  { (yyval.integer) = -1; }
3234 #line 3235 "parser.cc" /* yacc.c:1646 */
3235  break;
3236 
3237  case 85:
3238 #line 800 "parser.y" /* yacc.c:1646 */
3239  {
3240  if (!is_valid_u8((yyvsp[0].integer))) {
3241  semantic_error("flags value out of range");
3242  }
3243  (yyval.integer) = (yyvsp[0].integer);
3244 }
3245 #line 3246 "parser.cc" /* yacc.c:1646 */
3246  break;
3247 
3248  case 86:
3249 #line 806 "parser.y" /* yacc.c:1646 */
3250  {
3251  if (!is_valid_u8((yyvsp[0].integer))) {
3252  semantic_error("flags value out of range");
3253  }
3254  (yyval.integer) = (yyvsp[0].integer);
3255 }
3256 #line 3257 "parser.cc" /* yacc.c:1646 */
3257  break;
3258 
3259  case 87:
3260 #line 812 "parser.y" /* yacc.c:1646 */
3261  {
3262  uint64 flags;
3263  char *c;
3264 
3265  flags = 0;
3266  for (c = (yyvsp[0].string); *c != '\0'; c++) {
3267  switch (*c) {
3268  case 'T':
3269  if (flags & SCTP_ABORT_CHUNK_T_BIT) {
3270  semantic_error("T-bit specified multiple times");
3271  } else {
3272  flags |= SCTP_ABORT_CHUNK_T_BIT;
3273  }
3274  break;
3275  default:
3276  semantic_error("Only expecting T as flags");
3277  }
3278  }
3279  (yyval.integer) = flags;
3280 }
3281 #line 3282 "parser.cc" /* yacc.c:1646 */
3282  break;
3283 
3284  case 88:
3285 #line 835 "parser.y" /* yacc.c:1646 */
3286  { (yyval.integer) = -1; }
3287 #line 3288 "parser.cc" /* yacc.c:1646 */
3288  break;
3289 
3290  case 89:
3291 #line 836 "parser.y" /* yacc.c:1646 */
3292  {
3293  if (!is_valid_u8((yyvsp[0].integer))) {
3294  semantic_error("flags value out of range");
3295  }
3296  (yyval.integer) = (yyvsp[0].integer);
3297 }
3298 #line 3299 "parser.cc" /* yacc.c:1646 */
3299  break;
3300 
3301  case 90:
3302 #line 842 "parser.y" /* yacc.c:1646 */
3303  {
3304  if (!is_valid_u8((yyvsp[0].integer))) {
3305  semantic_error("flags value out of range");
3306  }
3307  (yyval.integer) = (yyvsp[0].integer);
3308 }
3309 #line 3310 "parser.cc" /* yacc.c:1646 */
3310  break;
3311 
3312  case 91:
3313 #line 848 "parser.y" /* yacc.c:1646 */
3314  {
3315  uint64 flags;
3316  char *c;
3317 
3318  flags = 0;
3319  for (c = (yyvsp[0].string); *c != '\0'; c++) {
3320  switch (*c) {
3321  case 'T':
3322  if (flags & SCTP_SHUTDOWN_COMPLETE_CHUNK_T_BIT) {
3323  semantic_error("T-bit specified multiple times");
3324  } else {
3325  flags |= SCTP_SHUTDOWN_COMPLETE_CHUNK_T_BIT;
3326  }
3327  break;
3328  default:
3329  semantic_error("Only expecting T as flags");
3330  }
3331  }
3332  (yyval.integer) = flags;
3333 }
3334 #line 3335 "parser.cc" /* yacc.c:1646 */
3335  break;
3336 
3337  case 92:
3338 #line 871 "parser.y" /* yacc.c:1646 */
3339  { (yyval.integer) = -1; }
3340 #line 3341 "parser.cc" /* yacc.c:1646 */
3341  break;
3342 
3343  case 93:
3344 #line 872 "parser.y" /* yacc.c:1646 */
3345  {
3346  if (!is_valid_u32((yyvsp[0].integer))) {
3347  semantic_error("tag value out of range");
3348  }
3349  (yyval.integer) = (yyvsp[0].integer);
3350 }
3351 #line 3352 "parser.cc" /* yacc.c:1646 */
3352  break;
3353 
3354  case 94:
3355 #line 881 "parser.y" /* yacc.c:1646 */
3356  { (yyval.integer) = -1; }
3357 #line 3358 "parser.cc" /* yacc.c:1646 */
3358  break;
3359 
3360  case 95:
3361 #line 882 "parser.y" /* yacc.c:1646 */
3362  {
3363  if (!is_valid_u32((yyvsp[0].integer))) {
3364  semantic_error("a_rwnd value out of range");
3365  }
3366  (yyval.integer) = (yyvsp[0].integer);
3367 }
3368 #line 3369 "parser.cc" /* yacc.c:1646 */
3369  break;
3370 
3371  case 96:
3372 #line 891 "parser.y" /* yacc.c:1646 */
3373  { (yyval.integer) = -1; }
3374 #line 3375 "parser.cc" /* yacc.c:1646 */
3375  break;
3376 
3377  case 97:
3378 #line 892 "parser.y" /* yacc.c:1646 */
3379  {
3380  if (!is_valid_u16((yyvsp[0].integer))) {
3381  semantic_error("os value out of range");
3382  }
3383  (yyval.integer) = (yyvsp[0].integer);
3384 }
3385 #line 3386 "parser.cc" /* yacc.c:1646 */
3386  break;
3387 
3388  case 98:
3389 #line 901 "parser.y" /* yacc.c:1646 */
3390  { (yyval.integer) = -1; }
3391 #line 3392 "parser.cc" /* yacc.c:1646 */
3392  break;
3393 
3394  case 99:
3395 #line 902 "parser.y" /* yacc.c:1646 */
3396  {
3397  if (!is_valid_u16((yyvsp[0].integer))) {
3398  semantic_error("is value out of range");
3399  }
3400  (yyval.integer) = (yyvsp[0].integer);
3401 }
3402 #line 3403 "parser.cc" /* yacc.c:1646 */
3403  break;
3404 
3405  case 100:
3406 #line 911 "parser.y" /* yacc.c:1646 */
3407  { (yyval.integer) = -1; }
3408 #line 3409 "parser.cc" /* yacc.c:1646 */
3409  break;
3410 
3411  case 101:
3412 #line 912 "parser.y" /* yacc.c:1646 */
3413  {
3414  if (!is_valid_u32((yyvsp[0].integer))) {
3415  semantic_error("tsn value out of range");
3416  }
3417  (yyval.integer) = (yyvsp[0].integer);
3418 }
3419 #line 3420 "parser.cc" /* yacc.c:1646 */
3420  break;
3421 
3422  case 102:
3423 #line 921 "parser.y" /* yacc.c:1646 */
3424  { (yyval.integer) = -1; }
3425 #line 3426 "parser.cc" /* yacc.c:1646 */
3426  break;
3427 
3428  case 103:
3429 #line 922 "parser.y" /* yacc.c:1646 */
3430  {
3431  if (!is_valid_u16((yyvsp[0].integer))) {
3432  semantic_error("sid value out of range");
3433  }
3434  (yyval.integer) = (yyvsp[0].integer);
3435 }
3436 #line 3437 "parser.cc" /* yacc.c:1646 */
3437  break;
3438 
3439  case 104:
3440 #line 931 "parser.y" /* yacc.c:1646 */
3441  { (yyval.integer) = -1; }
3442 #line 3443 "parser.cc" /* yacc.c:1646 */
3443  break;
3444 
3445  case 105:
3446 #line 932 "parser.y" /* yacc.c:1646 */
3447  {
3448  if (!is_valid_u16((yyvsp[0].integer))) {
3449  semantic_error("ssn value out of range");
3450  }
3451  (yyval.integer) = (yyvsp[0].integer);
3452 }
3453 #line 3454 "parser.cc" /* yacc.c:1646 */
3454  break;
3455 
3456  case 106:
3457 #line 942 "parser.y" /* yacc.c:1646 */
3458  { (yyval.integer) = -1; }
3459 #line 3460 "parser.cc" /* yacc.c:1646 */
3460  break;
3461 
3462  case 107:
3463 #line 943 "parser.y" /* yacc.c:1646 */
3464  {
3465  if (!is_valid_u32((yyvsp[0].integer))) {
3466  semantic_error("ppid value out of range");
3467  }
3468  (yyval.integer) = (yyvsp[0].integer);
3469 }
3470 #line 3471 "parser.cc" /* yacc.c:1646 */
3471  break;
3472 
3473  case 108:
3474 #line 949 "parser.y" /* yacc.c:1646 */
3475  {
3476  if (!is_valid_u32((yyvsp[0].integer))) {
3477  semantic_error("ppid value out of range");
3478  }
3479  (yyval.integer) = (yyvsp[0].integer);
3480 }
3481 #line 3482 "parser.cc" /* yacc.c:1646 */
3482  break;
3483 
3484  case 109:
3485 #line 958 "parser.y" /* yacc.c:1646 */
3486  { (yyval.integer) = -1; }
3487 #line 3488 "parser.cc" /* yacc.c:1646 */
3488  break;
3489 
3490  case 110:
3491 #line 959 "parser.y" /* yacc.c:1646 */
3492  {
3493  if (!is_valid_u32((yyvsp[0].integer))) {
3494  semantic_error("cum_tsn value out of range");
3495  }
3496  (yyval.integer) = (yyvsp[0].integer);
3497 }
3498 #line 3499 "parser.cc" /* yacc.c:1646 */
3499  break;
3500 
3501  case 111:
3502 #line 968 "parser.y" /* yacc.c:1646 */
3503  { (yyval.sack_block_list) = NULL; }
3504 #line 3505 "parser.cc" /* yacc.c:1646 */
3505  break;
3506 
3507  case 112:
3508 #line 969 "parser.y" /* yacc.c:1646 */
3509  { (yyval.sack_block_list) = NULL; }
3510 #line 3511 "parser.cc" /* yacc.c:1646 */
3511  break;
3512 
3513  case 113:
3514 #line 970 "parser.y" /* yacc.c:1646 */
3515  { (yyval.sack_block_list) = (yyvsp[-1].sack_block_list); }
3516 #line 3517 "parser.cc" /* yacc.c:1646 */
3517  break;
3518 
3519  case 114:
3520 #line 975 "parser.y" /* yacc.c:1646 */
3521  { (yyval.sack_block_list) = NULL; }
3522 #line 3523 "parser.cc" /* yacc.c:1646 */
3523  break;
3524 
3525  case 115:
3526 #line 976 "parser.y" /* yacc.c:1646 */
3527  { (yyval.sack_block_list) = NULL; }
3528 #line 3529 "parser.cc" /* yacc.c:1646 */
3529  break;
3530 
3531  case 116:
3532 #line 977 "parser.y" /* yacc.c:1646 */
3533  { (yyval.sack_block_list) = (yyvsp[-1].sack_block_list); }
3534 #line 3535 "parser.cc" /* yacc.c:1646 */
3535  break;
3536 
3537  case 117:
3538 #line 982 "parser.y" /* yacc.c:1646 */
3539  {
3540  if (((yyvsp[-9].integer) != -1) &&
3541  (!is_valid_u16((yyvsp[-9].integer)) || ((yyvsp[-9].integer) < SCTP_DATA_CHUNK_LENGTH))) {
3542  semantic_error("length value out of range");
3543  }
3544  (yyval.sctp_chunk) = PacketDrill::buildDataChunk((yyvsp[-11].integer), (yyvsp[-9].integer), (yyvsp[-7].integer), (yyvsp[-5].integer), (yyvsp[-3].integer), (yyvsp[-1].integer));
3545 }
3546 #line 3547 "parser.cc" /* yacc.c:1646 */
3547  break;
3548 
3549  case 118:
3550 #line 991 "parser.y" /* yacc.c:1646 */
3551  {
3552  (yyval.sctp_chunk) = PacketDrill::buildInitChunk((yyvsp[-12].integer), (yyvsp[-10].integer), (yyvsp[-8].integer), (yyvsp[-6].integer), (yyvsp[-4].integer), (yyvsp[-2].integer), (yyvsp[-1].expression_list));
3553 }
3554 #line 3555 "parser.cc" /* yacc.c:1646 */
3555  break;
3556 
3557  case 119:
3558 #line 996 "parser.y" /* yacc.c:1646 */
3559  {
3560  (yyval.sctp_chunk) = PacketDrill::buildInitAckChunk((yyvsp[-12].integer), (yyvsp[-10].integer), (yyvsp[-8].integer), (yyvsp[-6].integer), (yyvsp[-4].integer), (yyvsp[-2].integer), (yyvsp[-1].expression_list));
3561 }
3562 #line 3563 "parser.cc" /* yacc.c:1646 */
3563  break;
3564 
3565  case 120:
3566 #line 1001 "parser.y" /* yacc.c:1646 */
3567  {
3568  (yyval.sctp_chunk) = PacketDrill::buildSackChunk((yyvsp[-9].integer), (yyvsp[-7].integer), (yyvsp[-5].integer), (yyvsp[-3].sack_block_list), (yyvsp[-1].sack_block_list));
3569 }
3570 #line 3571 "parser.cc" /* yacc.c:1646 */
3571  break;
3572 
3573  case 121:
3574 #line 1006 "parser.y" /* yacc.c:1646 */
3575  {
3576  (yyval.sctp_chunk) = PacketDrill::buildHeartbeatChunk((yyvsp[-3].integer), (yyvsp[-1].sctp_parameter));
3577 }
3578 #line 3579 "parser.cc" /* yacc.c:1646 */
3579  break;
3580 
3581  case 122:
3582 #line 1012 "parser.y" /* yacc.c:1646 */
3583  {
3584  (yyval.sctp_chunk) = PacketDrill::buildHeartbeatAckChunk((yyvsp[-3].integer), (yyvsp[-1].sctp_parameter));
3585 }
3586 #line 3587 "parser.cc" /* yacc.c:1646 */
3587  break;
3588 
3589  case 123:
3590 #line 1018 "parser.y" /* yacc.c:1646 */
3591  {
3592  (yyval.sctp_chunk) = PacketDrill::buildAbortChunk((yyvsp[-1].integer));
3593 }
3594 #line 3595 "parser.cc" /* yacc.c:1646 */
3595  break;
3596 
3597  case 124:
3598 #line 1023 "parser.y" /* yacc.c:1646 */
3599  {
3600  (yyval.sctp_chunk) = PacketDrill::buildShutdownChunk((yyvsp[-3].integer), (yyvsp[-1].integer));
3601 }
3602 #line 3603 "parser.cc" /* yacc.c:1646 */
3603  break;
3604 
3605  case 125:
3606 #line 1028 "parser.y" /* yacc.c:1646 */
3607  {
3608  (yyval.sctp_chunk) = PacketDrill::buildShutdownAckChunk((yyvsp[-1].integer));
3609 }
3610 #line 3611 "parser.cc" /* yacc.c:1646 */
3611  break;
3612 
3613  case 126:
3614 #line 1033 "parser.y" /* yacc.c:1646 */
3615  {
3616  if (((yyvsp[-3].integer) != -1) &&
3617  (!is_valid_u16((yyvsp[-3].integer)) || ((yyvsp[-3].integer) < SCTP_COOKIE_ACK_LENGTH))) {
3618  semantic_error("length value out of range");
3619  }
3620  if (((yyvsp[-3].integer) != -1) && ((yyvsp[-1].byte_list) != NULL) &&
3621  ((yyvsp[-3].integer) != SCTP_COOKIE_ACK_LENGTH + (yyvsp[-1].byte_list)->getListLength())) {
3622  semantic_error("length value incompatible with val");
3623  }
3624  if (((yyvsp[-3].integer) == -1) && ((yyvsp[-1].byte_list) != NULL)) {
3625  semantic_error("length needs to be specified");
3626  }
3627  (yyval.sctp_chunk) = PacketDrill::buildCookieEchoChunk((yyvsp[-5].integer), (yyvsp[-3].integer), (yyvsp[-1].byte_list));
3628 }
3629 #line 3630 "parser.cc" /* yacc.c:1646 */
3630  break;
3631 
3632  case 127:
3633 #line 1049 "parser.y" /* yacc.c:1646 */
3634  {
3635  (yyval.sctp_chunk) = PacketDrill::buildCookieAckChunk((yyvsp[-1].integer));
3636 }
3637 #line 3638 "parser.cc" /* yacc.c:1646 */
3638  break;
3639 
3640  case 128:
3641 #line 1054 "parser.y" /* yacc.c:1646 */
3642  { (yyval.cause_list) = NULL; }
3643 #line 3644 "parser.cc" /* yacc.c:1646 */
3644  break;
3645 
3646  case 129:
3647 #line 1055 "parser.y" /* yacc.c:1646 */
3648  { (yyval.cause_list) = new cQueue("empty"); }
3649 #line 3650 "parser.cc" /* yacc.c:1646 */
3650  break;
3651 
3652  case 130:
3653 #line 1056 "parser.y" /* yacc.c:1646 */
3654  { (yyval.cause_list) = (yyvsp[0].cause_list); }
3655 #line 3656 "parser.cc" /* yacc.c:1646 */
3656  break;
3657 
3658  case 131:
3659 #line 1060 "parser.y" /* yacc.c:1646 */
3660  { (yyval.cause_list) = new cQueue("cause list");
3661  (yyval.cause_list)->insert((yyvsp[0].cause_item)); }
3662 #line 3663 "parser.cc" /* yacc.c:1646 */
3663  break;
3664 
3665  case 132:
3666 #line 1062 "parser.y" /* yacc.c:1646 */
3667  { (yyval.cause_list) = (yyvsp[-2].cause_list);
3668  (yyval.cause_list)->insert((yyvsp[0].cause_item)); }
3669 #line 3670 "parser.cc" /* yacc.c:1646 */
3670  break;
3671 
3672  case 133:
3673 #line 1067 "parser.y" /* yacc.c:1646 */
3674  {
3675  if (!is_valid_u16((yyvsp[-1].integer))) {
3676  semantic_error("stream identifier out of range");
3677  }
3678  (yyval.cause_item) = new PacketDrillStruct(INVALID_STREAM_IDENTIFIER, (yyvsp[-1].integer));
3679 }
3680 #line 3681 "parser.cc" /* yacc.c:1646 */
3681  break;
3682 
3683  case 134:
3684 #line 1073 "parser.y" /* yacc.c:1646 */
3685  {
3686  (yyval.cause_item) = new PacketDrillStruct(INVALID_STREAM_IDENTIFIER, -1);
3687 }
3688 #line 3689 "parser.cc" /* yacc.c:1646 */
3689  break;
3690 
3691  case 135:
3692 #line 1078 "parser.y" /* yacc.c:1646 */
3693  { (yyval.cause_item) = (yyvsp[0].cause_item); }
3694 #line 3695 "parser.cc" /* yacc.c:1646 */
3695  break;
3696 
3697  case 136:
3698 #line 1082 "parser.y" /* yacc.c:1646 */
3699  {
3700  (yyval.sctp_chunk) = PacketDrill::buildErrorChunk((yyvsp[-2].integer), (yyvsp[-1].cause_list));
3701 }
3702 #line 3703 "parser.cc" /* yacc.c:1646 */
3703  break;
3704 
3705  case 137:
3706 #line 1087 "parser.y" /* yacc.c:1646 */
3707  {
3708  (yyval.sctp_chunk) = PacketDrill::buildShutdownCompleteChunk((yyvsp[-1].integer));
3709 }
3710 #line 3711 "parser.cc" /* yacc.c:1646 */
3711  break;
3712 
3713  case 138:
3714 #line 1093 "parser.y" /* yacc.c:1646 */
3715  {
3716  if (!is_valid_u32((yyvsp[0].integer))) {
3717  semantic_error("req_sn out of range");
3718  }
3719  (yyval.integer) = (yyvsp[0].integer);
3720 }
3721 #line 3722 "parser.cc" /* yacc.c:1646 */
3722  break;
3723 
3724  case 139:
3725 #line 1099 "parser.y" /* yacc.c:1646 */
3726  { (yyval.integer) = -1; }
3727 #line 3728 "parser.cc" /* yacc.c:1646 */
3728  break;
3729 
3730  case 140:
3731 #line 1103 "parser.y" /* yacc.c:1646 */
3732  {
3733  if (!is_valid_u32((yyvsp[0].integer))) {
3734  semantic_error("resp_sn out of range");
3735  }
3736  (yyval.integer) = (yyvsp[0].integer);
3737 }
3738 #line 3739 "parser.cc" /* yacc.c:1646 */
3739  break;
3740 
3741  case 141:
3742 #line 1109 "parser.y" /* yacc.c:1646 */
3743  { (yyval.integer) = -1; }
3744 #line 3745 "parser.cc" /* yacc.c:1646 */
3745  break;
3746 
3747  case 142:
3748 #line 1113 "parser.y" /* yacc.c:1646 */
3749  {
3750  if (!is_valid_u32((yyvsp[0].integer))) {
3751  semantic_error("last_tsn out of range");
3752  }
3753  (yyval.integer) = (yyvsp[0].integer);
3754 }
3755 #line 3756 "parser.cc" /* yacc.c:1646 */
3756  break;
3757 
3758  case 143:
3759 #line 1119 "parser.y" /* yacc.c:1646 */
3760  { (yyval.integer) = -1; }
3761 #line 3762 "parser.cc" /* yacc.c:1646 */
3762  break;
3763 
3764  case 144:
3765 #line 1123 "parser.y" /* yacc.c:1646 */
3766  {
3767  if (!is_valid_u32((yyvsp[0].integer))) {
3768  semantic_error("result out of range");
3769  }
3770  (yyval.integer) = (yyvsp[0].integer);
3771 }
3772 #line 3773 "parser.cc" /* yacc.c:1646 */
3773  break;
3774 
3775  case 145:
3776 #line 1129 "parser.y" /* yacc.c:1646 */
3777  { (yyval.integer) = -1; }
3778 #line 3779 "parser.cc" /* yacc.c:1646 */
3779  break;
3780 
3781  case 146:
3782 #line 1133 "parser.y" /* yacc.c:1646 */
3783  {
3784  if (!is_valid_u32((yyvsp[0].integer))) {
3785  semantic_error("sender_next_tsn out of range");
3786  }
3787  (yyval.integer) = (yyvsp[0].integer);
3788 }
3789 #line 3790 "parser.cc" /* yacc.c:1646 */
3790  break;
3791 
3792  case 147:
3793 #line 1139 "parser.y" /* yacc.c:1646 */
3794  {
3795  if (!is_valid_u32((yyvsp[0].integer))) {
3796  semantic_error("sender_next_tsn out of range");
3797  }
3798  (yyval.integer) = (yyvsp[0].integer);
3799 }
3800 #line 3801 "parser.cc" /* yacc.c:1646 */
3801  break;
3802 
3803  case 148:
3804 #line 1145 "parser.y" /* yacc.c:1646 */
3805  { (yyval.integer) = -1; }
3806 #line 3807 "parser.cc" /* yacc.c:1646 */
3807  break;
3808 
3809  case 149:
3810 #line 1149 "parser.y" /* yacc.c:1646 */
3811  {
3812  if (!is_valid_u32((yyvsp[0].integer))) {
3813  semantic_error("receiver_next_tsn out of range");
3814  }
3815  (yyval.integer) = (yyvsp[0].integer);
3816 }
3817 #line 3818 "parser.cc" /* yacc.c:1646 */
3818  break;
3819 
3820  case 150:
3821 #line 1155 "parser.y" /* yacc.c:1646 */
3822  {
3823  if (!is_valid_u32((yyvsp[0].integer))) {
3824  semantic_error("receiver_next_tsn out of range");
3825  }
3826  (yyval.integer) = (yyvsp[0].integer);
3827 }
3828 #line 3829 "parser.cc" /* yacc.c:1646 */
3829  break;
3830 
3831  case 151:
3832 #line 1161 "parser.y" /* yacc.c:1646 */
3833  { (yyval.integer) = -1; }
3834 #line 3835 "parser.cc" /* yacc.c:1646 */
3835  break;
3836 
3837  case 152:
3838 #line 1165 "parser.y" /* yacc.c:1646 */
3839  {
3840  if (!is_valid_u16((yyvsp[0].integer))) {
3841  semantic_error("number_of_new_streams out of range");
3842  }
3843  (yyval.integer) = (yyvsp[0].integer);
3844 }
3845 #line 3846 "parser.cc" /* yacc.c:1646 */
3846  break;
3847 
3848  case 153:
3849 #line 1171 "parser.y" /* yacc.c:1646 */
3850  { (yyval.integer) = -1; }
3851 #line 3852 "parser.cc" /* yacc.c:1646 */
3852  break;
3853 
3854  case 154:
3855 #line 1175 "parser.y" /* yacc.c:1646 */
3856  {
3857  (yyval.stream_list) = new cQueue("stream_list");
3858  (yyval.stream_list)->insert((yyvsp[0].expression));
3859 }
3860 #line 3861 "parser.cc" /* yacc.c:1646 */
3861  break;
3862 
3863  case 155:
3864 #line 1179 "parser.y" /* yacc.c:1646 */
3865  {
3866  (yyval.stream_list) = (yyvsp[-2].stream_list); (yyval.stream_list)->insert((yyvsp[0].expression));
3867 }
3868 #line 3869 "parser.cc" /* yacc.c:1646 */
3869  break;
3870 
3871  case 156:
3872 #line 1185 "parser.y" /* yacc.c:1646 */
3873  {
3874  (yyval.expression) = new_integer_expression(-1, "%d");
3875 }
3876 #line 3877 "parser.cc" /* yacc.c:1646 */
3877  break;
3878 
3879  case 157:
3880 #line 1188 "parser.y" /* yacc.c:1646 */
3881  {
3882  if (!is_valid_u16((yyvsp[0].integer))) {
3883  semantic_error("Stream number value out of range");
3884  }
3885  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
3886 }
3887 #line 3888 "parser.cc" /* yacc.c:1646 */
3888  break;
3889 
3890  case 158:
3891 #line 1198 "parser.y" /* yacc.c:1646 */
3892  {
3893  (yyval.sctp_parameter) = new PacketDrillSctpParameter(OUTGOING_RESET_REQUEST_PARAMETER, 16, new PacketDrillStruct((yyvsp[-5].integer), (yyvsp[-3].integer), (yyvsp[-1].integer), -2, NULL));
3894 }
3895 #line 3896 "parser.cc" /* yacc.c:1646 */
3896  break;
3897 
3898  case 159:
3899 #line 1201 "parser.y" /* yacc.c:1646 */
3900  {
3901  (yyval.sctp_parameter) = new PacketDrillSctpParameter(OUTGOING_RESET_REQUEST_PARAMETER, 16, new PacketDrillStruct((yyvsp[-11].integer), (yyvsp[-9].integer), (yyvsp[-7].integer), -2, (yyvsp[-2].stream_list)));
3902 }
3903 #line 3904 "parser.cc" /* yacc.c:1646 */
3904  break;
3905 
3906  case 160:
3907 #line 1207 "parser.y" /* yacc.c:1646 */
3908  {
3909  (yyval.sctp_parameter) = new PacketDrillSctpParameter(INCOMING_RESET_REQUEST_PARAMETER, 8, new PacketDrillStruct((yyvsp[-1].integer), -2, -2, -2, NULL));
3910 }
3911 #line 3912 "parser.cc" /* yacc.c:1646 */
3912  break;
3913 
3914  case 161:
3915 #line 1210 "parser.y" /* yacc.c:1646 */
3916  {
3917  (yyval.sctp_parameter) = new PacketDrillSctpParameter(INCOMING_RESET_REQUEST_PARAMETER, 8, new PacketDrillStruct((yyvsp[-7].integer), -2, -2, -2, (yyvsp[-2].stream_list)));
3918 }
3919 #line 3920 "parser.cc" /* yacc.c:1646 */
3920  break;
3921 
3922  case 162:
3923 #line 1216 "parser.y" /* yacc.c:1646 */
3924  {
3925  (yyval.sctp_parameter) = new PacketDrillSctpParameter(SSN_TSN_RESET_REQUEST_PARAMETER, 8, new PacketDrillStruct((yyvsp[-1].integer), -2, -2, -2, NULL));
3926 }
3927 #line 3928 "parser.cc" /* yacc.c:1646 */
3928  break;
3929 
3930  case 163:
3931 #line 1222 "parser.y" /* yacc.c:1646 */
3932  {
3933  (yyval.sctp_parameter) = new PacketDrillSctpParameter(STREAM_RESET_RESPONSE_PARAMETER, 8, new PacketDrillStruct((yyvsp[-3].integer), (yyvsp[-1].integer), -2, -2, NULL));
3934 }
3935 #line 3936 "parser.cc" /* yacc.c:1646 */
3936  break;
3937 
3938  case 164:
3939 #line 1225 "parser.y" /* yacc.c:1646 */
3940  {
3941  (yyval.sctp_parameter) = new PacketDrillSctpParameter(STREAM_RESET_RESPONSE_PARAMETER, 12, new PacketDrillStruct((yyvsp[-7].integer), (yyvsp[-5].integer), (yyvsp[-3].integer), (yyvsp[-1].integer), NULL));
3942 }
3943 #line 3944 "parser.cc" /* yacc.c:1646 */
3944  break;
3945 
3946  case 165:
3947 #line 1231 "parser.y" /* yacc.c:1646 */
3948  {
3949  (yyval.sctp_parameter) = new PacketDrillSctpParameter(ADD_OUTGOING_STREAMS_REQUEST_PARAMETER, 12, new PacketDrillStruct((yyvsp[-3].integer), (yyvsp[-1].integer), -2, -2, NULL));
3950 }
3951 #line 3952 "parser.cc" /* yacc.c:1646 */
3952  break;
3953 
3954  case 166:
3955 #line 1237 "parser.y" /* yacc.c:1646 */
3956  {
3957  (yyval.sctp_parameter) = new PacketDrillSctpParameter(ADD_INCOMING_STREAMS_REQUEST_PARAMETER, 12, new PacketDrillStruct((yyvsp[-3].integer), (yyvsp[-1].integer), -2, -2, NULL));
3958 }
3959 #line 3960 "parser.cc" /* yacc.c:1646 */
3960  break;
3961 
3962  case 167:
3963 #line 1249 "parser.y" /* yacc.c:1646 */
3964  {
3965  (yyval.sctp_chunk) = PacketDrill::buildReconfigChunk((yyvsp[-2].integer), (yyvsp[-1].expression_list));
3966 }
3967 #line 3968 "parser.cc" /* yacc.c:1646 */
3968  break;
3969 
3970  case 168:
3971 #line 1255 "parser.y" /* yacc.c:1646 */
3972  { (yyval.expression_list) = NULL; }
3973 #line 3974 "parser.cc" /* yacc.c:1646 */
3974  break;
3975 
3976  case 169:
3977 #line 1256 "parser.y" /* yacc.c:1646 */
3978  { (yyval.expression_list) = new cQueue("empty"); }
3979 #line 3980 "parser.cc" /* yacc.c:1646 */
3980  break;
3981 
3982  case 170:
3983 #line 1257 "parser.y" /* yacc.c:1646 */
3984  { (yyval.expression_list) = (yyvsp[0].expression_list); }
3985 #line 3986 "parser.cc" /* yacc.c:1646 */
3986  break;
3987 
3988  case 171:
3989 #line 1261 "parser.y" /* yacc.c:1646 */
3990  {
3991  (yyval.expression_list) = new cQueue("sctp_parameter_list");
3992  (yyval.expression_list)->insert((yyvsp[0].sctp_parameter));
3993 }
3994 #line 3995 "parser.cc" /* yacc.c:1646 */
3995  break;
3996 
3997  case 172:
3998 #line 1265 "parser.y" /* yacc.c:1646 */
3999  {
4000  (yyval.expression_list) = (yyvsp[-2].expression_list);
4001  (yyval.expression_list)->insert((yyvsp[0].sctp_parameter));
4002 }
4003 #line 4004 "parser.cc" /* yacc.c:1646 */
4004  break;
4005 
4006  case 173:
4007 #line 1273 "parser.y" /* yacc.c:1646 */
4008  { (yyval.sctp_parameter) = (yyvsp[0].sctp_parameter); }
4009 #line 4010 "parser.cc" /* yacc.c:1646 */
4010  break;
4011 
4012  case 174:
4013 #line 1274 "parser.y" /* yacc.c:1646 */
4014  { (yyval.sctp_parameter) = (yyvsp[0].sctp_parameter); }
4015 #line 4016 "parser.cc" /* yacc.c:1646 */
4016  break;
4017 
4018  case 175:
4019 #line 1275 "parser.y" /* yacc.c:1646 */
4020  { (yyval.sctp_parameter) = (yyvsp[0].sctp_parameter); }
4021 #line 4022 "parser.cc" /* yacc.c:1646 */
4022  break;
4023 
4024  case 176:
4025 #line 1276 "parser.y" /* yacc.c:1646 */
4026  { (yyval.sctp_parameter) = (yyvsp[0].sctp_parameter); }
4027 #line 4028 "parser.cc" /* yacc.c:1646 */
4028  break;
4029 
4030  case 177:
4031 #line 1277 "parser.y" /* yacc.c:1646 */
4032  { (yyval.sctp_parameter) = (yyvsp[0].sctp_parameter); }
4033 #line 4034 "parser.cc" /* yacc.c:1646 */
4034  break;
4035 
4036  case 178:
4037 #line 1278 "parser.y" /* yacc.c:1646 */
4038  { (yyval.sctp_parameter) = (yyvsp[0].sctp_parameter); }
4039 #line 4040 "parser.cc" /* yacc.c:1646 */
4040  break;
4041 
4042  case 179:
4043 #line 1279 "parser.y" /* yacc.c:1646 */
4044  { (yyval.sctp_parameter) = (yyvsp[0].sctp_parameter); }
4045 #line 4046 "parser.cc" /* yacc.c:1646 */
4046  break;
4047 
4048  case 180:
4049 #line 1280 "parser.y" /* yacc.c:1646 */
4050  { (yyval.sctp_parameter) = (yyvsp[0].sctp_parameter); }
4051 #line 4052 "parser.cc" /* yacc.c:1646 */
4052  break;
4053 
4054  case 181:
4055 #line 1281 "parser.y" /* yacc.c:1646 */
4056  { (yyval.sctp_parameter) = (yyvsp[0].sctp_parameter); }
4057 #line 4058 "parser.cc" /* yacc.c:1646 */
4058  break;
4059 
4060  case 182:
4061 #line 1282 "parser.y" /* yacc.c:1646 */
4062  { (yyval.sctp_parameter) = (yyvsp[0].sctp_parameter); }
4063 #line 4064 "parser.cc" /* yacc.c:1646 */
4064  break;
4065 
4066  case 183:
4067 #line 1287 "parser.y" /* yacc.c:1646 */
4068  {
4069  (yyval.sctp_parameter) = new PacketDrillSctpParameter(HEARTBEAT_INFORMATION, -1, NULL);
4070 }
4071 #line 4072 "parser.cc" /* yacc.c:1646 */
4072  break;
4073 
4074  case 184:
4075 #line 1290 "parser.y" /* yacc.c:1646 */
4076  {
4077  if (((yyvsp[-3].integer) != -1) &&
4078  (!is_valid_u16((yyvsp[-3].integer)) || ((yyvsp[-3].integer) < 4))) {
4079  semantic_error("length value out of range");
4080  }
4081  if (((yyvsp[-3].integer) != -1) && ((yyvsp[-1].byte_list) != NULL) &&
4082  ((yyvsp[-3].integer) != 4 + (yyvsp[-1].byte_list)->getListLength())) {
4083  semantic_error("length value incompatible with val");
4084  }
4085  if (((yyvsp[-3].integer) == -1) && ((yyvsp[-1].byte_list) != NULL)) {
4086  semantic_error("length needs to be specified");
4087  }
4088  (yyval.sctp_parameter) = new PacketDrillSctpParameter(HEARTBEAT_INFORMATION, (yyvsp[-3].integer), (yyvsp[-1].byte_list));
4089 }
4090 #line 4091 "parser.cc" /* yacc.c:1646 */
4091  break;
4092 
4093  case 185:
4094 #line 1306 "parser.y" /* yacc.c:1646 */
4095  {
4096  (yyval.sctp_parameter) = new PacketDrillSctpParameter(SUPPORTED_EXTENSIONS, -1, NULL);
4097 }
4098 #line 4099 "parser.cc" /* yacc.c:1646 */
4099  break;
4100 
4101  case 186:
4102 #line 1309 "parser.y" /* yacc.c:1646 */
4103  {
4104  (yyval.sctp_parameter) = new PacketDrillSctpParameter(SUPPORTED_EXTENSIONS, (yyvsp[-2].byte_list)->getListLength(), (yyvsp[-2].byte_list));
4105 }
4106 #line 4107 "parser.cc" /* yacc.c:1646 */
4107  break;
4108 
4109  case 187:
4110 #line 1314 "parser.y" /* yacc.c:1646 */
4111  { (yyval.stream_list) = new cQueue("empty_address_types_list");
4112 }
4113 #line 4114 "parser.cc" /* yacc.c:1646 */
4114  break;
4115 
4116  case 188:
4117 #line 1316 "parser.y" /* yacc.c:1646 */
4118  { (yyval.stream_list) = new cQueue("address_types_list");
4119  (yyval.stream_list)->insert((yyvsp[0].expression));
4120 }
4121 #line 4122 "parser.cc" /* yacc.c:1646 */
4122  break;
4123 
4124  case 189:
4125 #line 1319 "parser.y" /* yacc.c:1646 */
4126  { (yyval.stream_list) = (yyvsp[-2].stream_list);
4127  (yyval.stream_list)->insert((yyvsp[0].expression));
4128 }
4129 #line 4130 "parser.cc" /* yacc.c:1646 */
4130  break;
4131 
4132  case 190:
4133 #line 1325 "parser.y" /* yacc.c:1646 */
4134  { if (!is_valid_u16((yyvsp[0].integer))) {
4135  semantic_error("address type value out of range");
4136  }
4137  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u"); }
4138 #line 4139 "parser.cc" /* yacc.c:1646 */
4139  break;
4140 
4141  case 191:
4142 #line 1329 "parser.y" /* yacc.c:1646 */
4143  { (yyval.expression) = new_integer_expression(SCTP_IPV4_ADDRESS_PARAMETER_TYPE, "%u"); }
4144 #line 4145 "parser.cc" /* yacc.c:1646 */
4145  break;
4146 
4147  case 192:
4148 #line 1330 "parser.y" /* yacc.c:1646 */
4149  { (yyval.expression) = new_integer_expression(SCTP_IPV6_ADDRESS_PARAMETER_TYPE, "%u"); }
4150 #line 4151 "parser.cc" /* yacc.c:1646 */
4151  break;
4152 
4153  case 193:
4154 #line 1334 "parser.y" /* yacc.c:1646 */
4155  {
4156  (yyval.sctp_parameter) = new PacketDrillSctpParameter(SUPPORTED_ADDRESS_TYPES, -1, NULL);
4157 }
4158 #line 4159 "parser.cc" /* yacc.c:1646 */
4159  break;
4160 
4161  case 194:
4162 #line 1337 "parser.y" /* yacc.c:1646 */
4163  {
4164 (yyvsp[-2].stream_list)->setName("SupportedAddressTypes");
4165  (yyval.sctp_parameter) = new PacketDrillSctpParameter(SUPPORTED_ADDRESS_TYPES, (yyvsp[-2].stream_list)->getLength(), (yyvsp[-2].stream_list));
4166 }
4167 #line 4168 "parser.cc" /* yacc.c:1646 */
4168  break;
4169 
4170  case 195:
4171 #line 1343 "parser.y" /* yacc.c:1646 */
4172  {
4173  (yyval.sctp_parameter) = new PacketDrillSctpParameter(STATE_COOKIE, -1, NULL);
4174 }
4175 #line 4176 "parser.cc" /* yacc.c:1646 */
4176  break;
4177 
4178  case 196:
4179 #line 1346 "parser.y" /* yacc.c:1646 */
4180  {
4181  (yyval.sctp_parameter) = new PacketDrillSctpParameter(STATE_COOKIE, -1, NULL);
4182 }
4183 #line 4184 "parser.cc" /* yacc.c:1646 */
4184  break;
4185 
4186  case 197:
4187 #line 1349 "parser.y" /* yacc.c:1646 */
4188  {
4189  if (((yyvsp[-5].integer) < 4) || !is_valid_u32((yyvsp[-5].integer))) {
4190  semantic_error("len value out of range");
4191  }
4192  (yyval.sctp_parameter) = new PacketDrillSctpParameter(STATE_COOKIE, (yyvsp[-5].integer), NULL);
4193 }
4194 #line 4195 "parser.cc" /* yacc.c:1646 */
4195  break;
4196 
4197  case 198:
4198 #line 1359 "parser.y" /* yacc.c:1646 */
4199  {
4200  (yyval.packet) = new PacketDrillPacket();
4201  (yyval.packet)->setDirection((yyvsp[0].direction));
4202 }
4203 #line 4204 "parser.cc" /* yacc.c:1646 */
4204  break;
4205 
4206  case 199:
4207 #line 1367 "parser.y" /* yacc.c:1646 */
4208  {
4209  (yyval.direction) = DIRECTION_INBOUND;
4210  current_script_line = yylineno;
4211 }
4212 #line 4213 "parser.cc" /* yacc.c:1646 */
4213  break;
4214 
4215  case 200:
4216 #line 1371 "parser.y" /* yacc.c:1646 */
4217  {
4218  (yyval.direction) = DIRECTION_OUTBOUND;
4219  current_script_line = yylineno;
4220 }
4221 #line 4222 "parser.cc" /* yacc.c:1646 */
4222  break;
4223 
4224  case 201:
4225 #line 1378 "parser.y" /* yacc.c:1646 */
4226  {
4227  (yyval.string) = (yyvsp[0].string);
4228 }
4229 #line 4230 "parser.cc" /* yacc.c:1646 */
4230  break;
4231 
4232  case 202:
4233 #line 1381 "parser.y" /* yacc.c:1646 */
4234  {
4235  (yyval.string) = strdup(".");
4236 }
4237 #line 4238 "parser.cc" /* yacc.c:1646 */
4238  break;
4239 
4240  case 203:
4241 #line 1384 "parser.y" /* yacc.c:1646 */
4242  {
4243  asprintf(&((yyval.string)), "%s.", (yyvsp[-1].string));
4244  free((yyvsp[-1].string));
4245 }
4246 #line 4247 "parser.cc" /* yacc.c:1646 */
4247  break;
4248 
4249  case 204:
4250 #line 1388 "parser.y" /* yacc.c:1646 */
4251  {
4252  (yyval.string) = strdup("");
4253 }
4254 #line 4255 "parser.cc" /* yacc.c:1646 */
4255  break;
4256 
4257  case 205:
4258 #line 1394 "parser.y" /* yacc.c:1646 */
4259  {
4260  if (!is_valid_u32((yyvsp[-5].integer))) {
4261  semantic_error("TCP start sequence number out of range");
4262  }
4263  if (!is_valid_u32((yyvsp[-3].integer))) {
4264  semantic_error("TCP end sequence number out of range");
4265  }
4266  if (!is_valid_u16((yyvsp[-1].integer))) {
4267  semantic_error("TCP payload size out of range");
4268  }
4269  if ((yyvsp[-3].integer) != ((yyvsp[-5].integer) +(yyvsp[-1].integer))) {
4270  semantic_error("inconsistent TCP sequence numbers and payload size");
4271  }
4272  (yyval.tcp_sequence_info).start_sequence = (yyvsp[-5].integer);
4273  (yyval.tcp_sequence_info).payload_bytes = (yyvsp[-1].integer);
4274  (yyval.tcp_sequence_info).protocol = IPPROTO_TCP;
4275 }
4276 #line 4277 "parser.cc" /* yacc.c:1646 */
4277  break;
4278 
4279  case 206:
4280 #line 1414 "parser.y" /* yacc.c:1646 */
4281  {
4282  (yyval.sequence_number) = 0;
4283 }
4284 #line 4285 "parser.cc" /* yacc.c:1646 */
4285  break;
4286 
4287  case 207:
4288 #line 1417 "parser.y" /* yacc.c:1646 */
4289  {
4290  if (!is_valid_u32((yyvsp[0].integer))) {
4291  semantic_error("TCP ack sequence number out of range");
4292  }
4293  (yyval.sequence_number) = (yyvsp[0].integer);
4294 }
4295 #line 4296 "parser.cc" /* yacc.c:1646 */
4296  break;
4297 
4298  case 208:
4299 #line 1426 "parser.y" /* yacc.c:1646 */
4300  {
4301  (yyval.window) = -1;
4302 }
4303 #line 4304 "parser.cc" /* yacc.c:1646 */
4304  break;
4305 
4306  case 209:
4307 #line 1429 "parser.y" /* yacc.c:1646 */
4308  {
4309  if (!is_valid_u16((yyvsp[0].integer))) {
4310  semantic_error("TCP window value out of range");
4311  }
4312  (yyval.window) = (yyvsp[0].integer);
4313 }
4314 #line 4315 "parser.cc" /* yacc.c:1646 */
4315  break;
4316 
4317  case 210:
4318 #line 1438 "parser.y" /* yacc.c:1646 */
4319  {
4320  (yyval.tcp_options) = new cQueue("opt_tcp_options");
4321 }
4322 #line 4323 "parser.cc" /* yacc.c:1646 */
4323  break;
4324 
4325  case 211:
4326 #line 1441 "parser.y" /* yacc.c:1646 */
4327  {
4328  (yyval.tcp_options) = (yyvsp[-1].tcp_options);
4329 }
4330 #line 4331 "parser.cc" /* yacc.c:1646 */
4331  break;
4332 
4333  case 212:
4334 #line 1444 "parser.y" /* yacc.c:1646 */
4335  {
4336  (yyval.tcp_options) = NULL; /* FLAG_OPTIONS_NOCHECK */
4337 }
4338 #line 4339 "parser.cc" /* yacc.c:1646 */
4339  break;
4340 
4341  case 213:
4342 #line 1451 "parser.y" /* yacc.c:1646 */
4343  {
4344  (yyval.tcp_options) = new cQueue("tcp_option");
4345  (yyval.tcp_options)->insert((yyvsp[0].tcp_option));
4346 }
4347 #line 4348 "parser.cc" /* yacc.c:1646 */
4348  break;
4349 
4350  case 214:
4351 #line 1455 "parser.y" /* yacc.c:1646 */
4352  {
4353  (yyval.tcp_options) = (yyvsp[-2].tcp_options);
4354  (yyval.tcp_options)->insert((yyvsp[0].tcp_option));
4355 }
4356 #line 4357 "parser.cc" /* yacc.c:1646 */
4357  break;
4358 
4359  case 215:
4360 #line 1463 "parser.y" /* yacc.c:1646 */
4361  {
4362  (yyval.tcp_option) = new PacketDrillTcpOption(TCPOPT_NOP, 1);
4363 }
4364 #line 4365 "parser.cc" /* yacc.c:1646 */
4365  break;
4366 
4367  case 216:
4368 #line 1466 "parser.y" /* yacc.c:1646 */
4369  {
4370  (yyval.tcp_option) = new PacketDrillTcpOption(TCPOPT_EOL, 1);
4371 }
4372 #line 4373 "parser.cc" /* yacc.c:1646 */
4373  break;
4374 
4375  case 217:
4376 #line 1469 "parser.y" /* yacc.c:1646 */
4377  {
4378  (yyval.tcp_option) = new PacketDrillTcpOption(TCPOPT_MAXSEG, TCPOLEN_MAXSEG);
4379  if (!is_valid_u16((yyvsp[0].integer))) {
4380  semantic_error("mss value out of range");
4381  }
4382  (yyval.tcp_option)->setMss((yyvsp[0].integer));
4383 }
4384 #line 4385 "parser.cc" /* yacc.c:1646 */
4385  break;
4386 
4387  case 218:
4388 #line 1476 "parser.y" /* yacc.c:1646 */
4389  {
4390  (yyval.tcp_option) = new PacketDrillTcpOption(TCPOPT_WINDOW, TCPOLEN_WINDOW);
4391  if (!is_valid_u8((yyvsp[0].integer))) {
4392  semantic_error("window scale shift count out of range");
4393  }
4394  (yyval.tcp_option)->setWindowScale((yyvsp[0].integer));
4395 }
4396 #line 4397 "parser.cc" /* yacc.c:1646 */
4397  break;
4398 
4399  case 219:
4400 #line 1483 "parser.y" /* yacc.c:1646 */
4401  {
4402  (yyval.tcp_option) = new PacketDrillTcpOption(TCPOPT_SACK_PERMITTED, TCPOLEN_SACK_PERMITTED);
4403 }
4404 #line 4405 "parser.cc" /* yacc.c:1646 */
4405  break;
4406 
4407  case 220:
4408 #line 1486 "parser.y" /* yacc.c:1646 */
4409  {
4410  (yyval.tcp_option) = new PacketDrillTcpOption(TCPOPT_SACK, 2+8*(yyvsp[0].sack_block_list)->getLength());
4411  (yyval.tcp_option)->setBlockList((yyvsp[0].sack_block_list));
4412 }
4413 #line 4414 "parser.cc" /* yacc.c:1646 */
4414  break;
4415 
4416  case 221:
4417 #line 1490 "parser.y" /* yacc.c:1646 */
4418  {
4419  uint32 val, ecr;
4420  (yyval.tcp_option) = new PacketDrillTcpOption(TCPOPT_TIMESTAMP, TCPOLEN_TIMESTAMP);
4421  if (!is_valid_u32((yyvsp[-2].integer))) {
4422  semantic_error("ts val out of range");
4423  }
4424  if (!is_valid_u32((yyvsp[0].integer))) {
4425  semantic_error("ecr val out of range");
4426  }
4427  val = (yyvsp[-2].integer);
4428  ecr = (yyvsp[0].integer);
4429  (yyval.tcp_option)->setVal(val);
4430  (yyval.tcp_option)->setEcr(ecr);
4431 }
4432 #line 4433 "parser.cc" /* yacc.c:1646 */
4433  break;
4434 
4435  case 222:
4436 #line 1507 "parser.y" /* yacc.c:1646 */
4437  {
4438  (yyval.sack_block_list) = new cQueue("sack_block_list");
4439  (yyval.sack_block_list)->insert((yyvsp[0].sack_block));
4440 }
4441 #line 4442 "parser.cc" /* yacc.c:1646 */
4442  break;
4443 
4444  case 223:
4445 #line 1511 "parser.y" /* yacc.c:1646 */
4446  {
4447  (yyval.sack_block_list) = (yyvsp[-1].sack_block_list); (yyval.sack_block_list)->insert((yyvsp[0].sack_block));
4448 }
4449 #line 4450 "parser.cc" /* yacc.c:1646 */
4450  break;
4451 
4452  case 224:
4453 #line 1517 "parser.y" /* yacc.c:1646 */
4454  { (yyval.sack_block_list) = new cQueue("gap_list");}
4455 #line 4456 "parser.cc" /* yacc.c:1646 */
4456  break;
4457 
4458  case 225:
4459 #line 1518 "parser.y" /* yacc.c:1646 */
4460  {
4461  (yyval.sack_block_list) = new cQueue("gap_list");
4462  (yyval.sack_block_list)->insert((yyvsp[0].sack_block));
4463 }
4464 #line 4465 "parser.cc" /* yacc.c:1646 */
4465  break;
4466 
4467  case 226:
4468 #line 1522 "parser.y" /* yacc.c:1646 */
4469  {
4470  (yyval.sack_block_list) = (yyvsp[-2].sack_block_list); (yyval.sack_block_list)->insert((yyvsp[0].sack_block));
4471 }
4472 #line 4473 "parser.cc" /* yacc.c:1646 */
4473  break;
4474 
4475  case 227:
4476 #line 1528 "parser.y" /* yacc.c:1646 */
4477  {
4478  if (!is_valid_u16((yyvsp[-2].integer))) {
4479  semantic_error("start value out of range");
4480  }
4481  if (!is_valid_u16((yyvsp[0].integer))) {
4482  semantic_error("end value out of range");
4483  }
4484  (yyval.sack_block) = new PacketDrillStruct((yyvsp[-2].integer), (yyvsp[0].integer));
4485 }
4486 #line 4487 "parser.cc" /* yacc.c:1646 */
4487  break;
4488 
4489  case 228:
4490 #line 1540 "parser.y" /* yacc.c:1646 */
4491  { (yyval.sack_block_list) = new cQueue("dup_list");}
4492 #line 4493 "parser.cc" /* yacc.c:1646 */
4493  break;
4494 
4495  case 229:
4496 #line 1541 "parser.y" /* yacc.c:1646 */
4497  {
4498  (yyval.sack_block_list) = new cQueue("dup_list");
4499  (yyval.sack_block_list)->insert((yyvsp[0].sack_block));
4500 }
4501 #line 4502 "parser.cc" /* yacc.c:1646 */
4502  break;
4503 
4504  case 230:
4505 #line 1545 "parser.y" /* yacc.c:1646 */
4506  {
4507  (yyval.sack_block_list) = (yyvsp[-2].sack_block_list); (yyval.sack_block_list)->insert((yyvsp[0].sack_block));
4508 }
4509 #line 4510 "parser.cc" /* yacc.c:1646 */
4510  break;
4511 
4512  case 231:
4513 #line 1551 "parser.y" /* yacc.c:1646 */
4514  {
4515  if (!is_valid_u16((yyvsp[-2].integer))) {
4516  semantic_error("start value out of range");
4517  }
4518  if (!is_valid_u16((yyvsp[0].integer))) {
4519  semantic_error("end value out of range");
4520  }
4521  (yyval.sack_block) = new PacketDrillStruct((yyvsp[-2].integer), (yyvsp[0].integer));
4522 }
4523 #line 4524 "parser.cc" /* yacc.c:1646 */
4524  break;
4525 
4526  case 232:
4527 #line 1563 "parser.y" /* yacc.c:1646 */
4528  {
4529  if (!is_valid_u32((yyvsp[-2].integer))) {
4530  semantic_error("TCP SACK left sequence number out of range\n");
4531  }
4532  if (!is_valid_u32((yyvsp[0].integer))) {
4533  semantic_error("TCP SACK right sequence number out of range");
4534  }
4535  PacketDrillStruct *block = new PacketDrillStruct((yyvsp[-2].integer), (yyvsp[0].integer));
4536  (yyval.sack_block) = block;
4537 }
4538 #line 4539 "parser.cc" /* yacc.c:1646 */
4539  break;
4540 
4541  case 233:
4542 #line 1576 "parser.y" /* yacc.c:1646 */
4543  {
4544  (yyval.syscall) = (struct syscall_spec *)calloc(1, sizeof(struct syscall_spec));
4545  (yyval.syscall)->end_usecs = (yyvsp[-6].time_usecs);
4546  (yyval.syscall)->name = (yyvsp[-5].string);
4547  (yyval.syscall)->arguments = (yyvsp[-4].expression_list);
4548  (yyval.syscall)->result = (yyvsp[-2].expression);
4549  (yyval.syscall)->error = (yyvsp[-1].errno_info);
4550  (yyval.syscall)->note = (yyvsp[0].string);
4551 }
4552 #line 4553 "parser.cc" /* yacc.c:1646 */
4553  break;
4554 
4555  case 234:
4556 #line 1588 "parser.y" /* yacc.c:1646 */
4557  {
4558  (yyval.time_usecs) = -1;
4559 }
4560 #line 4561 "parser.cc" /* yacc.c:1646 */
4561  break;
4562 
4563  case 235:
4564 #line 1591 "parser.y" /* yacc.c:1646 */
4565  {
4566  (yyval.time_usecs) = (yyvsp[0].time_usecs);
4567 }
4568 #line 4569 "parser.cc" /* yacc.c:1646 */
4569  break;
4570 
4571  case 236:
4572 #line 1597 "parser.y" /* yacc.c:1646 */
4573  {
4574  (yyval.string) = (yyvsp[0].string);
4575  current_script_line = yylineno;
4576 }
4577 #line 4578 "parser.cc" /* yacc.c:1646 */
4578  break;
4579 
4580  case 237:
4581 #line 1604 "parser.y" /* yacc.c:1646 */
4582  {
4583  (yyval.expression_list) = NULL;
4584 }
4585 #line 4586 "parser.cc" /* yacc.c:1646 */
4586  break;
4587 
4588  case 238:
4589 #line 1607 "parser.y" /* yacc.c:1646 */
4590  {
4591  (yyval.expression_list) = (yyvsp[-1].expression_list);
4592 }
4593 #line 4594 "parser.cc" /* yacc.c:1646 */
4594  break;
4595 
4596  case 239:
4597 #line 1613 "parser.y" /* yacc.c:1646 */
4598  {
4599  (yyval.expression_list) = new cQueue("new_expressionList");
4600  (yyval.expression_list)->insert((cObject*)(yyvsp[0].expression));
4601 }
4602 #line 4603 "parser.cc" /* yacc.c:1646 */
4603  break;
4604 
4605  case 240:
4606 #line 1617 "parser.y" /* yacc.c:1646 */
4607  {
4608  (yyval.expression_list) = (yyvsp[-2].expression_list);
4609  (yyval.expression_list)->insert((yyvsp[0].expression));
4610 }
4611 #line 4612 "parser.cc" /* yacc.c:1646 */
4612  break;
4613 
4614  case 241:
4615 #line 1624 "parser.y" /* yacc.c:1646 */
4616  {
4617  (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS);
4618 }
4619 #line 4620 "parser.cc" /* yacc.c:1646 */
4620  break;
4621 
4622  case 242:
4623 #line 1627 "parser.y" /* yacc.c:1646 */
4624  {
4625  (yyval.expression) = (yyvsp[0].expression); }
4626 #line 4627 "parser.cc" /* yacc.c:1646 */
4627  break;
4628 
4629  case 243:
4630 #line 1629 "parser.y" /* yacc.c:1646 */
4631  {
4632  (yyval.expression) = (yyvsp[0].expression);
4633 }
4634 #line 4635 "parser.cc" /* yacc.c:1646 */
4635  break;
4636 
4637  case 244:
4638 #line 1632 "parser.y" /* yacc.c:1646 */
4639  {
4640  if (!is_valid_u32((yyvsp[-1].integer))) {
4641  semantic_error("number out of range");
4642  }
4643  (yyval.expression) = new_integer_expression((yyvsp[-1].integer), "%lu");
4644 }
4645 #line 4646 "parser.cc" /* yacc.c:1646 */
4646  break;
4647 
4648  case 245:
4649 #line 1638 "parser.y" /* yacc.c:1646 */
4650  {
4651  if (!is_valid_u32((yyvsp[-1].integer))) {
4652  semantic_error("number out of range");
4653  }
4654  (yyval.expression) = new_integer_expression((yyvsp[-1].integer), "%lu");
4655 }
4656 #line 4657 "parser.cc" /* yacc.c:1646 */
4657  break;
4658 
4659  case 246:
4660 #line 1644 "parser.y" /* yacc.c:1646 */
4661  {
4662  if (!is_valid_u16((yyvsp[-1].integer))) {
4663  semantic_error("number out of range");
4664  }
4665  (yyval.expression) = new_integer_expression((yyvsp[-1].integer), "%lu");
4666 }
4667 #line 4668 "parser.cc" /* yacc.c:1646 */
4668  break;
4669 
4670  case 247:
4671 #line 1650 "parser.y" /* yacc.c:1646 */
4672  {
4673  (yyval.expression) = new PacketDrillExpression(EXPR_WORD);
4674  (yyval.expression)->setString((yyvsp[0].string));
4675 }
4676 #line 4677 "parser.cc" /* yacc.c:1646 */
4677  break;
4678 
4679  case 248:
4680 #line 1654 "parser.y" /* yacc.c:1646 */
4681  {
4682  (yyval.expression) = new PacketDrillExpression(EXPR_STRING);
4683  (yyval.expression)->setString((yyvsp[0].string));
4684  (yyval.expression)->setFormat("\"%s\"");
4685 }
4686 #line 4687 "parser.cc" /* yacc.c:1646 */
4687  break;
4688 
4689  case 249:
4690 #line 1659 "parser.y" /* yacc.c:1646 */
4691  {
4692  (yyval.expression) = new PacketDrillExpression(EXPR_STRING);
4693  (yyval.expression)->setString((yyvsp[-1].string));
4694  (yyval.expression)->setFormat("\"%s\"...");
4695 }
4696 #line 4697 "parser.cc" /* yacc.c:1646 */
4697  break;
4698 
4699  case 250:
4700 #line 1664 "parser.y" /* yacc.c:1646 */
4701  {
4702  (yyval.expression) = (yyvsp[0].expression);
4703 }
4704 #line 4705 "parser.cc" /* yacc.c:1646 */
4705  break;
4706 
4707  case 251:
4708 #line 1667 "parser.y" /* yacc.c:1646 */
4709  {
4710  (yyval.expression) = (yyvsp[0].expression);
4711 }
4712 #line 4713 "parser.cc" /* yacc.c:1646 */
4713  break;
4714 
4715  case 252:
4716 #line 1670 "parser.y" /* yacc.c:1646 */
4717  {
4718  (yyval.expression) = (yyvsp[0].expression);
4719 }
4720 #line 4721 "parser.cc" /* yacc.c:1646 */
4721  break;
4722 
4723  case 253:
4724 #line 1673 "parser.y" /* yacc.c:1646 */
4725  {
4726  (yyval.expression) = (yyvsp[0].expression);
4727 }
4728 #line 4729 "parser.cc" /* yacc.c:1646 */
4729  break;
4730 
4731  case 254:
4732 #line 1676 "parser.y" /* yacc.c:1646 */
4733  {
4734  (yyval.expression) = (yyvsp[0].expression);
4735 }
4736 #line 4737 "parser.cc" /* yacc.c:1646 */
4737  break;
4738 
4739  case 255:
4740 #line 1679 "parser.y" /* yacc.c:1646 */
4741  {
4742  (yyval.expression) = (yyvsp[0].expression);
4743 }
4744 #line 4745 "parser.cc" /* yacc.c:1646 */
4745  break;
4746 
4747  case 256:
4748 #line 1682 "parser.y" /* yacc.c:1646 */
4749  {
4750  (yyval.expression) = (yyvsp[0].expression);
4751 }
4752 #line 4753 "parser.cc" /* yacc.c:1646 */
4753  break;
4754 
4755  case 257:
4756 #line 1685 "parser.y" /* yacc.c:1646 */
4757  {
4758  (yyval.expression) = (yyvsp[0].expression);
4759 }
4760 #line 4761 "parser.cc" /* yacc.c:1646 */
4761  break;
4762 
4763  case 258:
4764 #line 1688 "parser.y" /* yacc.c:1646 */
4765  {
4766  (yyval.expression) = (yyvsp[0].expression);
4767 }
4768 #line 4769 "parser.cc" /* yacc.c:1646 */
4769  break;
4770 
4771  case 259:
4772 #line 1691 "parser.y" /* yacc.c:1646 */
4773  {
4774  (yyval.expression) = (yyvsp[0].expression);
4775 }
4776 #line 4777 "parser.cc" /* yacc.c:1646 */
4777  break;
4778 
4779  case 260:
4780 #line 1694 "parser.y" /* yacc.c:1646 */
4781  {
4782  (yyval.expression) = (yyvsp[0].expression);
4783 }
4784 #line 4785 "parser.cc" /* yacc.c:1646 */
4785  break;
4786 
4787  case 261:
4788 #line 1697 "parser.y" /* yacc.c:1646 */
4789  {
4790  (yyval.expression) = (yyvsp[0].expression);
4791 }
4792 #line 4793 "parser.cc" /* yacc.c:1646 */
4793  break;
4794 
4795  case 262:
4796 #line 1700 "parser.y" /* yacc.c:1646 */
4797  {
4798  (yyval.expression) = (yyvsp[0].expression);
4799 }
4800 #line 4801 "parser.cc" /* yacc.c:1646 */
4801  break;
4802 
4803  case 263:
4804 #line 1708 "parser.y" /* yacc.c:1646 */
4805  {
4806  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%ld");
4807 }
4808 #line 4809 "parser.cc" /* yacc.c:1646 */
4809  break;
4810 
4811  case 264:
4812 #line 1714 "parser.y" /* yacc.c:1646 */
4813  {
4814  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%#lx");
4815 }
4816 #line 4817 "parser.cc" /* yacc.c:1646 */
4817  break;
4818 
4819  case 265:
4820 #line 1720 "parser.y" /* yacc.c:1646 */
4821  { /* bitwise OR */
4822  (yyval.expression) = new PacketDrillExpression(EXPR_BINARY);
4823  struct binary_expression *binary = (struct binary_expression *) malloc(sizeof(struct binary_expression));
4824  binary->op = strdup("|");
4825  binary->lhs = (yyvsp[-2].expression);
4826  binary->rhs = (yyvsp[0].expression);
4827  (yyval.expression)->setBinary(binary);
4828 }
4829 #line 4830 "parser.cc" /* yacc.c:1646 */
4830  break;
4831 
4832  case 266:
4833 #line 1731 "parser.y" /* yacc.c:1646 */
4834  {
4835  (yyval.expression) = new PacketDrillExpression(EXPR_LIST);
4836  (yyval.expression)->setList(NULL);
4837 }
4838 #line 4839 "parser.cc" /* yacc.c:1646 */
4839  break;
4840 
4841  case 267:
4842 #line 1735 "parser.y" /* yacc.c:1646 */
4843  {
4844  (yyval.expression) = new PacketDrillExpression(EXPR_LIST);
4845  (yyval.expression)->setList((yyvsp[-1].expression_list));
4846 }
4847 #line 4848 "parser.cc" /* yacc.c:1646 */
4848  break;
4849 
4850  case 268:
4851 #line 1742 "parser.y" /* yacc.c:1646 */
4852  {
4853  if (!is_valid_u32((yyvsp[0].integer))) {
4854  semantic_error("srto_initial out of range\n");
4855  }
4856  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
4857 }
4858 #line 4859 "parser.cc" /* yacc.c:1646 */
4859  break;
4860 
4861  case 269:
4862 #line 1748 "parser.y" /* yacc.c:1646 */
4863  {
4864  (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS);
4865 }
4866 #line 4867 "parser.cc" /* yacc.c:1646 */
4867  break;
4868 
4869  case 270:
4870 #line 1754 "parser.y" /* yacc.c:1646 */
4871  {
4872  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
4873 }
4874 #line 4875 "parser.cc" /* yacc.c:1646 */
4875  break;
4876 
4877  case 271:
4878 #line 1757 "parser.y" /* yacc.c:1646 */
4879  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
4880 #line 4881 "parser.cc" /* yacc.c:1646 */
4881  break;
4882 
4883  case 272:
4884 #line 1761 "parser.y" /* yacc.c:1646 */
4885  {
4886  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
4887 }
4888 #line 4889 "parser.cc" /* yacc.c:1646 */
4889  break;
4890 
4891  case 273:
4892 #line 1764 "parser.y" /* yacc.c:1646 */
4893  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
4894 #line 4895 "parser.cc" /* yacc.c:1646 */
4895  break;
4896 
4897  case 274:
4898 #line 1768 "parser.y" /* yacc.c:1646 */
4899  {
4900  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
4901 }
4902 #line 4903 "parser.cc" /* yacc.c:1646 */
4903  break;
4904 
4905  case 275:
4906 #line 1771 "parser.y" /* yacc.c:1646 */
4907  {
4908  (yyval.expression) = new PacketDrillExpression(EXPR_WORD);
4909  (yyval.expression)->setString((yyvsp[0].string));
4910 }
4911 #line 4912 "parser.cc" /* yacc.c:1646 */
4912  break;
4913 
4914  case 276:
4915 #line 1775 "parser.y" /* yacc.c:1646 */
4916  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
4917 #line 4918 "parser.cc" /* yacc.c:1646 */
4918  break;
4919 
4920  case 277:
4921 #line 1779 "parser.y" /* yacc.c:1646 */
4922  {
4923  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_RTOINFO);
4924  struct sctp_rtoinfo_expr *rtoinfo = (struct sctp_rtoinfo_expr *) malloc(sizeof(struct sctp_rtoinfo_expr));
4925  rtoinfo->srto_assoc_id = (yyvsp[-7].expression);
4926  rtoinfo->srto_initial = (yyvsp[-5].expression);
4927  rtoinfo->srto_max = (yyvsp[-3].expression);
4928  rtoinfo->srto_min = (yyvsp[-1].expression);
4929  (yyval.expression)->setRtoinfo(rtoinfo);
4930 }
4931 #line 4932 "parser.cc" /* yacc.c:1646 */
4932  break;
4933 
4934  case 278:
4935 #line 1788 "parser.y" /* yacc.c:1646 */
4936  {
4937  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_RTOINFO);
4938  struct sctp_rtoinfo_expr *rtoinfo = (struct sctp_rtoinfo_expr *) malloc(sizeof(struct sctp_rtoinfo_expr));
4939  rtoinfo->srto_assoc_id = new PacketDrillExpression(EXPR_ELLIPSIS);
4940  rtoinfo->srto_initial = (yyvsp[-5].expression);
4941  rtoinfo->srto_max = (yyvsp[-3].expression);
4942  rtoinfo->srto_min = (yyvsp[-1].expression);
4943  (yyval.expression)->setRtoinfo(rtoinfo);
4944 }
4945 #line 4946 "parser.cc" /* yacc.c:1646 */
4946  break;
4947 
4948  case 279:
4949 #line 1800 "parser.y" /* yacc.c:1646 */
4950  {
4951  if (!is_valid_u16((yyvsp[0].integer))) {
4952  semantic_error("sasoc_asocmaxrxt out of range");
4953  }
4954  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hu");
4955 }
4956 #line 4957 "parser.cc" /* yacc.c:1646 */
4957  break;
4958 
4959  case 280:
4960 #line 1806 "parser.y" /* yacc.c:1646 */
4961  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
4962 #line 4963 "parser.cc" /* yacc.c:1646 */
4963  break;
4964 
4965  case 281:
4966 #line 1810 "parser.y" /* yacc.c:1646 */
4967  {
4968  if (!is_valid_u16((yyvsp[0].integer))) {
4969  semantic_error("sasoc_number_peer_destinations out of range");
4970  }
4971  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hu");
4972 }
4973 #line 4974 "parser.cc" /* yacc.c:1646 */
4974  break;
4975 
4976  case 282:
4977 #line 1816 "parser.y" /* yacc.c:1646 */
4978  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
4979 #line 4980 "parser.cc" /* yacc.c:1646 */
4980  break;
4981 
4982  case 283:
4983 #line 1820 "parser.y" /* yacc.c:1646 */
4984  {
4985  if (!is_valid_u32((yyvsp[0].integer))) {
4986  semantic_error("sasoc_peer_rwnd out of range");
4987  }
4988  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
4989 }
4990 #line 4991 "parser.cc" /* yacc.c:1646 */
4991  break;
4992 
4993  case 284:
4994 #line 1826 "parser.y" /* yacc.c:1646 */
4995  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
4996 #line 4997 "parser.cc" /* yacc.c:1646 */
4997  break;
4998 
4999  case 285:
5000 #line 1830 "parser.y" /* yacc.c:1646 */
5001  {
5002  if (!is_valid_u32((yyvsp[0].integer))) {
5003  semantic_error("sasoc_local_rwnd out of range");
5004  }
5005  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5006 }
5007 #line 5008 "parser.cc" /* yacc.c:1646 */
5008  break;
5009 
5010  case 286:
5011 #line 1836 "parser.y" /* yacc.c:1646 */
5012  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5013 #line 5014 "parser.cc" /* yacc.c:1646 */
5014  break;
5015 
5016  case 287:
5017 #line 1840 "parser.y" /* yacc.c:1646 */
5018  {
5019  if (!is_valid_u32((yyvsp[0].integer))) {
5020  semantic_error("sasoc_cookie_life out of range");
5021  }
5022  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5023 }
5024 #line 5025 "parser.cc" /* yacc.c:1646 */
5025  break;
5026 
5027  case 288:
5028 #line 1846 "parser.y" /* yacc.c:1646 */
5029  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5030 #line 5031 "parser.cc" /* yacc.c:1646 */
5031  break;
5032 
5033  case 289:
5034 #line 1851 "parser.y" /* yacc.c:1646 */
5035  {
5036  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_ASSOCPARAMS);
5037  struct sctp_assocparams_expr *assocparams = (struct sctp_assocparams_expr *) malloc(sizeof(struct sctp_assocparams_expr));
5038  assocparams->sasoc_assoc_id = (yyvsp[-11].expression);
5039  assocparams->sasoc_asocmaxrxt = (yyvsp[-9].expression);
5040  assocparams->sasoc_number_peer_destinations = (yyvsp[-7].expression);
5041  assocparams->sasoc_peer_rwnd = (yyvsp[-5].expression);
5042  assocparams->sasoc_local_rwnd = (yyvsp[-3].expression);
5043  assocparams->sasoc_cookie_life = (yyvsp[-1].expression);
5044  (yyval.expression)->setAssocParams(assocparams);
5045 }
5046 #line 5047 "parser.cc" /* yacc.c:1646 */
5047  break;
5048 
5049  case 290:
5050 #line 1863 "parser.y" /* yacc.c:1646 */
5051  {
5052  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_ASSOCPARAMS);
5053  struct sctp_assocparams_expr *assocparams = (struct sctp_assocparams_expr *) malloc(sizeof(struct sctp_assocparams_expr));
5054  assocparams->sasoc_assoc_id = new PacketDrillExpression(EXPR_ELLIPSIS);
5055  assocparams->sasoc_asocmaxrxt = (yyvsp[-9].expression);
5056  assocparams->sasoc_number_peer_destinations = (yyvsp[-7].expression);
5057  assocparams->sasoc_peer_rwnd = (yyvsp[-5].expression);
5058  assocparams->sasoc_local_rwnd = (yyvsp[-3].expression);
5059  assocparams->sasoc_cookie_life = (yyvsp[-1].expression);
5060  (yyval.expression)->setAssocParams(assocparams);
5061 }
5062 #line 5063 "parser.cc" /* yacc.c:1646 */
5063  break;
5064 
5065  case 291:
5066 #line 1878 "parser.y" /* yacc.c:1646 */
5067  {
5068  if (!is_valid_u16((yyvsp[0].integer))) {
5069  semantic_error("sinit_num_ostreams out of range");
5070  }
5071  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hu");
5072 }
5073 #line 5074 "parser.cc" /* yacc.c:1646 */
5074  break;
5075 
5076  case 292:
5077 #line 1884 "parser.y" /* yacc.c:1646 */
5078  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5079 #line 5080 "parser.cc" /* yacc.c:1646 */
5080  break;
5081 
5082  case 293:
5083 #line 1888 "parser.y" /* yacc.c:1646 */
5084  {
5085  if (!is_valid_u16((yyvsp[0].integer))) {
5086  semantic_error("sinit_max_instreams out of range");
5087  }
5088  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hu");
5089 }
5090 #line 5091 "parser.cc" /* yacc.c:1646 */
5091  break;
5092 
5093  case 294:
5094 #line 1894 "parser.y" /* yacc.c:1646 */
5095  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5096 #line 5097 "parser.cc" /* yacc.c:1646 */
5097  break;
5098 
5099  case 295:
5100 #line 1898 "parser.y" /* yacc.c:1646 */
5101  {
5102  if (!is_valid_u16((yyvsp[0].integer))) {
5103  semantic_error("sinit_max_attempts out of range");
5104  }
5105  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hu");
5106 }
5107 #line 5108 "parser.cc" /* yacc.c:1646 */
5108  break;
5109 
5110  case 296:
5111 #line 1904 "parser.y" /* yacc.c:1646 */
5112  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5113 #line 5114 "parser.cc" /* yacc.c:1646 */
5114  break;
5115 
5116  case 297:
5117 #line 1908 "parser.y" /* yacc.c:1646 */
5118  {
5119  if (!is_valid_u16((yyvsp[0].integer))) {
5120  semantic_error("sinit_max_init_timeo out of range");
5121  }
5122  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hu");
5123 }
5124 #line 5125 "parser.cc" /* yacc.c:1646 */
5125  break;
5126 
5127  case 298:
5128 #line 1914 "parser.y" /* yacc.c:1646 */
5129  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5130 #line 5131 "parser.cc" /* yacc.c:1646 */
5131  break;
5132 
5133  case 299:
5134 #line 1919 "parser.y" /* yacc.c:1646 */
5135  {
5136  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_INITMSG);
5137  struct sctp_initmsg_expr *initmsg = (struct sctp_initmsg_expr *) malloc(sizeof(struct sctp_initmsg_expr));
5138  initmsg->sinit_num_ostreams = (yyvsp[-7].expression);
5139  initmsg->sinit_max_instreams = (yyvsp[-5].expression);
5140  initmsg->sinit_max_attempts = (yyvsp[-3].expression);
5141  initmsg->sinit_max_init_timeo = (yyvsp[-1].expression);
5142  (yyval.expression)->setInitmsg(initmsg);
5143 }
5144 #line 5145 "parser.cc" /* yacc.c:1646 */
5145  break;
5146 
5147  case 300:
5148 #line 1933 "parser.y" /* yacc.c:1646 */
5149  {
5150  if (strcmp((yyvsp[-15].string), "AF_INET") == 0) {
5151  (yyval.expression) = new PacketDrillExpression(EXPR_SOCKET_ADDRESS_IPV4);
5152  (yyval.expression)->setIp(new L3Address(IPv4Address()));
5153  } else if (strcmp((yyvsp[-15].string), "AF_INET6") == 0) {
5154  (yyval.expression) = new PacketDrillExpression(EXPR_SOCKET_ADDRESS_IPV6);
5155  (yyval.expression)->setIp(new L3Address(IPv6Address()));
5156  }
5157 }
5158 #line 5159 "parser.cc" /* yacc.c:1646 */
5159  break;
5160 
5161  case 301:
5162 #line 1945 "parser.y" /* yacc.c:1646 */
5163  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5164 #line 5165 "parser.cc" /* yacc.c:1646 */
5165  break;
5166 
5167  case 302:
5168 #line 1946 "parser.y" /* yacc.c:1646 */
5169  { (yyval.expression) = (yyvsp[0].expression); }
5170 #line 5171 "parser.cc" /* yacc.c:1646 */
5171  break;
5172 
5173  case 303:
5174 #line 1950 "parser.y" /* yacc.c:1646 */
5175  {
5176  if (!is_valid_u32((yyvsp[0].integer))) {
5177  semantic_error("spp_hbinterval out of range");
5178  }
5179  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5180 }
5181 #line 5182 "parser.cc" /* yacc.c:1646 */
5182  break;
5183 
5184  case 304:
5185 #line 1956 "parser.y" /* yacc.c:1646 */
5186  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5187 #line 5188 "parser.cc" /* yacc.c:1646 */
5188  break;
5189 
5190  case 305:
5191 #line 1960 "parser.y" /* yacc.c:1646 */
5192  {
5193  if (!is_valid_u32((yyvsp[0].integer))) {
5194  semantic_error("spp_pathmtu out of range");
5195  }
5196  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5197 }
5198 #line 5199 "parser.cc" /* yacc.c:1646 */
5199  break;
5200 
5201  case 306:
5202 #line 1966 "parser.y" /* yacc.c:1646 */
5203  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5204 #line 5205 "parser.cc" /* yacc.c:1646 */
5205  break;
5206 
5207  case 307:
5208 #line 1970 "parser.y" /* yacc.c:1646 */
5209  {
5210  if (!is_valid_u16((yyvsp[0].integer))) {
5211  semantic_error("spp_pathmaxrxt out of range");
5212  }
5213  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hu");
5214 }
5215 #line 5216 "parser.cc" /* yacc.c:1646 */
5216  break;
5217 
5218  case 308:
5219 #line 1976 "parser.y" /* yacc.c:1646 */
5220  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5221 #line 5222 "parser.cc" /* yacc.c:1646 */
5222  break;
5223 
5224  case 309:
5225 #line 1980 "parser.y" /* yacc.c:1646 */
5226  { (yyval.expression) = (yyvsp[0].expression); }
5227 #line 5228 "parser.cc" /* yacc.c:1646 */
5228  break;
5229 
5230  case 310:
5231 #line 1984 "parser.y" /* yacc.c:1646 */
5232  {
5233  if (!is_valid_u32((yyvsp[0].integer))) {
5234  semantic_error("spp_ipv6_flowlabel out of range");
5235  }
5236  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5237 }
5238 #line 5239 "parser.cc" /* yacc.c:1646 */
5239  break;
5240 
5241  case 311:
5242 #line 1990 "parser.y" /* yacc.c:1646 */
5243  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5244 #line 5245 "parser.cc" /* yacc.c:1646 */
5245  break;
5246 
5247  case 312:
5248 #line 1994 "parser.y" /* yacc.c:1646 */
5249  {
5250  if (!is_valid_u8((yyvsp[0].integer))) {
5251  semantic_error("spp_dscp out of range");
5252  }
5253  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hhu");
5254 }
5255 #line 5256 "parser.cc" /* yacc.c:1646 */
5256  break;
5257 
5258  case 313:
5259 #line 2000 "parser.y" /* yacc.c:1646 */
5260  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5261 #line 5262 "parser.cc" /* yacc.c:1646 */
5262  break;
5263 
5264  case 314:
5265 #line 2005 "parser.y" /* yacc.c:1646 */
5266  {
5267  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_PEER_ADDR_PARAMS);
5268  struct sctp_paddrparams_expr *params = (struct sctp_paddrparams_expr *) malloc(sizeof(struct sctp_paddrparams_expr));
5269  params->spp_assoc_id = (yyvsp[-15].expression);
5270  params->spp_address = (yyvsp[-13].expression);
5271  params->spp_hbinterval = (yyvsp[-11].expression);
5272  params->spp_pathmaxrxt = (yyvsp[-9].expression);
5273  params->spp_pathmtu = (yyvsp[-7].expression);
5274  params->spp_flags = (yyvsp[-5].expression);
5275  params->spp_ipv6_flowlabel = (yyvsp[-3].expression);
5276  params->spp_dscp = (yyvsp[-1].expression);
5277  (yyval.expression)->setPaddrParams(params);
5278 }
5279 #line 5280 "parser.cc" /* yacc.c:1646 */
5280  break;
5281 
5282  case 315:
5283 #line 2019 "parser.y" /* yacc.c:1646 */
5284  {
5285  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_PEER_ADDR_PARAMS);
5286  struct sctp_paddrparams_expr *params = (struct sctp_paddrparams_expr *) malloc(sizeof(struct sctp_paddrparams_expr));
5287  params->spp_assoc_id = new PacketDrillExpression(EXPR_ELLIPSIS);
5288  params->spp_address = (yyvsp[-13].expression);
5289  params->spp_hbinterval = (yyvsp[-11].expression);
5290  params->spp_pathmaxrxt = (yyvsp[-9].expression);
5291  params->spp_pathmtu = (yyvsp[-7].expression);
5292  params->spp_flags = (yyvsp[-5].expression);
5293  params->spp_ipv6_flowlabel = (yyvsp[-3].expression);
5294  params->spp_dscp = (yyvsp[-1].expression);
5295  (yyval.expression)->setPaddrParams(params);
5296 }
5297 #line 5298 "parser.cc" /* yacc.c:1646 */
5298  break;
5299 
5300  case 316:
5301 #line 2035 "parser.y" /* yacc.c:1646 */
5302  { (yyval.expression) = (yyvsp[0].expression); }
5303 #line 5304 "parser.cc" /* yacc.c:1646 */
5304  break;
5305 
5306  case 317:
5307 #line 2039 "parser.y" /* yacc.c:1646 */
5308  {
5309  if (!is_valid_u32((yyvsp[0].integer))) {
5310  semantic_error("sstat_rwnd out of range");
5311  }
5312  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5313 }
5314 #line 5315 "parser.cc" /* yacc.c:1646 */
5315  break;
5316 
5317  case 318:
5318 #line 2045 "parser.y" /* yacc.c:1646 */
5319  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5320 #line 5321 "parser.cc" /* yacc.c:1646 */
5321  break;
5322 
5323  case 319:
5324 #line 2049 "parser.y" /* yacc.c:1646 */
5325  {
5326  if (!is_valid_u16((yyvsp[0].integer))) {
5327  semantic_error("sstat_unackdata out of range");
5328  }
5329  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hu");
5330 }
5331 #line 5332 "parser.cc" /* yacc.c:1646 */
5332  break;
5333 
5334  case 320:
5335 #line 2055 "parser.y" /* yacc.c:1646 */
5336  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5337 #line 5338 "parser.cc" /* yacc.c:1646 */
5338  break;
5339 
5340  case 321:
5341 #line 2059 "parser.y" /* yacc.c:1646 */
5342  {
5343  if (!is_valid_u16((yyvsp[0].integer))) {
5344  semantic_error("sstat_penddata out of range");
5345  }
5346  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hu");
5347 }
5348 #line 5349 "parser.cc" /* yacc.c:1646 */
5349  break;
5350 
5351  case 322:
5352 #line 2065 "parser.y" /* yacc.c:1646 */
5353  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5354 #line 5355 "parser.cc" /* yacc.c:1646 */
5355  break;
5356 
5357  case 323:
5358 #line 2069 "parser.y" /* yacc.c:1646 */
5359  {
5360  if (!is_valid_u16((yyvsp[0].integer))) {
5361  semantic_error("sstat_instrms out of range");
5362  }
5363  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hu");
5364 }
5365 #line 5366 "parser.cc" /* yacc.c:1646 */
5366  break;
5367 
5368  case 324:
5369 #line 2075 "parser.y" /* yacc.c:1646 */
5370  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5371 #line 5372 "parser.cc" /* yacc.c:1646 */
5372  break;
5373 
5374  case 325:
5375 #line 2079 "parser.y" /* yacc.c:1646 */
5376  {
5377  if (!is_valid_u16((yyvsp[0].integer))) {
5378  semantic_error("sstat_outstrms out of range");
5379  }
5380  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hu");
5381 }
5382 #line 5383 "parser.cc" /* yacc.c:1646 */
5383  break;
5384 
5385  case 326:
5386 #line 2085 "parser.y" /* yacc.c:1646 */
5387  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5388 #line 5389 "parser.cc" /* yacc.c:1646 */
5389  break;
5390 
5391  case 327:
5392 #line 2089 "parser.y" /* yacc.c:1646 */
5393  {
5394  if (!is_valid_u32((yyvsp[0].integer))) {
5395  semantic_error("sstat_fragmentation_point out of range");
5396  }
5397  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5398 }
5399 #line 5400 "parser.cc" /* yacc.c:1646 */
5400  break;
5401 
5402  case 328:
5403 #line 2095 "parser.y" /* yacc.c:1646 */
5404  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5405 #line 5406 "parser.cc" /* yacc.c:1646 */
5406  break;
5407 
5408  case 329:
5409 #line 2099 "parser.y" /* yacc.c:1646 */
5410  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5411 #line 5412 "parser.cc" /* yacc.c:1646 */
5412  break;
5413 
5414  case 330:
5415 #line 2105 "parser.y" /* yacc.c:1646 */
5416  {
5417  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_STATUS);
5418  struct sctp_status_expr *stat = (struct sctp_status_expr *) calloc(1, sizeof(struct sctp_status_expr));
5419  stat->sstat_assoc_id = (yyvsp[-17].expression);
5420  stat->sstat_state = (yyvsp[-15].expression);
5421  stat->sstat_rwnd = (yyvsp[-13].expression);
5422  stat->sstat_unackdata = (yyvsp[-11].expression);
5423  stat->sstat_penddata = (yyvsp[-9].expression);
5424  stat->sstat_instrms = (yyvsp[-7].expression);
5425  stat->sstat_outstrms = (yyvsp[-5].expression);
5426  stat->sstat_fragmentation_point = (yyvsp[-3].expression);
5427  stat->sstat_primary = (yyvsp[-1].expression);
5428  (yyval.expression)->setStatus(stat);
5429 }
5430 #line 5431 "parser.cc" /* yacc.c:1646 */
5431  break;
5432 
5433  case 331:
5434 #line 2120 "parser.y" /* yacc.c:1646 */
5435  {
5436  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_STATUS);
5437  struct sctp_status_expr *stat = (struct sctp_status_expr *) calloc(1, sizeof(struct sctp_status_expr));
5438  stat->sstat_assoc_id = new PacketDrillExpression(EXPR_ELLIPSIS);
5439  stat->sstat_state = (yyvsp[-15].expression);
5440  stat->sstat_rwnd = (yyvsp[-13].expression);
5441  stat->sstat_unackdata = (yyvsp[-11].expression);
5442  stat->sstat_penddata = (yyvsp[-9].expression);
5443  stat->sstat_instrms = (yyvsp[-7].expression);
5444  stat->sstat_outstrms = (yyvsp[-5].expression);
5445  stat->sstat_fragmentation_point = (yyvsp[-3].expression);
5446  stat->sstat_primary = (yyvsp[-1].expression);
5447  (yyval.expression)->setStatus(stat);
5448 }
5449 #line 5450 "parser.cc" /* yacc.c:1646 */
5450  break;
5451 
5452  case 332:
5453 #line 2137 "parser.y" /* yacc.c:1646 */
5454  {
5455  if (!is_valid_u16((yyvsp[0].integer))) {
5456  semantic_error("sinfo_stream out of range");
5457  }
5458  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5459 }
5460 #line 5461 "parser.cc" /* yacc.c:1646 */
5461  break;
5462 
5463  case 333:
5464 #line 2143 "parser.y" /* yacc.c:1646 */
5465  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5466 #line 5467 "parser.cc" /* yacc.c:1646 */
5467  break;
5468 
5469  case 334:
5470 #line 2147 "parser.y" /* yacc.c:1646 */
5471  {
5472  if (!is_valid_u16((yyvsp[0].integer))) {
5473  semantic_error("sinfo_ssn out of range");
5474  }
5475  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5476 }
5477 #line 5478 "parser.cc" /* yacc.c:1646 */
5478  break;
5479 
5480  case 335:
5481 #line 2153 "parser.y" /* yacc.c:1646 */
5482  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5483 #line 5484 "parser.cc" /* yacc.c:1646 */
5484  break;
5485 
5486  case 336:
5487 #line 2157 "parser.y" /* yacc.c:1646 */
5488  { (yyval.expression) = (yyvsp[0].expression); }
5489 #line 5490 "parser.cc" /* yacc.c:1646 */
5490  break;
5491 
5492  case 337:
5493 #line 2161 "parser.y" /* yacc.c:1646 */
5494  {
5495  if (!is_valid_u32((yyvsp[-1].integer))) {
5496  semantic_error("sinfo_ppid out of range");
5497  }
5498  (yyval.expression) = new_integer_expression((yyvsp[-1].integer), "%u");
5499 }
5500 #line 5501 "parser.cc" /* yacc.c:1646 */
5501  break;
5502 
5503  case 338:
5504 #line 2167 "parser.y" /* yacc.c:1646 */
5505  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5506 #line 5507 "parser.cc" /* yacc.c:1646 */
5507  break;
5508 
5509  case 339:
5510 #line 2171 "parser.y" /* yacc.c:1646 */
5511  {
5512  if (!is_valid_u32((yyvsp[0].integer))) {
5513  semantic_error("sinfo_context out of range");
5514  }
5515  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5516 }
5517 #line 5518 "parser.cc" /* yacc.c:1646 */
5518  break;
5519 
5520  case 340:
5521 #line 2177 "parser.y" /* yacc.c:1646 */
5522  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5523 #line 5524 "parser.cc" /* yacc.c:1646 */
5524  break;
5525 
5526  case 341:
5527 #line 2181 "parser.y" /* yacc.c:1646 */
5528  {
5529  if (!is_valid_u32((yyvsp[0].integer))) {
5530  semantic_error("sinfo_timetolive out of range");
5531  }
5532  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5533 }
5534 #line 5535 "parser.cc" /* yacc.c:1646 */
5535  break;
5536 
5537  case 342:
5538 #line 2187 "parser.y" /* yacc.c:1646 */
5539  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5540 #line 5541 "parser.cc" /* yacc.c:1646 */
5541  break;
5542 
5543  case 343:
5544 #line 2191 "parser.y" /* yacc.c:1646 */
5545  {
5546  if (!is_valid_u32((yyvsp[0].integer))) {
5547  semantic_error("sinfo_tsn out of range");
5548  }
5549  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5550 }
5551 #line 5552 "parser.cc" /* yacc.c:1646 */
5552  break;
5553 
5554  case 344:
5555 #line 2197 "parser.y" /* yacc.c:1646 */
5556  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5557 #line 5558 "parser.cc" /* yacc.c:1646 */
5558  break;
5559 
5560  case 345:
5561 #line 2201 "parser.y" /* yacc.c:1646 */
5562  {
5563  if (!is_valid_u32((yyvsp[0].integer))) {
5564  semantic_error("sinfo_cumtsn out of range");
5565  }
5566  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5567 }
5568 #line 5569 "parser.cc" /* yacc.c:1646 */
5569  break;
5570 
5571  case 346:
5572 #line 2207 "parser.y" /* yacc.c:1646 */
5573  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5574 #line 5575 "parser.cc" /* yacc.c:1646 */
5575  break;
5576 
5577  case 347:
5578 #line 2213 "parser.y" /* yacc.c:1646 */
5579  {
5580  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_SNDRCVINFO);
5581  struct sctp_sndrcvinfo_expr *info = (struct sctp_sndrcvinfo_expr *) calloc(1, sizeof(struct sctp_sndrcvinfo_expr));
5582  info->sinfo_stream = (yyvsp[-19].expression);
5583  info->sinfo_ssn = (yyvsp[-17].expression);
5584  info->sinfo_flags = (yyvsp[-15].expression);
5585  info->sinfo_ppid = (yyvsp[-13].expression);
5586  info->sinfo_context = (yyvsp[-11].expression);
5587  info->sinfo_timetolive = (yyvsp[-9].expression);
5588  info->sinfo_tsn = (yyvsp[-7].expression);
5589  info->sinfo_cumtsn = (yyvsp[-5].expression);
5590  info->sinfo_assoc_id = (yyvsp[-1].expression);
5591  (yyval.expression)->setSndRcvInfo(info);
5592 }
5593 #line 5594 "parser.cc" /* yacc.c:1646 */
5594  break;
5595 
5596  case 348:
5597 #line 2228 "parser.y" /* yacc.c:1646 */
5598  {
5599  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_SNDRCVINFO);
5600  struct sctp_sndrcvinfo_expr *info = (struct sctp_sndrcvinfo_expr *) malloc(sizeof(struct sctp_sndrcvinfo_expr));
5601  info->sinfo_stream = (yyvsp[-15].expression);
5602  info->sinfo_ssn = (yyvsp[-13].expression);
5603  info->sinfo_flags = (yyvsp[-11].expression);
5604  info->sinfo_ppid = (yyvsp[-9].expression);
5605  info->sinfo_context = (yyvsp[-7].expression);
5606  info->sinfo_timetolive = (yyvsp[-5].expression);
5607  info->sinfo_tsn = (yyvsp[-3].expression);
5608  info->sinfo_cumtsn = (yyvsp[-1].expression);
5609  info->sinfo_assoc_id = new PacketDrillExpression(EXPR_ELLIPSIS);
5610  (yyval.expression)->setSndRcvInfo(info);
5611 }
5612 #line 5613 "parser.cc" /* yacc.c:1646 */
5613  break;
5614 
5615  case 349:
5616 #line 2244 "parser.y" /* yacc.c:1646 */
5617  {
5618 printf("SRS_FLAGS = INTEGER\n");
5619  if (!is_valid_u16((yyvsp[0].integer))) {
5620  semantic_error("srs_flags out of range");
5621  }
5622  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%hu");
5623 }
5624 #line 5625 "parser.cc" /* yacc.c:1646 */
5625  break;
5626 
5627  case 350:
5628 #line 2251 "parser.y" /* yacc.c:1646 */
5629  {
5630 printf("SRS_FLAGS = MYWORD\n");
5631  (yyval.expression) = new PacketDrillExpression(EXPR_WORD);
5632  (yyval.expression)->setString((yyvsp[0].string));
5633 }
5634 #line 5635 "parser.cc" /* yacc.c:1646 */
5635  break;
5636 
5637  case 351:
5638 #line 2256 "parser.y" /* yacc.c:1646 */
5639  {
5640  (yyval.expression) = (yyvsp[0].expression);
5641 }
5642 #line 5643 "parser.cc" /* yacc.c:1646 */
5643  break;
5644 
5645  case 352:
5646 #line 2262 "parser.y" /* yacc.c:1646 */
5647  {
5648  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_RESET_STREAMS);
5649  struct sctp_reset_streams_expr *rs = (struct sctp_reset_streams_expr *) malloc(sizeof(struct sctp_reset_streams_expr));
5650  rs->srs_assoc_id = (yyvsp[-11].expression);
5651  rs->srs_flags = (yyvsp[-9].expression);
5652  if (!is_valid_u16((yyvsp[-5].integer))) {
5653  semantic_error("srs_number_streams out of range");
5654  }
5655  rs->srs_number_streams = new_integer_expression((yyvsp[-5].integer), "%hu");
5656  rs->srs_stream_list = (yyvsp[-1].expression);
5657  (yyval.expression)->setResetStreams(rs);
5658 }
5659 #line 5660 "parser.cc" /* yacc.c:1646 */
5660  break;
5661 
5662  case 353:
5663 #line 2274 "parser.y" /* yacc.c:1646 */
5664  {
5665  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_RESET_STREAMS);
5666  struct sctp_reset_streams_expr *rs = (struct sctp_reset_streams_expr *) malloc(sizeof(struct sctp_reset_streams_expr));
5667  rs->srs_assoc_id = new PacketDrillExpression(EXPR_ELLIPSIS);
5668  rs->srs_flags = (yyvsp[-9].expression);
5669  if (!is_valid_u16((yyvsp[-5].integer))) {
5670  semantic_error("srs_number_streams out of range");
5671  }
5672  rs->srs_number_streams = new_integer_expression((yyvsp[-5].integer), "%hu");
5673  rs->srs_stream_list = (yyvsp[-1].expression);
5674  (yyval.expression)->setResetStreams(rs);
5675 }
5676 #line 5677 "parser.cc" /* yacc.c:1646 */
5677  break;
5678 
5679  case 354:
5680 #line 2289 "parser.y" /* yacc.c:1646 */
5681  {
5682  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_ADD_STREAMS);
5683  struct sctp_add_streams_expr *rs = (struct sctp_add_streams_expr *) malloc(sizeof(struct sctp_add_streams_expr));
5684  rs->sas_assoc_id = (yyvsp[-9].expression);
5685  if (!is_valid_u16((yyvsp[-5].integer))) {
5686  semantic_error("sas_instrms out of range");
5687  }
5688  rs->sas_instrms = new_integer_expression((yyvsp[-5].integer), "%hu");
5689  if (!is_valid_u16((yyvsp[-1].integer))) {
5690  semantic_error("sas_outstrms out of range");
5691  }
5692  rs->sas_outstrms = new_integer_expression((yyvsp[-1].integer), "%hu");
5693  (yyval.expression)->setAddStreams(rs);
5694 }
5695 #line 5696 "parser.cc" /* yacc.c:1646 */
5696  break;
5697 
5698  case 355:
5699 #line 2303 "parser.y" /* yacc.c:1646 */
5700  {
5701  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_ADD_STREAMS);
5702  struct sctp_add_streams_expr *rs = (struct sctp_add_streams_expr *) malloc(sizeof(struct sctp_add_streams_expr));
5703  rs->sas_assoc_id = new PacketDrillExpression(EXPR_ELLIPSIS);
5704  if (!is_valid_u16((yyvsp[-5].integer))) {
5705  semantic_error("sas_instrms out of range");
5706  }
5707  rs->sas_instrms = new_integer_expression((yyvsp[-5].integer), "%hu");
5708  if (!is_valid_u16((yyvsp[-1].integer))) {
5709  semantic_error("sas_outstrms out of range");
5710  }
5711  rs->sas_outstrms = new_integer_expression((yyvsp[-1].integer), "%hu");
5712  (yyval.expression)->setAddStreams(rs);
5713 }
5714 #line 5715 "parser.cc" /* yacc.c:1646 */
5715  break;
5716 
5717  case 356:
5718 #line 2321 "parser.y" /* yacc.c:1646 */
5719  {
5720  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_ASSOCVAL);
5721  struct sctp_assoc_value_expr *assocval = (struct sctp_assoc_value_expr *) malloc(sizeof(struct sctp_assoc_value_expr));
5722  assocval->assoc_id = (yyvsp[-5].expression);
5723  assocval->assoc_value = (yyvsp[-1].expression);
5724  (yyval.expression)->setAssocval(assocval);
5725 }
5726 #line 5727 "parser.cc" /* yacc.c:1646 */
5727  break;
5728 
5729  case 357:
5730 #line 2328 "parser.y" /* yacc.c:1646 */
5731  {
5732  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_ASSOCVAL);
5733  struct sctp_assoc_value_expr *assocval = (struct sctp_assoc_value_expr *) malloc(sizeof(struct sctp_assoc_value_expr));
5734  assocval->assoc_id = new PacketDrillExpression(EXPR_ELLIPSIS);
5735  assocval->assoc_value = (yyvsp[-1].expression);
5736  (yyval.expression)->setAssocval(assocval);
5737 }
5738 #line 5739 "parser.cc" /* yacc.c:1646 */
5739  break;
5740 
5741  case 358:
5742 #line 2338 "parser.y" /* yacc.c:1646 */
5743  {
5744  if (!is_valid_u32((yyvsp[0].integer))) {
5745  semantic_error("sack_delay out of range");
5746  }
5747  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5748 }
5749 #line 5750 "parser.cc" /* yacc.c:1646 */
5750  break;
5751 
5752  case 359:
5753 #line 2344 "parser.y" /* yacc.c:1646 */
5754  {
5755  (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS);
5756 }
5757 #line 5758 "parser.cc" /* yacc.c:1646 */
5758  break;
5759 
5760  case 360:
5761 #line 2349 "parser.y" /* yacc.c:1646 */
5762  {
5763  if (!is_valid_u32((yyvsp[0].integer))) {
5764  semantic_error("sack_freq out of range");
5765  }
5766  (yyval.expression) = new_integer_expression((yyvsp[0].integer), "%u");
5767 }
5768 #line 5769 "parser.cc" /* yacc.c:1646 */
5769  break;
5770 
5771  case 361:
5772 #line 2355 "parser.y" /* yacc.c:1646 */
5773  { (yyval.expression) = new PacketDrillExpression(EXPR_ELLIPSIS); }
5774 #line 5775 "parser.cc" /* yacc.c:1646 */
5775  break;
5776 
5777  case 362:
5778 #line 2358 "parser.y" /* yacc.c:1646 */
5779  {
5780  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_SACKINFO);
5781  struct sctp_sack_info_expr *sackinfo = (struct sctp_sack_info_expr *) malloc(sizeof(struct sctp_sack_info_expr));
5782  sackinfo->sack_assoc_id = (yyvsp[-5].expression);
5783  sackinfo->sack_delay = (yyvsp[-3].expression);
5784  sackinfo->sack_freq = (yyvsp[-1].expression);
5785  (yyval.expression)->setSackinfo(sackinfo);
5786 }
5787 #line 5788 "parser.cc" /* yacc.c:1646 */
5788  break;
5789 
5790  case 363:
5791 #line 2366 "parser.y" /* yacc.c:1646 */
5792  {
5793  (yyval.expression) = new PacketDrillExpression(EXPR_SCTP_SACKINFO);
5794  struct sctp_sack_info_expr *sackinfo = (struct sctp_sack_info_expr *) malloc(sizeof(struct sctp_sack_info_expr));
5795  sackinfo->sack_assoc_id = new PacketDrillExpression(EXPR_ELLIPSIS);
5796  sackinfo->sack_delay = (yyvsp[-3].expression);
5797  sackinfo->sack_freq = (yyvsp[-1].expression);
5798  (yyval.expression)->setSackinfo(sackinfo);
5799 }
5800 #line 5801 "parser.cc" /* yacc.c:1646 */
5801  break;
5802 
5803  case 364:
5804 #line 2377 "parser.y" /* yacc.c:1646 */
5805  {
5806  (yyval.errno_info) = NULL;
5807 }
5808 #line 5809 "parser.cc" /* yacc.c:1646 */
5809  break;
5810 
5811  case 365:
5812 #line 2380 "parser.y" /* yacc.c:1646 */
5813  {
5814  (yyval.errno_info) = (struct errno_spec*)malloc(sizeof(struct errno_spec));
5815  (yyval.errno_info)->errno_macro = (yyvsp[-1].string);
5816  (yyval.errno_info)->strerror = (yyvsp[0].string);
5817 }
5818 #line 5819 "parser.cc" /* yacc.c:1646 */
5819  break;
5820 
5821  case 366:
5822 #line 2388 "parser.y" /* yacc.c:1646 */
5823  {
5824  (yyval.string) = NULL;
5825 }
5826 #line 5827 "parser.cc" /* yacc.c:1646 */
5827  break;
5828 
5829  case 367:
5830 #line 2391 "parser.y" /* yacc.c:1646 */
5831  {
5832  (yyval.string) = (yyvsp[0].string);
5833 }
5834 #line 5835 "parser.cc" /* yacc.c:1646 */
5835  break;
5836 
5837  case 368:
5838 #line 2397 "parser.y" /* yacc.c:1646 */
5839  {
5840  (yyval.string) = (yyvsp[-1].string);
5841 }
5842 #line 5843 "parser.cc" /* yacc.c:1646 */
5843  break;
5844 
5845  case 369:
5846 #line 2403 "parser.y" /* yacc.c:1646 */
5847  {
5848  (yyval.string) = (yyvsp[0].string);
5849 }
5850 #line 5851 "parser.cc" /* yacc.c:1646 */
5851  break;
5852 
5853  case 370:
5854 #line 2406 "parser.y" /* yacc.c:1646 */
5855  {
5856  asprintf(&((yyval.string)), "%s %s", (yyvsp[-1].string), (yyvsp[0].string));
5857  free((yyvsp[-1].string));
5858  free((yyvsp[0].string));
5859 }
5860 #line 5861 "parser.cc" /* yacc.c:1646 */
5861  break;
5862 
5863 
5864 #line 5865 "parser.cc" /* yacc.c:1646 */
5865  default: break;
5866  }
5867  /* User semantic actions sometimes alter yychar, and that requires
5868  that yytoken be updated with the new translation. We take the
5869  approach of translating immediately before every use of yytoken.
5870  One alternative is translating here after every semantic action,
5871  but that translation would be missed if the semantic action invokes
5872  YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
5873  if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
5874  incorrect destructor might then be invoked immediately. In the
5875  case of YYERROR or YYBACKUP, subsequent parser actions might lead
5876  to an incorrect destructor call or verbose syntax error message
5877  before the lookahead is translated. */
5878  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
5879 
5880  YYPOPSTACK (yylen);
5881  yylen = 0;
5882  YY_STACK_PRINT (yyss, yyssp);
5883 
5884  *++yyvsp = yyval;
5885  *++yylsp = yyloc;
5886 
5887  /* Now 'shift' the result of the reduction. Determine what state
5888  that goes to, based on the state we popped back to and the rule
5889  number reduced by. */
5890 
5891  yyn = yyr1[yyn];
5892 
5893  yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
5894  if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
5895  yystate = yytable[yystate];
5896  else
5897  yystate = yydefgoto[yyn - YYNTOKENS];
5898 
5899  goto yynewstate;
5900 
5901 
5902 /*--------------------------------------.
5903 | yyerrlab -- here on detecting error. |
5904 `--------------------------------------*/
5905 yyerrlab:
5906  /* Make sure we have latest lookahead translation. See comments at
5907  user semantic actions for why this is necessary. */
5908  yytoken = yychar == YYEMPTY ? YYEMPTY : YYTRANSLATE (yychar);
5909 
5910  /* If not already recovering from an error, report this error. */
5911  if (!yyerrstatus)
5912  {
5913  ++yynerrs;
5914 #if ! YYERROR_VERBOSE
5915  yyerror (YY_("syntax error"));
5916 #else
5917 # define YYSYNTAX_ERROR yysyntax_error (&yymsg_alloc, &yymsg, \
5918  yyssp, yytoken)
5919  {
5920  char const *yymsgp = YY_("syntax error");
5921  int yysyntax_error_status;
5922  yysyntax_error_status = YYSYNTAX_ERROR;
5923  if (yysyntax_error_status == 0)
5924  yymsgp = yymsg;
5925  else if (yysyntax_error_status == 1)
5926  {
5927  if (yymsg != yymsgbuf)
5928  YYSTACK_FREE (yymsg);
5929  yymsg = (char *) YYSTACK_ALLOC (yymsg_alloc);
5930  if (!yymsg)
5931  {
5932  yymsg = yymsgbuf;
5933  yymsg_alloc = sizeof yymsgbuf;
5934  yysyntax_error_status = 2;
5935  }
5936  else
5937  {
5938  yysyntax_error_status = YYSYNTAX_ERROR;
5939  yymsgp = yymsg;
5940  }
5941  }
5942  yyerror (yymsgp);
5943  if (yysyntax_error_status == 2)
5944  goto yyexhaustedlab;
5945  }
5946 # undef YYSYNTAX_ERROR
5947 #endif
5948  }
5949 
5950  yyerror_range[1] = yylloc;
5951 
5952  if (yyerrstatus == 3)
5953  {
5954  /* If just tried and failed to reuse lookahead token after an
5955  error, discard it. */
5956 
5957  if (yychar <= YYEOF)
5958  {
5959  /* Return failure if at end of input. */
5960  if (yychar == YYEOF)
5961  YYABORT;
5962  }
5963  else
5964  {
5965  yydestruct ("Error: discarding",
5966  yytoken, &yylval, &yylloc);
5967  yychar = YYEMPTY;
5968  }
5969  }
5970 
5971  /* Else will try to reuse lookahead token after shifting the error
5972  token. */
5973  goto yyerrlab1;
5974 
5975 
5976 /*---------------------------------------------------.
5977 | yyerrorlab -- error raised explicitly by YYERROR. |
5978 `---------------------------------------------------*/
5979 yyerrorlab:
5980 
5981  /* Pacify compilers like GCC when the user code never invokes
5982  YYERROR and the label yyerrorlab therefore never appears in user
5983  code. */
5984  if (/*CONSTCOND*/ 0)
5985  goto yyerrorlab;
5986 
5987  yyerror_range[1] = yylsp[1-yylen];
5988  /* Do not reclaim the symbols of the rule whose action triggered
5989  this YYERROR. */
5990  YYPOPSTACK (yylen);
5991  yylen = 0;
5992  YY_STACK_PRINT (yyss, yyssp);
5993  yystate = *yyssp;
5994  goto yyerrlab1;
5995 
5996 
5997 /*-------------------------------------------------------------.
5998 | yyerrlab1 -- common code for both syntax error and YYERROR. |
5999 `-------------------------------------------------------------*/
6000 yyerrlab1:
6001  yyerrstatus = 3; /* Each real token shifted decrements this. */
6002 
6003  for (;;)
6004  {
6005  yyn = yypact[yystate];
6006  if (!yypact_value_is_default (yyn))
6007  {
6008  yyn += YYTERROR;
6009  if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
6010  {
6011  yyn = yytable[yyn];
6012  if (0 < yyn)
6013  break;
6014  }
6015  }
6016 
6017  /* Pop the current state because it cannot handle the error token. */
6018  if (yyssp == yyss)
6019  YYABORT;
6020 
6021  yyerror_range[1] = *yylsp;
6022  yydestruct ("Error: popping",
6023  yystos[yystate], yyvsp, yylsp);
6024  YYPOPSTACK (1);
6025  yystate = *yyssp;
6026  YY_STACK_PRINT (yyss, yyssp);
6027  }
6028 
6029  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
6030  *++yyvsp = yylval;
6031  YY_IGNORE_MAYBE_UNINITIALIZED_END
6032 
6033  yyerror_range[2] = yylloc;
6034  /* Using YYLLOC is tempting, but would change the location of
6035  the lookahead. YYLOC is available though. */
6036  YYLLOC_DEFAULT (yyloc, yyerror_range, 2);
6037  *++yylsp = yyloc;
6038 
6039  /* Shift the error token. */
6040  YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
6041 
6042  yystate = yyn;
6043  goto yynewstate;
6044 
6045 
6046 /*-------------------------------------.
6047 | yyacceptlab -- YYACCEPT comes here. |
6048 `-------------------------------------*/
6049 yyacceptlab:
6050  yyresult = 0;
6051  goto yyreturn;
6052 
6053 /*-----------------------------------.
6054 | yyabortlab -- YYABORT comes here. |
6055 `-----------------------------------*/
6056 yyabortlab:
6057  yyresult = 1;
6058  goto yyreturn;
6059 
6060 #if !defined yyoverflow || YYERROR_VERBOSE
6061 /*-------------------------------------------------.
6062 | yyexhaustedlab -- memory exhaustion comes here. |
6063 `-------------------------------------------------*/
6064 yyexhaustedlab:
6065  yyerror (YY_("memory exhausted"));
6066  yyresult = 2;
6067  /* Fall through. */
6068 #endif
6069 
6070 yyreturn:
6071  if (yychar != YYEMPTY)
6072  {
6073  /* Make sure we have latest lookahead translation. See comments at
6074  user semantic actions for why this is necessary. */
6075  yytoken = YYTRANSLATE (yychar);
6076  yydestruct ("Cleanup: discarding lookahead",
6077  yytoken, &yylval, &yylloc);
6078  }
6079  /* Do not reclaim the symbols of the rule whose action triggered
6080  this YYABORT or YYACCEPT. */
6081  YYPOPSTACK (yylen);
6082  YY_STACK_PRINT (yyss, yyssp);
6083  while (yyssp != yyss)
6084  {
6085  yydestruct ("Cleanup: popping",
6086  yystos[*yyssp], yyvsp, yylsp);
6087  YYPOPSTACK (1);
6088  }
6089 #ifndef yyoverflow
6090  if (yyss != yyssa)
6091  YYSTACK_FREE (yyss);
6092 #endif
6093 #if YYERROR_VERBOSE
6094  if (yymsg != yymsgbuf)
6095  YYSTACK_FREE (yymsg);
6096 #endif
6097  return yyresult;
6098 }
sctp_paddrparams_expr::spp_assoc_id
PacketDrillExpression * spp_assoc_id
Definition: PacketDrillUtils.h:390
sctp_paddrparams_expr::spp_pathmaxrxt
PacketDrillExpression * spp_pathmaxrxt
Definition: PacketDrillUtils.h:393
SCTP_SHUTDOWN_COMPLETE_CHUNK_TYPE
#define SCTP_SHUTDOWN_COMPLETE_CHUNK_TYPE
Definition: PacketDrillUtils.h:82
PacketDrill::buildHeartbeatChunk
static PacketDrillSctpChunk * buildHeartbeatChunk(int64 flgs, PacketDrillSctpParameter *info)
Definition: PacketDrill.cc:882
SCTP_COOKIE_ACK_LENGTH
#define SCTP_COOKIE_ACK_LENGTH
Definition: SCTPAssociation.h:219
PacketDrillExpression
Definition: PacketDrillUtils.h:529
YYSTYPE::direction
enum direction_t direction
Definition: parser.h:204
SCTP_DATA_CHUNK_B_BIT
#define SCTP_DATA_CHUNK_B_BIT
Definition: PacketDrillUtils.h:88
YYSTYPE::stream_list
cQueue * stream_list
Definition: parser.h:230
SCTP_DATA_CHUNK_I_BIT
#define SCTP_DATA_CHUNK_I_BIT
Definition: PacketDrillUtils.h:86
inet::insert
void insert(std::vector< T > &v, int pos, const T &a)
Definition: stlutils.h:79
YYSTACK_FREE
#define YYSTACK_FREE
Definition: parser.cc:683
YYSTYPE::sctp_chunk
PacketDrillSctpChunk * sctp_chunk
Definition: parser.h:234
sctp_assocparams_expr::sasoc_assoc_id
PacketDrillExpression * sasoc_assoc_id
Definition: PacketDrillUtils.h:373
PacketDrill::buildSCTPPacket
static cPacket * buildSCTPPacket(int address_family, enum direction_t direction, cQueue *chunks)
Definition: PacketDrill.cc:247
SCTP_INIT_ACK_CHUNK_TYPE
#define SCTP_INIT_ACK_CHUNK_TYPE
Definition: PacketDrillUtils.h:72
YYSTYPE::errno_info
struct errno_spec * errno_info
Definition: parser.h:225
YYLLOC_DEFAULT
#define YYLLOC_DEFAULT(Current, Rhs, N)
Definition: parser.cc:1738
RELATIVE_RANGE_TIME
Definition: PacketDrillUtils.h:239
sctp_reset_streams_expr
Definition: PacketDrillUtils.h:413
PacketDrill::buildReconfigChunk
static PacketDrillSctpChunk * buildReconfigChunk(int64 flgs, cQueue *parameters)
Definition: PacketDrill.cc:937
HEARTBEAT_INFORMATION
Definition: parser.h:104
EXPR_SCTP_SACKINFO
Definition: PacketDrillUtils.h:258
PacketDrillPacket::setInetPacket
void setInetPacket(cPacket *pkt)
Definition: PacketDrillUtils.h:479
inet::sctp::INVALID_STREAM_IDENTIFIER
Definition: SCTPAssociation.h:189
ABSOLUTE_TIME
Definition: PacketDrillUtils.h:235
YYLAST
#define YYLAST
Definition: parser.cc:776
TCPOPT_NOP
#define TCPOPT_NOP
Definition: PacketDrillUtils.h:58
YYSTYPE::cause_item
PacketDrillStruct * cause_item
Definition: parser.h:218
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: parser.cc:1928
sctp_initmsg_expr
Definition: PacketDrillUtils.h:357
sctp_sndrcvinfo_expr::sinfo_assoc_id
PacketDrillExpression * sinfo_assoc_id
Definition: PacketDrillUtils.h:410
YYSTYPE::window
int32 window
Definition: parser.h:206
ABSOLUTE_RANGE_TIME
Definition: PacketDrillUtils.h:238
SCTP_ABORT_CHUNK_TYPE
#define SCTP_ABORT_CHUNK_TYPE
Definition: PacketDrillUtils.h:76
sctp_sack_info_expr::sack_freq
PacketDrillExpression * sack_freq
Definition: PacketDrillUtils.h:385
YYTERROR
#define YYTERROR
Definition: parser.cc:1729
SCTP_DATA_CHUNK_LENGTH
#define SCTP_DATA_CHUNK_LENGTH
Definition: SCTPAssociation.h:214
SCTP_ABORT_CHUNK_T_BIT
#define SCTP_ABORT_CHUNK_T_BIT
Definition: PacketDrillUtils.h:91
EXPR_ELLIPSIS
Definition: PacketDrillUtils.h:246
sctp_rtoinfo_expr
Definition: PacketDrillUtils.h:349
PacketDrill::buildUDPPacket
static cPacket * buildUDPPacket(int address_family, enum direction_t direction, uint16 udp_payload_bytes, char **error)
Definition: PacketDrill.cc:78
SCTP_SHUTDOWN_ACK_CHUNK_TYPE
#define SCTP_SHUTDOWN_ACK_CHUNK_TYPE
Definition: PacketDrillUtils.h:78
PacketDrill::buildInitAckChunk
static PacketDrillSctpChunk * buildInitAckChunk(int64 flgs, int64 tag, int64 a_rwnd, int64 os, int64 is, int64 tsn, cQueue *parameters)
Definition: PacketDrill.cc:609
protocol
uint8_t protocol
Definition: TCP_NSC.cc:88
sctp_reset_streams_expr::srs_number_streams
PacketDrillExpression * srs_number_streams
Definition: PacketDrillUtils.h:416
binary_expression::op
char * op
Definition: PacketDrillUtils.h:344
PacketDrillStruct
Definition: PacketDrillUtils.h:627
PacketDrill::buildShutdownChunk
static PacketDrillSctpChunk * buildShutdownChunk(int64 flgs, int64 cum_tsn)
Definition: PacketDrill.cc:803
PacketDrill::buildCookieEchoChunk
static PacketDrillSctpChunk * buildCookieEchoChunk(int64 flgs, int64 len, PacketDrillBytes *cookie)
Definition: PacketDrill.cc:772
EXPR_WORD
Definition: PacketDrillUtils.h:249
inet::sctp::SUPPORTED_EXTENSIONS
Definition: SCTPAssociation.h:170
sctp_sndrcvinfo_expr::sinfo_tsn
PacketDrillExpression * sinfo_tsn
Definition: PacketDrillUtils.h:408
TCPOLEN_MAXSEG
#define TCPOLEN_MAXSEG
Definition: PacketDrillUtils.h:60
YYSTYPE::tcp_sequence_info
struct YYSTYPE::@3 tcp_sequence_info
parse_and_finalize_config
void parse_and_finalize_config(struct invocation *invocation)
Definition: parser.cc:241
sctp_status_expr::sstat_penddata
PacketDrillExpression * sstat_penddata
Definition: PacketDrillUtils.h:426
sctp_status_expr::sstat_state
PacketDrillExpression * sstat_state
Definition: PacketDrillUtils.h:423
DIRECTION_OUTBOUND
Definition: PacketDrillUtils.h:186
YYSTYPE::byte
uint8 byte
Definition: parser.h:233
SCTP_SACK_CHUNK_TYPE
#define SCTP_SACK_CHUNK_TYPE
Definition: PacketDrillUtils.h:73
YYLTYPE
Definition: parser.h:247
YYEMPTY
#define YYEMPTY
Definition: parser.cc:1701
TCPOPT_EOL
#define TCPOPT_EOL
Definition: PacketDrillUtils.h:57
PacketDrillScript::addOption
void addOption(PacketDrillOption *opt)
Definition: PacketDrillUtils.h:624
YY_
#define YY_(Msgid)
Definition: parser.cc:585
PacketDrill::buildTCPPacket
static cPacket * buildTCPPacket(int address_family, enum direction_t direction, const char *flags, uint32 startSequence, uint16 tcpPayloadBytes, uint32 ackSequence, int32 window, cQueue *tcpOptions, char **error)
Definition: PacketDrill.cc:175
YYINITDEPTH
#define YYINITDEPTH
Definition: parser.cc:1934
PacketDrillPacket::getDirection
enum direction_t getDirection() const
Definition: PacketDrillUtils.h:476
EXPR_SCTP_ASSOCPARAMS
Definition: PacketDrillUtils.h:263
PacketDrillPacket::setDirection
void setDirection(enum direction_t dir)
Definition: PacketDrillUtils.h:477
sctp_assoc_value_expr::assoc_id
PacketDrillExpression * assoc_id
Definition: PacketDrillUtils.h:367
YY_IGNORE_MAYBE_UNINITIALIZED_END
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: parser.cc:636
yytype_int16
short int yytype_int16
Definition: parser.cc:559
sctp_sndrcvinfo_expr::sinfo_context
PacketDrillExpression * sinfo_context
Definition: PacketDrillUtils.h:406
SCTP_RECONFIG_CHUNK_TYPE
#define SCTP_RECONFIG_CHUNK_TYPE
Definition: PacketDrillUtils.h:84
EXPR_SCTP_SNDRCVINFO
Definition: PacketDrillUtils.h:260
inet::sctp::STREAM_RESET_RESPONSE_PARAMETER
Definition: SCTPAssociation.h:159
YYSTYPE::byte_list
PacketDrillBytes * byte_list
Definition: parser.h:232
PacketDrill::buildAbortChunk
static PacketDrillSctpChunk * buildAbortChunk(int64 flgs)
Definition: PacketDrill.cc:847
sctp_reset_streams_expr::srs_flags
PacketDrillExpression * srs_flags
Definition: PacketDrillUtils.h:415
YYDPRINTF
#define YYDPRINTF(Args)
Definition: parser.cc:1925
YYSTYPE
Definition: parser.h:195
syscall_spec
Definition: PacketDrillUtils.h:302
PACKET_EVENT
Definition: PacketDrillUtils.h:227
yylval
YYSTYPE yylval
Definition: parser.cc:2196
YYSTYPE::sequence_number
uint32 sequence_number
Definition: parser.h:207
inet::L3Address
This class provides the generic interface for network addresses.
Definition: L3Address.h:41
EXPR_SCTP_ASSOCVAL
Definition: PacketDrillUtils.h:257
PacketDrillOption
Definition: PacketDrillUtils.h:651
EXPR_SCTP_PEER_ADDR_PARAMS
Definition: PacketDrillUtils.h:259
sctp_reset_streams_expr::srs_stream_list
PacketDrillExpression * srs_stream_list
Definition: PacketDrillUtils.h:417
sctp_assoc_value_expr
Definition: PacketDrillUtils.h:366
yylloc
YYLTYPE yylloc
Definition: parser.cc:2200
malloc
void * malloc(YYSIZE_T)
PacketDrill::buildShutdownAckChunk
static PacketDrillSctpChunk * buildShutdownAckChunk(int64 flgs)
Definition: PacketDrill.cc:822
sctp_add_streams_expr::sas_assoc_id
PacketDrillExpression * sas_assoc_id
Definition: PacketDrillUtils.h:435
YYSTYPE::string
char * string
Definition: parser.h:201
EXPR_SCTP_STATUS
Definition: PacketDrillUtils.h:262
TCPOPT_SACK_PERMITTED
#define TCPOPT_SACK_PERMITTED
Definition: PacketDrillUtils.h:63
PacketDrillScript::addEvent
void addEvent(PacketDrillEvent *evt)
Definition: PacketDrillUtils.h:623
PacketDrill::buildErrorChunk
static PacketDrillSctpChunk * buildErrorChunk(int64 flgs, cQueue *causes)
Definition: PacketDrill.cc:862
STATE_COOKIE
Definition: parser.h:107
sctp_sndrcvinfo_expr::sinfo_ppid
PacketDrillExpression * sinfo_ppid
Definition: PacketDrillUtils.h:405
YYSTYPE::sack_block
PacketDrillStruct * sack_block
Definition: parser.h:217
YYSTYPE::sctp_parameter
PacketDrillSctpParameter * sctp_parameter
Definition: parser.h:222
PacketDrillEvent
Definition: PacketDrillUtils.h:482
sctp_add_streams_expr::sas_outstrms
PacketDrillExpression * sas_outstrms
Definition: PacketDrillUtils.h:437
YYABORT
#define YYABORT
Definition: parser.cc:1705
SCTP_DATA_CHUNK_E_BIT
#define SCTP_DATA_CHUNK_E_BIT
Definition: PacketDrillUtils.h:89
YYSTYPE::sack_block_list
cQueue * sack_block_list
Definition: parser.h:229
yytable_value_is_error
#define yytable_value_is_error(Yytable_value)
Definition: parser.cc:1005
binary_expression
Definition: PacketDrillUtils.h:343
yylex
int yylex(void)
inet::units::constants::c
const value< double, compose< units::m, pow< units::s,-1 > > > c(299792458)
NO_TIME_RANGE
#define NO_TIME_RANGE
Definition: PacketDrillUtils.h:197
yychar
int yychar
Definition: parser.cc:2193
PacketDrill::buildDataChunk
static PacketDrillSctpChunk * buildDataChunk(int64 flgs, int64 len, int64 tsn, int64 sid, int64 ssn, int64 ppid)
Definition: PacketDrill.cc:453
sctp_paddrparams_expr::spp_hbinterval
PacketDrillExpression * spp_hbinterval
Definition: PacketDrillUtils.h:392
yyalloc::yyss_alloc
yytype_int16 yyss_alloc
Definition: parser.cc:719
PacketDrillConfig::getWireProtocol
int getWireProtocol() const
Definition: PacketDrillUtils.h:458
YYMAXDEPTH
#define YYMAXDEPTH
Definition: parser.cc:1945
YYSTYPE::packet
PacketDrillPacket * packet
Definition: parser.h:214
EXPR_SCTP_ADD_STREAMS
Definition: PacketDrillUtils.h:264
inet::sctp::OUTGOING_RESET_REQUEST_PARAMETER
Definition: SCTPAssociation.h:156
sctp_sndrcvinfo_expr::sinfo_timetolive
PacketDrillExpression * sinfo_timetolive
Definition: PacketDrillUtils.h:407
sctp_paddrparams_expr::spp_flags
PacketDrillExpression * spp_flags
Definition: PacketDrillUtils.h:395
TCPOPT_MAXSEG
#define TCPOPT_MAXSEG
Definition: PacketDrillUtils.h:59
SCTP_INIT_CHUNK_TYPE
#define SCTP_INIT_CHUNK_TYPE
Definition: PacketDrillUtils.h:71
yyalloc::yyvs_alloc
YYSTYPE yyvs_alloc
Definition: parser.cc:720
sctp_initmsg_expr::sinit_max_instreams
PacketDrillExpression * sinit_max_instreams
Definition: PacketDrillUtils.h:359
sctp_paddrparams_expr::spp_ipv6_flowlabel
PacketDrillExpression * spp_ipv6_flowlabel
Definition: PacketDrillUtils.h:396
SCTP_DATA_CHUNK_U_BIT
#define SCTP_DATA_CHUNK_U_BIT
Definition: PacketDrillUtils.h:87
PacketDrill::buildCookieAckChunk
static PacketDrillSctpChunk * buildCookieAckChunk(int64 flgs)
Definition: PacketDrill.cc:794
sctp_assocparams_expr
Definition: PacketDrillUtils.h:372
sctp_status_expr::sstat_fragmentation_point
PacketDrillExpression * sstat_fragmentation_point
Definition: PacketDrillUtils.h:429
inet::uint64
uint64_t uint64
Definition: Compat.h:28
sctp_sndrcvinfo_expr
Definition: PacketDrillUtils.h:401
YYFINAL
#define YYFINAL
Definition: parser.cc:774
sctp_add_streams_expr
Definition: PacketDrillUtils.h:434
YYEOF
#define YYEOF
Definition: parser.cc:1702
YYSTYPE::expression_list
cQueue * expression_list
Definition: parser.h:220
PacketDrillSctpParameter
Definition: PacketDrillUtils.h:731
sctp_status_expr::sstat_unackdata
PacketDrillExpression * sstat_unackdata
Definition: PacketDrillUtils.h:425
YYSTACK_RELOCATE
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: parser.cc:740
sctp_assocparams_expr::sasoc_local_rwnd
PacketDrillExpression * sasoc_local_rwnd
Definition: PacketDrillUtils.h:377
command_spec
Definition: PacketDrillUtils.h:312
sctp_status_expr::sstat_rwnd
PacketDrillExpression * sstat_rwnd
Definition: PacketDrillUtils.h:424
sctp_assocparams_expr::sasoc_number_peer_destinations
PacketDrillExpression * sasoc_number_peer_destinations
Definition: PacketDrillUtils.h:375
YYSTYPE::command
struct command_spec * command
Definition: parser.h:216
DIRECTION_INBOUND
Definition: PacketDrillUtils.h:185
sctp_rtoinfo_expr::srto_assoc_id
PacketDrillExpression * srto_assoc_id
Definition: PacketDrillUtils.h:350
sctp_sndrcvinfo_expr::sinfo_flags
PacketDrillExpression * sinfo_flags
Definition: PacketDrillUtils.h:404
SCTP_PAD_CHUNK_TYPE
#define SCTP_PAD_CHUNK_TYPE
Definition: PacketDrillUtils.h:83
sctp_paddrparams_expr
Definition: PacketDrillUtils.h:389
inet::sctp::INCOMING_RESET_REQUEST_PARAMETER
Definition: SCTPAssociation.h:157
sctp_assocparams_expr::sasoc_cookie_life
PacketDrillExpression * sasoc_cookie_life
Definition: PacketDrillUtils.h:378
direction_t
direction_t
Definition: PacketDrillUtils.h:183
PacketDrill::buildInitChunk
static PacketDrillSctpChunk * buildInitChunk(int64 flgs, int64 tag, int64 a_rwnd, int64 os, int64 is, int64 tsn, cQueue *parameters)
Definition: PacketDrill.cc:523
SYSCALL_EVENT
Definition: PacketDrillUtils.h:228
yytext
char * yytext
inet::uint32
uint32_t uint32
Definition: Compat.h:30
SCTP_COOKIE_ACK_CHUNK_TYPE
#define SCTP_COOKIE_ACK_CHUNK_TYPE
Definition: PacketDrillUtils.h:81
inet::sctp::SUPPORTED_ADDRESS_TYPES
Definition: SCTPAssociation.h:181
TCPOLEN_SACK_PERMITTED
#define TCPOLEN_SACK_PERMITTED
Definition: PacketDrillUtils.h:64
sctp_rtoinfo_expr::srto_max
PacketDrillExpression * srto_max
Definition: PacketDrillUtils.h:352
sctp_initmsg_expr::sinit_max_init_timeo
PacketDrillExpression * sinit_max_init_timeo
Definition: PacketDrillUtils.h:361
PacketDrill::buildSackChunk
static PacketDrillSctpChunk * buildSackChunk(int64 flgs, int64 cum_tsn, int64 a_rwnd, cQueue *gaps, cQueue *dups)
Definition: PacketDrill.cc:701
yyalloc
Definition: parser.cc:717
PacketDrillPacket
Definition: PacketDrillUtils.h:465
sctp_assocparams_expr::sasoc_asocmaxrxt
PacketDrillExpression * sasoc_asocmaxrxt
Definition: PacketDrillUtils.h:374
EXPR_SCTP_RESET_STREAMS
Definition: PacketDrillUtils.h:261
YYSTYPE::syscall
struct syscall_spec * syscall
Definition: parser.h:215
SCTP_IPV4_ADDRESS_PARAMETER_TYPE
#define SCTP_IPV4_ADDRESS_PARAMETER_TYPE
Definition: PacketDrillUtils.h:170
sctp_sndrcvinfo_expr::sinfo_stream
PacketDrillExpression * sinfo_stream
Definition: PacketDrillUtils.h:402
YYSTYPE::tcp_options
cQueue * tcp_options
Definition: parser.h:224
YYSTYPE::sctp_chunk_list
cQueue * sctp_chunk_list
Definition: parser.h:226
sctp_sndrcvinfo_expr::sinfo_ssn
PacketDrillExpression * sinfo_ssn
Definition: PacketDrillUtils.h:403
inet::sctp::SSN_TSN_RESET_REQUEST_PARAMETER
Definition: SCTPAssociation.h:158
TCPOLEN_WINDOW
#define TCPOLEN_WINDOW
Definition: PacketDrillUtils.h:62
sctp_status_expr::sstat_assoc_id
PacketDrillExpression * sstat_assoc_id
Definition: PacketDrillUtils.h:422
PacketDrill::buildShutdownCompleteChunk
static PacketDrillSctpChunk * buildShutdownCompleteChunk(int64 flgs)
Definition: PacketDrill.cc:831
sctp_status_expr::sstat_outstrms
PacketDrillExpression * sstat_outstrms
Definition: PacketDrillUtils.h:428
sctp_paddrparams_expr::spp_dscp
PacketDrillExpression * spp_dscp
Definition: PacketDrillUtils.h:397
INVALID_EVENT
Definition: PacketDrillUtils.h:226
yynerrs
int yynerrs
Definition: parser.cc:2204
YYSTYPE::cause_list
cQueue * cause_list
Definition: parser.h:231
sctp_sack_info_expr::sack_delay
PacketDrillExpression * sack_delay
Definition: PacketDrillUtils.h:384
RELATIVE_TIME
Definition: PacketDrillUtils.h:236
EXPR_BINARY
Definition: PacketDrillUtils.h:253
COMMAND_EVENT
Definition: PacketDrillUtils.h:229
binary_expression::lhs
PacketDrillExpression * lhs
Definition: PacketDrillUtils.h:345
sctp_rtoinfo_expr::srto_min
PacketDrillExpression * srto_min
Definition: PacketDrillUtils.h:353
invocation
Definition: PacketDrillUtils.h:337
YYPOPSTACK
#define YYPOPSTACK(N)
TCPOLEN_TIMESTAMP
#define TCPOLEN_TIMESTAMP
Definition: PacketDrillUtils.h:67
errno_spec
Definition: PacketDrillUtils.h:201
yyalloc::yyls_alloc
YYLTYPE yyls_alloc
Definition: parser.cc:721
SCTP_HEARTBEAT_ACK_CHUNK_TYPE
#define SCTP_HEARTBEAT_ACK_CHUNK_TYPE
Definition: PacketDrillUtils.h:75
free
void free(void *)
sctp_sack_info_expr
Definition: PacketDrillUtils.h:382
YYSTYPE::option
PacketDrillOption * option
Definition: parser.h:223
YYSTYPE::event
PacketDrillEvent * event
Definition: parser.h:213
YYSTYPE::expression
PacketDrillExpression * expression
Definition: parser.h:219
EXPR_SOCKET_ADDRESS_IPV4
Definition: PacketDrillUtils.h:251
YYSIZE_T
#define YYSIZE_T
Definition: parser.cc:569
sctp_initmsg_expr::sinit_max_attempts
PacketDrillExpression * sinit_max_attempts
Definition: PacketDrillUtils.h:360
sctp_initmsg_expr::sinit_num_ostreams
PacketDrillExpression * sinit_num_ostreams
Definition: PacketDrillUtils.h:358
sctp_status_expr::sstat_primary
PacketDrillExpression * sstat_primary
Definition: PacketDrillUtils.h:430
YYSTYPE::time_usecs
int64 time_usecs
Definition: parser.h:203
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Type, Value, Location)
Definition: parser.cc:1926
EXPR_SCTP_RTOINFO
Definition: PacketDrillUtils.h:255
sctp_status_expr::sstat_instrms
PacketDrillExpression * sstat_instrms
Definition: PacketDrillUtils.h:427
sctp_reset_streams_expr::srs_assoc_id
PacketDrillExpression * srs_assoc_id
Definition: PacketDrillUtils.h:414
SCTP_SHUTDOWN_COMPLETE_CHUNK_T_BIT
#define SCTP_SHUTDOWN_COMPLETE_CHUNK_T_BIT
Definition: PacketDrillUtils.h:92
YYNTOKENS
#define YYNTOKENS
Definition: parser.cc:779
yylineno
int yylineno
sctp_sack_info_expr::sack_assoc_id
PacketDrillExpression * sack_assoc_id
Definition: PacketDrillUtils.h:383
sctp_add_streams_expr::sas_instrms
PacketDrillExpression * sas_instrms
Definition: PacketDrillUtils.h:436
YYACCEPT
#define YYACCEPT
Definition: parser.cc:1704
SCTP_COOKIE_ECHO_CHUNK_TYPE
#define SCTP_COOKIE_ECHO_CHUNK_TYPE
Definition: PacketDrillUtils.h:80
SCTP_ERROR_CHUNK_TYPE
#define SCTP_ERROR_CHUNK_TYPE
Definition: PacketDrillUtils.h:79
SCTP_SHUTDOWN_CHUNK_TYPE
#define SCTP_SHUTDOWN_CHUNK_TYPE
Definition: PacketDrillUtils.h:77
EXPR_SOCKET_ADDRESS_IPV6
Definition: PacketDrillUtils.h:252
PacketDrill::buildHeartbeatAckChunk
static PacketDrillSctpChunk * buildHeartbeatAckChunk(int64 flgs, PacketDrillSctpParameter *info)
Definition: PacketDrill.cc:919
sctp_paddrparams_expr::spp_address
PacketDrillExpression * spp_address
Definition: PacketDrillUtils.h:391
TCPOPT_WINDOW
#define TCPOPT_WINDOW
Definition: PacketDrillUtils.h:61
sctp_assocparams_expr::sasoc_peer_rwnd
PacketDrillExpression * sasoc_peer_rwnd
Definition: PacketDrillUtils.h:376
inet::int64
int64_t int64
Definition: Compat.h:29
YYSTYPE::integer
int64 integer
Definition: parser.h:199
EXPR_LIST
Definition: PacketDrillUtils.h:254
sctp_sndrcvinfo_expr::sinfo_cumtsn
PacketDrillExpression * sinfo_cumtsn
Definition: PacketDrillUtils.h:409
inet::IPv6Address
Stores a 128-bit IPv6 address in an efficient way.
Definition: IPv6Address.h:39
TCPOPT_SACK
#define TCPOPT_SACK
Definition: PacketDrillUtils.h:65
inet::IPv4Address
IPv4 address.
Definition: IPv4Address.h:45
sctp_status_expr
Definition: PacketDrillUtils.h:421
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: parser.cc:792
sctp_rtoinfo_expr::srto_initial
PacketDrillExpression * srto_initial
Definition: PacketDrillUtils.h:351
sctp_assoc_value_expr::assoc_value
PacketDrillExpression * assoc_value
Definition: PacketDrillUtils.h:368
EXPR_STRING
Definition: PacketDrillUtils.h:250
binary_expression::rhs
PacketDrillExpression * rhs
Definition: PacketDrillUtils.h:346
SCTP_DATA_CHUNK_TYPE
#define SCTP_DATA_CHUNK_TYPE
Definition: PacketDrillUtils.h:70
sctp_paddrparams_expr::spp_pathmtu
PacketDrillExpression * spp_pathmtu
Definition: PacketDrillUtils.h:394
yypact_value_is_default
#define yypact_value_is_default(Yystate)
Definition: parser.cc:1000
TCPOPT_TIMESTAMP
#define TCPOPT_TIMESTAMP
Definition: PacketDrillUtils.h:66
PacketDrillBytes
Definition: PacketDrillUtils.h:666
YYSTACK_BYTES
#define YYSTACK_BYTES(N)
Definition: parser.cc:729
SCTP_IPV6_ADDRESS_PARAMETER_TYPE
#define SCTP_IPV6_ADDRESS_PARAMETER_TYPE
Definition: PacketDrillUtils.h:171
PacketDrillTcpOption
Definition: PacketDrillUtils.h:681
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: parser.cc:682
YYSTYPE::tcp_option
PacketDrillTcpOption * tcp_option
Definition: parser.h:221
EXPR_SCTP_INITMSG
Definition: PacketDrillUtils.h:256
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: parser.cc:635
ANY_TIME
Definition: PacketDrillUtils.h:237
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: parser.cc:1927
SCTP_HEARTBEAT_CHUNK_TYPE
#define SCTP_HEARTBEAT_CHUNK_TYPE
Definition: PacketDrillUtils.h:74
int yywrap ( void  )
197 {
198  return 1;
199 }

Variable Documentation

struct invocation* invocation
int yychar

Referenced by yyparse().

FILE* yyin

Referenced by parse_script().

int yylineno

Referenced by parse_and_finalize_config(), parse_script(), and yyparse().

YYLTYPE yylloc = { 1, 1, 1, 1 }

Referenced by yyparse().

YYSTYPE yylval

Referenced by if(), and yyparse().

int yynerrs

Referenced by yyparse().

char* yytext

Referenced by parse_and_finalize_config(), and yyparse().