···

       
817
       
 
       
# FLATZINC

     

       
818
       
 
       
#

     

       
819
       
 
       


     

       
820
       
-
       
FLATZINCSRC0 = flatzinc.cpp registry.cpp branch.cpp lastval.cpp

     

       
821
       
 
       
FLATZINC_GENSRC0 = parser.tab.cpp lexer.yy.cpp

     

       
822
       
 
       
FLATZINCHDR0 = ast.hh conexpr.hh option.hh parser.hh \

     

       
823
       
 
       
	plugin.hh registry.hh symboltable.hh varspec.hh \

     

       
824
       
-
       
	branch.hh branch.hpp lastval.hh

     

       
825
       
 
       


     

       
826
       
 
       
FLATZINCSRC = $(FLATZINCSRC0:%=gecode/flatzinc/%)

     

       
827
       
 
       
FLATZINC_GENSRC = $(FLATZINC_GENSRC0:%=gecode/flatzinc/%)

     

···

       
817
       
 
       
# FLATZINC

     

       
818
       
 
       
#

     

       
819
       
 
       


     

       
820
       
+
       
FLATZINCSRC0 = flatzinc.cpp registry.cpp branch.cpp lastval.cpp complete.cpp

     

       
821
       
 
       
FLATZINC_GENSRC0 = parser.tab.cpp lexer.yy.cpp

     

       
822
       
 
       
FLATZINCHDR0 = ast.hh conexpr.hh option.hh parser.hh \

     

       
823
       
 
       
	plugin.hh registry.hh symboltable.hh varspec.hh \

     

       
824
       
+
       
	branch.hh branch.hpp lastval.hh complete.hh

     

       
825
       
 
       


     

       
826
       
 
       
FLATZINCSRC = $(FLATZINCSRC0:%=gecode/flatzinc/%)

     

       
827
       
 
       
FLATZINC_GENSRC = $(FLATZINC_GENSRC0:%=gecode/flatzinc/%)

     

···

       
69
       
 
       
[DESCRIPTION]

     

       
70
       
 
       
Let's see.

     

       
71
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
72
       
 
       
[RELEASE]

     

       
73
       
 
       
Version: 6.3.0

     

       
74
       
 
       
Date: 2020-??-??

     

···

       
69
       
 
       
[DESCRIPTION]

     

       
70
       
 
       
Let's see.

     

       
71
       
 
       


     

       
72
       
+
       
[ENTRY]

     

       
73
       
+
       
Module: search 

     

       
74
       
+
       
What:   new

     

       
75
       
+
       
Rank:   minor

     

       
76
       
+
       
Thanks: Jip J. Dekker

     

       
77
       
+
       
[DESCRIPTION]

     

       
78
       
+
       
Add RestartStop class to enforce a limit on the amount of restarts conducted

     

       
79
       
+
       
in a search. RestartStop is included in CombinedStop and accessible from the

     

       
80
       
+
       
FlatZinc interface through the --restart-limit flag.

     

       
81
       
+
       


     

       
82
       
 
       
[RELEASE]

     

       
83
       
 
       
Version: 6.3.0

     

       
84
       
 
       
Date: 2020-??-??

     

···

       
440
       
 
       
    Driver::StringOption      _restart;       ///< Restart method option

     

       
441
       
 
       
    Driver::DoubleOption      _r_base;        ///< Restart base

     

       
442
       
 
       
    Driver::UnsignedIntOption _r_scale;       ///< Restart scale factor

     

       
0
       
 
       

     

       
0
       
 
       

     

       
443
       
 
       
    Driver::BoolOption        _nogoods;       ///< Whether to use no-goods

     

       
444
       
 
       
    Driver::UnsignedIntOption _nogoods_limit; ///< Limit for no-good extraction

     

       
445
       
 
       
    Driver::DoubleOption      _relax;         ///< Probability to relax variable

     
···

       
590
       
 
       
    void restart_scale(unsigned int scale);

     

       
591
       
 
       
    /// Return restart scale factor

     

       
592
       
 
       
    unsigned int restart_scale(void) const;

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
593
       
 
       


     

       
594
       
 
       
    /// Set default nogoods posting behavior

     

       
595
       
 
       
    void nogoods(bool b);

     

···

       
440
       
 
       
    Driver::StringOption      _restart;       ///< Restart method option

     

       
441
       
 
       
    Driver::DoubleOption      _r_base;        ///< Restart base

     

       
442
       
 
       
    Driver::UnsignedIntOption _r_scale;       ///< Restart scale factor

     

       
443
       
+
       
    Driver::UnsignedLongLongIntOption

     

       
444
       
+
       
                              _r_limit;       ///< Cutoff for number of restarts 

     

       
445
       
 
       
    Driver::BoolOption        _nogoods;       ///< Whether to use no-goods

     

       
446
       
 
       
    Driver::UnsignedIntOption _nogoods_limit; ///< Limit for no-good extraction

     

       
447
       
 
       
    Driver::DoubleOption      _relax;         ///< Probability to relax variable

     
···

       
592
       
 
       
    void restart_scale(unsigned int scale);

     

       
593
       
 
       
    /// Return restart scale factor

     

       
594
       
 
       
    unsigned int restart_scale(void) const;

     

       
595
       
+
       


     

       
596
       
+
       
    /// Set default restart cutoff

     

       
597
       
+
       
    void restart_limit(unsigned long long int n);

     

       
598
       
+
       
    /// Return restart cutoff

     

       
599
       
+
       
    unsigned long long int restart_limit(void) const;

     

       
600
       
 
       


     

       
601
       
 
       
    /// Set default nogoods posting behavior

     

       
602
       
 
       
    void nogoods(bool b);

     

···

       
637
       
 
       
              Search::Config::base),

     

       
638
       
 
       
      _r_scale("restart-scale","scale factor for restart sequence",

     

       
639
       
 
       
               Search::Config::slice),

     

       
0
       
 
       

     

       
640
       
 
       
      _nogoods("nogoods","whether to use no-goods from restarts",false),

     

       
641
       
 
       
      _nogoods_limit("nogoods-limit","depth limit for no-good extraction",

     

       
642
       
 
       
                     Search::Config::nogoods_limit),

     
···

       
679
       
 
       
    add(_d_l);

     

       
680
       
 
       
    add(_node); add(_fail); add(_time); add(_interrupt);

     

       
681
       
 
       
    add(_assets); add(_slice);

     

       
682
       
-
       
    add(_restart); add(_r_base); add(_r_scale);

     

       
683
       
 
       
    add(_nogoods); add(_nogoods_limit);

     

       
684
       
 
       
    add(_relax);

     

       
685
       
 
       
    add(_mode); add(_iterations); add(_samples); add(_print_last);

     

···

       
637
       
 
       
              Search::Config::base),

     

       
638
       
 
       
      _r_scale("restart-scale","scale factor for restart sequence",

     

       
639
       
 
       
               Search::Config::slice),

     

       
640
       
+
       
      _r_limit("restart-limit","restart cutoff (0 = none, solution mode)"),

     

       
641
       
 
       
      _nogoods("nogoods","whether to use no-goods from restarts",false),

     

       
642
       
 
       
      _nogoods_limit("nogoods-limit","depth limit for no-good extraction",

     

       
643
       
 
       
                     Search::Config::nogoods_limit),

     
···

       
680
       
 
       
    add(_d_l);

     

       
681
       
 
       
    add(_node); add(_fail); add(_time); add(_interrupt);

     

       
682
       
 
       
    add(_assets); add(_slice);

     

       
683
       
+
       
    add(_restart); add(_r_base); add(_r_scale); add(_r_limit);

     

       
684
       
 
       
    add(_nogoods); add(_nogoods_limit);

     

       
685
       
 
       
    add(_relax);

     

       
686
       
 
       
    add(_mode); add(_iterations); add(_samples); add(_print_last);

     

···

       
426
       
 
       
  }

     

       
427
       
 
       


     

       
428
       
 
       
  inline void

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
429
       
 
       
  Options::nogoods(bool b) {

     

       
430
       
 
       
    _nogoods.value(b);

     

       
431
       
 
       
  }

     

···

       
426
       
 
       
  }

     

       
427
       
 
       


     

       
428
       
 
       
  inline void

     

       
429
       
+
       
  Options::restart_limit(unsigned long long int n) {

     

       
430
       
+
       
    _r_limit.value(n);

     

       
431
       
+
       
  }

     

       
432
       
+
       
  inline unsigned long long int

     

       
433
       
+
       
  Options::restart_limit(void) const {

     

       
434
       
+
       
    return _r_limit.value();

     

       
435
       
+
       
  }

     

       
436
       
+
       


     

       
437
       
+
       
  inline void

     

       
438
       
 
       
  Options::nogoods(bool b) {

     

       
439
       
 
       
    _nogoods.value(b);

     

       
440
       
 
       
  }

     

···

       
52
       
 
       
    Search::NodeStop* ns; ///< Used node stop object

     

       
53
       
 
       
    Search::FailStop* fs; ///< Used fail stop object

     

       
54
       
 
       
    Search::TimeStop* ts; ///< Used time stop object

     

       
0
       
 
       

     

       
55
       
 
       
    GECODE_DRIVER_EXPORT

     

       
56
       
 
       
    static bool sigint;   ///< Whether search was interrupted using Ctrl-C

     

       
57
       
 
       
    /// Initialize stop object

     

       
58
       
 
       
    CombinedStop(unsigned long long int node,

     

       
59
       
 
       
                 unsigned long long int fail,

     

       
60
       
-
       
                 double time)

     

       
0
       
 
       

     

       
61
       
 
       
      : ns((node > 0ULL) ? new Search::NodeStop(node) : nullptr),

     

       
62
       
 
       
        fs((fail > 0ULL) ? new Search::FailStop(fail) : nullptr),

     

       
63
       
-
       
        ts((time > 0.0)  ? new Search::TimeStop(time) : nullptr) {

     

       
0
       
 
       

     

       
64
       
 
       
      sigint = false;

     

       
65
       
 
       
    }

     

       
66
       
 
       
  public:

     
···

       
69
       
 
       
      SR_NODE = 1 << 0, ///< Node limit reached

     

       
70
       
 
       
      SR_FAIL = 1 << 1, ///< Fail limit reached

     

       
71
       
 
       
      SR_TIME = 1 << 2, ///< Time limit reached

     

       
72
       
-
       
      SR_INT  = 1 << 3  ///< Interrupted by user

     

       
0
       
 
       

     

       
73
       
 
       
    };

     

       
74
       
 
       
    /// Test whether search must be stopped

     

       
75
       
 
       
    virtual bool stop(const Search::Statistics& s, const Search::Options& o) {

     
···

       
77
       
 
       
        sigint ||

     

       
78
       
 
       
        ((ns != nullptr) && ns->stop(s,o)) ||

     

       
79
       
 
       
        ((fs != nullptr) && fs->stop(s,o)) ||

     

       
80
       
-
       
        ((ts != nullptr) && ts->stop(s,o));

     

       
0
       
 
       

     

       
81
       
 
       
    }

     

       
82
       
 
       
    /// Report reason why search has been stopped

     

       
83
       
 
       
    int reason(const Search::Statistics& s, const Search::Options& o) {

     
···

       
85
       
 
       
        (((ns != nullptr) && ns->stop(s,o)) ? SR_NODE : 0) |

     

       
86
       
 
       
        (((fs != nullptr) && fs->stop(s,o)) ? SR_FAIL : 0) |

     

       
87
       
 
       
        (((ts != nullptr) && ts->stop(s,o)) ? SR_TIME : 0) |

     

       
0
       
 
       

     

       
88
       
 
       
        (sigint                          ? SR_INT  : 0);

     

       
89
       
 
       
    }

     

       
90
       
 
       
    /// Create appropriate stop-object

     
···

       
92
       
 
       
    create(unsigned long long int node,

     

       
93
       
 
       
           unsigned long long int fail,

     

       
94
       
 
       
           double time,

     

       
0
       
 
       

     

       
95
       
 
       
           bool intr) {

     

       
96
       
-
       
      if (!intr && (node == 0ULL) && (fail == 0ULL) && (time == 0.0))

     

       
97
       
 
       
        return nullptr;

     

       
98
       
 
       
      else

     

       
99
       
-
       
        return new CombinedStop(node,fail,time);

     

       
100
       
 
       
    }

     

       
101
       
 
       
#ifdef GECODE_THREADS_WINDOWS

     

       
102
       
 
       
    /// Handler for catching Ctrl-C

     
···

       
128
       
 
       
    }

     

       
129
       
 
       
    /// Destructor

     

       
130
       
 
       
    ~CombinedStop(void) {

     

       
131
       
-
       
      delete ns; delete fs; delete ts;

     

       
132
       
 
       
    }

     

       
133
       
 
       
  };

     

       
134
       
 
       


     
···

       
378
       
 
       
          so.d_l     = o.d_l();

     

       
379
       
 
       
          so.assets  = o.assets();

     

       
380
       
 
       
          so.slice   = o.slice();

     

       
381
       
-
       
          so.stop    = CombinedStop::create(o.node(),o.fail(), o.time(),

     

       
382
       
 
       
                                            o.interrupt());

     

       
383
       
 
       
          so.cutoff  = createCutoff(o);

     

       
384
       
 
       
          so.clone   = false;

     
···

       
430
       
 
       
                  l_out << "fail ";

     

       
431
       
 
       
                if (r & CombinedStop::SR_TIME)

     

       
432
       
 
       
                  l_out << "time ";

     

       
0
       
 
       

     

       
0
       
 
       

     

       
433
       
 
       
                l_out << "limit reached" << endl << endl;

     

       
434
       
 
       
              }

     

       
435
       
 
       
            }

     
···

       
479
       
 
       
          so.c_d     = o.c_d();

     

       
480
       
 
       
          so.a_d     = o.a_d();

     

       
481
       
 
       
          so.d_l     = o.d_l();

     

       
482
       
-
       
          so.stop    = CombinedStop::create(o.node(),o.fail(), o.time(),

     

       
483
       
 
       
                                            o.interrupt());

     

       
484
       
 
       
          so.cutoff  = createCutoff(o);

     

       
485
       
 
       
          so.nogoods_limit = o.nogoods() ? o.nogoods_limit() : 0U;

     
···

       
541
       
 
       
              sok.c_d     = o.c_d();

     

       
542
       
 
       
              sok.a_d     = o.a_d();

     

       
543
       
 
       
              sok.d_l     = o.d_l();

     

       
544
       
-
       
              sok.stop    = CombinedStop::create(o.node(),o.fail(), o.time(),

     

       
545
       
 
       
                                                 false);

     

       
546
       
 
       
              sok.cutoff  = createCutoff(o);

     

       
547
       
 
       
              sok.nogoods_limit = o.nogoods() ? o.nogoods_limit() : 0U;

     

···

       
52
       
 
       
    Search::NodeStop* ns; ///< Used node stop object

     

       
53
       
 
       
    Search::FailStop* fs; ///< Used fail stop object

     

       
54
       
 
       
    Search::TimeStop* ts; ///< Used time stop object

     

       
55
       
+
       
    Search::RestartStop* rs; ///< Used restart stop object

     

       
56
       
 
       
    GECODE_DRIVER_EXPORT

     

       
57
       
 
       
    static bool sigint;   ///< Whether search was interrupted using Ctrl-C

     

       
58
       
 
       
    /// Initialize stop object

     

       
59
       
 
       
    CombinedStop(unsigned long long int node,

     

       
60
       
 
       
                 unsigned long long int fail,

     

       
61
       
+
       
                 double time,

     

       
62
       
+
       
                 unsigned long long int restart)

     

       
63
       
 
       
      : ns((node > 0ULL) ? new Search::NodeStop(node) : nullptr),

     

       
64
       
 
       
        fs((fail > 0ULL) ? new Search::FailStop(fail) : nullptr),

     

       
65
       
+
       
        ts((time > 0.0)  ? new Search::TimeStop(time) : nullptr),

     

       
66
       
+
       
        rs((restart > 0.0) ? new Search::RestartStop(restart) : nullptr) {

     

       
67
       
 
       
      sigint = false;

     

       
68
       
 
       
    }

     

       
69
       
 
       
  public:

     
···

       
72
       
 
       
      SR_NODE = 1 << 0, ///< Node limit reached

     

       
73
       
 
       
      SR_FAIL = 1 << 1, ///< Fail limit reached

     

       
74
       
 
       
      SR_TIME = 1 << 2, ///< Time limit reached

     

       
75
       
+
       
      SR_RESTART = 1 << 3, ///< Time limit reached

     

       
76
       
+
       
      SR_INT  = 1 << 4  ///< Interrupted by user

     

       
77
       
 
       
    };

     

       
78
       
 
       
    /// Test whether search must be stopped

     

       
79
       
 
       
    virtual bool stop(const Search::Statistics& s, const Search::Options& o) {

     
···

       
81
       
 
       
        sigint ||

     

       
82
       
 
       
        ((ns != nullptr) && ns->stop(s,o)) ||

     

       
83
       
 
       
        ((fs != nullptr) && fs->stop(s,o)) ||

     

       
84
       
+
       
        ((ts != nullptr) && ts->stop(s,o)) ||

     

       
85
       
+
       
        ((rs != nullptr) && rs->stop(s,o));

     

       
86
       
 
       
    }

     

       
87
       
 
       
    /// Report reason why search has been stopped

     

       
88
       
 
       
    int reason(const Search::Statistics& s, const Search::Options& o) {

     
···

       
90
       
 
       
        (((ns != nullptr) && ns->stop(s,o)) ? SR_NODE : 0) |

     

       
91
       
 
       
        (((fs != nullptr) && fs->stop(s,o)) ? SR_FAIL : 0) |

     

       
92
       
 
       
        (((ts != nullptr) && ts->stop(s,o)) ? SR_TIME : 0) |

     

       
93
       
+
       
        (((rs != nullptr) && rs->stop(s,o)) ? SR_RESTART : 0) |

     

       
94
       
 
       
        (sigint                          ? SR_INT  : 0);

     

       
95
       
 
       
    }

     

       
96
       
 
       
    /// Create appropriate stop-object

     
···

       
98
       
 
       
    create(unsigned long long int node,

     

       
99
       
 
       
           unsigned long long int fail,

     

       
100
       
 
       
           double time,

     

       
101
       
+
       
					 unsigned long long int restart,

     

       
102
       
 
       
           bool intr) {

     

       
103
       
+
       
      if (!intr && (node == 0ULL) && (fail == 0ULL) && (time == 0.0) && (restart == 0ULL))

     

       
104
       
 
       
        return nullptr;

     

       
105
       
 
       
      else

     

       
106
       
+
       
        return new CombinedStop(node,fail,time,restart);

     

       
107
       
 
       
    }

     

       
108
       
 
       
#ifdef GECODE_THREADS_WINDOWS

     

       
109
       
 
       
    /// Handler for catching Ctrl-C

     
···

       
135
       
 
       
    }

     

       
136
       
 
       
    /// Destructor

     

       
137
       
 
       
    ~CombinedStop(void) {

     

       
138
       
+
       
      delete ns; delete fs; delete ts; delete rs;

     

       
139
       
 
       
    }

     

       
140
       
 
       
  };

     

       
141
       
 
       


     
···

       
385
       
 
       
          so.d_l     = o.d_l();

     

       
386
       
 
       
          so.assets  = o.assets();

     

       
387
       
 
       
          so.slice   = o.slice();

     

       
388
       
+
       
          so.stop    = CombinedStop::create(o.node(),o.fail(), o.time(), o.restart_limit(),

     

       
389
       
 
       
                                            o.interrupt());

     

       
390
       
 
       
          so.cutoff  = createCutoff(o);

     

       
391
       
 
       
          so.clone   = false;

     
···

       
437
       
 
       
                  l_out << "fail ";

     

       
438
       
 
       
                if (r & CombinedStop::SR_TIME)

     

       
439
       
 
       
                  l_out << "time ";

     

       
440
       
+
       
                if (r & CombinedStop::SR_RESTART)

     

       
441
       
+
       
                  l_out << "restart ";

     

       
442
       
 
       
                l_out << "limit reached" << endl << endl;

     

       
443
       
 
       
              }

     

       
444
       
 
       
            }

     
···

       
488
       
 
       
          so.c_d     = o.c_d();

     

       
489
       
 
       
          so.a_d     = o.a_d();

     

       
490
       
 
       
          so.d_l     = o.d_l();

     

       
491
       
+
       
          so.stop    = CombinedStop::create(o.node(),o.fail(), o.time(), o.restart_limit(),

     

       
492
       
 
       
                                            o.interrupt());

     

       
493
       
 
       
          so.cutoff  = createCutoff(o);

     

       
494
       
 
       
          so.nogoods_limit = o.nogoods() ? o.nogoods_limit() : 0U;

     
···

       
550
       
 
       
              sok.c_d     = o.c_d();

     

       
551
       
 
       
              sok.a_d     = o.a_d();

     

       
552
       
 
       
              sok.d_l     = o.d_l();

     

       
553
       
+
       
              sok.stop    = CombinedStop::create(o.node(),o.fail(), o.time(), o.restart_limit(),

     

       
554
       
 
       
                                                 false);

     

       
555
       
 
       
              sok.cutoff  = createCutoff(o);

     

       
556
       
 
       
              sok.nogoods_limit = o.nogoods() ? o.nogoods_limit() : 0U;

     

···

       
244
       
 
       
      Gecode::Driver::StringOption      _restart;   ///< Restart method option

     

       
245
       
 
       
      Gecode::Driver::DoubleOption      _r_base;    ///< Restart base

     

       
246
       
 
       
      Gecode::Driver::UnsignedIntOption _r_scale;   ///< Restart scale factor

     

       
0
       
 
       

     

       
247
       
 
       
      Gecode::Driver::BoolOption        _nogoods;   ///< Whether to use no-goods

     

       
248
       
 
       
      Gecode::Driver::UnsignedIntOption _nogoods_limit; ///< Depth limit for extracting no-goods

     

       
249
       
 
       
      Gecode::Driver::BoolOption        _interrupt; ///< Whether to catch SIGINT

     
···

       
281
       
 
       
      _restart("restart","restart sequence type",RM_NONE),

     

       
282
       
 
       
      _r_base("restart-base","base for geometric restart sequence",1.5),

     

       
283
       
 
       
      _r_scale("restart-scale","scale factor for restart sequence",250),

     

       
0
       
 
       

     

       
284
       
 
       
      _nogoods("nogoods","whether to use no-goods from restarts",false),

     

       
285
       
 
       
      _nogoods_limit("nogoods-limit","depth limit for no-good extraction",

     

       
286
       
 
       
                     Search::Config::nogoods_limit),

     
···

       
312
       
 
       
      add(_node); add(_fail); add(_time); add(_time_limit); add(_interrupt);

     

       
313
       
 
       
      add(_seed);

     

       
314
       
 
       
      add(_step);

     

       
315
       
-
       
      add(_restart); add(_r_base); add(_r_scale);

     

       
316
       
 
       
      add(_nogoods); add(_nogoods_limit);

     

       
317
       
 
       
      add(_mode); add(_stat);

     

       
318
       
 
       
      add(_output);

     
···

       
368
       
 
       
    void restart_base(double d) { _r_base.value(d); }

     

       
369
       
 
       
    unsigned int restart_scale(void) const { return _r_scale.value(); }

     

       
370
       
 
       
    void restart_scale(int i) { _r_scale.value(i); }

     

       
0
       
 
       

     

       
371
       
 
       
    bool nogoods(void) const { return _nogoods.value(); }

     

       
372
       
 
       
    unsigned int nogoods_limit(void) const { return _nogoods_limit.value(); }

     

       
373
       
 
       
    bool interrupt(void) const { return _interrupt.value(); }

     
···

       
482
       
 
       
    /// The integer variables used in LNS

     

       
483
       
 
       
    Gecode::IntVarArray iv_lns;

     

       
484
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
485
       
 
       
    /// Status() variable

     

       
486
       
 
       
    Gecode::IntVarArray restart_status;

     

       
487
       
 
       
    /// int_uniform arguments

     

···

       
244
       
 
       
      Gecode::Driver::StringOption      _restart;   ///< Restart method option

     

       
245
       
 
       
      Gecode::Driver::DoubleOption      _r_base;    ///< Restart base

     

       
246
       
 
       
      Gecode::Driver::UnsignedIntOption _r_scale;   ///< Restart scale factor

     

       
247
       
+
       
      Gecode::Driver::UnsignedLongLongIntOption _r_limit; ///< Cutoff for number of restarts 

     

       
248
       
 
       
      Gecode::Driver::BoolOption        _nogoods;   ///< Whether to use no-goods

     

       
249
       
 
       
      Gecode::Driver::UnsignedIntOption _nogoods_limit; ///< Depth limit for extracting no-goods

     

       
250
       
 
       
      Gecode::Driver::BoolOption        _interrupt; ///< Whether to catch SIGINT

     
···

       
282
       
 
       
      _restart("restart","restart sequence type",RM_NONE),

     

       
283
       
 
       
      _r_base("restart-base","base for geometric restart sequence",1.5),

     

       
284
       
 
       
      _r_scale("restart-scale","scale factor for restart sequence",250),

     

       
285
       
+
       
      _r_limit("restart-limit","restart cutoff (0 = none, solution mode)"),

     

       
286
       
 
       
      _nogoods("nogoods","whether to use no-goods from restarts",false),

     

       
287
       
 
       
      _nogoods_limit("nogoods-limit","depth limit for no-good extraction",

     

       
288
       
 
       
                     Search::Config::nogoods_limit),

     
···

       
314
       
 
       
      add(_node); add(_fail); add(_time); add(_time_limit); add(_interrupt);

     

       
315
       
 
       
      add(_seed);

     

       
316
       
 
       
      add(_step);

     

       
317
       
+
       
      add(_restart); add(_r_base); add(_r_scale); add(_r_limit);

     

       
318
       
 
       
      add(_nogoods); add(_nogoods_limit);

     

       
319
       
 
       
      add(_mode); add(_stat);

     

       
320
       
 
       
      add(_output);

     
···

       
370
       
 
       
    void restart_base(double d) { _r_base.value(d); }

     

       
371
       
 
       
    unsigned int restart_scale(void) const { return _r_scale.value(); }

     

       
372
       
 
       
    void restart_scale(int i) { _r_scale.value(i); }

     

       
373
       
+
       
    unsigned long long int restart_limit(void) const { return _r_limit.value(); }

     

       
374
       
 
       
    bool nogoods(void) const { return _nogoods.value(); }

     

       
375
       
 
       
    unsigned int nogoods_limit(void) const { return _nogoods_limit.value(); }

     

       
376
       
 
       
    bool interrupt(void) const { return _interrupt.value(); }

     
···

       
485
       
 
       
    /// The integer variables used in LNS

     

       
486
       
 
       
    Gecode::IntVarArray iv_lns;

     

       
487
       
 
       


     

       
488
       
+
       
    /// Complete() variable

     

       
489
       
+
       
    Gecode::BoolVarArray restart_complete;

     

       
490
       
+
       
		std::shared_ptr<bool> complete_marker;

     

       
491
       
 
       
    /// Status() variable

     

       
492
       
 
       
    Gecode::IntVarArray restart_status;

     

       
493
       
 
       
    /// int_uniform arguments

     

···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */

     

       
2
       
+
       
/*

     

       
3
       
+
       
 *  Main authors:

     

       
4
       
+
       
 *     Jip J. Dekker <jip.dekker@monash.edu>

     

       
5
       
+
       
 *

     

       
6
       
+
       
 *  Copyright:

     

       
7
       
+
       
 *     Jip J. Dekker, 2018

     

       
8
       
+
       
 *

     

       
9
       
+
       
 *  This file is part of Gecode, the generic constraint

     

       
10
       
+
       
 *  development environment:

     

       
11
       
+
       
 *     http://www.gecode.org

     

       
12
       
+
       
 *

     

       
13
       
+
       
 *  Permission is hereby granted, free of charge, to any person obtaining

     

       
14
       
+
       
 *  a copy of this software and associated documentation files (the

     

       
15
       
+
       
 *  "Software"), to deal in the Software without restriction, including

     

       
16
       
+
       
 *  without limitation the rights to use, copy, modify, merge, publish,

     

       
17
       
+
       
 *  distribute, sublicense, and/or sell copies of the Software, and to

     

       
18
       
+
       
 *  permit persons to whom the Software is furnished to do so, subject to

     

       
19
       
+
       
 *  the following conditions:

     

       
20
       
+
       
 *

     

       
21
       
+
       
 *  The above copyright notice and this permission notice shall be

     

       
22
       
+
       
 *  included in all copies or substantial portions of the Software.

     

       
23
       
+
       
 *

     

       
24
       
+
       
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

     

       
25
       
+
       
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

     

       
26
       
+
       
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

     

       
27
       
+
       
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

     

       
28
       
+
       
 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

     

       
29
       
+
       
 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

     

       
30
       
+
       
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

     

       
31
       
+
       
 *

     

       
32
       
+
       
 */

     

       
33
       
+
       


     

       
34
       
+
       
#include "complete.hh"

     

       
35
       
+
       


     

       
36
       
+
       
namespace Gecode { namespace FlatZinc {

     

       
37
       
+
       


     

       
38
       
+
       


     

       
39
       
+
       
  Complete::Complete(Space &home, Complete &p)

     

       
40
       
+
       
  : UnaryPropagator<BoolView, PC_BOOL_VAL>(home,p), c(p.c) {}

     

       
41
       
+
       


     

       
42
       
+
       
  Complete::Complete(Home home, BoolView x0, std::shared_ptr<bool> c)

     

       
43
       
+
       
      : c(c), UnaryPropagator<BoolView, PC_BOOL_VAL>(home, x0) {}

     

       
44
       
+
       


     

       
45
       
+
       
  Actor* Complete::copy(Space &home) {

     

       
46
       
+
       
    return new (home) Complete(home,*this);

     

       
47
       
+
       
  }

     

       
48
       
+
       


     

       
49
       
+
       
  PropCost Complete::cost(const Space &home, const ModEventDelta &med) const {

     

       
50
       
+
       
    return PropCost::record();

     

       
51
       
+
       
  }

     

       
52
       
+
       


     

       
53
       
+
       
  ExecStatus Complete::propagate(Space &home, const ModEventDelta &med) {

     

       
54
       
+
       
    assert(x0.assigned());

     

       
55
       
+
       
    (*c) = x0.val();

     

       
56
       
+
       
		return ES_FAILED;

     

       
57
       
+
       
  }

     

       
58
       
+
       


     

       
59
       
+
       
  ExecStatus Complete::post(Home home, BoolView x0, std::shared_ptr<bool> c) {

     

       
60
       
+
       
		assert(c != nullptr);

     

       
61
       
+
       
    if (x0.assigned()) {

     

       
62
       
+
       
      (*c) = x0.val();

     

       
63
       
+
       
    } else {

     

       
64
       
+
       
      (void) new (home) Complete(home, x0, c);

     

       
65
       
+
       
    }

     

       
66
       
+
       
    return ES_OK;

     

       
67
       
+
       
  }

     

       
68
       
+
       


     

       
69
       
+
       


     

       
70
       
+
       
}}

     

···

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

···

       
1
       
+
       
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */

     

       
2
       
+
       
/*

     

       
3
       
+
       
 *  Main authors:

     

       
4
       
+
       
 *     Jip J. Dekker <jip.dekker@monash.edu>

     

       
5
       
+
       
 *

     

       
6
       
+
       
 *  Copyright:

     

       
7
       
+
       
 *     Jip J. Dekker, 2018

     

       
8
       
+
       
 *

     

       
9
       
+
       
 *  This file is part of Gecode, the generic constraint

     

       
10
       
+
       
 *  development environment:

     

       
11
       
+
       
 *     http://www.gecode.org

     

       
12
       
+
       
 *

     

       
13
       
+
       
 *  Permission is hereby granted, free of charge, to any person obtaining

     

       
14
       
+
       
 *  a copy of this software and associated documentation files (the

     

       
15
       
+
       
 *  "Software"), to deal in the Software without restriction, including

     

       
16
       
+
       
 *  without limitation the rights to use, copy, modify, merge, publish,

     

       
17
       
+
       
 *  distribute, sublicense, and/or sell copies of the Software, and to

     

       
18
       
+
       
 *  permit persons to whom the Software is furnished to do so, subject to

     

       
19
       
+
       
 *  the following conditions:

     

       
20
       
+
       
 *

     

       
21
       
+
       
 *  The above copyright notice and this permission notice shall be

     

       
22
       
+
       
 *  included in all copies or substantial portions of the Software.

     

       
23
       
+
       
 *

     

       
24
       
+
       
 *  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,

     

       
25
       
+
       
 *  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF

     

       
26
       
+
       
 *  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND

     

       
27
       
+
       
 *  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE

     

       
28
       
+
       
 *  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION

     

       
29
       
+
       
 *  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION

     

       
30
       
+
       
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

     

       
31
       
+
       
 *

     

       
32
       
+
       
 */

     

       
33
       
+
       


     

       
34
       
+
       
#ifndef __FLATZINC_COMPLETE_HH__

     

       
35
       
+
       
#define __FLATZINC_COMPLETE_HH__

     

       
36
       
+
       


     

       
37
       
+
       
#include <gecode/int.hh>

     

       
38
       
+
       
#include <memory>

     

       
39
       
+
       
using namespace Gecode::Int;

     

       
40
       
+
       


     

       
41
       
+
       
namespace Gecode { namespace FlatZinc {

     

       
42
       
+
       


     

       
43
       
+
       
  class Complete : public UnaryPropagator<BoolView, PC_BOOL_VAL> {

     

       
44
       
+
       
  protected:

     

       
45
       
+
       
    using UnaryPropagator<BoolView,PC_BOOL_VAL>::x0;

     

       
46
       
+
       
    std::shared_ptr<bool> c;

     

       
47
       
+
       


     

       
48
       
+
       
    /// Constructor for cloning \a p

     

       
49
       
+
       
    Complete(Space& home, Complete& p);

     

       
50
       
+
       
    /// Constructor for posting

     

       
51
       
+
       
    Complete(Home home, BoolView x0, std::shared_ptr<bool> c);

     

       
52
       
+
       
  public:

     

       
53
       
+
       
    /// Copy propagator during cloning

     

       
54
       
+
       
    virtual Actor* copy(Space& home);

     

       
55
       
+
       
    /// Cost function (defined as TODO)

     

       
56
       
+
       
    virtual PropCost cost(const Space& home, const ModEventDelta& med) const;

     

       
57
       
+
       
    /// Perform propagation

     

       
58
       
+
       
    virtual ExecStatus propagate(Space& home, const ModEventDelta& med);

     

       
59
       
+
       


     

       
60
       
+
       
    static ExecStatus post(Home home, BoolView x0, std::shared_ptr<bool> c);

     

       
61
       
+
       
  };

     

       
62
       
+
       


     

       
63
       
+
       
}}

     

       
64
       
+
       


     

       
65
       
+
       
#endif //__FLATZINC_COMPLETE_HH__

     

···

       
790
       
 
       
      iv_lns.update(*this, f.iv_lns);

     

       
791
       
 
       
      intVarCount = f.intVarCount;

     

       
792
       
 
       


     

       
0
       
 
       

     

       
793
       
 
       
      restart_status.update(*this, f.restart_status);

     

       
794
       
 
       
      int_uniform_var.update(*this, f.int_uniform_var);

     

       
795
       
 
       
      int_uniform_lb = f.int_uniform_lb;

     
···

       
1847
       
 
       
      n_p = PropagatorGroup::all.size(*this);

     

       
1848
       
 
       
    }

     

       
1849
       
 
       
    Search::Options o;

     

       
1850
       
-
       
    o.stop = Driver::CombinedStop::create(opt.node(), opt.fail(), opt.time(),

     

       
1851
       
 
       
                                          true);

     

       
1852
       
 
       
    o.c_d = opt.c_d();

     

       
1853
       
 
       
    o.a_d = opt.a_d();

     
···

       
2012
       
 
       
  bool

     

       
2013
       
 
       
  FlatZincSpace::slave(const MetaInfo& mi) {

     

       
2014
       
 
       
    if (mi.type() == MetaInfo::RESTART) {

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2015
       
 
       
      bool ret = false;

     

       
2016
       
 
       
      if (restart_status.size() > 0) {

     

       
2017
       
 
       
        assert(restart_status.size() == 1);

     

       
2018
       
-
       
        if (!mi.last()) {

     

       
2019
       
-
       
          rel(*this, restart_status[0], IRT_EQ, 1); // 1: START

     

       
2020
       
-
       
        } else if (mi.solution() > 0) {

     

       
2021
       
-
       
          rel(*this, restart_status[0], IRT_EQ, 4); // 4: SAT

     

       
2022
       
-
       
        } else {

     

       
2023
       
-
       
          rel(*this, restart_status[0], IRT_EQ, 2); // 2: UNKNOWN

     

       
2024
       
-
       
        }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
2025
       
 
       
        restart_status = IntVarArray(*this, 0);

     

       
2026
       
 
       
        ret = true;

     

       
2027
       
 
       
      }

     

···

       
790
       
 
       
      iv_lns.update(*this, f.iv_lns);

     

       
791
       
 
       
      intVarCount = f.intVarCount;

     

       
792
       
 
       


     

       
793
       
+
       
      restart_complete.update(*this, f.restart_complete);

     

       
794
       
 
       
      restart_status.update(*this, f.restart_status);

     

       
795
       
 
       
      int_uniform_var.update(*this, f.int_uniform_var);

     

       
796
       
 
       
      int_uniform_lb = f.int_uniform_lb;

     
···

       
1848
       
 
       
      n_p = PropagatorGroup::all.size(*this);

     

       
1849
       
 
       
    }

     

       
1850
       
 
       
    Search::Options o;

     

       
1851
       
+
       
    o.stop = Driver::CombinedStop::create(opt.node(), opt.fail(), opt.time(), opt.restart_limit(),

     

       
1852
       
 
       
                                          true);

     

       
1853
       
 
       
    o.c_d = opt.c_d();

     

       
1854
       
 
       
    o.a_d = opt.a_d();

     
···

       
2013
       
 
       
  bool

     

       
2014
       
 
       
  FlatZincSpace::slave(const MetaInfo& mi) {

     

       
2015
       
 
       
    if (mi.type() == MetaInfo::RESTART) {

     

       
2016
       
+
       
			if (restart_complete.size() > 0) {

     

       
2017
       
+
       
				assert(restart_complete.size() == 1);

     

       
2018
       
+
       
				assert(complete_marker != nullptr);

     

       
2019
       
+
       
				if (*complete_marker) {

     

       
2020
       
+
       
					// Fail the space

     

       
2021
       
+
       
					this->fail();

     

       
2022
       
+
       
					// Return true to signal we are in the global search space

     

       
2023
       
+
       
					return true;

     

       
2024
       
+
       
				}

     

       
2025
       
+
       
			}

     

       
2026
       
+
       


     

       
2027
       
 
       
      bool ret = false;

     

       
2028
       
 
       
      if (restart_status.size() > 0) {

     

       
2029
       
 
       
        assert(restart_status.size() == 1);

     

       
2030
       
+
       
				switch(mi.reason()) {

     

       
2031
       
+
       
					case MetaInfo::RR_INIT:

     

       
2032
       
+
       
						assert(!mi.last());

     

       
2033
       
+
       
						rel(*this, restart_status[0], IRT_EQ, 1); // 1: START

     

       
2034
       
+
       
						break;

     

       
2035
       
+
       
					case MetaInfo::RR_SOL:

     

       
2036
       
+
       
						assert(mi.solution() > 0);

     

       
2037
       
+
       
						rel(*this, restart_status[0], IRT_EQ, 4); // 4: SAT

     

       
2038
       
+
       
						break;

     

       
2039
       
+
       
					case MetaInfo::RR_CMPL:

     

       
2040
       
+
       
						rel(*this, restart_status[0], IRT_EQ, 3); // 3: UNSAT

     

       
2041
       
+
       
						break;

     

       
2042
       
+
       
					default:

     

       
2043
       
+
       
						assert(mi.reason() == MetaInfo::RR_LIM);

     

       
2044
       
+
       
						rel(*this, restart_status[0], IRT_EQ, 2); // 2: UNKNOWN

     

       
2045
       
+
       
						break;

     

       
2046
       
+
       
				}

     

       
2047
       
 
       
        restart_status = IntVarArray(*this, 0);

     

       
2048
       
 
       
        ret = true;

     

       
2049
       
 
       
      }

     

···

       
597
       
 
       
#define yymore() yymore_used_but_not_detected

     

       
598
       
 
       
#define YY_MORE_ADJ 0

     

       
599
       
 
       
#define YY_RESTORE_YY_MORE_OFFSET

     

       
600
       
-
       
#line 1 "../gecode/flatzinc/lexer.lxx"

     

       
601
       
 
       
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */

     

       
602
       
 
       
/*

     

       
603
       
 
       
 *  Main authors:

     
···

       
630
       
 
       
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

     

       
631
       
 
       
 *

     

       
632
       
 
       
 */

     

       
633
       
-
       
#line 40 "../gecode/flatzinc/lexer.lxx"

     

       
634
       
 
       
#if defined __GNUC__

     

       
635
       
 
       
#pragma GCC diagnostic ignored "-Wunused-function"

     

       
636
       
 
       
#pragma GCC diagnostic ignored "-Wunused-parameter"

     
···

       
939
       
 
       
		}

     

       
940
       
 
       


     

       
941
       
 
       
	{

     

       
942
       
-
       
#line 75 "../gecode/flatzinc/lexer.lxx"

     

       
943
       
 
       


     

       
944
       
 
       


     

       
945
       
 
       
#line 945 "gecode/flatzinc/lexer.yy.cpp"

     
···

       
1014
       
 
       
case 1:

     

       
1015
       
 
       
/* rule 1 can match eol */

     

       
1016
       
 
       
YY_RULE_SETUP

     

       
1017
       
-
       
#line 77 "../gecode/flatzinc/lexer.lxx"

     

       
1018
       
 
       
{ /*yylineno++;*/ /* ignore EOL */ }

     

       
1019
       
 
       
	YY_BREAK

     

       
1020
       
 
       
case 2:

     

       
1021
       
 
       
YY_RULE_SETUP

     

       
1022
       
-
       
#line 78 "../gecode/flatzinc/lexer.lxx"

     

       
1023
       
 
       
{ /* ignore whitespace */ }

     

       
1024
       
 
       
	YY_BREAK

     

       
1025
       
 
       
case 3:

     

       
1026
       
 
       
YY_RULE_SETUP

     

       
1027
       
-
       
#line 79 "../gecode/flatzinc/lexer.lxx"

     

       
1028
       
 
       
{ /* ignore comments */ }

     

       
1029
       
 
       
	YY_BREAK

     

       
1030
       
 
       
case 4:

     

       
1031
       
 
       
YY_RULE_SETUP

     

       
1032
       
-
       
#line 81 "../gecode/flatzinc/lexer.lxx"

     

       
1033
       
 
       
{ yylval->iValue = 1; return FZ_BOOL_LIT; }

     

       
1034
       
 
       
	YY_BREAK

     

       
1035
       
 
       
case 5:

     

       
1036
       
 
       
YY_RULE_SETUP

     

       
1037
       
-
       
#line 82 "../gecode/flatzinc/lexer.lxx"

     

       
1038
       
 
       
{ yylval->iValue = 0; return FZ_BOOL_LIT; }

     

       
1039
       
 
       
	YY_BREAK

     

       
1040
       
 
       
case 6:

     

       
1041
       
 
       
YY_RULE_SETUP

     

       
1042
       
-
       
#line 83 "../gecode/flatzinc/lexer.lxx"

     

       
1043
       
 
       
{ if (parseInt(yytext,yylval->iValue))

     

       
1044
       
 
       
                      return FZ_INT_LIT;

     

       
1045
       
 
       
                    else

     
···

       
1052
       
 
       
	YY_BREAK

     

       
1053
       
 
       
case 7:

     

       
1054
       
 
       
YY_RULE_SETUP

     

       
1055
       
-
       
#line 92 "../gecode/flatzinc/lexer.lxx"

     

       
1056
       
 
       
{  if (parseInt(yytext,yylval->iValue))

     

       
1057
       
 
       
                      return FZ_INT_LIT;

     

       
1058
       
 
       
                    else

     
···

       
1065
       
 
       
	YY_BREAK

     

       
1066
       
 
       
case 8:

     

       
1067
       
 
       
YY_RULE_SETUP

     

       
1068
       
-
       
#line 101 "../gecode/flatzinc/lexer.lxx"

     

       
1069
       
 
       
{ if (parseInt(yytext,yylval->iValue))

     

       
1070
       
 
       
                      return FZ_INT_LIT;

     

       
1071
       
 
       
                    else

     
···

       
1078
       
 
       
	YY_BREAK

     

       
1079
       
 
       
case 9:

     

       
1080
       
 
       
YY_RULE_SETUP

     

       
1081
       
-
       
#line 110 "../gecode/flatzinc/lexer.lxx"

     

       
1082
       
 
       
{ yylval->dValue = strtod(yytext,NULL);

     

       
1083
       
 
       
                    return FZ_FLOAT_LIT; }

     

       
1084
       
 
       
	YY_BREAK

     

       
1085
       
 
       
case 10:

     

       
1086
       
 
       
YY_RULE_SETUP

     

       
1087
       
-
       
#line 112 "../gecode/flatzinc/lexer.lxx"

     

       
1088
       
 
       
{ yylval->dValue = strtod(yytext,NULL);

     

       
1089
       
 
       
                                   return FZ_FLOAT_LIT; }

     

       
1090
       
 
       
	YY_BREAK

     

       
1091
       
 
       
case 11:

     

       
1092
       
 
       
YY_RULE_SETUP

     

       
1093
       
-
       
#line 114 "../gecode/flatzinc/lexer.lxx"

     

       
1094
       
 
       
{ yylval->dValue = strtod(yytext,NULL);

     

       
1095
       
 
       
                           return FZ_FLOAT_LIT; }

     

       
1096
       
 
       
	YY_BREAK

     

       
1097
       
 
       
case 12:

     

       
1098
       
 
       
YY_RULE_SETUP

     

       
1099
       
-
       
#line 116 "../gecode/flatzinc/lexer.lxx"

     

       
1100
       
 
       
{ return *yytext; }

     

       
1101
       
 
       
	YY_BREAK

     

       
1102
       
 
       
case 13:

     

       
1103
       
 
       
YY_RULE_SETUP

     

       
1104
       
-
       
#line 117 "../gecode/flatzinc/lexer.lxx"

     

       
1105
       
 
       
{ return FZ_DOTDOT; }

     

       
1106
       
 
       
	YY_BREAK

     

       
1107
       
 
       
case 14:

     

       
1108
       
 
       
YY_RULE_SETUP

     

       
1109
       
-
       
#line 118 "../gecode/flatzinc/lexer.lxx"

     

       
1110
       
 
       
{ return FZ_COLONCOLON; }

     

       
1111
       
 
       
	YY_BREAK

     

       
1112
       
 
       
case 15:

     

       
1113
       
 
       
YY_RULE_SETUP

     

       
1114
       
-
       
#line 119 "../gecode/flatzinc/lexer.lxx"

     

       
1115
       
 
       
{ return FZ_ANNOTATION; }

     

       
1116
       
 
       
	YY_BREAK

     

       
1117
       
 
       
case 16:

     

       
1118
       
 
       
YY_RULE_SETUP

     

       
1119
       
-
       
#line 120 "../gecode/flatzinc/lexer.lxx"

     

       
1120
       
 
       
{ return FZ_ANY; }

     

       
1121
       
 
       
	YY_BREAK

     

       
1122
       
 
       
case 17:

     

       
1123
       
 
       
YY_RULE_SETUP

     

       
1124
       
-
       
#line 121 "../gecode/flatzinc/lexer.lxx"

     

       
1125
       
 
       
{ return FZ_ARRAY; }

     

       
1126
       
 
       
	YY_BREAK

     

       
1127
       
 
       
case 18:

     

       
1128
       
 
       
YY_RULE_SETUP

     

       
1129
       
-
       
#line 122 "../gecode/flatzinc/lexer.lxx"

     

       
1130
       
 
       
{ return FZ_BOOL; }

     

       
1131
       
 
       
	YY_BREAK

     

       
1132
       
 
       
case 19:

     

       
1133
       
 
       
YY_RULE_SETUP

     

       
1134
       
-
       
#line 123 "../gecode/flatzinc/lexer.lxx"

     

       
1135
       
 
       
{ return FZ_CASE; }

     

       
1136
       
 
       
	YY_BREAK

     

       
1137
       
 
       
case 20:

     

       
1138
       
 
       
YY_RULE_SETUP

     

       
1139
       
-
       
#line 124 "../gecode/flatzinc/lexer.lxx"

     

       
1140
       
 
       
{ return FZ_CONSTRAINT; }

     

       
1141
       
 
       
	YY_BREAK

     

       
1142
       
 
       
case 21:

     

       
1143
       
 
       
YY_RULE_SETUP

     

       
1144
       
-
       
#line 125 "../gecode/flatzinc/lexer.lxx"

     

       
1145
       
 
       
{ return FZ_DEFAULT; }

     

       
1146
       
 
       
	YY_BREAK

     

       
1147
       
 
       
case 22:

     

       
1148
       
 
       
YY_RULE_SETUP

     

       
1149
       
-
       
#line 126 "../gecode/flatzinc/lexer.lxx"

     

       
1150
       
 
       
{ return FZ_ELSE; }

     

       
1151
       
 
       
	YY_BREAK

     

       
1152
       
 
       
case 23:

     

       
1153
       
 
       
YY_RULE_SETUP

     

       
1154
       
-
       
#line 127 "../gecode/flatzinc/lexer.lxx"

     

       
1155
       
 
       
{ return FZ_ELSEIF; }

     

       
1156
       
 
       
	YY_BREAK

     

       
1157
       
 
       
case 24:

     

       
1158
       
 
       
YY_RULE_SETUP

     

       
1159
       
-
       
#line 128 "../gecode/flatzinc/lexer.lxx"

     

       
1160
       
 
       
{ return FZ_ENDIF; }

     

       
1161
       
 
       
	YY_BREAK

     

       
1162
       
 
       
case 25:

     

       
1163
       
 
       
YY_RULE_SETUP

     

       
1164
       
-
       
#line 129 "../gecode/flatzinc/lexer.lxx"

     

       
1165
       
 
       
{ return FZ_ENUM; }

     

       
1166
       
 
       
	YY_BREAK

     

       
1167
       
 
       
case 26:

     

       
1168
       
 
       
YY_RULE_SETUP

     

       
1169
       
-
       
#line 130 "../gecode/flatzinc/lexer.lxx"

     

       
1170
       
 
       
{ return FZ_FLOAT; }

     

       
1171
       
 
       
	YY_BREAK

     

       
1172
       
 
       
case 27:

     

       
1173
       
 
       
YY_RULE_SETUP

     

       
1174
       
-
       
#line 131 "../gecode/flatzinc/lexer.lxx"

     

       
1175
       
 
       
{ return FZ_FUNCTION; }

     

       
1176
       
 
       
	YY_BREAK

     

       
1177
       
 
       
case 28:

     

       
1178
       
 
       
YY_RULE_SETUP

     

       
1179
       
-
       
#line 132 "../gecode/flatzinc/lexer.lxx"

     

       
1180
       
 
       
{ return FZ_IF; }

     

       
1181
       
 
       
	YY_BREAK

     

       
1182
       
 
       
case 29:

     

       
1183
       
 
       
YY_RULE_SETUP

     

       
1184
       
-
       
#line 133 "../gecode/flatzinc/lexer.lxx"

     

       
1185
       
 
       
{ return FZ_INCLUDE; }

     

       
1186
       
 
       
	YY_BREAK

     

       
1187
       
 
       
case 30:

     

       
1188
       
 
       
YY_RULE_SETUP

     

       
1189
       
-
       
#line 134 "../gecode/flatzinc/lexer.lxx"

     

       
1190
       
 
       
{ return FZ_INT; }

     

       
1191
       
 
       
	YY_BREAK

     

       
1192
       
 
       
case 31:

     

       
1193
       
 
       
YY_RULE_SETUP

     

       
1194
       
-
       
#line 135 "../gecode/flatzinc/lexer.lxx"

     

       
1195
       
 
       
{ return FZ_LET; }

     

       
1196
       
 
       
	YY_BREAK

     

       
1197
       
 
       
case 32:

     

       
1198
       
 
       
YY_RULE_SETUP

     

       
1199
       
-
       
#line 136 "../gecode/flatzinc/lexer.lxx"

     

       
1200
       
 
       
{ yylval->bValue = false; return FZ_MAXIMIZE; }

     

       
1201
       
 
       
	YY_BREAK

     

       
1202
       
 
       
case 33:

     

       
1203
       
 
       
YY_RULE_SETUP

     

       
1204
       
-
       
#line 137 "../gecode/flatzinc/lexer.lxx"

     

       
1205
       
 
       
{ yylval->bValue = true; return FZ_MINIMIZE; }

     

       
1206
       
 
       
	YY_BREAK

     

       
1207
       
 
       
case 34:

     

       
1208
       
 
       
YY_RULE_SETUP

     

       
1209
       
-
       
#line 138 "../gecode/flatzinc/lexer.lxx"

     

       
1210
       
 
       
{ return FZ_OF; }

     

       
1211
       
 
       
	YY_BREAK

     

       
1212
       
 
       
case 35:

     

       
1213
       
 
       
YY_RULE_SETUP

     

       
1214
       
-
       
#line 139 "../gecode/flatzinc/lexer.lxx"

     

       
1215
       
 
       
{ return FZ_SATISFY; }

     

       
1216
       
 
       
	YY_BREAK

     

       
1217
       
 
       
case 36:

     

       
1218
       
 
       
YY_RULE_SETUP

     

       
1219
       
-
       
#line 140 "../gecode/flatzinc/lexer.lxx"

     

       
1220
       
 
       
{ return FZ_OUTPUT; }

     

       
1221
       
 
       
	YY_BREAK

     

       
1222
       
 
       
case 37:

     

       
1223
       
 
       
YY_RULE_SETUP

     

       
1224
       
-
       
#line 141 "../gecode/flatzinc/lexer.lxx"

     

       
1225
       
 
       
{ yylval->bValue = false; return FZ_PAR; }

     

       
1226
       
 
       
	YY_BREAK

     

       
1227
       
 
       
case 38:

     

       
1228
       
 
       
YY_RULE_SETUP

     

       
1229
       
-
       
#line 142 "../gecode/flatzinc/lexer.lxx"

     

       
1230
       
 
       
{ return FZ_PREDICATE; }

     

       
1231
       
 
       
	YY_BREAK

     

       
1232
       
 
       
case 39:

     

       
1233
       
 
       
YY_RULE_SETUP

     

       
1234
       
-
       
#line 143 "../gecode/flatzinc/lexer.lxx"

     

       
1235
       
 
       
{ return FZ_RECORD; }

     

       
1236
       
 
       
	YY_BREAK

     

       
1237
       
 
       
case 40:

     

       
1238
       
 
       
YY_RULE_SETUP

     

       
1239
       
-
       
#line 144 "../gecode/flatzinc/lexer.lxx"

     

       
1240
       
 
       
{ return FZ_SET; }

     

       
1241
       
 
       
	YY_BREAK

     

       
1242
       
 
       
case 41:

     

       
1243
       
 
       
YY_RULE_SETUP

     

       
1244
       
-
       
#line 145 "../gecode/flatzinc/lexer.lxx"

     

       
1245
       
 
       
{ return FZ_SHOWCOND; }

     

       
1246
       
 
       
	YY_BREAK

     

       
1247
       
 
       
case 42:

     

       
1248
       
 
       
YY_RULE_SETUP

     

       
1249
       
-
       
#line 146 "../gecode/flatzinc/lexer.lxx"

     

       
1250
       
 
       
{ return FZ_SHOW; }

     

       
1251
       
 
       
	YY_BREAK

     

       
1252
       
 
       
case 43:

     

       
1253
       
 
       
YY_RULE_SETUP

     

       
1254
       
-
       
#line 147 "../gecode/flatzinc/lexer.lxx"

     

       
1255
       
 
       
{ return FZ_SOLVE; }

     

       
1256
       
 
       
	YY_BREAK

     

       
1257
       
 
       
case 44:

     

       
1258
       
 
       
YY_RULE_SETUP

     

       
1259
       
-
       
#line 148 "../gecode/flatzinc/lexer.lxx"

     

       
1260
       
 
       
{ return FZ_STRING; }

     

       
1261
       
 
       
	YY_BREAK

     

       
1262
       
 
       
case 45:

     

       
1263
       
 
       
YY_RULE_SETUP

     

       
1264
       
-
       
#line 149 "../gecode/flatzinc/lexer.lxx"

     

       
1265
       
 
       
{ return FZ_TEST; }

     

       
1266
       
 
       
	YY_BREAK

     

       
1267
       
 
       
case 46:

     

       
1268
       
 
       
YY_RULE_SETUP

     

       
1269
       
-
       
#line 150 "../gecode/flatzinc/lexer.lxx"

     

       
1270
       
 
       
{ return FZ_THEN; }

     

       
1271
       
 
       
	YY_BREAK

     

       
1272
       
 
       
case 47:

     

       
1273
       
 
       
YY_RULE_SETUP

     

       
1274
       
-
       
#line 151 "../gecode/flatzinc/lexer.lxx"

     

       
1275
       
 
       
{ return FZ_TUPLE; }

     

       
1276
       
 
       
	YY_BREAK

     

       
1277
       
 
       
case 48:

     

       
1278
       
 
       
YY_RULE_SETUP

     

       
1279
       
-
       
#line 152 "../gecode/flatzinc/lexer.lxx"

     

       
1280
       
 
       
{ return FZ_TYPE; }

     

       
1281
       
 
       
	YY_BREAK

     

       
1282
       
 
       
case 49:

     

       
1283
       
 
       
YY_RULE_SETUP

     

       
1284
       
-
       
#line 153 "../gecode/flatzinc/lexer.lxx"

     

       
1285
       
 
       
{ yylval->bValue = true; return FZ_VAR; }

     

       
1286
       
 
       
	YY_BREAK

     

       
1287
       
 
       
case 50:

     

       
1288
       
 
       
YY_RULE_SETUP

     

       
1289
       
-
       
#line 154 "../gecode/flatzinc/lexer.lxx"

     

       
1290
       
 
       
{ return FZ_VARIANT_RECORD; }

     

       
1291
       
 
       
	YY_BREAK

     

       
1292
       
 
       
case 51:

     

       
1293
       
 
       
YY_RULE_SETUP

     

       
1294
       
-
       
#line 155 "../gecode/flatzinc/lexer.lxx"

     

       
1295
       
 
       
{ return FZ_WHERE; }

     

       
1296
       
 
       
	YY_BREAK

     

       
1297
       
 
       
case 52:

     

       
1298
       
 
       
YY_RULE_SETUP

     

       
1299
       
-
       
#line 156 "../gecode/flatzinc/lexer.lxx"

     

       
1300
       
 
       
{ yylval->sValue = strdup(yytext); return FZ_ID; }

     

       
1301
       
 
       
	YY_BREAK

     

       
1302
       
 
       
case 53:

     

       
1303
       
 
       
YY_RULE_SETUP

     

       
1304
       
-
       
#line 157 "../gecode/flatzinc/lexer.lxx"

     

       
1305
       
 
       
{ yylval->sValue = strdup(yytext); return FZ_U_ID; }

     

       
1306
       
 
       
	YY_BREAK

     

       
1307
       
 
       
case 54:

     

       
1308
       
 
       
YY_RULE_SETUP

     

       
1309
       
-
       
#line 158 "../gecode/flatzinc/lexer.lxx"

     

       
1310
       
 
       
{

     

       
1311
       
 
       
                    yylval->sValue = strdup(yytext+1);

     

       
1312
       
 
       
                    yylval->sValue[strlen(yytext)-2] = 0;

     
···

       
1314
       
 
       
	YY_BREAK

     

       
1315
       
 
       
case 55:

     

       
1316
       
 
       
YY_RULE_SETUP

     

       
1317
       
-
       
#line 162 "../gecode/flatzinc/lexer.lxx"

     

       
1318
       
 
       
{ yyerror("Unknown character"); }

     

       
1319
       
 
       
	YY_BREAK

     

       
1320
       
 
       
case 56:

     

       
1321
       
 
       
YY_RULE_SETUP

     

       
1322
       
-
       
#line 163 "../gecode/flatzinc/lexer.lxx"

     

       
1323
       
 
       
ECHO;

     

       
1324
       
 
       
	YY_BREAK

     

       
1325
       
 
       
#line 1325 "gecode/flatzinc/lexer.yy.cpp"

     
···

       
2514
       
 
       


     

       
2515
       
 
       
#define YYTABLES_NAME "yytables"

     

       
2516
       
 
       


     

       
2517
       
-
       
#line 163 "../gecode/flatzinc/lexer.lxx"

     

       
2518
       
 
       


     

       
2519
       
 
       
int yy_input_proc(char* buf, int size, yyscan_t yyscanner) {

     

       
2520
       
 
       
  Gecode::FlatZinc::ParserState* parm =

     

···

       
597
       
 
       
#define yymore() yymore_used_but_not_detected

     

       
598
       
 
       
#define YY_MORE_ADJ 0

     

       
599
       
 
       
#define YY_RESTORE_YY_MORE_OFFSET

     

       
600
       
+
       
#line 1 "gecode/flatzinc/lexer.lxx"

     

       
601
       
 
       
/* -*- mode: C++; c-basic-offset: 2; indent-tabs-mode: nil -*- */

     

       
602
       
 
       
/*

     

       
603
       
 
       
 *  Main authors:

     
···

       
630
       
 
       
 *  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

     

       
631
       
 
       
 *

     

       
632
       
 
       
 */

     

       
633
       
+
       
#line 40 "gecode/flatzinc/lexer.lxx"

     

       
634
       
 
       
#if defined __GNUC__

     

       
635
       
 
       
#pragma GCC diagnostic ignored "-Wunused-function"

     

       
636
       
 
       
#pragma GCC diagnostic ignored "-Wunused-parameter"

     
···

       
939
       
 
       
		}

     

       
940
       
 
       


     

       
941
       
 
       
	{

     

       
942
       
+
       
#line 75 "gecode/flatzinc/lexer.lxx"

     

       
943
       
 
       


     

       
944
       
 
       


     

       
945
       
 
       
#line 945 "gecode/flatzinc/lexer.yy.cpp"

     
···

       
1014
       
 
       
case 1:

     

       
1015
       
 
       
/* rule 1 can match eol */

     

       
1016
       
 
       
YY_RULE_SETUP

     

       
1017
       
+
       
#line 77 "gecode/flatzinc/lexer.lxx"

     

       
1018
       
 
       
{ /*yylineno++;*/ /* ignore EOL */ }

     

       
1019
       
 
       
	YY_BREAK

     

       
1020
       
 
       
case 2:

     

       
1021
       
 
       
YY_RULE_SETUP

     

       
1022
       
+
       
#line 78 "gecode/flatzinc/lexer.lxx"

     

       
1023
       
 
       
{ /* ignore whitespace */ }

     

       
1024
       
 
       
	YY_BREAK

     

       
1025
       
 
       
case 3:

     

       
1026
       
 
       
YY_RULE_SETUP

     

       
1027
       
+
       
#line 79 "gecode/flatzinc/lexer.lxx"

     

       
1028
       
 
       
{ /* ignore comments */ }

     

       
1029
       
 
       
	YY_BREAK

     

       
1030
       
 
       
case 4:

     

       
1031
       
 
       
YY_RULE_SETUP

     

       
1032
       
+
       
#line 81 "gecode/flatzinc/lexer.lxx"

     

       
1033
       
 
       
{ yylval->iValue = 1; return FZ_BOOL_LIT; }

     

       
1034
       
 
       
	YY_BREAK

     

       
1035
       
 
       
case 5:

     

       
1036
       
 
       
YY_RULE_SETUP

     

       
1037
       
+
       
#line 82 "gecode/flatzinc/lexer.lxx"

     

       
1038
       
 
       
{ yylval->iValue = 0; return FZ_BOOL_LIT; }

     

       
1039
       
 
       
	YY_BREAK

     

       
1040
       
 
       
case 6:

     

       
1041
       
 
       
YY_RULE_SETUP

     

       
1042
       
+
       
#line 83 "gecode/flatzinc/lexer.lxx"

     

       
1043
       
 
       
{ if (parseInt(yytext,yylval->iValue))

     

       
1044
       
 
       
                      return FZ_INT_LIT;

     

       
1045
       
 
       
                    else

     
···

       
1052
       
 
       
	YY_BREAK

     

       
1053
       
 
       
case 7:

     

       
1054
       
 
       
YY_RULE_SETUP

     

       
1055
       
+
       
#line 92 "gecode/flatzinc/lexer.lxx"

     

       
1056
       
 
       
{  if (parseInt(yytext,yylval->iValue))

     

       
1057
       
 
       
                      return FZ_INT_LIT;

     

       
1058
       
 
       
                    else

     
···

       
1065
       
 
       
	YY_BREAK

     

       
1066
       
 
       
case 8:

     

       
1067
       
 
       
YY_RULE_SETUP

     

       
1068
       
+
       
#line 101 "gecode/flatzinc/lexer.lxx"

     

       
1069
       
 
       
{ if (parseInt(yytext,yylval->iValue))

     

       
1070
       
 
       
                      return FZ_INT_LIT;

     

       
1071
       
 
       
                    else

     
···

       
1078
       
 
       
	YY_BREAK

     

       
1079
       
 
       
case 9:

     

       
1080
       
 
       
YY_RULE_SETUP

     

       
1081
       
+
       
#line 110 "gecode/flatzinc/lexer.lxx"

     

       
1082
       
 
       
{ yylval->dValue = strtod(yytext,NULL);

     

       
1083
       
 
       
                    return FZ_FLOAT_LIT; }

     

       
1084
       
 
       
	YY_BREAK

     

       
1085
       
 
       
case 10:

     

       
1086
       
 
       
YY_RULE_SETUP

     

       
1087
       
+
       
#line 112 "gecode/flatzinc/lexer.lxx"

     

       
1088
       
 
       
{ yylval->dValue = strtod(yytext,NULL);

     

       
1089
       
 
       
                                   return FZ_FLOAT_LIT; }

     

       
1090
       
 
       
	YY_BREAK

     

       
1091
       
 
       
case 11:

     

       
1092
       
 
       
YY_RULE_SETUP

     

       
1093
       
+
       
#line 114 "gecode/flatzinc/lexer.lxx"

     

       
1094
       
 
       
{ yylval->dValue = strtod(yytext,NULL);

     

       
1095
       
 
       
                           return FZ_FLOAT_LIT; }

     

       
1096
       
 
       
	YY_BREAK

     

       
1097
       
 
       
case 12:

     

       
1098
       
 
       
YY_RULE_SETUP

     

       
1099
       
+
       
#line 116 "gecode/flatzinc/lexer.lxx"

     

       
1100
       
 
       
{ return *yytext; }

     

       
1101
       
 
       
	YY_BREAK

     

       
1102
       
 
       
case 13:

     

       
1103
       
 
       
YY_RULE_SETUP

     

       
1104
       
+
       
#line 117 "gecode/flatzinc/lexer.lxx"

     

       
1105
       
 
       
{ return FZ_DOTDOT; }

     

       
1106
       
 
       
	YY_BREAK

     

       
1107
       
 
       
case 14:

     

       
1108
       
 
       
YY_RULE_SETUP

     

       
1109
       
+
       
#line 118 "gecode/flatzinc/lexer.lxx"

     

       
1110
       
 
       
{ return FZ_COLONCOLON; }

     

       
1111
       
 
       
	YY_BREAK

     

       
1112
       
 
       
case 15:

     

       
1113
       
 
       
YY_RULE_SETUP

     

       
1114
       
+
       
#line 119 "gecode/flatzinc/lexer.lxx"

     

       
1115
       
 
       
{ return FZ_ANNOTATION; }

     

       
1116
       
 
       
	YY_BREAK

     

       
1117
       
 
       
case 16:

     

       
1118
       
 
       
YY_RULE_SETUP

     

       
1119
       
+
       
#line 120 "gecode/flatzinc/lexer.lxx"

     

       
1120
       
 
       
{ return FZ_ANY; }

     

       
1121
       
 
       
	YY_BREAK

     

       
1122
       
 
       
case 17:

     

       
1123
       
 
       
YY_RULE_SETUP

     

       
1124
       
+
       
#line 121 "gecode/flatzinc/lexer.lxx"

     

       
1125
       
 
       
{ return FZ_ARRAY; }

     

       
1126
       
 
       
	YY_BREAK

     

       
1127
       
 
       
case 18:

     

       
1128
       
 
       
YY_RULE_SETUP

     

       
1129
       
+
       
#line 122 "gecode/flatzinc/lexer.lxx"

     

       
1130
       
 
       
{ return FZ_BOOL; }

     

       
1131
       
 
       
	YY_BREAK

     

       
1132
       
 
       
case 19:

     

       
1133
       
 
       
YY_RULE_SETUP

     

       
1134
       
+
       
#line 123 "gecode/flatzinc/lexer.lxx"

     

       
1135
       
 
       
{ return FZ_CASE; }

     

       
1136
       
 
       
	YY_BREAK

     

       
1137
       
 
       
case 20:

     

       
1138
       
 
       
YY_RULE_SETUP

     

       
1139
       
+
       
#line 124 "gecode/flatzinc/lexer.lxx"

     

       
1140
       
 
       
{ return FZ_CONSTRAINT; }

     

       
1141
       
 
       
	YY_BREAK

     

       
1142
       
 
       
case 21:

     

       
1143
       
 
       
YY_RULE_SETUP

     

       
1144
       
+
       
#line 125 "gecode/flatzinc/lexer.lxx"

     

       
1145
       
 
       
{ return FZ_DEFAULT; }

     

       
1146
       
 
       
	YY_BREAK

     

       
1147
       
 
       
case 22:

     

       
1148
       
 
       
YY_RULE_SETUP

     

       
1149
       
+
       
#line 126 "gecode/flatzinc/lexer.lxx"

     

       
1150
       
 
       
{ return FZ_ELSE; }

     

       
1151
       
 
       
	YY_BREAK

     

       
1152
       
 
       
case 23:

     

       
1153
       
 
       
YY_RULE_SETUP

     

       
1154
       
+
       
#line 127 "gecode/flatzinc/lexer.lxx"

     

       
1155
       
 
       
{ return FZ_ELSEIF; }

     

       
1156
       
 
       
	YY_BREAK

     

       
1157
       
 
       
case 24:

     

       
1158
       
 
       
YY_RULE_SETUP

     

       
1159
       
+
       
#line 128 "gecode/flatzinc/lexer.lxx"

     

       
1160
       
 
       
{ return FZ_ENDIF; }

     

       
1161
       
 
       
	YY_BREAK

     

       
1162
       
 
       
case 25:

     

       
1163
       
 
       
YY_RULE_SETUP

     

       
1164
       
+
       
#line 129 "gecode/flatzinc/lexer.lxx"

     

       
1165
       
 
       
{ return FZ_ENUM; }

     

       
1166
       
 
       
	YY_BREAK

     

       
1167
       
 
       
case 26:

     

       
1168
       
 
       
YY_RULE_SETUP

     

       
1169
       
+
       
#line 130 "gecode/flatzinc/lexer.lxx"

     

       
1170
       
 
       
{ return FZ_FLOAT; }

     

       
1171
       
 
       
	YY_BREAK

     

       
1172
       
 
       
case 27:

     

       
1173
       
 
       
YY_RULE_SETUP

     

       
1174
       
+
       
#line 131 "gecode/flatzinc/lexer.lxx"

     

       
1175
       
 
       
{ return FZ_FUNCTION; }

     

       
1176
       
 
       
	YY_BREAK

     

       
1177
       
 
       
case 28:

     

       
1178
       
 
       
YY_RULE_SETUP

     

       
1179
       
+
       
#line 132 "gecode/flatzinc/lexer.lxx"

     

       
1180
       
 
       
{ return FZ_IF; }

     

       
1181
       
 
       
	YY_BREAK

     

       
1182
       
 
       
case 29:

     

       
1183
       
 
       
YY_RULE_SETUP

     

       
1184
       
+
       
#line 133 "gecode/flatzinc/lexer.lxx"

     

       
1185
       
 
       
{ return FZ_INCLUDE; }

     

       
1186
       
 
       
	YY_BREAK

     

       
1187
       
 
       
case 30:

     

       
1188
       
 
       
YY_RULE_SETUP

     

       
1189
       
+
       
#line 134 "gecode/flatzinc/lexer.lxx"

     

       
1190
       
 
       
{ return FZ_INT; }

     

       
1191
       
 
       
	YY_BREAK

     

       
1192
       
 
       
case 31:

     

       
1193
       
 
       
YY_RULE_SETUP

     

       
1194
       
+
       
#line 135 "gecode/flatzinc/lexer.lxx"

     

       
1195
       
 
       
{ return FZ_LET; }

     

       
1196
       
 
       
	YY_BREAK

     

       
1197
       
 
       
case 32:

     

       
1198
       
 
       
YY_RULE_SETUP

     

       
1199
       
+
       
#line 136 "gecode/flatzinc/lexer.lxx"

     

       
1200
       
 
       
{ yylval->bValue = false; return FZ_MAXIMIZE; }

     

       
1201
       
 
       
	YY_BREAK

     

       
1202
       
 
       
case 33:

     

       
1203
       
 
       
YY_RULE_SETUP

     

       
1204
       
+
       
#line 137 "gecode/flatzinc/lexer.lxx"

     

       
1205
       
 
       
{ yylval->bValue = true; return FZ_MINIMIZE; }

     

       
1206
       
 
       
	YY_BREAK

     

       
1207
       
 
       
case 34:

     

       
1208
       
 
       
YY_RULE_SETUP

     

       
1209
       
+
       
#line 138 "gecode/flatzinc/lexer.lxx"

     

       
1210
       
 
       
{ return FZ_OF; }

     

       
1211
       
 
       
	YY_BREAK

     

       
1212
       
 
       
case 35:

     

       
1213
       
 
       
YY_RULE_SETUP

     

       
1214
       
+
       
#line 139 "gecode/flatzinc/lexer.lxx"

     

       
1215
       
 
       
{ return FZ_SATISFY; }

     

       
1216
       
 
       
	YY_BREAK

     

       
1217
       
 
       
case 36:

     

       
1218
       
 
       
YY_RULE_SETUP

     

       
1219
       
+
       
#line 140 "gecode/flatzinc/lexer.lxx"

     

       
1220
       
 
       
{ return FZ_OUTPUT; }

     

       
1221
       
 
       
	YY_BREAK

     

       
1222
       
 
       
case 37:

     

       
1223
       
 
       
YY_RULE_SETUP

     

       
1224
       
+
       
#line 141 "gecode/flatzinc/lexer.lxx"

     

       
1225
       
 
       
{ yylval->bValue = false; return FZ_PAR; }

     

       
1226
       
 
       
	YY_BREAK

     

       
1227
       
 
       
case 38:

     

       
1228
       
 
       
YY_RULE_SETUP

     

       
1229
       
+
       
#line 142 "gecode/flatzinc/lexer.lxx"

     

       
1230
       
 
       
{ return FZ_PREDICATE; }

     

       
1231
       
 
       
	YY_BREAK

     

       
1232
       
 
       
case 39:

     

       
1233
       
 
       
YY_RULE_SETUP

     

       
1234
       
+
       
#line 143 "gecode/flatzinc/lexer.lxx"

     

       
1235
       
 
       
{ return FZ_RECORD; }

     

       
1236
       
 
       
	YY_BREAK

     

       
1237
       
 
       
case 40:

     

       
1238
       
 
       
YY_RULE_SETUP

     

       
1239
       
+
       
#line 144 "gecode/flatzinc/lexer.lxx"

     

       
1240
       
 
       
{ return FZ_SET; }

     

       
1241
       
 
       
	YY_BREAK

     

       
1242
       
 
       
case 41:

     

       
1243
       
 
       
YY_RULE_SETUP

     

       
1244
       
+
       
#line 145 "gecode/flatzinc/lexer.lxx"

     

       
1245
       
 
       
{ return FZ_SHOWCOND; }

     

       
1246
       
 
       
	YY_BREAK

     

       
1247
       
 
       
case 42:

     

       
1248
       
 
       
YY_RULE_SETUP

     

       
1249
       
+
       
#line 146 "gecode/flatzinc/lexer.lxx"

     

       
1250
       
 
       
{ return FZ_SHOW; }

     

       
1251
       
 
       
	YY_BREAK

     

       
1252
       
 
       
case 43:

     

       
1253
       
 
       
YY_RULE_SETUP

     

       
1254
       
+
       
#line 147 "gecode/flatzinc/lexer.lxx"

     

       
1255
       
 
       
{ return FZ_SOLVE; }

     

       
1256
       
 
       
	YY_BREAK

     

       
1257
       
 
       
case 44:

     

       
1258
       
 
       
YY_RULE_SETUP

     

       
1259
       
+
       
#line 148 "gecode/flatzinc/lexer.lxx"

     

       
1260
       
 
       
{ return FZ_STRING; }

     

       
1261
       
 
       
	YY_BREAK

     

       
1262
       
 
       
case 45:

     

       
1263
       
 
       
YY_RULE_SETUP

     

       
1264
       
+
       
#line 149 "gecode/flatzinc/lexer.lxx"

     

       
1265
       
 
       
{ return FZ_TEST; }

     

       
1266
       
 
       
	YY_BREAK

     

       
1267
       
 
       
case 46:

     

       
1268
       
 
       
YY_RULE_SETUP

     

       
1269
       
+
       
#line 150 "gecode/flatzinc/lexer.lxx"

     

       
1270
       
 
       
{ return FZ_THEN; }

     

       
1271
       
 
       
	YY_BREAK

     

       
1272
       
 
       
case 47:

     

       
1273
       
 
       
YY_RULE_SETUP

     

       
1274
       
+
       
#line 151 "gecode/flatzinc/lexer.lxx"

     

       
1275
       
 
       
{ return FZ_TUPLE; }

     

       
1276
       
 
       
	YY_BREAK

     

       
1277
       
 
       
case 48:

     

       
1278
       
 
       
YY_RULE_SETUP

     

       
1279
       
+
       
#line 152 "gecode/flatzinc/lexer.lxx"

     

       
1280
       
 
       
{ return FZ_TYPE; }

     

       
1281
       
 
       
	YY_BREAK

     

       
1282
       
 
       
case 49:

     

       
1283
       
 
       
YY_RULE_SETUP

     

       
1284
       
+
       
#line 153 "gecode/flatzinc/lexer.lxx"

     

       
1285
       
 
       
{ yylval->bValue = true; return FZ_VAR; }

     

       
1286
       
 
       
	YY_BREAK

     

       
1287
       
 
       
case 50:

     

       
1288
       
 
       
YY_RULE_SETUP

     

       
1289
       
+
       
#line 154 "gecode/flatzinc/lexer.lxx"

     

       
1290
       
 
       
{ return FZ_VARIANT_RECORD; }

     

       
1291
       
 
       
	YY_BREAK

     

       
1292
       
 
       
case 51:

     

       
1293
       
 
       
YY_RULE_SETUP

     

       
1294
       
+
       
#line 155 "gecode/flatzinc/lexer.lxx"

     

       
1295
       
 
       
{ return FZ_WHERE; }

     

       
1296
       
 
       
	YY_BREAK

     

       
1297
       
 
       
case 52:

     

       
1298
       
 
       
YY_RULE_SETUP

     

       
1299
       
+
       
#line 156 "gecode/flatzinc/lexer.lxx"

     

       
1300
       
 
       
{ yylval->sValue = strdup(yytext); return FZ_ID; }

     

       
1301
       
 
       
	YY_BREAK

     

       
1302
       
 
       
case 53:

     

       
1303
       
 
       
YY_RULE_SETUP

     

       
1304
       
+
       
#line 157 "gecode/flatzinc/lexer.lxx"

     

       
1305
       
 
       
{ yylval->sValue = strdup(yytext); return FZ_U_ID; }

     

       
1306
       
 
       
	YY_BREAK

     

       
1307
       
 
       
case 54:

     

       
1308
       
 
       
YY_RULE_SETUP

     

       
1309
       
+
       
#line 158 "gecode/flatzinc/lexer.lxx"

     

       
1310
       
 
       
{

     

       
1311
       
 
       
                    yylval->sValue = strdup(yytext+1);

     

       
1312
       
 
       
                    yylval->sValue[strlen(yytext)-2] = 0;

     
···

       
1314
       
 
       
	YY_BREAK

     

       
1315
       
 
       
case 55:

     

       
1316
       
 
       
YY_RULE_SETUP

     

       
1317
       
+
       
#line 162 "gecode/flatzinc/lexer.lxx"

     

       
1318
       
 
       
{ yyerror("Unknown character"); }

     

       
1319
       
 
       
	YY_BREAK

     

       
1320
       
 
       
case 56:

     

       
1321
       
 
       
YY_RULE_SETUP

     

       
1322
       
+
       
#line 163 "gecode/flatzinc/lexer.lxx"

     

       
1323
       
 
       
ECHO;

     

       
1324
       
 
       
	YY_BREAK

     

       
1325
       
 
       
#line 1325 "gecode/flatzinc/lexer.yy.cpp"

     
···

       
2514
       
 
       


     

       
2515
       
 
       
#define YYTABLES_NAME "yytables"

     

       
2516
       
 
       


     

       
2517
       
+
       
#line 163 "gecode/flatzinc/lexer.lxx"

     

       
2518
       
 
       


     

       
2519
       
 
       
int yy_input_proc(char* buf, int size, yyscan_t yyscanner) {

     

       
2520
       
 
       
  Gecode::FlatZinc::ParserState* parm =

     

···

       
213
       
 
       
    std::vector<ConExpr*> domainConstraints;

     

       
214
       
 
       


     

       
215
       
 
       
    int status_idx = -1;

     

       
0
       
 
       

     

       
216
       
 
       
    std::vector<std::array<int, 3>> int_uniform;

     

       
217
       
 
       
    std::vector<std::array<int, 2>> int_sol;

     

       
218
       
 
       
    std::vector<std::array<int, 2>> int_lastval;

     

···

       
213
       
 
       
    std::vector<ConExpr*> domainConstraints;

     

       
214
       
 
       


     

       
215
       
 
       
    int status_idx = -1;

     

       
216
       
+
       
    int complete_idx = -1;

     

       
217
       
 
       
    std::vector<std::array<int, 3>> int_uniform;

     

       
218
       
 
       
    std::vector<std::array<int, 2>> int_sol;

     

       
219
       
 
       
    std::vector<std::array<int, 2>> int_lastval;

     

···

       
1
       
-
       
/* A Bison parser, made by GNU Bison 3.7.2.  */

     

       
2
       
 
       


     

       
3
       
 
       
/* Bison implementation for Yacc-like parsers in C

     

       
4
       
 
       


     

       
5
       
-
       
   Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2020 Free Software Foundation,

     

       
6
       
 
       
   Inc.

     

       
7
       
 
       


     

       
8
       
 
       
   This program is free software: you can redistribute it and/or modify

     
···

       
16
       
 
       
   GNU General Public License for more details.

     

       
17
       
 
       


     

       
18
       
 
       
   You should have received a copy of the GNU General Public License

     

       
19
       
-
       
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */

     

       
20
       
 
       


     

       
21
       
 
       
/* As a special exception, you may create a larger work that contains

     

       
22
       
 
       
   part or all of the Bison parser skeleton and distribute that work

     
···

       
45
       
 
       
   define necessary library symbols; they are noted "INFRINGES ON

     

       
46
       
 
       
   USER NAME SPACE" below.  */

     

       
47
       
 
       


     

       
48
       
-
       
/* Identify Bison output.  */

     

       
49
       
-
       
#define YYBISON 1

     

       
50
       
 
       


     

       
51
       
-
       
/* Bison version.  */

     

       
52
       
-
       
#define YYBISON_VERSION "3.7.2"

     

       
53
       
 
       


     

       
54
       
 
       
/* Skeleton name.  */

     

       
55
       
 
       
#define YYSKELETON_NAME "yacc.c"

     
···

       
67
       
 
       


     

       
68
       
 
       


     

       
69
       
 
       
/* First part of user prologue.  */

     

       
70
       
-
       
#line 37 "../gecode/flatzinc/parser.yxx"

     

       
71
       
 
       


     

       
72
       
 
       
#define YYPARSE_PARAM parm

     

       
73
       
 
       
#define YYLEX_PARAM static_cast<ParserState*>(parm)->yyscanner

     

       
74
       
 
       
#include <gecode/flatzinc.hh>

     

       
75
       
 
       
#include <gecode/flatzinc/parser.hh>

     

       
76
       
 
       
#include <gecode/flatzinc/lastval.hh>

     

       
0
       
 
       

     

       
77
       
 
       
#include <iostream>

     

       
78
       
 
       
#include <fstream>

     

       
79
       
 
       


     
···

       
355
       
 
       
    pp->fg->restart_status = IntVarArray(*(pp->fg), 1);

     

       
356
       
 
       
    pp->fg->restart_status[0] = pp->fg->iv[pp->status_idx];

     

       
357
       
 
       
  }

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
358
       
 
       
  if (!(pp->int_uniform.empty())) {

     

       
359
       
 
       
    pp->fg->int_uniform_var = IntVarArray(*(pp->fg), pp->int_uniform.size());

     

       
360
       
 
       
    pp->fg->int_uniform_lb = new int[pp->int_uniform.size()];

     
···

       
532
       
 
       
}}

     

       
533
       
 
       


     

       
534
       
 
       


     

       
535
       
-
       
#line 536 "gecode/flatzinc/parser.tab.cpp"

     

       
536
       
 
       


     

       
537
       
 
       
# ifndef YY_CAST

     

       
538
       
 
       
#  ifdef __cplusplus

     
···

       
729
       
 
       
typedef short yytype_int16;

     

       
730
       
 
       
#endif

     

       
731
       
 
       


     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
732
       
 
       
#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__

     

       
733
       
 
       
typedef __UINT_LEAST8_TYPE__ yytype_uint8;

     

       
734
       
 
       
#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H \

     
···

       
826
       
 
       


     

       
827
       
 
       
/* Suppress unused-variable warnings by "using" E.  */

     

       
828
       
 
       
#if ! defined lint || defined __GNUC__

     

       
829
       
-
       
# define YYUSE(E) ((void) (E))

     

       
830
       
 
       
#else

     

       
831
       
-
       
# define YYUSE(E) /* empty */

     

       
832
       
 
       
#endif

     

       
833
       
 
       


     

       
834
       
 
       
#if defined __GNUC__ && ! defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__

     
···

       
1058
       
 
       
  /* YYRLINE[YYN] -- Source line where rule number YYN was defined.  */

     

       
1059
       
 
       
static const yytype_int16 yyrline[] =

     

       
1060
       
 
       
{

     

       
1061
       
-
       
       0,   604,   604,   606,   608,   611,   612,   614,   616,   619,

     

       
1062
       
-
       
     620,   622,   624,   627,   628,   635,   638,   640,   643,   644,

     

       
1063
       
-
       
     647,   651,   652,   653,   654,   657,   659,   661,   662,   665,

     

       
1064
       
-
       
     666,   669,   670,   676,   676,   679,   711,   743,   782,   815,

     

       
1065
       
-
       
     824,   834,   843,   855,   925,   991,  1062,  1130,  1151,  1171,

     

       
1066
       
-
       
    1191,  1214,  1218,  1233,  1257,  1258,  1262,  1264,  1267,  1267,

     

       
1067
       
-
       
    1269,  1273,  1275,  1290,  1313,  1314,  1318,  1320,  1324,  1328,

     

       
1068
       
-
       
    1330,  1345,  1368,  1369,  1373,  1375,  1378,  1381,  1383,  1398,

     

       
1069
       
-
       
    1421,  1422,  1426,  1428,  1431,  1436,  1437,  1442,  1443,  1448,

     

       
1070
       
-
       
    1449,  1454,  1455,  1459,  1583,  1597,  1622,  1624,  1626,  1632,

     

       
1071
       
-
       
    1634,  1647,  1649,  1658,  1660,  1667,  1668,  1672,  1674,  1679,

     

       
1072
       
-
       
    1680,  1684,  1686,  1691,  1692,  1696,  1698,  1703,  1704,  1708,

     

       
1073
       
-
       
    1710,  1718,  1720,  1724,  1726,  1731,  1732,  1736,  1738,  1740,

     

       
1074
       
-
       
    1742,  1744,  1840,  1855,  1856,  1860,  1862,  1870,  1904,  1911,

     

       
1075
       
-
       
    1918,  1944,  1945,  1953,  1954,  1958,  1960,  1964,  1968,  1972,

     

       
1076
       
-
       
    1974,  1978,  1980,  1982,  1985,  1985,  1988,  1990,  1992,  1994,

     

       
1077
       
-
       
    1996,  2102,  2113

     

       
1078
       
 
       
};

     

       
1079
       
 
       
#endif

     

       
1080
       
 
       


     
···

       
1252
       
 
       
  /* YYDEFGOTO[NTERM-NUM].  */

     

       
1253
       
 
       
static const yytype_int16 yydefgoto[] =

     

       
1254
       
 
       
{

     

       
1255
       
-
       
      -1,     2,     3,     4,    14,    15,    36,    37,     5,    48,

     

       
1256
       
 
       
      49,    50,    51,    52,   109,   110,   143,    16,   283,   284,

     

       
1257
       
 
       
     285,    83,   267,   293,   294,   295,   271,   288,   289,   290,

     

       
1258
       
 
       
     269,   323,   324,   325,   304,   256,   258,   260,   280,    38,

     
···

       
1507
       
 
       
                       yysymbol_kind_t yykind, YYSTYPE const * const yyvaluep, void *parm)

     

       
1508
       
 
       
{

     

       
1509
       
 
       
  FILE *yyoutput = yyo;

     

       
1510
       
-
       
  YYUSE (yyoutput);

     

       
1511
       
-
       
  YYUSE (parm);

     

       
1512
       
 
       
  if (!yyvaluep)

     

       
1513
       
 
       
    return;

     

       
1514
       
 
       
# ifdef YYPRINT

     
···

       
1516
       
 
       
    YYPRINT (yyo, yytoknum[yykind], *yyvaluep);

     

       
1517
       
 
       
# endif

     

       
1518
       
 
       
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

     

       
1519
       
-
       
  YYUSE (yykind);

     

       
1520
       
 
       
  YY_IGNORE_MAYBE_UNINITIALIZED_END

     

       
1521
       
 
       
}

     

       
1522
       
 
       


     
···

       
1897
       
 
       
yydestruct (const char *yymsg,

     

       
1898
       
 
       
            yysymbol_kind_t yykind, YYSTYPE *yyvaluep, void *parm)

     

       
1899
       
 
       
{

     

       
1900
       
-
       
  YYUSE (yyvaluep);

     

       
1901
       
-
       
  YYUSE (parm);

     

       
1902
       
 
       
  if (!yymsg)

     

       
1903
       
 
       
    yymsg = "Deleting";

     

       
1904
       
 
       
  YY_SYMBOL_PRINT (yymsg, yykind, yyvaluep, yylocationp);

     

       
1905
       
 
       


     

       
1906
       
 
       
  YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN

     

       
1907
       
-
       
  YYUSE (yykind);

     

       
1908
       
 
       
  YY_IGNORE_MAYBE_UNINITIALIZED_END

     

       
1909
       
 
       
}

     

       
1910
       
 
       


     
···

       
2174
       
 
       
  switch (yyn)

     

       
2175
       
 
       
    {

     

       
2176
       
 
       
  case 15: /* preddecl_item: FZ_PREDICATE FZ_ID '(' pred_arg_list ')'  */

     

       
2177
       
-
       
#line 636 "../gecode/flatzinc/parser.yxx"

     

       
2178
       
 
       
      { free((yyvsp[-3].sValue)); }

     

       
2179
       
-
       
#line 2180 "gecode/flatzinc/parser.tab.cpp"

     

       
2180
       
 
       
    break;

     

       
2181
       
 
       


     

       
2182
       
 
       
  case 20: /* pred_arg: pred_arg_type ':' FZ_ID  */

     

       
2183
       
-
       
#line 648 "../gecode/flatzinc/parser.yxx"

     

       
2184
       
 
       
      { free((yyvsp[0].sValue)); }

     

       
2185
       
-
       
#line 2186 "gecode/flatzinc/parser.tab.cpp"

     

       
2186
       
 
       
    break;

     

       
2187
       
 
       


     

       
2188
       
 
       
  case 25: /* pred_arg_simple_type: int_ti_expr_tail  */

     

       
2189
       
-
       
#line 658 "../gecode/flatzinc/parser.yxx"

     

       
2190
       
 
       
      { if ((yyvsp[0].oSet)()) delete (yyvsp[0].oSet).some(); }

     

       
2191
       
-
       
#line 2192 "gecode/flatzinc/parser.tab.cpp"

     

       
2192
       
 
       
    break;

     

       
2193
       
 
       


     

       
2194
       
 
       
  case 26: /* pred_arg_simple_type: FZ_SET FZ_OF int_ti_expr_tail  */

     

       
2195
       
-
       
#line 660 "../gecode/flatzinc/parser.yxx"

     

       
2196
       
 
       
      { if ((yyvsp[0].oSet)()) delete (yyvsp[0].oSet).some(); }

     

       
2197
       
-
       
#line 2198 "gecode/flatzinc/parser.tab.cpp"

     

       
2198
       
 
       
    break;

     

       
2199
       
 
       


     

       
2200
       
 
       
  case 35: /* vardecl_item: FZ_VAR int_ti_expr_tail ':' var_par_id annotations non_array_expr_opt  */

     

       
2201
       
-
       
#line 680 "../gecode/flatzinc/parser.yxx"

     

       
2202
       
 
       
      {

     

       
2203
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2204
       
 
       
        bool print = (yyvsp[-1].argVec) != NULL && (yyvsp[-1].argVec)->hasAtom("output_var");

     
···

       
2230
       
 
       
        }

     

       
2231
       
 
       
        delete (yyvsp[-1].argVec); free((yyvsp[-2].sValue));

     

       
2232
       
 
       
      }

     

       
2233
       
-
       
#line 2234 "gecode/flatzinc/parser.tab.cpp"

     

       
2234
       
 
       
    break;

     

       
2235
       
 
       


     

       
2236
       
 
       
  case 36: /* vardecl_item: FZ_VAR bool_ti_expr_tail ':' var_par_id annotations non_array_expr_opt  */

     

       
2237
       
-
       
#line 712 "../gecode/flatzinc/parser.yxx"

     

       
2238
       
 
       
      {

     

       
2239
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2240
       
 
       
        bool print = (yyvsp[-1].argVec) != NULL && (yyvsp[-1].argVec)->hasAtom("output_var");

     
···

       
2266
       
 
       
        }

     

       
2267
       
 
       
        delete (yyvsp[-1].argVec); free((yyvsp[-2].sValue));

     

       
2268
       
 
       
      }

     

       
2269
       
-
       
#line 2270 "gecode/flatzinc/parser.tab.cpp"

     

       
2270
       
 
       
    break;

     

       
2271
       
 
       


     

       
2272
       
 
       
  case 37: /* vardecl_item: FZ_VAR float_ti_expr_tail ':' var_par_id annotations non_array_expr_opt  */

     

       
2273
       
-
       
#line 744 "../gecode/flatzinc/parser.yxx"

     

       
2274
       
 
       
      {

     

       
2275
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2276
       
 
       
        bool print = (yyvsp[-1].argVec) != NULL && (yyvsp[-1].argVec)->hasAtom("output_var");

     
···

       
2309
       
 
       
        }

     

       
2310
       
 
       
        delete (yyvsp[-1].argVec); free((yyvsp[-2].sValue));

     

       
2311
       
 
       
      }

     

       
2312
       
-
       
#line 2313 "gecode/flatzinc/parser.tab.cpp"

     

       
2313
       
 
       
    break;

     

       
2314
       
 
       


     

       
2315
       
 
       
  case 38: /* vardecl_item: FZ_VAR FZ_SET FZ_OF int_ti_expr_tail ':' var_par_id annotations non_array_expr_opt  */

     

       
2316
       
-
       
#line 783 "../gecode/flatzinc/parser.yxx"

     

       
2317
       
 
       
      {

     

       
2318
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2319
       
 
       
        bool print = (yyvsp[-1].argVec) != NULL && (yyvsp[-1].argVec)->hasAtom("output_var");

     
···

       
2346
       
 
       
        }

     

       
2347
       
 
       
        delete (yyvsp[-1].argVec); free((yyvsp[-2].sValue));

     

       
2348
       
 
       
      }

     

       
2349
       
-
       
#line 2350 "gecode/flatzinc/parser.tab.cpp"

     

       
2350
       
 
       
    break;

     

       
2351
       
 
       


     

       
2352
       
 
       
  case 39: /* vardecl_item: FZ_INT ':' var_par_id annotations '=' non_array_expr  */

     

       
2353
       
-
       
#line 816 "../gecode/flatzinc/parser.yxx"

     

       
2354
       
 
       
      {

     

       
2355
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2356
       
 
       
        yyassert(pp, (yyvsp[0].arg)->isInt(), "Invalid int initializer");

     
···

       
2359
       
 
       
          "Duplicate symbol");

     

       
2360
       
 
       
        delete (yyvsp[-2].argVec); free((yyvsp[-3].sValue));

     

       
2361
       
 
       
      }

     

       
2362
       
-
       
#line 2363 "gecode/flatzinc/parser.tab.cpp"

     

       
2363
       
 
       
    break;

     

       
2364
       
 
       


     

       
2365
       
 
       
  case 40: /* vardecl_item: FZ_FLOAT ':' var_par_id annotations '=' non_array_expr  */

     

       
2366
       
-
       
#line 825 "../gecode/flatzinc/parser.yxx"

     

       
2367
       
 
       
      {

     

       
2368
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2369
       
 
       
        yyassert(pp, (yyvsp[0].arg)->isFloat(), "Invalid float initializer");

     
···

       
2373
       
 
       
          "Duplicate symbol");

     

       
2374
       
 
       
        delete (yyvsp[-2].argVec); free((yyvsp[-3].sValue));

     

       
2375
       
 
       
      }

     

       
2376
       
-
       
#line 2377 "gecode/flatzinc/parser.tab.cpp"

     

       
2377
       
 
       
    break;

     

       
2378
       
 
       


     

       
2379
       
 
       
  case 41: /* vardecl_item: FZ_BOOL ':' var_par_id annotations '=' non_array_expr  */

     

       
2380
       
-
       
#line 835 "../gecode/flatzinc/parser.yxx"

     

       
2381
       
 
       
      {

     

       
2382
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2383
       
 
       
        yyassert(pp, (yyvsp[0].arg)->isBool(), "Invalid bool initializer");

     
···

       
2386
       
 
       
          "Duplicate symbol");

     

       
2387
       
 
       
        delete (yyvsp[-2].argVec); free((yyvsp[-3].sValue));

     

       
2388
       
 
       
      }

     

       
2389
       
-
       
#line 2390 "gecode/flatzinc/parser.tab.cpp"

     

       
2390
       
 
       
    break;

     

       
2391
       
 
       


     

       
2392
       
 
       
  case 42: /* vardecl_item: FZ_SET FZ_OF FZ_INT ':' var_par_id annotations '=' non_array_expr  */

     

       
2393
       
-
       
#line 844 "../gecode/flatzinc/parser.yxx"

     

       
2394
       
 
       
      {

     

       
2395
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2396
       
 
       
        yyassert(pp, (yyvsp[0].arg)->isSet(), "Invalid set initializer");

     
···

       
2402
       
 
       
        delete set;

     

       
2403
       
 
       
        delete (yyvsp[-2].argVec); free((yyvsp[-3].sValue));

     

       
2404
       
 
       
      }

     

       
2405
       
-
       
#line 2406 "gecode/flatzinc/parser.tab.cpp"

     

       
2406
       
 
       
    break;

     

       
2407
       
 
       


     

       
2408
       
 
       
  case 43: /* vardecl_item: FZ_ARRAY '[' FZ_INT_LIT FZ_DOTDOT FZ_INT_LIT ']' FZ_OF FZ_VAR int_ti_expr_tail ':' var_par_id annotations vardecl_int_var_array_init  */

     

       
2409
       
-
       
#line 857 "../gecode/flatzinc/parser.yxx"

     

       
2410
       
 
       
      {

     

       
2411
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2412
       
 
       
        yyassert(pp, (yyvsp[-10].iValue)==1, "Arrays must start at 1");

     
···

       
2475
       
 
       
        }

     

       
2476
       
 
       
        delete (yyvsp[-1].argVec); free((yyvsp[-2].sValue));

     

       
2477
       
 
       
      }

     

       
2478
       
-
       
#line 2479 "gecode/flatzinc/parser.tab.cpp"

     

       
2479
       
 
       
    break;

     

       
2480
       
 
       


     

       
2481
       
 
       
  case 44: /* vardecl_item: FZ_ARRAY '[' FZ_INT_LIT FZ_DOTDOT FZ_INT_LIT ']' FZ_OF FZ_VAR bool_ti_expr_tail ':' var_par_id annotations vardecl_bool_var_array_init  */

     

       
2482
       
-
       
#line 927 "../gecode/flatzinc/parser.yxx"

     

       
2483
       
 
       
      {

     

       
2484
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2485
       
 
       
        bool print = (yyvsp[-1].argVec) != NULL && (yyvsp[-1].argVec)->hasCall("output_array");

     
···

       
2544
       
 
       
        }

     

       
2545
       
 
       
        delete (yyvsp[-1].argVec); free((yyvsp[-2].sValue));

     

       
2546
       
 
       
      }

     

       
2547
       
-
       
#line 2548 "gecode/flatzinc/parser.tab.cpp"

     

       
2548
       
 
       
    break;

     

       
2549
       
 
       


     

       
2550
       
 
       
  case 45: /* vardecl_item: FZ_ARRAY '[' FZ_INT_LIT FZ_DOTDOT FZ_INT_LIT ']' FZ_OF FZ_VAR float_ti_expr_tail ':' var_par_id annotations vardecl_float_var_array_init  */

     

       
2551
       
-
       
#line 994 "../gecode/flatzinc/parser.yxx"

     

       
2552
       
 
       
      {

     

       
2553
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2554
       
 
       
        yyassert(pp, (yyvsp[-10].iValue)==1, "Arrays must start at 1");

     
···

       
2617
       
 
       
        if ((yyvsp[-4].oPFloat)()) delete (yyvsp[-4].oPFloat).some();

     

       
2618
       
 
       
        delete (yyvsp[-1].argVec); free((yyvsp[-2].sValue));

     

       
2619
       
 
       
      }

     

       
2620
       
-
       
#line 2621 "gecode/flatzinc/parser.tab.cpp"

     

       
2621
       
 
       
    break;

     

       
2622
       
 
       


     

       
2623
       
 
       
  case 46: /* vardecl_item: FZ_ARRAY '[' FZ_INT_LIT FZ_DOTDOT FZ_INT_LIT ']' FZ_OF FZ_VAR FZ_SET FZ_OF int_ti_expr_tail ':' var_par_id annotations vardecl_set_var_array_init  */

     

       
2624
       
-
       
#line 1064 "../gecode/flatzinc/parser.yxx"

     

       
2625
       
 
       
      {

     

       
2626
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2627
       
 
       
        bool print = (yyvsp[-1].argVec) != NULL && (yyvsp[-1].argVec)->hasCall("output_array");

     
···

       
2688
       
 
       
        }

     

       
2689
       
 
       
        delete (yyvsp[-1].argVec); free((yyvsp[-2].sValue));

     

       
2690
       
 
       
      }

     

       
2691
       
-
       
#line 2692 "gecode/flatzinc/parser.tab.cpp"

     

       
2692
       
 
       
    break;

     

       
2693
       
 
       


     

       
2694
       
 
       
  case 47: /* vardecl_item: FZ_ARRAY '[' FZ_INT_LIT FZ_DOTDOT FZ_INT_LIT ']' FZ_OF FZ_INT ':' var_par_id annotations '=' '[' int_list ']'  */

     

       
2695
       
-
       
#line 1132 "../gecode/flatzinc/parser.yxx"

     

       
2696
       
 
       
      {

     

       
2697
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2698
       
 
       
        yyassert(pp, (yyvsp[-12].iValue)==1, "Arrays must start at 1");

     
···

       
2712
       
 
       
        free((yyvsp[-5].sValue));

     

       
2713
       
 
       
        delete (yyvsp[-4].argVec);

     

       
2714
       
 
       
      }

     

       
2715
       
-
       
#line 2716 "gecode/flatzinc/parser.tab.cpp"

     

       
2716
       
 
       
    break;

     

       
2717
       
 
       


     

       
2718
       
 
       
  case 48: /* vardecl_item: FZ_ARRAY '[' FZ_INT_LIT FZ_DOTDOT FZ_INT_LIT ']' FZ_OF FZ_BOOL ':' var_par_id annotations '=' '[' bool_list ']'  */

     

       
2719
       
-
       
#line 1153 "../gecode/flatzinc/parser.yxx"

     

       
2720
       
 
       
      {

     

       
2721
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2722
       
 
       
        yyassert(pp, (yyvsp[-12].iValue)==1, "Arrays must start at 1");

     
···

       
2735
       
 
       
        free((yyvsp[-5].sValue));

     

       
2736
       
 
       
        delete (yyvsp[-4].argVec);

     

       
2737
       
 
       
      }

     

       
2738
       
-
       
#line 2739 "gecode/flatzinc/parser.tab.cpp"

     

       
2739
       
 
       
    break;

     

       
2740
       
 
       


     

       
2741
       
 
       
  case 49: /* vardecl_item: FZ_ARRAY '[' FZ_INT_LIT FZ_DOTDOT FZ_INT_LIT ']' FZ_OF FZ_FLOAT ':' var_par_id annotations '=' '[' float_list ']'  */

     

       
2742
       
-
       
#line 1173 "../gecode/flatzinc/parser.yxx"

     

       
2743
       
 
       
      {

     

       
2744
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2745
       
 
       
        yyassert(pp, (yyvsp[-12].iValue)==1, "Arrays must start at 1");

     
···

       
2758
       
 
       
        delete (yyvsp[-1].floatSetValue);

     

       
2759
       
 
       
        delete (yyvsp[-4].argVec); free((yyvsp[-5].sValue));

     

       
2760
       
 
       
      }

     

       
2761
       
-
       
#line 2762 "gecode/flatzinc/parser.tab.cpp"

     

       
2762
       
 
       
    break;

     

       
2763
       
 
       


     

       
2764
       
 
       
  case 50: /* vardecl_item: FZ_ARRAY '[' FZ_INT_LIT FZ_DOTDOT FZ_INT_LIT ']' FZ_OF FZ_SET FZ_OF FZ_INT ':' var_par_id annotations '=' '[' set_literal_list ']'  */

     

       
2765
       
-
       
#line 1193 "../gecode/flatzinc/parser.yxx"

     

       
2766
       
 
       
      {

     

       
2767
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
2768
       
 
       
        yyassert(pp, (yyvsp[-14].iValue)==1, "Arrays must start at 1");

     
···

       
2782
       
 
       
        delete (yyvsp[-1].setValueList);

     

       
2783
       
 
       
        delete (yyvsp[-4].argVec); free((yyvsp[-5].sValue));

     

       
2784
       
 
       
      }

     

       
2785
       
-
       
#line 2786 "gecode/flatzinc/parser.tab.cpp"

     

       
2786
       
 
       
    break;

     

       
2787
       
 
       


     

       
2788
       
 
       
  case 51: /* int_init: FZ_INT_LIT  */

     

       
2789
       
-
       
#line 1215 "../gecode/flatzinc/parser.yxx"

     

       
2790
       
 
       
      {

     

       
2791
       
 
       
        (yyval.varSpec) = new IntVarSpec((yyvsp[0].iValue),false,false);

     

       
2792
       
 
       
      }

     

       
2793
       
-
       
#line 2794 "gecode/flatzinc/parser.tab.cpp"

     

       
2794
       
 
       
    break;

     

       
2795
       
 
       


     

       
2796
       
 
       
  case 52: /* int_init: var_par_id  */

     

       
2797
       
-
       
#line 1219 "../gecode/flatzinc/parser.yxx"

     

       
2798
       
 
       
      {

     

       
2799
       
 
       
        SymbolEntry e;

     

       
2800
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     
···

       
2809
       
 
       
        }

     

       
2810
       
 
       
        free((yyvsp[0].sValue));

     

       
2811
       
 
       
      }

     

       
2812
       
-
       
#line 2813 "gecode/flatzinc/parser.tab.cpp"

     

       
2813
       
 
       
    break;

     

       
2814
       
 
       


     

       
2815
       
 
       
  case 53: /* int_init: var_par_id '[' FZ_INT_LIT ']'  */

     

       
2816
       
-
       
#line 1234 "../gecode/flatzinc/parser.yxx"

     

       
2817
       
 
       
      {

     

       
2818
       
 
       
        vector<int> v;

     

       
2819
       
 
       
        SymbolEntry e;

     
···

       
2834
       
 
       
        }

     

       
2835
       
 
       
        free((yyvsp[-3].sValue));

     

       
2836
       
 
       
      }

     

       
2837
       
-
       
#line 2838 "gecode/flatzinc/parser.tab.cpp"

     

       
2838
       
 
       
    break;

     

       
2839
       
 
       


     

       
2840
       
 
       
  case 54: /* int_init_list: %empty  */

     

       
2841
       
-
       
#line 1257 "../gecode/flatzinc/parser.yxx"

     

       
2842
       
 
       
      { (yyval.varSpecVec) = new vector<VarSpec*>(0); }

     

       
2843
       
-
       
#line 2844 "gecode/flatzinc/parser.tab.cpp"

     

       
2844
       
 
       
    break;

     

       
2845
       
 
       


     

       
2846
       
 
       
  case 55: /* int_init_list: int_init_list_head list_tail  */

     

       
2847
       
-
       
#line 1259 "../gecode/flatzinc/parser.yxx"

     

       
2848
       
 
       
      { (yyval.varSpecVec) = (yyvsp[-1].varSpecVec); }

     

       
2849
       
-
       
#line 2850 "gecode/flatzinc/parser.tab.cpp"

     

       
2850
       
 
       
    break;

     

       
2851
       
 
       


     

       
2852
       
 
       
  case 56: /* int_init_list_head: int_init  */

     

       
2853
       
-
       
#line 1263 "../gecode/flatzinc/parser.yxx"

     

       
2854
       
 
       
      { (yyval.varSpecVec) = new vector<VarSpec*>(1); (*(yyval.varSpecVec))[0] = (yyvsp[0].varSpec); }

     

       
2855
       
-
       
#line 2856 "gecode/flatzinc/parser.tab.cpp"

     

       
2856
       
 
       
    break;

     

       
2857
       
 
       


     

       
2858
       
 
       
  case 57: /* int_init_list_head: int_init_list_head ',' int_init  */

     

       
2859
       
-
       
#line 1265 "../gecode/flatzinc/parser.yxx"

     

       
2860
       
 
       
      { (yyval.varSpecVec) = (yyvsp[-2].varSpecVec); (yyval.varSpecVec)->push_back((yyvsp[0].varSpec)); }

     

       
2861
       
-
       
#line 2862 "gecode/flatzinc/parser.tab.cpp"

     

       
2862
       
 
       
    break;

     

       
2863
       
 
       


     

       
2864
       
 
       
  case 60: /* int_var_array_literal: '[' int_init_list ']'  */

     

       
2865
       
-
       
#line 1270 "../gecode/flatzinc/parser.yxx"

     

       
2866
       
 
       
      { (yyval.varSpecVec) = (yyvsp[-1].varSpecVec); }

     

       
2867
       
-
       
#line 2868 "gecode/flatzinc/parser.tab.cpp"

     

       
2868
       
 
       
    break;

     

       
2869
       
 
       


     

       
2870
       
 
       
  case 61: /* float_init: FZ_FLOAT_LIT  */

     

       
2871
       
-
       
#line 1274 "../gecode/flatzinc/parser.yxx"

     

       
2872
       
 
       
      { (yyval.varSpec) = new FloatVarSpec((yyvsp[0].dValue),false,false); }

     

       
2873
       
-
       
#line 2874 "gecode/flatzinc/parser.tab.cpp"

     

       
2874
       
 
       
    break;

     

       
2875
       
 
       


     

       
2876
       
 
       
  case 62: /* float_init: var_par_id  */

     

       
2877
       
-
       
#line 1276 "../gecode/flatzinc/parser.yxx"

     

       
2878
       
 
       
      {

     

       
2879
       
 
       
        SymbolEntry e;

     

       
2880
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     
···

       
2889
       
 
       
        }

     

       
2890
       
 
       
        free((yyvsp[0].sValue));

     

       
2891
       
 
       
      }

     

       
2892
       
-
       
#line 2893 "gecode/flatzinc/parser.tab.cpp"

     

       
2893
       
 
       
    break;

     

       
2894
       
 
       


     

       
2895
       
 
       
  case 63: /* float_init: var_par_id '[' FZ_INT_LIT ']'  */

     

       
2896
       
-
       
#line 1291 "../gecode/flatzinc/parser.yxx"

     

       
2897
       
 
       
      {

     

       
2898
       
 
       
        SymbolEntry e;

     

       
2899
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     
···

       
2913
       
 
       
        }

     

       
2914
       
 
       
        free((yyvsp[-3].sValue));

     

       
2915
       
 
       
      }

     

       
2916
       
-
       
#line 2917 "gecode/flatzinc/parser.tab.cpp"

     

       
2917
       
 
       
    break;

     

       
2918
       
 
       


     

       
2919
       
 
       
  case 64: /* float_init_list: %empty  */

     

       
2920
       
-
       
#line 1313 "../gecode/flatzinc/parser.yxx"

     

       
2921
       
 
       
      { (yyval.varSpecVec) = new vector<VarSpec*>(0); }

     

       
2922
       
-
       
#line 2923 "gecode/flatzinc/parser.tab.cpp"

     

       
2923
       
 
       
    break;

     

       
2924
       
 
       


     

       
2925
       
 
       
  case 65: /* float_init_list: float_init_list_head list_tail  */

     

       
2926
       
-
       
#line 1315 "../gecode/flatzinc/parser.yxx"

     

       
2927
       
 
       
      { (yyval.varSpecVec) = (yyvsp[-1].varSpecVec); }

     

       
2928
       
-
       
#line 2929 "gecode/flatzinc/parser.tab.cpp"

     

       
2929
       
 
       
    break;

     

       
2930
       
 
       


     

       
2931
       
 
       
  case 66: /* float_init_list_head: float_init  */

     

       
2932
       
-
       
#line 1319 "../gecode/flatzinc/parser.yxx"

     

       
2933
       
 
       
      { (yyval.varSpecVec) = new vector<VarSpec*>(1); (*(yyval.varSpecVec))[0] = (yyvsp[0].varSpec); }

     

       
2934
       
-
       
#line 2935 "gecode/flatzinc/parser.tab.cpp"

     

       
2935
       
 
       
    break;

     

       
2936
       
 
       


     

       
2937
       
 
       
  case 67: /* float_init_list_head: float_init_list_head ',' float_init  */

     

       
2938
       
-
       
#line 1321 "../gecode/flatzinc/parser.yxx"

     

       
2939
       
 
       
      { (yyval.varSpecVec) = (yyvsp[-2].varSpecVec); (yyval.varSpecVec)->push_back((yyvsp[0].varSpec)); }

     

       
2940
       
-
       
#line 2941 "gecode/flatzinc/parser.tab.cpp"

     

       
2941
       
 
       
    break;

     

       
2942
       
 
       


     

       
2943
       
 
       
  case 68: /* float_var_array_literal: '[' float_init_list ']'  */

     

       
2944
       
-
       
#line 1325 "../gecode/flatzinc/parser.yxx"

     

       
2945
       
 
       
      { (yyval.varSpecVec) = (yyvsp[-1].varSpecVec); }

     

       
2946
       
-
       
#line 2947 "gecode/flatzinc/parser.tab.cpp"

     

       
2947
       
 
       
    break;

     

       
2948
       
 
       


     

       
2949
       
 
       
  case 69: /* bool_init: FZ_BOOL_LIT  */

     

       
2950
       
-
       
#line 1329 "../gecode/flatzinc/parser.yxx"

     

       
2951
       
 
       
      { (yyval.varSpec) = new BoolVarSpec((yyvsp[0].iValue),false,false); }

     

       
2952
       
-
       
#line 2953 "gecode/flatzinc/parser.tab.cpp"

     

       
2953
       
 
       
    break;

     

       
2954
       
 
       


     

       
2955
       
 
       
  case 70: /* bool_init: var_par_id  */

     

       
2956
       
-
       
#line 1331 "../gecode/flatzinc/parser.yxx"

     

       
2957
       
 
       
      {

     

       
2958
       
 
       
        SymbolEntry e;

     

       
2959
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     
···

       
2968
       
 
       
        }

     

       
2969
       
 
       
        free((yyvsp[0].sValue));

     

       
2970
       
 
       
      }

     

       
2971
       
-
       
#line 2972 "gecode/flatzinc/parser.tab.cpp"

     

       
2972
       
 
       
    break;

     

       
2973
       
 
       


     

       
2974
       
 
       
  case 71: /* bool_init: var_par_id '[' FZ_INT_LIT ']'  */

     

       
2975
       
-
       
#line 1346 "../gecode/flatzinc/parser.yxx"

     

       
2976
       
 
       
      {

     

       
2977
       
 
       
        SymbolEntry e;

     

       
2978
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     
···

       
2992
       
 
       
        }

     

       
2993
       
 
       
        free((yyvsp[-3].sValue));

     

       
2994
       
 
       
      }

     

       
2995
       
-
       
#line 2996 "gecode/flatzinc/parser.tab.cpp"

     

       
2996
       
 
       
    break;

     

       
2997
       
 
       


     

       
2998
       
 
       
  case 72: /* bool_init_list: %empty  */

     

       
2999
       
-
       
#line 1368 "../gecode/flatzinc/parser.yxx"

     

       
3000
       
 
       
      { (yyval.varSpecVec) = new vector<VarSpec*>(0); }

     

       
3001
       
-
       
#line 3002 "gecode/flatzinc/parser.tab.cpp"

     

       
3002
       
 
       
    break;

     

       
3003
       
 
       


     

       
3004
       
 
       
  case 73: /* bool_init_list: bool_init_list_head list_tail  */

     

       
3005
       
-
       
#line 1370 "../gecode/flatzinc/parser.yxx"

     

       
3006
       
 
       
      { (yyval.varSpecVec) = (yyvsp[-1].varSpecVec); }

     

       
3007
       
-
       
#line 3008 "gecode/flatzinc/parser.tab.cpp"

     

       
3008
       
 
       
    break;

     

       
3009
       
 
       


     

       
3010
       
 
       
  case 74: /* bool_init_list_head: bool_init  */

     

       
3011
       
-
       
#line 1374 "../gecode/flatzinc/parser.yxx"

     

       
3012
       
 
       
      { (yyval.varSpecVec) = new vector<VarSpec*>(1); (*(yyval.varSpecVec))[0] = (yyvsp[0].varSpec); }

     

       
3013
       
-
       
#line 3014 "gecode/flatzinc/parser.tab.cpp"

     

       
3014
       
 
       
    break;

     

       
3015
       
 
       


     

       
3016
       
 
       
  case 75: /* bool_init_list_head: bool_init_list_head ',' bool_init  */

     

       
3017
       
-
       
#line 1376 "../gecode/flatzinc/parser.yxx"

     

       
3018
       
 
       
      { (yyval.varSpecVec) = (yyvsp[-2].varSpecVec); (yyval.varSpecVec)->push_back((yyvsp[0].varSpec)); }

     

       
3019
       
-
       
#line 3020 "gecode/flatzinc/parser.tab.cpp"

     

       
3020
       
 
       
    break;

     

       
3021
       
 
       


     

       
3022
       
 
       
  case 76: /* bool_var_array_literal: '[' bool_init_list ']'  */

     

       
3023
       
-
       
#line 1378 "../gecode/flatzinc/parser.yxx"

     

       
3024
       
 
       
                                                { (yyval.varSpecVec) = (yyvsp[-1].varSpecVec); }

     

       
3025
       
-
       
#line 3026 "gecode/flatzinc/parser.tab.cpp"

     

       
3026
       
 
       
    break;

     

       
3027
       
 
       


     

       
3028
       
 
       
  case 77: /* set_init: set_literal  */

     

       
3029
       
-
       
#line 1382 "../gecode/flatzinc/parser.yxx"

     

       
3030
       
 
       
      { (yyval.varSpec) = new SetVarSpec((yyvsp[0].setLit),false,false); }

     

       
3031
       
-
       
#line 3032 "gecode/flatzinc/parser.tab.cpp"

     

       
3032
       
 
       
    break;

     

       
3033
       
 
       


     

       
3034
       
 
       
  case 78: /* set_init: var_par_id  */

     

       
3035
       
-
       
#line 1384 "../gecode/flatzinc/parser.yxx"

     

       
3036
       
 
       
      {

     

       
3037
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
3038
       
 
       
        SymbolEntry e;

     
···

       
3047
       
 
       
        }

     

       
3048
       
 
       
        free((yyvsp[0].sValue));

     

       
3049
       
 
       
      }

     

       
3050
       
-
       
#line 3051 "gecode/flatzinc/parser.tab.cpp"

     

       
3051
       
 
       
    break;

     

       
3052
       
 
       


     

       
3053
       
 
       
  case 79: /* set_init: var_par_id '[' FZ_INT_LIT ']'  */

     

       
3054
       
-
       
#line 1399 "../gecode/flatzinc/parser.yxx"

     

       
3055
       
 
       
      {

     

       
3056
       
 
       
        SymbolEntry e;

     

       
3057
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     
···

       
3071
       
 
       
        }

     

       
3072
       
 
       
        free((yyvsp[-3].sValue));

     

       
3073
       
 
       
      }

     

       
3074
       
-
       
#line 3075 "gecode/flatzinc/parser.tab.cpp"

     

       
3075
       
 
       
    break;

     

       
3076
       
 
       


     

       
3077
       
 
       
  case 80: /* set_init_list: %empty  */

     

       
3078
       
-
       
#line 1421 "../gecode/flatzinc/parser.yxx"

     

       
3079
       
 
       
      { (yyval.varSpecVec) = new vector<VarSpec*>(0); }

     

       
3080
       
-
       
#line 3081 "gecode/flatzinc/parser.tab.cpp"

     

       
3081
       
 
       
    break;

     

       
3082
       
 
       


     

       
3083
       
 
       
  case 81: /* set_init_list: set_init_list_head list_tail  */

     

       
3084
       
-
       
#line 1423 "../gecode/flatzinc/parser.yxx"

     

       
3085
       
 
       
      { (yyval.varSpecVec) = (yyvsp[-1].varSpecVec); }

     

       
3086
       
-
       
#line 3087 "gecode/flatzinc/parser.tab.cpp"

     

       
3087
       
 
       
    break;

     

       
3088
       
 
       


     

       
3089
       
 
       
  case 82: /* set_init_list_head: set_init  */

     

       
3090
       
-
       
#line 1427 "../gecode/flatzinc/parser.yxx"

     

       
3091
       
 
       
      { (yyval.varSpecVec) = new vector<VarSpec*>(1); (*(yyval.varSpecVec))[0] = (yyvsp[0].varSpec); }

     

       
3092
       
-
       
#line 3093 "gecode/flatzinc/parser.tab.cpp"

     

       
3093
       
 
       
    break;

     

       
3094
       
 
       


     

       
3095
       
 
       
  case 83: /* set_init_list_head: set_init_list_head ',' set_init  */

     

       
3096
       
-
       
#line 1429 "../gecode/flatzinc/parser.yxx"

     

       
3097
       
 
       
      { (yyval.varSpecVec) = (yyvsp[-2].varSpecVec); (yyval.varSpecVec)->push_back((yyvsp[0].varSpec)); }

     

       
3098
       
-
       
#line 3099 "gecode/flatzinc/parser.tab.cpp"

     

       
3099
       
 
       
    break;

     

       
3100
       
 
       


     

       
3101
       
 
       
  case 84: /* set_var_array_literal: '[' set_init_list ']'  */

     

       
3102
       
-
       
#line 1432 "../gecode/flatzinc/parser.yxx"

     

       
3103
       
 
       
      { (yyval.varSpecVec) = (yyvsp[-1].varSpecVec); }

     

       
3104
       
-
       
#line 3105 "gecode/flatzinc/parser.tab.cpp"

     

       
3105
       
 
       
    break;

     

       
3106
       
 
       


     

       
3107
       
 
       
  case 85: /* vardecl_int_var_array_init: %empty  */

     

       
3108
       
-
       
#line 1436 "../gecode/flatzinc/parser.yxx"

     

       
3109
       
 
       
      { (yyval.oVarSpecVec) = Option<vector<VarSpec*>* >::none(); }

     

       
3110
       
-
       
#line 3111 "gecode/flatzinc/parser.tab.cpp"

     

       
3111
       
 
       
    break;

     

       
3112
       
 
       


     

       
3113
       
 
       
  case 86: /* vardecl_int_var_array_init: '=' int_var_array_literal  */

     

       
3114
       
-
       
#line 1438 "../gecode/flatzinc/parser.yxx"

     

       
3115
       
 
       
      { (yyval.oVarSpecVec) = Option<vector<VarSpec*>* >::some((yyvsp[0].varSpecVec)); }

     

       
3116
       
-
       
#line 3117 "gecode/flatzinc/parser.tab.cpp"

     

       
3117
       
 
       
    break;

     

       
3118
       
 
       


     

       
3119
       
 
       
  case 87: /* vardecl_bool_var_array_init: %empty  */

     

       
3120
       
-
       
#line 1442 "../gecode/flatzinc/parser.yxx"

     

       
3121
       
 
       
      { (yyval.oVarSpecVec) = Option<vector<VarSpec*>* >::none(); }

     

       
3122
       
-
       
#line 3123 "gecode/flatzinc/parser.tab.cpp"

     

       
3123
       
 
       
    break;

     

       
3124
       
 
       


     

       
3125
       
 
       
  case 88: /* vardecl_bool_var_array_init: '=' bool_var_array_literal  */

     

       
3126
       
-
       
#line 1444 "../gecode/flatzinc/parser.yxx"

     

       
3127
       
 
       
      { (yyval.oVarSpecVec) = Option<vector<VarSpec*>* >::some((yyvsp[0].varSpecVec)); }

     

       
3128
       
-
       
#line 3129 "gecode/flatzinc/parser.tab.cpp"

     

       
3129
       
 
       
    break;

     

       
3130
       
 
       


     

       
3131
       
 
       
  case 89: /* vardecl_float_var_array_init: %empty  */

     

       
3132
       
-
       
#line 1448 "../gecode/flatzinc/parser.yxx"

     

       
3133
       
 
       
      { (yyval.oVarSpecVec) = Option<vector<VarSpec*>* >::none(); }

     

       
3134
       
-
       
#line 3135 "gecode/flatzinc/parser.tab.cpp"

     

       
3135
       
 
       
    break;

     

       
3136
       
 
       


     

       
3137
       
 
       
  case 90: /* vardecl_float_var_array_init: '=' float_var_array_literal  */

     

       
3138
       
-
       
#line 1450 "../gecode/flatzinc/parser.yxx"

     

       
3139
       
 
       
      { (yyval.oVarSpecVec) = Option<vector<VarSpec*>* >::some((yyvsp[0].varSpecVec)); }

     

       
3140
       
-
       
#line 3141 "gecode/flatzinc/parser.tab.cpp"

     

       
3141
       
 
       
    break;

     

       
3142
       
 
       


     

       
3143
       
 
       
  case 91: /* vardecl_set_var_array_init: %empty  */

     

       
3144
       
-
       
#line 1454 "../gecode/flatzinc/parser.yxx"

     

       
3145
       
 
       
      { (yyval.oVarSpecVec) = Option<vector<VarSpec*>* >::none(); }

     

       
3146
       
-
       
#line 3147 "gecode/flatzinc/parser.tab.cpp"

     

       
3147
       
 
       
    break;

     

       
3148
       
 
       


     

       
3149
       
 
       
  case 92: /* vardecl_set_var_array_init: '=' set_var_array_literal  */

     

       
3150
       
-
       
#line 1456 "../gecode/flatzinc/parser.yxx"

     

       
3151
       
 
       
      { (yyval.oVarSpecVec) = Option<vector<VarSpec*>* >::some((yyvsp[0].varSpecVec)); }

     

       
3152
       
-
       
#line 3153 "gecode/flatzinc/parser.tab.cpp"

     

       
3153
       
 
       
    break;

     

       
3154
       
 
       


     

       
3155
       
 
       
  case 93: /* constraint_item: FZ_CONSTRAINT FZ_ID '(' flat_expr_list ')' annotations  */

     

       
3156
       
-
       
#line 1460 "../gecode/flatzinc/parser.yxx"

     

       
3157
       
 
       
      {

     

       
3158
       
 
       
        ParserState *pp = static_cast<ParserState*>(parm);

     

       
3159
       
 
       
        if (!pp->hadError) {

     

       
3160
       
 
       
          std::string cid((yyvsp[-4].sValue));

     

       
3161
       
 
       
          if (cid=="status" && (yyvsp[-2].argVec)->a[0]->isIntVar()) {

     

       
3162
       
 
       
            pp->status_idx = (yyvsp[-2].argVec)->a[0]->getIntVar();

     

       
0
       
 
       

     

       
0
       
 
       

     

       
3163
       
 
       
          } else if (cid=="int_lastval" && (yyvsp[-2].argVec)->a[0]->isIntVar() && (yyvsp[-2].argVec)->a[1]->isIntVar()) {

     

       
3164
       
 
       
            int base0 = getBaseIntVar(pp,(yyvsp[-2].argVec)->a[0]->getIntVar());

     

       
3165
       
 
       
            int base1 = getBaseIntVar(pp,(yyvsp[-2].argVec)->a[1]->getIntVar());

     
···

       
3276
       
 
       
        }

     

       
3277
       
 
       
        free((yyvsp[-4].sValue));

     

       
3278
       
 
       
      }

     

       
3279
       
-
       
#line 3280 "gecode/flatzinc/parser.tab.cpp"

     

       
3280
       
 
       
    break;

     

       
3281
       
 
       


     

       
3282
       
 
       
  case 94: /* solve_item: FZ_SOLVE annotations FZ_SATISFY  */

     

       
3283
       
-
       
#line 1584 "../gecode/flatzinc/parser.yxx"

     

       
3284
       
 
       
      {

     

       
3285
       
 
       
        ParserState *pp = static_cast<ParserState*>(parm);

     

       
3286
       
 
       
        initfg(pp);

     
···

       
3294
       
 
       
          delete (yyvsp[-1].argVec);

     

       
3295
       
 
       
        }

     

       
3296
       
 
       
      }

     

       
3297
       
-
       
#line 3298 "gecode/flatzinc/parser.tab.cpp"

     

       
3298
       
 
       
    break;

     

       
3299
       
 
       


     

       
3300
       
 
       
  case 95: /* solve_item: FZ_SOLVE annotations minmax solve_expr  */

     

       
3301
       
-
       
#line 1598 "../gecode/flatzinc/parser.yxx"

     

       
3302
       
 
       
      {

     

       
3303
       
 
       
        ParserState *pp = static_cast<ParserState*>(parm);

     

       
3304
       
 
       
        initfg(pp);

     
···

       
3317
       
 
       
          delete (yyvsp[-2].argVec);

     

       
3318
       
 
       
        }

     

       
3319
       
 
       
      }

     

       
3320
       
-
       
#line 3321 "gecode/flatzinc/parser.tab.cpp"

     

       
3321
       
 
       
    break;

     

       
3322
       
 
       


     

       
3323
       
 
       
  case 96: /* int_ti_expr_tail: FZ_INT  */

     

       
3324
       
-
       
#line 1623 "../gecode/flatzinc/parser.yxx"

     

       
3325
       
 
       
      { (yyval.oSet) = Option<AST::SetLit* >::none(); }

     

       
3326
       
-
       
#line 3327 "gecode/flatzinc/parser.tab.cpp"

     

       
3327
       
 
       
    break;

     

       
3328
       
 
       


     

       
3329
       
 
       
  case 97: /* int_ti_expr_tail: '{' int_list '}'  */

     

       
3330
       
-
       
#line 1625 "../gecode/flatzinc/parser.yxx"

     

       
3331
       
 
       
      { (yyval.oSet) = Option<AST::SetLit* >::some(new AST::SetLit(*(yyvsp[-1].setValue))); }

     

       
3332
       
-
       
#line 3333 "gecode/flatzinc/parser.tab.cpp"

     

       
3333
       
 
       
    break;

     

       
3334
       
 
       


     

       
3335
       
 
       
  case 98: /* int_ti_expr_tail: FZ_INT_LIT FZ_DOTDOT FZ_INT_LIT  */

     

       
3336
       
-
       
#line 1627 "../gecode/flatzinc/parser.yxx"

     

       
3337
       
 
       
      {

     

       
3338
       
 
       
        (yyval.oSet) = Option<AST::SetLit* >::some(new AST::SetLit((yyvsp[-2].iValue), (yyvsp[0].iValue)));

     

       
3339
       
 
       
      }

     

       
3340
       
-
       
#line 3341 "gecode/flatzinc/parser.tab.cpp"

     

       
3341
       
 
       
    break;

     

       
3342
       
 
       


     

       
3343
       
 
       
  case 99: /* bool_ti_expr_tail: FZ_BOOL  */

     

       
3344
       
-
       
#line 1633 "../gecode/flatzinc/parser.yxx"

     

       
3345
       
 
       
      { (yyval.oSet) = Option<AST::SetLit* >::none(); }

     

       
3346
       
-
       
#line 3347 "gecode/flatzinc/parser.tab.cpp"

     

       
3347
       
 
       
    break;

     

       
3348
       
 
       


     

       
3349
       
 
       
  case 100: /* bool_ti_expr_tail: '{' bool_list_head list_tail '}'  */

     

       
3350
       
-
       
#line 1635 "../gecode/flatzinc/parser.yxx"

     

       
3351
       
 
       
      { bool haveTrue = false;

     

       
3352
       
 
       
        bool haveFalse = false;

     

       
3353
       
 
       
        for (int i=(yyvsp[-2].setValue)->size(); i--;) {

     
···

       
3358
       
 
       
        (yyval.oSet) = Option<AST::SetLit* >::some(

     

       
3359
       
 
       
          new AST::SetLit(!haveFalse,haveTrue));

     

       
3360
       
 
       
      }

     

       
3361
       
-
       
#line 3362 "gecode/flatzinc/parser.tab.cpp"

     

       
3362
       
 
       
    break;

     

       
3363
       
 
       


     

       
3364
       
 
       
  case 101: /* float_ti_expr_tail: FZ_FLOAT  */

     

       
3365
       
-
       
#line 1648 "../gecode/flatzinc/parser.yxx"

     

       
3366
       
 
       
      { (yyval.oPFloat) = Option<std::pair<double,double>* >::none(); }

     

       
3367
       
-
       
#line 3368 "gecode/flatzinc/parser.tab.cpp"

     

       
3368
       
 
       
    break;

     

       
3369
       
 
       


     

       
3370
       
 
       
  case 102: /* float_ti_expr_tail: FZ_FLOAT_LIT FZ_DOTDOT FZ_FLOAT_LIT  */

     

       
3371
       
-
       
#line 1650 "../gecode/flatzinc/parser.yxx"

     

       
3372
       
 
       
      { std::pair<double,double>* dom = new std::pair<double,double>((yyvsp[-2].dValue),(yyvsp[0].dValue));

     

       
3373
       
 
       
        (yyval.oPFloat) = Option<std::pair<double,double>* >::some(dom); }

     

       
3374
       
-
       
#line 3375 "gecode/flatzinc/parser.tab.cpp"

     

       
3375
       
 
       
    break;

     

       
3376
       
 
       


     

       
3377
       
 
       
  case 103: /* set_literal: '{' int_list '}'  */

     

       
3378
       
-
       
#line 1659 "../gecode/flatzinc/parser.yxx"

     

       
3379
       
 
       
      { (yyval.setLit) = new AST::SetLit(*(yyvsp[-1].setValue)); }

     

       
3380
       
-
       
#line 3381 "gecode/flatzinc/parser.tab.cpp"

     

       
3381
       
 
       
    break;

     

       
3382
       
 
       


     

       
3383
       
 
       
  case 104: /* set_literal: FZ_INT_LIT FZ_DOTDOT FZ_INT_LIT  */

     

       
3384
       
-
       
#line 1661 "../gecode/flatzinc/parser.yxx"

     

       
3385
       
 
       
      { (yyval.setLit) = new AST::SetLit((yyvsp[-2].iValue), (yyvsp[0].iValue)); }

     

       
3386
       
-
       
#line 3387 "gecode/flatzinc/parser.tab.cpp"

     

       
3387
       
 
       
    break;

     

       
3388
       
 
       


     

       
3389
       
 
       
  case 105: /* int_list: %empty  */

     

       
3390
       
-
       
#line 1667 "../gecode/flatzinc/parser.yxx"

     

       
3391
       
 
       
      { (yyval.setValue) = new vector<int>(0); }

     

       
3392
       
-
       
#line 3393 "gecode/flatzinc/parser.tab.cpp"

     

       
3393
       
 
       
    break;

     

       
3394
       
 
       


     

       
3395
       
 
       
  case 106: /* int_list: int_list_head list_tail  */

     

       
3396
       
-
       
#line 1669 "../gecode/flatzinc/parser.yxx"

     

       
3397
       
 
       
      { (yyval.setValue) = (yyvsp[-1].setValue); }

     

       
3398
       
-
       
#line 3399 "gecode/flatzinc/parser.tab.cpp"

     

       
3399
       
 
       
    break;

     

       
3400
       
 
       


     

       
3401
       
 
       
  case 107: /* int_list_head: FZ_INT_LIT  */

     

       
3402
       
-
       
#line 1673 "../gecode/flatzinc/parser.yxx"

     

       
3403
       
 
       
      { (yyval.setValue) = new vector<int>(1); (*(yyval.setValue))[0] = (yyvsp[0].iValue); }

     

       
3404
       
-
       
#line 3405 "gecode/flatzinc/parser.tab.cpp"

     

       
3405
       
 
       
    break;

     

       
3406
       
 
       


     

       
3407
       
 
       
  case 108: /* int_list_head: int_list_head ',' FZ_INT_LIT  */

     

       
3408
       
-
       
#line 1675 "../gecode/flatzinc/parser.yxx"

     

       
3409
       
 
       
      { (yyval.setValue) = (yyvsp[-2].setValue); (yyval.setValue)->push_back((yyvsp[0].iValue)); }

     

       
3410
       
-
       
#line 3411 "gecode/flatzinc/parser.tab.cpp"

     

       
3411
       
 
       
    break;

     

       
3412
       
 
       


     

       
3413
       
 
       
  case 109: /* bool_list: %empty  */

     

       
3414
       
-
       
#line 1679 "../gecode/flatzinc/parser.yxx"

     

       
3415
       
 
       
      { (yyval.setValue) = new vector<int>(0); }

     

       
3416
       
-
       
#line 3417 "gecode/flatzinc/parser.tab.cpp"

     

       
3417
       
 
       
    break;

     

       
3418
       
 
       


     

       
3419
       
 
       
  case 110: /* bool_list: bool_list_head list_tail  */

     

       
3420
       
-
       
#line 1681 "../gecode/flatzinc/parser.yxx"

     

       
3421
       
 
       
      { (yyval.setValue) = (yyvsp[-1].setValue); }

     

       
3422
       
-
       
#line 3423 "gecode/flatzinc/parser.tab.cpp"

     

       
3423
       
 
       
    break;

     

       
3424
       
 
       


     

       
3425
       
 
       
  case 111: /* bool_list_head: FZ_BOOL_LIT  */

     

       
3426
       
-
       
#line 1685 "../gecode/flatzinc/parser.yxx"

     

       
3427
       
 
       
      { (yyval.setValue) = new vector<int>(1); (*(yyval.setValue))[0] = (yyvsp[0].iValue); }

     

       
3428
       
-
       
#line 3429 "gecode/flatzinc/parser.tab.cpp"

     

       
3429
       
 
       
    break;

     

       
3430
       
 
       


     

       
3431
       
 
       
  case 112: /* bool_list_head: bool_list_head ',' FZ_BOOL_LIT  */

     

       
3432
       
-
       
#line 1687 "../gecode/flatzinc/parser.yxx"

     

       
3433
       
 
       
      { (yyval.setValue) = (yyvsp[-2].setValue); (yyval.setValue)->push_back((yyvsp[0].iValue)); }

     

       
3434
       
-
       
#line 3435 "gecode/flatzinc/parser.tab.cpp"

     

       
3435
       
 
       
    break;

     

       
3436
       
 
       


     

       
3437
       
 
       
  case 113: /* float_list: %empty  */

     

       
3438
       
-
       
#line 1691 "../gecode/flatzinc/parser.yxx"

     

       
3439
       
 
       
      { (yyval.floatSetValue) = new vector<double>(0); }

     

       
3440
       
-
       
#line 3441 "gecode/flatzinc/parser.tab.cpp"

     

       
3441
       
 
       
    break;

     

       
3442
       
 
       


     

       
3443
       
 
       
  case 114: /* float_list: float_list_head list_tail  */

     

       
3444
       
-
       
#line 1693 "../gecode/flatzinc/parser.yxx"

     

       
3445
       
 
       
      { (yyval.floatSetValue) = (yyvsp[-1].floatSetValue); }

     

       
3446
       
-
       
#line 3447 "gecode/flatzinc/parser.tab.cpp"

     

       
3447
       
 
       
    break;

     

       
3448
       
 
       


     

       
3449
       
 
       
  case 115: /* float_list_head: FZ_FLOAT_LIT  */

     

       
3450
       
-
       
#line 1697 "../gecode/flatzinc/parser.yxx"

     

       
3451
       
 
       
      { (yyval.floatSetValue) = new vector<double>(1); (*(yyval.floatSetValue))[0] = (yyvsp[0].dValue); }

     

       
3452
       
-
       
#line 3453 "gecode/flatzinc/parser.tab.cpp"

     

       
3453
       
 
       
    break;

     

       
3454
       
 
       


     

       
3455
       
 
       
  case 116: /* float_list_head: float_list_head ',' FZ_FLOAT_LIT  */

     

       
3456
       
-
       
#line 1699 "../gecode/flatzinc/parser.yxx"

     

       
3457
       
 
       
      { (yyval.floatSetValue) = (yyvsp[-2].floatSetValue); (yyval.floatSetValue)->push_back((yyvsp[0].dValue)); }

     

       
3458
       
-
       
#line 3459 "gecode/flatzinc/parser.tab.cpp"

     

       
3459
       
 
       
    break;

     

       
3460
       
 
       


     

       
3461
       
 
       
  case 117: /* set_literal_list: %empty  */

     

       
3462
       
-
       
#line 1703 "../gecode/flatzinc/parser.yxx"

     

       
3463
       
 
       
      { (yyval.setValueList) = new vector<AST::SetLit>(0); }

     

       
3464
       
-
       
#line 3465 "gecode/flatzinc/parser.tab.cpp"

     

       
3465
       
 
       
    break;

     

       
3466
       
 
       


     

       
3467
       
 
       
  case 118: /* set_literal_list: set_literal_list_head list_tail  */

     

       
3468
       
-
       
#line 1705 "../gecode/flatzinc/parser.yxx"

     

       
3469
       
 
       
      { (yyval.setValueList) = (yyvsp[-1].setValueList); }

     

       
3470
       
-
       
#line 3471 "gecode/flatzinc/parser.tab.cpp"

     

       
3471
       
 
       
    break;

     

       
3472
       
 
       


     

       
3473
       
 
       
  case 119: /* set_literal_list_head: set_literal  */

     

       
3474
       
-
       
#line 1709 "../gecode/flatzinc/parser.yxx"

     

       
3475
       
 
       
      { (yyval.setValueList) = new vector<AST::SetLit>(1); (*(yyval.setValueList))[0] = *(yyvsp[0].setLit); delete (yyvsp[0].setLit); }

     

       
3476
       
-
       
#line 3477 "gecode/flatzinc/parser.tab.cpp"

     

       
3477
       
 
       
    break;

     

       
3478
       
 
       


     

       
3479
       
 
       
  case 120: /* set_literal_list_head: set_literal_list_head ',' set_literal  */

     

       
3480
       
-
       
#line 1711 "../gecode/flatzinc/parser.yxx"

     

       
3481
       
 
       
      { (yyval.setValueList) = (yyvsp[-2].setValueList); (yyval.setValueList)->push_back(*(yyvsp[0].setLit)); delete (yyvsp[0].setLit); }

     

       
3482
       
-
       
#line 3483 "gecode/flatzinc/parser.tab.cpp"

     

       
3483
       
 
       
    break;

     

       
3484
       
 
       


     

       
3485
       
 
       
  case 121: /* flat_expr_list: flat_expr  */

     

       
3486
       
-
       
#line 1719 "../gecode/flatzinc/parser.yxx"

     

       
3487
       
 
       
      { (yyval.argVec) = new AST::Array((yyvsp[0].arg)); }

     

       
3488
       
-
       
#line 3489 "gecode/flatzinc/parser.tab.cpp"

     

       
3489
       
 
       
    break;

     

       
3490
       
 
       


     

       
3491
       
 
       
  case 122: /* flat_expr_list: flat_expr_list ',' flat_expr  */

     

       
3492
       
-
       
#line 1721 "../gecode/flatzinc/parser.yxx"

     

       
3493
       
 
       
      { (yyval.argVec) = (yyvsp[-2].argVec); (yyval.argVec)->append((yyvsp[0].arg)); }

     

       
3494
       
-
       
#line 3495 "gecode/flatzinc/parser.tab.cpp"

     

       
3495
       
 
       
    break;

     

       
3496
       
 
       


     

       
3497
       
 
       
  case 123: /* flat_expr: non_array_expr  */

     

       
3498
       
-
       
#line 1725 "../gecode/flatzinc/parser.yxx"

     

       
3499
       
 
       
      { (yyval.arg) = (yyvsp[0].arg); }

     

       
3500
       
-
       
#line 3501 "gecode/flatzinc/parser.tab.cpp"

     

       
3501
       
 
       
    break;

     

       
3502
       
 
       


     

       
3503
       
 
       
  case 124: /* flat_expr: '[' non_array_expr_list ']'  */

     

       
3504
       
-
       
#line 1727 "../gecode/flatzinc/parser.yxx"

     

       
3505
       
 
       
      { (yyval.arg) = (yyvsp[-1].argVec); }

     

       
3506
       
-
       
#line 3507 "gecode/flatzinc/parser.tab.cpp"

     

       
3507
       
 
       
    break;

     

       
3508
       
 
       


     

       
3509
       
 
       
  case 125: /* non_array_expr_opt: %empty  */

     

       
3510
       
-
       
#line 1731 "../gecode/flatzinc/parser.yxx"

     

       
3511
       
 
       
      { (yyval.oArg) = Option<AST::Node*>::none(); }

     

       
3512
       
-
       
#line 3513 "gecode/flatzinc/parser.tab.cpp"

     

       
3513
       
 
       
    break;

     

       
3514
       
 
       


     

       
3515
       
 
       
  case 126: /* non_array_expr_opt: '=' non_array_expr  */

     

       
3516
       
-
       
#line 1733 "../gecode/flatzinc/parser.yxx"

     

       
3517
       
 
       
      { (yyval.oArg) = Option<AST::Node*>::some((yyvsp[0].arg)); }

     

       
3518
       
-
       
#line 3519 "gecode/flatzinc/parser.tab.cpp"

     

       
3519
       
 
       
    break;

     

       
3520
       
 
       


     

       
3521
       
 
       
  case 127: /* non_array_expr: FZ_BOOL_LIT  */

     

       
3522
       
-
       
#line 1737 "../gecode/flatzinc/parser.yxx"

     

       
3523
       
 
       
      { (yyval.arg) = new AST::BoolLit((yyvsp[0].iValue)); }

     

       
3524
       
-
       
#line 3525 "gecode/flatzinc/parser.tab.cpp"

     

       
3525
       
 
       
    break;

     

       
3526
       
 
       


     

       
3527
       
 
       
  case 128: /* non_array_expr: FZ_INT_LIT  */

     

       
3528
       
-
       
#line 1739 "../gecode/flatzinc/parser.yxx"

     

       
3529
       
 
       
      { (yyval.arg) = new AST::IntLit((yyvsp[0].iValue)); }

     

       
3530
       
-
       
#line 3531 "gecode/flatzinc/parser.tab.cpp"

     

       
3531
       
 
       
    break;

     

       
3532
       
 
       


     

       
3533
       
 
       
  case 129: /* non_array_expr: FZ_FLOAT_LIT  */

     

       
3534
       
-
       
#line 1741 "../gecode/flatzinc/parser.yxx"

     

       
3535
       
 
       
      { (yyval.arg) = new AST::FloatLit((yyvsp[0].dValue)); }

     

       
3536
       
-
       
#line 3537 "gecode/flatzinc/parser.tab.cpp"

     

       
3537
       
 
       
    break;

     

       
3538
       
 
       


     

       
3539
       
 
       
  case 130: /* non_array_expr: set_literal  */

     

       
3540
       
-
       
#line 1743 "../gecode/flatzinc/parser.yxx"

     

       
3541
       
 
       
      { (yyval.arg) = (yyvsp[0].setLit); }

     

       
3542
       
-
       
#line 3543 "gecode/flatzinc/parser.tab.cpp"

     

       
3543
       
 
       
    break;

     

       
3544
       
 
       


     

       
3545
       
 
       
  case 131: /* non_array_expr: var_par_id  */

     

       
3546
       
-
       
#line 1745 "../gecode/flatzinc/parser.yxx"

     

       
3547
       
 
       
      {

     

       
3548
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
3549
       
 
       
        SymbolEntry e;

     
···

       
3639
       
 
       
        }

     

       
3640
       
 
       
        free((yyvsp[0].sValue));

     

       
3641
       
 
       
      }

     

       
3642
       
-
       
#line 3643 "gecode/flatzinc/parser.tab.cpp"

     

       
3643
       
 
       
    break;

     

       
3644
       
 
       


     

       
3645
       
 
       
  case 132: /* non_array_expr: var_par_id '[' non_array_expr ']'  */

     

       
3646
       
-
       
#line 1841 "../gecode/flatzinc/parser.yxx"

     

       
3647
       
 
       
      {

     

       
3648
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
3649
       
 
       
        int i = -1;

     
···

       
3655
       
 
       
        delete (yyvsp[-1].arg);

     

       
3656
       
 
       
        free((yyvsp[-3].sValue));

     

       
3657
       
 
       
      }

     

       
3658
       
-
       
#line 3659 "gecode/flatzinc/parser.tab.cpp"

     

       
3659
       
 
       
    break;

     

       
3660
       
 
       


     

       
3661
       
 
       
  case 133: /* non_array_expr_list: %empty  */

     

       
3662
       
-
       
#line 1855 "../gecode/flatzinc/parser.yxx"

     

       
3663
       
 
       
      { (yyval.argVec) = new AST::Array(0); }

     

       
3664
       
-
       
#line 3665 "gecode/flatzinc/parser.tab.cpp"

     

       
3665
       
 
       
    break;

     

       
3666
       
 
       


     

       
3667
       
 
       
  case 134: /* non_array_expr_list: non_array_expr_list_head list_tail  */

     

       
3668
       
-
       
#line 1857 "../gecode/flatzinc/parser.yxx"

     

       
3669
       
 
       
      { (yyval.argVec) = (yyvsp[-1].argVec); }

     

       
3670
       
-
       
#line 3671 "gecode/flatzinc/parser.tab.cpp"

     

       
3671
       
 
       
    break;

     

       
3672
       
 
       


     

       
3673
       
 
       
  case 135: /* non_array_expr_list_head: non_array_expr  */

     

       
3674
       
-
       
#line 1861 "../gecode/flatzinc/parser.yxx"

     

       
3675
       
 
       
      { (yyval.argVec) = new AST::Array((yyvsp[0].arg)); }

     

       
3676
       
-
       
#line 3677 "gecode/flatzinc/parser.tab.cpp"

     

       
3677
       
 
       
    break;

     

       
3678
       
 
       


     

       
3679
       
 
       
  case 136: /* non_array_expr_list_head: non_array_expr_list_head ',' non_array_expr  */

     

       
3680
       
-
       
#line 1863 "../gecode/flatzinc/parser.yxx"

     

       
3681
       
 
       
      { (yyval.argVec) = (yyvsp[-2].argVec); (yyval.argVec)->append((yyvsp[0].arg)); }

     

       
3682
       
-
       
#line 3683 "gecode/flatzinc/parser.tab.cpp"

     

       
3683
       
 
       
    break;

     

       
3684
       
 
       


     

       
3685
       
 
       
  case 137: /* solve_expr: var_par_id  */

     

       
3686
       
-
       
#line 1871 "../gecode/flatzinc/parser.yxx"

     

       
3687
       
 
       
      {

     

       
3688
       
 
       
        ParserState *pp = static_cast<ParserState*>(parm);

     

       
3689
       
 
       
        SymbolEntry e;

     
···

       
3717
       
 
       
        }

     

       
3718
       
 
       
        free((yyvsp[0].sValue));

     

       
3719
       
 
       
      }

     

       
3720
       
-
       
#line 3721 "gecode/flatzinc/parser.tab.cpp"

     

       
3721
       
 
       
    break;

     

       
3722
       
 
       


     

       
3723
       
 
       
  case 138: /* solve_expr: FZ_INT_LIT  */

     

       
3724
       
-
       
#line 1905 "../gecode/flatzinc/parser.yxx"

     

       
3725
       
 
       
      {

     

       
3726
       
 
       
        ParserState *pp = static_cast<ParserState*>(parm);

     

       
3727
       
 
       
        pp->intvars.push_back(varspec("OBJ_CONST_INTRODUCED",

     

       
3728
       
 
       
          new IntVarSpec(0,true,false)));

     

       
3729
       
 
       
        (yyval.iValue) = pp->intvars.size()-1;

     

       
3730
       
 
       
      }

     

       
3731
       
-
       
#line 3732 "gecode/flatzinc/parser.tab.cpp"

     

       
3732
       
 
       
    break;

     

       
3733
       
 
       


     

       
3734
       
 
       
  case 139: /* solve_expr: FZ_FLOAT_LIT  */

     

       
3735
       
-
       
#line 1912 "../gecode/flatzinc/parser.yxx"

     

       
3736
       
 
       
      {

     

       
3737
       
 
       
        ParserState *pp = static_cast<ParserState*>(parm);

     

       
3738
       
 
       
        pp->intvars.push_back(varspec("OBJ_CONST_INTRODUCED",

     

       
3739
       
 
       
          new IntVarSpec(0,true,false)));

     

       
3740
       
 
       
        (yyval.iValue) = pp->intvars.size()-1;

     

       
3741
       
 
       
      }

     

       
3742
       
-
       
#line 3743 "gecode/flatzinc/parser.tab.cpp"

     

       
3743
       
 
       
    break;

     

       
3744
       
 
       


     

       
3745
       
 
       
  case 140: /* solve_expr: var_par_id '[' FZ_INT_LIT ']'  */

     

       
3746
       
-
       
#line 1919 "../gecode/flatzinc/parser.yxx"

     

       
3747
       
 
       
      {

     

       
3748
       
 
       
        SymbolEntry e;

     

       
3749
       
 
       
        ParserState *pp = static_cast<ParserState*>(parm);

     
···

       
3767
       
 
       
        }

     

       
3768
       
 
       
        free((yyvsp[-3].sValue));

     

       
3769
       
 
       
      }

     

       
3770
       
-
       
#line 3771 "gecode/flatzinc/parser.tab.cpp"

     

       
3771
       
 
       
    break;

     

       
3772
       
 
       


     

       
3773
       
 
       
  case 143: /* annotations: %empty  */

     

       
3774
       
-
       
#line 1953 "../gecode/flatzinc/parser.yxx"

     

       
3775
       
 
       
      { (yyval.argVec) = NULL; }

     

       
3776
       
-
       
#line 3777 "gecode/flatzinc/parser.tab.cpp"

     

       
3777
       
 
       
    break;

     

       
3778
       
 
       


     

       
3779
       
 
       
  case 144: /* annotations: annotations_head  */

     

       
3780
       
-
       
#line 1955 "../gecode/flatzinc/parser.yxx"

     

       
3781
       
 
       
      { (yyval.argVec) = (yyvsp[0].argVec); }

     

       
3782
       
-
       
#line 3783 "gecode/flatzinc/parser.tab.cpp"

     

       
3783
       
 
       
    break;

     

       
3784
       
 
       


     

       
3785
       
 
       
  case 145: /* annotations_head: FZ_COLONCOLON annotation  */

     

       
3786
       
-
       
#line 1959 "../gecode/flatzinc/parser.yxx"

     

       
3787
       
 
       
      { (yyval.argVec) = new AST::Array((yyvsp[0].arg)); }

     

       
3788
       
-
       
#line 3789 "gecode/flatzinc/parser.tab.cpp"

     

       
3789
       
 
       
    break;

     

       
3790
       
 
       


     

       
3791
       
 
       
  case 146: /* annotations_head: annotations_head FZ_COLONCOLON annotation  */

     

       
3792
       
-
       
#line 1961 "../gecode/flatzinc/parser.yxx"

     

       
3793
       
 
       
      { (yyval.argVec) = (yyvsp[-2].argVec); (yyval.argVec)->append((yyvsp[0].arg)); }

     

       
3794
       
-
       
#line 3795 "gecode/flatzinc/parser.tab.cpp"

     

       
3795
       
 
       
    break;

     

       
3796
       
 
       


     

       
3797
       
 
       
  case 147: /* annotation: FZ_ID '(' annotation_list ')'  */

     

       
3798
       
-
       
#line 1965 "../gecode/flatzinc/parser.yxx"

     

       
3799
       
 
       
      {

     

       
3800
       
 
       
        (yyval.arg) = new AST::Call((yyvsp[-3].sValue), AST::extractSingleton((yyvsp[-1].arg))); free((yyvsp[-3].sValue));

     

       
3801
       
 
       
      }

     

       
3802
       
-
       
#line 3803 "gecode/flatzinc/parser.tab.cpp"

     

       
3803
       
 
       
    break;

     

       
3804
       
 
       


     

       
3805
       
 
       
  case 148: /* annotation: annotation_expr  */

     

       
3806
       
-
       
#line 1969 "../gecode/flatzinc/parser.yxx"

     

       
3807
       
 
       
      { (yyval.arg) = (yyvsp[0].arg); }

     

       
3808
       
-
       
#line 3809 "gecode/flatzinc/parser.tab.cpp"

     

       
3809
       
 
       
    break;

     

       
3810
       
 
       


     

       
3811
       
 
       
  case 149: /* annotation_list: annotation  */

     

       
3812
       
-
       
#line 1973 "../gecode/flatzinc/parser.yxx"

     

       
3813
       
 
       
      { (yyval.arg) = new AST::Array((yyvsp[0].arg)); }

     

       
3814
       
-
       
#line 3815 "gecode/flatzinc/parser.tab.cpp"

     

       
3815
       
 
       
    break;

     

       
3816
       
 
       


     

       
3817
       
 
       
  case 150: /* annotation_list: annotation_list ',' annotation  */

     

       
3818
       
-
       
#line 1975 "../gecode/flatzinc/parser.yxx"

     

       
3819
       
 
       
      { (yyval.arg) = (yyvsp[-2].arg); (yyval.arg)->append((yyvsp[0].arg)); }

     

       
3820
       
-
       
#line 3821 "gecode/flatzinc/parser.tab.cpp"

     

       
3821
       
 
       
    break;

     

       
3822
       
 
       


     

       
3823
       
 
       
  case 151: /* annotation_expr: ann_non_array_expr  */

     

       
3824
       
-
       
#line 1979 "../gecode/flatzinc/parser.yxx"

     

       
3825
       
 
       
      { (yyval.arg) = (yyvsp[0].arg); }

     

       
3826
       
-
       
#line 3827 "gecode/flatzinc/parser.tab.cpp"

     

       
3827
       
 
       
    break;

     

       
3828
       
 
       


     

       
3829
       
 
       
  case 152: /* annotation_expr: '[' ']'  */

     

       
3830
       
-
       
#line 1981 "../gecode/flatzinc/parser.yxx"

     

       
3831
       
 
       
      { (yyval.arg) = new AST::Array(); }

     

       
3832
       
-
       
#line 3833 "gecode/flatzinc/parser.tab.cpp"

     

       
3833
       
 
       
    break;

     

       
3834
       
 
       


     

       
3835
       
 
       
  case 153: /* annotation_expr: '[' annotation_list annotation_list_tail ']'  */

     

       
3836
       
-
       
#line 1983 "../gecode/flatzinc/parser.yxx"

     

       
3837
       
 
       
      { (yyval.arg) = (yyvsp[-2].arg); }

     

       
3838
       
-
       
#line 3839 "gecode/flatzinc/parser.tab.cpp"

     

       
3839
       
 
       
    break;

     

       
3840
       
 
       


     

       
3841
       
 
       
  case 156: /* ann_non_array_expr: FZ_BOOL_LIT  */

     

       
3842
       
-
       
#line 1989 "../gecode/flatzinc/parser.yxx"

     

       
3843
       
 
       
      { (yyval.arg) = new AST::BoolLit((yyvsp[0].iValue)); }

     

       
3844
       
-
       
#line 3845 "gecode/flatzinc/parser.tab.cpp"

     

       
3845
       
 
       
    break;

     

       
3846
       
 
       


     

       
3847
       
 
       
  case 157: /* ann_non_array_expr: FZ_INT_LIT  */

     

       
3848
       
-
       
#line 1991 "../gecode/flatzinc/parser.yxx"

     

       
3849
       
 
       
      { (yyval.arg) = new AST::IntLit((yyvsp[0].iValue)); }

     

       
3850
       
-
       
#line 3851 "gecode/flatzinc/parser.tab.cpp"

     

       
3851
       
 
       
    break;

     

       
3852
       
 
       


     

       
3853
       
 
       
  case 158: /* ann_non_array_expr: FZ_FLOAT_LIT  */

     

       
3854
       
-
       
#line 1993 "../gecode/flatzinc/parser.yxx"

     

       
3855
       
 
       
      { (yyval.arg) = new AST::FloatLit((yyvsp[0].dValue)); }

     

       
3856
       
-
       
#line 3857 "gecode/flatzinc/parser.tab.cpp"

     

       
3857
       
 
       
    break;

     

       
3858
       
 
       


     

       
3859
       
 
       
  case 159: /* ann_non_array_expr: set_literal  */

     

       
3860
       
-
       
#line 1995 "../gecode/flatzinc/parser.yxx"

     

       
3861
       
 
       
      { (yyval.arg) = (yyvsp[0].setLit); }

     

       
3862
       
-
       
#line 3863 "gecode/flatzinc/parser.tab.cpp"

     

       
3863
       
 
       
    break;

     

       
3864
       
 
       


     

       
3865
       
 
       
  case 160: /* ann_non_array_expr: var_par_id  */

     

       
3866
       
-
       
#line 1997 "../gecode/flatzinc/parser.yxx"

     

       
3867
       
 
       
      {

     

       
3868
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
3869
       
 
       
        SymbolEntry e;

     
···

       
3969
       
 
       
          (yyval.arg) = getVarRefArg(pp,(yyvsp[0].sValue),true);

     

       
3970
       
 
       
        free((yyvsp[0].sValue));

     

       
3971
       
 
       
      }

     

       
3972
       
-
       
#line 3973 "gecode/flatzinc/parser.tab.cpp"

     

       
3973
       
 
       
    break;

     

       
3974
       
 
       


     

       
3975
       
 
       
  case 161: /* ann_non_array_expr: var_par_id '[' ann_non_array_expr ']'  */

     

       
3976
       
-
       
#line 2103 "../gecode/flatzinc/parser.yxx"

     

       
3977
       
 
       
      {

     

       
3978
       
 
       
        ParserState* pp = static_cast<ParserState*>(parm);

     

       
3979
       
 
       
        int i = -1;

     
···

       
3984
       
 
       
          (yyval.arg) = new AST::IntLit(0); // keep things consistent

     

       
3985
       
 
       
        free((yyvsp[-3].sValue));

     

       
3986
       
 
       
      }

     

       
3987
       
-
       
#line 3988 "gecode/flatzinc/parser.tab.cpp"

     

       
3988
       
 
       
    break;

     

       
3989
       
 
       


     

       
3990
       
 
       
  case 162: /* ann_non_array_expr: FZ_STRING_LIT  */

     

       
3991
       
-
       
#line 2114 "../gecode/flatzinc/parser.yxx"

     

       
3992
       
 
       
      {

     

       
3993
       
 
       
        (yyval.arg) = new AST::String((yyvsp[0].sValue));

     

       
3994
       
 
       
        free((yyvsp[0].sValue));

     

       
3995
       
 
       
      }

     

       
3996
       
-
       
#line 3997 "gecode/flatzinc/parser.tab.cpp"

     

       
3997
       
 
       
    break;

     

       
3998
       
 
       


     

       
3999
       
 
       


     

       
4000
       
-
       
#line 4001 "gecode/flatzinc/parser.tab.cpp"

     

       
4001
       
 
       


     

       
4002
       
 
       
      default: break;

     

       
4003
       
 
       
    }