2
/* A Bison parser, made from adsedgelabelevaluation.y
3
by GNU Bison version 1.28 */
5
#define YYBISON 1 /* Identify Bison output. */
7
#define yyparse adsedgelabelevaluationparse
8
#define yylex adsedgelabelevaluationlex
9
#define yyerror adsedgelabelevaluationerror
10
#define yylval adsedgelabelevaluationlval
11
#define yychar adsedgelabelevaluationchar
12
#define yydebug adsedgelabelevaluationdebug
13
#define yynerrs adsedgelabelevaluationnerrs
21
#define IDENTIFIER 264
39
#line 1 "adsedgelabelevaluation.y"
41
#include "adsedgelabelevaluationparse.h"
47
#define YYERROR_VERBOSE
49
int proptype[200]; /* should be initialised by caller */
50
char *propname[200];/* should be initialised by caller */
51
int boollist[200];/* should be initialised by caller */
52
int count;/* should be initialised by caller */
53
int isin; /* true if IN predicate is part of label */
55
int outcome; /* result */
58
int isintexp,isstrexp;
62
int GetBool(char *s, int t){
65
if ((!strcmp(propname[i],s))&& (proptype[i]==t)) return boollist[i];
73
#line 34 "adsedgelabelevaluation.y"
96
#define YYTRANSLATE(x) ((unsigned)(x) <= 280 ? yytranslate[x] : 42)
98
static const char yytranslate[] = { 0,
99
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
100
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
101
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
102
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
103
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
104
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
105
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
106
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
107
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
108
2, 2, 2, 27, 2, 2, 2, 2, 2, 2,
109
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
110
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
111
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
112
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
113
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
114
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
115
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
116
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
117
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
118
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
119
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
120
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
121
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
122
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
123
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
124
2, 2, 2, 2, 2, 1, 3, 4, 5, 6,
125
7, 8, 9, 10, 11, 12, 13, 14, 15, 16,
126
17, 18, 19, 20, 21, 22, 23, 24, 25, 26
130
static const short yyprhs[] = { 0,
131
0, 2, 6, 7, 9, 10, 14, 16, 18, 22,
132
24, 28, 30, 33, 37, 42, 44, 45, 49, 50,
133
53, 56, 58, 60, 62, 64, 66, 68, 70, 72,
137
static const short yyrhs[] = { 29,
138
0, 30, 31, 41, 0, 0, 10, 0, 0, 6,
139
32, 7, 0, 33, 0, 34, 0, 33, 20, 34,
140
0, 35, 0, 34, 23, 35, 0, 36, 0, 25,
141
35, 0, 4, 32, 5, 0, 26, 4, 10, 5,
142
0, 11, 0, 0, 10, 37, 38, 0, 0, 39,
143
9, 0, 40, 3, 0, 14, 0, 15, 0, 16,
144
0, 17, 0, 13, 0, 12, 0, 14, 0, 15,
151
static const short yyrline[] = { 0,
152
49, 52, 58, 59, 71, 72, 76, 87, 88, 96,
153
97, 105, 106, 107, 108, 111, 112, 116, 142, 143,
154
145, 149, 150, 151, 152, 153, 154, 159, 160, 166,
160
#if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
162
static const char * const yytname[] = { "$","error","$undefined.","QUOTE",
163
"OPEN","CLOSE","OPENB","CLOSEB","NL","INTEGER","IDENTIFIER","TRUE","LEQ","GEQ",
164
"EQ","NEQ","GT","LT","MINUS","PLUS","OR","TIMES","DIV","AND","NEG","NOT","IN",
165
"'^'","input","line","event","guard","pexp","orexp","andexp","literal","atomic",
166
"@1","isexp","irel","srel","action", NULL
170
static const short yyr1[] = { 0,
171
28, 29, 30, 30, 31, 31, 32, 33, 33, 34,
172
34, 35, 35, 35, 35, 36, 37, 36, 38, 38,
173
38, 39, 39, 39, 39, 39, 39, 40, 40, 41,
177
static const short yyr2[] = { 0,
178
1, 3, 0, 1, 0, 3, 1, 1, 3, 1,
179
3, 1, 2, 3, 4, 1, 0, 3, 0, 2,
180
2, 1, 1, 1, 1, 1, 1, 1, 1, 0,
184
static const short yydefact[] = { 3,
185
4, 1, 5, 0, 30, 0, 17, 16, 0, 0,
186
0, 7, 8, 10, 12, 0, 2, 0, 19, 13,
187
0, 6, 0, 0, 31, 14, 27, 26, 22, 23,
188
24, 25, 18, 0, 0, 0, 9, 11, 20, 21,
192
static const short yydefgoto[] = { 42,
193
2, 3, 5, 11, 12, 13, 14, 15, 19, 33,
197
static const short yypact[] = { -7,
198
-32768,-32768, -2, -4, -20, -4,-32768,-32768, -4, 1,
199
8, -12, -6,-32768,-32768, 9,-32768, 13, -3,-32768,
200
10,-32768, -4, -4,-32768,-32768,-32768,-32768, 20, 21,
201
-32768,-32768,-32768, 16, 23, 22, -6,-32768,-32768,-32768,
202
-32768, 28, 29,-32768
205
static const short yypgoto[] = {-32768,
206
-32768,-32768,-32768, 24,-32768, 11, -8,-32768,-32768,-32768,
214
static const short yytable[] = { 6,
215
20, 16, 1, 4, 21, 7, 8, 23, 27, 28,
216
29, 30, 31, 32, 22, 38, 24, 26, 25, 36,
217
9, 10, -28, -29, 39, 40, 41, 43, 44, 18,
221
static const short yycheck[] = { 4,
222
9, 22, 10, 6, 4, 10, 11, 20, 12, 13,
223
14, 15, 16, 17, 7, 24, 23, 5, 10, 10,
224
25, 26, 3, 3, 9, 3, 5, 0, 0, 6,
227
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
228
#line 3 "/usr/lib/bison.simple"
229
/* This file comes from bison-1.28. */
231
/* Skeleton output parser for bison,
232
Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
234
This program is free software; you can redistribute it and/or modify
235
it under the terms of the GNU General Public License as published by
236
the Free Software Foundation; either version 2, or (at your option)
239
This program is distributed in the hope that it will be useful,
240
but WITHOUT ANY WARRANTY; without even the implied warranty of
241
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
242
GNU General Public License for more details.
244
You should have received a copy of the GNU General Public License
245
along with this program; if not, write to the Free Software
246
Foundation, Inc., 59 Temple Place - Suite 330,
247
Boston, MA 02111-1307, USA. */
249
/* As a special exception, when this file is copied by Bison into a
250
Bison output file, you may use that output file without restriction.
251
This special exception was added by the Free Software Foundation
252
in version 1.24 of Bison. */
254
/* This is the parser code that is written into each bison parser
255
when the %semantic_parser declaration is not specified in the grammar.
256
It was written by Richard Stallman by simplifying the hairy parser
257
used when %semantic_parser is specified. */
259
#ifndef YYSTACK_USE_ALLOCA
261
#define YYSTACK_USE_ALLOCA
262
#else /* alloca not defined */
264
#define YYSTACK_USE_ALLOCA
265
#define alloca __builtin_alloca
266
#else /* not GNU C. */
267
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))
268
#define YYSTACK_USE_ALLOCA
270
#else /* not sparc */
271
/* We think this test detects Watcom and Microsoft C. */
272
/* This used to test MSDOS, but that is a bad idea
273
since that symbol is in the user namespace. */
274
#if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)
275
#if 0 /* No need for malloc.h, which pollutes the namespace;
276
instead, just don't use alloca. */
279
#else /* not MSDOS, or __TURBOC__ */
281
/* I don't know what this was needed for, but it pollutes the namespace.
282
So I turned it off. rms, 2 May 1997. */
283
/* #include <malloc.h> */
285
#define YYSTACK_USE_ALLOCA
286
#else /* not MSDOS, or __TURBOC__, or _AIX */
288
#ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,
289
and on HPUX 10. Eventually we can turn this on. */
290
#define YYSTACK_USE_ALLOCA
291
#define alloca __builtin_alloca
294
#endif /* not _AIX */
295
#endif /* not MSDOS, or __TURBOC__ */
296
#endif /* not sparc */
297
#endif /* not GNU C */
298
#endif /* alloca not defined */
299
#endif /* YYSTACK_USE_ALLOCA not defined */
301
#ifdef YYSTACK_USE_ALLOCA
302
#define YYSTACK_ALLOC alloca
304
#define YYSTACK_ALLOC malloc
307
/* Note: there must be only one dollar sign in this file.
308
It is replaced by the list of actions, each action
309
as one case of the switch. */
311
#define yyerrok (yyerrstatus = 0)
312
#define yyclearin (yychar = YYEMPTY)
315
#define YYACCEPT goto yyacceptlab
316
#define YYABORT goto yyabortlab
317
#define YYERROR goto yyerrlab1
318
/* Like YYERROR except do call yyerror.
319
This remains here temporarily to ease the
320
transition to the new meaning of YYERROR, for GCC.
321
Once GCC version 2 has supplanted version 1, this can go. */
322
#define YYFAIL goto yyerrlab
323
#define YYRECOVERING() (!!yyerrstatus)
324
#define YYBACKUP(token, value) \
326
if (yychar == YYEMPTY && yylen == 1) \
327
{ yychar = (token), yylval = (value); \
328
yychar1 = YYTRANSLATE (yychar); \
333
{ yyerror ("syntax error: cannot back up"); YYERROR; } \
337
#define YYERRCODE 256
340
#define YYLEX yylex()
346
#define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
348
#define YYLEX yylex(&yylval, &yylloc)
350
#else /* not YYLSP_NEEDED */
352
#define YYLEX yylex(&yylval, YYLEX_PARAM)
354
#define YYLEX yylex(&yylval)
356
#endif /* not YYLSP_NEEDED */
359
/* If nonreentrant, generate the variables here */
363
int yychar; /* the lookahead symbol */
364
YYSTYPE yylval; /* the semantic value of the */
365
/* lookahead symbol */
368
YYLTYPE yylloc; /* location data for the lookahead */
372
int yynerrs; /* number of parse errors so far */
373
#endif /* not YYPURE */
376
int yydebug; /* nonzero means print parse trace */
377
/* Since this is uninitialized, it does not stop multiple parsers
381
/* YYINITDEPTH indicates the initial size of the parser's stacks */
384
#define YYINITDEPTH 200
387
/* YYMAXDEPTH is the maximum size the stacks can grow to
388
(effective only if the built-in stack extension method is used). */
395
#define YYMAXDEPTH 10000
398
/* Define __yy_memcpy. Note that the size argument
399
should be passed with type unsigned int, because that is what the non-GCC
400
definitions require. With GCC, __builtin_memcpy takes an arg
401
of type size_t, but it can handle unsigned int. */
403
#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
404
#define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
405
#else /* not GNU C or C++ */
408
/* This is the most reliable way to avoid incompatibilities
409
in available built-in functions on various systems. */
411
__yy_memcpy (to, from, count)
416
register char *f = from;
417
register char *t = to;
418
register int i = count;
424
#else /* __cplusplus */
426
/* This is the most reliable way to avoid incompatibilities
427
in available built-in functions on various systems. */
429
__yy_memcpy (char *to, char *from, unsigned int count)
431
register char *t = to;
432
register char *f = from;
433
register int i = count;
442
#line 217 "/usr/lib/bison.simple"
444
/* The user can define YYPARSE_PARAM as the name of an argument to be passed
445
into yyparse. The argument should have type void *.
446
It should actually point to an object.
447
Grammar actions can access the variable by casting it
448
to the proper pointer type. */
452
#define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
453
#define YYPARSE_PARAM_DECL
454
#else /* not __cplusplus */
455
#define YYPARSE_PARAM_ARG YYPARSE_PARAM
456
#define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
457
#endif /* not __cplusplus */
458
#else /* not YYPARSE_PARAM */
459
#define YYPARSE_PARAM_ARG
460
#define YYPARSE_PARAM_DECL
461
#endif /* not YYPARSE_PARAM */
463
/* Prevent warning if -Wstrict-prototypes. */
466
int yyparse (void *);
473
yyparse(YYPARSE_PARAM_ARG)
476
register int yystate;
478
register short *yyssp;
479
register YYSTYPE *yyvsp;
480
int yyerrstatus; /* number of tokens to shift before error messages enabled */
481
int yychar1 = 0; /* lookahead token as an internal (translated) token number */
483
short yyssa[YYINITDEPTH]; /* the state stack */
484
YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
486
short *yyss = yyssa; /* refer to the stacks thru separate pointers */
487
YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
490
YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
491
YYLTYPE *yyls = yylsa;
494
#define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
496
#define YYPOPSTACK (yyvsp--, yyssp--)
499
int yystacksize = YYINITDEPTH;
500
int yyfree_stacks = 0;
511
YYSTYPE yyval; /* the variable used to return */
512
/* semantic values from the action */
519
fprintf(stderr, "Starting parse\n");
525
yychar = YYEMPTY; /* Cause a token to be read. */
527
/* Initialize stack pointers.
528
Waste one element of value and location stack
529
so that they stay on the same level as the state stack.
530
The wasted elements are never initialized. */
538
/* Push a new state, which is found in yystate . */
539
/* In all cases, when you get here, the value and location stacks
540
have just been pushed. so pushing a state here evens the stacks. */
545
if (yyssp >= yyss + yystacksize - 1)
547
/* Give user a chance to reallocate the stack */
548
/* Use copies of these so that the &'s don't force the real ones into memory. */
549
YYSTYPE *yyvs1 = yyvs;
552
YYLTYPE *yyls1 = yyls;
555
/* Get the current used size of the three stacks, in elements. */
556
int size = yyssp - yyss + 1;
559
/* Each stack pointer address is followed by the size of
560
the data in use in that stack, in bytes. */
562
/* This used to be a conditional around just the two extra args,
563
but that might be undefined if yyoverflow is a macro. */
564
yyoverflow("parser stack overflow",
565
&yyss1, size * sizeof (*yyssp),
566
&yyvs1, size * sizeof (*yyvsp),
567
&yyls1, size * sizeof (*yylsp),
570
yyoverflow("parser stack overflow",
571
&yyss1, size * sizeof (*yyssp),
572
&yyvs1, size * sizeof (*yyvsp),
576
yyss = yyss1; yyvs = yyvs1;
580
#else /* no yyoverflow */
581
/* Extend the stack our own way. */
582
if (yystacksize >= YYMAXDEPTH)
584
yyerror("parser stack overflow");
596
if (yystacksize > YYMAXDEPTH)
597
yystacksize = YYMAXDEPTH;
598
#ifndef YYSTACK_USE_ALLOCA
601
yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));
602
__yy_memcpy ((char *)yyss, (char *)yyss1,
603
size * (unsigned int) sizeof (*yyssp));
604
yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));
605
__yy_memcpy ((char *)yyvs, (char *)yyvs1,
606
size * (unsigned int) sizeof (*yyvsp));
608
yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));
609
__yy_memcpy ((char *)yyls, (char *)yyls1,
610
size * (unsigned int) sizeof (*yylsp));
612
#endif /* no yyoverflow */
614
yyssp = yyss + size - 1;
615
yyvsp = yyvs + size - 1;
617
yylsp = yyls + size - 1;
622
fprintf(stderr, "Stack size increased to %d\n", yystacksize);
625
if (yyssp >= yyss + yystacksize - 1)
631
fprintf(stderr, "Entering state %d\n", yystate);
637
/* Do appropriate processing given the current state. */
638
/* Read a lookahead token if we need one and don't already have one. */
641
/* First try to decide what to do without reference to lookahead token. */
643
yyn = yypact[yystate];
647
/* Not known => get a lookahead token if don't already have one. */
649
/* yychar is either YYEMPTY or YYEOF
650
or a valid token in external form. */
652
if (yychar == YYEMPTY)
656
fprintf(stderr, "Reading a token: ");
661
/* Convert token to internal form (in yychar1) for indexing tables with */
663
if (yychar <= 0) /* This means end of input. */
666
yychar = YYEOF; /* Don't call YYLEX any more */
670
fprintf(stderr, "Now at end of input.\n");
675
yychar1 = YYTRANSLATE(yychar);
680
fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
681
/* Give the individual parser a way to print the precise meaning
682
of a token, for further debugging info. */
684
YYPRINT (stderr, yychar, yylval);
686
fprintf (stderr, ")\n");
692
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
697
/* yyn is what to do for this token type in this state.
698
Negative => reduce, -yyn is rule number.
699
Positive => shift, yyn is new state.
700
New state is final state => don't bother to shift,
702
0, or most negative number => error. */
717
/* Shift the lookahead token. */
721
fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
724
/* Discard the token being shifted unless it is eof. */
733
/* count tokens shifted since error; after three, turn off error status. */
734
if (yyerrstatus) yyerrstatus--;
739
/* Do the default action for the current state. */
742
yyn = yydefact[yystate];
746
/* Do a reduction. yyn is the number of a rule to reduce with. */
750
yyval = yyvsp[1-yylen]; /* implement default value of the action */
757
fprintf (stderr, "Reducing via rule %d (line %d), ",
760
/* Print the symbols being reduced, and their result. */
761
for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
762
fprintf (stderr, "%s ", yytname[yyrhs[i]]);
763
fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
771
#line 52 "adsedgelabelevaluation.y"
772
{if (yyvsp[-2].i>=0 && yyvsp[-1].i>=0) outcome= (yyvsp[-2].i) && (yyvsp[-1].i); else outcome=0; ;
775
#line 58 "adsedgelabelevaluation.y"
779
#line 59 "adsedgelabelevaluation.y"
782
b=GetBool(yyvsp[0].str,EVENT);
785
b=GetBool(yyvsp[0].str,SENDEVENT);
786
if (b>=0) yyval.i=b; else yyval.i=-1;
791
#line 71 "adsedgelabelevaluation.y"
795
#line 72 "adsedgelabelevaluation.y"
796
{if (yyvsp[-1].i >=0) yyval.i=yyvsp[-1].i;else yyval.i=1;;
799
#line 76 "adsedgelabelevaluation.y"
800
{yyval.i=yyvsp[0].i;;
803
#line 87 "adsedgelabelevaluation.y"
804
{yyval.i=yyvsp[0].i;;
807
#line 89 "adsedgelabelevaluation.y"
808
{ if ((yyvsp[0].i >= 0) && (yyvsp[-2].i>=0)) yyval.i=(yyvsp[0].i || yyvsp[-2].i);
809
if ((yyvsp[0].i < 0) && (yyvsp[-2].i>=0)) yyval.i=(yyvsp[-2].i);
810
if ((yyvsp[0].i >= 0) && (yyvsp[-2].i < 0)) yyval.i=(yyvsp[0].i);
811
if ((yyvsp[0].i < 0) && (yyvsp[-2].i < 0)) yyval.i=-1;
815
#line 96 "adsedgelabelevaluation.y"
816
{yyval.i=yyvsp[0].i;;
819
#line 98 "adsedgelabelevaluation.y"
820
{ if ((yyvsp[0].i >= 0) && (yyvsp[-2].i>=0)) yyval.i=(yyvsp[0].i && yyvsp[-2].i);
821
if ((yyvsp[0].i < 0) && (yyvsp[-2].i>=0)) yyval.i=(yyvsp[-2].i);
822
if ((yyvsp[0].i >= 0) && (yyvsp[-2].i < 0)) yyval.i=(yyvsp[0].i);
823
if ((yyvsp[0].i < 0) && (yyvsp[-2].i < 0)) yyval.i=-1;
827
#line 105 "adsedgelabelevaluation.y"
828
{if (yyvsp[0].i>=0) yyval.i=yyvsp[0].i;else yyval.i=-1;;
831
#line 106 "adsedgelabelevaluation.y"
832
{if (yyvsp[0].i>=0) yyval.i=(!yyvsp[0].i);else yyval.i=-1;if (isin) yyval.i=1;;
835
#line 107 "adsedgelabelevaluation.y"
836
{yyval.i=yyvsp[-1].i;;
839
#line 108 "adsedgelabelevaluation.y"
840
{yyval.i=1;isin=1; /* IN clause checked elsewhere */;
843
#line 111 "adsedgelabelevaluation.y"
847
#line 112 "adsedgelabelevaluation.y"
849
strcpy(temp,yyvsp[0].str);
853
#line 116 "adsedgelabelevaluation.y"
857
strcpy(temp,yyvsp[-2].str);
859
if (b==-1) b=GetBool(temp,INTERNAL_INT);
860
if (b>=0) yyval.i=b; else yyval.i=-1;
864
strcpy(temp,yyvsp[-2].str);
865
b=GetBool(temp,STRING);
866
if (b==-1) b=GetBool(temp,INTERNAL_STRING);
867
if (b>=0) yyval.i=b; else yyval.i=-1;
871
b = GetBool(temp,PROP);
872
if (b==-1) b=GetBool(temp,INTERNAL_PROP);
873
if (b>=0) yyval.i=b; else {yyval.i=-1;}
879
#line 142 "adsedgelabelevaluation.y"
880
{isintexp=0;isstrexp=0;;
883
#line 143 "adsedgelabelevaluation.y"
884
{strcpy(yyval.str,yyvsp[-1].str);
885
isintexp =1;isstrexp=0;;
888
#line 145 "adsedgelabelevaluation.y"
889
{ strcpy(yyval.str,yyvsp[-1].str);
890
isintexp=0;isstrexp=1;;
893
#line 149 "adsedgelabelevaluation.y"
894
{strcpy(yyval.str,yyvsp[0].str);;
897
#line 150 "adsedgelabelevaluation.y"
898
{strcpy(yyval.str,yyvsp[0].str);;
901
#line 151 "adsedgelabelevaluation.y"
902
{strcpy(yyval.str,yyvsp[0].str);;
905
#line 152 "adsedgelabelevaluation.y"
906
{strcpy(yyval.str,yyvsp[0].str);;
909
#line 153 "adsedgelabelevaluation.y"
910
{strcpy(yyval.str,yyvsp[0].str);;
913
#line 154 "adsedgelabelevaluation.y"
914
{strcpy(yyval.str,yyvsp[0].str);;
917
#line 159 "adsedgelabelevaluation.y"
918
{strcpy(yyval.str,yyvsp[0].str);;
921
#line 160 "adsedgelabelevaluation.y"
922
{strcpy(yyval.str,yyvsp[0].str);;
925
#line 166 "adsedgelabelevaluation.y"
929
#line 167 "adsedgelabelevaluation.y"
933
/* the action file gets copied in in place of this dollarsign */
934
#line 543 "/usr/lib/bison.simple"
945
short *ssp1 = yyss - 1;
946
fprintf (stderr, "state stack now");
947
while (ssp1 != yyssp)
948
fprintf (stderr, " %d", *++ssp1);
949
fprintf (stderr, "\n");
959
yylsp->first_line = yylloc.first_line;
960
yylsp->first_column = yylloc.first_column;
961
yylsp->last_line = (yylsp-1)->last_line;
962
yylsp->last_column = (yylsp-1)->last_column;
967
yylsp->last_line = (yylsp+yylen-1)->last_line;
968
yylsp->last_column = (yylsp+yylen-1)->last_column;
972
/* Now "shift" the result of the reduction.
973
Determine what state that goes to,
974
based on the state we popped back to
975
and the rule number reduced by. */
979
yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
980
if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
981
yystate = yytable[yystate];
983
yystate = yydefgoto[yyn - YYNTBASE];
987
yyerrlab: /* here on detecting error */
990
/* If not already recovering from an error, report this error. */
994
#ifdef YYERROR_VERBOSE
995
yyn = yypact[yystate];
997
if (yyn > YYFLAG && yyn < YYLAST)
1004
/* Start X at -yyn if nec to avoid negative indexes in yycheck. */
1005
for (x = (yyn < 0 ? -yyn : 0);
1006
x < (sizeof(yytname) / sizeof(char *)); x++)
1007
if (yycheck[x + yyn] == x)
1008
size += strlen(yytname[x]) + 15, count++;
1009
msg = (char *) malloc(size + 15);
1012
strcpy(msg, "parse error");
1017
for (x = (yyn < 0 ? -yyn : 0);
1018
x < (sizeof(yytname) / sizeof(char *)); x++)
1019
if (yycheck[x + yyn] == x)
1021
strcat(msg, count == 0 ? ", expecting `" : " or `");
1022
strcat(msg, yytname[x]);
1031
yyerror ("parse error; also virtual memory exceeded");
1034
#endif /* YYERROR_VERBOSE */
1035
yyerror("parse error");
1039
yyerrlab1: /* here on error raised explicitly by an action */
1041
if (yyerrstatus == 3)
1043
/* if just tried and failed to reuse lookahead token after an error, discard it. */
1045
/* return failure if at end of input */
1046
if (yychar == YYEOF)
1051
fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
1057
/* Else will try to reuse lookahead token
1058
after shifting the error token. */
1060
yyerrstatus = 3; /* Each real token shifted decrements this */
1064
yyerrdefault: /* current state does not do anything special for the error token. */
1067
/* This is wrong; only states that explicitly want error tokens
1068
should shift them. */
1069
yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
1070
if (yyn) goto yydefault;
1073
yyerrpop: /* pop the current state because it cannot handle the error token */
1075
if (yyssp == yyss) YYABORT;
1085
short *ssp1 = yyss - 1;
1086
fprintf (stderr, "Error: state stack now");
1087
while (ssp1 != yyssp)
1088
fprintf (stderr, " %d", *++ssp1);
1089
fprintf (stderr, "\n");
1095
yyn = yypact[yystate];
1100
if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
1119
fprintf(stderr, "Shifting error token, ");
1131
/* YYACCEPT comes here. */
1143
/* YYABORT comes here. */
1154
#line 169 "adsedgelabelevaluation.y"
added
removed
src/sd/bv/adsedgelabelevaluation.tab.c
