← Back to branch summary

~verifypn-cpn/verifypn/RERS_2018

« back to all changes in this revision

Viewing changes to PetriEngine/PQL/PQLQueryParser.parser.cpp

  • Committer: Peter G. Jensen
  • Date: 2018-10-04 17:48:09 UTC
  • Revision ID: peter.gjoel@gmail.com-20181004174809-xrlpv9pb37x3kh2s
should parse RERS ctl-semantics, reductions might be incorrect

Show diffs side-by-side

added added

removed removed

Lines of Context:
PetriEngine/PQL/PQLQueryParser.parser.cpp
134
134
    AND = 267,
135
135
    OR = 268,
136
136
    NOT = 269,
137
 
    EQUAL = 270,
138
 
    NEQUAL = 271,
139
 
    LESS = 272,
140
 
    LESSEQUAL = 273,
141
 
    GREATER = 274,
142
 
    GREATEREQUAL = 275,
143
 
    PLUS = 276,
144
 
    MINUS = 277,
145
 
    MULTIPLY = 278,
146
 
    EF = 279,
147
 
    EG = 280,
148
 
    AF = 281,
149
 
    AG = 282,
150
 
    A = 283,
151
 
    E = 284,
152
 
    U = 285,
153
 
    W = 286
 
137
    IMPLIES = 270,
 
138
    EQUAL = 271,
 
139
    NEQUAL = 272,
 
140
    LESS = 273,
 
141
    LESSEQUAL = 274,
 
142
    GREATER = 275,
 
143
    GREATEREQUAL = 276,
 
144
    PLUS = 277,
 
145
    MINUS = 278,
 
146
    MULTIPLY = 279,
 
147
    EF = 280,
 
148
    EG = 281,
 
149
    AF = 282,
 
150
    AG = 283,
 
151
    A = 284,
 
152
    E = 285,
 
153
    U = 286,
 
154
    W = 287
154
155
  };
155
156
#endif
156
157
 
166
167
    std::string *string;
167
168
    int token;
168
169
 
169
 
#line 170 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:355  */
 
170
#line 171 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:355  */
170
171
};
171
172
 
172
173
typedef union YYSTYPE YYSTYPE;
183
184
 
184
185
/* Copy the second part of user declarations.  */
185
186
 
186
 
#line 187 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:358  */
 
187
#line 188 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:358  */
187
188
 
188
189
#ifdef short
189
190
# undef short
423
424
#endif /* !YYCOPY_NEEDED */
424
425
 
425
426
/* YYFINAL -- State number of the termination state.  */
426
 
#define YYFINAL  40
 
427
#define YYFINAL  42
427
428
/* YYLAST -- Last index in YYTABLE.  */
428
 
#define YYLAST   132
 
429
#define YYLAST   168
429
430
 
430
431
/* YYNTOKENS -- Number of terminals.  */
431
 
#define YYNTOKENS  32
 
432
#define YYNTOKENS  33
432
433
/* YYNNTS -- Number of nonterminals.  */
433
 
#define YYNNTS  8
 
434
#define YYNNTS  10
434
435
/* YYNRULES -- Number of rules.  */
435
 
#define YYNRULES  36
 
436
#define YYNRULES  43
436
437
/* YYNSTATES -- Number of states.  */
437
 
#define YYNSTATES  76
 
438
#define YYNSTATES  92
438
439
 
439
440
/* YYTRANSLATE[YYX] -- Symbol number corresponding to YYX as returned
440
441
   by yylex, with out-of-bounds checking.  */
441
442
#define YYUNDEFTOK  2
442
 
#define YYMAXUTOK   286
 
443
#define YYMAXUTOK   287
443
444
 
444
445
#define YYTRANSLATE(YYX)                                                \
445
446
  ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
476
477
       2,     2,     2,     2,     2,     2,     1,     2,     3,     4,
477
478
       5,     6,     7,     8,     9,    10,    11,    12,    13,    14,
478
479
      15,    16,    17,    18,    19,    20,    21,    22,    23,    24,
479
 
      25,    26,    27,    28,    29,    30,    31
 
480
      25,    26,    27,    28,    29,    30,    31,    32
480
481
};
481
482
 
482
483
#if YYDEBUG
483
484
  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */
484
485
static const yytype_uint8 yyrline[] =
485
486
{
486
 
       0,    54,    54,    55,    59,    60,    61,    62,    63,    64,
487
 
      65,    66,    67,    68,    69,    72,    75,    76,    77,    78,
488
 
      79,    80,    84,    85,    86,    87,    88,    89,    93,    95,
489
 
      97,    98,   102,   104,   108,   109,   111
 
487
       0,    53,    53,    54,    58,    59,    63,    64,    65,    66,
 
488
      67,    68,    69,    80,    85,    86,    87,    88,    92,    93,
 
489
      94,    95,    96,    97,    98,   102,   108,   119,   120,   124,
 
490
     125,   126,   127,   128,   129,   133,   135,   137,   138,   142,
 
491
     144,   148,   149,   151
490
492
};
491
493
#endif
492
494
 
496
498
static const char *const yytname[] =
497
499
{
498
500
  "$end", "error", "$undefined", "ID", "INT", "DEADLOCK", "TRUE", "FALSE",
499
 
  "LPAREN", "RPAREN", "RSQBRCKT", "LSQBRCKT", "AND", "OR", "NOT", "EQUAL",
500
 
  "NEQUAL", "LESS", "LESSEQUAL", "GREATER", "GREATEREQUAL", "PLUS",
501
 
  "MINUS", "MULTIPLY", "EF", "EG", "AF", "AG", "A", "E", "U", "W",
502
 
  "$accept", "query", "quant", "logic", "compare", "expr", "term",
503
 
  "factor", YY_NULLPTR
 
501
  "LPAREN", "RPAREN", "RSQBRCKT", "LSQBRCKT", "AND", "OR", "NOT",
 
502
  "IMPLIES", "EQUAL", "NEQUAL", "LESS", "LESSEQUAL", "GREATER",
 
503
  "GREATEREQUAL", "PLUS", "MINUS", "MULTIPLY", "EF", "EG", "AF", "AG", "A",
 
504
  "E", "U", "W", "$accept", "query", "formula", "quant", "logic", "lop",
 
505
  "compare", "expr", "term", "factor", YY_NULLPTR
504
506
};
505
507
#endif
506
508
 
512
514
       0,   256,   257,   258,   259,   260,   261,   262,   263,   264,
513
515
     265,   266,   267,   268,   269,   270,   271,   272,   273,   274,
514
516
     275,   276,   277,   278,   279,   280,   281,   282,   283,   284,
515
 
     285,   286
 
517
     285,   286,   287
516
518
};
517
519
# endif
518
520
 
519
 
#define YYPACT_NINF -23
 
521
#define YYPACT_NINF -34
520
522
 
521
523
#define yypact_value_is_default(Yystate) \
522
 
  (!!((Yystate) == (-23)))
 
524
  (!!((Yystate) == (-34)))
523
525
 
524
 
#define YYTABLE_NINF -16
 
526
#define YYTABLE_NINF -1
525
527
 
526
528
#define yytable_value_is_error(Yytable_value) \
527
529
  0
528
530
 
529
531
  /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
530
532
     STATE-NUM.  */
531
 
static const yytype_int8 yypact[] =
 
533
static const yytype_int16 yypact[] =
532
534
{
533
 
      54,   -23,   -23,   -23,   -23,   -23,   -23,    81,    10,    81,
534
 
      -2,     8,    81,    81,    81,    81,    11,    19,     9,   -23,
535
 
     -23,   -23,   110,    -8,   -23,    26,   102,    24,    81,   -23,
536
 
      17,    81,     8,   -18,   -23,   -23,   -23,   -23,    81,    81,
537
 
     -23,     8,     8,     8,     8,     8,     8,    25,    25,    25,
538
 
     -23,   -23,    81,   -23,    81,   -23,     1,    12,    13,   -18,
539
 
     -18,   -18,   -18,   -18,   -18,    -8,    -8,   -23,   -23,   -23,
540
 
      81,    81,    28,    29,   -23,   -23
 
535
      76,   -34,   -34,   -34,   -34,   -34,   -34,   104,    37,   104,
 
536
       1,    12,   104,   104,   104,   104,     9,    11,     3,   152,
 
537
     -34,   -34,   -34,   -34,    47,   -23,   -34,    80,   119,    17,
 
538
     104,   -34,    24,   104,    12,     8,   -34,   -34,   -34,   -34,
 
539
     104,   104,   -34,   104,   104,   104,   104,    12,    12,    12,
 
540
      12,    12,    12,   158,   158,   158,   -34,   -34,   104,   152,
 
541
     104,   152,     2,    -3,    30,   -34,   -34,   -34,   -34,     8,
 
542
       8,     8,     8,     8,     8,   -23,   -23,   -34,   152,   152,
 
543
     104,   104,   104,   104,   108,   134,   139,   144,   -34,   -34,
 
544
     -34,   -34
541
545
};
542
546
 
543
547
  /* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
545
549
     means the default is an error.  */
546
550
static const yytype_uint8 yydefact[] =
547
551
{
548
 
       0,     3,    36,    35,    20,    18,    19,    15,     0,    15,
549
 
       0,     0,    15,    15,    15,    15,     0,     0,     0,     2,
550
 
      14,    17,     0,    31,    33,     0,     0,     0,    15,    16,
551
 
       0,    15,     0,    30,     7,     6,     5,     4,    15,    15,
552
 
       1,     0,     0,     0,     0,     0,     0,     0,     0,     0,
553
 
      21,    34,    15,    10,    15,    11,     0,     0,     0,    22,
554
 
      23,    24,    25,    26,    27,    28,    29,    32,    12,    13,
555
 
      15,    15,     0,     0,     8,     9
 
552
       0,     3,    43,    42,    22,    20,    21,     0,     0,     0,
 
553
       0,     0,     0,     0,     0,     0,     0,     0,     0,     2,
 
554
       5,     4,    24,    19,     0,    38,    40,     0,     0,     0,
 
555
       0,    18,     0,     0,     0,    37,     9,     8,     7,     6,
 
556
       0,     0,     1,     0,     0,     0,     0,     0,     0,     0,
 
557
       0,     0,     0,     0,     0,     0,    23,    41,     0,    14,
 
558
       0,    15,     0,     0,     0,    27,    28,    25,    26,    29,
 
559
      30,    31,    32,    33,    34,    35,    36,    39,    16,    17,
 
560
       0,     0,     0,     0,     0,     0,     0,     0,    10,    12,
 
561
      11,    13
556
562
};
557
563
 
558
564
  /* YYPGOTO[NTERM-NUM].  */
559
565
static const yytype_int8 yypgoto[] =
560
566
{
561
 
     -23,   -23,    -7,   -23,   -23,     7,   -22,    -9
 
567
     -34,   -34,    -7,   -34,   -34,   -34,   -34,     7,    -5,   -33
562
568
};
563
569
 
564
570
  /* YYDEFGOTO[NTERM-NUM].  */
565
571
static const yytype_int8 yydefgoto[] =
566
572
{
567
 
      -1,    18,    19,    20,    21,    22,    23,    24
 
573
      -1,    18,    19,    20,    21,    22,    23,    24,    25,    26
568
574
};
569
575
 
570
576
  /* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM.  If
571
577
     positive, shift that token.  If negative, reduce the rule whose
572
578
     number is the opposite.  If YYTABLE_NINF, syntax error.  */
573
 
static const yytype_int8 yytable[] =
 
579
static const yytype_uint8 yytable[] =
574
580
{
575
 
      25,    30,    29,    47,    48,    34,    35,    36,    37,    40,
576
 
      51,     2,     3,    27,    26,    49,    32,    31,    33,    38,
577
 
      28,    53,    47,    48,    55,    65,    66,    39,     2,     3,
578
 
      11,    57,    58,    32,    52,    50,    54,    74,    75,    56,
579
 
      67,     0,    70,    71,     0,    68,     0,    69,    59,    60,
580
 
      61,    62,    63,    64,   -15,     1,     0,     2,     3,     4,
581
 
       5,     6,     7,    72,    73,     8,     0,     0,     9,     0,
582
 
       0,    10,     0,     0,     0,     0,    11,     0,    12,    13,
583
 
      14,    15,    16,    17,     2,     3,     4,     5,     6,     7,
584
 
       0,     0,     8,     0,     0,     9,     0,     0,    10,     0,
585
 
       0,     0,     0,    11,     0,    12,    13,    14,    15,    16,
586
 
      17,    51,     0,     0,     0,     0,     0,    41,    42,    43,
587
 
      44,    45,    46,    47,    48,    41,    42,    43,    44,    45,
588
 
      46,    47,    48
 
581
      27,    55,    31,    42,    32,    36,    37,    38,    39,    43,
 
582
      44,    57,    45,    46,    28,     2,     3,    40,    35,    41,
 
583
      34,    33,    77,    59,    53,    54,    61,    58,    80,    81,
 
584
      53,    54,     0,    63,    64,    11,    65,    66,    67,    68,
 
585
      29,    62,    43,    44,    60,    45,    46,    30,    75,    76,
 
586
       0,    78,     0,    79,    69,    70,    71,    72,    73,    74,
 
587
       0,    82,    83,    47,    48,    49,    50,    51,    52,    53,
 
588
      54,     0,     0,    84,    85,    86,    87,     1,     0,     2,
 
589
       3,     4,     5,     6,     7,     0,     0,     8,     0,    56,
 
590
       9,     0,    43,    44,    10,    45,    46,     0,     0,    11,
 
591
       0,    12,    13,    14,    15,    16,    17,     2,     3,     4,
 
592
       5,     6,     7,     0,     0,     8,     0,    88,     9,     0,
 
593
      43,    44,    10,    45,    46,     0,     0,    11,    57,    12,
 
594
      13,    14,    15,    16,    17,    47,    48,    49,    50,    51,
 
595
      52,    53,    54,    89,     0,     0,    43,    44,    90,    45,
 
596
      46,    43,    44,    91,    45,    46,    43,    44,     0,    45,
 
597
      46,     2,     3,     0,    43,    44,    34,    45,    46
589
598
};
590
599
 
591
600
static const yytype_int8 yycheck[] =
592
601
{
593
 
       7,     3,     9,    21,    22,    12,    13,    14,    15,     0,
594
 
       9,     3,     4,     3,     7,    23,     8,    19,    11,     8,
595
 
      10,    28,    21,    22,    31,    47,    48,     8,     3,     4,
596
 
      22,    38,    39,     8,    10,     9,    19,     9,     9,    32,
597
 
      49,    -1,    30,    30,    -1,    52,    -1,    54,    41,    42,
598
 
      43,    44,    45,    46,     0,     1,    -1,     3,     4,     5,
599
 
       6,     7,     8,    70,    71,    11,    -1,    -1,    14,    -1,
600
 
      -1,    17,    -1,    -1,    -1,    -1,    22,    -1,    24,    25,
601
 
      26,    27,    28,    29,     3,     4,     5,     6,     7,     8,
602
 
      -1,    -1,    11,    -1,    -1,    14,    -1,    -1,    17,    -1,
603
 
      -1,    -1,    -1,    22,    -1,    24,    25,    26,    27,    28,
604
 
      29,     9,    -1,    -1,    -1,    -1,    -1,    15,    16,    17,
605
 
      18,    19,    20,    21,    22,    15,    16,    17,    18,    19,
606
 
      20,    21,    22
 
602
       7,    24,     9,     0,     3,    12,    13,    14,    15,    12,
 
603
      13,     9,    15,    16,     7,     3,     4,     8,    11,     8,
 
604
       8,    20,    55,    30,    22,    23,    33,    10,    31,    32,
 
605
      22,    23,    -1,    40,    41,    23,    43,    44,    45,    46,
 
606
       3,    34,    12,    13,    20,    15,    16,    10,    53,    54,
 
607
      -1,    58,    -1,    60,    47,    48,    49,    50,    51,    52,
 
608
      -1,    31,    32,    16,    17,    18,    19,    20,    21,    22,
 
609
      23,    -1,    -1,    80,    81,    82,    83,     1,    -1,     3,
 
610
       4,     5,     6,     7,     8,    -1,    -1,    11,    -1,     9,
 
611
      14,    -1,    12,    13,    18,    15,    16,    -1,    -1,    23,
 
612
      -1,    25,    26,    27,    28,    29,    30,     3,     4,     5,
 
613
       6,     7,     8,    -1,    -1,    11,    -1,     9,    14,    -1,
 
614
      12,    13,    18,    15,    16,    -1,    -1,    23,     9,    25,
 
615
      26,    27,    28,    29,    30,    16,    17,    18,    19,    20,
 
616
      21,    22,    23,     9,    -1,    -1,    12,    13,     9,    15,
 
617
      16,    12,    13,     9,    15,    16,    12,    13,    -1,    15,
 
618
      16,     3,     4,    -1,    12,    13,     8,    15,    16
607
619
};
608
620
 
609
621
  /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
611
623
static const yytype_uint8 yystos[] =
612
624
{
613
625
       0,     1,     3,     4,     5,     6,     7,     8,    11,    14,
614
 
      17,    22,    24,    25,    26,    27,    28,    29,    33,    34,
615
 
      35,    36,    37,    38,    39,    34,    37,     3,    10,    34,
616
 
       3,    19,     8,    37,    34,    34,    34,    34,     8,     8,
617
 
       0,    15,    16,    17,    18,    19,    20,    21,    22,    23,
618
 
       9,     9,    10,    34,    19,    34,    37,    34,    34,    37,
619
 
      37,    37,    37,    37,    37,    38,    38,    39,    34,    34,
620
 
      30,    30,    34,    34,     9,     9
 
626
      18,    23,    25,    26,    27,    28,    29,    30,    34,    35,
 
627
      36,    37,    38,    39,    40,    41,    42,    35,    40,     3,
 
628
      10,    35,     3,    20,     8,    40,    35,    35,    35,    35,
 
629
       8,     8,     0,    12,    13,    15,    16,    16,    17,    18,
 
630
      19,    20,    21,    22,    23,    24,     9,     9,    10,    35,
 
631
      20,    35,    40,    35,    35,    35,    35,    35,    35,    40,
 
632
      40,    40,    40,    40,    40,    41,    41,    42,    35,    35,
 
633
      31,    32,    31,    32,    35,    35,    35,    35,     9,     9,
 
634
       9,     9
621
635
};
622
636
 
623
637
  /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives.  */
624
638
static const yytype_uint8 yyr1[] =
625
639
{
626
 
       0,    32,    33,    33,    34,    34,    34,    34,    34,    34,
627
 
      34,    34,    34,    34,    34,    35,    35,    35,    35,    35,
628
 
      35,    35,    36,    36,    36,    36,    36,    36,    37,    37,
629
 
      37,    37,    38,    38,    39,    39,    39
 
640
       0,    33,    34,    34,    35,    35,    36,    36,    36,    36,
 
641
      36,    36,    36,    36,    36,    36,    36,    36,    37,    37,
 
642
      37,    37,    37,    37,    37,    38,    38,    38,    38,    39,
 
643
      39,    39,    39,    39,    39,    40,    40,    40,    40,    41,
 
644
      41,    42,    42,    42
630
645
};
631
646
 
632
647
  /* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN.  */
633
648
static const yytype_uint8 yyr2[] =
634
649
{
635
 
       0,     2,     1,     1,     2,     2,     2,     2,     6,     6,
636
 
       3,     3,     4,     4,     1,     0,     2,     1,     1,     1,
637
 
       1,     3,     3,     3,     3,     3,     3,     3,     3,     3,
638
 
       2,     1,     3,     1,     3,     1,     1
 
650
       0,     2,     1,     1,     1,     1,     2,     2,     2,     2,
 
651
       6,     6,     6,     6,     3,     3,     4,     4,     2,     1,
 
652
       1,     1,     1,     3,     1,     3,     3,     3,     3,     3,
 
653
       3,     3,     3,     3,     3,     3,     3,     2,     1,     3,
 
654
       1,     3,     1,     1
639
655
};
640
656
 
641
657
 
1312
1328
  switch (yyn)
1313
1329
    {
1314
1330
        case 2:
1315
 
#line 54 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1331
#line 53 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1316
1332
    { query = Condition_ptr((yyvsp[0].cond));}
1317
 
#line 1318 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1333
#line 1334 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1318
1334
    break;
1319
1335
 
1320
1336
  case 3:
1321
 
#line 55 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1337
#line 54 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1322
1338
    { yyerrok;}
1323
 
#line 1324 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1339
#line 1340 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1324
1340
    break;
1325
1341
 
1326
1342
  case 4:
 
1343
#line 58 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1344
    { (yyval.cond) = (yyvsp[0].cond); }
 
1345
#line 1346 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1346
    break;
 
1347
 
 
1348
  case 5:
1327
1349
#line 59 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1350
    { (yyval.cond) = (yyvsp[0].cond); }
 
1351
#line 1352 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1352
    break;
 
1353
 
 
1354
  case 6:
 
1355
#line 63 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1328
1356
    { (yyval.cond) = new AGCondition(Condition_ptr((yyvsp[0].cond)));}
1329
 
#line 1330 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1357
#line 1358 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1330
1358
    break;
1331
1359
 
1332
 
  case 5:
1333
 
#line 60 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1360
  case 7:
 
1361
#line 64 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1334
1362
    { (yyval.cond) = new AFCondition(Condition_ptr((yyvsp[0].cond)));}
1335
 
#line 1336 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1363
#line 1364 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1336
1364
    break;
1337
1365
 
1338
 
  case 6:
1339
 
#line 61 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1366
  case 8:
 
1367
#line 65 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1340
1368
    { (yyval.cond) = new EGCondition(Condition_ptr((yyvsp[0].cond)));}
1341
 
#line 1342 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1369
#line 1370 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1342
1370
    break;
1343
1371
 
1344
 
  case 7:
1345
 
#line 62 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1372
  case 9:
 
1373
#line 66 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1346
1374
    { (yyval.cond) = new EFCondition(Condition_ptr((yyvsp[0].cond)));}
1347
 
#line 1348 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1375
#line 1376 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1348
1376
    break;
1349
1377
 
1350
 
  case 8:
1351
 
#line 63 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1378
  case 10:
 
1379
#line 67 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1352
1380
    { (yyval.cond) = new AUCondition(Condition_ptr((yyvsp[-3].cond)), Condition_ptr((yyvsp[-1].cond)));}
1353
 
#line 1354 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1381
#line 1382 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1354
1382
    break;
1355
1383
 
1356
 
  case 9:
1357
 
#line 64 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1384
  case 11:
 
1385
#line 68 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1358
1386
    { (yyval.cond) = new EUCondition(Condition_ptr((yyvsp[-3].cond)), Condition_ptr((yyvsp[-1].cond)));}
1359
 
#line 1360 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1360
 
    break;
1361
 
 
1362
 
  case 10:
1363
 
#line 65 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1364
 
    { (yyval.cond) = new AXCondition(Condition_ptr((yyvsp[0].cond)));}
1365
 
#line 1366 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1366
 
    break;
1367
 
 
1368
 
  case 11:
1369
 
#line 66 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1370
 
    { (yyval.cond) = new EXCondition(Condition_ptr((yyvsp[0].cond)));}
1371
 
#line 1372 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1387
#line 1388 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1372
1388
    break;
1373
1389
 
1374
1390
  case 12:
1375
 
#line 67 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1376
 
    { (yyval.cond) = new ATransitionCondition(*(yyvsp[-2].string), Condition_ptr((yyvsp[0].cond))); }
1377
 
#line 1378 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1391
#line 69 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1392
    {
 
1393
        auto a = Condition_ptr((yyvsp[-3].cond)); 
 
1394
        auto b = Condition_ptr((yyvsp[-1].cond));
 
1395
        (yyval.cond) = new NotCondition(
 
1396
                std::make_shared<EUCondition>(
 
1397
                    std::make_shared<AndCondition>(a, std::make_shared<NotCondition>(b)),
 
1398
                    std::make_shared<AndCondition>(std::make_shared<NotCondition>(a), 
 
1399
                                                   std::make_shared<NotCondition>(b))
 
1400
                )
 
1401
            );
 
1402
    }
 
1403
#line 1404 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1378
1404
    break;
1379
1405
 
1380
1406
  case 13:
1381
 
#line 68 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1382
 
    { (yyval.cond) = new ETransitionCondition(*(yyvsp[-2].string), Condition_ptr((yyvsp[0].cond))); }
1383
 
#line 1384 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1407
#line 80 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1408
    { 
 
1409
        auto a = Condition_ptr((yyvsp[-3].cond)); 
 
1410
        auto b = Condition_ptr((yyvsp[-1].cond));
 
1411
        (yyval.cond) = new OrCondition(std::make_shared<EGCondition>(a), std::make_shared<EUCondition>(a, b)); 
 
1412
    }
 
1413
#line 1414 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1384
1414
    break;
1385
1415
 
1386
1416
  case 14:
1387
 
#line 69 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1388
 
    { (yyval.cond) = (yyvsp[0].cond);}
1389
 
#line 1390 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1417
#line 85 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1418
    { (yyval.cond) = new AXCondition(Condition_ptr((yyvsp[0].cond)));}
 
1419
#line 1420 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1420
    break;
 
1421
 
 
1422
  case 15:
 
1423
#line 86 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1424
    { (yyval.cond) = new EXCondition(Condition_ptr((yyvsp[0].cond)));}
 
1425
#line 1426 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1390
1426
    break;
1391
1427
 
1392
1428
  case 16:
1393
 
#line 75 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1394
 
    { (yyval.cond) = new NotCondition(Condition_ptr((yyvsp[0].cond)));}
1395
 
#line 1396 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1429
#line 87 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1430
    { (yyval.cond) = new ATransitionCondition(*(yyvsp[-2].string), Condition_ptr((yyvsp[0].cond))); }
 
1431
#line 1432 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1396
1432
    break;
1397
1433
 
1398
1434
  case 17:
1399
 
#line 76 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1400
 
    { (yyval.cond) = (yyvsp[0].cond);}
1401
 
#line 1402 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1435
#line 88 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1436
    { (yyval.cond) = new ETransitionCondition(*(yyvsp[-2].string), Condition_ptr((yyvsp[0].cond))); }
 
1437
#line 1438 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1402
1438
    break;
1403
1439
 
1404
1440
  case 18:
1405
 
#line 77 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1406
 
    { (yyval.cond) = new BooleanCondition(true);}
1407
 
#line 1408 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1441
#line 92 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1442
    { (yyval.cond) = new NotCondition(Condition_ptr((yyvsp[0].cond)));}
 
1443
#line 1444 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1408
1444
    break;
1409
1445
 
1410
1446
  case 19:
1411
 
#line 78 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1412
 
    { (yyval.cond) = new BooleanCondition(false);}
1413
 
#line 1414 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1447
#line 93 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1448
    { (yyval.cond) = (yyvsp[0].cond);}
 
1449
#line 1450 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1414
1450
    break;
1415
1451
 
1416
1452
  case 20:
1417
 
#line 79 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1418
 
    { (yyval.cond) = new DeadlockCondition();}
1419
 
#line 1420 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1453
#line 94 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1454
    { (yyval.cond) = new BooleanCondition(true);}
 
1455
#line 1456 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1420
1456
    break;
1421
1457
 
1422
1458
  case 21:
1423
 
#line 80 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1424
 
    { (yyval.cond) = (yyvsp[-1].cond);}
1425
 
#line 1426 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1459
#line 95 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1460
    { (yyval.cond) = new BooleanCondition(false);}
 
1461
#line 1462 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1426
1462
    break;
1427
1463
 
1428
1464
  case 22:
1429
 
#line 84 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1430
 
    { (yyval.cond) = new EqualCondition(Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr)));}
1431
 
#line 1432 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1465
#line 96 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1466
    { (yyval.cond) = new DeadlockCondition();}
 
1467
#line 1468 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1432
1468
    break;
1433
1469
 
1434
1470
  case 23:
1435
 
#line 85 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1436
 
    { (yyval.cond) = new NotEqualCondition(Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr)));}
1437
 
#line 1438 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1438
 
    break;
1439
 
 
1440
 
  case 24:
1441
 
#line 86 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1442
 
    { (yyval.cond) = new LessThanCondition(Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr)));}
1443
 
#line 1444 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1471
#line 97 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1472
    { (yyval.cond) = (yyvsp[-1].cond);}
 
1473
#line 1474 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1444
1474
    break;
1445
1475
 
1446
1476
  case 25:
1447
 
#line 87 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1448
 
    { (yyval.cond) = new LessThanOrEqualCondition(Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr)));}
1449
 
#line 1450 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1477
#line 103 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1478
    { 
 
1479
        auto a = Condition_ptr((yyvsp[-2].cond)); 
 
1480
        auto b = Condition_ptr((yyvsp[0].cond));
 
1481
        (yyval.cond) = new OrCondition(std::make_shared<NotCondition>(a), std::make_shared<AndCondition>(a, b)); 
 
1482
    }
 
1483
#line 1484 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1450
1484
    break;
1451
1485
 
1452
1486
  case 26:
1453
 
#line 88 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1454
 
    { (yyval.cond) = new GreaterThanCondition(Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr)));}
1455
 
#line 1456 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1487
#line 108 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1488
    {
 
1489
        auto a = Condition_ptr((yyvsp[-2].cond)); 
 
1490
        auto b = Condition_ptr((yyvsp[0].cond));
 
1491
        (yyval.cond) = new OrCondition(
 
1492
                std::make_shared<AndCondition>(a, b),
 
1493
                std::make_shared<AndCondition>(
 
1494
                    std::make_shared<NotCondition>(a),
 
1495
                    std::make_shared<NotCondition>(b)
 
1496
                    )                    
 
1497
                );
 
1498
    }
 
1499
#line 1500 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1456
1500
    break;
1457
1501
 
1458
1502
  case 27:
1459
 
#line 89 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1460
 
    { (yyval.cond) = new GreaterThanOrEqualCondition(Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr)));}
1461
 
#line 1462 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1503
#line 119 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1504
    { (yyval.cond) = new AndCondition(Condition_ptr((yyvsp[-2].cond)), Condition_ptr((yyvsp[0].cond)));}
 
1505
#line 1506 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1462
1506
    break;
1463
1507
 
1464
1508
  case 28:
1465
 
#line 93 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1466
 
    { (yyval.expr) = new PlusExpr(std::vector<Expr_ptr>(
1467
 
        {Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr))}));}
1468
 
#line 1469 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1509
#line 120 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1510
    { (yyval.cond) = new OrCondition(Condition_ptr((yyvsp[-2].cond)), Condition_ptr((yyvsp[0].cond)));}
 
1511
#line 1512 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1469
1512
    break;
1470
1513
 
1471
1514
  case 29:
1472
 
#line 95 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1473
 
    { (yyval.expr) = new SubtractExpr(std::vector<Expr_ptr>(
1474
 
        {Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr))}));}
1475
 
#line 1476 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1515
#line 124 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1516
    { (yyval.cond) = new EqualCondition(Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr)));}
 
1517
#line 1518 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1476
1518
    break;
1477
1519
 
1478
1520
  case 30:
1479
 
#line 97 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1480
 
    { (yyval.expr) = new MinusExpr(Expr_ptr((yyvsp[0].expr)));}
1481
 
#line 1482 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1521
#line 125 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1522
    { (yyval.cond) = new NotEqualCondition(Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr)));}
 
1523
#line 1524 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1482
1524
    break;
1483
1525
 
1484
1526
  case 31:
1485
 
#line 98 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1486
 
    { (yyval.expr) = (yyvsp[0].expr);}
1487
 
#line 1488 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1527
#line 126 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1528
    { (yyval.cond) = new LessThanCondition(Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr)));}
 
1529
#line 1530 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1488
1530
    break;
1489
1531
 
1490
1532
  case 32:
1491
 
#line 102 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1492
 
    { (yyval.expr) = new MultiplyExpr(std::vector<Expr_ptr>(
1493
 
        {Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr))}));}
1494
 
#line 1495 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1533
#line 127 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1534
    { (yyval.cond) = new LessThanOrEqualCondition(Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr)));}
 
1535
#line 1536 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1495
1536
    break;
1496
1537
 
1497
1538
  case 33:
1498
 
#line 104 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1499
 
    { (yyval.expr) = (yyvsp[0].expr);}
1500
 
#line 1501 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1539
#line 128 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1540
    { (yyval.cond) = new GreaterThanCondition(Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr)));}
 
1541
#line 1542 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1501
1542
    break;
1502
1543
 
1503
1544
  case 34:
1504
 
#line 108 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1545
#line 129 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1546
    { (yyval.cond) = new GreaterThanOrEqualCondition(Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr)));}
 
1547
#line 1548 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1548
    break;
 
1549
 
 
1550
  case 35:
 
1551
#line 133 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1552
    { (yyval.expr) = new PlusExpr(std::vector<Expr_ptr>(
 
1553
        {Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr))}));}
 
1554
#line 1555 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1555
    break;
 
1556
 
 
1557
  case 36:
 
1558
#line 135 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1559
    { (yyval.expr) = new SubtractExpr(std::vector<Expr_ptr>(
 
1560
        {Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr))}));}
 
1561
#line 1562 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1562
    break;
 
1563
 
 
1564
  case 37:
 
1565
#line 137 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1566
    { (yyval.expr) = new MinusExpr(Expr_ptr((yyvsp[0].expr)));}
 
1567
#line 1568 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1568
    break;
 
1569
 
 
1570
  case 38:
 
1571
#line 138 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1572
    { (yyval.expr) = (yyvsp[0].expr);}
 
1573
#line 1574 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1574
    break;
 
1575
 
 
1576
  case 39:
 
1577
#line 142 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1578
    { (yyval.expr) = new MultiplyExpr(std::vector<Expr_ptr>(
 
1579
        {Expr_ptr((yyvsp[-2].expr)), Expr_ptr((yyvsp[0].expr))}));}
 
1580
#line 1581 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1581
    break;
 
1582
 
 
1583
  case 40:
 
1584
#line 144 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1585
    { (yyval.expr) = (yyvsp[0].expr);}
 
1586
#line 1587 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1587
    break;
 
1588
 
 
1589
  case 41:
 
1590
#line 148 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1505
1591
    { (yyval.expr) = (yyvsp[-1].expr);}
1506
 
#line 1507 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1592
#line 1593 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1507
1593
    break;
1508
1594
 
1509
 
  case 35:
1510
 
#line 109 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1595
  case 42:
 
1596
#line 149 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1511
1597
    { (yyval.expr) = new LiteralExpr(atol((yyvsp[0].string)->c_str()));
1512
1598
        delete (yyvsp[0].string);}
1513
 
#line 1514 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1599
#line 1600 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1514
1600
    break;
1515
1601
 
1516
 
  case 36:
1517
 
#line 111 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
 
1602
  case 43:
 
1603
#line 151 "PetriEngine/PQL/PQLQueryParser.y" /* yacc.c:1646  */
1518
1604
    { (yyval.expr) = new IdentifierExpr(*(yyvsp[0].string));
1519
1605
        delete (yyvsp[0].string);}
1520
 
#line 1521 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1606
#line 1607 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1521
1607
    break;
1522
1608
 
1523
1609
 
1524
 
#line 1525 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
 
1610
#line 1611 "PetriEngine/PQL/PQLQueryParser.parser.cpp" /* yacc.c:1646  */
1525
1611
      default: break;
1526
1612
    }
1527
1613
  /* User semantic actions sometimes alter yychar, and that requires