OR-Tools  9.1
parser.tab.cc
Go to the documentation of this file.
1// Copyright 2010-2021 Google LLC
2// Licensed under the Apache License, Version 2.0 (the "License");
3// you may not use this file except in compliance with the License.
4// You may obtain a copy of the License at
5//
6// http://www.apache.org/licenses/LICENSE-2.0
7//
8// Unless required by applicable law or agreed to in writing, software
9// distributed under the License is distributed on an "AS IS" BASIS,
10// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
11// See the License for the specific language governing permissions and
12// limitations under the License.
13
14/* A Bison parser, made by GNU Bison 3.7.6. */
15
16/* Bison implementation for Yacc-like parsers in C
17
18 Copyright (C) 1984, 1989-1990, 2000-2015, 2018-2021 Free Software Foundation,
19 Inc.
20
21 This program is free software: you can redistribute it and/or modify
22 it under the terms of the GNU General Public License as published by
23 the Free Software Foundation, either version 3 of the License, or
24 (at your option) any later version.
25
26 This program is distributed in the hope that it will be useful,
27 but WITHOUT ANY WARRANTY; without even the implied warranty of
28 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
29 GNU General Public License for more details.
30
31 You should have received a copy of the GNU General Public License
32 along with this program. If not, see <https://www.gnu.org/licenses/>. */
33
34/* As a special exception, you may create a larger work that contains
35 part or all of the Bison parser skeleton and distribute that work
36 under terms of your choice, so long as that work isn't itself a
37 parser generator using the skeleton or a modified version thereof
38 as a parser skeleton. Alternatively, if you modify or redistribute
39 the parser skeleton itself, you may (at your option) remove this
40 special exception, which will cause the skeleton and the resulting
41 Bison output files to be licensed under the GNU General Public
42 License without this special exception.
43
44 This special exception was added by the Free Software Foundation in
45 version 2.2 of Bison. */
46
47/* C LALR(1) parser skeleton written by Richard Stallman, by
48 simplifying the original so-called "semantic" parser. */
49
50/* DO NOT RELY ON FEATURES THAT ARE NOT DOCUMENTED in the manual,
51 especially those whose name start with YY_ or yy_. They are
52 private implementation details that can be changed or removed. */
53
54/* All symbols defined below should begin with yy or YY, to avoid
55 infringing on user name space. This should be done even for local
56 variables, as they might otherwise be expanded by user macros.
57 There are some unavoidable exceptions within include files to
58 define necessary library symbols; they are noted "INFRINGES ON
59 USER NAME SPACE" below. */
60
61/* Identify Bison output, and Bison version. */
62#define YYBISON 30706
63
64/* Bison version string. */
65#define YYBISON_VERSION "3.7.6"
66
67/* Skeleton name. */
68#define YYSKELETON_NAME "yacc.c"
69
70/* Pure parsers. */
71#define YYPURE 2
72
73/* Push parsers. */
74#define YYPUSH 0
75
76/* Pull parsers. */
77#define YYPULL 1
78
79/* Substitute the type names. */
80#define YYSTYPE ORFZ_STYPE
81/* Substitute the variable and function names. */
82#define yyparse orfz_parse
83#define yylex orfz_lex
84#define yyerror orfz_error
85#define yydebug orfz_debug
86#define yynerrs orfz_nerrs
87
88#ifndef YY_CAST
89#ifdef __cplusplus
90#define YY_CAST(Type, Val) static_cast<Type>(Val)
91#define YY_REINTERPRET_CAST(Type, Val) reinterpret_cast<Type>(Val)
92#else
93#define YY_CAST(Type, Val) ((Type)(Val))
94#define YY_REINTERPRET_CAST(Type, Val) ((Type)(Val))
95#endif
96#endif
97#ifndef YY_NULLPTR
98#if defined __cplusplus
99#if 201103L <= __cplusplus
100#define YY_NULLPTR nullptr
101#else
102#define YY_NULLPTR 0
103#endif
104#else
105#define YY_NULLPTR ((void*)0)
106#endif
107#endif
108
109#include "parser.tab.hh"
110/* Symbol kind. */
111enum yysymbol_kind_t {
112 YYSYMBOL_YYEMPTY = -2,
113 YYSYMBOL_YYEOF = 0, /* "end of file" */
114 YYSYMBOL_YYerror = 1, /* error */
115 YYSYMBOL_YYUNDEF = 2, /* "invalid token" */
116 YYSYMBOL_ARRAY = 3, /* ARRAY */
117 YYSYMBOL_TOKEN_BOOL = 4, /* TOKEN_BOOL */
118 YYSYMBOL_CONSTRAINT = 5, /* CONSTRAINT */
119 YYSYMBOL_TOKEN_FLOAT = 6, /* TOKEN_FLOAT */
120 YYSYMBOL_TOKEN_INT = 7, /* TOKEN_INT */
121 YYSYMBOL_MAXIMIZE = 8, /* MAXIMIZE */
122 YYSYMBOL_MINIMIZE = 9, /* MINIMIZE */
123 YYSYMBOL_OF = 10, /* OF */
124 YYSYMBOL_PREDICATE = 11, /* PREDICATE */
125 YYSYMBOL_SATISFY = 12, /* SATISFY */
126 YYSYMBOL_SET = 13, /* SET */
127 YYSYMBOL_SOLVE = 14, /* SOLVE */
128 YYSYMBOL_VAR = 15, /* VAR */
129 YYSYMBOL_DOTDOT = 16, /* DOTDOT */
130 YYSYMBOL_COLONCOLON = 17, /* COLONCOLON */
131 YYSYMBOL_IVALUE = 18, /* IVALUE */
132 YYSYMBOL_SVALUE = 19, /* SVALUE */
133 YYSYMBOL_IDENTIFIER = 20, /* IDENTIFIER */
134 YYSYMBOL_DVALUE = 21, /* DVALUE */
135 YYSYMBOL_22_ = 22, /* ';' */
136 YYSYMBOL_23_ = 23, /* '(' */
137 YYSYMBOL_24_ = 24, /* ')' */
138 YYSYMBOL_25_ = 25, /* ',' */
139 YYSYMBOL_26_ = 26, /* ':' */
140 YYSYMBOL_27_ = 27, /* '[' */
141 YYSYMBOL_28_ = 28, /* ']' */
142 YYSYMBOL_29_ = 29, /* '=' */
143 YYSYMBOL_30_ = 30, /* '{' */
144 YYSYMBOL_31_ = 31, /* '}' */
145 YYSYMBOL_YYACCEPT = 32, /* $accept */
146 YYSYMBOL_model = 33, /* model */
147 YYSYMBOL_predicates = 34, /* predicates */
148 YYSYMBOL_predicate = 35, /* predicate */
149 YYSYMBOL_predicate_arguments = 36, /* predicate_arguments */
150 YYSYMBOL_predicate_argument = 37, /* predicate_argument */
151 YYSYMBOL_predicate_array_argument = 38, /* predicate_array_argument */
152 YYSYMBOL_predicate_ints = 39, /* predicate_ints */
153 YYSYMBOL_variable_or_constant_declarations =
154 40, /* variable_or_constant_declarations */
155 YYSYMBOL_variable_or_constant_declaration =
156 41, /* variable_or_constant_declaration */
157 YYSYMBOL_optional_var_or_value = 42, /* optional_var_or_value */
158 YYSYMBOL_optional_var_or_value_array = 43, /* optional_var_or_value_array */
159 YYSYMBOL_var_or_value_array = 44, /* var_or_value_array */
160 YYSYMBOL_var_or_value = 45, /* var_or_value */
161 YYSYMBOL_int_domain = 46, /* int_domain */
162 YYSYMBOL_set_domain = 47, /* set_domain */
163 YYSYMBOL_float_domain = 48, /* float_domain */
164 YYSYMBOL_domain = 49, /* domain */
165 YYSYMBOL_integers = 50, /* integers */
166 YYSYMBOL_integer = 51, /* integer */
167 YYSYMBOL_floats = 52, /* floats */
168 YYSYMBOL_float = 53, /* float */
169 YYSYMBOL_const_literal = 54, /* const_literal */
170 YYSYMBOL_const_literals = 55, /* const_literals */
171 YYSYMBOL_constraints = 56, /* constraints */
172 YYSYMBOL_constraint = 57, /* constraint */
173 YYSYMBOL_arguments = 58, /* arguments */
174 YYSYMBOL_argument = 59, /* argument */
175 YYSYMBOL_annotations = 60, /* annotations */
176 YYSYMBOL_annotation_arguments = 61, /* annotation_arguments */
177 YYSYMBOL_annotation = 62, /* annotation */
178 YYSYMBOL_solve = 63 /* solve */
179};
180typedef enum yysymbol_kind_t yysymbol_kind_t;
181
182/* Unqualified %code blocks. */
183#line 36 "./ortools/flatzinc/parser.yy"
184
185#include "absl/strings/match.h"
186#include "absl/strings/str_format.h"
187#include "ortools/flatzinc/parser_util.cc"
188
189using operations_research::fz::Annotation;
190using operations_research::fz::Argument;
191using operations_research::fz::Constraint;
192using operations_research::fz::ConvertAsIntegerOrDie;
193using operations_research::fz::Domain;
194using operations_research::fz::Lookup;
195using operations_research::fz::Model;
196using operations_research::fz::ParserContext;
197using operations_research::fz::SolutionOutputSpecs;
198using operations_research::fz::Variable;
199using operations_research::fz::VarRefOrValue;
200
201#line 191 "./ortools/flatzinc/parser.tab.cc"
202
203#ifdef short
204#undef short
205#endif
206
207/* On compilers that do not define __PTRDIFF_MAX__ etc., make sure
208 <limits.h> and (if available) <stdint.h> are included
209 so that the code can choose integer types of a good width. */
210
211#ifndef __PTRDIFF_MAX__
212#include <limits.h> /* INFRINGES ON USER NAME SPACE */
213#if defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
214#include <stdint.h> /* INFRINGES ON USER NAME SPACE */
215#define YY_STDINT_H
216#endif
217#endif
218
219/* Narrow types that promote to a signed type and that can represent a
220 signed or unsigned integer of at least N bits. In tables they can
221 save space and decrease cache pressure. Promoting to a signed type
222 helps avoid bugs in integer arithmetic. */
223
224#ifdef __INT_LEAST8_MAX__
225typedef __INT_LEAST8_TYPE__ yytype_int8;
226#elif defined YY_STDINT_H
227typedef int_least8_t yytype_int8;
228#else
229typedef signed char yytype_int8;
230#endif
231
232#ifdef __INT_LEAST16_MAX__
233typedef __INT_LEAST16_TYPE__ yytype_int16;
234#elif defined YY_STDINT_H
235typedef int_least16_t yytype_int16;
236#else
237typedef short yytype_int16;
238#endif
239
240/* Work around bug in HP-UX 11.23, which defines these macros
241 incorrectly for preprocessor constants. This workaround can likely
242 be removed in 2023, as HPE has promised support for HP-UX 11.23
243 (aka HP-UX 11i v2) only through the end of 2022; see Table 2 of
244 <https://h20195.www2.hpe.com/V2/getpdf.aspx/4AA4-7673ENW.pdf>. */
245#ifdef __hpux
246#undef UINT_LEAST8_MAX
247#undef UINT_LEAST16_MAX
248#define UINT_LEAST8_MAX 255
249#define UINT_LEAST16_MAX 65535
250#endif
251
252#if defined __UINT_LEAST8_MAX__ && __UINT_LEAST8_MAX__ <= __INT_MAX__
253typedef __UINT_LEAST8_TYPE__ yytype_uint8;
254#elif (!defined __UINT_LEAST8_MAX__ && defined YY_STDINT_H && \
255 UINT_LEAST8_MAX <= INT_MAX)
256typedef uint_least8_t yytype_uint8;
257#elif !defined __UINT_LEAST8_MAX__ && UCHAR_MAX <= INT_MAX
258typedef unsigned char yytype_uint8;
259#else
260typedef short yytype_uint8;
261#endif
262
263#if defined __UINT_LEAST16_MAX__ && __UINT_LEAST16_MAX__ <= __INT_MAX__
264typedef __UINT_LEAST16_TYPE__ yytype_uint16;
265#elif (!defined __UINT_LEAST16_MAX__ && defined YY_STDINT_H && \
266 UINT_LEAST16_MAX <= INT_MAX)
267typedef uint_least16_t yytype_uint16;
268#elif !defined __UINT_LEAST16_MAX__ && USHRT_MAX <= INT_MAX
269typedef unsigned short yytype_uint16;
270#else
271typedef int yytype_uint16;
272#endif
273
274#ifndef YYPTRDIFF_T
275#if defined __PTRDIFF_TYPE__ && defined __PTRDIFF_MAX__
276#define YYPTRDIFF_T __PTRDIFF_TYPE__
277#define YYPTRDIFF_MAXIMUM __PTRDIFF_MAX__
278#elif defined PTRDIFF_MAX
279#ifndef ptrdiff_t
280#include <stddef.h> /* INFRINGES ON USER NAME SPACE */
281#endif
282#define YYPTRDIFF_T ptrdiff_t
283#define YYPTRDIFF_MAXIMUM PTRDIFF_MAX
284#else
285#define YYPTRDIFF_T long
286#define YYPTRDIFF_MAXIMUM LONG_MAX
287#endif
288#endif
289
290#ifndef YYSIZE_T
291#ifdef __SIZE_TYPE__
292#define YYSIZE_T __SIZE_TYPE__
293#elif defined size_t
294#define YYSIZE_T size_t
295#elif defined __STDC_VERSION__ && 199901 <= __STDC_VERSION__
296#include <stddef.h> /* INFRINGES ON USER NAME SPACE */
297#define YYSIZE_T size_t
298#else
299#define YYSIZE_T unsigned
300#endif
301#endif
302
303#define YYSIZE_MAXIMUM \
304 YY_CAST(YYPTRDIFF_T, \
305 (YYPTRDIFF_MAXIMUM < YY_CAST(YYSIZE_T, -1) ? YYPTRDIFF_MAXIMUM \
306 : YY_CAST(YYSIZE_T, -1)))
307
308#define YYSIZEOF(X) YY_CAST(YYPTRDIFF_T, sizeof(X))
309
310/* Stored state numbers (used for stacks). */
311typedef yytype_uint8 yy_state_t;
312
313/* State numbers in computations. */
314typedef int yy_state_fast_t;
315
316#ifndef YY_
317#if defined YYENABLE_NLS && YYENABLE_NLS
318#if ENABLE_NLS
319#include <libintl.h> /* INFRINGES ON USER NAME SPACE */
320#define YY_(Msgid) dgettext("bison-runtime", Msgid)
321#endif
322#endif
323#ifndef YY_
324#define YY_(Msgid) Msgid
325#endif
326#endif
327
328#ifndef YY_ATTRIBUTE_PURE
329#if defined __GNUC__ && 2 < __GNUC__ + (96 <= __GNUC_MINOR__)
330#define YY_ATTRIBUTE_PURE __attribute__((__pure__))
331#else
332#define YY_ATTRIBUTE_PURE
333#endif
334#endif
335
336#ifndef YY_ATTRIBUTE_UNUSED
337#if defined __GNUC__ && 2 < __GNUC__ + (7 <= __GNUC_MINOR__)
338#define YY_ATTRIBUTE_UNUSED __attribute__((__unused__))
339#else
340#define YY_ATTRIBUTE_UNUSED
341#endif
342#endif
343
344/* Suppress unused-variable warnings by "using" E. */
345#if !defined lint || defined __GNUC__
346#define YY_USE(E) ((void)(E))
347#else
348#define YY_USE(E) /* empty */
349#endif
350
351#if defined __GNUC__ && !defined __ICC && 407 <= __GNUC__ * 100 + __GNUC_MINOR__
352/* Suppress an incorrect diagnostic about yylval being uninitialized. */
353#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN \
354 _Pragma("GCC diagnostic push") \
355 _Pragma("GCC diagnostic ignored \"-Wuninitialized\"") \
356 _Pragma("GCC diagnostic ignored \"-Wmaybe-uninitialized\"")
357#define YY_IGNORE_MAYBE_UNINITIALIZED_END _Pragma("GCC diagnostic pop")
358#else
359#define YY_INITIAL_VALUE(Value) Value
360#endif
361#ifndef YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
362#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
363#define YY_IGNORE_MAYBE_UNINITIALIZED_END
364#endif
365#ifndef YY_INITIAL_VALUE
366#define YY_INITIAL_VALUE(Value) /* Nothing. */
367#endif
368
369#if defined __cplusplus && defined __GNUC__ && !defined __ICC && 6 <= __GNUC__
370#define YY_IGNORE_USELESS_CAST_BEGIN \
371 _Pragma("GCC diagnostic push") \
372 _Pragma("GCC diagnostic ignored \"-Wuseless-cast\"")
373#define YY_IGNORE_USELESS_CAST_END _Pragma("GCC diagnostic pop")
374#endif
375#ifndef YY_IGNORE_USELESS_CAST_BEGIN
376#define YY_IGNORE_USELESS_CAST_BEGIN
377#define YY_IGNORE_USELESS_CAST_END
378#endif
379
380#define YY_ASSERT(E) ((void)(0 && (E)))
381
382#if 1
383
384/* The parser invokes alloca or malloc; define the necessary symbols. */
385
386#ifdef YYSTACK_USE_ALLOCA
387#if YYSTACK_USE_ALLOCA
388#ifdef __GNUC__
389#define YYSTACK_ALLOC __builtin_alloca
390#elif defined __BUILTIN_VA_ARG_INCR
391#include <alloca.h> /* INFRINGES ON USER NAME SPACE */
392#elif defined _AIX
393#define YYSTACK_ALLOC __alloca
394#elif defined _MSC_VER
395#include <malloc.h> /* INFRINGES ON USER NAME SPACE */
396#define alloca _alloca
397#else
398#define YYSTACK_ALLOC alloca
399#if !defined _ALLOCA_H && !defined EXIT_SUCCESS
400#include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
401/* Use EXIT_SUCCESS as a witness for stdlib.h. */
402#ifndef EXIT_SUCCESS
403#define EXIT_SUCCESS 0
404#endif
405#endif
406#endif
407#endif
408#endif
409
410#ifdef YYSTACK_ALLOC
411/* Pacify GCC's 'empty if-body' warning. */
412#define YYSTACK_FREE(Ptr) \
413 do { /* empty */ \
414 ; \
415 } while (0)
416#ifndef YYSTACK_ALLOC_MAXIMUM
417/* The OS might guarantee only one guard page at the bottom of the stack,
418 and a page size can be as small as 4096 bytes. So we cannot safely
419 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
420 to allow for a few compiler-allocated temporary stack slots. */
421#define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
422#endif
423#else
424#define YYSTACK_ALLOC YYMALLOC
425#define YYSTACK_FREE YYFREE
426#ifndef YYSTACK_ALLOC_MAXIMUM
427#define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
428#endif
429#if (defined __cplusplus && !defined EXIT_SUCCESS && \
430 !((defined YYMALLOC || defined malloc) && \
431 (defined YYFREE || defined free)))
432#include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
433#ifndef EXIT_SUCCESS
434#define EXIT_SUCCESS 0
435#endif
436#endif
437#ifndef YYMALLOC
438#define YYMALLOC malloc
439#if !defined malloc && !defined EXIT_SUCCESS
440void* malloc(YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
441#endif
442#endif
443#ifndef YYFREE
444#define YYFREE free
445#if !defined free && !defined EXIT_SUCCESS
446void free(void*); /* INFRINGES ON USER NAME SPACE */
447#endif
448#endif
449#endif
450#endif /* 1 */
451
452#if (!defined yyoverflow && \
453 (!defined __cplusplus || \
454 (defined ORFZ_STYPE_IS_TRIVIAL && ORFZ_STYPE_IS_TRIVIAL)))
455
456/* A type that is properly aligned for any stack member. */
457union yyalloc {
458 yy_state_t yyss_alloc;
459 YYSTYPE yyvs_alloc;
460};
461
462/* The size of the maximum gap between one aligned stack and the next. */
463#define YYSTACK_GAP_MAXIMUM (YYSIZEOF(union yyalloc) - 1)
464
465/* The size of an array large to enough to hold all stacks, each with
466 N elements. */
467#define YYSTACK_BYTES(N) \
468 ((N) * (YYSIZEOF(yy_state_t) + YYSIZEOF(YYSTYPE)) + YYSTACK_GAP_MAXIMUM)
469
470#define YYCOPY_NEEDED 1
471
472/* Relocate STACK from its old location to the new one. The
473 local variables YYSIZE and YYSTACKSIZE give the old and new number of
474 elements in the stack, and YYPTR gives the new location of the
475 stack. Advance YYPTR to a properly aligned location for the next
476 stack. */
477#define YYSTACK_RELOCATE(Stack_alloc, Stack) \
478 do { \
479 YYPTRDIFF_T yynewbytes; \
480 YYCOPY(&yyptr->Stack_alloc, Stack, yysize); \
481 Stack = &yyptr->Stack_alloc; \
482 yynewbytes = yystacksize * YYSIZEOF(*Stack) + YYSTACK_GAP_MAXIMUM; \
483 yyptr += yynewbytes / YYSIZEOF(*yyptr); \
484 } while (0)
485
486#endif
487
488#if defined YYCOPY_NEEDED && YYCOPY_NEEDED
489/* Copy COUNT objects from SRC to DST. The source and destination do
490 not overlap. */
491#ifndef YYCOPY
492#if defined __GNUC__ && 1 < __GNUC__
493#define YYCOPY(Dst, Src, Count) \
494 __builtin_memcpy(Dst, Src, YY_CAST(YYSIZE_T, (Count)) * sizeof(*(Src)))
495#else
496#define YYCOPY(Dst, Src, Count) \
497 do { \
498 YYPTRDIFF_T yyi; \
499 for (yyi = 0; yyi < (Count); yyi++) (Dst)[yyi] = (Src)[yyi]; \
500 } while (0)
501#endif
502#endif
503#endif /* !YYCOPY_NEEDED */
504
505/* YYFINAL -- State number of the termination state. */
506#define YYFINAL 3
507/* YYLAST -- Last index in YYTABLE. */
508#define YYLAST 274
509
510/* YYNTOKENS -- Number of terminals. */
511#define YYNTOKENS 32
512/* YYNNTS -- Number of nonterminals. */
513#define YYNNTS 32
514/* YYNRULES -- Number of rules. */
515#define YYNRULES 97
516/* YYNSTATES -- Number of states. */
517#define YYNSTATES 224
518
519/* YYMAXUTOK -- Last valid token kind. */
520#define YYMAXUTOK 276
521
522/* YYTRANSLATE(TOKEN-NUM) -- Symbol number corresponding to TOKEN-NUM
523 as returned by yylex, with out-of-bounds checking. */
524#define YYTRANSLATE(YYX) \
525 (0 <= (YYX) && (YYX) <= YYMAXUTOK \
526 ? YY_CAST(yysymbol_kind_t, yytranslate[YYX]) \
527 : YYSYMBOL_YYUNDEF)
528
529/* YYTRANSLATE[TOKEN-NUM] -- Symbol number corresponding to TOKEN-NUM
530 as returned by yylex. */
531static const yytype_int8 yytranslate[] = {
532 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
533 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
534 23, 24, 2, 2, 25, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 26, 22,
535 2, 29, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
536 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 27, 2, 28, 2, 2, 2, 2, 2, 2,
537 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
538 2, 2, 2, 30, 2, 31, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
539 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
540 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
541 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
542 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
543 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
544 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
545 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21};
546
547#if ORFZ_DEBUG
548/* YYRLINE[YYN] -- Source line where rule number YYN was defined. */
549static const yytype_int16 yyrline[] = {
550 0, 102, 102, 109, 113, 114, 119, 122, 123, 126, 127, 128, 129, 132,
551 133, 136, 137, 144, 145, 148, 167, 182, 193, 208, 219, 245, 278, 355,
552 356, 359, 360, 361, 364, 368, 374, 375, 376, 391, 412, 413, 414, 415,
553 422, 423, 424, 425, 432, 433, 438, 439, 440, 443, 444, 447, 448, 449,
554 454, 455, 458, 459, 460, 465, 466, 467, 472, 473, 476, 477, 483, 487,
555 493, 494, 497, 509, 510, 513, 514, 515, 516, 517, 522, 548, 565, 613,
556 622, 626, 629, 630, 633, 634, 635, 636, 646, 655, 661, 676, 684, 695};
557#endif
558
560#define YY_ACCESSING_SYMBOL(State) YY_CAST(yysymbol_kind_t, yystos[State])
561
562#if 1
563/* The user-facing name of the symbol whose (internal) number is
564 YYSYMBOL. No bounds checking. */
565static const char* yysymbol_name(yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED;
566
567/* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
568 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
569static const char* const yytname[] = {"\"end of file\"",
570 "error",
571 "\"invalid token\"",
572 "ARRAY",
573 "TOKEN_BOOL",
574 "CONSTRAINT",
575 "TOKEN_FLOAT",
576 "TOKEN_INT",
577 "MAXIMIZE",
578 "MINIMIZE",
579 "OF",
580 "PREDICATE",
581 "SATISFY",
582 "SET",
583 "SOLVE",
584 "VAR",
585 "DOTDOT",
586 "COLONCOLON",
587 "IVALUE",
588 "SVALUE",
589 "IDENTIFIER",
590 "DVALUE",
591 "';'",
592 "'('",
593 "')'",
594 "','",
595 "':'",
596 "'['",
597 "']'",
598 "'='",
599 "'{'",
600 "'}'",
601 "$accept",
602 "model",
603 "predicates",
604 "predicate",
605 "predicate_arguments",
606 "predicate_argument",
607 "predicate_array_argument",
608 "predicate_ints",
609 "variable_or_constant_declarations",
610 "variable_or_constant_declaration",
611 "optional_var_or_value",
612 "optional_var_or_value_array",
613 "var_or_value_array",
614 "var_or_value",
615 "int_domain",
616 "set_domain",
617 "float_domain",
618 "domain",
619 "integers",
620 "integer",
621 "floats",
622 "float",
623 "const_literal",
624 "const_literals",
625 "constraints",
626 "constraint",
627 "arguments",
628 "argument",
629 "annotations",
630 "annotation_arguments",
631 "annotation",
632 "solve",
633 YY_NULLPTR};
634
635static const char* yysymbol_name(yysymbol_kind_t yysymbol) {
636 return yytname[yysymbol];
637}
638#endif
639
640#ifdef YYPRINT
641/* YYTOKNUM[NUM] -- (External) token number corresponding to the
642 (internal) symbol number NUM (which must be that of a token). */
643static const yytype_int16 yytoknum[] = {0, 256, 257, 258, 259, 260, 261, 262,
644 263, 264, 265, 266, 267, 268, 269, 270,
645 271, 272, 273, 274, 275, 276, 59, 40,
646 41, 44, 58, 91, 93, 61, 123, 125};
647#endif
648
649#define YYPACT_NINF (-184)
650
651#define yypact_value_is_default(Yyn) ((Yyn) == YYPACT_NINF)
652
653#define YYTABLE_NINF (-19)
654
655#define yytable_value_is_error(Yyn) 0
656
657/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
658 STATE-NUM. */
659static const yytype_int16 yypact[] = {
660 -184, 26, 7, -184, -15, 41, 24, 36, -184, 64, -184, 70,
661 -184, -184, -184, 112, 88, 117, 129, 155, 116, -184, -184, -184,
662 121, 132, 49, 143, 20, 126, 164, 162, -184, 157, -2, -184,
663 -184, 123, 165, -184, 166, 167, 159, 88, 163, 168, 169, 174,
664 -184, -184, 175, 155, 172, -184, -184, 176, 155, -184, -184, 173,
665 127, -184, -184, 53, 171, -184, 49, 178, 181, 182, 38, -184,
666 177, -184, 16, 84, 84, 84, -184, 122, 179, 185, 180, -184,
667 183, -184, -184, 184, -184, -184, 30, -184, 14, 186, -184, 187,
668 -184, 95, 155, 152, -184, -184, -184, 190, -184, 98, 122, -184,
669 200, 191, 201, -184, 203, 139, -184, 194, 188, -184, -1, -184,
670 198, 199, -184, 192, -184, -184, 82, -184, 125, -184, 84, 202,
671 122, 204, 138, -184, -184, -184, 68, 78, -184, 205, 206, -184,
672 133, -184, 193, 207, 139, -184, -184, 209, -184, -184, 154, 208,
673 122, -184, 88, 211, 88, 212, 213, 214, -184, 215, -184, -184,
674 216, -184, -184, -184, -184, 219, 210, 220, 221, 222, 227, -184,
675 -184, 228, -184, 229, -184, -184, -184, -184, -184, 48, 59, 61,
676 83, 223, 224, 225, 226, -184, 106, 14, 134, 99, -184, 140,
677 -184, 142, 230, -184, -184, 144, -184, -184, 146, -184, 14, -184,
678 217, 160, -184, -184, -184, 231, -184, -184};
679
680/* YYDEFACT[STATE-NUM] -- Default reduction number in state STATE-NUM.
681 Performed when YYTABLE does not specify something else to do. Zero
682 means the default is an error. */
683static const yytype_int8 yydefact[] = {
684 5, 0, 0, 1, 0, 0, 0, 71, 4, 0, 3, 0, 38, 46, 39, 0, 0, 0, 0,
685 0, 0, 48, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 53, 54, 0, 52, 17, 0,
686 0, 85, 0, 0, 0, 0, 0, 8, 0, 0, 42, 43, 0, 0, 0, 40, 47, 0, 0,
687 41, 85, 0, 0, 70, 2, 0, 0, 6, 0, 0, 0, 0, 0, 85, 0, 51, 0, 0,
688 0, 0, 95, 0, 16, 0, 0, 13, 0, 7, 9, 0, 44, 45, 28, 55, 0, 75, 77,
689 80, 76, 0, 0, 0, 74, 97, 96, 89, 90, 91, 0, 84, 0, 0, 0, 10, 0, 0,
690 25, 61, 66, 65, 0, 19, 0, 0, 34, 36, 35, 83, 0, 33, 0, 85, 0, 0, 0,
691 0, 0, 87, 15, 14, 0, 0, 27, 0, 0, 64, 0, 78, 0, 0, 0, 82, 79, 72,
692 73, 88, 0, 0, 0, 94, 0, 0, 0, 0, 0, 0, 62, 0, 63, 81, 0, 32, 92,
693 93, 86, 0, 0, 0, 0, 0, 0, 67, 37, 0, 11, 0, 85, 85, 85, 12, 85, 0,
694 0, 0, 31, 0, 0, 0, 0, 26, 0, 0, 0, 0, 21, 0, 69, 0, 59, 58, 23,
695 0, 57, 30, 0, 20, 0, 24, 0, 0, 22, 29, 68, 0, 56, 60};
696
697/* YYPGOTO[NTERM-NUM]. */
698static const yytype_int16 yypgoto[] = {
699 -184, -184, -184, -184, 161, -184, -184, 110, -184, -184, -184,
700 -184, 27, -107, 90, 92, 93, -7, -50, 218, -184, 17,
701 -183, -184, -184, -184, -184, -72, -56, 101, -76, -184};
702
703/* YYDEFGOTO[NTERM-NUM]. */
704static const yytype_uint8 yydefgoto[] = {
705 0, 1, 2, 6, 44, 45, 82, 83, 7, 20, 114, 197, 126, 127, 21, 22,
706 23, 46, 34, 35, 209, 210, 119, 205, 25, 40, 99, 100, 60, 134, 135, 41};
707
708/* YYTABLE[YYPACT[STATE-NUM]] -- What to do in state STATE-NUM. If
709 positive, shift that token. If negative, reduce the rule whose
710 number is the opposite. If YYTABLE_NINF, syntax error. */
711static const yytype_int16 yytable[] = {
712 24, 70, 74, 107, 101, 102, 140, 8, 4, 29, -18, -18, -18, -18, -18,
713 90, 204, 32, 5, 33, -18, -18, -18, 56, 48, -18, 3, 49, -18, 57,
714 143, 220, 115, 79, 116, 117, 64, -18, 50, 11, 12, 169, 13, 14, 118,
715 92, 10, 79, 128, 15, 51, 16, 42, 12, 17, 13, 14, 18, 152, 113,
716 80, 9, 15, 56, 43, 79, 19, 17, 144, 89, 18, 81, 12, 151, 13,
717 14, 79, 193, 79, 19, 172, 15, 12, 158, 13, 14, 17, 26, 194, 18,
718 195, 15, 12, 160, 13, 14, 17, 27, 19, 18, 79, 15, 93, 94, 95,
719 96, 17, 148, 19, 18, 149, 97, 196, 122, 98, 123, 124, 122, 19, 123,
720 124, 132, 28, 125, 32, 133, 33, 211, 189, 190, 191, 159, 192, 30, 202,
721 76, 77, 38, 36, 78, 103, 104, 105, 58, 79, 31, 39, 37, 203, 106,
722 56, 173, 52, 175, 206, 207, 150, 122, 56, 123, 124, 47, 208, 156, 166,
723 56, 157, 214, 213, 217, 215, 148, 218, 32, 219, 33, 129, 130, 170, 156,
724 206, 207, 53, 54, 55, 59, 63, 65, 61, 62, 68, 69, 71, 66, 72,
725 67, 75, 84, 86, 87, 88, 109, 120, 111, 108, 91, 131, 80, 110, 137,
726 141, 138, 112, 139, 121, 142, 145, 146, 136, 147, 153, 167, 155, 164, 165,
727 168, 79, 85, 212, 161, 182, 162, 163, 154, 222, 221, 171, 174, 176, 177,
728 178, 184, 185, 179, 180, 181, 183, 186, 187, 188, 198, 199, 200, 201, 0,
729 0, 0, 216, 0, 223, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
730 0, 0, 0, 0, 73};
731
732static const yytype_int16 yycheck[] = {
733 7, 51, 58, 79, 76, 77, 113, 22, 1, 16, 3, 4, 5, 6, 7, 71,
734 199, 18, 11, 20, 13, 14, 15, 25, 4, 18, 0, 7, 21, 31, 31, 214,
735 18, 17, 20, 21, 43, 30, 18, 3, 4, 148, 6, 7, 30, 29, 22, 17,
736 98, 13, 30, 15, 3, 4, 18, 6, 7, 21, 130, 29, 7, 20, 13, 25,
737 15, 17, 30, 18, 118, 31, 21, 18, 4, 129, 6, 7, 17, 29, 17, 30,
738 156, 13, 4, 15, 6, 7, 18, 23, 29, 21, 29, 13, 4, 15, 6, 7,
739 18, 27, 30, 21, 17, 13, 18, 19, 20, 21, 18, 25, 30, 21, 28, 27,
740 29, 18, 30, 20, 21, 18, 30, 20, 21, 23, 10, 28, 18, 27, 20, 28,
741 184, 185, 186, 138, 188, 16, 28, 8, 9, 5, 22, 12, 18, 19, 20, 20,
742 17, 16, 14, 26, 198, 27, 25, 158, 26, 160, 20, 21, 31, 18, 25, 20,
743 21, 18, 28, 25, 31, 25, 28, 25, 28, 25, 28, 25, 28, 18, 28, 20,
744 24, 25, 24, 25, 20, 21, 18, 21, 27, 20, 27, 24, 22, 22, 16, 16,
745 20, 25, 18, 26, 23, 26, 20, 18, 18, 16, 16, 20, 25, 28, 16, 7,
746 28, 18, 16, 10, 28, 10, 27, 27, 18, 18, 108, 27, 18, 28, 18, 18,
747 18, 18, 17, 66, 201, 139, 20, 139, 139, 132, 217, 18, 28, 26, 26, 26,
748 26, 20, 20, 28, 28, 26, 26, 20, 20, 20, 27, 27, 27, 27, -1, -1,
749 -1, 27, -1, 28, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
750 -1, -1, 56};
751
752/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
753 symbol of state STATE-NUM. */
754static const yytype_int8 yystos[] = {
755 0, 33, 34, 0, 1, 11, 35, 40, 22, 20, 22, 3, 4, 6, 7, 13, 15, 18, 21,
756 30, 41, 46, 47, 48, 49, 56, 23, 27, 10, 49, 16, 16, 18, 20, 50, 51, 22, 26,
757 5, 14, 57, 63, 3, 15, 36, 37, 49, 18, 4, 7, 18, 30, 26, 18, 21, 27, 25,
758 31, 20, 20, 60, 22, 22, 27, 49, 24, 25, 26, 16, 16, 50, 20, 18, 51, 60, 23,
759 8, 9, 12, 17, 7, 18, 38, 39, 26, 36, 20, 18, 18, 31, 60, 28, 29, 18, 19,
760 20, 21, 27, 30, 58, 59, 59, 59, 18, 19, 20, 27, 62, 25, 16, 28, 20, 28, 29,
761 42, 18, 20, 21, 30, 54, 16, 27, 18, 20, 21, 28, 44, 45, 50, 24, 25, 16, 23,
762 27, 61, 62, 39, 18, 10, 10, 45, 16, 27, 31, 50, 18, 18, 27, 25, 28, 31, 60,
763 59, 18, 61, 18, 25, 28, 15, 49, 15, 46, 47, 48, 18, 18, 31, 28, 18, 45, 24,
764 28, 62, 49, 26, 49, 26, 26, 26, 28, 28, 26, 20, 26, 20, 20, 20, 20, 20, 60,
765 60, 60, 60, 29, 29, 29, 29, 43, 27, 27, 27, 27, 28, 50, 54, 55, 20, 21, 28,
766 52, 53, 28, 44, 28, 25, 28, 27, 25, 28, 28, 54, 18, 53, 28};
767
768/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
769static const yytype_int8 yyr1[] = {
770 0, 32, 33, 34, 34, 34, 35, 36, 36, 37, 37, 37, 37, 38, 38, 39, 39,
771 40, 40, 41, 41, 41, 41, 41, 41, 41, 41, 42, 42, 43, 43, 43, 44, 44,
772 45, 45, 45, 45, 46, 46, 46, 46, 47, 47, 47, 47, 48, 48, 49, 49, 49,
773 50, 50, 51, 51, 51, 52, 52, 53, 53, 53, 54, 54, 54, 54, 54, 54, 54,
774 55, 55, 56, 56, 57, 58, 58, 59, 59, 59, 59, 59, 59, 59, 59, 59, 60,
775 60, 61, 61, 62, 62, 62, 62, 62, 62, 62, 63, 63, 63};
776
777/* YYR2[YYN] -- Number of symbols on the right hand side of rule YYN. */
778static const yytype_int8 yyr2[] = {
779 0, 2, 5, 3, 3, 0, 5, 3, 1, 3, 4, 8, 9, 1, 3, 3, 1, 3, 0, 6,
780 15, 14, 15, 14, 15, 6, 13, 2, 0, 4, 3, 0, 3, 1, 1, 1, 1, 4, 1, 1,
781 3, 3, 3, 3, 5, 5, 1, 3, 1, 1, 1, 3, 1, 1, 1, 4, 3, 1, 1, 1,
782 4, 1, 3, 3, 2, 1, 1, 4, 3, 1, 3, 0, 6, 3, 1, 1, 1, 1, 3, 3,
783 1, 4, 3, 2, 3, 0, 3, 1, 3, 1, 1, 1, 4, 4, 3, 3, 4, 4};
784
785enum { YYENOMEM = -2 };
786
787#define yyerrok (yyerrstatus = 0)
788#define yyclearin (yychar = ORFZ_EMPTY)
789
790#define YYACCEPT goto yyacceptlab
791#define YYABORT goto yyabortlab
792#define YYERROR goto yyerrorlab
793
794#define YYRECOVERING() (!!yyerrstatus)
795
796#define YYBACKUP(Token, Value) \
797 do \
798 if (yychar == ORFZ_EMPTY) { \
799 yychar = (Token); \
800 yylval = (Value); \
801 YYPOPSTACK(yylen); \
802 yystate = *yyssp; \
803 goto yybackup; \
804 } else { \
805 yyerror(context, model, ok, scanner, \
806 YY_("syntax error: cannot back up")); \
807 YYERROR; \
808 } \
809 while (0)
810
811/* Backward compatibility with an undocumented macro.
812 Use ORFZ_error or ORFZ_UNDEF. */
813#define YYERRCODE ORFZ_UNDEF
814
815/* Enable debugging if requested. */
816#if ORFZ_DEBUG
817
818#ifndef YYFPRINTF
819#include <stdio.h> /* INFRINGES ON USER NAME SPACE */
820#define YYFPRINTF fprintf
821#endif
822
823#define YYDPRINTF(Args) \
824 do { \
825 if (yydebug) YYFPRINTF Args; \
826 } while (0)
827
828/* This macro is provided for backward compatibility. */
829#ifndef YY_LOCATION_PRINT
830#define YY_LOCATION_PRINT(File, Loc) ((void)0)
831#endif
832
833#define YY_SYMBOL_PRINT(Title, Kind, Value, Location) \
834 do { \
835 if (yydebug) { \
836 YYFPRINTF(stderr, "%s ", Title); \
837 yy_symbol_print(stderr, Kind, Value, context, model, ok, scanner); \
838 YYFPRINTF(stderr, "\n"); \
839 } \
840 } while (0)
841
842/*-----------------------------------.
843| Print this symbol's value on YYO. |
844`-----------------------------------*/
845
846static void yy_symbol_value_print(
847 FILE* yyo, yysymbol_kind_t yykind, YYSTYPE const* const yyvaluep,
848 operations_research::fz::ParserContext* context,
849 operations_research::fz::Model* model, bool* ok, void* scanner) {
850 FILE* yyoutput = yyo;
851 YY_USE(yyoutput);
852 YY_USE(context);
853 YY_USE(model);
854 YY_USE(ok);
855 YY_USE(scanner);
856 if (!yyvaluep) return;
857#ifdef YYPRINT
858 if (yykind < YYNTOKENS) YYPRINT(yyo, yytoknum[yykind], *yyvaluep);
859#endif
860 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
861 YY_USE(yykind);
862 YY_IGNORE_MAYBE_UNINITIALIZED_END
863}
864
865/*---------------------------.
866| Print this symbol on YYO. |
867`---------------------------*/
868
869static void yy_symbol_print(FILE* yyo, yysymbol_kind_t yykind,
870 YYSTYPE const* const yyvaluep,
871 operations_research::fz::ParserContext* context,
872 operations_research::fz::Model* model, bool* ok,
873 void* scanner) {
874 YYFPRINTF(yyo, "%s %s (", yykind < YYNTOKENS ? "token" : "nterm",
875 yysymbol_name(yykind));
876
877 yy_symbol_value_print(yyo, yykind, yyvaluep, context, model, ok, scanner);
878 YYFPRINTF(yyo, ")");
879}
880
881/*------------------------------------------------------------------.
882| yy_stack_print -- Print the state stack from its BOTTOM up to its |
883| TOP (included). |
884`------------------------------------------------------------------*/
885
886static void yy_stack_print(yy_state_t* yybottom, yy_state_t* yytop) {
887 YYFPRINTF(stderr, "Stack now");
888 for (; yybottom <= yytop; yybottom++) {
889 int yybot = *yybottom;
890 YYFPRINTF(stderr, " %d", yybot);
891 }
892 YYFPRINTF(stderr, "\n");
893}
894
895#define YY_STACK_PRINT(Bottom, Top) \
896 do { \
897 if (yydebug) yy_stack_print((Bottom), (Top)); \
898 } while (0)
899
900/*------------------------------------------------.
901| Report that the YYRULE is going to be reduced. |
902`------------------------------------------------*/
903
904static void yy_reduce_print(yy_state_t* yyssp, YYSTYPE* yyvsp, int yyrule,
905 operations_research::fz::ParserContext* context,
906 operations_research::fz::Model* model, bool* ok,
907 void* scanner) {
908 int yylno = yyrline[yyrule];
909 int yynrhs = yyr2[yyrule];
910 int yyi;
911 YYFPRINTF(stderr, "Reducing stack by rule %d (line %d):\n", yyrule - 1,
912 yylno);
913 /* The symbols being reduced. */
914 for (yyi = 0; yyi < yynrhs; yyi++) {
915 YYFPRINTF(stderr, " $%d = ", yyi + 1);
916 yy_symbol_print(stderr, YY_ACCESSING_SYMBOL(+yyssp[yyi + 1 - yynrhs]),
917 &yyvsp[(yyi + 1) - (yynrhs)], context, model, ok, scanner);
918 YYFPRINTF(stderr, "\n");
919 }
920}
921
922#define YY_REDUCE_PRINT(Rule) \
923 do { \
924 if (yydebug) \
925 yy_reduce_print(yyssp, yyvsp, Rule, context, model, ok, scanner); \
926 } while (0)
927
928/* Nonzero means print parse trace. It is left uninitialized so that
929 multiple parsers can coexist. */
930int yydebug;
931#else /* !ORFZ_DEBUG */
932#define YYDPRINTF(Args) ((void)0)
933#define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
934#define YY_STACK_PRINT(Bottom, Top)
935#define YY_REDUCE_PRINT(Rule)
936#endif /* !ORFZ_DEBUG */
937
938/* YYINITDEPTH -- initial size of the parser's stacks. */
939#ifndef YYINITDEPTH
940#define YYINITDEPTH 200
941#endif
942
943/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
944 if the built-in stack extension method is used).
945
946 Do not make this value too large; the results are undefined if
947 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
948 evaluated with infinite-precision integer arithmetic. */
949
950#ifndef YYMAXDEPTH
951#define YYMAXDEPTH 10000
952#endif
953
954/* Context of a parse error. */
955typedef struct {
956 yy_state_t* yyssp;
957 yysymbol_kind_t yytoken;
958} yypcontext_t;
959
960/* Put in YYARG at most YYARGN of the expected tokens given the
961 current YYCTX, and return the number of tokens stored in YYARG. If
962 YYARG is null, return the number of expected tokens (guaranteed to
963 be less than YYNTOKENS). Return YYENOMEM on memory exhaustion.
964 Return 0 if there are more than YYARGN expected tokens, yet fill
965 YYARG up to YYARGN. */
966static int yypcontext_expected_tokens(const yypcontext_t* yyctx,
967 yysymbol_kind_t yyarg[], int yyargn) {
968 /* Actual size of YYARG. */
969 int yycount = 0;
970 int yyn = yypact[+*yyctx->yyssp];
971 if (!yypact_value_is_default(yyn)) {
972 /* Start YYX at -YYN if negative to avoid negative indexes in
973 YYCHECK. In other words, skip the first -YYN actions for
974 this state because they are default actions. */
975 int yyxbegin = yyn < 0 ? -yyn : 0;
976 /* Stay within bounds of both yycheck and yytname. */
977 int yychecklim = YYLAST - yyn + 1;
978 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
979 int yyx;
980 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
981 if (yycheck[yyx + yyn] == yyx && yyx != YYSYMBOL_YYerror &&
982 !yytable_value_is_error(yytable[yyx + yyn])) {
983 if (!yyarg)
984 ++yycount;
985 else if (yycount == yyargn)
986 return 0;
987 else
988 yyarg[yycount++] = YY_CAST(yysymbol_kind_t, yyx);
989 }
990 }
991 if (yyarg && yycount == 0 && 0 < yyargn) yyarg[0] = YYSYMBOL_YYEMPTY;
992 return yycount;
993}
994
995#ifndef yystrlen
996#if defined __GLIBC__ && defined _STRING_H
997#define yystrlen(S) (YY_CAST(YYPTRDIFF_T, strlen(S)))
998#else
999/* Return the length of YYSTR. */
1000static YYPTRDIFF_T yystrlen(const char* yystr) {
1001 YYPTRDIFF_T yylen;
1002 for (yylen = 0; yystr[yylen]; yylen++) continue;
1003 return yylen;
1004}
1005#endif
1006#endif
1007
1008#ifndef yystpcpy
1009#if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1010#define yystpcpy stpcpy
1011#else
1012/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1013 YYDEST. */
1014static char* yystpcpy(char* yydest, const char* yysrc) {
1015 char* yyd = yydest;
1016 const char* yys = yysrc;
1017
1018 while ((*yyd++ = *yys++) != '\0') continue;
1019
1020 return yyd - 1;
1021}
1022#endif
1023#endif
1024
1025#ifndef yytnamerr
1026/* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1027 quotes and backslashes, so that it's suitable for yyerror. The
1028 heuristic is that double-quoting is unnecessary unless the string
1029 contains an apostrophe, a comma, or backslash (other than
1030 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1031 null, do not copy; instead, return the length of what the result
1032 would have been. */
1033static YYPTRDIFF_T yytnamerr(char* yyres, const char* yystr) {
1034 if (*yystr == '"') {
1035 YYPTRDIFF_T yyn = 0;
1036 char const* yyp = yystr;
1037 for (;;) switch (*++yyp) {
1038 case '\'':
1039 case ',':
1040 goto do_not_strip_quotes;
1041
1042 case '\\':
1043 if (*++yyp != '\\')
1044 goto do_not_strip_quotes;
1045 else
1046 goto append;
1047
1048 append:
1049 default:
1050 if (yyres) yyres[yyn] = *yyp;
1051 yyn++;
1052 break;
1053
1054 case '"':
1055 if (yyres) yyres[yyn] = '\0';
1056 return yyn;
1057 }
1058 do_not_strip_quotes:;
1059 }
1060
1061 if (yyres)
1062 return yystpcpy(yyres, yystr) - yyres;
1063 else
1064 return yystrlen(yystr);
1065}
1066#endif
1067
1068static int yy_syntax_error_arguments(const yypcontext_t* yyctx,
1069 yysymbol_kind_t yyarg[], int yyargn) {
1070 /* Actual size of YYARG. */
1071 int yycount = 0;
1072 /* There are many possibilities here to consider:
1073 - If this state is a consistent state with a default action, then
1074 the only way this function was invoked is if the default action
1075 is an error action. In that case, don't check for expected
1076 tokens because there are none.
1077 - The only way there can be no lookahead present (in yychar) is if
1078 this state is a consistent state with a default action. Thus,
1079 detecting the absence of a lookahead is sufficient to determine
1080 that there is no unexpected or expected token to report. In that
1081 case, just report a simple "syntax error".
1082 - Don't assume there isn't a lookahead just because this state is a
1083 consistent state with a default action. There might have been a
1084 previous inconsistent state, consistent state with a non-default
1085 action, or user semantic action that manipulated yychar.
1086 - Of course, the expected token list depends on states to have
1087 correct lookahead information, and it depends on the parser not
1088 to perform extra reductions after fetching a lookahead from the
1089 scanner and before detecting a syntax error. Thus, state merging
1090 (from LALR or IELR) and default reductions corrupt the expected
1091 token list. However, the list is correct for canonical LR with
1092 one exception: it will still contain any token that will not be
1093 accepted due to an error action in a later state.
1094 */
1095 if (yyctx->yytoken != YYSYMBOL_YYEMPTY) {
1096 int yyn;
1097 if (yyarg) yyarg[yycount] = yyctx->yytoken;
1098 ++yycount;
1099 yyn = yypcontext_expected_tokens(yyctx, yyarg ? yyarg + 1 : yyarg,
1100 yyargn - 1);
1101 if (yyn == YYENOMEM)
1102 return YYENOMEM;
1103 else
1104 yycount += yyn;
1105 }
1106 return yycount;
1107}
1108
1109/* Copy into *YYMSG, which is of size *YYMSG_ALLOC, an error message
1110 about the unexpected token YYTOKEN for the state stack whose top is
1111 YYSSP.
1112
1113 Return 0 if *YYMSG was successfully written. Return -1 if *YYMSG is
1114 not large enough to hold the message. In that case, also set
1115 *YYMSG_ALLOC to the required number of bytes. Return YYENOMEM if the
1116 required number of bytes is too large to store. */
1117static int yysyntax_error(YYPTRDIFF_T* yymsg_alloc, char** yymsg,
1118 const yypcontext_t* yyctx) {
1119 enum { YYARGS_MAX = 5 };
1120 /* Internationalized format string. */
1121 const char* yyformat = YY_NULLPTR;
1122 /* Arguments of yyformat: reported tokens (one for the "unexpected",
1123 one per "expected"). */
1124 yysymbol_kind_t yyarg[YYARGS_MAX];
1125 /* Cumulated lengths of YYARG. */
1126 YYPTRDIFF_T yysize = 0;
1127
1128 /* Actual size of YYARG. */
1129 int yycount = yy_syntax_error_arguments(yyctx, yyarg, YYARGS_MAX);
1130 if (yycount == YYENOMEM) return YYENOMEM;
1131
1132 switch (yycount) {
1133#define YYCASE_(N, S) \
1134 case N: \
1135 yyformat = S; \
1136 break
1137 default: /* Avoid compiler warnings. */
1138 YYCASE_(0, YY_("syntax error"));
1139 YYCASE_(1, YY_("syntax error, unexpected %s"));
1140 YYCASE_(2, YY_("syntax error, unexpected %s, expecting %s"));
1141 YYCASE_(3, YY_("syntax error, unexpected %s, expecting %s or %s"));
1142 YYCASE_(4, YY_("syntax error, unexpected %s, expecting %s or %s or %s"));
1143 YYCASE_(
1144 5,
1145 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s"));
1146#undef YYCASE_
1147 }
1148
1149 /* Compute error message size. Don't count the "%s"s, but reserve
1150 room for the terminator. */
1151 yysize = yystrlen(yyformat) - 2 * yycount + 1;
1152 {
1153 int yyi;
1154 for (yyi = 0; yyi < yycount; ++yyi) {
1155 YYPTRDIFF_T yysize1 = yysize + yytnamerr(YY_NULLPTR, yytname[yyarg[yyi]]);
1156 if (yysize <= yysize1 && yysize1 <= YYSTACK_ALLOC_MAXIMUM)
1157 yysize = yysize1;
1158 else
1159 return YYENOMEM;
1160 }
1161 }
1162
1163 if (*yymsg_alloc < yysize) {
1164 *yymsg_alloc = 2 * yysize;
1165 if (!(yysize <= *yymsg_alloc && *yymsg_alloc <= YYSTACK_ALLOC_MAXIMUM))
1166 *yymsg_alloc = YYSTACK_ALLOC_MAXIMUM;
1167 return -1;
1168 }
1169
1170 /* Avoid sprintf, as that infringes on the user's name space.
1171 Don't have undefined behavior even if the translation
1172 produced a string with the wrong number of "%s"s. */
1173 {
1174 char* yyp = *yymsg;
1175 int yyi = 0;
1176 while ((*yyp = *yyformat) != '\0')
1177 if (*yyp == '%' && yyformat[1] == 's' && yyi < yycount) {
1178 yyp += yytnamerr(yyp, yytname[yyarg[yyi++]]);
1179 yyformat += 2;
1180 } else {
1181 ++yyp;
1182 ++yyformat;
1183 }
1184 }
1185 return 0;
1186}
1187
1188/*-----------------------------------------------.
1189| Release the memory associated to this symbol. |
1190`-----------------------------------------------*/
1191
1192static void yydestruct(const char* yymsg, yysymbol_kind_t yykind,
1193 YYSTYPE* yyvaluep,
1194 operations_research::fz::ParserContext* context,
1195 operations_research::fz::Model* model, bool* ok,
1196 void* scanner) {
1197 YY_USE(yyvaluep);
1198 YY_USE(context);
1199 YY_USE(model);
1200 YY_USE(ok);
1201 YY_USE(scanner);
1202 if (!yymsg) yymsg = "Deleting";
1203 YY_SYMBOL_PRINT(yymsg, yykind, yyvaluep, yylocationp);
1204
1205 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1206 YY_USE(yykind);
1207 YY_IGNORE_MAYBE_UNINITIALIZED_END
1208}
1209
1210/*----------.
1211| yyparse. |
1212`----------*/
1213
1214int yyparse(operations_research::fz::ParserContext* context,
1215 operations_research::fz::Model* model, bool* ok, void* scanner) {
1216 /* Lookahead token kind. */
1217 int yychar;
1218
1219 /* The semantic value of the lookahead symbol. */
1220 /* Default value used for initialization, for pacifying older GCCs
1221 or non-GCC compilers. */
1222 YY_INITIAL_VALUE(static YYSTYPE yyval_default;)
1223 YYSTYPE yylval YY_INITIAL_VALUE(= yyval_default);
1224
1225 /* Number of syntax errors so far. */
1226 int yynerrs = 0;
1227
1228 yy_state_fast_t yystate = 0;
1229 /* Number of tokens to shift before error messages enabled. */
1230 int yyerrstatus = 0;
1231
1232 /* Refer to the stacks through separate pointers, to allow yyoverflow
1233 to reallocate them elsewhere. */
1234
1235 /* Their size. */
1236 YYPTRDIFF_T yystacksize = YYINITDEPTH;
1237
1238 /* The state stack: array, bottom, top. */
1239 yy_state_t yyssa[YYINITDEPTH];
1240 yy_state_t* yyss = yyssa;
1241 yy_state_t* yyssp = yyss;
1242
1243 /* The semantic value stack: array, bottom, top. */
1244 YYSTYPE yyvsa[YYINITDEPTH];
1245 YYSTYPE* yyvs = yyvsa;
1246 YYSTYPE* yyvsp = yyvs;
1247
1248 int yyn;
1249 /* The return value of yyparse. */
1250 int yyresult;
1251 /* Lookahead symbol kind. */
1252 yysymbol_kind_t yytoken = YYSYMBOL_YYEMPTY;
1253 /* The variables used to return semantic value and location from the
1254 action routines. */
1255 YYSTYPE yyval;
1256
1257 /* Buffer for error messages, and its allocated size. */
1258 char yymsgbuf[128];
1259 char* yymsg = yymsgbuf;
1260 YYPTRDIFF_T yymsg_alloc = sizeof yymsgbuf;
1261
1262#define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
1263
1264 /* The number of symbols on the RHS of the reduced rule.
1265 Keep to zero when no symbol should be popped. */
1266 int yylen = 0;
1267
1268 YYDPRINTF((stderr, "Starting parse\n"));
1269
1270 yychar = ORFZ_EMPTY; /* Cause a token to be read. */
1271 goto yysetstate;
1272
1273/*------------------------------------------------------------.
1274| yynewstate -- push a new state, which is found in yystate. |
1275`------------------------------------------------------------*/
1276yynewstate:
1277 /* In all cases, when you get here, the value and location stacks
1278 have just been pushed. So pushing a state here evens the stacks. */
1279 yyssp++;
1280
1281/*--------------------------------------------------------------------.
1282| yysetstate -- set current state (the top of the stack) to yystate. |
1283`--------------------------------------------------------------------*/
1284yysetstate:
1285 YYDPRINTF((stderr, "Entering state %d\n", yystate));
1286 YY_ASSERT(0 <= yystate && yystate < YYNSTATES);
1287 YY_IGNORE_USELESS_CAST_BEGIN
1288 *yyssp = YY_CAST(yy_state_t, yystate);
1289 YY_IGNORE_USELESS_CAST_END
1290 YY_STACK_PRINT(yyss, yyssp);
1291
1292 if (yyss + yystacksize - 1 <= yyssp)
1293#if !defined yyoverflow && !defined YYSTACK_RELOCATE
1294 goto yyexhaustedlab;
1295#else
1296 {
1297 /* Get the current used size of the three stacks, in elements. */
1298 YYPTRDIFF_T yysize = yyssp - yyss + 1;
1299
1300#if defined yyoverflow
1301 {
1302 /* Give user a chance to reallocate the stack. Use copies of
1303 these so that the &'s don't force the real ones into
1304 memory. */
1305 yy_state_t* yyss1 = yyss;
1306 YYSTYPE* yyvs1 = yyvs;
1307
1308 /* Each stack pointer address is followed by the size of the
1309 data in use in that stack, in bytes. This used to be a
1310 conditional around just the two extra args, but that might
1311 be undefined if yyoverflow is a macro. */
1312 yyoverflow(YY_("memory exhausted"), &yyss1, yysize * YYSIZEOF(*yyssp),
1313 &yyvs1, yysize * YYSIZEOF(*yyvsp), &yystacksize);
1314 yyss = yyss1;
1315 yyvs = yyvs1;
1316 }
1317#else /* defined YYSTACK_RELOCATE */
1318 /* Extend the stack our own way. */
1319 if (YYMAXDEPTH <= yystacksize) goto yyexhaustedlab;
1320 yystacksize *= 2;
1321 if (YYMAXDEPTH < yystacksize) yystacksize = YYMAXDEPTH;
1322
1323 {
1324 yy_state_t* yyss1 = yyss;
1325 union yyalloc* yyptr =
1326 YY_CAST(union yyalloc*,
1327 YYSTACK_ALLOC(YY_CAST(YYSIZE_T, YYSTACK_BYTES(yystacksize))));
1328 if (!yyptr) goto yyexhaustedlab;
1329 YYSTACK_RELOCATE(yyss_alloc, yyss);
1330 YYSTACK_RELOCATE(yyvs_alloc, yyvs);
1331#undef YYSTACK_RELOCATE
1332 if (yyss1 != yyssa) YYSTACK_FREE(yyss1);
1333 }
1334#endif
1335
1336 yyssp = yyss + yysize - 1;
1337 yyvsp = yyvs + yysize - 1;
1338
1339 YY_IGNORE_USELESS_CAST_BEGIN
1340 YYDPRINTF(
1341 (stderr, "Stack size increased to %ld\n", YY_CAST(long, yystacksize)));
1342 YY_IGNORE_USELESS_CAST_END
1343
1344 if (yyss + yystacksize - 1 <= yyssp) YYABORT;
1345 }
1346#endif /* !defined yyoverflow && !defined YYSTACK_RELOCATE */
1347
1348 if (yystate == YYFINAL) YYACCEPT;
1349
1350 goto yybackup;
1351
1352/*-----------.
1353| yybackup. |
1354`-----------*/
1355yybackup:
1356 /* Do appropriate processing given the current state. Read a
1357 lookahead token if we need one and don't already have one. */
1358
1359 /* First try to decide what to do without reference to lookahead token. */
1360 yyn = yypact[yystate];
1361 if (yypact_value_is_default(yyn)) goto yydefault;
1362
1363 /* Not known => get a lookahead token if don't already have one. */
1364
1365 /* YYCHAR is either empty, or end-of-input, or a valid lookahead. */
1366 if (yychar == ORFZ_EMPTY) {
1367 YYDPRINTF((stderr, "Reading a token\n"));
1368 yychar = yylex(&yylval, scanner);
1369 }
1370
1371 if (yychar <= ORFZ_EOF) {
1372 yychar = ORFZ_EOF;
1373 yytoken = YYSYMBOL_YYEOF;
1374 YYDPRINTF((stderr, "Now at end of input.\n"));
1375 } else if (yychar == ORFZ_error) {
1376 /* The scanner already issued an error message, process directly
1377 to error recovery. But do not keep the error token as
1378 lookahead, it is too special and may lead us to an endless
1379 loop in error recovery. */
1380 yychar = ORFZ_UNDEF;
1381 yytoken = YYSYMBOL_YYerror;
1382 goto yyerrlab1;
1383 } else {
1384 yytoken = YYTRANSLATE(yychar);
1385 YY_SYMBOL_PRINT("Next token is", yytoken, &yylval, &yylloc);
1386 }
1387
1388 /* If the proper action on seeing token YYTOKEN is to reduce or to
1389 detect an error, take that action. */
1390 yyn += yytoken;
1391 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken) goto yydefault;
1392 yyn = yytable[yyn];
1393 if (yyn <= 0) {
1394 if (yytable_value_is_error(yyn)) goto yyerrlab;
1395 yyn = -yyn;
1396 goto yyreduce;
1397 }
1398
1399 /* Count tokens shifted since error; after three, turn off error
1400 status. */
1401 if (yyerrstatus) yyerrstatus--;
1402
1403 /* Shift the lookahead token. */
1404 YY_SYMBOL_PRINT("Shifting", yytoken, &yylval, &yylloc);
1405 yystate = yyn;
1406 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
1407 *++yyvsp = yylval;
1408 YY_IGNORE_MAYBE_UNINITIALIZED_END
1409
1410 /* Discard the shifted token. */
1411 yychar = ORFZ_EMPTY;
1412 goto yynewstate;
1413
1414/*-----------------------------------------------------------.
1415| yydefault -- do the default action for the current state. |
1416`-----------------------------------------------------------*/
1417yydefault:
1418 yyn = yydefact[yystate];
1419 if (yyn == 0) goto yyerrlab;
1420 goto yyreduce;
1421
1422/*-----------------------------.
1423| yyreduce -- do a reduction. |
1424`-----------------------------*/
1425yyreduce:
1426 /* yyn is the number of a rule to reduce with. */
1427 yylen = yyr2[yyn];
1428
1429 /* If YYLEN is nonzero, implement the default value of the action:
1430 '$$ = $1'.
1431
1432 Otherwise, the following line sets YYVAL to garbage.
1433 This behavior is undocumented and Bison
1434 users should not rely upon it. Assigning to YYVAL
1435 unconditionally makes the parser a bit smaller, and it avoids a
1436 GCC warning that YYVAL may be used uninitialized. */
1437 yyval = yyvsp[1 - yylen];
1438
1439 YY_REDUCE_PRINT(yyn);
1440 switch (yyn) {
1441 case 4: /* predicates: predicates error ';' */
1442#line 113 "./ortools/flatzinc/parser.yy"
1443 {
1444 yyerrok;
1445 }
1446#line 1592 "./ortools/flatzinc/parser.tab.cc"
1447 break;
1448
1449 case 19: /* variable_or_constant_declaration: domain ':' IDENTIFIER
1450 annotations '=' const_literal */
1451#line 148 "./ortools/flatzinc/parser.yy"
1452 {
1453 // Declaration of a (named) constant: we simply register it in the
1454 // parser's context, and don't store it in the model.
1455 const Domain& domain = (yyvsp[-5].domain);
1456 const std::string& identifier = (yyvsp[-3].string_value);
1457 const Domain& assignment = (yyvsp[0].domain);
1458 std::vector<Annotation>* const annotations = (yyvsp[-2].annotations);
1459
1460 if (!assignment.HasOneValue()) {
1461 // TODO(user): Check that the assignment is included in the domain.
1462 context->domain_map[identifier] = assignment;
1463 } else {
1464 const int64_t value = assignment.values.front();
1465 CHECK(domain.Contains(value));
1466 context->integer_map[identifier] = value;
1467 }
1468 delete annotations;
1469 }
1470#line 1616 "./ortools/flatzinc/parser.tab.cc"
1471 break;
1472
1473 case 20: /* variable_or_constant_declaration: ARRAY '[' IVALUE DOTDOT IVALUE
1474 ']' OF int_domain ':' IDENTIFIER annotations '=' '[' integers
1475 ']' */
1476#line 168 "./ortools/flatzinc/parser.yy"
1477 {
1478 std::vector<Annotation>* const annotations = (yyvsp[-4].annotations);
1479 // Declaration of a (named) constant array. See rule right above.
1480 CHECK_EQ((yyvsp[-12].integer_value), 1)
1481 << "Only [1..n] array are supported here.";
1482 const int64_t num_constants = (yyvsp[-10].integer_value);
1483 const std::string& identifier = (yyvsp[-5].string_value);
1484 const std::vector<int64_t>* const assignments = (yyvsp[-1].integers);
1485 CHECK(assignments != nullptr);
1486 CHECK_EQ(num_constants, assignments->size());
1487 // TODO(user): CHECK all values within domain.
1488 context->integer_array_map[identifier] = *assignments;
1489 delete assignments;
1490 delete annotations;
1491 }
1492#line 1635 "./ortools/flatzinc/parser.tab.cc"
1493 break;
1494
1495 case 21: /* variable_or_constant_declaration: ARRAY '[' IVALUE DOTDOT IVALUE
1496 ']' OF int_domain ':' IDENTIFIER annotations '=' '[' ']' */
1497#line 183 "./ortools/flatzinc/parser.yy"
1498 {
1499 std::vector<Annotation>* const annotations = (yyvsp[-3].annotations);
1500 // Declaration of a (named) constant array. See rule right above.
1501 CHECK_EQ((yyvsp[-11].integer_value), 1)
1502 << "Only [1..n] array are supported here.";
1503 const int64_t num_constants = (yyvsp[-9].integer_value);
1504 CHECK_EQ(num_constants, 0) << "Empty arrays should have a size of 0";
1505 const std::string& identifier = (yyvsp[-4].string_value);
1506 context->integer_array_map[identifier] = std::vector<int64_t>();
1507 delete annotations;
1508 }
1509#line 1650 "./ortools/flatzinc/parser.tab.cc"
1510 break;
1511
1512 case 22: /* variable_or_constant_declaration: ARRAY '[' IVALUE DOTDOT IVALUE
1513 ']' OF float_domain ':' IDENTIFIER annotations '=' '[' floats
1514 ']' */
1515#line 194 "./ortools/flatzinc/parser.yy"
1516 {
1517 std::vector<Annotation>* const annotations = (yyvsp[-4].annotations);
1518 // Declaration of a (named) constant array. See rule right above.
1519 CHECK_EQ((yyvsp[-12].integer_value), 1)
1520 << "Only [1..n] array are supported here.";
1521 const int64_t num_constants = (yyvsp[-10].integer_value);
1522 const std::string& identifier = (yyvsp[-5].string_value);
1523 const std::vector<double>* const assignments = (yyvsp[-1].doubles);
1524 CHECK(assignments != nullptr);
1525 CHECK_EQ(num_constants, assignments->size());
1526 // TODO(user): CHECK all values within domain.
1527 context->float_array_map[identifier] = *assignments;
1528 delete assignments;
1529 delete annotations;
1530 }
1531#line 1669 "./ortools/flatzinc/parser.tab.cc"
1532 break;
1533
1534 case 23: /* variable_or_constant_declaration: ARRAY '[' IVALUE DOTDOT IVALUE
1535 ']' OF float_domain ':' IDENTIFIER annotations '=' '[' ']' */
1536#line 209 "./ortools/flatzinc/parser.yy"
1537 {
1538 std::vector<Annotation>* const annotations = (yyvsp[-3].annotations);
1539 // Declaration of a (named) constant array. See rule right above.
1540 CHECK_EQ((yyvsp[-11].integer_value), 1)
1541 << "Only [1..n] array are supported here.";
1542 const int64_t num_constants = (yyvsp[-9].integer_value);
1543 CHECK_EQ(num_constants, 0) << "Empty arrays should have a size of 0";
1544 const std::string& identifier = (yyvsp[-4].string_value);
1545 context->float_array_map[identifier] = std::vector<double>();
1546 delete annotations;
1547 }
1548#line 1684 "./ortools/flatzinc/parser.tab.cc"
1549 break;
1550
1551 case 24: /* variable_or_constant_declaration: ARRAY '[' IVALUE DOTDOT IVALUE
1552 ']' OF set_domain ':' IDENTIFIER annotations '=' '['
1553 const_literals ']' */
1554#line 220 "./ortools/flatzinc/parser.yy"
1555 {
1556 // Declaration of a (named) constant array: See rule above.
1557 CHECK_EQ((yyvsp[-12].integer_value), 1)
1558 << "Only [1..n] array are supported here.";
1559 const int64_t num_constants = (yyvsp[-10].integer_value);
1560 const Domain& domain = (yyvsp[-7].domain);
1561 const std::string& identifier = (yyvsp[-5].string_value);
1562 const std::vector<Domain>* const assignments = (yyvsp[-1].domains);
1563 const std::vector<Annotation>* const annotations =
1564 (yyvsp[-4].annotations);
1565 CHECK(assignments != nullptr);
1566 CHECK_EQ(num_constants, assignments->size());
1567
1568 if (!AllDomainsHaveOneValue(*assignments)) {
1569 context->domain_array_map[identifier] = *assignments;
1570 // TODO(user): check that all assignments are included in the domain.
1571 } else {
1572 std::vector<int64_t> values(num_constants);
1573 for (int i = 0; i < num_constants; ++i) {
1574 values[i] = (*assignments)[i].values.front();
1575 CHECK(domain.Contains(values[i]));
1576 }
1577 context->integer_array_map[identifier] = values;
1578 }
1579 delete assignments;
1580 delete annotations;
1581 }
1582#line 1714 "./ortools/flatzinc/parser.tab.cc"
1583 break;
1584
1585 case 25: /* variable_or_constant_declaration: VAR domain ':' IDENTIFIER
1586 annotations optional_var_or_value */
1587#line 245 "./ortools/flatzinc/parser.yy"
1588 {
1589 // Declaration of a variable. If it's unassigned or assigned to a
1590 // constant, we'll create a new var stored in the model. If it's
1591 // assigned to another variable x then we simply adjust that
1592 // existing variable x according to the current (re-)declaration.
1593 const Domain& domain = (yyvsp[-4].domain);
1594 const std::string& identifier = (yyvsp[-2].string_value);
1595 std::vector<Annotation>* const annotations = (yyvsp[-1].annotations);
1596 const VarRefOrValue& assignment = (yyvsp[0].var_or_value);
1597 const bool introduced = ContainsId(annotations, "var_is_introduced") ||
1598 absl::StartsWith(identifier, "X_INTRODUCED");
1599 Variable* var = nullptr;
1600 if (!assignment.defined) {
1601 var = model->AddVariable(identifier, domain, introduced);
1602 } else if (assignment.variable == nullptr) { // just an integer constant.
1603 CHECK(domain.Contains(assignment.value));
1604 var = model->AddVariable(
1605 identifier, Domain::IntegerValue(assignment.value), introduced);
1606 } else { // a variable.
1607 var = assignment.variable;
1608 var->Merge(identifier, domain, introduced);
1609 }
1610
1611 // We also register the variable in the parser's context, and add some
1612 // output to the model if needed.
1613 context->variable_map[identifier] = var;
1614 if (ContainsId(annotations, "output_var")) {
1615 model->AddOutput(SolutionOutputSpecs::SingleVariable(
1616 identifier, var, domain.display_as_boolean));
1617 }
1618 delete annotations;
1619 }
1620#line 1752 "./ortools/flatzinc/parser.tab.cc"
1621 break;
1622
1623 case 26: /* variable_or_constant_declaration: ARRAY '[' IVALUE DOTDOT IVALUE
1624 ']' OF VAR domain ':' IDENTIFIER annotations
1625 optional_var_or_value_array */
1626#line 279 "./ortools/flatzinc/parser.yy"
1627 {
1628 // Declaration of a "variable array": these is exactly like N simple
1629 // variable declarations, where the identifier for declaration #i is
1630 // IDENTIFIER[i] (1-based index).
1631 CHECK_EQ((yyvsp[-10].integer_value), 1);
1632 const int64_t num_vars = (yyvsp[-8].integer_value);
1633 const Domain& domain = (yyvsp[-4].domain);
1634 const std::string& identifier = (yyvsp[-2].string_value);
1635 std::vector<Annotation>* const annotations = (yyvsp[-1].annotations);
1636 std::vector<VarRefOrValue>* const assignments =
1637 (yyvsp[0].var_or_value_array);
1638 CHECK(assignments == nullptr || assignments->size() == num_vars);
1639 const bool introduced = ContainsId(annotations, "var_is_introduced") ||
1640 absl::StartsWith(identifier, "X_INTRODUCED");
1641
1642 std::vector<Variable*> vars(num_vars, nullptr);
1643
1644 for (int i = 0; i < num_vars; ++i) {
1645 const std::string var_name =
1646 absl::StrFormat("%s[%d]", identifier, i + 1);
1647 if (assignments == nullptr) {
1648 vars[i] = model->AddVariable(var_name, domain, introduced);
1649 } else if ((*assignments)[i].variable == nullptr) {
1650 if ((*assignments)[i].is_float) {
1651 // Assigned to an float constant.
1652 const double value = (*assignments)[i].float_value;
1653 // CHECK(domain.Contains(value));
1654 vars[i] = model->AddVariable(var_name, Domain::FloatValue(value),
1655 introduced);
1656 } else {
1657 // Assigned to an integer constant.
1658 const int64_t value = (*assignments)[i].value;
1659 CHECK(domain.Contains(value));
1660 vars[i] = model->AddVariable(var_name, Domain::IntegerValue(value),
1661 introduced);
1662 }
1663 } else {
1664 Variable* const var = (*assignments)[i].variable;
1665 CHECK(var != nullptr);
1666 vars[i] = var;
1667 vars[i]->Merge(var_name, domain, introduced);
1668 }
1669 }
1670 delete assignments;
1671
1672 // Register the variable array on the context.
1673 context->variable_array_map[identifier] = vars;
1674
1675 // We parse the annotations to build an output object if
1676 // needed. It's a bit more convoluted than the simple variable
1677 // output.
1678 if (annotations != nullptr) {
1679 for (int i = 0; i < annotations->size(); ++i) {
1680 const Annotation& ann = (*annotations)[i];
1681 if (ann.IsFunctionCallWithIdentifier("output_array")) {
1682 // We have found an output annotation.
1683 CHECK_EQ(1, ann.annotations.size());
1684 CHECK_EQ(Annotation::ANNOTATION_LIST, ann.annotations.back().type);
1685 const Annotation& list = ann.annotations.back();
1686 // Let's build the vector of bounds.
1687 std::vector<SolutionOutputSpecs::Bounds> bounds;
1688 for (int a = 0; a < list.annotations.size(); ++a) {
1689 const Annotation& bound = list.annotations[a];
1690 CHECK_EQ(Annotation::INTERVAL, bound.type);
1691 bounds.emplace_back(SolutionOutputSpecs::Bounds(
1692 bound.interval_min, bound.interval_max));
1693 }
1694 // We add the output information.
1695 model->AddOutput(SolutionOutputSpecs::MultiDimensionalArray(
1696 identifier, bounds, vars, domain.display_as_boolean));
1697 }
1698 }
1699 delete annotations;
1700 }
1701 }
1702#line 1831 "./ortools/flatzinc/parser.tab.cc"
1703 break;
1704
1705 case 27: /* optional_var_or_value: '=' var_or_value */
1706#line 355 "./ortools/flatzinc/parser.yy"
1707 {
1708 (yyval.var_or_value) = (yyvsp[0].var_or_value);
1709 }
1710#line 1837 "./ortools/flatzinc/parser.tab.cc"
1711 break;
1712
1713 case 28: /* optional_var_or_value: %empty */
1714#line 356 "./ortools/flatzinc/parser.yy"
1715 {
1716 (yyval.var_or_value) = VarRefOrValue::Undefined();
1717 }
1718#line 1843 "./ortools/flatzinc/parser.tab.cc"
1719 break;
1720
1721 case 29: /* optional_var_or_value_array: '=' '[' var_or_value_array ']' */
1722#line 359 "./ortools/flatzinc/parser.yy"
1723 {
1724 (yyval.var_or_value_array) = (yyvsp[-1].var_or_value_array);
1725 }
1726#line 1849 "./ortools/flatzinc/parser.tab.cc"
1727 break;
1728
1729 case 30: /* optional_var_or_value_array: '=' '[' ']' */
1730#line 360 "./ortools/flatzinc/parser.yy"
1731 {
1732 (yyval.var_or_value_array) = nullptr;
1733 }
1734#line 1855 "./ortools/flatzinc/parser.tab.cc"
1735 break;
1736
1737 case 31: /* optional_var_or_value_array: %empty */
1738#line 361 "./ortools/flatzinc/parser.yy"
1739 {
1740 (yyval.var_or_value_array) = nullptr;
1741 }
1742#line 1861 "./ortools/flatzinc/parser.tab.cc"
1743 break;
1744
1745 case 32: /* var_or_value_array: var_or_value_array ',' var_or_value */
1746#line 364 "./ortools/flatzinc/parser.yy"
1747 {
1748 (yyval.var_or_value_array) = (yyvsp[-2].var_or_value_array);
1749 (yyval.var_or_value_array)->push_back((yyvsp[0].var_or_value));
1750 }
1751#line 1870 "./ortools/flatzinc/parser.tab.cc"
1752 break;
1753
1754 case 33: /* var_or_value_array: var_or_value */
1755#line 368 "./ortools/flatzinc/parser.yy"
1756 {
1757 (yyval.var_or_value_array) = new std::vector<VarRefOrValue>();
1758 (yyval.var_or_value_array)->push_back((yyvsp[0].var_or_value));
1759 }
1760#line 1879 "./ortools/flatzinc/parser.tab.cc"
1761 break;
1762
1763 case 34: /* var_or_value: IVALUE */
1764#line 374 "./ortools/flatzinc/parser.yy"
1765 {
1766 (yyval.var_or_value) = VarRefOrValue::Value((yyvsp[0].integer_value));
1767 }
1768#line 1885 "./ortools/flatzinc/parser.tab.cc"
1769 break;
1770
1771 case 35: /* var_or_value: DVALUE */
1772#line 375 "./ortools/flatzinc/parser.yy"
1773 {
1774 (yyval.var_or_value) = VarRefOrValue::FloatValue((yyvsp[0].double_value));
1775 }
1776#line 1891 "./ortools/flatzinc/parser.tab.cc"
1777 break;
1778
1779 case 36: /* var_or_value: IDENTIFIER */
1780#line 376 "./ortools/flatzinc/parser.yy"
1781 {
1782 // A reference to an existing integer constant or variable.
1783 const std::string& id = (yyvsp[0].string_value);
1784 if (gtl::ContainsKey(context->integer_map, id)) {
1785 (yyval.var_or_value) =
1786 VarRefOrValue::Value(gtl::FindOrDie(context->integer_map, id));
1787 } else if (gtl::ContainsKey(context->float_map, id)) {
1788 (yyval.var_or_value) =
1789 VarRefOrValue::FloatValue(gtl::FindOrDie(context->float_map, id));
1790 } else if (gtl::ContainsKey(context->variable_map, id)) {
1791 (yyval.var_or_value) =
1792 VarRefOrValue::VarRef(gtl::FindOrDie(context->variable_map, id));
1793 } else {
1794 LOG(ERROR) << "Unknown symbol " << id;
1795 (yyval.var_or_value) = VarRefOrValue::Undefined();
1796 *ok = false;
1797 }
1798 }
1799#line 1911 "./ortools/flatzinc/parser.tab.cc"
1800 break;
1801
1802 case 37: /* var_or_value: IDENTIFIER '[' IVALUE ']' */
1803#line 391 "./ortools/flatzinc/parser.yy"
1804 {
1805 // A given element of an existing constant array or variable array.
1806 const std::string& id = (yyvsp[-3].string_value);
1807 const int64_t value = (yyvsp[-1].integer_value);
1808 if (gtl::ContainsKey(context->integer_array_map, id)) {
1809 (yyval.var_or_value) = VarRefOrValue::Value(
1810 Lookup(gtl::FindOrDie(context->integer_array_map, id), value));
1811 } else if (gtl::ContainsKey(context->float_array_map, id)) {
1812 (yyval.var_or_value) = VarRefOrValue::FloatValue(
1813 Lookup(gtl::FindOrDie(context->float_array_map, id), value));
1814 } else if (gtl::ContainsKey(context->variable_array_map, id)) {
1815 (yyval.var_or_value) = VarRefOrValue::VarRef(
1816 Lookup(gtl::FindOrDie(context->variable_array_map, id), value));
1817 } else {
1818 LOG(ERROR) << "Unknown symbol " << id;
1819 (yyval.var_or_value) = VarRefOrValue::Undefined();
1820 *ok = false;
1821 }
1822 }
1823#line 1935 "./ortools/flatzinc/parser.tab.cc"
1824 break;
1825
1826 case 38: /* int_domain: TOKEN_BOOL */
1827#line 412 "./ortools/flatzinc/parser.yy"
1828 {
1829 (yyval.domain) = Domain::Boolean();
1830 }
1831#line 1941 "./ortools/flatzinc/parser.tab.cc"
1832 break;
1833
1834 case 39: /* int_domain: TOKEN_INT */
1835#line 413 "./ortools/flatzinc/parser.yy"
1836 {
1837 (yyval.domain) = Domain::AllInt64();
1838 }
1839#line 1947 "./ortools/flatzinc/parser.tab.cc"
1840 break;
1841
1842 case 40: /* int_domain: IVALUE DOTDOT IVALUE */
1843#line 414 "./ortools/flatzinc/parser.yy"
1844 {
1845 (yyval.domain) =
1846 Domain::Interval((yyvsp[-2].integer_value), (yyvsp[0].integer_value));
1847 }
1848#line 1953 "./ortools/flatzinc/parser.tab.cc"
1849 break;
1850
1851 case 41: /* int_domain: '{' integers '}' */
1852#line 415 "./ortools/flatzinc/parser.yy"
1853 {
1854 CHECK((yyvsp[-1].integers) != nullptr);
1855 (yyval.domain) = Domain::IntegerList(std::move(*(yyvsp[-1].integers)));
1856 delete (yyvsp[-1].integers);
1857 }
1858#line 1963 "./ortools/flatzinc/parser.tab.cc"
1859 break;
1860
1861 case 42: /* set_domain: SET OF TOKEN_BOOL */
1862#line 422 "./ortools/flatzinc/parser.yy"
1863 {
1864 (yyval.domain) = Domain::SetOfBoolean();
1865 }
1866#line 1969 "./ortools/flatzinc/parser.tab.cc"
1867 break;
1868
1869 case 43: /* set_domain: SET OF TOKEN_INT */
1870#line 423 "./ortools/flatzinc/parser.yy"
1871 {
1872 (yyval.domain) = Domain::SetOfAllInt64();
1873 }
1874#line 1975 "./ortools/flatzinc/parser.tab.cc"
1875 break;
1876
1877 case 44: /* set_domain: SET OF IVALUE DOTDOT IVALUE */
1878#line 424 "./ortools/flatzinc/parser.yy"
1879 {
1880 (yyval.domain) = Domain::SetOfInterval((yyvsp[-2].integer_value),
1881 (yyvsp[0].integer_value));
1882 }
1883#line 1981 "./ortools/flatzinc/parser.tab.cc"
1884 break;
1885
1886 case 45: /* set_domain: SET OF '{' integers '}' */
1887#line 425 "./ortools/flatzinc/parser.yy"
1888 {
1889 CHECK((yyvsp[-1].integers) != nullptr);
1890 (yyval.domain) =
1891 Domain::SetOfIntegerList(std::move(*(yyvsp[-1].integers)));
1892 delete (yyvsp[-1].integers);
1893 }
1894#line 1991 "./ortools/flatzinc/parser.tab.cc"
1895 break;
1896
1897 case 46: /* float_domain: TOKEN_FLOAT */
1898#line 432 "./ortools/flatzinc/parser.yy"
1899 {
1900 (yyval.domain) = Domain::AllFloats();
1901 }
1902#line 1997 "./ortools/flatzinc/parser.tab.cc"
1903 break;
1904
1905 case 47: /* float_domain: DVALUE DOTDOT DVALUE */
1906#line 433 "./ortools/flatzinc/parser.yy"
1907 {
1908 (yyval.domain) = Domain::FloatInterval((yyvsp[-2].double_value),
1909 (yyvsp[0].double_value));
1910 }
1911#line 2005 "./ortools/flatzinc/parser.tab.cc"
1912 break;
1913
1914 case 48: /* domain: int_domain */
1915#line 438 "./ortools/flatzinc/parser.yy"
1916 {
1917 (yyval.domain) = (yyvsp[0].domain);
1918 }
1919#line 2011 "./ortools/flatzinc/parser.tab.cc"
1920 break;
1921
1922 case 49: /* domain: set_domain */
1923#line 439 "./ortools/flatzinc/parser.yy"
1924 {
1925 (yyval.domain) = (yyvsp[0].domain);
1926 }
1927#line 2017 "./ortools/flatzinc/parser.tab.cc"
1928 break;
1929
1930 case 50: /* domain: float_domain */
1931#line 440 "./ortools/flatzinc/parser.yy"
1932 {
1933 (yyval.domain) = (yyvsp[0].domain);
1934 }
1935#line 2023 "./ortools/flatzinc/parser.tab.cc"
1936 break;
1937
1938 case 51: /* integers: integers ',' integer */
1939#line 443 "./ortools/flatzinc/parser.yy"
1940 {
1941 (yyval.integers) = (yyvsp[-2].integers);
1942 (yyval.integers)->emplace_back((yyvsp[0].integer_value));
1943 }
1944#line 2029 "./ortools/flatzinc/parser.tab.cc"
1945 break;
1946
1947 case 52: /* integers: integer */
1948#line 444 "./ortools/flatzinc/parser.yy"
1949 {
1950 (yyval.integers) = new std::vector<int64_t>();
1951 (yyval.integers)->emplace_back((yyvsp[0].integer_value));
1952 }
1953#line 2035 "./ortools/flatzinc/parser.tab.cc"
1954 break;
1955
1956 case 53: /* integer: IVALUE */
1957#line 447 "./ortools/flatzinc/parser.yy"
1958 {
1959 (yyval.integer_value) = (yyvsp[0].integer_value);
1960 }
1961#line 2041 "./ortools/flatzinc/parser.tab.cc"
1962 break;
1963
1964 case 54: /* integer: IDENTIFIER */
1965#line 448 "./ortools/flatzinc/parser.yy"
1966 {
1967 (yyval.integer_value) =
1968 gtl::FindOrDie(context->integer_map, (yyvsp[0].string_value));
1969 }
1970#line 2047 "./ortools/flatzinc/parser.tab.cc"
1971 break;
1972
1973 case 55: /* integer: IDENTIFIER '[' IVALUE ']' */
1974#line 449 "./ortools/flatzinc/parser.yy"
1975 {
1976 (yyval.integer_value) = Lookup(
1977 gtl::FindOrDie(context->integer_array_map, (yyvsp[-3].string_value)),
1978 (yyvsp[-1].integer_value));
1979 }
1980#line 2055 "./ortools/flatzinc/parser.tab.cc"
1981 break;
1982
1983 case 56: /* floats: floats ',' float */
1984#line 454 "./ortools/flatzinc/parser.yy"
1985 {
1986 (yyval.doubles) = (yyvsp[-2].doubles);
1987 (yyval.doubles)->emplace_back((yyvsp[0].double_value));
1988 }
1989#line 2061 "./ortools/flatzinc/parser.tab.cc"
1990 break;
1991
1992 case 57: /* floats: float */
1993#line 455 "./ortools/flatzinc/parser.yy"
1994 {
1995 (yyval.doubles) = new std::vector<double>();
1996 (yyval.doubles)->emplace_back((yyvsp[0].double_value));
1997 }
1998#line 2067 "./ortools/flatzinc/parser.tab.cc"
1999 break;
2000
2001 case 58: /* float: DVALUE */
2002#line 458 "./ortools/flatzinc/parser.yy"
2003 {
2004 (yyval.double_value) = (yyvsp[0].double_value);
2005 }
2006#line 2073 "./ortools/flatzinc/parser.tab.cc"
2007 break;
2008
2009 case 59: /* float: IDENTIFIER */
2010#line 459 "./ortools/flatzinc/parser.yy"
2011 {
2012 (yyval.double_value) =
2013 gtl::FindOrDie(context->float_map, (yyvsp[0].string_value));
2014 }
2015#line 2079 "./ortools/flatzinc/parser.tab.cc"
2016 break;
2017
2018 case 60: /* float: IDENTIFIER '[' IVALUE ']' */
2019#line 460 "./ortools/flatzinc/parser.yy"
2020 {
2021 (yyval.double_value) = Lookup(
2022 gtl::FindOrDie(context->float_array_map, (yyvsp[-3].string_value)),
2023 (yyvsp[-1].integer_value));
2024 }
2025#line 2087 "./ortools/flatzinc/parser.tab.cc"
2026 break;
2027
2028 case 61: /* const_literal: IVALUE */
2029#line 465 "./ortools/flatzinc/parser.yy"
2030 {
2031 (yyval.domain) = Domain::IntegerValue((yyvsp[0].integer_value));
2032 }
2033#line 2093 "./ortools/flatzinc/parser.tab.cc"
2034 break;
2035
2036 case 62: /* const_literal: IVALUE DOTDOT IVALUE */
2037#line 466 "./ortools/flatzinc/parser.yy"
2038 {
2039 (yyval.domain) =
2040 Domain::Interval((yyvsp[-2].integer_value), (yyvsp[0].integer_value));
2041 }
2042#line 2099 "./ortools/flatzinc/parser.tab.cc"
2043 break;
2044
2045 case 63: /* const_literal: '{' integers '}' */
2046#line 467 "./ortools/flatzinc/parser.yy"
2047 {
2048 CHECK((yyvsp[-1].integers) != nullptr);
2049 (yyval.domain) = Domain::IntegerList(std::move(*(yyvsp[-1].integers)));
2050 delete (yyvsp[-1].integers);
2051 }
2052#line 2109 "./ortools/flatzinc/parser.tab.cc"
2053 break;
2054
2055 case 64: /* const_literal: '{' '}' */
2056#line 472 "./ortools/flatzinc/parser.yy"
2057 {
2058 (yyval.domain) = Domain::EmptyDomain();
2059 }
2060#line 2115 "./ortools/flatzinc/parser.tab.cc"
2061 break;
2062
2063 case 65: /* const_literal: DVALUE */
2064#line 473 "./ortools/flatzinc/parser.yy"
2065 {
2066 (yyval.domain) = Domain::FloatValue((yyvsp[0].double_value));
2067 }
2068#line 2123 "./ortools/flatzinc/parser.tab.cc"
2069 break;
2070
2071 case 66: /* const_literal: IDENTIFIER */
2072#line 476 "./ortools/flatzinc/parser.yy"
2073 {
2074 (yyval.domain) = Domain::IntegerValue(
2075 gtl::FindOrDie(context->integer_map, (yyvsp[0].string_value)));
2076 }
2077#line 2129 "./ortools/flatzinc/parser.tab.cc"
2078 break;
2079
2080 case 67: /* const_literal: IDENTIFIER '[' IVALUE ']' */
2081#line 477 "./ortools/flatzinc/parser.yy"
2082 {
2083 (yyval.domain) = Domain::IntegerValue(Lookup(
2084 gtl::FindOrDie(context->integer_array_map, (yyvsp[-3].string_value)),
2085 (yyvsp[-1].integer_value)));
2086 }
2087#line 2138 "./ortools/flatzinc/parser.tab.cc"
2088 break;
2089
2090 case 68: /* const_literals: const_literals ',' const_literal */
2091#line 483 "./ortools/flatzinc/parser.yy"
2092 {
2093 (yyval.domains) = (yyvsp[-2].domains);
2094 (yyval.domains)->emplace_back((yyvsp[0].domain));
2095 }
2096#line 2147 "./ortools/flatzinc/parser.tab.cc"
2097 break;
2098
2099 case 69: /* const_literals: const_literal */
2100#line 487 "./ortools/flatzinc/parser.yy"
2101 {
2102 (yyval.domains) = new std::vector<Domain>();
2103 (yyval.domains)->emplace_back((yyvsp[0].domain));
2104 }
2105#line 2153 "./ortools/flatzinc/parser.tab.cc"
2106 break;
2107
2108 case 72: /* constraint: CONSTRAINT IDENTIFIER '(' arguments ')' annotations
2109 */
2110#line 497 "./ortools/flatzinc/parser.yy"
2111 {
2112 const std::string& identifier = (yyvsp[-4].string_value);
2113 CHECK((yyvsp[-2].args) != nullptr) << "Missing argument in constraint";
2114 const std::vector<Argument>& arguments = *(yyvsp[-2].args);
2115 std::vector<Annotation>* const annotations = (yyvsp[0].annotations);
2116
2117 model->AddConstraint(identifier, arguments,
2118 ContainsId(annotations, "domain"));
2119 delete annotations;
2120 delete (yyvsp[-2].args);
2121 }
2122#line 2168 "./ortools/flatzinc/parser.tab.cc"
2123 break;
2124
2125 case 73: /* arguments: arguments ',' argument */
2126#line 509 "./ortools/flatzinc/parser.yy"
2127 {
2128 (yyval.args) = (yyvsp[-2].args);
2129 (yyval.args)->emplace_back((yyvsp[0].arg));
2130 }
2131#line 2174 "./ortools/flatzinc/parser.tab.cc"
2132 break;
2133
2134 case 74: /* arguments: argument */
2135#line 510 "./ortools/flatzinc/parser.yy"
2136 {
2137 (yyval.args) = new std::vector<Argument>();
2138 (yyval.args)->emplace_back((yyvsp[0].arg));
2139 }
2140#line 2180 "./ortools/flatzinc/parser.tab.cc"
2141 break;
2142
2143 case 75: /* argument: IVALUE */
2144#line 513 "./ortools/flatzinc/parser.yy"
2145 {
2146 (yyval.arg) = Argument::IntegerValue((yyvsp[0].integer_value));
2147 }
2148#line 2186 "./ortools/flatzinc/parser.tab.cc"
2149 break;
2150
2151 case 76: /* argument: DVALUE */
2152#line 514 "./ortools/flatzinc/parser.yy"
2153 {
2154 (yyval.arg) = Argument::FloatValue((yyvsp[0].double_value));
2155 }
2156#line 2192 "./ortools/flatzinc/parser.tab.cc"
2157 break;
2158
2159 case 77: /* argument: SVALUE */
2160#line 515 "./ortools/flatzinc/parser.yy"
2161 {
2162 (yyval.arg) = Argument::VoidArgument();
2163 }
2164#line 2198 "./ortools/flatzinc/parser.tab.cc"
2165 break;
2166
2167 case 78: /* argument: IVALUE DOTDOT IVALUE */
2168#line 516 "./ortools/flatzinc/parser.yy"
2169 {
2170 (yyval.arg) = Argument::Interval((yyvsp[-2].integer_value),
2171 (yyvsp[0].integer_value));
2172 }
2173#line 2204 "./ortools/flatzinc/parser.tab.cc"
2174 break;
2175
2176 case 79: /* argument: '{' integers '}' */
2177#line 517 "./ortools/flatzinc/parser.yy"
2178 {
2179 CHECK((yyvsp[-1].integers) != nullptr);
2180 (yyval.arg) = Argument::IntegerList(std::move(*(yyvsp[-1].integers)));
2181 delete (yyvsp[-1].integers);
2182 }
2183#line 2214 "./ortools/flatzinc/parser.tab.cc"
2184 break;
2185
2186 case 80: /* argument: IDENTIFIER */
2187#line 522 "./ortools/flatzinc/parser.yy"
2188 {
2189 const std::string& id = (yyvsp[0].string_value);
2190 if (gtl::ContainsKey(context->integer_map, id)) {
2191 (yyval.arg) =
2192 Argument::IntegerValue(gtl::FindOrDie(context->integer_map, id));
2193 } else if (gtl::ContainsKey(context->integer_array_map, id)) {
2194 (yyval.arg) = Argument::IntegerList(
2195 gtl::FindOrDie(context->integer_array_map, id));
2196 } else if (gtl::ContainsKey(context->float_map, id)) {
2197 const double d = gtl::FindOrDie(context->float_map, id);
2198 (yyval.arg) = Argument::FloatValue(d);
2199 } else if (gtl::ContainsKey(context->float_array_map, id)) {
2200 const auto& double_values =
2201 gtl::FindOrDie(context->float_array_map, id);
2202 (yyval.arg) = Argument::FloatList(std::move(double_values));
2203 } else if (gtl::ContainsKey(context->variable_map, id)) {
2204 (yyval.arg) =
2205 Argument::VarRef(gtl::FindOrDie(context->variable_map, id));
2206 } else if (gtl::ContainsKey(context->variable_array_map, id)) {
2207 (yyval.arg) = Argument::VarRefArray(
2208 gtl::FindOrDie(context->variable_array_map, id));
2209 } else if (gtl::ContainsKey(context->domain_map, id)) {
2210 const Domain& d = gtl::FindOrDie(context->domain_map, id);
2211 (yyval.arg) = Argument::FromDomain(d);
2212 } else {
2213 CHECK(gtl::ContainsKey(context->domain_array_map, id))
2214 << "Unknown identifier: " << id;
2215 const std::vector<Domain>& d =
2216 gtl::FindOrDie(context->domain_array_map, id);
2217 (yyval.arg) = Argument::DomainList(d);
2218 }
2219 }
2220#line 2245 "./ortools/flatzinc/parser.tab.cc"
2221 break;
2222
2223 case 81: /* argument: IDENTIFIER '[' IVALUE ']' */
2224#line 548 "./ortools/flatzinc/parser.yy"
2225 {
2226 const std::string& id = (yyvsp[-3].string_value);
2227 const int64_t index = (yyvsp[-1].integer_value);
2228 if (gtl::ContainsKey(context->integer_array_map, id)) {
2229 (yyval.arg) = Argument::IntegerValue(
2230 Lookup(gtl::FindOrDie(context->integer_array_map, id), index));
2231 } else if (gtl::ContainsKey(context->variable_array_map, id)) {
2232 (yyval.arg) = Argument::VarRef(
2233 Lookup(gtl::FindOrDie(context->variable_array_map, id), index));
2234 } else {
2235 CHECK(gtl::ContainsKey(context->domain_array_map, id))
2236 << "Unknown identifier: " << id;
2237 const Domain& d =
2238 Lookup(gtl::FindOrDie(context->domain_array_map, id), index);
2239 (yyval.arg) = Argument::FromDomain(d);
2240 }
2241 }
2242#line 2267 "./ortools/flatzinc/parser.tab.cc"
2243 break;
2244
2245 case 82: /* argument: '[' var_or_value_array ']' */
2246#line 565 "./ortools/flatzinc/parser.yy"
2247 {
2248 std::vector<VarRefOrValue>* const arguments =
2249 (yyvsp[-1].var_or_value_array);
2250 CHECK(arguments != nullptr);
2251 bool has_variables = false;
2252 bool has_floats = false;
2253 for (int i = 0; i < arguments->size(); ++i) {
2254 if ((*arguments)[i].variable != nullptr) {
2255 has_variables = true;
2256 }
2257 if ((*arguments)[i].is_float) {
2258 has_floats = true;
2259 }
2260 }
2261 if (has_variables) {
2262 std::vector<Variable*> vars;
2263 vars.reserve(arguments->size());
2264 for (int i = 0; i < arguments->size(); ++i) {
2265 const VarRefOrValue data = (*arguments)[i];
2266 if (data.variable != nullptr) {
2267 vars.push_back(data.variable);
2268 } else if (!data.is_float) {
2269 vars.push_back(model->AddConstant(data.value));
2270 } else {
2271 vars.push_back(model->AddFloatConstant(data.float_value));
2272 }
2273 }
2274 (yyval.arg) = Argument::VarRefArray(std::move(vars));
2275 } else if (has_floats) {
2276 std::vector<double> values;
2277 values.reserve(arguments->size());
2278 for (const VarRefOrValue& data : *arguments) {
2279 if (data.is_float) {
2280 values.push_back(data.float_value);
2281 } else {
2282 values.push_back(data.value);
2283 }
2284 }
2285 (yyval.arg) = Argument::FloatList(std::move(values));
2286 } else {
2287 std::vector<int64_t> values;
2288 values.reserve(arguments->size());
2289 for (const VarRefOrValue& data : *arguments) {
2290 values.push_back(data.value);
2291 }
2292 (yyval.arg) = Argument::IntegerList(std::move(values));
2293 }
2294 delete arguments;
2295 }
2296#line 2320 "./ortools/flatzinc/parser.tab.cc"
2297 break;
2298
2299 case 83: /* argument: '[' ']' */
2300#line 613 "./ortools/flatzinc/parser.yy"
2301 {
2302 (yyval.arg) = Argument::VoidArgument();
2303 }
2304#line 2328 "./ortools/flatzinc/parser.tab.cc"
2305 break;
2306
2307 case 84: /* annotations: annotations COLONCOLON annotation */
2308#line 622 "./ortools/flatzinc/parser.yy"
2309 {
2310 (yyval.annotations) = (yyvsp[-2].annotations) != nullptr
2311 ? (yyvsp[-2].annotations)
2312 : new std::vector<Annotation>();
2313 (yyval.annotations)->emplace_back((yyvsp[0].annotation));
2314 }
2315#line 2337 "./ortools/flatzinc/parser.tab.cc"
2316 break;
2317
2318 case 85: /* annotations: %empty */
2319#line 626 "./ortools/flatzinc/parser.yy"
2320 {
2321 (yyval.annotations) = nullptr;
2322 }
2323#line 2343 "./ortools/flatzinc/parser.tab.cc"
2324 break;
2325
2326 case 86: /* annotation_arguments: annotation_arguments ',' annotation */
2327#line 629 "./ortools/flatzinc/parser.yy"
2328 {
2329 (yyval.annotations) = (yyvsp[-2].annotations);
2330 (yyval.annotations)->emplace_back((yyvsp[0].annotation));
2331 }
2332#line 2349 "./ortools/flatzinc/parser.tab.cc"
2333 break;
2334
2335 case 87: /* annotation_arguments: annotation */
2336#line 630 "./ortools/flatzinc/parser.yy"
2337 {
2338 (yyval.annotations) = new std::vector<Annotation>();
2339 (yyval.annotations)->emplace_back((yyvsp[0].annotation));
2340 }
2341#line 2355 "./ortools/flatzinc/parser.tab.cc"
2342 break;
2343
2344 case 88: /* annotation: IVALUE DOTDOT IVALUE */
2345#line 633 "./ortools/flatzinc/parser.yy"
2346 {
2347 (yyval.annotation) = Annotation::Interval((yyvsp[-2].integer_value),
2348 (yyvsp[0].integer_value));
2349 }
2350#line 2361 "./ortools/flatzinc/parser.tab.cc"
2351 break;
2352
2353 case 89: /* annotation: IVALUE */
2354#line 634 "./ortools/flatzinc/parser.yy"
2355 {
2356 (yyval.annotation) = Annotation::IntegerValue((yyvsp[0].integer_value));
2357 }
2358#line 2367 "./ortools/flatzinc/parser.tab.cc"
2359 break;
2360
2361 case 90: /* annotation: SVALUE */
2362#line 635 "./ortools/flatzinc/parser.yy"
2363 {
2364 (yyval.annotation) = Annotation::String((yyvsp[0].string_value));
2365 }
2366#line 2373 "./ortools/flatzinc/parser.tab.cc"
2367 break;
2368
2369 case 91: /* annotation: IDENTIFIER */
2370#line 636 "./ortools/flatzinc/parser.yy"
2371 {
2372 const std::string& id = (yyvsp[0].string_value);
2373 if (gtl::ContainsKey(context->variable_map, id)) {
2374 (yyval.annotation) =
2375 Annotation::VarRef(gtl::FindOrDie(context->variable_map, id));
2376 } else if (gtl::ContainsKey(context->variable_array_map, id)) {
2377 (yyval.annotation) = Annotation::VarRefArray(
2378 gtl::FindOrDie(context->variable_array_map, id));
2379 } else {
2380 (yyval.annotation) = Annotation::Identifier(id);
2381 }
2382 }
2383#line 2388 "./ortools/flatzinc/parser.tab.cc"
2384 break;
2385
2386 case 92: /* annotation: IDENTIFIER '(' annotation_arguments ')' */
2387#line 646 "./ortools/flatzinc/parser.yy"
2388 {
2389 std::vector<Annotation>* const annotations = (yyvsp[-1].annotations);
2390 if (annotations != nullptr) {
2391 (yyval.annotation) = Annotation::FunctionCallWithArguments(
2392 (yyvsp[-3].string_value), std::move(*annotations));
2393 delete annotations;
2394 } else {
2395 (yyval.annotation) = Annotation::FunctionCall((yyvsp[-3].string_value));
2396 }
2397 }
2398#line 2402 "./ortools/flatzinc/parser.tab.cc"
2399 break;
2400
2401 case 93: /* annotation: IDENTIFIER '[' IVALUE ']' */
2402#line 655 "./ortools/flatzinc/parser.yy"
2403 {
2404 CHECK(gtl::ContainsKey(context->variable_array_map,
2405 (yyvsp[-3].string_value)))
2406 << "Unknown identifier: " << (yyvsp[-3].string_value);
2407 (yyval.annotation) = Annotation::VarRef(Lookup(
2408 gtl::FindOrDie(context->variable_array_map, (yyvsp[-3].string_value)),
2409 (yyvsp[-1].integer_value)));
2410 }
2411#line 2413 "./ortools/flatzinc/parser.tab.cc"
2412 break;
2413
2414 case 94: /* annotation: '[' annotation_arguments ']' */
2415#line 661 "./ortools/flatzinc/parser.yy"
2416 {
2417 std::vector<Annotation>* const annotations = (yyvsp[-1].annotations);
2418 if (annotations != nullptr) {
2419 (yyval.annotation) =
2420 Annotation::AnnotationList(std::move(*annotations));
2421 delete annotations;
2422 } else {
2423 (yyval.annotation) = Annotation::Empty();
2424 }
2425 }
2426#line 2427 "./ortools/flatzinc/parser.tab.cc"
2427 break;
2428
2429 case 95: /* solve: SOLVE annotations SATISFY */
2430#line 676 "./ortools/flatzinc/parser.yy"
2431 {
2432 if ((yyvsp[-1].annotations) != nullptr) {
2433 model->Satisfy(std::move(*(yyvsp[-1].annotations)));
2434 delete (yyvsp[-1].annotations);
2435 } else {
2436 model->Satisfy(std::vector<Annotation>());
2437 }
2438 }
2439#line 2440 "./ortools/flatzinc/parser.tab.cc"
2440 break;
2441
2442 case 96: /* solve: SOLVE annotations MINIMIZE argument */
2443#line 684 "./ortools/flatzinc/parser.yy"
2444 {
2445 Variable* obj_var = (yyvsp[0].arg).type == Argument::VAR_REF
2446 ? (yyvsp[0].arg).Var()
2447 : model->AddConstant((yyvsp[0].arg).Value());
2448 if ((yyvsp[-2].annotations) != nullptr) {
2449 model->Minimize(obj_var, std::move(*(yyvsp[-2].annotations)));
2450 delete (yyvsp[-2].annotations);
2451 } else {
2452 model->Minimize(obj_var, std::vector<Annotation>());
2453 }
2454 }
2455#line 2456 "./ortools/flatzinc/parser.tab.cc"
2456 break;
2457
2458 case 97: /* solve: SOLVE annotations MAXIMIZE argument */
2459#line 695 "./ortools/flatzinc/parser.yy"
2460 {
2461 Variable* obj_var = (yyvsp[0].arg).type == Argument::VAR_REF
2462 ? (yyvsp[0].arg).Var()
2463 : model->AddConstant((yyvsp[0].arg).Value());
2464 if ((yyvsp[-2].annotations) != nullptr) {
2465 model->Maximize(obj_var, std::move(*(yyvsp[-2].annotations)));
2466 delete (yyvsp[-2].annotations);
2467 } else {
2468 model->Maximize(obj_var, std::vector<Annotation>());
2469 }
2470 }
2471#line 2472 "./ortools/flatzinc/parser.tab.cc"
2472 break;
2473
2474#line 2476 "./ortools/flatzinc/parser.tab.cc"
2475
2476 default:
2477 break;
2478 }
2479 /* User semantic actions sometimes alter yychar, and that requires
2480 that yytoken be updated with the new translation. We take the
2481 approach of translating immediately before every use of yytoken.
2482 One alternative is translating here after every semantic action,
2483 but that translation would be missed if the semantic action invokes
2484 YYABORT, YYACCEPT, or YYERROR immediately after altering yychar or
2485 if it invokes YYBACKUP. In the case of YYABORT or YYACCEPT, an
2486 incorrect destructor might then be invoked immediately. In the
2487 case of YYERROR or YYBACKUP, subsequent parser actions might lead
2488 to an incorrect destructor call or verbose syntax error message
2489 before the lookahead is translated. */
2490 YY_SYMBOL_PRINT("-> $$ =", YY_CAST(yysymbol_kind_t, yyr1[yyn]), &yyval,
2491 &yyloc);
2492
2493 YYPOPSTACK(yylen);
2494 yylen = 0;
2495
2496 *++yyvsp = yyval;
2497
2498 /* Now 'shift' the result of the reduction. Determine what state
2499 that goes to, based on the state we popped back to and the rule
2500 number reduced by. */
2501 {
2502 const int yylhs = yyr1[yyn] - YYNTOKENS;
2503 const int yyi = yypgoto[yylhs] + *yyssp;
2504 yystate = (0 <= yyi && yyi <= YYLAST && yycheck[yyi] == *yyssp
2505 ? yytable[yyi]
2506 : yydefgoto[yylhs]);
2507 }
2508
2509 goto yynewstate;
2510
2511/*--------------------------------------.
2512| yyerrlab -- here on detecting error. |
2513`--------------------------------------*/
2514yyerrlab:
2515 /* Make sure we have latest lookahead translation. See comments at
2516 user semantic actions for why this is necessary. */
2517 yytoken = yychar == ORFZ_EMPTY ? YYSYMBOL_YYEMPTY : YYTRANSLATE(yychar);
2518 /* If not already recovering from an error, report this error. */
2519 if (!yyerrstatus) {
2520 ++yynerrs;
2521 {
2522 yypcontext_t yyctx = {yyssp, yytoken};
2523 char const* yymsgp = YY_("syntax error");
2524 int yysyntax_error_status;
2525 yysyntax_error_status = yysyntax_error(&yymsg_alloc, &yymsg, &yyctx);
2526 if (yysyntax_error_status == 0)
2527 yymsgp = yymsg;
2528 else if (yysyntax_error_status == -1) {
2529 if (yymsg != yymsgbuf) YYSTACK_FREE(yymsg);
2530 yymsg = YY_CAST(char*, YYSTACK_ALLOC(YY_CAST(YYSIZE_T, yymsg_alloc)));
2531 if (yymsg) {
2532 yysyntax_error_status = yysyntax_error(&yymsg_alloc, &yymsg, &yyctx);
2533 yymsgp = yymsg;
2534 } else {
2535 yymsg = yymsgbuf;
2536 yymsg_alloc = sizeof yymsgbuf;
2537 yysyntax_error_status = YYENOMEM;
2538 }
2539 }
2540 yyerror(context, model, ok, scanner, yymsgp);
2541 if (yysyntax_error_status == YYENOMEM) goto yyexhaustedlab;
2542 }
2543 }
2544
2545 if (yyerrstatus == 3) {
2546 /* If just tried and failed to reuse lookahead token after an
2547 error, discard it. */
2548
2549 if (yychar <= ORFZ_EOF) {
2550 /* Return failure if at end of input. */
2551 if (yychar == ORFZ_EOF) YYABORT;
2552 } else {
2553 yydestruct("Error: discarding", yytoken, &yylval, context, model, ok,
2554 scanner);
2555 yychar = ORFZ_EMPTY;
2556 }
2557 }
2558
2559 /* Else will try to reuse lookahead token after shifting the error
2560 token. */
2561 goto yyerrlab1;
2562
2563/*---------------------------------------------------.
2564| yyerrorlab -- error raised explicitly by YYERROR. |
2565`---------------------------------------------------*/
2566yyerrorlab:
2567 /* Pacify compilers when the user code never invokes YYERROR and the
2568 label yyerrorlab therefore never appears in user code. */
2569 if (0) YYERROR;
2570
2571 /* Do not reclaim the symbols of the rule whose action triggered
2572 this YYERROR. */
2573 YYPOPSTACK(yylen);
2574 yylen = 0;
2575 YY_STACK_PRINT(yyss, yyssp);
2576 yystate = *yyssp;
2577 goto yyerrlab1;
2578
2579/*-------------------------------------------------------------.
2580| yyerrlab1 -- common code for both syntax error and YYERROR. |
2581`-------------------------------------------------------------*/
2582yyerrlab1:
2583 yyerrstatus = 3; /* Each real token shifted decrements this. */
2584
2585 /* Pop stack until we find a state that shifts the error token. */
2586 for (;;) {
2587 yyn = yypact[yystate];
2588 if (!yypact_value_is_default(yyn)) {
2589 yyn += YYSYMBOL_YYerror;
2590 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYSYMBOL_YYerror) {
2591 yyn = yytable[yyn];
2592 if (0 < yyn) break;
2593 }
2594 }
2595
2596 /* Pop the current state because it cannot handle the error token. */
2597 if (yyssp == yyss) YYABORT;
2598
2599 yydestruct("Error: popping", YY_ACCESSING_SYMBOL(yystate), yyvsp, context,
2600 model, ok, scanner);
2601 YYPOPSTACK(1);
2602 yystate = *yyssp;
2603 YY_STACK_PRINT(yyss, yyssp);
2604 }
2605
2606 YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
2607 *++yyvsp = yylval;
2608 YY_IGNORE_MAYBE_UNINITIALIZED_END
2609
2610 /* Shift the error token. */
2611 YY_SYMBOL_PRINT("Shifting", YY_ACCESSING_SYMBOL(yyn), yyvsp, yylsp);
2612
2613 yystate = yyn;
2614 goto yynewstate;
2615
2616/*-------------------------------------.
2617| yyacceptlab -- YYACCEPT comes here. |
2618`-------------------------------------*/
2619yyacceptlab:
2620 yyresult = 0;
2621 goto yyreturn;
2622
2623/*-----------------------------------.
2624| yyabortlab -- YYABORT comes here. |
2625`-----------------------------------*/
2626yyabortlab:
2627 yyresult = 1;
2628 goto yyreturn;
2629
2630#if 1
2631/*-------------------------------------------------.
2632| yyexhaustedlab -- memory exhaustion comes here. |
2633`-------------------------------------------------*/
2634yyexhaustedlab:
2635 yyerror(context, model, ok, scanner, YY_("memory exhausted"));
2636 yyresult = 2;
2637 goto yyreturn;
2638#endif
2639
2640/*-------------------------------------------------------.
2641| yyreturn -- parsing is finished, clean up and return. |
2642`-------------------------------------------------------*/
2643yyreturn:
2644 if (yychar != ORFZ_EMPTY) {
2645 /* Make sure we have latest lookahead translation. See comments at
2646 user semantic actions for why this is necessary. */
2647 yytoken = YYTRANSLATE(yychar);
2648 yydestruct("Cleanup: discarding lookahead", yytoken, &yylval, context,
2649 model, ok, scanner);
2650 }
2651 /* Do not reclaim the symbols of the rule whose action triggered
2652 this YYABORT or YYACCEPT. */
2653 YYPOPSTACK(yylen);
2654 YY_STACK_PRINT(yyss, yyssp);
2655 while (yyssp != yyss) {
2656 yydestruct("Cleanup: popping", YY_ACCESSING_SYMBOL(+*yyssp), yyvsp, context,
2657 model, ok, scanner);
2658 YYPOPSTACK(1);
2659 }
2660#ifndef yyoverflow
2661 if (yyss != yyssa) YYSTACK_FREE(yyss);
2662#endif
2663 if (yymsg != yymsgbuf) YYSTACK_FREE(yymsg);
2664 return yyresult;
2665}
2666
2667#line 707 "./ortools/flatzinc/parser.yy"
CHECK
#define CHECK(condition)
Definition: base/logging.h:491
CHECK_EQ
#define CHECK_EQ(val1, val2)
Definition: base/logging.h:698
LOG
#define LOG(severity)
Definition: base/logging.h:416
operations_research::fz::Model
Definition: flatzinc/model.h:333
a
int64_t a
Definition: constraint_solver/table.cc:46
bounds
SharedBoundsManager * bounds
Definition: cp_model_solver.cc:2014
value
int64_t value
Definition: demon_profiler.cc:44
var
IntVar * var
Definition: expr_array.cc:1874
model
GRBmodel * model
Definition: gurobi_interface.cc:273
context
GurobiMPCallbackContext * context
Definition: gurobi_interface.cc:513
ERROR
const int ERROR
Definition: log_severity.h:32
gtl::FindOrDie
const Collection::value_type::second_type & FindOrDie(const Collection &collection, const typename Collection::value_type::first_type &key)
Definition: map_util.h:206
gtl::ContainsKey
bool ContainsKey(const Collection &collection, const Key &key)
Definition: map_util.h:200
operations_research::fz::Lookup
const T & Lookup(const std::vector< T > &v, int index)
Definition: parser_util.cc:75
operations_research::fz::ContainsId
bool ContainsId(std::vector< Annotation > *annotations, const std::string &id)
Definition: parser_util.cc:43
operations_research::fz::ConvertAsIntegerOrDie
int64_t ConvertAsIntegerOrDie(double d)
Definition: parser_util.cc:65
operations_research::fz::AllDomainsHaveOneValue
bool AllDomainsHaveOneValue(const std::vector< Domain > &domains)
Definition: parser_util.cc:56
operations_research::sat::Value
std::function< int64_t(const Model &)> Value(IntegerVariable v)
Definition: integer.h:1544
index
int index
Definition: pack.cc:509
yysymbol_name
static const char * yysymbol_name(yysymbol_kind_t yysymbol) YY_ATTRIBUTE_UNUSED
Definition: parser.tab.cc:635
yystrlen
static YYPTRDIFF_T yystrlen(const char *yystr)
Definition: parser.tab.cc:1000
YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
#define YY_IGNORE_MAYBE_UNINITIALIZED_BEGIN
Definition: parser.tab.cc:362
YYMAXDEPTH
#define YYMAXDEPTH
Definition: parser.tab.cc:951
yydestruct
static void yydestruct(const char *yymsg, yysymbol_kind_t yykind, YYSTYPE *yyvaluep, operations_research::fz::ParserContext *context, operations_research::fz::Model *model, bool *ok, void *scanner)
Definition: parser.tab.cc:1192
YYSTACK_FREE
#define YYSTACK_FREE
Definition: parser.tab.cc:425
yytranslate
static const yytype_int8 yytranslate[]
Definition: parser.tab.cc:531
yysymbol_kind_t
yysymbol_kind_t
Definition: parser.tab.cc:111
YYSYMBOL_integer
@ YYSYMBOL_integer
Definition: parser.tab.cc:166
YYSYMBOL_25_
@ YYSYMBOL_25_
Definition: parser.tab.cc:138
YYSYMBOL_YYUNDEF
@ YYSYMBOL_YYUNDEF
Definition: parser.tab.cc:115
YYSYMBOL_const_literals
@ YYSYMBOL_const_literals
Definition: parser.tab.cc:170
YYSYMBOL_optional_var_or_value_array
@ YYSYMBOL_optional_var_or_value_array
Definition: parser.tab.cc:158
YYSYMBOL_float_domain
@ YYSYMBOL_float_domain
Definition: parser.tab.cc:163
YYSYMBOL_var_or_value_array
@ YYSYMBOL_var_or_value_array
Definition: parser.tab.cc:159
YYSYMBOL_var_or_value
@ YYSYMBOL_var_or_value
Definition: parser.tab.cc:160
YYSYMBOL_DVALUE
@ YYSYMBOL_DVALUE
Definition: parser.tab.cc:134
YYSYMBOL_SVALUE
@ YYSYMBOL_SVALUE
Definition: parser.tab.cc:132
YYSYMBOL_26_
@ YYSYMBOL_26_
Definition: parser.tab.cc:139
YYSYMBOL_YYerror
@ YYSYMBOL_YYerror
Definition: parser.tab.cc:114
YYSYMBOL_SET
@ YYSYMBOL_SET
Definition: parser.tab.cc:126
YYSYMBOL_IVALUE
@ YYSYMBOL_IVALUE
Definition: parser.tab.cc:131
YYSYMBOL_predicate
@ YYSYMBOL_predicate
Definition: parser.tab.cc:148
YYSYMBOL_SATISFY
@ YYSYMBOL_SATISFY
Definition: parser.tab.cc:125
YYSYMBOL_29_
@ YYSYMBOL_29_
Definition: parser.tab.cc:142
YYSYMBOL_TOKEN_FLOAT
@ YYSYMBOL_TOKEN_FLOAT
Definition: parser.tab.cc:119
YYSYMBOL_28_
@ YYSYMBOL_28_
Definition: parser.tab.cc:141
YYSYMBOL_variable_or_constant_declarations
@ YYSYMBOL_variable_or_constant_declarations
Definition: parser.tab.cc:153
YYSYMBOL_annotation
@ YYSYMBOL_annotation
Definition: parser.tab.cc:177
YYSYMBOL_predicate_arguments
@ YYSYMBOL_predicate_arguments
Definition: parser.tab.cc:149
YYSYMBOL_constraints
@ YYSYMBOL_constraints
Definition: parser.tab.cc:171
YYSYMBOL_variable_or_constant_declaration
@ YYSYMBOL_variable_or_constant_declaration
Definition: parser.tab.cc:155
YYSYMBOL_annotations
@ YYSYMBOL_annotations
Definition: parser.tab.cc:175
YYSYMBOL_floats
@ YYSYMBOL_floats
Definition: parser.tab.cc:167
YYSYMBOL_model
@ YYSYMBOL_model
Definition: parser.tab.cc:146
YYSYMBOL_integers
@ YYSYMBOL_integers
Definition: parser.tab.cc:165
YYSYMBOL_solve
@ YYSYMBOL_solve
Definition: parser.tab.cc:178
YYSYMBOL_arguments
@ YYSYMBOL_arguments
Definition: parser.tab.cc:173
YYSYMBOL_optional_var_or_value
@ YYSYMBOL_optional_var_or_value
Definition: parser.tab.cc:157
YYSYMBOL_predicate_array_argument
@ YYSYMBOL_predicate_array_argument
Definition: parser.tab.cc:151
YYSYMBOL_annotation_arguments
@ YYSYMBOL_annotation_arguments
Definition: parser.tab.cc:176
YYSYMBOL_DOTDOT
@ YYSYMBOL_DOTDOT
Definition: parser.tab.cc:129
YYSYMBOL_TOKEN_INT
@ YYSYMBOL_TOKEN_INT
Definition: parser.tab.cc:120
YYSYMBOL_VAR
@ YYSYMBOL_VAR
Definition: parser.tab.cc:128
YYSYMBOL_set_domain
@ YYSYMBOL_set_domain
Definition: parser.tab.cc:162
YYSYMBOL_TOKEN_BOOL
@ YYSYMBOL_TOKEN_BOOL
Definition: parser.tab.cc:117
YYSYMBOL_constraint
@ YYSYMBOL_constraint
Definition: parser.tab.cc:172
YYSYMBOL_MINIMIZE
@ YYSYMBOL_MINIMIZE
Definition: parser.tab.cc:122
YYSYMBOL_ARRAY
@ YYSYMBOL_ARRAY
Definition: parser.tab.cc:116
YYSYMBOL_float
@ YYSYMBOL_float
Definition: parser.tab.cc:168
YYSYMBOL_predicate_argument
@ YYSYMBOL_predicate_argument
Definition: parser.tab.cc:150
YYSYMBOL_COLONCOLON
@ YYSYMBOL_COLONCOLON
Definition: parser.tab.cc:130
YYSYMBOL_const_literal
@ YYSYMBOL_const_literal
Definition: parser.tab.cc:169
YYSYMBOL_predicate_ints
@ YYSYMBOL_predicate_ints
Definition: parser.tab.cc:152
YYSYMBOL_YYACCEPT
@ YYSYMBOL_YYACCEPT
Definition: parser.tab.cc:145
YYSYMBOL_30_
@ YYSYMBOL_30_
Definition: parser.tab.cc:143
YYSYMBOL_23_
@ YYSYMBOL_23_
Definition: parser.tab.cc:136
YYSYMBOL_domain
@ YYSYMBOL_domain
Definition: parser.tab.cc:164
YYSYMBOL_YYEOF
@ YYSYMBOL_YYEOF
Definition: parser.tab.cc:113
YYSYMBOL_OF
@ YYSYMBOL_OF
Definition: parser.tab.cc:123
YYSYMBOL_22_
@ YYSYMBOL_22_
Definition: parser.tab.cc:135
YYSYMBOL_24_
@ YYSYMBOL_24_
Definition: parser.tab.cc:137
YYSYMBOL_27_
@ YYSYMBOL_27_
Definition: parser.tab.cc:140
YYSYMBOL_argument
@ YYSYMBOL_argument
Definition: parser.tab.cc:174
YYSYMBOL_YYEMPTY
@ YYSYMBOL_YYEMPTY
Definition: parser.tab.cc:112
YYSYMBOL_IDENTIFIER
@ YYSYMBOL_IDENTIFIER
Definition: parser.tab.cc:133
YYSYMBOL_predicates
@ YYSYMBOL_predicates
Definition: parser.tab.cc:147
YYSYMBOL_int_domain
@ YYSYMBOL_int_domain
Definition: parser.tab.cc:161
YYSYMBOL_PREDICATE
@ YYSYMBOL_PREDICATE
Definition: parser.tab.cc:124
YYSYMBOL_31_
@ YYSYMBOL_31_
Definition: parser.tab.cc:144
YYSYMBOL_CONSTRAINT
@ YYSYMBOL_CONSTRAINT
Definition: parser.tab.cc:118
YYSYMBOL_MAXIMIZE
@ YYSYMBOL_MAXIMIZE
Definition: parser.tab.cc:121
YYSYMBOL_SOLVE
@ YYSYMBOL_SOLVE
Definition: parser.tab.cc:127
yyerrok
#define yyerrok
Definition: parser.tab.cc:787
YY_ASSERT
#define YY_ASSERT(E)
Definition: parser.tab.cc:380
YY_
#define YY_(Msgid)
Definition: parser.tab.cc:324
YY_IGNORE_MAYBE_UNINITIALIZED_END
#define YY_IGNORE_MAYBE_UNINITIALIZED_END
Definition: parser.tab.cc:363
yydefact
static const yytype_int8 yydefact[]
Definition: parser.tab.cc:683
YYNSTATES
#define YYNSTATES
Definition: parser.tab.cc:517
YYSTYPE
#define YYSTYPE
Definition: parser.tab.cc:80
YY_IGNORE_USELESS_CAST_END
#define YY_IGNORE_USELESS_CAST_END
Definition: parser.tab.cc:377
yytype_int16
short yytype_int16
Definition: parser.tab.cc:237
YYABORT
#define YYABORT
Definition: parser.tab.cc:791
yyrline
static const yytype_int16 yyrline[]
Definition: parser.tab.cc:549
YYSTACK_BYTES
#define YYSTACK_BYTES(N)
Definition: parser.tab.cc:467
yy_state_t
yytype_uint8 yy_state_t
Definition: parser.tab.cc:311
YY_REDUCE_PRINT
#define YY_REDUCE_PRINT(Rule)
Definition: parser.tab.cc:922
YY_CAST
#define YY_CAST(Type, Val)
Definition: parser.tab.cc:93
yypact
static const yytype_int16 yypact[]
Definition: parser.tab.cc:659
yylex
#define yylex
Definition: parser.tab.cc:83
YYCASE_
#define YYCASE_(N, S)
yydefgoto
static const yytype_uint8 yydefgoto[]
Definition: parser.tab.cc:704
YY_NULLPTR
#define YY_NULLPTR
Definition: parser.tab.cc:105
yy_symbol_print
static void yy_symbol_print(FILE *yyo, yysymbol_kind_t yykind, YYSTYPE const *const yyvaluep, operations_research::fz::ParserContext *context, operations_research::fz::Model *model, bool *ok, void *scanner)
Definition: parser.tab.cc:869
YYFINAL
#define YYFINAL
Definition: parser.tab.cc:506
YY_ACCESSING_SYMBOL
#define YY_ACCESSING_SYMBOL(State)
Accessing symbol of state STATE.
Definition: parser.tab.cc:560
YY_SYMBOL_PRINT
#define YY_SYMBOL_PRINT(Title, Kind, Value, Location)
Definition: parser.tab.cc:833
yypgoto
static const yytype_int16 yypgoto[]
Definition: parser.tab.cc:698
YY_INITIAL_VALUE
#define YY_INITIAL_VALUE(Value)
Definition: parser.tab.cc:359
yy_symbol_value_print
static void yy_symbol_value_print(FILE *yyo, yysymbol_kind_t yykind, YYSTYPE const *const yyvaluep, operations_research::fz::ParserContext *context, operations_research::fz::Model *model, bool *ok, void *scanner)
Definition: parser.tab.cc:846
YYENOMEM
@ YYENOMEM
Definition: parser.tab.cc:785
yytnamerr
static YYPTRDIFF_T yytnamerr(char *yyres, const char *yystr)
Definition: parser.tab.cc:1033
yyparse
#define yyparse
Definition: parser.tab.cc:82
YYNTOKENS
#define YYNTOKENS
Definition: parser.tab.cc:511
yytype_uint8
unsigned char yytype_uint8
Definition: parser.tab.cc:258
YY_STACK_PRINT
#define YY_STACK_PRINT(Bottom, Top)
Definition: parser.tab.cc:895
YYSIZE_T
#define YYSIZE_T
Definition: parser.tab.cc:299
YYSTACK_ALLOC_MAXIMUM
#define YYSTACK_ALLOC_MAXIMUM
Definition: parser.tab.cc:427
yydebug
#define yydebug
Definition: parser.tab.cc:85
YY_IGNORE_USELESS_CAST_BEGIN
#define YY_IGNORE_USELESS_CAST_BEGIN
Definition: parser.tab.cc:376
yyr2
static const yytype_int8 yyr2[]
Definition: parser.tab.cc:778
malloc
void * malloc(YYSIZE_T)
YYPTRDIFF_T
#define YYPTRDIFF_T
Definition: parser.tab.cc:285
yynerrs
#define yynerrs
Definition: parser.tab.cc:86
yytable
static const yytype_int16 yytable[]
Definition: parser.tab.cc:711
YYACCEPT
#define YYACCEPT
Definition: parser.tab.cc:790
yytable_value_is_error
#define yytable_value_is_error(Yyn)
Definition: parser.tab.cc:655
YYTRANSLATE
#define YYTRANSLATE(YYX)
Definition: parser.tab.cc:524
yystos
static const yytype_int8 yystos[]
Definition: parser.tab.cc:754
YY_ATTRIBUTE_UNUSED
#define YY_ATTRIBUTE_UNUSED
Definition: parser.tab.cc:340
yytname
static const char *const yytname[]
Definition: parser.tab.cc:569
yypcontext_expected_tokens
static int yypcontext_expected_tokens(const yypcontext_t *yyctx, yysymbol_kind_t yyarg[], int yyargn)
Definition: parser.tab.cc:966
yyr1
static const yytype_int8 yyr1[]
Definition: parser.tab.cc:769
yystpcpy
static char * yystpcpy(char *yydest, const char *yysrc)
Definition: parser.tab.cc:1014
YYPOPSTACK
#define YYPOPSTACK(N)
yy_state_fast_t
int yy_state_fast_t
Definition: parser.tab.cc:314
yytype_uint16
unsigned short yytype_uint16
Definition: parser.tab.cc:269
YYLAST
#define YYLAST
Definition: parser.tab.cc:508
YYSTACK_RELOCATE
#define YYSTACK_RELOCATE(Stack_alloc, Stack)
Definition: parser.tab.cc:477
yypact_value_is_default
#define yypact_value_is_default(Yyn)
Definition: parser.tab.cc:651
YYINITDEPTH
#define YYINITDEPTH
Definition: parser.tab.cc:940
yy_syntax_error_arguments
static int yy_syntax_error_arguments(const yypcontext_t *yyctx, yysymbol_kind_t yyarg[], int yyargn)
Definition: parser.tab.cc:1068
yy_reduce_print
static void yy_reduce_print(yy_state_t *yyssp, YYSTYPE *yyvsp, int yyrule, operations_research::fz::ParserContext *context, operations_research::fz::Model *model, bool *ok, void *scanner)
Definition: parser.tab.cc:904
yytype_int8
signed char yytype_int8
Definition: parser.tab.cc:229
free
void free(void *)
YYERROR
#define YYERROR
Definition: parser.tab.cc:792
yy_stack_print
static void yy_stack_print(yy_state_t *yybottom, yy_state_t *yytop)
Definition: parser.tab.cc:886
YYSIZEOF
#define YYSIZEOF(X)
Definition: parser.tab.cc:308
YYFPRINTF
#define YYFPRINTF
Definition: parser.tab.cc:820
yycheck
static const yytype_int16 yycheck[]
Definition: parser.tab.cc:732
YYSTACK_ALLOC
#define YYSTACK_ALLOC
Definition: parser.tab.cc:424
YYDPRINTF
#define YYDPRINTF(Args)
Definition: parser.tab.cc:823
YY_USE
#define YY_USE(E)
Definition: parser.tab.cc:346
yyerror
#define yyerror
Definition: parser.tab.cc:84
yysyntax_error
static int yysyntax_error(YYPTRDIFF_T *yymsg_alloc, char **yymsg, const yypcontext_t *yyctx)
Definition: parser.tab.cc:1117
yylval
yylval
Definition: parser.yy.cc:963
parser_util.cc
bound
int64_t bound
Definition: routing_filters.cc:984
operations_research::fz::Annotation
Definition: flatzinc/model.h:256
operations_research::fz::Annotation::IsFunctionCallWithIdentifier
bool IsFunctionCallWithIdentifier(const std::string &identifier) const
Definition: flatzinc/model.h:281
operations_research::fz::Annotation::annotations
std::vector< Annotation > annotations
Definition: flatzinc/model.h:293
operations_research::fz::Argument
Definition: flatzinc/model.h:154
operations_research::fz::Constraint
Definition: flatzinc/model.h:214
operations_research::fz::Domain
Definition: flatzinc/model.h:50
operations_research::fz::Domain::Contains
bool Contains(int64_t value) const
Definition: model.cc:356
operations_research::fz::Domain::display_as_boolean
bool display_as_boolean
Definition: flatzinc/model.h:108
operations_research::fz::Domain::HasOneValue
bool HasOneValue() const
Definition: model.cc:324
operations_research::fz::Domain::values
std::vector< int64_t > values
Definition: flatzinc/model.h:106
operations_research::fz::ParserContext
Definition: parser_util.h:30
operations_research::fz::SolutionOutputSpecs
Definition: flatzinc/model.h:300
operations_research::fz::VarRefOrValue
Definition: parser_util.h:44
operations_research::fz::VarRefOrValue::defined
bool defined
Definition: parser_util.h:69
operations_research::fz::VarRefOrValue::float_value
double float_value
Definition: parser_util.h:68
operations_research::fz::VarRefOrValue::is_float
bool is_float
Definition: parser_util.h:70
operations_research::fz::VarRefOrValue::value
int64_t value
Definition: parser_util.h:67
operations_research::fz::VarRefOrValue::variable
Variable * variable
Definition: parser_util.h:66
operations_research::fz::Variable
Definition: flatzinc/model.h:119
yypcontext_t
Definition: parser.tab.cc:955
yypcontext_t::yytoken
yysymbol_kind_t yytoken
Definition: parser.tab.cc:957
yypcontext_t::yyssp
yy_state_t * yyssp
Definition: parser.tab.cc:956
yyalloc::yyvs_alloc
YYSTYPE yyvs_alloc
Definition: parser.tab.cc:459
yyalloc::yyss_alloc
yy_state_t yyss_alloc
Definition: parser.tab.cc:458