Line data Source code
1 :
2 : /* A Bison parser, made by GNU Bison 2.4.1. */
3 :
4 : /* Skeleton implementation for Bison's Yacc-like parsers in C
5 :
6 : Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
7 : Free Software Foundation, Inc.
8 :
9 : This program is free software: you can redistribute it and/or modify
10 : it under the terms of the GNU General Public License as published by
11 : the Free Software Foundation, either version 3 of the License, or
12 : (at your option) any later version.
13 :
14 : This program is distributed in the hope that it will be useful,
15 : but WITHOUT ANY WARRANTY; without even the implied warranty of
16 : MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 : GNU General Public License for more details.
18 :
19 : You should have received a copy of the GNU General Public License
20 : along with this program. If not, see <http://www.gnu.org/licenses/>. */
21 :
22 : /* As a special exception, you may create a larger work that contains
23 : part or all of the Bison parser skeleton and distribute that work
24 : under terms of your choice, so long as that work isn't itself a
25 : parser generator using the skeleton or a modified version thereof
26 : as a parser skeleton. Alternatively, if you modify or redistribute
27 : the parser skeleton itself, you may (at your option) remove this
28 : special exception, which will cause the skeleton and the resulting
29 : Bison output files to be licensed under the GNU General Public
30 : License without this special exception.
31 :
32 : This special exception was added by the Free Software Foundation in
33 : version 2.2 of Bison. */
34 :
35 : /* C LALR(1) parser skeleton written by Richard Stallman, by
36 : simplifying the original so-called "semantic" parser. */
37 :
38 : /* All symbols defined below should begin with yy or YY, to avoid
39 : infringing on user name space. This should be done even for local
40 : variables, as they might otherwise be expanded by user macros.
41 : There are some unavoidable exceptions within include files to
42 : define necessary library symbols; they are noted "INFRINGES ON
43 : USER NAME SPACE" below. */
44 :
45 : /* Identify Bison output. */
46 : #define YYBISON 1
47 :
48 : /* Bison version. */
49 : #define YYBISON_VERSION "2.4.1"
50 :
51 : /* Skeleton name. */
52 : #define YYSKELETON_NAME "yacc.c"
53 :
54 : /* Pure parsers. */
55 : #define YYPURE 0
56 :
57 : /* Push parsers. */
58 : #define YYPUSH 0
59 :
60 : /* Pull parsers. */
61 : #define YYPULL 1
62 :
63 : /* Using locations. */
64 : #define YYLSP_NEEDED 0
65 :
66 : /* Substitute the variable and function names. */
67 : #define yyparse eqLoader_parse
68 : #define yylex eqLoader_lex
69 : #define yyerror eqLoader_error
70 : #define yylval eqLoader_lval
71 : #define yychar eqLoader_char
72 : #define yydebug eqLoader_debug
73 : #define yynerrs eqLoader_nerrs
74 :
75 :
76 : /* Copy the first part of user declarations. */
77 :
78 :
79 : #include "loader.h"
80 :
81 : #include "canvas.h"
82 : #include "channel.h"
83 : #include "compound.h"
84 : #include "equalizers/dfrEqualizer.h"
85 : #include "equalizers/framerateEqualizer.h"
86 : #include "equalizers/loadEqualizer.h"
87 : #include "equalizers/treeEqualizer.h"
88 : #include "equalizers/monitorEqualizer.h"
89 : #include "equalizers/viewEqualizer.h"
90 : #include "equalizers/tileEqualizer.h"
91 : #include "frame.h"
92 : #include "tileQueue.h"
93 : #include "global.h"
94 : #include "layout.h"
95 : #include "node.h"
96 : #include "observer.h"
97 : #include "pipe.h"
98 : #include "segment.h"
99 : #include "server.h"
100 : #include "view.h"
101 : #include "window.h"
102 :
103 : #include <eq/fabric/paths.h>
104 : #include <lunchbox/os.h>
105 : #include <lunchbox/file.h>
106 :
107 : #include <locale.h>
108 : #include <string>
109 :
110 : #pragma warning(disable: 4065)
111 :
112 : namespace eq
113 : {
114 : namespace loader
115 : {
116 : static eq::server::Loader* loader = 0;
117 20 : std::string filename;
118 :
119 20 : static eq::server::ServerPtr server;
120 : static eq::server::Config* config = 0;
121 : static eq::server::Node* node = 0;
122 : static eq::server::Pipe* eqPipe = 0; // avoid name clash
123 : static eq::server::Window* window = 0;
124 : static eq::server::Channel* channel = 0;
125 : static eq::server::Layout* layout = 0;
126 : static eq::server::View* view = 0;
127 : static eq::server::Canvas* canvas = 0;
128 : static eq::server::Segment* segment = 0;
129 : static eq::server::Observer* observer = 0;
130 : static eq::server::Compound* eqCompound = 0; // avoid name clash
131 : static eq::server::DFREqualizer* dfrEqualizer = 0;
132 : static eq::server::LoadEqualizer* loadEqualizer = 0;
133 : static eq::server::TreeEqualizer* treeEqualizer = 0;
134 : static eq::server::TileEqualizer* tileEqualizer = 0;
135 20 : static eq::server::SwapBarrierPtr swapBarrier;
136 : static eq::server::Frame* frame = 0;
137 : static eq::server::TileQueue* tileQueue = 0;
138 20 : static co::ConnectionDescriptionPtr connectionDescription;
139 20 : static eq::fabric::Wall wall;
140 20 : static eq::fabric::Projection projection;
141 : static fabric::Frame::Buffer buffers = fabric::Frame::Buffer::none;
142 : }
143 : }
144 :
145 : using namespace lunchbox;
146 : using namespace eq::loader;
147 :
148 : int eqLoader_lex();
149 :
150 : #define yylineno eqLoader_lineno
151 : void yyerror( const char *errmsg );
152 : extern char* yytext;
153 : extern FILE* yyin;
154 : extern const char* yyinString;
155 : extern int yylineno;
156 :
157 :
158 :
159 : /* Enabling traces. */
160 : #ifndef YYDEBUG
161 : # define YYDEBUG 0
162 : #endif
163 :
164 : /* Enabling verbose error messages. */
165 : #ifdef YYERROR_VERBOSE
166 : # undef YYERROR_VERBOSE
167 : # define YYERROR_VERBOSE 1
168 : #else
169 : # define YYERROR_VERBOSE 0
170 : #endif
171 :
172 : /* Enabling the token table. */
173 : #ifndef YYTOKEN_TABLE
174 : # define YYTOKEN_TABLE 0
175 : #endif
176 :
177 :
178 : /* Tokens. */
179 : #ifndef YYTOKENTYPE
180 : # define YYTOKENTYPE
181 : /* Put the tokens into the symbol table, so that GDB and other debuggers
182 : know about them. */
183 : enum yytokentype {
184 : EQTOKEN_HEADER = 258,
185 : EQTOKEN_ASCII = 259,
186 : EQTOKEN_GLOBAL = 260,
187 : EQTOKEN_CHANNEL_IATTR_HINT_STATISTICS = 261,
188 : EQTOKEN_CHANNEL_IATTR_HINT_SENDTOKEN = 262,
189 : EQTOKEN_CHANNEL_SATTR_DUMP_IMAGE = 263,
190 : EQTOKEN_COMPOUND_IATTR_STEREO_MODE = 264,
191 : EQTOKEN_COMPOUND_IATTR_STEREO_ANAGLYPH_LEFT_MASK = 265,
192 : EQTOKEN_COMPOUND_IATTR_STEREO_ANAGLYPH_RIGHT_MASK = 266,
193 : EQTOKEN_COMPOUND_IATTR_UPDATE_FOV = 267,
194 : EQTOKEN_CONNECTION_SATTR_FILENAME = 268,
195 : EQTOKEN_CONNECTION_SATTR_HOSTNAME = 269,
196 : EQTOKEN_CONNECTION_IATTR_BANDWIDTH = 270,
197 : EQTOKEN_CONNECTION_IATTR_TYPE = 271,
198 : EQTOKEN_CONNECTION_IATTR_PORT = 272,
199 : EQTOKEN_CONFIG_FATTR_EYE_BASE = 273,
200 : EQTOKEN_CONFIG_IATTR_ROBUSTNESS = 274,
201 : EQTOKEN_NODE_SATTR_LAUNCH_COMMAND = 275,
202 : EQTOKEN_NODE_CATTR_LAUNCH_COMMAND_QUOTE = 276,
203 : EQTOKEN_NODE_IATTR_THREAD_MODEL = 277,
204 : EQTOKEN_NODE_IATTR_HINT_AFFINITY = 278,
205 : EQTOKEN_NODE_IATTR_HINT_STATISTICS = 279,
206 : EQTOKEN_NODE_IATTR_LAUNCH_TIMEOUT = 280,
207 : EQTOKEN_PIPE_IATTR_HINT_THREAD = 281,
208 : EQTOKEN_PIPE_IATTR_HINT_AFFINITY = 282,
209 : EQTOKEN_VIEW_SATTR_DEFLECT_HOST = 283,
210 : EQTOKEN_WINDOW_IATTR_HINT_CORE_PROFILE = 284,
211 : EQTOKEN_WINDOW_IATTR_HINT_OPENGL_MAJOR = 285,
212 : EQTOKEN_WINDOW_IATTR_HINT_OPENGL_MINOR = 286,
213 : EQTOKEN_WINDOW_IATTR_HINT_STEREO = 287,
214 : EQTOKEN_WINDOW_IATTR_HINT_DOUBLEBUFFER = 288,
215 : EQTOKEN_WINDOW_IATTR_HINT_FULLSCREEN = 289,
216 : EQTOKEN_WINDOW_IATTR_HINT_DECORATION = 290,
217 : EQTOKEN_WINDOW_IATTR_HINT_SWAPSYNC = 291,
218 : EQTOKEN_WINDOW_IATTR_HINT_DRAWABLE = 292,
219 : EQTOKEN_WINDOW_IATTR_HINT_STATISTICS = 293,
220 : EQTOKEN_WINDOW_IATTR_HINT_SCREENSAVER = 294,
221 : EQTOKEN_WINDOW_IATTR_HINT_GRAB_POINTER = 295,
222 : EQTOKEN_WINDOW_IATTR_HINT_HEIGHT = 296,
223 : EQTOKEN_WINDOW_IATTR_HINT_WIDTH = 297,
224 : EQTOKEN_WINDOW_IATTR_PLANES_ACCUM = 298,
225 : EQTOKEN_WINDOW_IATTR_PLANES_ACCUM_ALPHA = 299,
226 : EQTOKEN_WINDOW_IATTR_PLANES_ALPHA = 300,
227 : EQTOKEN_WINDOW_IATTR_PLANES_COLOR = 301,
228 : EQTOKEN_WINDOW_IATTR_PLANES_DEPTH = 302,
229 : EQTOKEN_WINDOW_IATTR_PLANES_SAMPLES = 303,
230 : EQTOKEN_WINDOW_IATTR_PLANES_STENCIL = 304,
231 : EQTOKEN_SERVER = 305,
232 : EQTOKEN_CONFIG = 306,
233 : EQTOKEN_APPNODE = 307,
234 : EQTOKEN_NODE = 308,
235 : EQTOKEN_PIPE = 309,
236 : EQTOKEN_WINDOW = 310,
237 : EQTOKEN_ATTRIBUTES = 311,
238 : EQTOKEN_HINT_CORE_PROFILE = 312,
239 : EQTOKEN_HINT_OPENGL_MAJOR = 313,
240 : EQTOKEN_HINT_OPENGL_MINOR = 314,
241 : EQTOKEN_HINT_STEREO = 315,
242 : EQTOKEN_HINT_DOUBLEBUFFER = 316,
243 : EQTOKEN_HINT_FULLSCREEN = 317,
244 : EQTOKEN_HINT_DECORATION = 318,
245 : EQTOKEN_HINT_STATISTICS = 319,
246 : EQTOKEN_HINT_SENDTOKEN = 320,
247 : EQTOKEN_HINT_SWAPSYNC = 321,
248 : EQTOKEN_HINT_DRAWABLE = 322,
249 : EQTOKEN_HINT_THREAD = 323,
250 : EQTOKEN_HINT_AFFINITY = 324,
251 : EQTOKEN_HINT_SCREENSAVER = 325,
252 : EQTOKEN_HINT_GRAB_POINTER = 326,
253 : EQTOKEN_PLANES_COLOR = 327,
254 : EQTOKEN_PLANES_ALPHA = 328,
255 : EQTOKEN_PLANES_DEPTH = 329,
256 : EQTOKEN_PLANES_STENCIL = 330,
257 : EQTOKEN_PLANES_ACCUM = 331,
258 : EQTOKEN_PLANES_ACCUM_ALPHA = 332,
259 : EQTOKEN_PLANES_SAMPLES = 333,
260 : EQTOKEN_ON = 334,
261 : EQTOKEN_OFF = 335,
262 : EQTOKEN_AUTO = 336,
263 : EQTOKEN_FASTEST = 337,
264 : EQTOKEN_NICEST = 338,
265 : EQTOKEN_QUAD = 339,
266 : EQTOKEN_ANAGLYPH = 340,
267 : EQTOKEN_PASSIVE = 341,
268 : EQTOKEN_RED = 342,
269 : EQTOKEN_GREEN = 343,
270 : EQTOKEN_BLUE = 344,
271 : EQTOKEN_HORIZONTAL = 345,
272 : EQTOKEN_VERTICAL = 346,
273 : EQTOKEN_FRAMERATE = 347,
274 : EQTOKEN_CHANNEL = 348,
275 : EQTOKEN_OBSERVER = 349,
276 : EQTOKEN_LAYOUT = 350,
277 : EQTOKEN_VIEW = 351,
278 : EQTOKEN_CANVAS = 352,
279 : EQTOKEN_SEGMENT = 353,
280 : EQTOKEN_COMPOUND = 354,
281 : EQTOKEN_DFREQUALIZER = 355,
282 : EQTOKEN_FRAMERATEEQUALIZER = 356,
283 : EQTOKEN_LOADEQUALIZER = 357,
284 : EQTOKEN_TREEEQUALIZER = 358,
285 : EQTOKEN_MONITOREQUALIZER = 359,
286 : EQTOKEN_VIEWEQUALIZER = 360,
287 : EQTOKEN_TILEEQUALIZER = 361,
288 : EQTOKEN_DAMPING = 362,
289 : EQTOKEN_CONNECTION = 363,
290 : EQTOKEN_NAME = 364,
291 : EQTOKEN_TYPE = 365,
292 : EQTOKEN_TCPIP = 366,
293 : EQTOKEN_RSP = 367,
294 : EQTOKEN_RDMA = 368,
295 : EQTOKEN_UDT = 369,
296 : EQTOKEN_TEXTURE = 370,
297 : EQTOKEN_MEMORY = 371,
298 : EQTOKEN_FIXED = 372,
299 : EQTOKEN_RELATIVE_TO_ORIGIN = 373,
300 : EQTOKEN_RELATIVE_TO_OBSERVER = 374,
301 : EQTOKEN_HMD = 375,
302 : EQTOKEN_HOST = 376,
303 : EQTOKEN_HOSTNAME = 377,
304 : EQTOKEN_INTERFACE = 378,
305 : EQTOKEN_LAUNCH_COMMAND = 379,
306 : EQTOKEN_LAUNCH_COMMAND_QUOTE = 380,
307 : EQTOKEN_LAUNCH_TIMEOUT = 381,
308 : EQTOKEN_PORT = 382,
309 : EQTOKEN_FILENAME = 383,
310 : EQTOKEN_TASK = 384,
311 : EQTOKEN_EYE = 385,
312 : EQTOKEN_EYE_BASE = 386,
313 : EQTOKEN_EYE_LEFT = 387,
314 : EQTOKEN_EYE_CYCLOP = 388,
315 : EQTOKEN_EYE_RIGHT = 389,
316 : EQTOKEN_FOCUS_DISTANCE = 390,
317 : EQTOKEN_FOCUS_MODE = 391,
318 : EQTOKEN_OPENCV_CAMERA = 392,
319 : EQTOKEN_VRPN_TRACKER = 393,
320 : EQTOKEN_ROBUSTNESS = 394,
321 : EQTOKEN_THREAD_MODEL = 395,
322 : EQTOKEN_ASYNC = 396,
323 : EQTOKEN_DRAW_SYNC = 397,
324 : EQTOKEN_LOCAL_SYNC = 398,
325 : EQTOKEN_BUFFER = 399,
326 : EQTOKEN_CLEAR = 400,
327 : EQTOKEN_DRAW = 401,
328 : EQTOKEN_ASSEMBLE = 402,
329 : EQTOKEN_READBACK = 403,
330 : EQTOKEN_COLOR = 404,
331 : EQTOKEN_DEPTH = 405,
332 : EQTOKEN_CYCLOP = 406,
333 : EQTOKEN_LEFT = 407,
334 : EQTOKEN_RIGHT = 408,
335 : EQTOKEN_VIEWPORT = 409,
336 : EQTOKEN_RANGE = 410,
337 : EQTOKEN_PERIOD = 411,
338 : EQTOKEN_PHASE = 412,
339 : EQTOKEN_PIXEL = 413,
340 : EQTOKEN_SUBPIXEL = 414,
341 : EQTOKEN_BANDWIDTH = 415,
342 : EQTOKEN_DEVICE = 416,
343 : EQTOKEN_WALL = 417,
344 : EQTOKEN_BOTTOM_LEFT = 418,
345 : EQTOKEN_BOTTOM_RIGHT = 419,
346 : EQTOKEN_TOP_LEFT = 420,
347 : EQTOKEN_PROJECTION = 421,
348 : EQTOKEN_ORIGIN = 422,
349 : EQTOKEN_DISTANCE = 423,
350 : EQTOKEN_FOV = 424,
351 : EQTOKEN_HPR = 425,
352 : EQTOKEN_LATENCY = 426,
353 : EQTOKEN_SWAPBARRIER = 427,
354 : EQTOKEN_NVGROUP = 428,
355 : EQTOKEN_NVBARRIER = 429,
356 : EQTOKEN_OUTPUTFRAME = 430,
357 : EQTOKEN_INPUTFRAME = 431,
358 : EQTOKEN_OUTPUTTILES = 432,
359 : EQTOKEN_INPUTTILES = 433,
360 : EQTOKEN_STEREO_MODE = 434,
361 : EQTOKEN_STEREO_ANAGLYPH_LEFT_MASK = 435,
362 : EQTOKEN_STEREO_ANAGLYPH_RIGHT_MASK = 436,
363 : EQTOKEN_UPDATE_FOV = 437,
364 : EQTOKEN_PBUFFER = 438,
365 : EQTOKEN_FBO = 439,
366 : EQTOKEN_RGBA16F = 440,
367 : EQTOKEN_RGBA32F = 441,
368 : EQTOKEN_MODE = 442,
369 : EQTOKEN_2D = 443,
370 : EQTOKEN_ASSEMBLE_ONLY_LIMIT = 444,
371 : EQTOKEN_DB = 445,
372 : EQTOKEN_BOUNDARY = 446,
373 : EQTOKEN_RESISTANCE = 447,
374 : EQTOKEN_ZOOM = 448,
375 : EQTOKEN_MONO = 449,
376 : EQTOKEN_STEREO = 450,
377 : EQTOKEN_STRING = 451,
378 : EQTOKEN_CHARACTER = 452,
379 : EQTOKEN_FLOAT = 453,
380 : EQTOKEN_INTEGER = 454,
381 : EQTOKEN_UNSIGNED = 455,
382 : EQTOKEN_SIZE = 456,
383 : EQTOKEN_CORE = 457,
384 : EQTOKEN_SOCKET = 458,
385 : EQTOKEN_DEFLECT_HOST = 459,
386 : EQTOKEN_DUMP_IMAGE = 460
387 : };
388 : #endif
389 :
390 :
391 :
392 : #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
393 : typedef union YYSTYPE
394 : {
395 :
396 :
397 : const char* _string;
398 : char _character;
399 : int _int;
400 : unsigned _unsigned;
401 : float _float;
402 : co::ConnectionType _connectionType;
403 : eq::server::LoadEqualizer::Mode _loadEqualizerMode;
404 : eq::server::TreeEqualizer::Mode _treeEqualizerMode;
405 : float _viewport[4];
406 :
407 :
408 :
409 : } YYSTYPE;
410 : # define YYSTYPE_IS_TRIVIAL 1
411 : # define yystype YYSTYPE /* obsolescent; will be withdrawn */
412 : # define YYSTYPE_IS_DECLARED 1
413 : #endif
414 :
415 :
416 : /* Copy the second part of user declarations. */
417 :
418 :
419 :
420 : #ifdef short
421 : # undef short
422 : #endif
423 :
424 : #ifdef YYTYPE_UINT8
425 : typedef YYTYPE_UINT8 yytype_uint8;
426 : #else
427 : typedef unsigned char yytype_uint8;
428 : #endif
429 :
430 : #ifdef YYTYPE_INT8
431 : typedef YYTYPE_INT8 yytype_int8;
432 : #elif (defined __STDC__ || defined __C99__FUNC__ \
433 : || defined __cplusplus || defined _MSC_VER)
434 : typedef signed char yytype_int8;
435 : #else
436 : typedef short int yytype_int8;
437 : #endif
438 :
439 : #ifdef YYTYPE_UINT16
440 : typedef YYTYPE_UINT16 yytype_uint16;
441 : #else
442 : typedef unsigned short int yytype_uint16;
443 : #endif
444 :
445 : #ifdef YYTYPE_INT16
446 : typedef YYTYPE_INT16 yytype_int16;
447 : #else
448 : typedef short int yytype_int16;
449 : #endif
450 :
451 : #ifndef YYSIZE_T
452 : # ifdef __SIZE_TYPE__
453 : # define YYSIZE_T __SIZE_TYPE__
454 : # elif defined size_t
455 : # define YYSIZE_T size_t
456 : # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
457 : || defined __cplusplus || defined _MSC_VER)
458 : # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
459 : # define YYSIZE_T size_t
460 : # else
461 : # define YYSIZE_T unsigned int
462 : # endif
463 : #endif
464 :
465 : #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
466 :
467 : #ifndef YY_
468 : # if YYENABLE_NLS
469 : # if ENABLE_NLS
470 : # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
471 : # define YY_(msgid) dgettext ("bison-runtime", msgid)
472 : # endif
473 : # endif
474 : # ifndef YY_
475 : # define YY_(msgid) msgid
476 : # endif
477 : #endif
478 :
479 : /* Suppress unused-variable warnings by "using" E. */
480 : #if ! defined lint || defined __GNUC__
481 : # define YYUSE(e) ((void) (e))
482 : #else
483 : # define YYUSE(e) /* empty */
484 : #endif
485 :
486 : /* Identity function, used to suppress warnings about constant conditions. */
487 : #ifndef lint
488 : # define YYID(n) (n)
489 : #else
490 : #if (defined __STDC__ || defined __C99__FUNC__ \
491 : || defined __cplusplus || defined _MSC_VER)
492 : static int
493 : YYID (int yyi)
494 : #else
495 : static int
496 : YYID (yyi)
497 : int yyi;
498 : #endif
499 : {
500 : return yyi;
501 : }
502 : #endif
503 :
504 : #if ! defined yyoverflow || YYERROR_VERBOSE
505 :
506 : /* The parser invokes alloca or malloc; define the necessary symbols. */
507 :
508 : # ifdef YYSTACK_USE_ALLOCA
509 : # if YYSTACK_USE_ALLOCA
510 : # ifdef __GNUC__
511 : # define YYSTACK_ALLOC __builtin_alloca
512 : # elif defined __BUILTIN_VA_ARG_INCR
513 : # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
514 : # elif defined _AIX
515 : # define YYSTACK_ALLOC __alloca
516 : # elif defined _MSC_VER
517 : # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
518 : # define alloca _alloca
519 : # else
520 : # define YYSTACK_ALLOC alloca
521 : # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
522 : || defined __cplusplus || defined _MSC_VER)
523 : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
524 : # ifndef _STDLIB_H
525 : # define _STDLIB_H 1
526 : # endif
527 : # endif
528 : # endif
529 : # endif
530 : # endif
531 :
532 : # ifdef YYSTACK_ALLOC
533 : /* Pacify GCC's `empty if-body' warning. */
534 : # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
535 : # ifndef YYSTACK_ALLOC_MAXIMUM
536 : /* The OS might guarantee only one guard page at the bottom of the stack,
537 : and a page size can be as small as 4096 bytes. So we cannot safely
538 : invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
539 : to allow for a few compiler-allocated temporary stack slots. */
540 : # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
541 : # endif
542 : # else
543 : # define YYSTACK_ALLOC YYMALLOC
544 : # define YYSTACK_FREE YYFREE
545 : # ifndef YYSTACK_ALLOC_MAXIMUM
546 : # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
547 : # endif
548 : # if (defined __cplusplus && ! defined _STDLIB_H \
549 : && ! ((defined YYMALLOC || defined malloc) \
550 : && (defined YYFREE || defined free)))
551 : # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
552 : # ifndef _STDLIB_H
553 : # define _STDLIB_H 1
554 : # endif
555 : # endif
556 : # ifndef YYMALLOC
557 : # define YYMALLOC malloc
558 : # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
559 : || defined __cplusplus || defined _MSC_VER)
560 : void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
561 : # endif
562 : # endif
563 : # ifndef YYFREE
564 : # define YYFREE free
565 : # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
566 : || defined __cplusplus || defined _MSC_VER)
567 : void free (void *); /* INFRINGES ON USER NAME SPACE */
568 : # endif
569 : # endif
570 : # endif
571 : #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
572 :
573 :
574 : #if (! defined yyoverflow \
575 : && (! defined __cplusplus \
576 : || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
577 :
578 : /* A type that is properly aligned for any stack member. */
579 : union yyalloc
580 : {
581 : yytype_int16 yyss_alloc;
582 : YYSTYPE yyvs_alloc;
583 : };
584 :
585 : /* The size of the maximum gap between one aligned stack and the next. */
586 : # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
587 :
588 : /* The size of an array large to enough to hold all stacks, each with
589 : N elements. */
590 : # define YYSTACK_BYTES(N) \
591 : ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
592 : + YYSTACK_GAP_MAXIMUM)
593 :
594 : /* Copy COUNT objects from FROM to TO. The source and destination do
595 : not overlap. */
596 : # ifndef YYCOPY
597 : # if defined __GNUC__ && 1 < __GNUC__
598 : # define YYCOPY(To, From, Count) \
599 : __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
600 : # else
601 : # define YYCOPY(To, From, Count) \
602 : do \
603 : { \
604 : YYSIZE_T yyi; \
605 : for (yyi = 0; yyi < (Count); yyi++) \
606 : (To)[yyi] = (From)[yyi]; \
607 : } \
608 : while (YYID (0))
609 : # endif
610 : # endif
611 :
612 : /* Relocate STACK from its old location to the new one. The
613 : local variables YYSIZE and YYSTACKSIZE give the old and new number of
614 : elements in the stack, and YYPTR gives the new location of the
615 : stack. Advance YYPTR to a properly aligned location for the next
616 : stack. */
617 : # define YYSTACK_RELOCATE(Stack_alloc, Stack) \
618 : do \
619 : { \
620 : YYSIZE_T yynewbytes; \
621 : YYCOPY (&yyptr->Stack_alloc, Stack, yysize); \
622 : Stack = &yyptr->Stack_alloc; \
623 : yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
624 : yyptr += yynewbytes / sizeof (*yyptr); \
625 : } \
626 : while (YYID (0))
627 :
628 : #endif
629 :
630 : /* YYFINAL -- State number of the termination state. */
631 : #define YYFINAL 10
632 : /* YYLAST -- Last index in YYTABLE. */
633 : #define YYLAST 1288
634 :
635 : /* YYNTOKENS -- Number of terminals. */
636 : #define YYNTOKENS 212
637 : /* YYNNTS -- Number of nonterminals. */
638 : #define YYNNTS 154
639 : /* YYNRULES -- Number of rules. */
640 : #define YYNRULES 434
641 : /* YYNRULES -- Number of states. */
642 : #define YYNSTATES 768
643 :
644 : /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
645 : #define YYUNDEFTOK 2
646 : #define YYMAXUTOK 460
647 :
648 : #define YYTRANSLATE(YYX) \
649 : ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
650 :
651 : /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
652 : static const yytype_uint8 yytranslate[] =
653 : {
654 : 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
655 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
656 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
657 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
658 : 210, 211, 2, 2, 2, 2, 2, 2, 2, 2,
659 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
660 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
661 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
662 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
663 : 2, 208, 2, 209, 2, 2, 2, 2, 2, 2,
664 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
665 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
666 : 2, 2, 2, 206, 2, 207, 2, 2, 2, 2,
667 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
668 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
669 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
670 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
671 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
672 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
673 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
674 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
675 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
676 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
677 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
678 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
679 : 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
680 : 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
681 : 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
682 : 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
683 : 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
684 : 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
685 : 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
686 : 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
687 : 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
688 : 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
689 : 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
690 : 105, 106, 107, 108, 109, 110, 111, 112, 113, 114,
691 : 115, 116, 117, 118, 119, 120, 121, 122, 123, 124,
692 : 125, 126, 127, 128, 129, 130, 131, 132, 133, 134,
693 : 135, 136, 137, 138, 139, 140, 141, 142, 143, 144,
694 : 145, 146, 147, 148, 149, 150, 151, 152, 153, 154,
695 : 155, 156, 157, 158, 159, 160, 161, 162, 163, 164,
696 : 165, 166, 167, 168, 169, 170, 171, 172, 173, 174,
697 : 175, 176, 177, 178, 179, 180, 181, 182, 183, 184,
698 : 185, 186, 187, 188, 189, 190, 191, 192, 193, 194,
699 : 195, 196, 197, 198, 199, 200, 201, 202, 203, 204,
700 : 205
701 : };
702 :
703 : #if YYDEBUG
704 : /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
705 : YYRHS. */
706 : static const yytype_uint16 yyprhs[] =
707 : {
708 : 0, 0, 3, 7, 11, 12, 16, 21, 22, 23,
709 : 26, 29, 32, 35, 38, 41, 44, 47, 50, 53,
710 : 56, 59, 62, 65, 68, 71, 74, 77, 80, 83,
711 : 86, 89, 92, 95, 98, 101, 104, 107, 110, 113,
712 : 116, 119, 122, 125, 128, 131, 134, 137, 140, 143,
713 : 146, 149, 152, 155, 158, 160, 162, 164, 166, 168,
714 : 169, 176, 177, 180, 181, 187, 189, 192, 193, 199,
715 : 200, 203, 205, 208, 210, 212, 214, 216, 219, 224,
716 : 225, 228, 231, 234, 236, 238, 239, 245, 246, 252,
717 : 253, 256, 259, 262, 264, 266, 271, 272, 278, 279,
718 : 282, 285, 288, 291, 294, 297, 300, 301, 304, 307,
719 : 310, 313, 316, 319, 322, 323, 329, 330, 333, 335,
720 : 340, 343, 346, 349, 352, 353, 356, 359, 362, 363,
721 : 369, 370, 373, 375, 380, 383, 386, 387, 390, 393,
722 : 396, 399, 402, 405, 408, 411, 414, 417, 420, 423,
723 : 426, 429, 432, 435, 438, 441, 444, 447, 448, 454,
724 : 455, 458, 461, 466, 469, 470, 473, 476, 479, 482,
725 : 483, 489, 490, 493, 496, 499, 506, 513, 520, 523,
726 : 526, 529, 532, 533, 539, 540, 543, 546, 548, 549,
727 : 555, 556, 559, 564, 567, 568, 572, 575, 577, 579,
728 : 582, 585, 587, 589, 590, 593, 596, 597, 603, 604,
729 : 607, 610, 613, 615, 618, 621, 623, 625, 627, 628,
730 : 634, 635, 638, 641, 644, 645, 651, 654, 656, 658,
731 : 660, 661, 664, 666, 668, 670, 671, 677, 678, 681,
732 : 683, 686, 689, 692, 693, 699, 700, 706, 707, 713,
733 : 716, 722, 725, 728, 734, 742, 748, 750, 752, 754,
734 : 756, 758, 760, 762, 764, 769, 770, 775, 776, 779,
735 : 782, 785, 788, 791, 794, 797, 800, 803, 804, 807,
736 : 809, 811, 813, 815, 816, 819, 821, 823, 825, 826,
737 : 829, 831, 833, 834, 840, 841, 844, 851, 858, 865,
738 : 868, 870, 872, 873, 879, 880, 883, 890, 893, 899,
739 : 906, 908, 910, 912, 914, 916, 918, 920, 921, 927,
740 : 931, 932, 938, 939, 945, 949, 953, 954, 960, 961,
741 : 964, 967, 970, 971, 974, 977, 983, 986, 989, 992,
742 : 998, 1001, 1003, 1005, 1007, 1009, 1010, 1013, 1016, 1022,
743 : 1025, 1028, 1034, 1037, 1039, 1041, 1043, 1045, 1046, 1049,
744 : 1052, 1058, 1059, 1065, 1066, 1069, 1072, 1075, 1078, 1079,
745 : 1085, 1086, 1092, 1093, 1096, 1099, 1102, 1105, 1106, 1112,
746 : 1118, 1120, 1122, 1123, 1129, 1130, 1136, 1137, 1140, 1143,
747 : 1149, 1150, 1153, 1156, 1159, 1162, 1165, 1172, 1176, 1177,
748 : 1179, 1182, 1184, 1186, 1188, 1190, 1192, 1194, 1196, 1198,
749 : 1200, 1202, 1204, 1206, 1208, 1210, 1212, 1214, 1216, 1218,
750 : 1220, 1222, 1224, 1226, 1228, 1230, 1232, 1235, 1238, 1240,
751 : 1242, 1244, 1246, 1248, 1250
752 : };
753 :
754 : /* YYRHS -- A `-1'-separated list of the rules' RHS. */
755 : static const yytype_int16 yyrhs[] =
756 : {
757 : 213, 0, -1, 214, 215, 218, -1, 214, 215, 224,
758 : -1, -1, 3, 363, 4, -1, 5, 206, 216, 207,
759 : -1, -1, -1, 216, 215, -1, 14, 361, -1, 16,
760 : 217, -1, 17, 365, -1, 13, 361, -1, 15, 365,
761 : -1, 18, 363, -1, 19, 360, -1, 20, 361, -1,
762 : 21, 362, -1, 22, 360, -1, 23, 360, -1, 25,
763 : 365, -1, 24, 360, -1, 26, 360, -1, 27, 360,
764 : -1, 29, 360, -1, 30, 360, -1, 31, 360, -1,
765 : 32, 360, -1, 33, 360, -1, 34, 360, -1, 35,
766 : 360, -1, 36, 360, -1, 37, 360, -1, 38, 360,
767 : -1, 39, 360, -1, 40, 360, -1, 41, 360, -1,
768 : 42, 360, -1, 46, 360, -1, 45, 360, -1, 47,
769 : 360, -1, 49, 360, -1, 43, 360, -1, 44, 360,
770 : -1, 48, 360, -1, 6, 360, -1, 7, 360, -1,
771 : 9, 360, -1, 10, 357, -1, 11, 357, -1, 12,
772 : 360, -1, 8, 361, -1, 28, 361, -1, 111, -1,
773 : 54, -1, 112, -1, 113, -1, 114, -1, -1, 50,
774 : 206, 219, 220, 223, 207, -1, -1, 220, 221, -1,
775 : -1, 108, 206, 222, 239, 207, -1, 224, -1, 223,
776 : 224, -1, -1, 51, 206, 225, 226, 207, -1, -1,
777 : 226, 227, -1, 230, -1, 109, 361, -1, 261, -1,
778 : 265, -1, 277, -1, 288, -1, 171, 365, -1, 56,
779 : 206, 228, 207, -1, -1, 228, 229, -1, 131, 363,
780 : -1, 139, 360, -1, 233, -1, 231, -1, -1, 53,
781 : 206, 232, 235, 207, -1, -1, 52, 206, 234, 235,
782 : 207, -1, -1, 235, 236, -1, 109, 361, -1, 121,
783 : 361, -1, 237, -1, 243, -1, 56, 206, 241, 207,
784 : -1, -1, 108, 206, 238, 239, 207, -1, -1, 239,
785 : 240, -1, 110, 217, -1, 122, 361, -1, 123, 361,
786 : -1, 127, 365, -1, 160, 365, -1, 128, 361, -1,
787 : -1, 241, 242, -1, 124, 361, -1, 125, 362, -1,
788 : 140, 360, -1, 126, 360, -1, 64, 360, -1, 69,
789 : 360, -1, -1, 54, 206, 244, 245, 207, -1, -1,
790 : 245, 246, -1, 249, -1, 56, 206, 247, 207, -1,
791 : 109, 361, -1, 127, 365, -1, 161, 365, -1, 154,
792 : 356, -1, -1, 247, 248, -1, 68, 360, -1, 69,
793 : 360, -1, -1, 55, 206, 250, 251, 207, -1, -1,
794 : 251, 252, -1, 255, -1, 56, 206, 253, 207, -1,
795 : 109, 361, -1, 154, 356, -1, -1, 253, 254, -1,
796 : 57, 360, -1, 58, 360, -1, 59, 360, -1, 60,
797 : 360, -1, 61, 360, -1, 62, 360, -1, 63, 360,
798 : -1, 66, 360, -1, 67, 360, -1, 64, 360, -1,
799 : 70, 360, -1, 71, 360, -1, 72, 360, -1, 73,
800 : 360, -1, 74, 360, -1, 75, 360, -1, 76, 360,
801 : -1, 77, 360, -1, 78, 360, -1, -1, 93, 206,
802 : 256, 257, 207, -1, -1, 257, 258, -1, 109, 361,
803 : -1, 56, 206, 259, 207, -1, 154, 356, -1, -1,
804 : 259, 260, -1, 64, 360, -1, 65, 360, -1, 205,
805 : 361, -1, -1, 94, 206, 262, 263, 207, -1, -1,
806 : 263, 264, -1, 109, 361, -1, 131, 363, -1, 132,
807 : 208, 363, 363, 363, 209, -1, 133, 208, 363, 363,
808 : 363, 209, -1, 134, 208, 363, 363, 363, 209, -1,
809 : 135, 363, -1, 136, 360, -1, 137, 360, -1, 138,
810 : 361, -1, -1, 95, 206, 266, 267, 207, -1, -1,
811 : 267, 268, -1, 109, 361, -1, 269, -1, -1, 96,
812 : 206, 270, 271, 207, -1, -1, 271, 272, -1, 56,
813 : 206, 275, 207, -1, 109, 361, -1, -1, 187, 273,
814 : 274, -1, 154, 356, -1, 305, -1, 310, -1, 94,
815 : 361, -1, 94, 365, -1, 194, -1, 195, -1, -1,
816 : 275, 276, -1, 204, 361, -1, -1, 97, 206, 278,
817 : 279, 207, -1, -1, 279, 280, -1, 109, 361, -1,
818 : 95, 361, -1, 336, -1, 95, 365, -1, 95, 80,
819 : -1, 305, -1, 310, -1, 281, -1, -1, 98, 206,
820 : 282, 283, 207, -1, -1, 283, 284, -1, 109, 361,
821 : -1, 93, 361, -1, -1, 130, 208, 285, 286, 209,
822 : -1, 154, 356, -1, 336, -1, 305, -1, 310, -1,
823 : -1, 286, 287, -1, 151, -1, 152, -1, 153, -1,
824 : -1, 99, 206, 289, 290, 207, -1, -1, 290, 291,
825 : -1, 288, -1, 109, 361, -1, 93, 361, -1, 93,
826 : 295, -1, -1, 129, 208, 292, 299, 209, -1, -1,
827 : 130, 208, 293, 301, 209, -1, -1, 144, 208, 294,
828 : 303, 209, -1, 154, 356, -1, 155, 208, 363, 363,
829 : 209, -1, 156, 365, -1, 157, 365, -1, 193, 208,
830 : 363, 363, 209, -1, 158, 208, 365, 365, 365, 365,
831 : 209, -1, 159, 208, 365, 365, 209, -1, 305, -1,
832 : 310, -1, 314, -1, 336, -1, 340, -1, 342, -1,
833 : 348, -1, 350, -1, 56, 206, 354, 207, -1, -1,
834 : 210, 296, 297, 211, -1, -1, 297, 298, -1, 97,
835 : 361, -1, 97, 365, -1, 98, 361, -1, 98, 365,
836 : -1, 95, 361, -1, 95, 365, -1, 96, 361, -1,
837 : 96, 365, -1, -1, 299, 300, -1, 145, -1, 146,
838 : -1, 147, -1, 148, -1, -1, 301, 302, -1, 151,
839 : -1, 152, -1, 153, -1, -1, 303, 304, -1, 149,
840 : -1, 150, -1, -1, 162, 206, 306, 307, 207, -1,
841 : -1, 307, 308, -1, 163, 208, 363, 363, 363, 209,
842 : -1, 164, 208, 363, 363, 363, 209, -1, 165, 208,
843 : 363, 363, 363, 209, -1, 110, 309, -1, 117, -1,
844 : 120, -1, -1, 166, 206, 311, 312, 207, -1, -1,
845 : 312, 313, -1, 167, 208, 363, 363, 363, 209, -1,
846 : 168, 363, -1, 169, 208, 363, 363, 209, -1, 170,
847 : 208, 363, 363, 363, 209, -1, 315, -1, 317, -1,
848 : 318, -1, 320, -1, 322, -1, 323, -1, 324, -1,
849 : -1, 100, 206, 316, 326, 207, -1, 101, 206, 207,
850 : -1, -1, 102, 206, 319, 328, 207, -1, -1, 103,
851 : 206, 321, 331, 207, -1, 104, 206, 207, -1, 105,
852 : 206, 207, -1, -1, 106, 206, 325, 334, 207, -1,
853 : -1, 326, 327, -1, 107, 363, -1, 92, 363, -1,
854 : -1, 328, 329, -1, 107, 363, -1, 191, 208, 365,
855 : 365, 209, -1, 189, 363, -1, 191, 363, -1, 187,
856 : 330, -1, 192, 208, 365, 365, 209, -1, 192, 363,
857 : -1, 188, -1, 190, -1, 90, -1, 91, -1, -1,
858 : 331, 332, -1, 107, 363, -1, 191, 208, 365, 365,
859 : 209, -1, 191, 363, -1, 187, 333, -1, 192, 208,
860 : 365, 365, 209, -1, 192, 363, -1, 188, -1, 190,
861 : -1, 90, -1, 91, -1, -1, 334, 335, -1, 109,
862 : 361, -1, 201, 208, 365, 365, 209, -1, -1, 172,
863 : 206, 337, 338, 207, -1, -1, 338, 339, -1, 109,
864 : 361, -1, 173, 360, -1, 174, 360, -1, -1, 175,
865 : 206, 341, 344, 207, -1, -1, 176, 206, 343, 344,
866 : 207, -1, -1, 344, 345, -1, 109, 361, -1, 110,
867 : 347, -1, 154, 356, -1, -1, 144, 208, 346, 303,
868 : 209, -1, 193, 208, 363, 363, 209, -1, 115, -1,
869 : 116, -1, -1, 177, 206, 349, 352, 207, -1, -1,
870 : 178, 206, 351, 352, 207, -1, -1, 352, 353, -1,
871 : 109, 361, -1, 201, 208, 365, 365, 209, -1, -1,
872 : 354, 355, -1, 179, 360, -1, 180, 357, -1, 181,
873 : 357, -1, 182, 360, -1, 208, 363, 363, 363, 363,
874 : 209, -1, 208, 358, 209, -1, -1, 359, -1, 358,
875 : 359, -1, 87, -1, 88, -1, 89, -1, 79, -1,
876 : 80, -1, 81, -1, 82, -1, 90, -1, 83, -1,
877 : 84, -1, 85, -1, 86, -1, 91, -1, 55, -1,
878 : 184, -1, 183, -1, 141, -1, 142, -1, 143, -1,
879 : 185, -1, 186, -1, 117, -1, 118, -1, 119, -1,
880 : 364, -1, 202, 364, -1, 203, 364, -1, 196, -1,
881 : 197, -1, 198, -1, 364, -1, 199, -1, 365, -1,
882 : 200, -1
883 : };
884 :
885 : /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
886 : static const yytype_uint16 yyrline[] =
887 : {
888 : 0, 328, 328, 328, 330, 330, 336, 337, 340, 340,
889 : 343, 348, 353, 358, 363, 368, 373, 378, 383, 388,
890 : 393, 398, 403, 408, 413, 418, 423, 428, 433, 438,
891 : 443, 448, 453, 458, 463, 468, 473, 478, 483, 488,
892 : 493, 498, 503, 508, 513, 518, 523, 528, 533, 538,
893 : 543, 548, 553, 558, 565, 566, 567, 568, 569, 571,
894 : 571, 575, 575, 577, 576, 588, 588, 590, 589, 597,
895 : 597, 599, 600, 601, 602, 603, 604, 605, 606, 607,
896 : 607, 609, 611, 614, 614, 615, 615, 621, 620, 627,
897 : 627, 629, 630, 631, 632, 633, 636, 635, 642, 642,
898 : 644, 645, 646, 647, 648, 649, 651, 651, 653, 655,
899 : 658, 660, 662, 668, 673, 672, 678, 678, 680, 681,
900 : 682, 683, 684, 685, 690, 690, 692, 694, 698, 697,
901 : 704, 704, 706, 707, 708, 709, 718, 718, 720, 722,
902 : 724, 726, 728, 730, 732, 734, 736, 738, 740, 742,
903 : 744, 746, 748, 750, 752, 754, 756, 760, 759, 766,
904 : 766, 768, 769, 770, 779, 779, 781, 784, 787, 790,
905 : 790, 792, 792, 794, 795, 805, 810, 815, 820, 821,
906 : 823, 824, 826, 826, 828, 828, 830, 831, 833, 833,
907 : 835, 835, 837, 838, 839, 839, 841, 844, 845, 846,
908 : 857, 871, 872, 874, 874, 876, 881, 881, 883, 883,
909 : 885, 886, 897, 898, 910, 914, 915, 916, 918, 918,
910 : 920, 920, 922, 923, 934, 934, 936, 939, 940, 941,
911 : 943, 943, 945, 946, 947, 950, 949, 959, 959, 961,
912 : 962, 963, 974, 998, 998, 1000, 1000, 1002, 1002, 1005,
913 : 1008, 1010, 1011, 1012, 1014, 1016, 1018, 1019, 1020, 1021,
914 : 1022, 1023, 1024, 1025, 1026, 1029, 1029, 1037, 1037, 1039,
915 : 1049, 1059, 1066, 1073, 1083, 1093, 1100, 1108, 1108, 1110,
916 : 1111, 1112, 1113, 1115, 1115, 1117, 1118, 1119, 1121, 1121,
917 : 1123, 1124, 1126, 1126, 1128, 1128, 1130, 1132, 1134, 1136,
918 : 1139, 1140, 1142, 1142, 1145, 1145, 1147, 1149, 1151, 1153,
919 : 1156, 1156, 1156, 1156, 1157, 1157, 1157, 1160, 1159, 1166,
920 : 1171, 1170, 1178, 1177, 1184, 1188, 1193, 1192, 1200, 1200,
921 : 1202, 1203, 1205, 1205, 1207, 1208, 1210, 1212, 1213, 1214,
922 : 1216, 1219, 1220, 1221, 1222, 1224, 1224, 1226, 1227, 1229,
923 : 1230, 1231, 1233, 1236, 1237, 1238, 1239, 1241, 1241, 1243,
924 : 1244, 1248, 1248, 1251, 1251, 1252, 1253, 1254, 1258, 1258,
925 : 1264, 1264, 1270, 1270, 1272, 1273, 1274, 1277, 1277, 1280,
926 : 1284, 1285, 1287, 1287, 1293, 1293, 1299, 1299, 1301, 1302,
927 : 1305, 1305, 1307, 1309, 1312, 1315, 1318, 1326, 1328, 1329,
928 : 1330, 1332, 1333, 1334, 1337, 1338, 1339, 1340, 1341, 1342,
929 : 1343, 1344, 1345, 1346, 1347, 1348, 1349, 1354, 1355, 1356,
930 : 1357, 1358, 1359, 1360, 1361, 1362, 1363, 1364, 1366, 1375,
931 : 1377, 1378, 1380, 1381, 1382
932 : };
933 : #endif
934 :
935 : #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
936 : /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
937 : First, the terminals, then, starting at YYNTOKENS, nonterminals. */
938 : static const char *const yytname[] =
939 : {
940 : "$end", "error", "$undefined", "EQTOKEN_HEADER", "EQTOKEN_ASCII",
941 : "EQTOKEN_GLOBAL", "EQTOKEN_CHANNEL_IATTR_HINT_STATISTICS",
942 : "EQTOKEN_CHANNEL_IATTR_HINT_SENDTOKEN",
943 : "EQTOKEN_CHANNEL_SATTR_DUMP_IMAGE", "EQTOKEN_COMPOUND_IATTR_STEREO_MODE",
944 : "EQTOKEN_COMPOUND_IATTR_STEREO_ANAGLYPH_LEFT_MASK",
945 : "EQTOKEN_COMPOUND_IATTR_STEREO_ANAGLYPH_RIGHT_MASK",
946 : "EQTOKEN_COMPOUND_IATTR_UPDATE_FOV", "EQTOKEN_CONNECTION_SATTR_FILENAME",
947 : "EQTOKEN_CONNECTION_SATTR_HOSTNAME",
948 : "EQTOKEN_CONNECTION_IATTR_BANDWIDTH", "EQTOKEN_CONNECTION_IATTR_TYPE",
949 : "EQTOKEN_CONNECTION_IATTR_PORT", "EQTOKEN_CONFIG_FATTR_EYE_BASE",
950 : "EQTOKEN_CONFIG_IATTR_ROBUSTNESS", "EQTOKEN_NODE_SATTR_LAUNCH_COMMAND",
951 : "EQTOKEN_NODE_CATTR_LAUNCH_COMMAND_QUOTE",
952 : "EQTOKEN_NODE_IATTR_THREAD_MODEL", "EQTOKEN_NODE_IATTR_HINT_AFFINITY",
953 : "EQTOKEN_NODE_IATTR_HINT_STATISTICS",
954 : "EQTOKEN_NODE_IATTR_LAUNCH_TIMEOUT", "EQTOKEN_PIPE_IATTR_HINT_THREAD",
955 : "EQTOKEN_PIPE_IATTR_HINT_AFFINITY", "EQTOKEN_VIEW_SATTR_DEFLECT_HOST",
956 : "EQTOKEN_WINDOW_IATTR_HINT_CORE_PROFILE",
957 : "EQTOKEN_WINDOW_IATTR_HINT_OPENGL_MAJOR",
958 : "EQTOKEN_WINDOW_IATTR_HINT_OPENGL_MINOR",
959 : "EQTOKEN_WINDOW_IATTR_HINT_STEREO",
960 : "EQTOKEN_WINDOW_IATTR_HINT_DOUBLEBUFFER",
961 : "EQTOKEN_WINDOW_IATTR_HINT_FULLSCREEN",
962 : "EQTOKEN_WINDOW_IATTR_HINT_DECORATION",
963 : "EQTOKEN_WINDOW_IATTR_HINT_SWAPSYNC",
964 : "EQTOKEN_WINDOW_IATTR_HINT_DRAWABLE",
965 : "EQTOKEN_WINDOW_IATTR_HINT_STATISTICS",
966 : "EQTOKEN_WINDOW_IATTR_HINT_SCREENSAVER",
967 : "EQTOKEN_WINDOW_IATTR_HINT_GRAB_POINTER",
968 : "EQTOKEN_WINDOW_IATTR_HINT_HEIGHT", "EQTOKEN_WINDOW_IATTR_HINT_WIDTH",
969 : "EQTOKEN_WINDOW_IATTR_PLANES_ACCUM",
970 : "EQTOKEN_WINDOW_IATTR_PLANES_ACCUM_ALPHA",
971 : "EQTOKEN_WINDOW_IATTR_PLANES_ALPHA", "EQTOKEN_WINDOW_IATTR_PLANES_COLOR",
972 : "EQTOKEN_WINDOW_IATTR_PLANES_DEPTH",
973 : "EQTOKEN_WINDOW_IATTR_PLANES_SAMPLES",
974 : "EQTOKEN_WINDOW_IATTR_PLANES_STENCIL", "EQTOKEN_SERVER",
975 : "EQTOKEN_CONFIG", "EQTOKEN_APPNODE", "EQTOKEN_NODE", "EQTOKEN_PIPE",
976 : "EQTOKEN_WINDOW", "EQTOKEN_ATTRIBUTES", "EQTOKEN_HINT_CORE_PROFILE",
977 : "EQTOKEN_HINT_OPENGL_MAJOR", "EQTOKEN_HINT_OPENGL_MINOR",
978 : "EQTOKEN_HINT_STEREO", "EQTOKEN_HINT_DOUBLEBUFFER",
979 : "EQTOKEN_HINT_FULLSCREEN", "EQTOKEN_HINT_DECORATION",
980 : "EQTOKEN_HINT_STATISTICS", "EQTOKEN_HINT_SENDTOKEN",
981 : "EQTOKEN_HINT_SWAPSYNC", "EQTOKEN_HINT_DRAWABLE", "EQTOKEN_HINT_THREAD",
982 : "EQTOKEN_HINT_AFFINITY", "EQTOKEN_HINT_SCREENSAVER",
983 : "EQTOKEN_HINT_GRAB_POINTER", "EQTOKEN_PLANES_COLOR",
984 : "EQTOKEN_PLANES_ALPHA", "EQTOKEN_PLANES_DEPTH", "EQTOKEN_PLANES_STENCIL",
985 : "EQTOKEN_PLANES_ACCUM", "EQTOKEN_PLANES_ACCUM_ALPHA",
986 : "EQTOKEN_PLANES_SAMPLES", "EQTOKEN_ON", "EQTOKEN_OFF", "EQTOKEN_AUTO",
987 : "EQTOKEN_FASTEST", "EQTOKEN_NICEST", "EQTOKEN_QUAD", "EQTOKEN_ANAGLYPH",
988 : "EQTOKEN_PASSIVE", "EQTOKEN_RED", "EQTOKEN_GREEN", "EQTOKEN_BLUE",
989 : "EQTOKEN_HORIZONTAL", "EQTOKEN_VERTICAL", "EQTOKEN_FRAMERATE",
990 : "EQTOKEN_CHANNEL", "EQTOKEN_OBSERVER", "EQTOKEN_LAYOUT", "EQTOKEN_VIEW",
991 : "EQTOKEN_CANVAS", "EQTOKEN_SEGMENT", "EQTOKEN_COMPOUND",
992 : "EQTOKEN_DFREQUALIZER", "EQTOKEN_FRAMERATEEQUALIZER",
993 : "EQTOKEN_LOADEQUALIZER", "EQTOKEN_TREEEQUALIZER",
994 : "EQTOKEN_MONITOREQUALIZER", "EQTOKEN_VIEWEQUALIZER",
995 : "EQTOKEN_TILEEQUALIZER", "EQTOKEN_DAMPING", "EQTOKEN_CONNECTION",
996 : "EQTOKEN_NAME", "EQTOKEN_TYPE", "EQTOKEN_TCPIP", "EQTOKEN_RSP",
997 : "EQTOKEN_RDMA", "EQTOKEN_UDT", "EQTOKEN_TEXTURE", "EQTOKEN_MEMORY",
998 : "EQTOKEN_FIXED", "EQTOKEN_RELATIVE_TO_ORIGIN",
999 : "EQTOKEN_RELATIVE_TO_OBSERVER", "EQTOKEN_HMD", "EQTOKEN_HOST",
1000 : "EQTOKEN_HOSTNAME", "EQTOKEN_INTERFACE", "EQTOKEN_LAUNCH_COMMAND",
1001 : "EQTOKEN_LAUNCH_COMMAND_QUOTE", "EQTOKEN_LAUNCH_TIMEOUT", "EQTOKEN_PORT",
1002 : "EQTOKEN_FILENAME", "EQTOKEN_TASK", "EQTOKEN_EYE", "EQTOKEN_EYE_BASE",
1003 : "EQTOKEN_EYE_LEFT", "EQTOKEN_EYE_CYCLOP", "EQTOKEN_EYE_RIGHT",
1004 : "EQTOKEN_FOCUS_DISTANCE", "EQTOKEN_FOCUS_MODE", "EQTOKEN_OPENCV_CAMERA",
1005 : "EQTOKEN_VRPN_TRACKER", "EQTOKEN_ROBUSTNESS", "EQTOKEN_THREAD_MODEL",
1006 : "EQTOKEN_ASYNC", "EQTOKEN_DRAW_SYNC", "EQTOKEN_LOCAL_SYNC",
1007 : "EQTOKEN_BUFFER", "EQTOKEN_CLEAR", "EQTOKEN_DRAW", "EQTOKEN_ASSEMBLE",
1008 : "EQTOKEN_READBACK", "EQTOKEN_COLOR", "EQTOKEN_DEPTH", "EQTOKEN_CYCLOP",
1009 : "EQTOKEN_LEFT", "EQTOKEN_RIGHT", "EQTOKEN_VIEWPORT", "EQTOKEN_RANGE",
1010 : "EQTOKEN_PERIOD", "EQTOKEN_PHASE", "EQTOKEN_PIXEL", "EQTOKEN_SUBPIXEL",
1011 : "EQTOKEN_BANDWIDTH", "EQTOKEN_DEVICE", "EQTOKEN_WALL",
1012 : "EQTOKEN_BOTTOM_LEFT", "EQTOKEN_BOTTOM_RIGHT", "EQTOKEN_TOP_LEFT",
1013 : "EQTOKEN_PROJECTION", "EQTOKEN_ORIGIN", "EQTOKEN_DISTANCE",
1014 : "EQTOKEN_FOV", "EQTOKEN_HPR", "EQTOKEN_LATENCY", "EQTOKEN_SWAPBARRIER",
1015 : "EQTOKEN_NVGROUP", "EQTOKEN_NVBARRIER", "EQTOKEN_OUTPUTFRAME",
1016 : "EQTOKEN_INPUTFRAME", "EQTOKEN_OUTPUTTILES", "EQTOKEN_INPUTTILES",
1017 : "EQTOKEN_STEREO_MODE", "EQTOKEN_STEREO_ANAGLYPH_LEFT_MASK",
1018 : "EQTOKEN_STEREO_ANAGLYPH_RIGHT_MASK", "EQTOKEN_UPDATE_FOV",
1019 : "EQTOKEN_PBUFFER", "EQTOKEN_FBO", "EQTOKEN_RGBA16F", "EQTOKEN_RGBA32F",
1020 : "EQTOKEN_MODE", "EQTOKEN_2D", "EQTOKEN_ASSEMBLE_ONLY_LIMIT",
1021 : "EQTOKEN_DB", "EQTOKEN_BOUNDARY", "EQTOKEN_RESISTANCE", "EQTOKEN_ZOOM",
1022 : "EQTOKEN_MONO", "EQTOKEN_STEREO", "EQTOKEN_STRING", "EQTOKEN_CHARACTER",
1023 : "EQTOKEN_FLOAT", "EQTOKEN_INTEGER", "EQTOKEN_UNSIGNED", "EQTOKEN_SIZE",
1024 : "EQTOKEN_CORE", "EQTOKEN_SOCKET", "EQTOKEN_DEFLECT_HOST",
1025 : "EQTOKEN_DUMP_IMAGE", "'{'", "'}'", "'['", "']'", "'('", "')'",
1026 : "$accept", "file", "header", "global", "globals", "connectionType",
1027 : "server", "$@1", "serverConnections", "serverConnection", "$@2",
1028 : "configs", "config", "$@3", "configFields", "configField",
1029 : "configAttributes", "configAttribute", "node", "renderNode", "$@4",
1030 : "appNode", "$@5", "nodeFields", "nodeField", "connection", "$@6",
1031 : "connectionFields", "connectionField", "nodeAttributes", "nodeAttribute",
1032 : "pipe", "$@7", "pipeFields", "pipeField", "pipeAttributes",
1033 : "pipeAttribute", "window", "$@8", "windowFields", "windowField",
1034 : "windowAttributes", "windowAttribute", "channel", "$@9", "channelFields",
1035 : "channelField", "channelAttributes", "channelAttribute", "observer",
1036 : "$@10", "observerFields", "observerField", "layout", "$@11",
1037 : "layoutFields", "layoutField", "view", "$@12", "viewFields", "viewField",
1038 : "$@13", "viewMode", "viewAttributes", "viewAttribute", "canvas", "$@14",
1039 : "canvasFields", "canvasField", "segment", "$@15", "segmentFields",
1040 : "segmentField", "$@16", "segmentEyes", "segumentEye", "compound", "$@17",
1041 : "compoundFields", "compoundField", "$@18", "$@19", "$@20",
1042 : "viewSegmentRef", "$@21", "viewSegmentRefFields", "viewSegmentRefField",
1043 : "compoundTasks", "compoundTask", "compoundEyes", "compoundEye",
1044 : "buffers", "buffer", "wall", "$@22", "wallFields", "wallField",
1045 : "wallType", "projection", "$@23", "projectionFields", "projectionField",
1046 : "equalizer", "dfrEqualizer", "$@24", "framerateEqualizer",
1047 : "loadEqualizer", "$@25", "treeEqualizer", "$@26", "monitorEqualizer",
1048 : "viewEqualizer", "tileEqualizer", "$@27", "dfrEqualizerFields",
1049 : "dfrEqualizerField", "loadEqualizerFields", "loadEqualizerField",
1050 : "loadEqualizerMode", "treeEqualizerFields", "treeEqualizerField",
1051 : "treeEqualizerMode", "tileEqualizerFields", "tileEqualizerField",
1052 : "swapBarrier", "$@28", "swapBarrierFields", "swapBarrierField",
1053 : "outputFrame", "$@29", "inputFrame", "$@30", "frameFields", "frameField",
1054 : "$@31", "frameType", "outputTiles", "$@32", "inputTiles", "$@33",
1055 : "tileQueueFields", "tileQueueField", "compoundAttributes",
1056 : "compoundAttribute", "viewport", "colorMask", "colorMaskBits",
1057 : "colorMaskBit", "IATTR", "STRING", "CHARACTER", "FLOAT", "INTEGER",
1058 : "UNSIGNED", 0
1059 : };
1060 : #endif
1061 :
1062 : # ifdef YYPRINT
1063 : /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1064 : token YYLEX-NUM. */
1065 : static const yytype_uint16 yytoknum[] =
1066 : {
1067 : 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1068 : 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1069 : 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1070 : 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1071 : 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1072 : 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1073 : 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1074 : 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1075 : 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1076 : 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1077 : 355, 356, 357, 358, 359, 360, 361, 362, 363, 364,
1078 : 365, 366, 367, 368, 369, 370, 371, 372, 373, 374,
1079 : 375, 376, 377, 378, 379, 380, 381, 382, 383, 384,
1080 : 385, 386, 387, 388, 389, 390, 391, 392, 393, 394,
1081 : 395, 396, 397, 398, 399, 400, 401, 402, 403, 404,
1082 : 405, 406, 407, 408, 409, 410, 411, 412, 413, 414,
1083 : 415, 416, 417, 418, 419, 420, 421, 422, 423, 424,
1084 : 425, 426, 427, 428, 429, 430, 431, 432, 433, 434,
1085 : 435, 436, 437, 438, 439, 440, 441, 442, 443, 444,
1086 : 445, 446, 447, 448, 449, 450, 451, 452, 453, 454,
1087 : 455, 456, 457, 458, 459, 460, 123, 125, 91, 93,
1088 : 40, 41
1089 : };
1090 : # endif
1091 :
1092 : /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1093 : static const yytype_uint16 yyr1[] =
1094 : {
1095 : 0, 212, 213, 213, 214, 214, 215, 215, 216, 216,
1096 : 215, 215, 215, 215, 215, 215, 215, 215, 215, 215,
1097 : 215, 215, 215, 215, 215, 215, 215, 215, 215, 215,
1098 : 215, 215, 215, 215, 215, 215, 215, 215, 215, 215,
1099 : 215, 215, 215, 215, 215, 215, 215, 215, 215, 215,
1100 : 215, 215, 215, 215, 217, 217, 217, 217, 217, 219,
1101 : 218, 220, 220, 222, 221, 223, 223, 225, 224, 226,
1102 : 226, 227, 227, 227, 227, 227, 227, 227, 227, 228,
1103 : 228, 229, 229, 230, 230, 232, 231, 234, 233, 235,
1104 : 235, 236, 236, 236, 236, 236, 238, 237, 239, 239,
1105 : 240, 240, 240, 240, 240, 240, 241, 241, 242, 242,
1106 : 242, 242, 242, 242, 244, 243, 245, 245, 246, 246,
1107 : 246, 246, 246, 246, 247, 247, 248, 248, 250, 249,
1108 : 251, 251, 252, 252, 252, 252, 253, 253, 254, 254,
1109 : 254, 254, 254, 254, 254, 254, 254, 254, 254, 254,
1110 : 254, 254, 254, 254, 254, 254, 254, 256, 255, 257,
1111 : 257, 258, 258, 258, 259, 259, 260, 260, 260, 262,
1112 : 261, 263, 263, 264, 264, 264, 264, 264, 264, 264,
1113 : 264, 264, 266, 265, 267, 267, 268, 268, 270, 269,
1114 : 271, 271, 272, 272, 273, 272, 272, 272, 272, 272,
1115 : 272, 274, 274, 275, 275, 276, 278, 277, 279, 279,
1116 : 280, 280, 280, 280, 280, 280, 280, 280, 282, 281,
1117 : 283, 283, 284, 284, 285, 284, 284, 284, 284, 284,
1118 : 286, 286, 287, 287, 287, 289, 288, 290, 290, 291,
1119 : 291, 291, 291, 292, 291, 293, 291, 294, 291, 291,
1120 : 291, 291, 291, 291, 291, 291, 291, 291, 291, 291,
1121 : 291, 291, 291, 291, 291, 296, 295, 297, 297, 298,
1122 : 298, 298, 298, 298, 298, 298, 298, 299, 299, 300,
1123 : 300, 300, 300, 301, 301, 302, 302, 302, 303, 303,
1124 : 304, 304, 306, 305, 307, 307, 308, 308, 308, 308,
1125 : 309, 309, 311, 310, 312, 312, 313, 313, 313, 313,
1126 : 314, 314, 314, 314, 314, 314, 314, 316, 315, 317,
1127 : 319, 318, 321, 320, 322, 323, 325, 324, 326, 326,
1128 : 327, 327, 328, 328, 329, 329, 329, 329, 329, 329,
1129 : 329, 330, 330, 330, 330, 331, 331, 332, 332, 332,
1130 : 332, 332, 332, 333, 333, 333, 333, 334, 334, 335,
1131 : 335, 337, 336, 338, 338, 339, 339, 339, 341, 340,
1132 : 343, 342, 344, 344, 345, 345, 345, 346, 345, 345,
1133 : 347, 347, 349, 348, 351, 350, 352, 352, 353, 353,
1134 : 354, 354, 355, 355, 355, 355, 356, 357, 358, 358,
1135 : 358, 359, 359, 359, 360, 360, 360, 360, 360, 360,
1136 : 360, 360, 360, 360, 360, 360, 360, 360, 360, 360,
1137 : 360, 360, 360, 360, 360, 360, 360, 360, 361, 362,
1138 : 363, 363, 364, 364, 365
1139 : };
1140 :
1141 : /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1142 : static const yytype_uint8 yyr2[] =
1143 : {
1144 : 0, 2, 3, 3, 0, 3, 4, 0, 0, 2,
1145 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1146 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1147 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1148 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1149 : 2, 2, 2, 2, 1, 1, 1, 1, 1, 0,
1150 : 6, 0, 2, 0, 5, 1, 2, 0, 5, 0,
1151 : 2, 1, 2, 1, 1, 1, 1, 2, 4, 0,
1152 : 2, 2, 2, 1, 1, 0, 5, 0, 5, 0,
1153 : 2, 2, 2, 1, 1, 4, 0, 5, 0, 2,
1154 : 2, 2, 2, 2, 2, 2, 0, 2, 2, 2,
1155 : 2, 2, 2, 2, 0, 5, 0, 2, 1, 4,
1156 : 2, 2, 2, 2, 0, 2, 2, 2, 0, 5,
1157 : 0, 2, 1, 4, 2, 2, 0, 2, 2, 2,
1158 : 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1159 : 2, 2, 2, 2, 2, 2, 2, 0, 5, 0,
1160 : 2, 2, 4, 2, 0, 2, 2, 2, 2, 0,
1161 : 5, 0, 2, 2, 2, 6, 6, 6, 2, 2,
1162 : 2, 2, 0, 5, 0, 2, 2, 1, 0, 5,
1163 : 0, 2, 4, 2, 0, 3, 2, 1, 1, 2,
1164 : 2, 1, 1, 0, 2, 2, 0, 5, 0, 2,
1165 : 2, 2, 1, 2, 2, 1, 1, 1, 0, 5,
1166 : 0, 2, 2, 2, 0, 5, 2, 1, 1, 1,
1167 : 0, 2, 1, 1, 1, 0, 5, 0, 2, 1,
1168 : 2, 2, 2, 0, 5, 0, 5, 0, 5, 2,
1169 : 5, 2, 2, 5, 7, 5, 1, 1, 1, 1,
1170 : 1, 1, 1, 1, 4, 0, 4, 0, 2, 2,
1171 : 2, 2, 2, 2, 2, 2, 2, 0, 2, 1,
1172 : 1, 1, 1, 0, 2, 1, 1, 1, 0, 2,
1173 : 1, 1, 0, 5, 0, 2, 6, 6, 6, 2,
1174 : 1, 1, 0, 5, 0, 2, 6, 2, 5, 6,
1175 : 1, 1, 1, 1, 1, 1, 1, 0, 5, 3,
1176 : 0, 5, 0, 5, 3, 3, 0, 5, 0, 2,
1177 : 2, 2, 0, 2, 2, 5, 2, 2, 2, 5,
1178 : 2, 1, 1, 1, 1, 0, 2, 2, 5, 2,
1179 : 2, 5, 2, 1, 1, 1, 1, 0, 2, 2,
1180 : 5, 0, 5, 0, 2, 2, 2, 2, 0, 5,
1181 : 0, 5, 0, 2, 2, 2, 2, 0, 5, 5,
1182 : 1, 1, 0, 5, 0, 5, 0, 2, 2, 5,
1183 : 0, 2, 2, 2, 2, 2, 6, 3, 0, 1,
1184 : 2, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1185 : 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1186 : 1, 1, 1, 1, 1, 1, 2, 2, 1, 1,
1187 : 1, 1, 1, 1, 1
1188 : };
1189 :
1190 : /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1191 : STATE-NUM when YYTABLE doesn't specify something else to do. Zero
1192 : means the default is an error. */
1193 : static const yytype_uint16 yydefact[] =
1194 : {
1195 : 4, 0, 0, 7, 430, 432, 434, 0, 431, 433,
1196 : 1, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1197 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1198 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1199 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1200 : 0, 0, 0, 0, 0, 0, 0, 5, 8, 414,
1201 : 404, 405, 406, 407, 409, 410, 411, 412, 408, 413,
1202 : 422, 423, 424, 417, 418, 419, 416, 415, 420, 421,
1203 : 0, 0, 46, 425, 47, 428, 52, 48, 398, 49,
1204 : 50, 51, 13, 10, 14, 55, 54, 56, 57, 58,
1205 : 11, 12, 15, 16, 17, 429, 18, 19, 20, 22,
1206 : 21, 23, 24, 53, 25, 26, 27, 28, 29, 30,
1207 : 31, 32, 33, 34, 35, 36, 37, 38, 43, 44,
1208 : 40, 39, 41, 45, 42, 0, 0, 2, 3, 0,
1209 : 426, 427, 401, 402, 403, 0, 399, 59, 67, 6,
1210 : 9, 397, 400, 61, 69, 0, 0, 0, 62, 0,
1211 : 65, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1212 : 68, 70, 71, 84, 83, 73, 74, 75, 76, 63,
1213 : 60, 66, 87, 85, 79, 169, 182, 206, 235, 72,
1214 : 77, 98, 89, 89, 0, 171, 184, 208, 237, 0,
1215 : 0, 0, 0, 0, 78, 80, 0, 0, 0, 0,
1216 : 0, 0, 0, 0, 0, 0, 64, 99, 0, 0,
1217 : 0, 0, 0, 88, 90, 93, 94, 86, 81, 82,
1218 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 170,
1219 : 172, 0, 0, 183, 185, 187, 0, 0, 0, 0,
1220 : 0, 0, 207, 209, 217, 215, 216, 212, 0, 0,
1221 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1222 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1223 : 0, 0, 236, 239, 238, 256, 257, 258, 310, 311,
1224 : 312, 313, 314, 315, 316, 259, 260, 261, 262, 263,
1225 : 100, 101, 102, 103, 105, 104, 114, 106, 96, 91,
1226 : 92, 173, 174, 0, 0, 0, 178, 179, 180, 181,
1227 : 188, 186, 214, 211, 213, 218, 210, 292, 302, 361,
1228 : 390, 265, 242, 241, 317, 0, 320, 322, 0, 0,
1229 : 326, 240, 243, 245, 247, 0, 249, 0, 251, 252,
1230 : 0, 0, 368, 370, 382, 384, 0, 116, 0, 98,
1231 : 0, 0, 0, 190, 220, 294, 304, 363, 0, 267,
1232 : 328, 319, 332, 345, 324, 325, 357, 277, 283, 288,
1233 : 0, 0, 0, 0, 372, 372, 386, 386, 0, 0,
1234 : 0, 0, 0, 0, 0, 0, 95, 107, 0, 0,
1235 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1236 : 0, 264, 391, 0, 0, 0, 0, 0, 0, 0,
1237 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1238 : 0, 0, 0, 0, 0, 0, 115, 117, 118, 112,
1239 : 113, 108, 109, 111, 110, 97, 0, 0, 0, 0,
1240 : 0, 0, 0, 194, 189, 191, 197, 198, 0, 0,
1241 : 0, 0, 219, 221, 228, 229, 227, 0, 0, 0,
1242 : 0, 293, 295, 0, 0, 0, 0, 303, 305, 0,
1243 : 0, 0, 362, 364, 392, 393, 394, 395, 0, 0,
1244 : 0, 0, 266, 268, 0, 0, 318, 329, 0, 0,
1245 : 0, 0, 0, 321, 333, 0, 0, 0, 0, 323,
1246 : 346, 0, 0, 327, 358, 279, 280, 281, 282, 244,
1247 : 278, 285, 286, 287, 246, 284, 290, 291, 248, 289,
1248 : 0, 250, 0, 255, 0, 0, 0, 0, 0, 369,
1249 : 373, 371, 0, 0, 383, 387, 385, 253, 128, 124,
1250 : 120, 121, 123, 122, 175, 176, 177, 203, 199, 200,
1251 : 193, 196, 0, 223, 222, 224, 226, 300, 301, 299,
1252 : 0, 0, 0, 0, 307, 0, 0, 365, 366, 367,
1253 : 273, 274, 275, 276, 269, 270, 271, 272, 331, 330,
1254 : 334, 343, 344, 341, 342, 338, 336, 0, 337, 0,
1255 : 340, 347, 355, 356, 353, 354, 350, 0, 349, 0,
1256 : 352, 359, 0, 0, 0, 374, 380, 381, 375, 377,
1257 : 376, 0, 388, 0, 130, 0, 0, 201, 202, 195,
1258 : 230, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1259 : 0, 0, 396, 254, 288, 0, 0, 0, 0, 0,
1260 : 119, 125, 0, 192, 204, 0, 0, 0, 0, 0,
1261 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1262 : 0, 0, 0, 0, 129, 131, 132, 126, 127, 205,
1263 : 232, 233, 234, 225, 231, 0, 0, 0, 0, 308,
1264 : 0, 335, 339, 348, 351, 360, 378, 379, 389, 136,
1265 : 157, 134, 135, 296, 297, 298, 306, 309, 0, 159,
1266 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1267 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 133,
1268 : 137, 0, 138, 139, 140, 141, 142, 143, 144, 147,
1269 : 145, 146, 148, 149, 150, 151, 152, 153, 154, 155,
1270 : 156, 0, 0, 0, 158, 160, 164, 161, 163, 0,
1271 : 0, 0, 0, 162, 165, 166, 167, 168
1272 : };
1273 :
1274 : /* YYDEFGOTO[NTERM-NUM]. */
1275 : static const yytype_int16 yydefgoto[] =
1276 : {
1277 : -1, 2, 3, 56, 139, 100, 137, 153, 155, 158,
1278 : 191, 159, 138, 154, 156, 171, 194, 205, 172, 173,
1279 : 193, 174, 192, 200, 224, 225, 359, 199, 217, 358,
1280 : 397, 226, 357, 389, 437, 625, 651, 438, 624, 647,
1281 : 675, 708, 730, 676, 709, 731, 755, 759, 764, 175,
1282 : 195, 206, 240, 176, 196, 207, 244, 245, 363, 402,
1283 : 455, 562, 629, 626, 654, 177, 197, 208, 253, 254,
1284 : 364, 403, 463, 630, 655, 684, 178, 198, 209, 284,
1285 : 377, 378, 379, 332, 369, 413, 493, 418, 520, 419,
1286 : 525, 420, 529, 255, 365, 404, 472, 569, 256, 366,
1287 : 405, 478, 287, 288, 370, 289, 290, 372, 291, 373,
1288 : 292, 293, 294, 376, 414, 497, 415, 504, 595, 416,
1289 : 510, 606, 417, 514, 257, 367, 406, 483, 296, 384,
1290 : 297, 385, 425, 540, 644, 618, 298, 386, 299, 387,
1291 : 427, 545, 368, 412, 346, 89, 145, 146, 82, 86,
1292 : 106, 7, 83, 9
1293 : };
1294 :
1295 : /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1296 : STATE-NUM. */
1297 : #define YYPACT_NINF -390
1298 : static const yytype_int16 yypact[] =
1299 : {
1300 : 46, 98, 67, 1195, -390, -390, -390, 83, -390, -390,
1301 : -390, -109, 345, 345, -86, 345, -91, -91, 345, -86,
1302 : -86, -77, 326, -77, 98, 345, -86, -58, 345, 345,
1303 : 345, -77, 345, 345, -86, 345, 345, 345, 345, 345,
1304 : 345, 345, 345, 345, 345, 345, 345, 345, 345, 345,
1305 : 345, 345, 345, 345, 345, 345, 52, -390, -390, -390,
1306 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1307 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1308 : 89, 89, -390, -390, -390, -390, -390, -390, 222, -390,
1309 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1310 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1311 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1312 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1313 : -390, -390, -390, -390, -390, -75, -63, -390, -390, 1081,
1314 : -390, -390, -390, -390, -390, 17, -390, -390, -390, -390,
1315 : -390, -390, -390, -390, -390, 32, -43, -56, -390, -44,
1316 : -390, -30, -26, -11, 11, 21, 33, 65, -86, -77,
1317 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1318 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1319 : -390, -390, -390, -390, 116, -390, -390, -390, -390, 180,
1320 : -1, 3, 98, 345, -390, -390, 144, -88, 56, 213,
1321 : 326, -86, -86, -77, -86, -77, -390, -390, 68, 88,
1322 : 114, -86, -86, -390, -390, -390, -390, -390, -390, -390,
1323 : -86, 98, -47, -20, 60, 98, 345, 345, -86, -390,
1324 : -390, 115, -86, -390, -390, -390, -66, 118, -86, 124,
1325 : 125, 127, -390, -390, -390, -390, -390, -390, 128, -97,
1326 : 129, 135, 150, 157, 159, 160, 167, -86, 96, 142,
1327 : 166, 168, 176, -77, -77, 188, 190, 193, 195, 196,
1328 : 198, 197, -390, -390, -390, -390, -390, -390, -390, -390,
1329 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1330 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1331 : -390, -390, -390, 98, 98, 98, -390, -390, -390, -390,
1332 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1333 : -390, -390, -390, -390, -390, 2, -390, -390, 12, 41,
1334 : -390, -390, -390, -390, -390, 98, -390, 98, -390, -390,
1335 : -77, -77, -390, -390, -390, -390, 98, -390, 1, -390,
1336 : 98, 98, 98, -390, -390, -390, -390, -390, 266, -390,
1337 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1338 : 98, 98, -77, -77, -390, -390, -390, -390, 98, 5,
1339 : 345, 345, -86, -58, 345, 345, -390, -390, 226, 98,
1340 : 98, 98, 6, 49, 122, 282, 9, 345, -91, -91,
1341 : 345, -390, -390, 40, -6, 42, 50, 13, 214, 174,
1342 : -5, 98, 55, -77, 204, 37, 151, 58, 66, 205,
1343 : 212, 215, -86, -77, 168, -77, -390, -390, -390, -390,
1344 : -390, -390, -390, -390, -390, -390, 206, 210, 223, 216,
1345 : -67, -86, 168, -390, -390, -390, -390, -390, -86, -86,
1346 : 233, 168, -390, -390, -390, -390, -390, 85, 235, 246,
1347 : 247, -390, -390, 252, 98, 253, 257, -390, -390, -86,
1348 : 345, 345, -390, -390, -390, -390, -390, -390, -67, -67,
1349 : -67, -67, -390, -390, 98, 98, -390, -390, 98, -17,
1350 : 98, -14, 147, -390, -390, 98, 62, 209, 271, -390,
1351 : -390, -86, 258, -390, -390, -390, -390, -390, -390, -390,
1352 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1353 : 98, -390, -77, -390, -86, 185, 264, 168, 268, -390,
1354 : -390, -390, -86, 272, -390, -390, -390, -390, -390, -390,
1355 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1356 : -390, -390, -39, -390, -390, -390, -390, -390, -390, -390,
1357 : 98, 98, 98, 98, -390, 98, 98, -390, -390, -390,
1358 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1359 : -390, -390, -390, -390, -390, -390, -390, -77, -390, -77,
1360 : -390, -390, -390, -390, -390, -390, -390, -77, -390, -77,
1361 : -390, -390, -77, 225, 275, -390, -390, -390, -390, -390,
1362 : -390, 98, -390, -77, -390, 0, 36, -390, -390, -390,
1363 : -390, 98, 98, 98, 98, 98, 98, -77, -77, -77,
1364 : -77, -77, -390, -390, -390, 98, -77, -45, 345, 345,
1365 : -390, -390, -86, -390, -390, 186, 98, 98, 98, 98,
1366 : 281, 98, 283, 284, 285, 286, 290, 143, 291, 292,
1367 : 296, 298, -86, 168, -390, -390, -390, -390, -390, -390,
1368 : -390, -390, -390, -390, -390, 297, 299, 300, 301, -390,
1369 : 302, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1370 : -390, -390, -390, -390, -390, -390, -390, -390, 18, -390,
1371 : 345, 345, 345, 345, 345, 345, 345, 345, 345, 345,
1372 : 345, 345, 345, 345, 345, 345, 345, 345, 345, -390,
1373 : -390, -38, -390, -390, -390, -390, -390, -390, -390, -390,
1374 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1375 : -390, 310, -86, 168, -390, -390, -390, -390, -390, -18,
1376 : 345, 345, -86, -390, -390, -390, -390, -390
1377 : };
1378 :
1379 : /* YYPGOTO[NTERM-NUM]. */
1380 : static const yytype_int16 yypgoto[] =
1381 : {
1382 : -390, -390, -390, 119, -390, 295, -390, -390, -390, -390,
1383 : -390, -390, 15, -390, -390, -390, -390, -390, -390, -390,
1384 : -390, -390, -390, 288, -390, -390, -390, 132, -390, -390,
1385 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1386 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1387 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1388 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1389 : -390, -390, -390, -390, -390, -390, 308, -390, -390, -390,
1390 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1391 : -390, -137, -390, -206, -390, -390, -390, -390, -203, -390,
1392 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1393 : -390, -390, -390, -390, -390, -390, -390, -390, -390, -390,
1394 : -390, -390, -390, -390, -205, -390, -390, -390, -390, -390,
1395 : -390, -390, 134, -390, -390, -390, -390, -390, -390, -390,
1396 : 133, -390, -390, -390, -389, -16, -390, 376, -13, 24,
1397 : 130, 379, 97, 553
1398 : };
1399 :
1400 : /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1401 : positive, shift that token. If negative, reduce the rule which
1402 : number is the opposite. If zero, do what YYDEFACT says.
1403 : If YYTABLE_NINF, syntax error. */
1404 : #define YYTABLE_NINF -1
1405 : static const yytype_uint16 yytable[] =
1406 : {
1407 : 84, 90, 87, 285, 295, 91, 286, 136, 241, 161,
1408 : 162, 670, 103, 163, 322, 107, 108, 109, 751, 111,
1409 : 112, 242, 114, 115, 116, 117, 118, 119, 120, 121,
1410 : 122, 123, 124, 125, 126, 127, 128, 129, 130, 131,
1411 : 132, 133, 134, 92, 93, 552, 760, 761, 671, 1,
1412 : 104, 164, 165, 218, 166, 219, 167, 218, 113, 219,
1413 : 430, 431, 449, 561, 672, 390, 168, 10, 648, 649,
1414 : 391, 752, 566, 591, 592, 710, 711, 712, 713, 714,
1415 : 715, 716, 717, 136, 718, 719, 494, 57, 720, 721,
1416 : 722, 723, 724, 725, 726, 727, 728, 58, 8, 85,
1417 : 450, 495, 135, 136, 142, 143, 144, 220, 221, 673,
1418 : 85, 220, 221, 331, 432, 451, 753, 88, 479, 243,
1419 : 222, 8, 511, 6, 222, 392, 393, 394, 169, 85,
1420 : 85, 147, 433, 6, 6, 488, 489, 490, 491, 105,
1421 : 157, 395, 458, 148, 526, 527, 534, 535, 620, 498,
1422 : 179, 246, 602, 603, 247, 627, 628, 505, 459, 434,
1423 : 452, 313, 674, 180, 170, 248, 435, 542, 249, 754,
1424 : 160, 593, 250, 594, 181, 542, 182, 140, 141, 460,
1425 : 183, 536, 480, 481, 4, 5, 6, 762, 314, 763,
1426 : 229, 537, 189, 453, 597, 184, 456, 464, 466, 457,
1427 : 465, 496, 567, 461, 528, 568, 223, 650, 396, 371,
1428 : 227, 249, 436, 454, 512, 250, 482, 185, 249, 374,
1429 : 513, 251, 250, 317, 318, 729, 151, 186, 251, 499,
1430 : 538, 500, 467, 501, 502, 301, 302, 506, 304, 187,
1431 : 652, 507, 508, 653, 539, 309, 310, 202, 375, 503,
1432 : 604, 492, 605, 230, 311, 203, 462, 509, 150, 543,
1433 : 534, 535, 319, 252, 531, 544, 321, 543, 315, 258,
1434 : 323, 188, 326, 546, 306, 231, 232, 233, 234, 235,
1435 : 236, 237, 238, 333, 702, 468, 469, 470, 5, 6,
1436 : 210, 341, 526, 527, 307, 536, 4, 5, 6, 8,
1437 : 616, 617, 211, 212, 342, 537, 259, 213, 214, 142,
1438 : 143, 144, 167, 260, 261, 262, 263, 264, 265, 266,
1439 : 308, 320, 267, 204, 325, 521, 522, 523, 8, 471,
1440 : 327, 328, 8, 329, 330, 334, 210, 680, 681, 682,
1441 : 215, 335, 268, 269, 538, 4, 5, 6, 211, 212,
1442 : 343, 239, 696, 213, 214, 599, 336, 270, 541, 515,
1443 : 516, 517, 518, 337, 758, 338, 339, 271, 272, 273,
1444 : 274, 275, 276, 340, 344, 249, 345, 439, 440, 250,
1445 : 95, 443, 444, 524, 347, 251, 215, 216, 277, 278,
1446 : 279, 280, 485, 486, 484, 683, 350, 487, 351, 352,
1447 : 59, 353, 354, 102, 355, 356, 281, 4, 5, 6,
1448 : 8, 8, 8, 533, 547, 554, 441, 607, 548, 555,
1449 : 282, 549, 557, 519, 60, 61, 62, 63, 64, 65,
1450 : 66, 67, 556, 445, 642, 68, 69, 96, 97, 98,
1451 : 99, 565, 8, 570, 8, 407, 408, 409, 410, 473,
1452 : 474, 475, 476, 8, 571, 572, 550, 8, 8, 8,
1453 : 573, 575, 70, 71, 72, 576, 612, 578, 579, 4,
1454 : 5, 6, 619, 411, 558, 560, 621, 8, 8, 609,
1455 : 623, 201, 563, 564, 643, 8, 73, 74, 75, 477,
1456 : 689, 398, 691, 692, 693, 694, 8, 8, 8, 695,
1457 : 697, 698, 699, 577, 700, 300, 703, 667, 704, 705,
1458 : 706, 707, 580, 582, 584, 586, 756, 283, 8, 426,
1459 : 428, 152, 0, 442, 0, 0, 0, 0, 76, 77,
1460 : 78, 79, 0, 0, 0, 611, 0, 0, 0, 0,
1461 : 0, 0, 0, 0, 5, 6, 0, 80, 81, 0,
1462 : 0, 0, 0, 0, 0, 0, 0, 0, 615, 0,
1463 : 0, 0, 0, 0, 0, 0, 622, 0, 0, 0,
1464 : 0, 8, 0, 0, 94, 0, 101, 0, 0, 0,
1465 : 0, 228, 0, 0, 110, 0, 0, 0, 0, 0,
1466 : 0, 8, 8, 0, 0, 8, 0, 8, 8, 8,
1467 : 0, 0, 8, 0, 8, 8, 0, 0, 0, 0,
1468 : 312, 0, 0, 0, 316, 0, 0, 0, 0, 0,
1469 : 0, 0, 0, 0, 0, 0, 0, 8, 0, 0,
1470 : 0, 0, 0, 0, 0, 677, 678, 0, 0, 0,
1471 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1472 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1473 : 0, 0, 0, 0, 0, 0, 0, 8, 8, 8,
1474 : 8, 0, 8, 8, 0, 0, 679, 0, 0, 0,
1475 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1476 : 0, 0, 360, 361, 362, 0, 701, 732, 733, 734,
1477 : 735, 736, 737, 738, 739, 740, 741, 742, 743, 744,
1478 : 745, 746, 747, 748, 749, 750, 0, 0, 8, 0,
1479 : 0, 0, 190, 0, 380, 0, 381, 0, 8, 8,
1480 : 8, 8, 8, 8, 0, 388, 0, 0, 0, 399,
1481 : 400, 401, 8, 0, 0, 0, 0, 765, 766, 0,
1482 : 0, 0, 0, 8, 8, 8, 8, 0, 8, 421,
1483 : 422, 0, 0, 0, 0, 0, 303, 429, 305, 0,
1484 : 0, 0, 0, 0, 0, 0, 757, 0, 446, 447,
1485 : 448, 0, 0, 0, 0, 0, 767, 0, 0, 0,
1486 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 324,
1487 : 530, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1488 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1489 : 0, 0, 0, 0, 0, 0, 348, 349, 0, 0,
1490 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1491 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1492 : 0, 0, 0, 574, 0, 0, 0, 0, 0, 0,
1493 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1494 : 0, 0, 0, 588, 589, 0, 0, 590, 0, 596,
1495 : 598, 600, 0, 0, 601, 0, 608, 610, 0, 0,
1496 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1497 : 0, 0, 0, 382, 383, 0, 0, 0, 0, 613,
1498 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1499 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1500 : 0, 0, 0, 0, 0, 423, 424, 0, 0, 0,
1501 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 631,
1502 : 632, 633, 634, 0, 635, 636, 0, 0, 0, 0,
1503 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1504 : 0, 0, 0, 0, 0, 0, 532, 0, 0, 0,
1505 : 0, 0, 0, 0, 0, 0, 551, 0, 553, 0,
1506 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1507 : 645, 0, 0, 559, 0, 0, 0, 0, 0, 0,
1508 : 656, 657, 658, 659, 660, 661, 0, 0, 0, 0,
1509 : 0, 0, 0, 0, 668, 0, 0, 0, 0, 0,
1510 : 0, 0, 0, 0, 0, 685, 686, 687, 688, 0,
1511 : 690, 581, 583, 585, 587, 0, 0, 0, 0, 0,
1512 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1513 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1514 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1515 : 0, 0, 0, 0, 0, 614, 11, 12, 13, 14,
1516 : 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1517 : 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1518 : 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1519 : 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
1520 : 55, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1521 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1522 : 637, 0, 638, 0, 0, 0, 0, 0, 0, 0,
1523 : 639, 0, 640, 0, 0, 641, 0, 0, 0, 0,
1524 : 0, 0, 0, 0, 0, 0, 646, 0, 0, 0,
1525 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1526 : 662, 663, 664, 665, 666, 0, 0, 0, 0, 669,
1527 : 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1528 : 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1529 : 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1530 : 41, 42, 43, 44, 45, 46, 47, 48, 49, 50,
1531 : 51, 52, 53, 54, 55, 0, 0, 0, 0, 0,
1532 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1533 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1534 : 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1535 : 0, 0, 0, 0, 0, 0, 0, 0, 149
1536 : };
1537 :
1538 : static const yytype_int16 yycheck[] =
1539 : {
1540 : 13, 17, 15, 209, 209, 18, 209, 51, 96, 52,
1541 : 53, 56, 25, 56, 80, 28, 29, 30, 56, 32,
1542 : 33, 109, 35, 36, 37, 38, 39, 40, 41, 42,
1543 : 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
1544 : 53, 54, 55, 19, 20, 434, 64, 65, 93, 3,
1545 : 26, 94, 95, 54, 97, 56, 99, 54, 34, 56,
1546 : 55, 56, 56, 452, 109, 64, 109, 0, 68, 69,
1547 : 69, 109, 461, 90, 91, 57, 58, 59, 60, 61,
1548 : 62, 63, 64, 51, 66, 67, 92, 4, 70, 71,
1549 : 72, 73, 74, 75, 76, 77, 78, 206, 1, 196,
1550 : 94, 107, 50, 51, 87, 88, 89, 108, 109, 154,
1551 : 196, 108, 109, 210, 109, 109, 154, 208, 109, 207,
1552 : 121, 24, 109, 200, 121, 124, 125, 126, 171, 196,
1553 : 196, 206, 127, 200, 200, 95, 96, 97, 98, 197,
1554 : 108, 140, 93, 206, 149, 150, 109, 110, 537, 107,
1555 : 206, 95, 90, 91, 98, 194, 195, 107, 109, 154,
1556 : 154, 208, 207, 207, 207, 109, 161, 109, 162, 207,
1557 : 155, 188, 166, 190, 159, 109, 206, 80, 81, 130,
1558 : 206, 144, 173, 174, 198, 199, 200, 205, 208, 207,
1559 : 203, 154, 168, 187, 208, 206, 402, 403, 403, 402,
1560 : 403, 207, 117, 154, 209, 120, 207, 207, 207, 207,
1561 : 207, 162, 207, 207, 201, 166, 207, 206, 162, 207,
1562 : 207, 172, 166, 236, 237, 207, 209, 206, 172, 187,
1563 : 193, 189, 110, 191, 192, 211, 212, 187, 214, 206,
1564 : 204, 191, 192, 207, 207, 221, 222, 131, 207, 207,
1565 : 188, 211, 190, 109, 230, 139, 207, 207, 139, 201,
1566 : 109, 110, 238, 207, 209, 207, 242, 201, 208, 56,
1567 : 246, 206, 248, 207, 206, 131, 132, 133, 134, 135,
1568 : 136, 137, 138, 259, 673, 163, 164, 165, 199, 200,
1569 : 110, 267, 149, 150, 206, 144, 198, 199, 200, 202,
1570 : 115, 116, 122, 123, 208, 154, 93, 127, 128, 87,
1571 : 88, 89, 99, 100, 101, 102, 103, 104, 105, 106,
1572 : 206, 206, 109, 207, 206, 151, 152, 153, 231, 207,
1573 : 206, 206, 235, 206, 206, 206, 110, 151, 152, 153,
1574 : 160, 206, 129, 130, 193, 198, 199, 200, 122, 123,
1575 : 208, 207, 209, 127, 128, 208, 206, 144, 207, 145,
1576 : 146, 147, 148, 206, 753, 206, 206, 154, 155, 156,
1577 : 157, 158, 159, 206, 208, 162, 208, 390, 391, 166,
1578 : 54, 394, 395, 209, 208, 172, 160, 207, 175, 176,
1579 : 177, 178, 408, 409, 407, 209, 208, 410, 208, 206,
1580 : 55, 206, 206, 24, 206, 208, 193, 198, 199, 200,
1581 : 313, 314, 315, 209, 209, 209, 392, 208, 206, 209,
1582 : 207, 206, 206, 209, 79, 80, 81, 82, 83, 84,
1583 : 85, 86, 209, 207, 209, 90, 91, 111, 112, 113,
1584 : 114, 208, 345, 208, 347, 179, 180, 181, 182, 167,
1585 : 168, 169, 170, 356, 208, 208, 432, 360, 361, 362,
1586 : 208, 208, 117, 118, 119, 208, 208, 480, 481, 198,
1587 : 199, 200, 208, 207, 450, 451, 208, 380, 381, 208,
1588 : 208, 193, 458, 459, 209, 388, 141, 142, 143, 207,
1589 : 209, 359, 209, 209, 209, 209, 399, 400, 401, 209,
1590 : 209, 209, 206, 479, 206, 210, 209, 644, 209, 209,
1591 : 209, 209, 488, 489, 490, 491, 206, 209, 421, 385,
1592 : 387, 145, -1, 393, -1, -1, -1, -1, 183, 184,
1593 : 185, 186, -1, -1, -1, 511, -1, -1, -1, -1,
1594 : -1, -1, -1, -1, 199, 200, -1, 202, 203, -1,
1595 : -1, -1, -1, -1, -1, -1, -1, -1, 534, -1,
1596 : -1, -1, -1, -1, -1, -1, 542, -1, -1, -1,
1597 : -1, 474, -1, -1, 21, -1, 23, -1, -1, -1,
1598 : -1, 202, -1, -1, 31, -1, -1, -1, -1, -1,
1599 : -1, 494, 495, -1, -1, 498, -1, 500, 501, 502,
1600 : -1, -1, 505, -1, 507, 508, -1, -1, -1, -1,
1601 : 231, -1, -1, -1, 235, -1, -1, -1, -1, -1,
1602 : -1, -1, -1, -1, -1, -1, -1, 530, -1, -1,
1603 : -1, -1, -1, -1, -1, 648, 649, -1, -1, -1,
1604 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1605 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1606 : -1, -1, -1, -1, -1, -1, -1, 570, 571, 572,
1607 : 573, -1, 575, 576, -1, -1, 652, -1, -1, -1,
1608 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1609 : -1, -1, 313, 314, 315, -1, 672, 710, 711, 712,
1610 : 713, 714, 715, 716, 717, 718, 719, 720, 721, 722,
1611 : 723, 724, 725, 726, 727, 728, -1, -1, 621, -1,
1612 : -1, -1, 169, -1, 345, -1, 347, -1, 631, 632,
1613 : 633, 634, 635, 636, -1, 356, -1, -1, -1, 360,
1614 : 361, 362, 645, -1, -1, -1, -1, 760, 761, -1,
1615 : -1, -1, -1, 656, 657, 658, 659, -1, 661, 380,
1616 : 381, -1, -1, -1, -1, -1, 213, 388, 215, -1,
1617 : -1, -1, -1, -1, -1, -1, 752, -1, 399, 400,
1618 : 401, -1, -1, -1, -1, -1, 762, -1, -1, -1,
1619 : -1, -1, -1, -1, -1, -1, -1, -1, -1, 246,
1620 : 421, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1621 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1622 : -1, -1, -1, -1, -1, -1, 273, 274, -1, -1,
1623 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1624 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1625 : -1, -1, -1, 474, -1, -1, -1, -1, -1, -1,
1626 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1627 : -1, -1, -1, 494, 495, -1, -1, 498, -1, 500,
1628 : 501, 502, -1, -1, 505, -1, 507, 508, -1, -1,
1629 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1630 : -1, -1, -1, 350, 351, -1, -1, -1, -1, 530,
1631 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1632 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1633 : -1, -1, -1, -1, -1, 382, 383, -1, -1, -1,
1634 : -1, -1, -1, -1, -1, -1, -1, -1, -1, 570,
1635 : 571, 572, 573, -1, 575, 576, -1, -1, -1, -1,
1636 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1637 : -1, -1, -1, -1, -1, -1, 423, -1, -1, -1,
1638 : -1, -1, -1, -1, -1, -1, 433, -1, 435, -1,
1639 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1640 : 621, -1, -1, 450, -1, -1, -1, -1, -1, -1,
1641 : 631, 632, 633, 634, 635, 636, -1, -1, -1, -1,
1642 : -1, -1, -1, -1, 645, -1, -1, -1, -1, -1,
1643 : -1, -1, -1, -1, -1, 656, 657, 658, 659, -1,
1644 : 661, 488, 489, 490, 491, -1, -1, -1, -1, -1,
1645 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1646 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1647 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1648 : -1, -1, -1, -1, -1, 532, 5, 6, 7, 8,
1649 : 9, 10, 11, 12, 13, 14, 15, 16, 17, 18,
1650 : 19, 20, 21, 22, 23, 24, 25, 26, 27, 28,
1651 : 29, 30, 31, 32, 33, 34, 35, 36, 37, 38,
1652 : 39, 40, 41, 42, 43, 44, 45, 46, 47, 48,
1653 : 49, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1654 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1655 : 597, -1, 599, -1, -1, -1, -1, -1, -1, -1,
1656 : 607, -1, 609, -1, -1, 612, -1, -1, -1, -1,
1657 : -1, -1, -1, -1, -1, -1, 623, -1, -1, -1,
1658 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1659 : 637, 638, 639, 640, 641, -1, -1, -1, -1, 646,
1660 : 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
1661 : 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
1662 : 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
1663 : 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
1664 : 45, 46, 47, 48, 49, -1, -1, -1, -1, -1,
1665 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1666 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1667 : -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1668 : -1, -1, -1, -1, -1, -1, -1, -1, 207
1669 : };
1670 :
1671 : /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1672 : symbol of state STATE-NUM. */
1673 : static const yytype_uint16 yystos[] =
1674 : {
1675 : 0, 3, 213, 214, 198, 199, 200, 363, 364, 365,
1676 : 0, 5, 6, 7, 8, 9, 10, 11, 12, 13,
1677 : 14, 15, 16, 17, 18, 19, 20, 21, 22, 23,
1678 : 24, 25, 26, 27, 28, 29, 30, 31, 32, 33,
1679 : 34, 35, 36, 37, 38, 39, 40, 41, 42, 43,
1680 : 44, 45, 46, 47, 48, 49, 215, 4, 206, 55,
1681 : 79, 80, 81, 82, 83, 84, 85, 86, 90, 91,
1682 : 117, 118, 119, 141, 142, 143, 183, 184, 185, 186,
1683 : 202, 203, 360, 364, 360, 196, 361, 360, 208, 357,
1684 : 357, 360, 361, 361, 365, 54, 111, 112, 113, 114,
1685 : 217, 365, 363, 360, 361, 197, 362, 360, 360, 360,
1686 : 365, 360, 360, 361, 360, 360, 360, 360, 360, 360,
1687 : 360, 360, 360, 360, 360, 360, 360, 360, 360, 360,
1688 : 360, 360, 360, 360, 360, 50, 51, 218, 224, 216,
1689 : 364, 364, 87, 88, 89, 358, 359, 206, 206, 207,
1690 : 215, 209, 359, 219, 225, 220, 226, 108, 221, 223,
1691 : 224, 52, 53, 56, 94, 95, 97, 99, 109, 171,
1692 : 207, 227, 230, 231, 233, 261, 265, 277, 288, 206,
1693 : 207, 224, 206, 206, 206, 206, 206, 206, 206, 361,
1694 : 365, 222, 234, 232, 228, 262, 266, 278, 289, 239,
1695 : 235, 235, 131, 139, 207, 229, 263, 267, 279, 290,
1696 : 110, 122, 123, 127, 128, 160, 207, 240, 54, 56,
1697 : 108, 109, 121, 207, 236, 237, 243, 207, 363, 360,
1698 : 109, 131, 132, 133, 134, 135, 136, 137, 138, 207,
1699 : 264, 96, 109, 207, 268, 269, 95, 98, 109, 162,
1700 : 166, 172, 207, 280, 281, 305, 310, 336, 56, 93,
1701 : 100, 101, 102, 103, 104, 105, 106, 109, 129, 130,
1702 : 144, 154, 155, 156, 157, 158, 159, 175, 176, 177,
1703 : 178, 193, 207, 288, 291, 305, 310, 314, 315, 317,
1704 : 318, 320, 322, 323, 324, 336, 340, 342, 348, 350,
1705 : 217, 361, 361, 365, 361, 365, 206, 206, 206, 361,
1706 : 361, 361, 363, 208, 208, 208, 363, 360, 360, 361,
1707 : 206, 361, 80, 361, 365, 206, 361, 206, 206, 206,
1708 : 206, 210, 295, 361, 206, 206, 206, 206, 206, 206,
1709 : 206, 361, 208, 208, 208, 208, 356, 208, 365, 365,
1710 : 208, 208, 206, 206, 206, 206, 208, 244, 241, 238,
1711 : 363, 363, 363, 270, 282, 306, 311, 337, 354, 296,
1712 : 316, 207, 319, 321, 207, 207, 325, 292, 293, 294,
1713 : 363, 363, 365, 365, 341, 343, 349, 351, 363, 245,
1714 : 64, 69, 124, 125, 126, 140, 207, 242, 239, 363,
1715 : 363, 363, 271, 283, 307, 312, 338, 179, 180, 181,
1716 : 182, 207, 355, 297, 326, 328, 331, 334, 299, 301,
1717 : 303, 363, 363, 365, 365, 344, 344, 352, 352, 363,
1718 : 55, 56, 109, 127, 154, 161, 207, 246, 249, 360,
1719 : 360, 361, 362, 360, 360, 207, 363, 363, 363, 56,
1720 : 94, 109, 154, 187, 207, 272, 305, 310, 93, 109,
1721 : 130, 154, 207, 284, 305, 310, 336, 110, 163, 164,
1722 : 165, 207, 308, 167, 168, 169, 170, 207, 313, 109,
1723 : 173, 174, 207, 339, 360, 357, 357, 360, 95, 96,
1724 : 97, 98, 211, 298, 92, 107, 207, 327, 107, 187,
1725 : 189, 191, 192, 207, 329, 107, 187, 191, 192, 207,
1726 : 332, 109, 201, 207, 335, 145, 146, 147, 148, 209,
1727 : 300, 151, 152, 153, 209, 302, 149, 150, 209, 304,
1728 : 363, 209, 365, 209, 109, 110, 144, 154, 193, 207,
1729 : 345, 207, 109, 201, 207, 353, 207, 209, 206, 206,
1730 : 361, 365, 356, 365, 209, 209, 209, 206, 361, 365,
1731 : 361, 356, 273, 361, 361, 208, 356, 117, 120, 309,
1732 : 208, 208, 208, 208, 363, 208, 208, 361, 360, 360,
1733 : 361, 365, 361, 365, 361, 365, 361, 365, 363, 363,
1734 : 363, 90, 91, 188, 190, 330, 363, 208, 363, 208,
1735 : 363, 363, 90, 91, 188, 190, 333, 208, 363, 208,
1736 : 363, 361, 208, 363, 365, 361, 115, 116, 347, 208,
1737 : 356, 208, 361, 208, 250, 247, 275, 194, 195, 274,
1738 : 285, 363, 363, 363, 363, 363, 363, 365, 365, 365,
1739 : 365, 365, 209, 209, 346, 363, 365, 251, 68, 69,
1740 : 207, 248, 204, 207, 276, 286, 363, 363, 363, 363,
1741 : 363, 363, 365, 365, 365, 365, 365, 303, 363, 365,
1742 : 56, 93, 109, 154, 207, 252, 255, 360, 360, 361,
1743 : 151, 152, 153, 209, 287, 363, 363, 363, 363, 209,
1744 : 363, 209, 209, 209, 209, 209, 209, 209, 209, 206,
1745 : 206, 361, 356, 209, 209, 209, 209, 209, 253, 256,
1746 : 57, 58, 59, 60, 61, 62, 63, 64, 66, 67,
1747 : 70, 71, 72, 73, 74, 75, 76, 77, 78, 207,
1748 : 254, 257, 360, 360, 360, 360, 360, 360, 360, 360,
1749 : 360, 360, 360, 360, 360, 360, 360, 360, 360, 360,
1750 : 360, 56, 109, 154, 207, 258, 206, 361, 356, 259,
1751 : 64, 65, 205, 207, 260, 360, 360, 361
1752 : };
1753 :
1754 : #define yyerrok (yyerrstatus = 0)
1755 : #define yyclearin (yychar = YYEMPTY)
1756 : #define YYEMPTY (-2)
1757 : #define YYEOF 0
1758 :
1759 : #define YYACCEPT goto yyacceptlab
1760 : #define YYABORT goto yyabortlab
1761 : #define YYERROR goto yyerrorlab
1762 :
1763 :
1764 : /* Like YYERROR except do call yyerror. This remains here temporarily
1765 : to ease the transition to the new meaning of YYERROR, for GCC.
1766 : Once GCC version 2 has supplanted version 1, this can go. */
1767 :
1768 : #define YYFAIL goto yyerrlab
1769 :
1770 : #define YYRECOVERING() (!!yyerrstatus)
1771 :
1772 : #define YYBACKUP(Token, Value) \
1773 : do \
1774 : if (yychar == YYEMPTY && yylen == 1) \
1775 : { \
1776 : yychar = (Token); \
1777 : yylval = (Value); \
1778 : yytoken = YYTRANSLATE (yychar); \
1779 : YYPOPSTACK (1); \
1780 : goto yybackup; \
1781 : } \
1782 : else \
1783 : { \
1784 : yyerror (YY_("syntax error: cannot back up")); \
1785 : YYERROR; \
1786 : } \
1787 : while (YYID (0))
1788 :
1789 :
1790 : #define YYTERROR 1
1791 : #define YYERRCODE 256
1792 :
1793 :
1794 : /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1795 : If N is 0, then set CURRENT to the empty location which ends
1796 : the previous symbol: RHS[0] (always defined). */
1797 :
1798 : #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1799 : #ifndef YYLLOC_DEFAULT
1800 : # define YYLLOC_DEFAULT(Current, Rhs, N) \
1801 : do \
1802 : if (YYID (N)) \
1803 : { \
1804 : (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1805 : (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1806 : (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1807 : (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1808 : } \
1809 : else \
1810 : { \
1811 : (Current).first_line = (Current).last_line = \
1812 : YYRHSLOC (Rhs, 0).last_line; \
1813 : (Current).first_column = (Current).last_column = \
1814 : YYRHSLOC (Rhs, 0).last_column; \
1815 : } \
1816 : while (YYID (0))
1817 : #endif
1818 :
1819 :
1820 : /* YY_LOCATION_PRINT -- Print the location on the stream.
1821 : This macro was not mandated originally: define only if we know
1822 : we won't break user code: when these are the locations we know. */
1823 :
1824 : #ifndef YY_LOCATION_PRINT
1825 : # if YYLTYPE_IS_TRIVIAL
1826 : # define YY_LOCATION_PRINT(File, Loc) \
1827 : fprintf (File, "%d.%d-%d.%d", \
1828 : (Loc).first_line, (Loc).first_column, \
1829 : (Loc).last_line, (Loc).last_column)
1830 : # else
1831 : # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1832 : # endif
1833 : #endif
1834 :
1835 :
1836 : /* YYLEX -- calling `yylex' with the right arguments. */
1837 :
1838 : #ifdef YYLEX_PARAM
1839 : # define YYLEX yylex (YYLEX_PARAM)
1840 : #else
1841 : # define YYLEX yylex ()
1842 : #endif
1843 :
1844 : /* Enable debugging if requested. */
1845 : #if YYDEBUG
1846 :
1847 : # ifndef YYFPRINTF
1848 : # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1849 : # define YYFPRINTF fprintf
1850 : # endif
1851 :
1852 : # define YYDPRINTF(Args) \
1853 : do { \
1854 : if (yydebug) \
1855 : YYFPRINTF Args; \
1856 : } while (YYID (0))
1857 :
1858 : # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1859 : do { \
1860 : if (yydebug) \
1861 : { \
1862 : YYFPRINTF (stderr, "%s ", Title); \
1863 : yy_symbol_print (stderr, \
1864 : Type, Value); \
1865 : YYFPRINTF (stderr, "\n"); \
1866 : } \
1867 : } while (YYID (0))
1868 :
1869 :
1870 : /*--------------------------------.
1871 : | Print this symbol on YYOUTPUT. |
1872 : `--------------------------------*/
1873 :
1874 : /*ARGSUSED*/
1875 : #if (defined __STDC__ || defined __C99__FUNC__ \
1876 : || defined __cplusplus || defined _MSC_VER)
1877 : static void
1878 : yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1879 : #else
1880 : static void
1881 : yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1882 : FILE *yyoutput;
1883 : int yytype;
1884 : YYSTYPE const * const yyvaluep;
1885 : #endif
1886 : {
1887 : if (!yyvaluep)
1888 : return;
1889 : # ifdef YYPRINT
1890 : if (yytype < YYNTOKENS)
1891 : YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1892 : # else
1893 : YYUSE (yyoutput);
1894 : # endif
1895 : switch (yytype)
1896 : {
1897 : default:
1898 : break;
1899 : }
1900 : }
1901 :
1902 :
1903 : /*--------------------------------.
1904 : | Print this symbol on YYOUTPUT. |
1905 : `--------------------------------*/
1906 :
1907 : #if (defined __STDC__ || defined __C99__FUNC__ \
1908 : || defined __cplusplus || defined _MSC_VER)
1909 : static void
1910 : yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1911 : #else
1912 : static void
1913 : yy_symbol_print (yyoutput, yytype, yyvaluep)
1914 : FILE *yyoutput;
1915 : int yytype;
1916 : YYSTYPE const * const yyvaluep;
1917 : #endif
1918 : {
1919 : if (yytype < YYNTOKENS)
1920 : YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1921 : else
1922 : YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1923 :
1924 : yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1925 : YYFPRINTF (yyoutput, ")");
1926 : }
1927 :
1928 : /*------------------------------------------------------------------.
1929 : | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1930 : | TOP (included). |
1931 : `------------------------------------------------------------------*/
1932 :
1933 : #if (defined __STDC__ || defined __C99__FUNC__ \
1934 : || defined __cplusplus || defined _MSC_VER)
1935 : static void
1936 : yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1937 : #else
1938 : static void
1939 : yy_stack_print (yybottom, yytop)
1940 : yytype_int16 *yybottom;
1941 : yytype_int16 *yytop;
1942 : #endif
1943 : {
1944 : YYFPRINTF (stderr, "Stack now");
1945 : for (; yybottom <= yytop; yybottom++)
1946 : {
1947 : int yybot = *yybottom;
1948 : YYFPRINTF (stderr, " %d", yybot);
1949 : }
1950 : YYFPRINTF (stderr, "\n");
1951 : }
1952 :
1953 : # define YY_STACK_PRINT(Bottom, Top) \
1954 : do { \
1955 : if (yydebug) \
1956 : yy_stack_print ((Bottom), (Top)); \
1957 : } while (YYID (0))
1958 :
1959 :
1960 : /*------------------------------------------------.
1961 : | Report that the YYRULE is going to be reduced. |
1962 : `------------------------------------------------*/
1963 :
1964 : #if (defined __STDC__ || defined __C99__FUNC__ \
1965 : || defined __cplusplus || defined _MSC_VER)
1966 : static void
1967 : yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1968 : #else
1969 : static void
1970 : yy_reduce_print (yyvsp, yyrule)
1971 : YYSTYPE *yyvsp;
1972 : int yyrule;
1973 : #endif
1974 : {
1975 : int yynrhs = yyr2[yyrule];
1976 : int yyi;
1977 : unsigned long int yylno = yyrline[yyrule];
1978 : YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1979 : yyrule - 1, yylno);
1980 : /* The symbols being reduced. */
1981 : for (yyi = 0; yyi < yynrhs; yyi++)
1982 : {
1983 : YYFPRINTF (stderr, " $%d = ", yyi + 1);
1984 : yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1985 : &(yyvsp[(yyi + 1) - (yynrhs)])
1986 : );
1987 : YYFPRINTF (stderr, "\n");
1988 : }
1989 : }
1990 :
1991 : # define YY_REDUCE_PRINT(Rule) \
1992 : do { \
1993 : if (yydebug) \
1994 : yy_reduce_print (yyvsp, Rule); \
1995 : } while (YYID (0))
1996 :
1997 : /* Nonzero means print parse trace. It is left uninitialized so that
1998 : multiple parsers can coexist. */
1999 : int yydebug;
2000 : #else /* !YYDEBUG */
2001 : # define YYDPRINTF(Args)
2002 : # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
2003 : # define YY_STACK_PRINT(Bottom, Top)
2004 : # define YY_REDUCE_PRINT(Rule)
2005 : #endif /* !YYDEBUG */
2006 :
2007 :
2008 : /* YYINITDEPTH -- initial size of the parser's stacks. */
2009 : #ifndef YYINITDEPTH
2010 : # define YYINITDEPTH 200
2011 : #endif
2012 :
2013 : /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
2014 : if the built-in stack extension method is used).
2015 :
2016 : Do not make this value too large; the results are undefined if
2017 : YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
2018 : evaluated with infinite-precision integer arithmetic. */
2019 :
2020 : #ifndef YYMAXDEPTH
2021 : # define YYMAXDEPTH 10000
2022 : #endif
2023 :
2024 :
2025 :
2026 : #if YYERROR_VERBOSE
2027 :
2028 : # ifndef yystrlen
2029 : # if defined __GLIBC__ && defined _STRING_H
2030 : # define yystrlen strlen
2031 : # else
2032 : /* Return the length of YYSTR. */
2033 : #if (defined __STDC__ || defined __C99__FUNC__ \
2034 : || defined __cplusplus || defined _MSC_VER)
2035 : static YYSIZE_T
2036 : yystrlen (const char *yystr)
2037 : #else
2038 : static YYSIZE_T
2039 : yystrlen (yystr)
2040 : const char *yystr;
2041 : #endif
2042 : {
2043 : YYSIZE_T yylen;
2044 : for (yylen = 0; yystr[yylen]; yylen++)
2045 : continue;
2046 : return yylen;
2047 : }
2048 : # endif
2049 : # endif
2050 :
2051 : # ifndef yystpcpy
2052 : # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
2053 : # define yystpcpy stpcpy
2054 : # else
2055 : /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
2056 : YYDEST. */
2057 : #if (defined __STDC__ || defined __C99__FUNC__ \
2058 : || defined __cplusplus || defined _MSC_VER)
2059 : static char *
2060 : yystpcpy (char *yydest, const char *yysrc)
2061 : #else
2062 : static char *
2063 : yystpcpy (yydest, yysrc)
2064 : char *yydest;
2065 : const char *yysrc;
2066 : #endif
2067 : {
2068 : char *yyd = yydest;
2069 : const char *yys = yysrc;
2070 :
2071 : while ((*yyd++ = *yys++) != '\0')
2072 : continue;
2073 :
2074 : return yyd - 1;
2075 : }
2076 : # endif
2077 : # endif
2078 :
2079 : # ifndef yytnamerr
2080 : /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
2081 : quotes and backslashes, so that it's suitable for yyerror. The
2082 : heuristic is that double-quoting is unnecessary unless the string
2083 : contains an apostrophe, a comma, or backslash (other than
2084 : backslash-backslash). YYSTR is taken from yytname. If YYRES is
2085 : null, do not copy; instead, return the length of what the result
2086 : would have been. */
2087 : static YYSIZE_T
2088 : yytnamerr (char *yyres, const char *yystr)
2089 : {
2090 : if (*yystr == '"')
2091 : {
2092 : YYSIZE_T yyn = 0;
2093 : char const *yyp = yystr;
2094 :
2095 : for (;;)
2096 : switch (*++yyp)
2097 : {
2098 : case '\'':
2099 : case ',':
2100 : goto do_not_strip_quotes;
2101 :
2102 : case '\\':
2103 : if (*++yyp != '\\')
2104 : goto do_not_strip_quotes;
2105 : /* Fall through. */
2106 : default:
2107 : if (yyres)
2108 : yyres[yyn] = *yyp;
2109 : yyn++;
2110 : break;
2111 :
2112 : case '"':
2113 : if (yyres)
2114 : yyres[yyn] = '\0';
2115 : return yyn;
2116 : }
2117 : do_not_strip_quotes: ;
2118 : }
2119 :
2120 : if (! yyres)
2121 : return yystrlen (yystr);
2122 :
2123 : return yystpcpy (yyres, yystr) - yyres;
2124 : }
2125 : # endif
2126 :
2127 : /* Copy into YYRESULT an error message about the unexpected token
2128 : YYCHAR while in state YYSTATE. Return the number of bytes copied,
2129 : including the terminating null byte. If YYRESULT is null, do not
2130 : copy anything; just return the number of bytes that would be
2131 : copied. As a special case, return 0 if an ordinary "syntax error"
2132 : message will do. Return YYSIZE_MAXIMUM if overflow occurs during
2133 : size calculation. */
2134 : static YYSIZE_T
2135 : yysyntax_error (char *yyresult, int yystate, int yychar)
2136 : {
2137 : int yyn = yypact[yystate];
2138 :
2139 : if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
2140 : return 0;
2141 : else
2142 : {
2143 : int yytype = YYTRANSLATE (yychar);
2144 : YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
2145 : YYSIZE_T yysize = yysize0;
2146 : YYSIZE_T yysize1;
2147 : int yysize_overflow = 0;
2148 : enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2149 : char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2150 : int yyx;
2151 :
2152 : # if 0
2153 : /* This is so xgettext sees the translatable formats that are
2154 : constructed on the fly. */
2155 : YY_("syntax error, unexpected %s");
2156 : YY_("syntax error, unexpected %s, expecting %s");
2157 : YY_("syntax error, unexpected %s, expecting %s or %s");
2158 : YY_("syntax error, unexpected %s, expecting %s or %s or %s");
2159 : YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
2160 : # endif
2161 : char *yyfmt;
2162 : char const *yyf;
2163 : static char const yyunexpected[] = "syntax error, unexpected %s";
2164 : static char const yyexpecting[] = ", expecting %s";
2165 : static char const yyor[] = " or %s";
2166 : char yyformat[sizeof yyunexpected
2167 : + sizeof yyexpecting - 1
2168 : + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
2169 : * (sizeof yyor - 1))];
2170 : char const *yyprefix = yyexpecting;
2171 :
2172 : /* Start YYX at -YYN if negative to avoid negative indexes in
2173 : YYCHECK. */
2174 : int yyxbegin = yyn < 0 ? -yyn : 0;
2175 :
2176 : /* Stay within bounds of both yycheck and yytname. */
2177 : int yychecklim = YYLAST - yyn + 1;
2178 : int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2179 : int yycount = 1;
2180 :
2181 : yyarg[0] = yytname[yytype];
2182 : yyfmt = yystpcpy (yyformat, yyunexpected);
2183 :
2184 : for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2185 : if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2186 : {
2187 : if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2188 : {
2189 : yycount = 1;
2190 : yysize = yysize0;
2191 : yyformat[sizeof yyunexpected - 1] = '\0';
2192 : break;
2193 : }
2194 : yyarg[yycount++] = yytname[yyx];
2195 : yysize1 = yysize + yytnamerr (0, yytname[yyx]);
2196 : yysize_overflow |= (yysize1 < yysize);
2197 : yysize = yysize1;
2198 : yyfmt = yystpcpy (yyfmt, yyprefix);
2199 : yyprefix = yyor;
2200 : }
2201 :
2202 : yyf = YY_(yyformat);
2203 : yysize1 = yysize + yystrlen (yyf);
2204 : yysize_overflow |= (yysize1 < yysize);
2205 : yysize = yysize1;
2206 :
2207 : if (yysize_overflow)
2208 : return YYSIZE_MAXIMUM;
2209 :
2210 : if (yyresult)
2211 : {
2212 : /* Avoid sprintf, as that infringes on the user's name space.
2213 : Don't have undefined behavior even if the translation
2214 : produced a string with the wrong number of "%s"s. */
2215 : char *yyp = yyresult;
2216 : int yyi = 0;
2217 : while ((*yyp = *yyf) != '\0')
2218 : {
2219 : if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
2220 : {
2221 : yyp += yytnamerr (yyp, yyarg[yyi++]);
2222 : yyf += 2;
2223 : }
2224 : else
2225 : {
2226 : yyp++;
2227 : yyf++;
2228 : }
2229 : }
2230 : }
2231 : return yysize;
2232 : }
2233 : }
2234 : #endif /* YYERROR_VERBOSE */
2235 :
2236 :
2237 : /*-----------------------------------------------.
2238 : | Release the memory associated to this symbol. |
2239 : `-----------------------------------------------*/
2240 :
2241 : /*ARGSUSED*/
2242 : #if (defined __STDC__ || defined __C99__FUNC__ \
2243 : || defined __cplusplus || defined _MSC_VER)
2244 : static void
2245 810 : yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2246 : #else
2247 : static void
2248 : yydestruct (yymsg, yytype, yyvaluep)
2249 : const char *yymsg;
2250 : int yytype;
2251 : YYSTYPE *yyvaluep;
2252 : #endif
2253 : {
2254 : YYUSE (yyvaluep);
2255 :
2256 810 : if (!yymsg)
2257 0 : yymsg = "Deleting";
2258 : YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2259 :
2260 : switch (yytype)
2261 : {
2262 :
2263 : default:
2264 810 : break;
2265 : }
2266 810 : }
2267 :
2268 : /* Prevent warnings from -Wmissing-prototypes. */
2269 : #ifdef YYPARSE_PARAM
2270 : #if defined __STDC__ || defined __cplusplus
2271 : int yyparse (void *YYPARSE_PARAM);
2272 : #else
2273 : int yyparse ();
2274 : #endif
2275 : #else /* ! YYPARSE_PARAM */
2276 : #if defined __STDC__ || defined __cplusplus
2277 : int yyparse (void);
2278 : #else
2279 : int yyparse ();
2280 : #endif
2281 : #endif /* ! YYPARSE_PARAM */
2282 :
2283 :
2284 : /* The lookahead symbol. */
2285 : int yychar;
2286 :
2287 : /* The semantic value of the lookahead symbol. */
2288 : YYSTYPE yylval;
2289 :
2290 : /* Number of syntax errors so far. */
2291 : int yynerrs;
2292 :
2293 :
2294 :
2295 : /*-------------------------.
2296 : | yyparse or yypush_parse. |
2297 : `-------------------------*/
2298 :
2299 : #ifdef YYPARSE_PARAM
2300 : #if (defined __STDC__ || defined __C99__FUNC__ \
2301 : || defined __cplusplus || defined _MSC_VER)
2302 : int
2303 : yyparse (void *YYPARSE_PARAM)
2304 : #else
2305 : int
2306 : yyparse (YYPARSE_PARAM)
2307 : void *YYPARSE_PARAM;
2308 : #endif
2309 : #else /* ! YYPARSE_PARAM */
2310 : #if (defined __STDC__ || defined __C99__FUNC__ \
2311 : || defined __cplusplus || defined _MSC_VER)
2312 : int
2313 404 : yyparse (void)
2314 : #else
2315 : int
2316 : yyparse ()
2317 :
2318 : #endif
2319 : #endif
2320 : {
2321 :
2322 :
2323 : int yystate;
2324 : /* Number of tokens to shift before error messages enabled. */
2325 : int yyerrstatus;
2326 :
2327 : /* The stacks and their tools:
2328 : `yyss': related to states.
2329 : `yyvs': related to semantic values.
2330 :
2331 : Refer to the stacks thru separate pointers, to allow yyoverflow
2332 : to reallocate them elsewhere. */
2333 :
2334 : /* The state stack. */
2335 : yytype_int16 yyssa[YYINITDEPTH];
2336 : yytype_int16 *yyss;
2337 : yytype_int16 *yyssp;
2338 :
2339 : /* The semantic value stack. */
2340 : YYSTYPE yyvsa[YYINITDEPTH];
2341 : YYSTYPE *yyvs;
2342 : YYSTYPE *yyvsp;
2343 :
2344 : YYSIZE_T yystacksize;
2345 :
2346 : int yyn;
2347 : int yyresult;
2348 : /* Lookahead token as an internal (translated) token number. */
2349 : int yytoken;
2350 : /* The variables used to return semantic value and location from the
2351 : action routines. */
2352 : YYSTYPE yyval;
2353 :
2354 : #if YYERROR_VERBOSE
2355 : /* Buffer for error messages, and its allocated size. */
2356 : char yymsgbuf[128];
2357 : char *yymsg = yymsgbuf;
2358 : YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2359 : #endif
2360 :
2361 : #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2362 :
2363 : /* The number of symbols on the RHS of the reduced rule.
2364 : Keep to zero when no symbol should be popped. */
2365 404 : int yylen = 0;
2366 :
2367 404 : yytoken = 0;
2368 404 : yyss = yyssa;
2369 404 : yyvs = yyvsa;
2370 404 : yystacksize = YYINITDEPTH;
2371 :
2372 : YYDPRINTF ((stderr, "Starting parse\n"));
2373 :
2374 404 : yystate = 0;
2375 404 : yyerrstatus = 0;
2376 404 : yynerrs = 0;
2377 404 : yychar = YYEMPTY; /* Cause a token to be read. */
2378 :
2379 : /* Initialize stack pointers.
2380 : Waste one element of value and location stack
2381 : so that they stay on the same level as the state stack.
2382 : The wasted elements are never initialized. */
2383 404 : yyssp = yyss;
2384 404 : yyvsp = yyvs;
2385 :
2386 404 : goto yysetstate;
2387 :
2388 : /*------------------------------------------------------------.
2389 : | yynewstate -- Push a new state, which is found in yystate. |
2390 : `------------------------------------------------------------*/
2391 : yynewstate:
2392 : /* In all cases, when you get here, the value and location stacks
2393 : have just been pushed. So pushing a state here evens the stacks. */
2394 431944 : yyssp++;
2395 :
2396 : yysetstate:
2397 432348 : *yyssp = yystate;
2398 :
2399 432348 : if (yyss + yystacksize - 1 <= yyssp)
2400 : {
2401 : /* Get the current used size of the three stacks, in elements. */
2402 0 : YYSIZE_T yysize = yyssp - yyss + 1;
2403 :
2404 : #ifdef yyoverflow
2405 : {
2406 : /* Give user a chance to reallocate the stack. Use copies of
2407 : these so that the &'s don't force the real ones into
2408 : memory. */
2409 : YYSTYPE *yyvs1 = yyvs;
2410 : yytype_int16 *yyss1 = yyss;
2411 :
2412 : /* Each stack pointer address is followed by the size of the
2413 : data in use in that stack, in bytes. This used to be a
2414 : conditional around just the two extra args, but that might
2415 : be undefined if yyoverflow is a macro. */
2416 : yyoverflow (YY_("memory exhausted"),
2417 : &yyss1, yysize * sizeof (*yyssp),
2418 : &yyvs1, yysize * sizeof (*yyvsp),
2419 : &yystacksize);
2420 :
2421 : yyss = yyss1;
2422 : yyvs = yyvs1;
2423 : }
2424 : #else /* no yyoverflow */
2425 : # ifndef YYSTACK_RELOCATE
2426 : goto yyexhaustedlab;
2427 : # else
2428 : /* Extend the stack our own way. */
2429 0 : if (YYMAXDEPTH <= yystacksize)
2430 0 : goto yyexhaustedlab;
2431 0 : yystacksize *= 2;
2432 0 : if (YYMAXDEPTH < yystacksize)
2433 0 : yystacksize = YYMAXDEPTH;
2434 :
2435 : {
2436 0 : yytype_int16 *yyss1 = yyss;
2437 : union yyalloc *yyptr =
2438 0 : (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2439 0 : if (! yyptr)
2440 0 : goto yyexhaustedlab;
2441 0 : YYSTACK_RELOCATE (yyss_alloc, yyss);
2442 0 : YYSTACK_RELOCATE (yyvs_alloc, yyvs);
2443 : # undef YYSTACK_RELOCATE
2444 0 : if (yyss1 != yyssa)
2445 0 : YYSTACK_FREE (yyss1);
2446 : }
2447 : # endif
2448 : #endif /* no yyoverflow */
2449 :
2450 0 : yyssp = yyss + yysize - 1;
2451 0 : yyvsp = yyvs + yysize - 1;
2452 :
2453 : YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2454 : (unsigned long int) yystacksize));
2455 :
2456 0 : if (yyss + yystacksize - 1 <= yyssp)
2457 0 : YYABORT;
2458 : }
2459 :
2460 : YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2461 :
2462 432348 : if (yystate == YYFINAL)
2463 402 : YYACCEPT;
2464 :
2465 431946 : goto yybackup;
2466 :
2467 : /*-----------.
2468 : | yybackup. |
2469 : `-----------*/
2470 : yybackup:
2471 :
2472 : /* Do appropriate processing given the current state. Read a
2473 : lookahead token if we need one and don't already have one. */
2474 :
2475 : /* First try to decide what to do without reference to lookahead token. */
2476 431946 : yyn = yypact[yystate];
2477 431946 : if (yyn == YYPACT_NINF)
2478 259944 : goto yydefault;
2479 :
2480 : /* Not known => get a lookahead token if don't already have one. */
2481 :
2482 : /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
2483 172002 : if (yychar == YYEMPTY)
2484 : {
2485 : YYDPRINTF ((stderr, "Reading a token: "));
2486 171902 : yychar = YYLEX;
2487 : }
2488 :
2489 172002 : if (yychar <= YYEOF)
2490 : {
2491 402 : yychar = yytoken = YYEOF;
2492 : YYDPRINTF ((stderr, "Now at end of input.\n"));
2493 : }
2494 : else
2495 : {
2496 171600 : yytoken = YYTRANSLATE (yychar);
2497 : YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2498 : }
2499 :
2500 : /* If the proper action on seeing token YYTOKEN is to reduce or to
2501 : detect an error, take that action. */
2502 172002 : yyn += yytoken;
2503 172002 : if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2504 : goto yydefault;
2505 171900 : yyn = yytable[yyn];
2506 171900 : if (yyn <= 0)
2507 : {
2508 0 : if (yyn == 0 || yyn == YYTABLE_NINF)
2509 : goto yyerrlab;
2510 0 : yyn = -yyn;
2511 0 : goto yyreduce;
2512 : }
2513 :
2514 : /* Count tokens shifted since error; after three, turn off error
2515 : status. */
2516 171900 : if (yyerrstatus)
2517 0 : yyerrstatus--;
2518 :
2519 : /* Shift the lookahead token. */
2520 : YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2521 :
2522 : /* Discard the shifted token. */
2523 171900 : yychar = YYEMPTY;
2524 :
2525 171900 : yystate = yyn;
2526 171900 : *++yyvsp = yylval;
2527 :
2528 171900 : goto yynewstate;
2529 :
2530 :
2531 : /*-----------------------------------------------------------.
2532 : | yydefault -- do the default action for the current state. |
2533 : `-----------------------------------------------------------*/
2534 : yydefault:
2535 260046 : yyn = yydefact[yystate];
2536 260046 : if (yyn == 0)
2537 2 : goto yyerrlab;
2538 260044 : goto yyreduce;
2539 :
2540 :
2541 : /*-----------------------------.
2542 : | yyreduce -- Do a reduction. |
2543 : `-----------------------------*/
2544 : yyreduce:
2545 : /* yyn is the number of a rule to reduce with. */
2546 260044 : yylen = yyr2[yyn];
2547 :
2548 : /* If YYLEN is nonzero, implement the default value of the action:
2549 : `$$ = $1'.
2550 :
2551 : Otherwise, the following line sets YYVAL to garbage.
2552 : This behavior is undocumented and Bison
2553 : users should not rely upon it. Assigning to YYVAL
2554 : unconditionally makes the parser a bit smaller, and it avoids a
2555 : GCC warning that YYVAL may be used uninitialized. */
2556 260044 : yyval = yyvsp[1-yylen];
2557 :
2558 :
2559 : YY_REDUCE_PRINT (yyn);
2560 260044 : switch (yyn)
2561 : {
2562 : case 5:
2563 :
2564 : {
2565 402 : eq::server::Global::instance()->setConfigFAttribute(
2566 804 : eq::server::Config::FATTR_VERSION, (yyvsp[(2) - (3)]._float) );
2567 : ;}
2568 402 : break;
2569 :
2570 : case 10:
2571 :
2572 : {
2573 8 : eq::server::Global::instance()->setConnectionSAttribute(
2574 4 : eq::server::ConnectionDescription::SATTR_HOSTNAME, (yyvsp[(2) - (2)]._string) );
2575 : ;}
2576 4 : break;
2577 :
2578 : case 11:
2579 :
2580 : {
2581 2 : eq::server::Global::instance()->setConnectionIAttribute(
2582 4 : eq::server::ConnectionDescription::IATTR_TYPE, (yyvsp[(2) - (2)]._connectionType) );
2583 : ;}
2584 2 : break;
2585 :
2586 : case 12:
2587 :
2588 : {
2589 2 : eq::server::Global::instance()->setConnectionIAttribute(
2590 4 : eq::server::ConnectionDescription::IATTR_PORT, (yyvsp[(2) - (2)]._unsigned) );
2591 : ;}
2592 2 : break;
2593 :
2594 : case 13:
2595 :
2596 : {
2597 8 : eq::server::Global::instance()->setConnectionSAttribute(
2598 4 : eq::server::ConnectionDescription::SATTR_FILENAME, (yyvsp[(2) - (2)]._string) );
2599 : ;}
2600 4 : break;
2601 :
2602 : case 14:
2603 :
2604 : {
2605 0 : eq::server::Global::instance()->setConnectionIAttribute(
2606 0 : eq::server::ConnectionDescription::IATTR_BANDWIDTH, (yyvsp[(2) - (2)]._unsigned) );
2607 : ;}
2608 0 : break;
2609 :
2610 : case 15:
2611 :
2612 : {
2613 8 : eq::server::Global::instance()->setConfigFAttribute(
2614 8 : eq::server::Config::FATTR_EYE_BASE, (yyvsp[(2) - (2)]._float) );
2615 : ;}
2616 8 : break;
2617 :
2618 : case 16:
2619 :
2620 : {
2621 4 : eq::server::Global::instance()->setConfigIAttribute(
2622 4 : eq::server::Config::IATTR_ROBUSTNESS, (yyvsp[(2) - (2)]._int) );
2623 : ;}
2624 4 : break;
2625 :
2626 : case 17:
2627 :
2628 : {
2629 8 : eq::server::Global::instance()->setNodeSAttribute(
2630 4 : eq::server::Node::SATTR_LAUNCH_COMMAND, (yyvsp[(2) - (2)]._string) );
2631 : ;}
2632 4 : break;
2633 :
2634 : case 18:
2635 :
2636 : {
2637 4 : eq::server::Global::instance()->setNodeCAttribute(
2638 8 : eq::server::Node::CATTR_LAUNCH_COMMAND_QUOTE, (yyvsp[(2) - (2)]._character) );
2639 : ;}
2640 4 : break;
2641 :
2642 : case 19:
2643 :
2644 : {
2645 8 : eq::server::Global::instance()->setNodeIAttribute(
2646 8 : eq::server::Node::IATTR_THREAD_MODEL, (yyvsp[(2) - (2)]._int) );
2647 : ;}
2648 8 : break;
2649 :
2650 : case 20:
2651 :
2652 : {
2653 0 : eq::server::Global::instance()->setNodeIAttribute(
2654 0 : eq::server::Node::IATTR_HINT_AFFINITY, (yyvsp[(2) - (2)]._int) );
2655 : ;}
2656 0 : break;
2657 :
2658 : case 21:
2659 :
2660 : {
2661 4 : eq::server::Global::instance()->setNodeIAttribute(
2662 8 : eq::server::Node::IATTR_LAUNCH_TIMEOUT, (yyvsp[(2) - (2)]._unsigned) );
2663 : ;}
2664 4 : break;
2665 :
2666 : case 22:
2667 :
2668 : {
2669 0 : LBWARN << "Ignoring deprecated attribute Node::IATTR_HINT_STATISTICS"
2670 0 : << std::endl;
2671 : ;}
2672 0 : break;
2673 :
2674 : case 23:
2675 :
2676 : {
2677 6 : eq::server::Global::instance()->setPipeIAttribute(
2678 6 : eq::server::Pipe::IATTR_HINT_THREAD, (yyvsp[(2) - (2)]._int) );
2679 : ;}
2680 6 : break;
2681 :
2682 : case 24:
2683 :
2684 : {
2685 2 : eq::server::Global::instance()->setPipeIAttribute(
2686 2 : eq::server::Pipe::IATTR_HINT_AFFINITY, (yyvsp[(2) - (2)]._int) );
2687 : ;}
2688 2 : break;
2689 :
2690 : case 25:
2691 :
2692 : {
2693 0 : eq::server::Global::instance()->setWindowIAttribute(
2694 0 : eq::server::WindowSettings::IATTR_HINT_CORE_PROFILE, (yyvsp[(2) - (2)]._int) );
2695 : ;}
2696 0 : break;
2697 :
2698 : case 26:
2699 :
2700 : {
2701 0 : eq::server::Global::instance()->setWindowIAttribute(
2702 0 : eq::server::WindowSettings::IATTR_HINT_OPENGL_MAJOR, (yyvsp[(2) - (2)]._int) );
2703 : ;}
2704 0 : break;
2705 :
2706 : case 27:
2707 :
2708 : {
2709 0 : eq::server::Global::instance()->setWindowIAttribute(
2710 0 : eq::server::WindowSettings::IATTR_HINT_OPENGL_MINOR, (yyvsp[(2) - (2)]._int) );
2711 : ;}
2712 0 : break;
2713 :
2714 : case 28:
2715 :
2716 : {
2717 4 : eq::server::Global::instance()->setWindowIAttribute(
2718 4 : eq::server::WindowSettings::IATTR_HINT_STEREO, (yyvsp[(2) - (2)]._int) );
2719 : ;}
2720 4 : break;
2721 :
2722 : case 29:
2723 :
2724 : {
2725 12 : eq::server::Global::instance()->setWindowIAttribute(
2726 12 : eq::server::WindowSettings::IATTR_HINT_DOUBLEBUFFER, (yyvsp[(2) - (2)]._int) );
2727 : ;}
2728 12 : break;
2729 :
2730 : case 30:
2731 :
2732 : {
2733 86 : eq::server::Global::instance()->setWindowIAttribute(
2734 86 : eq::server::WindowSettings::IATTR_HINT_FULLSCREEN, (yyvsp[(2) - (2)]._int) );
2735 : ;}
2736 86 : break;
2737 :
2738 : case 31:
2739 :
2740 : {
2741 24 : eq::server::Global::instance()->setWindowIAttribute(
2742 24 : eq::server::WindowSettings::IATTR_HINT_DECORATION, (yyvsp[(2) - (2)]._int) );
2743 : ;}
2744 24 : break;
2745 :
2746 : case 32:
2747 :
2748 : {
2749 28 : eq::server::Global::instance()->setWindowIAttribute(
2750 28 : eq::server::WindowSettings::IATTR_HINT_SWAPSYNC, (yyvsp[(2) - (2)]._int) );
2751 : ;}
2752 28 : break;
2753 :
2754 : case 33:
2755 :
2756 : {
2757 18 : eq::server::Global::instance()->setWindowIAttribute(
2758 18 : eq::server::WindowSettings::IATTR_HINT_DRAWABLE, (yyvsp[(2) - (2)]._int) );
2759 : ;}
2760 18 : break;
2761 :
2762 : case 34:
2763 :
2764 : {
2765 12 : eq::server::Global::instance()->setWindowIAttribute(
2766 12 : eq::server::WindowSettings::IATTR_HINT_STATISTICS, (yyvsp[(2) - (2)]._int) );
2767 : ;}
2768 12 : break;
2769 :
2770 : case 35:
2771 :
2772 : {
2773 0 : eq::server::Global::instance()->setWindowIAttribute(
2774 0 : eq::server::WindowSettings::IATTR_HINT_SCREENSAVER, (yyvsp[(2) - (2)]._int) );
2775 : ;}
2776 0 : break;
2777 :
2778 : case 36:
2779 :
2780 : {
2781 4 : eq::server::Global::instance()->setWindowIAttribute(
2782 4 : eq::server::WindowSettings::IATTR_HINT_GRAB_POINTER, (yyvsp[(2) - (2)]._int) );
2783 : ;}
2784 4 : break;
2785 :
2786 : case 37:
2787 :
2788 : {
2789 0 : eq::server::Global::instance()->setWindowIAttribute(
2790 0 : eq::server::WindowSettings::IATTR_HINT_HEIGHT, (yyvsp[(2) - (2)]._int) );
2791 : ;}
2792 0 : break;
2793 :
2794 : case 38:
2795 :
2796 : {
2797 0 : eq::server::Global::instance()->setWindowIAttribute(
2798 0 : eq::server::WindowSettings::IATTR_HINT_WIDTH, (yyvsp[(2) - (2)]._int) );
2799 : ;}
2800 0 : break;
2801 :
2802 : case 39:
2803 :
2804 : {
2805 4 : eq::server::Global::instance()->setWindowIAttribute(
2806 4 : eq::server::WindowSettings::IATTR_PLANES_COLOR, (yyvsp[(2) - (2)]._int) );
2807 : ;}
2808 4 : break;
2809 :
2810 : case 40:
2811 :
2812 : {
2813 4 : eq::server::Global::instance()->setWindowIAttribute(
2814 4 : eq::server::WindowSettings::IATTR_PLANES_ALPHA, (yyvsp[(2) - (2)]._int) );
2815 : ;}
2816 4 : break;
2817 :
2818 : case 41:
2819 :
2820 : {
2821 4 : eq::server::Global::instance()->setWindowIAttribute(
2822 4 : eq::server::WindowSettings::IATTR_PLANES_DEPTH, (yyvsp[(2) - (2)]._int) );
2823 : ;}
2824 4 : break;
2825 :
2826 : case 42:
2827 :
2828 : {
2829 100 : eq::server::Global::instance()->setWindowIAttribute(
2830 100 : eq::server::WindowSettings::IATTR_PLANES_STENCIL, (yyvsp[(2) - (2)]._int) );
2831 : ;}
2832 100 : break;
2833 :
2834 : case 43:
2835 :
2836 : {
2837 4 : eq::server::Global::instance()->setWindowIAttribute(
2838 4 : eq::server::WindowSettings::IATTR_PLANES_ACCUM, (yyvsp[(2) - (2)]._int) );
2839 : ;}
2840 4 : break;
2841 :
2842 : case 44:
2843 :
2844 : {
2845 4 : eq::server::Global::instance()->setWindowIAttribute(
2846 4 : eq::server::WindowSettings::IATTR_PLANES_ACCUM_ALPHA, (yyvsp[(2) - (2)]._int) );
2847 : ;}
2848 4 : break;
2849 :
2850 : case 45:
2851 :
2852 : {
2853 8 : eq::server::Global::instance()->setWindowIAttribute(
2854 8 : eq::server::WindowSettings::IATTR_PLANES_SAMPLES, (yyvsp[(2) - (2)]._int) );
2855 : ;}
2856 8 : break;
2857 :
2858 : case 46:
2859 :
2860 : {
2861 6 : eq::server::Global::instance()->setChannelIAttribute(
2862 6 : eq::server::Channel::IATTR_HINT_STATISTICS, (yyvsp[(2) - (2)]._int) );
2863 : ;}
2864 6 : break;
2865 :
2866 : case 47:
2867 :
2868 : {
2869 0 : eq::server::Global::instance()->setChannelIAttribute(
2870 0 : eq::server::Channel::IATTR_HINT_SENDTOKEN, (yyvsp[(2) - (2)]._int) );
2871 : ;}
2872 0 : break;
2873 :
2874 : case 48:
2875 :
2876 : {
2877 12 : eq::server::Global::instance()->setCompoundIAttribute(
2878 12 : eq::server::Compound::IATTR_STEREO_MODE, (yyvsp[(2) - (2)]._int) );
2879 : ;}
2880 12 : break;
2881 :
2882 : case 49:
2883 :
2884 : {
2885 4 : eq::server::Global::instance()->setCompoundIAttribute(
2886 8 : eq::server::Compound::IATTR_STEREO_ANAGLYPH_LEFT_MASK, (yyvsp[(2) - (2)]._unsigned) );
2887 : ;}
2888 4 : break;
2889 :
2890 : case 50:
2891 :
2892 : {
2893 4 : eq::server::Global::instance()->setCompoundIAttribute(
2894 8 : eq::server::Compound::IATTR_STEREO_ANAGLYPH_RIGHT_MASK, (yyvsp[(2) - (2)]._unsigned) );
2895 : ;}
2896 4 : break;
2897 :
2898 : case 51:
2899 :
2900 : {
2901 0 : LBWARN << "ignoring removed attribute EQ_COMPOUND_IATTR_UPDATE_FOV"
2902 0 : << std::endl;
2903 : ;}
2904 0 : break;
2905 :
2906 : case 52:
2907 :
2908 : {
2909 8 : eq::server::Global::instance()->setChannelSAttribute(
2910 4 : eq::server::Channel::SATTR_DUMP_IMAGE, (yyvsp[(2) - (2)]._string) );
2911 : ;}
2912 4 : break;
2913 :
2914 : case 53:
2915 :
2916 : {
2917 0 : eq::server::Global::instance()->setViewSAttribute(
2918 0 : eq::server::View::SATTR_DEFLECT_HOST, (yyvsp[(2) - (2)]._string) );
2919 : ;}
2920 0 : break;
2921 :
2922 : case 54:
2923 :
2924 450 : { (yyval._connectionType) = co::CONNECTIONTYPE_TCPIP; ;}
2925 450 : break;
2926 :
2927 : case 55:
2928 :
2929 0 : { (yyval._connectionType) = co::CONNECTIONTYPE_NAMEDPIPE; ;}
2930 0 : break;
2931 :
2932 : case 56:
2933 :
2934 64 : { (yyval._connectionType) = co::CONNECTIONTYPE_RSP; ;}
2935 64 : break;
2936 :
2937 : case 57:
2938 :
2939 0 : { (yyval._connectionType) = co::CONNECTIONTYPE_RDMA; ;}
2940 0 : break;
2941 :
2942 : case 58:
2943 :
2944 0 : { (yyval._connectionType) = co::CONNECTIONTYPE_UDT; ;}
2945 0 : break;
2946 :
2947 : case 59:
2948 :
2949 402 : { server = new eq::server::Server(); ;}
2950 402 : break;
2951 :
2952 : case 63:
2953 :
2954 : {
2955 374 : connectionDescription = new eq::server::ConnectionDescription;
2956 374 : connectionDescription->setHostname( "" );
2957 374 : connectionDescription->port = 0; // OS chosen port
2958 : ;}
2959 374 : break;
2960 :
2961 : case 64:
2962 :
2963 : {
2964 374 : server->addConnectionDescription( connectionDescription.get( ));
2965 374 : connectionDescription = 0;
2966 : ;}
2967 374 : break;
2968 :
2969 : case 67:
2970 :
2971 : {
2972 402 : config = new eq::server::Config( server );
2973 402 : config->setName( filename );
2974 402 : node = new eq::server::Node( config );
2975 402 : node->setApplicationNode( true );
2976 : ;}
2977 402 : break;
2978 :
2979 : case 68:
2980 :
2981 402 : { config = 0; ;}
2982 402 : break;
2983 :
2984 : case 72:
2985 :
2986 200 : { config->setName( (yyvsp[(2) - (2)]._string) ); ;}
2987 200 : break;
2988 :
2989 : case 77:
2990 :
2991 38 : { config->setLatency( (yyvsp[(2) - (2)]._unsigned) ); ;}
2992 38 : break;
2993 :
2994 : case 81:
2995 :
2996 202 : { config->setFAttribute(
2997 202 : eq::server::Config::FATTR_EYE_BASE, (yyvsp[(2) - (2)]._float) ); ;}
2998 202 : break;
2999 :
3000 : case 82:
3001 :
3002 202 : { config->setIAttribute(
3003 202 : eq::server::Config::IATTR_ROBUSTNESS, (yyvsp[(2) - (2)]._int) ); ;}
3004 202 : break;
3005 :
3006 : case 85:
3007 :
3008 : {
3009 424 : node = new eq::server::Node( config );
3010 : ;}
3011 424 : break;
3012 :
3013 : case 86:
3014 :
3015 424 : { node = 0; ;}
3016 424 : break;
3017 :
3018 : case 87:
3019 :
3020 : {
3021 394 : node = config->findApplicationNode();
3022 394 : LBASSERT( node );
3023 : ;}
3024 394 : break;
3025 :
3026 : case 88:
3027 :
3028 394 : { node = 0; ;}
3029 394 : break;
3030 :
3031 : case 91:
3032 :
3033 36 : { node->setName( (yyvsp[(2) - (2)]._string) ); ;}
3034 36 : break;
3035 :
3036 : case 92:
3037 :
3038 250 : { node->setHost( (yyvsp[(2) - (2)]._string) ); ;}
3039 250 : break;
3040 :
3041 : case 96:
3042 :
3043 588 : { connectionDescription = new eq::server::ConnectionDescription; ;}
3044 588 : break;
3045 :
3046 : case 97:
3047 :
3048 : {
3049 588 : node->addConnectionDescription( connectionDescription );
3050 588 : connectionDescription = 0;
3051 : ;}
3052 588 : break;
3053 :
3054 : case 100:
3055 :
3056 512 : { connectionDescription->type = (yyvsp[(2) - (2)]._connectionType); ;}
3057 512 : break;
3058 :
3059 : case 101:
3060 :
3061 962 : { connectionDescription->setHostname((yyvsp[(2) - (2)]._string)); ;}
3062 962 : break;
3063 :
3064 : case 102:
3065 :
3066 0 : { connectionDescription->setInterface((yyvsp[(2) - (2)]._string)); ;}
3067 0 : break;
3068 :
3069 : case 103:
3070 :
3071 4 : { connectionDescription->port = (yyvsp[(2) - (2)]._unsigned); ;}
3072 4 : break;
3073 :
3074 : case 104:
3075 :
3076 0 : { connectionDescription->bandwidth = (yyvsp[(2) - (2)]._unsigned); ;}
3077 0 : break;
3078 :
3079 : case 105:
3080 :
3081 480 : { connectionDescription->setFilename((yyvsp[(2) - (2)]._string)); ;}
3082 480 : break;
3083 :
3084 : case 108:
3085 :
3086 0 : { node->setSAttribute( eq::server::Node::SATTR_LAUNCH_COMMAND, (yyvsp[(2) - (2)]._string) ); ;}
3087 0 : break;
3088 :
3089 : case 109:
3090 :
3091 0 : { node->setCAttribute( eq::server::Node::CATTR_LAUNCH_COMMAND_QUOTE,
3092 0 : (yyvsp[(2) - (2)]._character) ); ;}
3093 0 : break;
3094 :
3095 : case 110:
3096 :
3097 0 : { node->setIAttribute( eq::server::Node::IATTR_THREAD_MODEL, (yyvsp[(2) - (2)]._int) ); ;}
3098 0 : break;
3099 :
3100 : case 111:
3101 :
3102 0 : { node->setIAttribute( eq::server::Node::IATTR_LAUNCH_TIMEOUT, (yyvsp[(2) - (2)]._int) ); ;}
3103 0 : break;
3104 :
3105 : case 112:
3106 :
3107 : {
3108 0 : LBWARN
3109 0 : << "Ignoring deprecated attribute Node::IATTR_HINT_STATISTICS"
3110 0 : << std::endl;
3111 : ;}
3112 0 : break;
3113 :
3114 : case 113:
3115 :
3116 0 : { node->setIAttribute( eq::server::Node::IATTR_HINT_AFFINITY, (yyvsp[(2) - (2)]._int) ); ;}
3117 0 : break;
3118 :
3119 : case 114:
3120 :
3121 : {
3122 1146 : eqPipe = new eq::server::Pipe( node );
3123 : ;}
3124 1146 : break;
3125 :
3126 : case 115:
3127 :
3128 1146 : { eqPipe = 0; ;}
3129 1146 : break;
3130 :
3131 : case 120:
3132 :
3133 164 : { eqPipe->setName( (yyvsp[(2) - (2)]._string) ); ;}
3134 164 : break;
3135 :
3136 : case 121:
3137 :
3138 0 : { eqPipe->setPort( (yyvsp[(2) - (2)]._unsigned) ); ;}
3139 0 : break;
3140 :
3141 : case 122:
3142 :
3143 124 : { eqPipe->setDevice( (yyvsp[(2) - (2)]._unsigned) ); ;}
3144 124 : break;
3145 :
3146 : case 123:
3147 :
3148 : {
3149 0 : eqPipe->setPixelViewport( eq::fabric::PixelViewport
3150 0 : ( (int)(yyvsp[(2) - (2)]._viewport)[0], (int)(yyvsp[(2) - (2)]._viewport)[1], (int)(yyvsp[(2) - (2)]._viewport)[2], (int)(yyvsp[(2) - (2)]._viewport)[3] ));
3151 : ;}
3152 0 : break;
3153 :
3154 : case 126:
3155 :
3156 20 : { eqPipe->setIAttribute( eq::server::Pipe::IATTR_HINT_THREAD, (yyvsp[(2) - (2)]._int) ); ;}
3157 20 : break;
3158 :
3159 : case 127:
3160 :
3161 0 : { eqPipe->setIAttribute( eq::server::Pipe::IATTR_HINT_AFFINITY, (yyvsp[(2) - (2)]._int)); ;}
3162 0 : break;
3163 :
3164 : case 128:
3165 :
3166 : {
3167 1490 : window = new eq::server::Window( eqPipe );
3168 1490 : window->init(); // not in ctor, virtual method
3169 : ;}
3170 1490 : break;
3171 :
3172 : case 129:
3173 :
3174 1490 : { window = 0; ;}
3175 1490 : break;
3176 :
3177 : case 134:
3178 :
3179 540 : { window->setName( (yyvsp[(2) - (2)]._string) ); ;}
3180 540 : break;
3181 :
3182 : case 135:
3183 :
3184 : {
3185 1292 : if( (yyvsp[(2) - (2)]._viewport)[2] > 1 || (yyvsp[(2) - (2)]._viewport)[3] > 1 )
3186 3460 : window->setPixelViewport( eq::fabric::PixelViewport
3187 4152 : ( (int)(yyvsp[(2) - (2)]._viewport)[0], (int)(yyvsp[(2) - (2)]._viewport)[1], (int)(yyvsp[(2) - (2)]._viewport)[2], (int)(yyvsp[(2) - (2)]._viewport)[3] ));
3188 : else
3189 1200 : window->setViewport( eq::fabric::Viewport((yyvsp[(2) - (2)]._viewport)[0], (yyvsp[(2) - (2)]._viewport)[1],
3190 600 : (yyvsp[(2) - (2)]._viewport)[2], (yyvsp[(2) - (2)]._viewport)[3]));
3191 : ;}
3192 1292 : break;
3193 :
3194 : case 138:
3195 :
3196 0 : { window->setIAttribute( eq::server::WindowSettings::IATTR_HINT_CORE_PROFILE, (yyvsp[(2) - (2)]._int) ); ;}
3197 0 : break;
3198 :
3199 : case 139:
3200 :
3201 0 : { window->setIAttribute( eq::server::WindowSettings::IATTR_HINT_OPENGL_MAJOR, (yyvsp[(2) - (2)]._int) ); ;}
3202 0 : break;
3203 :
3204 : case 140:
3205 :
3206 0 : { window->setIAttribute( eq::server::WindowSettings::IATTR_HINT_OPENGL_MINOR, (yyvsp[(2) - (2)]._int) ); ;}
3207 0 : break;
3208 :
3209 : case 141:
3210 :
3211 4 : { window->setIAttribute( eq::server::WindowSettings::IATTR_HINT_STEREO, (yyvsp[(2) - (2)]._int) ); ;}
3212 4 : break;
3213 :
3214 : case 142:
3215 :
3216 12 : { window->setIAttribute( eq::server::WindowSettings::IATTR_HINT_DOUBLEBUFFER, (yyvsp[(2) - (2)]._int) ); ;}
3217 12 : break;
3218 :
3219 : case 143:
3220 :
3221 76 : { window->setIAttribute( eq::server::WindowSettings::IATTR_HINT_FULLSCREEN, (yyvsp[(2) - (2)]._int) ); ;}
3222 76 : break;
3223 :
3224 : case 144:
3225 :
3226 14 : { window->setIAttribute( eq::server::WindowSettings::IATTR_HINT_DECORATION, (yyvsp[(2) - (2)]._int) ); ;}
3227 14 : break;
3228 :
3229 : case 145:
3230 :
3231 38 : { window->setIAttribute( eq::server::WindowSettings::IATTR_HINT_SWAPSYNC, (yyvsp[(2) - (2)]._int) ); ;}
3232 38 : break;
3233 :
3234 : case 146:
3235 :
3236 70 : { window->setIAttribute( eq::server::WindowSettings::IATTR_HINT_DRAWABLE, (yyvsp[(2) - (2)]._int) ); ;}
3237 70 : break;
3238 :
3239 : case 147:
3240 :
3241 8 : { window->setIAttribute( eq::server::WindowSettings::IATTR_HINT_STATISTICS, (yyvsp[(2) - (2)]._int) ); ;}
3242 8 : break;
3243 :
3244 : case 148:
3245 :
3246 0 : { window->setIAttribute( eq::server::WindowSettings::IATTR_HINT_SCREENSAVER, (yyvsp[(2) - (2)]._int) ); ;}
3247 0 : break;
3248 :
3249 : case 149:
3250 :
3251 2 : { window->setIAttribute( eq::server::WindowSettings::IATTR_HINT_GRAB_POINTER, (yyvsp[(2) - (2)]._int) ); ;}
3252 2 : break;
3253 :
3254 : case 150:
3255 :
3256 16 : { window->setIAttribute( eq::server::WindowSettings::IATTR_PLANES_COLOR, (yyvsp[(2) - (2)]._int) ); ;}
3257 16 : break;
3258 :
3259 : case 151:
3260 :
3261 4 : { window->setIAttribute( eq::server::WindowSettings::IATTR_PLANES_ALPHA, (yyvsp[(2) - (2)]._int) ); ;}
3262 4 : break;
3263 :
3264 : case 152:
3265 :
3266 8 : { window->setIAttribute( eq::server::WindowSettings::IATTR_PLANES_DEPTH, (yyvsp[(2) - (2)]._int) ); ;}
3267 8 : break;
3268 :
3269 : case 153:
3270 :
3271 54 : { window->setIAttribute( eq::server::WindowSettings::IATTR_PLANES_STENCIL, (yyvsp[(2) - (2)]._int) ); ;}
3272 54 : break;
3273 :
3274 : case 154:
3275 :
3276 2 : { window->setIAttribute( eq::server::WindowSettings::IATTR_PLANES_ACCUM, (yyvsp[(2) - (2)]._int) ); ;}
3277 2 : break;
3278 :
3279 : case 155:
3280 :
3281 2 : { window->setIAttribute( eq::server::WindowSettings::IATTR_PLANES_ACCUM_ALPHA, (yyvsp[(2) - (2)]._int) ); ;}
3282 2 : break;
3283 :
3284 : case 156:
3285 :
3286 8 : { window->setIAttribute( eq::server::WindowSettings::IATTR_PLANES_SAMPLES, (yyvsp[(2) - (2)]._int) ); ;}
3287 8 : break;
3288 :
3289 : case 157:
3290 :
3291 : {
3292 1646 : channel = new eq::server::Channel( window );
3293 1646 : channel->init(); // not in ctor, virtual method
3294 : ;}
3295 1646 : break;
3296 :
3297 : case 158:
3298 :
3299 1646 : { channel = 0; ;}
3300 1646 : break;
3301 :
3302 : case 161:
3303 :
3304 1646 : { channel->setName( (yyvsp[(2) - (2)]._string) ); ;}
3305 1646 : break;
3306 :
3307 : case 163:
3308 :
3309 : {
3310 1278 : if( (yyvsp[(2) - (2)]._viewport)[2] > 1 || (yyvsp[(2) - (2)]._viewport)[3] > 1 )
3311 1900 : channel->setPixelViewport( eq::fabric::PixelViewport
3312 2280 : ( (int)(yyvsp[(2) - (2)]._viewport)[0], (int)(yyvsp[(2) - (2)]._viewport)[1], (int)(yyvsp[(2) - (2)]._viewport)[2], (int)(yyvsp[(2) - (2)]._viewport)[3] ));
3313 : else
3314 1796 : channel->setViewport(eq::fabric::Viewport( (yyvsp[(2) - (2)]._viewport)[0], (yyvsp[(2) - (2)]._viewport)[1],
3315 898 : (yyvsp[(2) - (2)]._viewport)[2], (yyvsp[(2) - (2)]._viewport)[3]));
3316 : ;}
3317 1278 : break;
3318 :
3319 : case 166:
3320 :
3321 0 : { channel->setIAttribute( eq::server::Channel::IATTR_HINT_STATISTICS,
3322 0 : (yyvsp[(2) - (2)]._int) ); ;}
3323 0 : break;
3324 :
3325 : case 167:
3326 :
3327 0 : { channel->setIAttribute( eq::server::Channel::IATTR_HINT_SENDTOKEN,
3328 0 : (yyvsp[(2) - (2)]._int) ); ;}
3329 0 : break;
3330 :
3331 : case 168:
3332 :
3333 4 : { channel->setSAttribute( eq::server::Channel::SATTR_DUMP_IMAGE,
3334 2 : (yyvsp[(2) - (2)]._string) ); ;}
3335 2 : break;
3336 :
3337 : case 169:
3338 :
3339 394 : { observer = new eq::server::Observer( config );;}
3340 394 : break;
3341 :
3342 : case 170:
3343 :
3344 394 : { observer = 0; ;}
3345 394 : break;
3346 :
3347 : case 173:
3348 :
3349 8 : { observer->setName( (yyvsp[(2) - (2)]._string) ); ;}
3350 8 : break;
3351 :
3352 : case 174:
3353 :
3354 : {
3355 0 : const float eyeBase_2 = (yyvsp[(2) - (2)]._float) * .5f;
3356 0 : observer->setEyePosition( eq::fabric::EYE_LEFT,
3357 0 : eq::fabric::Vector3f( -eyeBase_2, 0.f, 0.f ));
3358 0 : observer->setEyePosition( eq::fabric::EYE_CYCLOP,
3359 0 : eq::fabric::Vector3f( ));
3360 0 : observer->setEyePosition( eq::fabric::EYE_RIGHT,
3361 0 : eq::fabric::Vector3f( eyeBase_2, 0.f, 0.f ));
3362 : ;}
3363 0 : break;
3364 :
3365 : case 175:
3366 :
3367 : {
3368 202 : observer->setEyePosition( eq::fabric::EYE_LEFT,
3369 404 : eq::fabric::Vector3f( (yyvsp[(3) - (6)]._float), (yyvsp[(4) - (6)]._float), (yyvsp[(5) - (6)]._float) ));
3370 : ;}
3371 202 : break;
3372 :
3373 : case 176:
3374 :
3375 : {
3376 202 : observer->setEyePosition( eq::fabric::EYE_CYCLOP,
3377 404 : eq::fabric::Vector3f( (yyvsp[(3) - (6)]._float), (yyvsp[(4) - (6)]._float), (yyvsp[(5) - (6)]._float) ));
3378 : ;}
3379 202 : break;
3380 :
3381 : case 177:
3382 :
3383 : {
3384 202 : observer->setEyePosition( eq::fabric::EYE_RIGHT,
3385 404 : eq::fabric::Vector3f( (yyvsp[(3) - (6)]._float), (yyvsp[(4) - (6)]._float), (yyvsp[(5) - (6)]._float) ));
3386 : ;}
3387 202 : break;
3388 :
3389 : case 178:
3390 :
3391 204 : { observer->setFocusDistance( (yyvsp[(2) - (2)]._float) ); ;}
3392 204 : break;
3393 :
3394 : case 179:
3395 :
3396 204 : { observer->setFocusMode( eq::fabric::FocusMode( (yyvsp[(2) - (2)]._int) )); ;}
3397 204 : break;
3398 :
3399 : case 180:
3400 :
3401 202 : { observer->setOpenCVCamera( (yyvsp[(2) - (2)]._int) ); ;}
3402 202 : break;
3403 :
3404 : case 181:
3405 :
3406 0 : { observer->setVRPNTracker( (yyvsp[(2) - (2)]._string) ); ;}
3407 0 : break;
3408 :
3409 : case 182:
3410 :
3411 630 : { layout = new eq::server::Layout( config ); ;}
3412 630 : break;
3413 :
3414 : case 183:
3415 :
3416 630 : { layout = 0; ;}
3417 630 : break;
3418 :
3419 : case 186:
3420 :
3421 304 : { layout->setName( (yyvsp[(2) - (2)]._string) ); ;}
3422 304 : break;
3423 :
3424 : case 188:
3425 :
3426 698 : { view = new eq::server::View( layout ); ;}
3427 698 : break;
3428 :
3429 : case 189:
3430 :
3431 698 : { view = 0; ;}
3432 698 : break;
3433 :
3434 : case 193:
3435 :
3436 4 : { view->setName( (yyvsp[(2) - (2)]._string) ); ;}
3437 4 : break;
3438 :
3439 : case 194:
3440 :
3441 88 : { view->changeMode( eq::server::View::MODE_MONO ); ;}
3442 88 : break;
3443 :
3444 : case 196:
3445 :
3446 472 : { view->setViewport( eq::fabric::Viewport( (yyvsp[(2) - (2)]._viewport)[0], (yyvsp[(2) - (2)]._viewport)[1],
3447 236 : (yyvsp[(2) - (2)]._viewport)[2], (yyvsp[(2) - (2)]._viewport)[3] ));;}
3448 236 : break;
3449 :
3450 : case 197:
3451 :
3452 232 : { view->setWall( wall ); ;}
3453 232 : break;
3454 :
3455 : case 198:
3456 :
3457 0 : { view->setProjection( projection ); ;}
3458 0 : break;
3459 :
3460 : case 199:
3461 :
3462 : {
3463 348 : eq::server::Observer* ob = config->find< eq::server::Observer >( (yyvsp[(2) - (2)]._string) );
3464 348 : if( ob )
3465 348 : view->setObserver( ob );
3466 : else
3467 : {
3468 0 : yyerror( "No observer of the given name" );
3469 0 : YYERROR;
3470 : }
3471 : ;}
3472 348 : break;
3473 :
3474 : case 200:
3475 :
3476 : {
3477 300 : const eq::server::ObserverPath path( (yyvsp[(2) - (2)]._unsigned) );
3478 300 : eq::server::Observer* ob = config->getObserver( path );
3479 300 : if( ob )
3480 300 : view->setObserver( ob );
3481 : else
3482 : {
3483 0 : yyerror( "No observer of the given index" );
3484 0 : YYERROR;
3485 : }
3486 : ;}
3487 300 : break;
3488 :
3489 : case 201:
3490 :
3491 0 : { view->changeMode( eq::server::View::MODE_MONO ); ;}
3492 0 : break;
3493 :
3494 : case 202:
3495 :
3496 88 : { view->changeMode( eq::server::View::MODE_STEREO ); ;}
3497 88 : break;
3498 :
3499 : case 205:
3500 :
3501 : {
3502 2 : view->setSAttribute( eq::server::View::SATTR_DEFLECT_HOST, (yyvsp[(2) - (2)]._string) );
3503 : ;}
3504 2 : break;
3505 :
3506 : case 206:
3507 :
3508 418 : { canvas = new eq::server::Canvas( config ); ;}
3509 418 : break;
3510 :
3511 : case 207:
3512 :
3513 418 : { config->activateCanvas( canvas ); canvas = 0; ;}
3514 418 : break;
3515 :
3516 : case 210:
3517 :
3518 12 : { canvas->setName( (yyvsp[(2) - (2)]._string) ); ;}
3519 12 : break;
3520 :
3521 : case 211:
3522 :
3523 : {
3524 472 : eq::server::Layout* l = config->find< eq::server::Layout >( (yyvsp[(2) - (2)]._string) );
3525 472 : if( l )
3526 472 : canvas->addLayout( l );
3527 : else
3528 : {
3529 0 : yyerror( "No layout of the given name" );
3530 0 : YYERROR;
3531 : }
3532 : ;}
3533 472 : break;
3534 :
3535 : case 212:
3536 :
3537 8 : { canvas->setSwapBarrier( swapBarrier ); swapBarrier = 0; ;}
3538 8 : break;
3539 :
3540 : case 213:
3541 :
3542 : {
3543 166 : const eq::server::LayoutPath path( (yyvsp[(2) - (2)]._unsigned) );
3544 166 : eq::server::Layout* l = config->getLayout( path );
3545 166 : if( l )
3546 166 : canvas->addLayout( l );
3547 : else
3548 : {
3549 0 : yyerror( "No layout of the given index" );
3550 0 : YYERROR;
3551 : }
3552 : ;}
3553 166 : break;
3554 :
3555 : case 214:
3556 :
3557 : {
3558 4 : canvas->addLayout( 0 );
3559 : ;}
3560 4 : break;
3561 :
3562 : case 215:
3563 :
3564 394 : { canvas->setWall( wall ); ;}
3565 394 : break;
3566 :
3567 : case 216:
3568 :
3569 0 : { canvas->setProjection( projection ); ;}
3570 0 : break;
3571 :
3572 : case 218:
3573 :
3574 790 : { segment = new eq::server::Segment( canvas ); ;}
3575 790 : break;
3576 :
3577 : case 222:
3578 :
3579 0 : { segment->setName( (yyvsp[(2) - (2)]._string) ); ;}
3580 0 : break;
3581 :
3582 : case 223:
3583 :
3584 : {
3585 790 : eq::server::Channel* ch = config->find< eq::server::Channel >( (yyvsp[(2) - (2)]._string) );
3586 790 : if( ch )
3587 790 : segment->setChannel( ch );
3588 : else
3589 : {
3590 0 : yyerror( "No channel of the given name" );
3591 0 : YYERROR;
3592 : }
3593 : ;}
3594 790 : break;
3595 :
3596 : case 224:
3597 :
3598 108 : { segment->setEyes( eq::fabric::EYE_UNDEFINED );;}
3599 108 : break;
3600 :
3601 : case 226:
3602 :
3603 608 : { segment->setViewport( eq::fabric::Viewport( (yyvsp[(2) - (2)]._viewport)[0], (yyvsp[(2) - (2)]._viewport)[1],
3604 304 : (yyvsp[(2) - (2)]._viewport)[2], (yyvsp[(2) - (2)]._viewport)[3] ));;}
3605 304 : break;
3606 :
3607 : case 227:
3608 :
3609 0 : { segment->setSwapBarrier( swapBarrier ); swapBarrier = 0; ;}
3610 0 : break;
3611 :
3612 : case 228:
3613 :
3614 256 : { segment->setWall( wall ); ;}
3615 256 : break;
3616 :
3617 : case 229:
3618 :
3619 68 : { segment->setProjection( projection ); ;}
3620 68 : break;
3621 :
3622 : case 232:
3623 :
3624 96 : { segment->enableEye( eq::fabric::EYE_CYCLOP ); ;}
3625 96 : break;
3626 :
3627 : case 233:
3628 :
3629 52 : { segment->enableEye( eq::fabric::EYE_LEFT ); ;}
3630 52 : break;
3631 :
3632 : case 234:
3633 :
3634 52 : { segment->enableEye( eq::fabric::EYE_RIGHT ); ;}
3635 52 : break;
3636 :
3637 : case 235:
3638 :
3639 : {
3640 3828 : if( eqCompound )
3641 3242 : eqCompound = new eq::server::Compound( eqCompound );
3642 : else
3643 586 : eqCompound = new eq::server::Compound( config );
3644 : ;}
3645 3828 : break;
3646 :
3647 : case 236:
3648 :
3649 3828 : { eqCompound = eqCompound->getParent(); ;}
3650 3828 : break;
3651 :
3652 : case 240:
3653 :
3654 16 : { eqCompound->setName( (yyvsp[(2) - (2)]._string) ); ;}
3655 16 : break;
3656 :
3657 : case 241:
3658 :
3659 : {
3660 1668 : eq::server::Channel* ch = config->find< eq::server::Channel >( (yyvsp[(2) - (2)]._string) );
3661 1668 : if( ch )
3662 1668 : eqCompound->setChannel( ch );
3663 : else
3664 : {
3665 0 : yyerror( "No channel of the given name" );
3666 0 : YYERROR;
3667 : }
3668 : ;}
3669 1668 : break;
3670 :
3671 : case 242:
3672 :
3673 : {
3674 1040 : if( !segment || !view )
3675 : {
3676 0 : yyerror( "Incomplete channel reference (view or segment missing)" );
3677 0 : YYERROR;
3678 : }
3679 : else
3680 : {
3681 1040 : eq::server::Channel* ch = config->findChannel( segment, view );
3682 1040 : if( ch )
3683 1040 : eqCompound->setChannel( ch );
3684 : else
3685 : {
3686 0 : yyerror( "No channel for the given view and segment" );
3687 0 : YYERROR;
3688 : }
3689 : }
3690 :
3691 1040 : canvas = 0;
3692 1040 : segment = 0;
3693 1040 : layout = 0;
3694 1040 : view = 0;
3695 : ;}
3696 1040 : break;
3697 :
3698 : case 243:
3699 :
3700 368 : { eqCompound->setTasks( eq::fabric::TASK_NONE ); ;}
3701 368 : break;
3702 :
3703 : case 245:
3704 :
3705 200 : { eqCompound->setEyes( eq::fabric::EYE_UNDEFINED );;}
3706 200 : break;
3707 :
3708 : case 247:
3709 :
3710 188 : { buffers = eq::fabric::Frame::Buffer::none; ;}
3711 188 : break;
3712 :
3713 : case 248:
3714 :
3715 188 : { eqCompound->setBuffers( buffers );
3716 188 : buffers = eq::fabric::Frame::Buffer::none; ;}
3717 188 : break;
3718 :
3719 : case 249:
3720 :
3721 496 : { eqCompound->setViewport( eq::fabric::Viewport( (yyvsp[(2) - (2)]._viewport)[0], (yyvsp[(2) - (2)]._viewport)[1],
3722 248 : (yyvsp[(2) - (2)]._viewport)[2], (yyvsp[(2) - (2)]._viewport)[3] ));;}
3723 248 : break;
3724 :
3725 : case 250:
3726 :
3727 692 : { eqCompound->setRange( eq::fabric::Range( (yyvsp[(3) - (5)]._float), (yyvsp[(4) - (5)]._float) )); ;}
3728 692 : break;
3729 :
3730 : case 251:
3731 :
3732 68 : { eqCompound->setPeriod( (yyvsp[(2) - (2)]._unsigned) ); ;}
3733 68 : break;
3734 :
3735 : case 252:
3736 :
3737 68 : { eqCompound->setPhase( (yyvsp[(2) - (2)]._unsigned) ); ;}
3738 68 : break;
3739 :
3740 : case 253:
3741 :
3742 4 : { eqCompound->setZoom( eq::fabric::Zoom( (yyvsp[(3) - (5)]._float), (yyvsp[(4) - (5)]._float) )); ;}
3743 4 : break;
3744 :
3745 : case 254:
3746 :
3747 92 : { eqCompound->setPixel( eq::fabric::Pixel( (yyvsp[(3) - (7)]._unsigned), (yyvsp[(4) - (7)]._unsigned), (yyvsp[(5) - (7)]._unsigned), (yyvsp[(6) - (7)]._unsigned) )); ;}
3748 92 : break;
3749 :
3750 : case 255:
3751 :
3752 44 : { eqCompound->setSubPixel( eq::fabric::SubPixel( (yyvsp[(3) - (5)]._unsigned), (yyvsp[(4) - (5)]._unsigned) )); ;}
3753 44 : break;
3754 :
3755 : case 256:
3756 :
3757 56 : { eqCompound->setWall( wall ); ;}
3758 56 : break;
3759 :
3760 : case 257:
3761 :
3762 0 : { eqCompound->setProjection( projection ); ;}
3763 0 : break;
3764 :
3765 : case 259:
3766 :
3767 428 : { eqCompound->setSwapBarrier(swapBarrier); swapBarrier = 0; ;}
3768 428 : break;
3769 :
3770 : case 265:
3771 :
3772 : {
3773 1040 : canvas = 0;
3774 1040 : segment = config->getSegment( eq::server::SegmentPath( 0 ));
3775 1040 : layout = 0;
3776 1040 : view = config->getView( eq::server::ViewPath( 0 ));;
3777 : ;}
3778 1040 : break;
3779 :
3780 : case 269:
3781 :
3782 : {
3783 16 : canvas = config->find< eq::server::Canvas >( (yyvsp[(2) - (2)]._string) );
3784 16 : if( !canvas )
3785 : {
3786 0 : yyerror( "Can't find canvas" );
3787 0 : YYERROR;
3788 : }
3789 16 : segment = canvas->getSegment( eq::server::SegmentPath( 0 ));
3790 : ;}
3791 16 : break;
3792 :
3793 : case 270:
3794 :
3795 : {
3796 616 : canvas = config->getCanvas( eq::server::CanvasPath( (yyvsp[(2) - (2)]._unsigned) ));
3797 616 : if( !canvas )
3798 : {
3799 0 : yyerror( "Can't find canvas" );
3800 0 : YYERROR;
3801 : }
3802 616 : segment = canvas->getSegment( eq::server::SegmentPath( 0 ));
3803 : ;}
3804 616 : break;
3805 :
3806 : case 271:
3807 :
3808 : {
3809 0 : if( canvas )
3810 0 : segment = canvas->findSegment( (yyvsp[(2) - (2)]._string) );
3811 : else
3812 0 : segment = config->find< eq::server::Segment >( (yyvsp[(2) - (2)]._string) );
3813 : ;}
3814 0 : break;
3815 :
3816 : case 272:
3817 :
3818 : {
3819 1034 : if( canvas )
3820 632 : segment = canvas->getSegment( eq::server::SegmentPath( (yyvsp[(2) - (2)]._unsigned) ));
3821 : else
3822 402 : segment = config->getSegment( eq::server::SegmentPath( (yyvsp[(2) - (2)]._unsigned) ));
3823 : ;}
3824 1034 : break;
3825 :
3826 : case 273:
3827 :
3828 : {
3829 510 : layout = config->find< eq::server::Layout >( (yyvsp[(2) - (2)]._string) );
3830 510 : if( !layout )
3831 : {
3832 0 : yyerror( "Can't find layout" );
3833 0 : YYERROR;
3834 : }
3835 510 : view = layout->getView( eq::server::ViewPath( 0 ));;
3836 : ;}
3837 510 : break;
3838 :
3839 : case 274:
3840 :
3841 : {
3842 324 : layout = config->getLayout( eq::server::LayoutPath( (yyvsp[(2) - (2)]._unsigned) ));
3843 324 : if( !layout )
3844 : {
3845 0 : yyerror( "Can't find layout" );
3846 0 : YYERROR;
3847 : }
3848 324 : view = layout->getView( eq::server::ViewPath( 0 ));;
3849 : ;}
3850 324 : break;
3851 :
3852 : case 275:
3853 :
3854 : {
3855 2 : if( layout )
3856 2 : view = layout->findView( (yyvsp[(2) - (2)]._string) );
3857 : else
3858 0 : view = config->find< eq::server::View >( (yyvsp[(2) - (2)]._string) );
3859 : ;}
3860 2 : break;
3861 :
3862 : case 276:
3863 :
3864 : {
3865 1032 : if( layout )
3866 826 : view = layout->getView( eq::server::ViewPath( (yyvsp[(2) - (2)]._unsigned) ));
3867 : else
3868 206 : view = config->getView( eq::server::ViewPath( (yyvsp[(2) - (2)]._unsigned) ));
3869 : ;}
3870 1032 : break;
3871 :
3872 : case 279:
3873 :
3874 176 : { eqCompound->enableTask( eq::fabric::TASK_CLEAR ); ;}
3875 176 : break;
3876 :
3877 : case 280:
3878 :
3879 8 : { eqCompound->enableTask( eq::fabric::TASK_DRAW ); ;}
3880 8 : break;
3881 :
3882 : case 281:
3883 :
3884 232 : { eqCompound->enableTask( eq::fabric::TASK_ASSEMBLE );;}
3885 232 : break;
3886 :
3887 : case 282:
3888 :
3889 144 : { eqCompound->enableTask( eq::fabric::TASK_READBACK );;}
3890 144 : break;
3891 :
3892 : case 285:
3893 :
3894 140 : { eqCompound->enableEye( eq::fabric::EYE_CYCLOP ); ;}
3895 140 : break;
3896 :
3897 : case 286:
3898 :
3899 96 : { eqCompound->enableEye( eq::fabric::EYE_LEFT ); ;}
3900 96 : break;
3901 :
3902 : case 287:
3903 :
3904 100 : { eqCompound->enableEye( eq::fabric::EYE_RIGHT ); ;}
3905 100 : break;
3906 :
3907 : case 290:
3908 :
3909 436 : { buffers |= eq::fabric::Frame::Buffer::color; ;}
3910 436 : break;
3911 :
3912 : case 291:
3913 :
3914 188 : { buffers |= eq::fabric::Frame::Buffer::depth; ;}
3915 188 : break;
3916 :
3917 : case 292:
3918 :
3919 938 : { wall = eq::fabric::Wall(); ;}
3920 938 : break;
3921 :
3922 : case 296:
3923 :
3924 780 : { wall.bottomLeft = eq::fabric::Vector3f( (yyvsp[(3) - (6)]._float), (yyvsp[(4) - (6)]._float), (yyvsp[(5) - (6)]._float) ); ;}
3925 780 : break;
3926 :
3927 : case 297:
3928 :
3929 780 : { wall.bottomRight = eq::fabric::Vector3f( (yyvsp[(3) - (6)]._float), (yyvsp[(4) - (6)]._float), (yyvsp[(5) - (6)]._float) ); ;}
3930 780 : break;
3931 :
3932 : case 298:
3933 :
3934 780 : { wall.topLeft = eq::fabric::Vector3f( (yyvsp[(3) - (6)]._float), (yyvsp[(4) - (6)]._float), (yyvsp[(5) - (6)]._float) ); ;}
3935 780 : break;
3936 :
3937 : case 300:
3938 :
3939 0 : { wall.type = eq::fabric::Wall::TYPE_FIXED; ;}
3940 0 : break;
3941 :
3942 : case 301:
3943 :
3944 26 : { wall.type = eq::fabric::Wall::TYPE_HMD; ;}
3945 26 : break;
3946 :
3947 : case 302:
3948 :
3949 68 : { projection = eq::fabric::Projection(); ;}
3950 68 : break;
3951 :
3952 : case 306:
3953 :
3954 40 : { projection.origin = eq::fabric::Vector3f( (yyvsp[(3) - (6)]._float), (yyvsp[(4) - (6)]._float), (yyvsp[(5) - (6)]._float) ); ;}
3955 40 : break;
3956 :
3957 : case 307:
3958 :
3959 68 : { projection.distance = (yyvsp[(2) - (2)]._float); ;}
3960 68 : break;
3961 :
3962 : case 308:
3963 :
3964 68 : { projection.fov = eq::fabric::Vector2f( (yyvsp[(3) - (5)]._float), (yyvsp[(4) - (5)]._float) ); ;}
3965 68 : break;
3966 :
3967 : case 309:
3968 :
3969 68 : { projection.hpr = eq::fabric::Vector3f( (yyvsp[(3) - (6)]._float), (yyvsp[(4) - (6)]._float), (yyvsp[(5) - (6)]._float) ); ;}
3970 68 : break;
3971 :
3972 : case 317:
3973 :
3974 16 : { dfrEqualizer = new eq::server::DFREqualizer; ;}
3975 16 : break;
3976 :
3977 : case 318:
3978 :
3979 : {
3980 16 : eqCompound->addEqualizer( dfrEqualizer );
3981 16 : dfrEqualizer = 0;
3982 : ;}
3983 16 : break;
3984 :
3985 : case 319:
3986 :
3987 : {
3988 28 : eqCompound->addEqualizer( new eq::server::FramerateEqualizer );
3989 : ;}
3990 28 : break;
3991 :
3992 : case 320:
3993 :
3994 188 : { loadEqualizer = new eq::server::LoadEqualizer; ;}
3995 188 : break;
3996 :
3997 : case 321:
3998 :
3999 : {
4000 188 : eqCompound->addEqualizer( loadEqualizer );
4001 188 : loadEqualizer = 0;
4002 : ;}
4003 188 : break;
4004 :
4005 : case 322:
4006 :
4007 0 : { treeEqualizer = new eq::server::TreeEqualizer; ;}
4008 0 : break;
4009 :
4010 : case 323:
4011 :
4012 : {
4013 0 : eqCompound->addEqualizer( treeEqualizer );
4014 0 : treeEqualizer = 0;
4015 : ;}
4016 0 : break;
4017 :
4018 : case 324:
4019 :
4020 : {
4021 4 : eqCompound->addEqualizer( new eq::server::MonitorEqualizer );
4022 : ;}
4023 4 : break;
4024 :
4025 : case 325:
4026 :
4027 : {
4028 32 : eqCompound->addEqualizer( new eq::server::ViewEqualizer );
4029 : ;}
4030 32 : break;
4031 :
4032 : case 326:
4033 :
4034 8 : { tileEqualizer = new eq::server::TileEqualizer; ;}
4035 8 : break;
4036 :
4037 : case 327:
4038 :
4039 : {
4040 8 : eqCompound->addEqualizer( tileEqualizer );
4041 8 : tileEqualizer = 0;
4042 : ;}
4043 8 : break;
4044 :
4045 : case 330:
4046 :
4047 2 : { dfrEqualizer->setDamping( (yyvsp[(2) - (2)]._float) ); ;}
4048 2 : break;
4049 :
4050 : case 331:
4051 :
4052 16 : { dfrEqualizer->setFrameRate( (yyvsp[(2) - (2)]._float) ); ;}
4053 16 : break;
4054 :
4055 : case 334:
4056 :
4057 8 : { loadEqualizer->setDamping( (yyvsp[(2) - (2)]._float) ); ;}
4058 8 : break;
4059 :
4060 : case 335:
4061 :
4062 0 : { loadEqualizer->setBoundary( eq::fabric::Vector2i( (yyvsp[(3) - (5)]._unsigned), (yyvsp[(4) - (5)]._unsigned) )); ;}
4063 0 : break;
4064 :
4065 : case 336:
4066 :
4067 0 : { loadEqualizer->setAssembleOnlyLimit( (yyvsp[(2) - (2)]._float) ); ;}
4068 0 : break;
4069 :
4070 : case 337:
4071 :
4072 0 : { loadEqualizer->setBoundary( (yyvsp[(2) - (2)]._float) ); ;}
4073 0 : break;
4074 :
4075 : case 338:
4076 :
4077 140 : { loadEqualizer->setMode( (yyvsp[(2) - (2)]._loadEqualizerMode) ); ;}
4078 140 : break;
4079 :
4080 : case 339:
4081 :
4082 0 : { loadEqualizer->setResistance( eq::fabric::Vector2i( (yyvsp[(3) - (5)]._unsigned), (yyvsp[(4) - (5)]._unsigned) )); ;}
4083 0 : break;
4084 :
4085 : case 340:
4086 :
4087 0 : { loadEqualizer->setResistance( (yyvsp[(2) - (2)]._float) ); ;}
4088 0 : break;
4089 :
4090 : case 341:
4091 :
4092 92 : { (yyval._loadEqualizerMode) = eq::server::LoadEqualizer::MODE_2D; ;}
4093 92 : break;
4094 :
4095 : case 342:
4096 :
4097 24 : { (yyval._loadEqualizerMode) = eq::server::LoadEqualizer::MODE_DB; ;}
4098 24 : break;
4099 :
4100 : case 343:
4101 :
4102 16 : { (yyval._loadEqualizerMode) = eq::server::LoadEqualizer::MODE_HORIZONTAL; ;}
4103 16 : break;
4104 :
4105 : case 344:
4106 :
4107 8 : { (yyval._loadEqualizerMode) = eq::server::LoadEqualizer::MODE_VERTICAL; ;}
4108 8 : break;
4109 :
4110 : case 347:
4111 :
4112 0 : { treeEqualizer->setDamping( (yyvsp[(2) - (2)]._float) ); ;}
4113 0 : break;
4114 :
4115 : case 348:
4116 :
4117 0 : { treeEqualizer->setBoundary( eq::fabric::Vector2i( (yyvsp[(3) - (5)]._unsigned), (yyvsp[(4) - (5)]._unsigned) )); ;}
4118 0 : break;
4119 :
4120 : case 349:
4121 :
4122 0 : { treeEqualizer->setBoundary( (yyvsp[(2) - (2)]._float) ); ;}
4123 0 : break;
4124 :
4125 : case 350:
4126 :
4127 0 : { treeEqualizer->setMode( (yyvsp[(2) - (2)]._treeEqualizerMode) ); ;}
4128 0 : break;
4129 :
4130 : case 351:
4131 :
4132 0 : { treeEqualizer->setResistance( eq::fabric::Vector2i( (yyvsp[(3) - (5)]._unsigned), (yyvsp[(4) - (5)]._unsigned) )); ;}
4133 0 : break;
4134 :
4135 : case 352:
4136 :
4137 0 : { treeEqualizer->setResistance( (yyvsp[(2) - (2)]._float) ); ;}
4138 0 : break;
4139 :
4140 : case 353:
4141 :
4142 0 : { (yyval._treeEqualizerMode) = eq::server::TreeEqualizer::MODE_2D; ;}
4143 0 : break;
4144 :
4145 : case 354:
4146 :
4147 0 : { (yyval._treeEqualizerMode) = eq::server::TreeEqualizer::MODE_DB; ;}
4148 0 : break;
4149 :
4150 : case 355:
4151 :
4152 0 : { (yyval._treeEqualizerMode) = eq::server::TreeEqualizer::MODE_HORIZONTAL; ;}
4153 0 : break;
4154 :
4155 : case 356:
4156 :
4157 0 : { (yyval._treeEqualizerMode) = eq::server::TreeEqualizer::MODE_VERTICAL; ;}
4158 0 : break;
4159 :
4160 : case 359:
4161 :
4162 4 : { tileEqualizer->setName( (yyvsp[(2) - (2)]._string) ); ;}
4163 4 : break;
4164 :
4165 : case 360:
4166 :
4167 4 : { tileEqualizer->setTileSize( eq::fabric::Vector2i( (yyvsp[(3) - (5)]._unsigned), (yyvsp[(4) - (5)]._unsigned) )); ;}
4168 4 : break;
4169 :
4170 : case 361:
4171 :
4172 436 : { swapBarrier = new eq::server::SwapBarrier; ;}
4173 436 : break;
4174 :
4175 : case 365:
4176 :
4177 236 : { swapBarrier->setName( (yyvsp[(2) - (2)]._string) ); ;}
4178 236 : break;
4179 :
4180 : case 366:
4181 :
4182 8 : { swapBarrier->setNVSwapGroup( (yyvsp[(2) - (2)]._int) ); ;}
4183 8 : break;
4184 :
4185 : case 367:
4186 :
4187 8 : { swapBarrier->setNVSwapBarrier( (yyvsp[(2) - (2)]._int) ); ;}
4188 8 : break;
4189 :
4190 : case 368:
4191 :
4192 2708 : { frame = new eq::server::Frame; ;}
4193 2708 : break;
4194 :
4195 : case 369:
4196 :
4197 : {
4198 2708 : eqCompound->addOutputFrame( frame );
4199 2708 : frame = 0;
4200 : ;}
4201 2708 : break;
4202 :
4203 : case 370:
4204 :
4205 2776 : { frame = new eq::server::Frame; ;}
4206 2776 : break;
4207 :
4208 : case 371:
4209 :
4210 : {
4211 2776 : eqCompound->addInputFrame( frame );
4212 2776 : frame = 0;
4213 : ;}
4214 2776 : break;
4215 :
4216 : case 374:
4217 :
4218 4940 : { frame->setName( (yyvsp[(2) - (2)]._string) ); ;}
4219 4940 : break;
4220 :
4221 : case 376:
4222 :
4223 2952 : { frame->setViewport(eq::fabric::Viewport( (yyvsp[(2) - (2)]._viewport)[0], (yyvsp[(2) - (2)]._viewport)[1],
4224 1476 : (yyvsp[(2) - (2)]._viewport)[2], (yyvsp[(2) - (2)]._viewport)[3])); ;}
4225 1476 : break;
4226 :
4227 : case 377:
4228 :
4229 248 : { buffers = eq::fabric::Frame::Buffer::none; ;}
4230 248 : break;
4231 :
4232 : case 378:
4233 :
4234 248 : { frame->setBuffers( buffers );
4235 248 : buffers = eq::fabric::Frame::Buffer::none; ;}
4236 248 : break;
4237 :
4238 : case 379:
4239 :
4240 0 : { frame->setNativeZoom( eq::fabric::Zoom( (yyvsp[(3) - (5)]._float), (yyvsp[(4) - (5)]._float) )); ;}
4241 0 : break;
4242 :
4243 : case 380:
4244 :
4245 124 : { frame->setType( eq::fabric::Frame::TYPE_TEXTURE ); ;}
4246 124 : break;
4247 :
4248 : case 381:
4249 :
4250 0 : { frame->setType( eq::fabric::Frame::TYPE_MEMORY ); ;}
4251 0 : break;
4252 :
4253 : case 382:
4254 :
4255 0 : { tileQueue = new eq::server::TileQueue; ;}
4256 0 : break;
4257 :
4258 : case 383:
4259 :
4260 : {
4261 0 : eqCompound->addOutputTileQueue( tileQueue );
4262 0 : tileQueue = 0;
4263 : ;}
4264 0 : break;
4265 :
4266 : case 384:
4267 :
4268 0 : { tileQueue = new eq::server::TileQueue; ;}
4269 0 : break;
4270 :
4271 : case 385:
4272 :
4273 : {
4274 0 : eqCompound->addInputTileQueue( tileQueue );
4275 0 : tileQueue = 0;
4276 : ;}
4277 0 : break;
4278 :
4279 : case 388:
4280 :
4281 0 : { tileQueue->setName( (yyvsp[(2) - (2)]._string) ); ;}
4282 0 : break;
4283 :
4284 : case 389:
4285 :
4286 0 : { tileQueue->setTileSize( eq::fabric::Vector2i( (yyvsp[(3) - (5)]._unsigned), (yyvsp[(4) - (5)]._unsigned) )); ;}
4287 0 : break;
4288 :
4289 : case 392:
4290 :
4291 12 : { eqCompound->setIAttribute( eq::server::Compound::IATTR_STEREO_MODE, (yyvsp[(2) - (2)]._int) ); ;}
4292 12 : break;
4293 :
4294 : case 393:
4295 :
4296 8 : { eqCompound->setIAttribute(
4297 16 : eq::server::Compound::IATTR_STEREO_ANAGLYPH_LEFT_MASK, (yyvsp[(2) - (2)]._unsigned) ); ;}
4298 8 : break;
4299 :
4300 : case 394:
4301 :
4302 8 : { eqCompound->setIAttribute(
4303 16 : eq::server::Compound::IATTR_STEREO_ANAGLYPH_RIGHT_MASK, (yyvsp[(2) - (2)]._unsigned) ); ;}
4304 8 : break;
4305 :
4306 : case 395:
4307 :
4308 0 : { LBWARN << "ignoring removed attribute update_FOV" << std::endl; ;}
4309 0 : break;
4310 :
4311 : case 396:
4312 :
4313 : {
4314 4834 : (yyval._viewport)[0] = (yyvsp[(2) - (6)]._float);
4315 4834 : (yyval._viewport)[1] = (yyvsp[(3) - (6)]._float);
4316 4834 : (yyval._viewport)[2] = (yyvsp[(4) - (6)]._float);
4317 4834 : (yyval._viewport)[3] = (yyvsp[(5) - (6)]._float);
4318 : ;}
4319 4834 : break;
4320 :
4321 : case 397:
4322 :
4323 24 : { (yyval._unsigned) = (yyvsp[(2) - (3)]._unsigned); ;}
4324 24 : break;
4325 :
4326 : case 398:
4327 :
4328 0 : { (yyval._unsigned) =eq::server::Compound::COLOR_MASK_NONE; ;}
4329 0 : break;
4330 :
4331 : case 399:
4332 :
4333 24 : { (yyval._unsigned) = (yyvsp[(1) - (1)]._unsigned); ;}
4334 24 : break;
4335 :
4336 : case 400:
4337 :
4338 36 : { (yyval._unsigned) = ((yyvsp[(1) - (2)]._unsigned) | (yyvsp[(2) - (2)]._unsigned));;}
4339 36 : break;
4340 :
4341 : case 401:
4342 :
4343 20 : { (yyval._unsigned) = eq::server::Compound::COLOR_MASK_RED; ;}
4344 20 : break;
4345 :
4346 : case 402:
4347 :
4348 20 : { (yyval._unsigned) = eq::server::Compound::COLOR_MASK_GREEN; ;}
4349 20 : break;
4350 :
4351 : case 403:
4352 :
4353 20 : { (yyval._unsigned) = eq::server::Compound::COLOR_MASK_BLUE; ;}
4354 20 : break;
4355 :
4356 : case 404:
4357 :
4358 276 : { (yyval._int) = eq::fabric::ON; ;}
4359 276 : break;
4360 :
4361 : case 405:
4362 :
4363 398 : { (yyval._int) = eq::fabric::OFF; ;}
4364 398 : break;
4365 :
4366 : case 406:
4367 :
4368 208 : { (yyval._int) = eq::fabric::AUTO; ;}
4369 208 : break;
4370 :
4371 : case 407:
4372 :
4373 2 : { (yyval._int) = eq::fabric::FASTEST; ;}
4374 2 : break;
4375 :
4376 : case 408:
4377 :
4378 0 : { (yyval._int) = eq::fabric::HORIZONTAL; ;}
4379 0 : break;
4380 :
4381 : case 409:
4382 :
4383 10 : { (yyval._int) = eq::fabric::NICEST; ;}
4384 10 : break;
4385 :
4386 : case 410:
4387 :
4388 0 : { (yyval._int) = eq::fabric::QUAD; ;}
4389 0 : break;
4390 :
4391 : case 411:
4392 :
4393 20 : { (yyval._int) = eq::fabric::ANAGLYPH; ;}
4394 20 : break;
4395 :
4396 : case 412:
4397 :
4398 4 : { (yyval._int) = eq::fabric::PASSIVE; ;}
4399 4 : break;
4400 :
4401 : case 413:
4402 :
4403 0 : { (yyval._int) = eq::fabric::VERTICAL; ;}
4404 0 : break;
4405 :
4406 : case 414:
4407 :
4408 18 : { (yyval._int) = eq::fabric::WINDOW; ;}
4409 18 : break;
4410 :
4411 : case 415:
4412 :
4413 70 : { (yyval._int) = eq::fabric::FBO; ;}
4414 70 : break;
4415 :
4416 : case 416:
4417 :
4418 : {
4419 0 : (yyval._int) = eq::fabric::FBO;
4420 0 : LBERROR << "Using FBO in place of removed PBuffer support" << std::endl;
4421 : ;}
4422 0 : break;
4423 :
4424 : case 417:
4425 :
4426 2 : { (yyval._int) = eq::fabric::ASYNC; ;}
4427 2 : break;
4428 :
4429 : case 418:
4430 :
4431 2 : { (yyval._int) = eq::fabric::DRAW_SYNC; ;}
4432 2 : break;
4433 :
4434 : case 419:
4435 :
4436 4 : { (yyval._int) = eq::fabric::LOCAL_SYNC; ;}
4437 4 : break;
4438 :
4439 : case 420:
4440 :
4441 8 : { (yyval._int) = eq::fabric::RGBA16F; ;}
4442 8 : break;
4443 :
4444 : case 421:
4445 :
4446 4 : { (yyval._int) = eq::fabric::RGBA32F; ;}
4447 4 : break;
4448 :
4449 : case 422:
4450 :
4451 200 : { (yyval._int) = eq::fabric::FIXED; ;}
4452 200 : break;
4453 :
4454 : case 423:
4455 :
4456 0 : { (yyval._int) = eq::fabric::RELATIVE_TO_ORIGIN; ;}
4457 0 : break;
4458 :
4459 : case 424:
4460 :
4461 4 : { (yyval._int) = eq::fabric::RELATIVE_TO_OBSERVER; ;}
4462 4 : break;
4463 :
4464 : case 425:
4465 :
4466 98 : { (yyval._int) = (yyvsp[(1) - (1)]._int); ;}
4467 98 : break;
4468 :
4469 : case 426:
4470 :
4471 0 : { (yyval._int) = eq::fabric::CORE + (yyvsp[(2) - (2)]._int); ;}
4472 0 : break;
4473 :
4474 : case 427:
4475 :
4476 0 : { (yyval._int) = eq::fabric::SOCKET + (yyvsp[(2) - (2)]._int); ;}
4477 0 : break;
4478 :
4479 : case 428:
4480 :
4481 : {
4482 13628 : static std::string stringBuf;
4483 13628 : stringBuf = yytext;
4484 13628 : stringBuf.erase( 0, 1 ); // Leading '"'
4485 13628 : stringBuf.erase( stringBuf.size()-1, 1 ); // Trailing '"'
4486 13628 : (yyval._string) = stringBuf.c_str();
4487 : ;}
4488 13628 : break;
4489 :
4490 : case 429:
4491 :
4492 4 : { (yyval._character) = yytext[1]; ;}
4493 4 : break;
4494 :
4495 : case 430:
4496 :
4497 17466 : { (yyval._float) = atof( yytext ); ;}
4498 17466 : break;
4499 :
4500 : case 431:
4501 :
4502 13470 : { (yyval._float) = (yyvsp[(1) - (1)]._int); ;}
4503 13470 : break;
4504 :
4505 : case 432:
4506 :
4507 664 : { (yyval._int) = atoi( yytext ); ;}
4508 664 : break;
4509 :
4510 : case 433:
4511 :
4512 12904 : { (yyval._int) = (yyvsp[(1) - (1)]._unsigned); ;}
4513 12904 : break;
4514 :
4515 : case 434:
4516 :
4517 17148 : { (yyval._unsigned) = atoi( yytext ); ;}
4518 17148 : break;
4519 :
4520 :
4521 :
4522 102606 : default: break;
4523 : }
4524 : YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
4525 :
4526 260044 : YYPOPSTACK (yylen);
4527 260044 : yylen = 0;
4528 : YY_STACK_PRINT (yyss, yyssp);
4529 :
4530 260044 : *++yyvsp = yyval;
4531 :
4532 : /* Now `shift' the result of the reduction. Determine what state
4533 : that goes to, based on the state we popped back to and the rule
4534 : number reduced by. */
4535 :
4536 260044 : yyn = yyr1[yyn];
4537 :
4538 260044 : yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
4539 260044 : if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
4540 82858 : yystate = yytable[yystate];
4541 : else
4542 177186 : yystate = yydefgoto[yyn - YYNTOKENS];
4543 :
4544 260044 : goto yynewstate;
4545 :
4546 :
4547 : /*------------------------------------.
4548 : | yyerrlab -- here on detecting error |
4549 : `------------------------------------*/
4550 : yyerrlab:
4551 : /* If not already recovering from an error, report this error. */
4552 2 : if (!yyerrstatus)
4553 : {
4554 2 : ++yynerrs;
4555 : #if ! YYERROR_VERBOSE
4556 2 : yyerror (YY_("syntax error"));
4557 : #else
4558 : {
4559 : YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
4560 : if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
4561 : {
4562 : YYSIZE_T yyalloc = 2 * yysize;
4563 : if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
4564 : yyalloc = YYSTACK_ALLOC_MAXIMUM;
4565 : if (yymsg != yymsgbuf)
4566 : YYSTACK_FREE (yymsg);
4567 : yymsg = (char *) YYSTACK_ALLOC (yyalloc);
4568 : if (yymsg)
4569 : yymsg_alloc = yyalloc;
4570 : else
4571 : {
4572 : yymsg = yymsgbuf;
4573 : yymsg_alloc = sizeof yymsgbuf;
4574 : }
4575 : }
4576 :
4577 : if (0 < yysize && yysize <= yymsg_alloc)
4578 : {
4579 : (void) yysyntax_error (yymsg, yystate, yychar);
4580 : yyerror (yymsg);
4581 : }
4582 : else
4583 : {
4584 : yyerror (YY_("syntax error"));
4585 : if (yysize != 0)
4586 : goto yyexhaustedlab;
4587 : }
4588 : }
4589 : #endif
4590 : }
4591 :
4592 :
4593 :
4594 2 : if (yyerrstatus == 3)
4595 : {
4596 : /* If just tried and failed to reuse lookahead token after an
4597 : error, discard it. */
4598 :
4599 0 : if (yychar <= YYEOF)
4600 : {
4601 : /* Return failure if at end of input. */
4602 0 : if (yychar == YYEOF)
4603 0 : YYABORT;
4604 : }
4605 : else
4606 : {
4607 : yydestruct ("Error: discarding",
4608 0 : yytoken, &yylval);
4609 0 : yychar = YYEMPTY;
4610 : }
4611 : }
4612 :
4613 : /* Else will try to reuse lookahead token after shifting the error
4614 : token. */
4615 2 : goto yyerrlab1;
4616 :
4617 :
4618 : /*---------------------------------------------------.
4619 : | yyerrorlab -- error raised explicitly by YYERROR. |
4620 : `---------------------------------------------------*/
4621 : yyerrorlab:
4622 :
4623 : /* Pacify compilers like GCC when the user code never invokes
4624 : YYERROR and the label yyerrorlab therefore never appears in user
4625 : code. */
4626 : if (/*CONSTCOND*/ 0)
4627 : goto yyerrorlab;
4628 :
4629 : /* Do not reclaim the symbols of the rule which action triggered
4630 : this YYERROR. */
4631 0 : YYPOPSTACK (yylen);
4632 0 : yylen = 0;
4633 : YY_STACK_PRINT (yyss, yyssp);
4634 0 : yystate = *yyssp;
4635 0 : goto yyerrlab1;
4636 :
4637 :
4638 : /*-------------------------------------------------------------.
4639 : | yyerrlab1 -- common code for both syntax error and YYERROR. |
4640 : `-------------------------------------------------------------*/
4641 : yyerrlab1:
4642 2 : yyerrstatus = 3; /* Each real token shifted decrements this. */
4643 :
4644 : for (;;)
4645 : {
4646 10 : yyn = yypact[yystate];
4647 6 : if (yyn != YYPACT_NINF)
4648 : {
4649 6 : yyn += YYTERROR;
4650 6 : if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
4651 : {
4652 0 : yyn = yytable[yyn];
4653 0 : if (0 < yyn)
4654 0 : break;
4655 : }
4656 : }
4657 :
4658 : /* Pop the current state because it cannot handle the error token. */
4659 6 : if (yyssp == yyss)
4660 2 : YYABORT;
4661 :
4662 :
4663 4 : yydestruct ("Error: popping",
4664 8 : yystos[yystate], yyvsp);
4665 4 : YYPOPSTACK (1);
4666 4 : yystate = *yyssp;
4667 : YY_STACK_PRINT (yyss, yyssp);
4668 : }
4669 :
4670 0 : *++yyvsp = yylval;
4671 :
4672 :
4673 : /* Shift the error token. */
4674 : YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
4675 :
4676 0 : yystate = yyn;
4677 0 : goto yynewstate;
4678 :
4679 :
4680 : /*-------------------------------------.
4681 : | yyacceptlab -- YYACCEPT comes here. |
4682 : `-------------------------------------*/
4683 : yyacceptlab:
4684 402 : yyresult = 0;
4685 402 : goto yyreturn;
4686 :
4687 : /*-----------------------------------.
4688 : | yyabortlab -- YYABORT comes here. |
4689 : `-----------------------------------*/
4690 : yyabortlab:
4691 2 : yyresult = 1;
4692 2 : goto yyreturn;
4693 :
4694 : #if !defined(yyoverflow) || YYERROR_VERBOSE
4695 : /*-------------------------------------------------.
4696 : | yyexhaustedlab -- memory exhaustion comes here. |
4697 : `-------------------------------------------------*/
4698 : yyexhaustedlab:
4699 0 : yyerror (YY_("memory exhausted"));
4700 0 : yyresult = 2;
4701 : /* Fall through. */
4702 : #endif
4703 :
4704 : yyreturn:
4705 404 : if (yychar != YYEMPTY)
4706 : yydestruct ("Cleanup: discarding lookahead",
4707 2 : yytoken, &yylval);
4708 : /* Do not reclaim the symbols of the rule which action triggered
4709 : this YYABORT or YYACCEPT. */
4710 404 : YYPOPSTACK (yylen);
4711 : YY_STACK_PRINT (yyss, yyssp);
4712 2012 : while (yyssp != yyss)
4713 : {
4714 804 : yydestruct ("Cleanup: popping",
4715 1608 : yystos[*yyssp], yyvsp);
4716 804 : YYPOPSTACK (1);
4717 : }
4718 : #ifndef yyoverflow
4719 404 : if (yyss != yyssa)
4720 0 : YYSTACK_FREE (yyss);
4721 : #endif
4722 : #if YYERROR_VERBOSE
4723 : if (yymsg != yymsgbuf)
4724 : YYSTACK_FREE (yymsg);
4725 : #endif
4726 : /* Make sure YYID is used. */
4727 404 : return YYID (yyresult);
4728 : }
4729 :
4730 :
4731 :
4732 :
4733 :
4734 : namespace eq
4735 : {
4736 : namespace server
4737 : {
4738 :
4739 : //---------------------------------------------------------------------------
4740 : // loader
4741 : //---------------------------------------------------------------------------
4742 404 : ServerPtr Loader::loadFile( const std::string& filename )
4743 : {
4744 404 : yyin = fopen( filename.c_str(), "r" );
4745 404 : yyinString = 0;
4746 :
4747 404 : if( !yyin )
4748 : {
4749 0 : LBERROR << "Can't open config file " << filename << std::endl;
4750 0 : return 0;
4751 : }
4752 :
4753 404 : loader::filename = filename;
4754 404 : _parse();
4755 404 : loader::filename.clear();
4756 :
4757 404 : fclose( yyin );
4758 :
4759 808 : eq::server::ServerPtr server = loader::server;
4760 404 : loader::server = 0;
4761 404 : return server;
4762 : }
4763 :
4764 0 : void Loader::_parseString( const char* data )
4765 : {
4766 0 : yyin = 0;
4767 0 : yyinString = data;
4768 0 : _parse();
4769 0 : }
4770 :
4771 404 : void Loader::_parse()
4772 : {
4773 404 : LBASSERTINFO( !eq::loader::loader, "Config file loader is not reentrant" );
4774 404 : eq::loader::loader = this;
4775 :
4776 404 : loader::server = 0;
4777 404 : config = 0;
4778 404 : yylineno = 0;
4779 :
4780 808 : const std::string oldLocale = setlocale( LC_NUMERIC, "C" );
4781 404 : const bool error = ( eqLoader_parse() != 0 );
4782 404 : setlocale( LC_NUMERIC, oldLocale.c_str( ));
4783 :
4784 404 : if( error )
4785 2 : loader::server = 0;
4786 :
4787 404 : eq::loader::loader = 0;
4788 404 : }
4789 :
4790 0 : ServerPtr Loader::parseServer( const char* data )
4791 : {
4792 0 : _parseString( data );
4793 :
4794 0 : eq::server::ServerPtr server = loader::server;
4795 0 : loader::server = 0;
4796 0 : return server;
4797 : }
4798 :
4799 : }
4800 60 : }
4801 :
|
