1 /* A Bison parser, made by GNU Bison 2.3. */
2
3 /* Skeleton implementation for Bison's Yacc-like parsers in C
4
5 Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6
7 This program is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 This program is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with this program; if not, see: <http://www.gnu.org/licenses/>
19 Boston, MA 02110-1301, USA. */
20
21 /* As a special exception, you may create a larger work that contains
22 part or all of the Bison parser skeleton and distribute that work
23 under terms of your choice, so long as that work isn't itself a
24 parser generator using the skeleton or a modified version thereof
25 as a parser skeleton. Alternatively, if you modify or redistribute
26 the parser skeleton itself, you may (at your option) remove this
27 special exception, which will cause the skeleton and the resulting
28 Bison output files to be licensed under the GNU General Public
29 License without this special exception.
30
31 This special exception was added by the Free Software Foundation in
32 version 2.2 of Bison. */
33
34 /* C LALR(1) parser skeleton written by Richard Stallman, by
35 simplifying the original so-called "semantic" parser. */
36
37 /* All symbols defined below should begin with yy or YY, to avoid
38 infringing on user name space. This should be done even for local
39 variables, as they might otherwise be expanded by user macros.
40 There are some unavoidable exceptions within include files to
41 define necessary library symbols; they are noted "INFRINGES ON
42 USER NAME SPACE" below. */
43
44 /* Identify Bison output. */
45 #define YYBISON 1
46
47 /* Bison version. */
48 #define YYBISON_VERSION "2.3"
49
50 /* Skeleton name. */
51 #define YYSKELETON_NAME "yacc.c"
52
53 /* Pure parsers. */
54 #define YYPURE 0
55
56 /* Using locations. */
57 #define YYLSP_NEEDED 0
58
59
60
61 /* Tokens. */
62 #ifndef YYTOKENTYPE
63 # define YYTOKENTYPE
64 /* Put the tokens into the symbol table, so that GDB and other debuggers
65 know about them. */
66 enum yytokentype {
67 STR = 258,
68 GSTR = 259,
69 VAR = 260,
70 FONT = 261,
71 NUMBER = 262,
72 WINDOWTITLE = 263,
73 WINDOWLOCALETITLE = 264,
74 WINDOWSIZE = 265,
75 WINDOWPOSITION = 266,
76 USEGETTEXT = 267,
77 FORECOLOR = 268,
78 BACKCOLOR = 269,
79 SHADCOLOR = 270,
80 LICOLOR = 271,
81 COLORSET = 272,
82 OBJECT = 273,
83 INIT = 274,
84 PERIODICTASK = 275,
85 QUITFUNC = 276,
86 MAIN = 277,
87 END = 278,
88 PROP = 279,
89 TYPE = 280,
90 SIZE = 281,
91 POSITION = 282,
92 VALUE = 283,
93 VALUEMIN = 284,
94 VALUEMAX = 285,
95 TITLE = 286,
96 SWALLOWEXEC = 287,
97 ICON = 288,
98 FLAGS = 289,
99 WARP = 290,
100 WRITETOFILE = 291,
101 LOCALETITLE = 292,
102 HIDDEN = 293,
103 NOFOCUS = 294,
104 NORELIEFSTRING = 295,
105 CENTER = 296,
106 LEFT = 297,
107 RIGHT = 298,
108 CASE = 299,
109 SINGLECLIC = 300,
110 DOUBLECLIC = 301,
111 BEG = 302,
112 POINT = 303,
113 EXEC = 304,
114 HIDE = 305,
115 SHOW = 306,
116 CHFONT = 307,
117 CHFORECOLOR = 308,
118 CHBACKCOLOR = 309,
119 CHCOLORSET = 310,
120 CHWINDOWTITLE = 311,
121 CHWINDOWTITLEFARG = 312,
122 KEY = 313,
123 GETVALUE = 314,
124 GETMINVALUE = 315,
125 GETMAXVALUE = 316,
126 GETFORE = 317,
127 GETBACK = 318,
128 GETHILIGHT = 319,
129 GETSHADOW = 320,
130 CHVALUE = 321,
131 CHVALUEMAX = 322,
132 CHVALUEMIN = 323,
133 ADD = 324,
134 DIV = 325,
135 MULT = 326,
136 GETTITLE = 327,
137 GETOUTPUT = 328,
138 STRCOPY = 329,
139 NUMTOHEX = 330,
140 HEXTONUM = 331,
141 QUIT = 332,
142 LAUNCHSCRIPT = 333,
143 GETSCRIPTFATHER = 334,
144 SENDTOSCRIPT = 335,
145 RECEIVFROMSCRIPT = 336,
146 GET = 337,
147 SET = 338,
148 SENDSIGN = 339,
149 REMAINDEROFDIV = 340,
150 GETTIME = 341,
151 GETSCRIPTARG = 342,
152 GETPID = 343,
153 SENDMSGANDGET = 344,
154 PARSE = 345,
155 LASTSTRING = 346,
156 GETTEXT = 347,
157 IF = 348,
158 THEN = 349,
159 ELSE = 350,
160 FOR = 351,
161 TO = 352,
162 DO = 353,
163 WHILE = 354,
164 BEGF = 355,
165 ENDF = 356,
166 EQUAL = 357,
167 INFEQ = 358,
168 SUPEQ = 359,
169 INF = 360,
170 SUP = 361,
171 DIFF = 362
172 };
173 #endif
174 /* Tokens. */
175 #define STR 258
176 #define GSTR 259
177 #define VAR 260
178 #define FONT 261
179 #define NUMBER 262
180 #define WINDOWTITLE 263
181 #define WINDOWLOCALETITLE 264
182 #define WINDOWSIZE 265
183 #define WINDOWPOSITION 266
184 #define USEGETTEXT 267
185 #define FORECOLOR 268
186 #define BACKCOLOR 269
187 #define SHADCOLOR 270
188 #define LICOLOR 271
189 #define COLORSET 272
190 #define OBJECT 273
191 #define INIT 274
192 #define PERIODICTASK 275
193 #define QUITFUNC 276
194 #define MAIN 277
195 #define END 278
196 #define PROP 279
197 #define TYPE 280
198 #define SIZE 281
199 #define POSITION 282
200 #define VALUE 283
201 #define VALUEMIN 284
202 #define VALUEMAX 285
203 #define TITLE 286
204 #define SWALLOWEXEC 287
205 #define ICON 288
206 #define FLAGS 289
207 #define WARP 290
208 #define WRITETOFILE 291
209 #define LOCALETITLE 292
210 #define HIDDEN 293
211 #define NOFOCUS 294
212 #define NORELIEFSTRING 295
213 #define CENTER 296
214 #define LEFT 297
215 #define RIGHT 298
216 #define CASE 299
217 #define SINGLECLIC 300
218 #define DOUBLECLIC 301
219 #define BEG 302
220 #define POINT 303
221 #define EXEC 304
222 #define HIDE 305
223 #define SHOW 306
224 #define CHFONT 307
225 #define CHFORECOLOR 308
226 #define CHBACKCOLOR 309
227 #define CHCOLORSET 310
228 #define CHWINDOWTITLE 311
229 #define CHWINDOWTITLEFARG 312
230 #define KEY 313
231 #define GETVALUE 314
232 #define GETMINVALUE 315
233 #define GETMAXVALUE 316
234 #define GETFORE 317
235 #define GETBACK 318
236 #define GETHILIGHT 319
237 #define GETSHADOW 320
238 #define CHVALUE 321
239 #define CHVALUEMAX 322
240 #define CHVALUEMIN 323
241 #define ADD 324
242 #define DIV 325
243 #define MULT 326
244 #define GETTITLE 327
245 #define GETOUTPUT 328
246 #define STRCOPY 329
247 #define NUMTOHEX 330
248 #define HEXTONUM 331
249 #define QUIT 332
250 #define LAUNCHSCRIPT 333
251 #define GETSCRIPTFATHER 334
252 #define SENDTOSCRIPT 335
253 #define RECEIVFROMSCRIPT 336
254 #define GET 337
255 #define SET 338
256 #define SENDSIGN 339
257 #define REMAINDEROFDIV 340
258 #define GETTIME 341
259 #define GETSCRIPTARG 342
260 #define GETPID 343
261 #define SENDMSGANDGET 344
262 #define PARSE 345
263 #define LASTSTRING 346
264 #define GETTEXT 347
265 #define IF 348
266 #define THEN 349
267 #define ELSE 350
268 #define FOR 351
269 #define TO 352
270 #define DO 353
271 #define WHILE 354
272 #define BEGF 355
273 #define ENDF 356
274 #define EQUAL 357
275 #define INFEQ 358
276 #define SUPEQ 359
277 #define INF 360
278 #define SUP 361
279 #define DIFF 362
280
281
282
283
284 /* Copy the first part of user declarations. */
285 #line 1 "script.y"
286
287 /* This program is free software; you can redistribute it and/or modify
288 * it under the terms of the GNU General Public License as published by
289 * the Free Software Foundation; either version 2 of the License, or
290 * (at your option) any later version.
291 *
292 * This program is distributed in the hope that it will be useful,
293 * but WITHOUT ANY WARRANTY; without even the implied warranty of
294 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
295 * GNU General Public License for more details.
296 *
297 * You should have received a copy of the GNU General Public License
298 * along with this program; if not, see: <http://www.gnu.org/licenses/>
299 */
300 #include "config.h"
301 #include "types.h"
302 #include "libs/FGettext.h"
303
304 #define MAX_VARS 5120
305 extern int numligne;
306 ScriptProp *scriptprop;
307 int nbobj=-1; /* Number of objects */
308 int HasPosition,HasType=0;
309 TabObj *tabobj; /* Array of objects, limit=1000 */
310 int TabIdObj[1001]; /* Array of object IDs */
311 Bloc **TabIObj; /* TabIObj[Obj][Case] -> block linked to case */
312 Bloc *PileBloc[10]; /* 10 imbrications max for conditional loops */
313 int TopPileB=0; /* Top of block stack */
314 CaseObj *TabCObj; /* Structure to store case values and numbers */
315 int CurrCase;
316 int i;
317 char **TabNVar; /* Array for variable names */
318 char **TabVVar; /* Array for variable values */
319 int NbVar;
320 long BuffArg[6][20]; /* Arguments are stacked for each function */
321 int NbArg[6]; /* Array: number of arguments for each layer */
322 int SPileArg; /* Size of argument stack */
323 long l;
324 extern char* ScriptName;
325
326 /* Global Initialization */
InitVarGlob(void)327 void InitVarGlob(void)
328 {
329 scriptprop=fxcalloc(1, sizeof(ScriptProp));
330 scriptprop->x=-1;
331 scriptprop->y=-1;
332 scriptprop->colorset = -1;
333 scriptprop->initbloc=NULL;
334
335 tabobj=fxcalloc(1, sizeof(TabObj));
336 for (i=0;i<1001;i++)
337 TabIdObj[i]=-1;
338 TabNVar=NULL;
339 TabVVar=NULL;
340 NbVar=-1;
341
342 SPileArg=-1;
343 scriptprop->usegettext = False;
344 scriptprop->periodictasks=NULL;
345 scriptprop->quitfunc=NULL;
346 }
347
348 /* Object Initialization */
InitObjTabCase(int HasMainLoop)349 void InitObjTabCase(int HasMainLoop)
350 {
351 if (nbobj==0)
352 {
353 TabIObj=fxcalloc(1, sizeof(long));
354 TabCObj=fxcalloc(1, sizeof(CaseObj));
355 }
356 else
357 {
358 TabIObj=(Bloc**)realloc(TabIObj,sizeof(long)*(nbobj+1));
359 TabCObj=(CaseObj*)realloc(TabCObj,sizeof(CaseObj)*(nbobj+1));
360 }
361
362 if (!HasMainLoop)
363 TabIObj[nbobj]=NULL;
364 CurrCase=-1;
365 TabCObj[nbobj].NbCase=-1;
366 }
367
368 /* Add a case in TabCase array */
369 /* Case Initialization: increase array size */
InitCase(int cond)370 void InitCase(int cond)
371 {
372 CurrCase++;
373
374 /* We store the case condition */
375 TabCObj[nbobj].NbCase++;
376 if (TabCObj[nbobj].NbCase==0)
377 TabCObj[nbobj].LstCase=fxcalloc(1, sizeof(int));
378 else
379 TabCObj[nbobj].LstCase=(int*)realloc(TabCObj[nbobj].LstCase,sizeof(int)*(CurrCase+1));
380 TabCObj[nbobj].LstCase[CurrCase]=cond;
381
382 if (CurrCase==0)
383 TabIObj[nbobj]=fxcalloc(1, sizeof(Bloc));
384 else
385 TabIObj[nbobj]=(Bloc*)realloc(TabIObj[nbobj],sizeof(Bloc)*(CurrCase+1));
386
387 TabIObj[nbobj][CurrCase].NbInstr=-1;
388 TabIObj[nbobj][CurrCase].TabInstr=NULL;
389
390 /* This case is for current instruction block: we stack it */
391 PileBloc[0]=&TabIObj[nbobj][CurrCase];
392 TopPileB=0;
393 }
394
395 /* Remove an argument level in BuffArg stack */
RmLevelBufArg(void)396 void RmLevelBufArg(void)
397 {
398 SPileArg--;
399 }
400
401 /* Function to concatenate the n latest levels of stack */
402 /* Returns sorted, unstacked elements and size */
Depile(int NbLevelArg,int * s)403 long *Depile(int NbLevelArg, int *s)
404 {
405 long *Temp;
406 int j;
407 int i;
408 int size;
409
410 if (NbLevelArg>0)
411 {
412 Temp=fxcalloc(1, sizeof(long));
413 size=0;
414 for (i=SPileArg-NbLevelArg+1;i<=SPileArg;i++)
415 {
416 size=NbArg[i]+size+1;
417 Temp=(long*)realloc (Temp,sizeof(long)*size);
418 for (j=0;j<=NbArg[i];j++)
419 {
420 Temp[j+size-NbArg[i]-1]=BuffArg[i][j];
421 }
422 }
423 *s=size;
424 for (i=0;i<NbLevelArg;i++) /* Unstack argument layers */
425 RmLevelBufArg();
426 return Temp;
427 }
428 else
429 {
430 *s=0;
431 return NULL;
432 }
433 }
434
435 /* Add a command */
AddCom(int Type,int NbLevelArg)436 void AddCom(int Type, int NbLevelArg)
437 {
438 int CurrInstr;
439
440
441 PileBloc[TopPileB]->NbInstr++;
442 CurrInstr=PileBloc[TopPileB]->NbInstr;
443
444 if (CurrInstr==0)
445 PileBloc[TopPileB]->TabInstr=fxcalloc(1, sizeof(Instr) * (CurrInstr + 1));
446 else
447 PileBloc[TopPileB]->TabInstr=(Instr*)realloc(PileBloc[TopPileB]->TabInstr,
448 sizeof(Instr)*(CurrInstr+1));
449 /* Put instructins into block */
450 PileBloc[TopPileB]->TabInstr[CurrInstr].Type=Type;
451 /* We remove the last argument layer, and we put it in command */
452
453 PileBloc[TopPileB]->TabInstr[CurrInstr].TabArg=Depile(NbLevelArg,
454 &PileBloc[TopPileB]->TabInstr[CurrInstr].NbArg);
455 }
456
457 /* Initialize the buffer containing current command arguments */
458 /* Add a layer of arguments in stack */
AddLevelBufArg(void)459 void AddLevelBufArg(void)
460 {
461 /* Increase stack size */
462 SPileArg++;
463 NbArg[SPileArg]=-1;
464 }
465
466 /* Add an argument in the argument layer on top of TabArg stack */
AddBufArg(long * TabLong,int NbLong)467 void AddBufArg(long *TabLong,int NbLong)
468 {
469 int i;
470
471 for (i=0;i<NbLong;i++)
472 {
473 BuffArg[SPileArg][i+NbArg[SPileArg]+1]=TabLong[i];
474 }
475 NbArg[SPileArg]=NbArg[SPileArg]+NbLong;
476 }
477
478 /* Search for a variable name in TabVar, create it if nonexistant */
479 /* Returns an Id */
AddVar(char * Name)480 void AddVar(char *Name) /* ajout de variable a la fin de la derniere commande pointee */
481 {
482 int i;
483
484 /* Comparison of already existing variables */
485 for (i=0;i<=NbVar;i++)
486 if (strcmp(TabNVar[i],Name)==0)
487 {
488 l=(long)i;
489 AddBufArg(&l,1);
490 return ;
491 }
492
493 if (NbVar>MAX_VARS-2)
494 {
495 fvwm_debug(__func__,
496 "[%s] Line %d: too many variables (>5120)\n",ScriptName,numligne);
497 exit(1);
498 }
499
500 /* Variable was not found: create it */
501 NbVar++;
502
503 if (NbVar==0)
504 {
505 TabNVar=fxcalloc(1, sizeof(long));
506 TabVVar=fxcalloc(1, sizeof(long));
507 }
508 else
509 {
510 TabNVar=(char**)realloc(TabNVar,sizeof(long)*(NbVar+1));
511 TabVVar=(char**)realloc(TabVVar,sizeof(long)*(NbVar+1));
512 }
513
514 TabNVar[NbVar]=fxstrdup(Name);
515 TabVVar[NbVar]=fxcalloc(1, sizeof(char));
516 TabVVar[NbVar][0]='\0';
517
518
519 /* Add variable into Arg buffer */
520 l=(long)NbVar;
521 AddBufArg(&l,1);
522 return ;
523 }
524
525 /* Add a string constant as argument */
AddConstStr(char * Name)526 void AddConstStr(char *Name)
527 {
528 /* We create a new vraible and put constant in it */
529 NbVar++;
530 if (NbVar==0)
531 {
532 TabVVar=fxcalloc(1, sizeof(long));
533 TabNVar=fxcalloc(1, sizeof(long));
534 }
535 else
536 {
537 TabVVar=(char**)realloc(TabVVar,sizeof(long)*(NbVar+1));
538 TabNVar=(char**)realloc(TabNVar,sizeof(long)*(NbVar+1));
539 }
540
541 TabNVar[NbVar]=fxcalloc(1, sizeof(char));
542 TabNVar[NbVar][0]='\0';
543 TabVVar[NbVar]=fxstrdup(Name);
544
545 /* Add the constant Id into the current list of arguments */
546 l=(long)NbVar;
547 AddBufArg(&l,1);
548 }
549
550 /* Add a number constant as argument */
AddConstNum(long num)551 void AddConstNum(long num)
552 {
553
554 /* We don't create a new variable */
555 /* Number is codede to become an ID */
556 l=num+200000;
557 /* Add the constant into the current list of arguments */
558 AddBufArg(&l,1);
559 }
560
561 /* Add a function as argument */
562 /* Remove function arguments from stack, */
563 /* concatenate them, and put them into stack */
AddFunct(int code,int NbLevelArg)564 void AddFunct(int code,int NbLevelArg)
565 {
566 int size;
567 long *l;
568 int i;
569
570 /* Method: unstack BuffArg and complete the bottom level of BuffArg */
571 l=Depile(NbLevelArg, &size);
572
573 size++;
574 if (size==1)
575 l=fxcalloc(1, sizeof(long));
576 else
577 {
578 l=(long*)realloc(l,sizeof(long)*(size));
579 for (i=size-2;i>-1;i--) /* Move arguments */
580 {
581 l[i+1]=l[i];
582 }
583 }
584 l[0]=(long)code-150000;
585
586 AddBufArg(l,size);
587 }
588
589 /* Add a test instruction to execute one block or more */
590 /* store the instruction and these blocks field becomes NULL */
AddComBloc(int TypeCond,int NbLevelArg,int NbBloc)591 void AddComBloc(int TypeCond, int NbLevelArg, int NbBloc)
592 {
593 int i;
594 int OldNA;
595 int CurrInstr;
596
597 /* Add the test instruction as a command */
598 AddCom(TypeCond, NbLevelArg);
599
600 /* We then initialize both fields for bloc1 and bloc2 */
601 CurrInstr=PileBloc[TopPileB]->NbInstr;
602 /* Caution: NbArg can change if we use a function as argument */
603 OldNA=PileBloc[TopPileB]->TabInstr[CurrInstr].NbArg;
604
605 PileBloc[TopPileB]->TabInstr[CurrInstr].TabArg=(long*)realloc(
606 PileBloc[TopPileB]->TabInstr[CurrInstr].TabArg,sizeof(long)*(OldNA+NbBloc));
607 for (i=0;i<NbBloc;i++)
608 {
609 PileBloc[TopPileB]->TabInstr[CurrInstr].TabArg[OldNA+i]=0;
610 }
611 PileBloc[TopPileB]->TabInstr[CurrInstr].NbArg=OldNA+NbBloc;
612 }
613
614 /* Create a new block, and stack it: it's becoming the current block */
EmpilerBloc(void)615 void EmpilerBloc(void)
616 {
617 Bloc *TmpBloc;
618
619 TmpBloc=fxcalloc(1, sizeof(Bloc));
620 TmpBloc->NbInstr=-1;
621 TmpBloc->TabInstr=NULL;
622 TopPileB++;
623 PileBloc[TopPileB]=TmpBloc;
624
625 }
626
627 /* Unstack the script intitialization block and put it into its special location */
DepilerBloc(int IdBloc)628 void DepilerBloc(int IdBloc)
629 {
630 Bloc *Bloc1;
631 Instr *IfInstr;
632
633 Bloc1=PileBloc[TopPileB];
634 TopPileB--;
635 IfInstr=&PileBloc[TopPileB]->TabInstr[PileBloc[TopPileB]->NbInstr];
636 IfInstr->TabArg[IfInstr->NbArg-IdBloc]=(long)Bloc1;
637 }
638
639 /* Syntax error management */
yyerror(char * errmsg)640 int yyerror(char *errmsg)
641 {
642 fvwm_debug(__func__, "[%s] Line %d: %s\n",ScriptName,numligne,errmsg);
643 return 0;
644 }
645
646
647
648
649 /* Enabling traces. */
650 #ifndef YYDEBUG
651 # define YYDEBUG 0
652 #endif
653
654 /* Enabling verbose error messages. */
655 #ifdef YYERROR_VERBOSE
656 # undef YYERROR_VERBOSE
657 # define YYERROR_VERBOSE 1
658 #else
659 # define YYERROR_VERBOSE 0
660 #endif
661
662 /* Enabling the token table. */
663 #ifndef YYTOKEN_TABLE
664 # define YYTOKEN_TABLE 0
665 #endif
666
667 #if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
668 typedef union YYSTYPE
669 #line 368 "script.y"
670 { char *str;
671 int number;
672 }
673 /* Line 187 of yacc.c. */
674 #line 678 "y.tab.c"
675 YYSTYPE;
676 # define yystype YYSTYPE /* obsolescent; will be withdrawn */
677 # define YYSTYPE_IS_DECLARED 1
678 # define YYSTYPE_IS_TRIVIAL 1
679 #endif
680
681
682
683 /* Copy the second part of user declarations. */
684
685
686 /* Line 216 of yacc.c. */
687 #line 691 "y.tab.c"
688
689 #ifdef short
690 # undef short
691 #endif
692
693 #ifdef YYTYPE_UINT8
694 typedef YYTYPE_UINT8 yytype_uint8;
695 #else
696 typedef unsigned char yytype_uint8;
697 #endif
698
699 #ifdef YYTYPE_INT8
700 typedef YYTYPE_INT8 yytype_int8;
701 #elif (defined __STDC__ || defined __C99__FUNC__ \
702 || defined __cplusplus || defined _MSC_VER)
703 typedef signed char yytype_int8;
704 #else
705 typedef short int yytype_int8;
706 #endif
707
708 #ifdef YYTYPE_UINT16
709 typedef YYTYPE_UINT16 yytype_uint16;
710 #else
711 typedef unsigned short int yytype_uint16;
712 #endif
713
714 #ifdef YYTYPE_INT16
715 typedef YYTYPE_INT16 yytype_int16;
716 #else
717 typedef short int yytype_int16;
718 #endif
719
720 #ifndef YYSIZE_T
721 # ifdef __SIZE_TYPE__
722 # define YYSIZE_T __SIZE_TYPE__
723 # elif defined size_t
724 # define YYSIZE_T size_t
725 # elif ! defined YYSIZE_T && (defined __STDC__ || defined __C99__FUNC__ \
726 || defined __cplusplus || defined _MSC_VER)
727 # include <stddef.h> /* INFRINGES ON USER NAME SPACE */
728 # define YYSIZE_T size_t
729 # else
730 # define YYSIZE_T unsigned int
731 # endif
732 #endif
733
734 #define YYSIZE_MAXIMUM ((YYSIZE_T) -1)
735
736 #ifndef YY_
737 # if YYENABLE_NLS
738 # if ENABLE_NLS
739 # include <libintl.h> /* INFRINGES ON USER NAME SPACE */
740 # define YY_(msgid) dgettext ("bison-runtime", msgid)
741 # endif
742 # endif
743 # ifndef YY_
744 # define YY_(msgid) msgid
745 # endif
746 #endif
747
748 /* Suppress unused-variable warnings by "using" E. */
749 #if ! defined lint || defined __GNUC__
750 # define YYUSE(e) ((void) (e))
751 #else
752 # define YYUSE(e) /* empty */
753 #endif
754
755 /* Identity function, used to suppress warnings about constant conditions. */
756 #ifndef lint
757 # define YYID(n) (n)
758 #else
759 #if (defined __STDC__ || defined __C99__FUNC__ \
760 || defined __cplusplus || defined _MSC_VER)
761 static int
YYID(int i)762 YYID (int i)
763 #else
764 static int
765 YYID (i)
766 int i;
767 #endif
768 {
769 return i;
770 }
771 #endif
772
773 #if ! defined yyoverflow || YYERROR_VERBOSE
774
775 /* The parser invokes alloca or malloc; define the necessary symbols. */
776
777 # ifdef YYSTACK_USE_ALLOCA
778 # if YYSTACK_USE_ALLOCA
779 # ifdef __GNUC__
780 # define YYSTACK_ALLOC __builtin_alloca
781 # elif defined __BUILTIN_VA_ARG_INCR
782 # include <alloca.h> /* INFRINGES ON USER NAME SPACE */
783 # elif defined _AIX
784 # define YYSTACK_ALLOC __alloca
785 # elif defined _MSC_VER
786 # include <malloc.h> /* INFRINGES ON USER NAME SPACE */
787 # define alloca _alloca
788 # else
789 # define YYSTACK_ALLOC alloca
790 # if ! defined _ALLOCA_H && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
791 || defined __cplusplus || defined _MSC_VER)
792 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
793 # ifndef _STDLIB_H
794 # define _STDLIB_H 1
795 # endif
796 # endif
797 # endif
798 # endif
799 # endif
800
801 # ifdef YYSTACK_ALLOC
802 /* Pacify GCC's `empty if-body' warning. */
803 # define YYSTACK_FREE(Ptr) do { /* empty */; } while (YYID (0))
804 # ifndef YYSTACK_ALLOC_MAXIMUM
805 /* The OS might guarantee only one guard page at the bottom of the stack,
806 and a page size can be as small as 4096 bytes. So we cannot safely
807 invoke alloca (N) if N exceeds 4096. Use a slightly smaller number
808 to allow for a few compiler-allocated temporary stack slots. */
809 # define YYSTACK_ALLOC_MAXIMUM 4032 /* reasonable circa 2006 */
810 # endif
811 # else
812 # define YYSTACK_ALLOC YYMALLOC
813 # define YYSTACK_FREE YYFREE
814 # ifndef YYSTACK_ALLOC_MAXIMUM
815 # define YYSTACK_ALLOC_MAXIMUM YYSIZE_MAXIMUM
816 # endif
817 # if (defined __cplusplus && ! defined _STDLIB_H \
818 && ! ((defined YYMALLOC || defined malloc) \
819 && (defined YYFREE || defined free)))
820 # include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
821 # ifndef _STDLIB_H
822 # define _STDLIB_H 1
823 # endif
824 # endif
825 # ifndef YYMALLOC
826 # define YYMALLOC malloc
827 # if ! defined malloc && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
828 || defined __cplusplus || defined _MSC_VER)
829 void *malloc (YYSIZE_T); /* INFRINGES ON USER NAME SPACE */
830 # endif
831 # endif
832 # ifndef YYFREE
833 # define YYFREE free
834 # if ! defined free && ! defined _STDLIB_H && (defined __STDC__ || defined __C99__FUNC__ \
835 || defined __cplusplus || defined _MSC_VER)
836 void free (void *); /* INFRINGES ON USER NAME SPACE */
837 # endif
838 # endif
839 # endif
840 #endif /* ! defined yyoverflow || YYERROR_VERBOSE */
841
842
843 #if (! defined yyoverflow \
844 && (! defined __cplusplus \
845 || (defined YYSTYPE_IS_TRIVIAL && YYSTYPE_IS_TRIVIAL)))
846
847 /* A type that is properly aligned for any stack member. */
848 union yyalloc
849 {
850 yytype_int16 yyss;
851 YYSTYPE yyvs;
852 };
853
854 /* The size of the maximum gap between one aligned stack and the next. */
855 # define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
856
857 /* The size of an array large to enough to hold all stacks, each with
858 N elements. */
859 # define YYSTACK_BYTES(N) \
860 ((N) * (sizeof (yytype_int16) + sizeof (YYSTYPE)) \
861 + YYSTACK_GAP_MAXIMUM)
862
863 /* Copy COUNT objects from FROM to TO. The source and destination do
864 not overlap. */
865 # ifndef YYCOPY
866 # if defined __GNUC__ && 1 < __GNUC__
867 # define YYCOPY(To, From, Count) \
868 __builtin_memcpy (To, From, (Count) * sizeof (*(From)))
869 # else
870 # define YYCOPY(To, From, Count) \
871 do \
872 { \
873 YYSIZE_T yyi; \
874 for (yyi = 0; yyi < (Count); yyi++) \
875 (To)[yyi] = (From)[yyi]; \
876 } \
877 while (YYID (0))
878 # endif
879 # endif
880
881 /* Relocate STACK from its old location to the new one. The
882 local variables YYSIZE and YYSTACKSIZE give the old and new number of
883 elements in the stack, and YYPTR gives the new location of the
884 stack. Advance YYPTR to a properly aligned location for the next
885 stack. */
886 # define YYSTACK_RELOCATE(Stack) \
887 do \
888 { \
889 YYSIZE_T yynewbytes; \
890 YYCOPY (&yyptr->Stack, Stack, yysize); \
891 Stack = &yyptr->Stack; \
892 yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
893 yyptr += yynewbytes / sizeof (*yyptr); \
894 } \
895 while (YYID (0))
896
897 #endif
898
899 /* YYFINAL -- State number of the termination state. */
900 #define YYFINAL 3
901 /* YYLAST -- Last index in YYTABLE. */
902 #define YYLAST 1277
903
904 /* YYNTOKENS -- Number of terminals. */
905 #define YYNTOKENS 108
906 /* YYNNTS -- Number of nonterminals. */
907 #define YYNNTS 67
908 /* YYNRULES -- Number of rules. */
909 #define YYNRULES 217
910 /* YYNRULES -- Number of states. */
911 #define YYNSTATES 474
912
913 /* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
914 #define YYUNDEFTOK 2
915 #define YYMAXUTOK 362
916
917 #define YYTRANSLATE(YYX) \
918 ((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
919
920 /* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
921 static const yytype_uint8 yytranslate[] =
922 {
923 0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
924 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
925 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
926 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
927 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
928 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
929 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
930 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
931 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
932 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
933 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
934 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
935 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
936 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
937 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
938 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
939 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
940 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
941 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
942 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
943 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
944 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
945 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
946 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
947 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
948 2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
949 5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
950 15, 16, 17, 18, 19, 20, 21, 22, 23, 24,
951 25, 26, 27, 28, 29, 30, 31, 32, 33, 34,
952 35, 36, 37, 38, 39, 40, 41, 42, 43, 44,
953 45, 46, 47, 48, 49, 50, 51, 52, 53, 54,
954 55, 56, 57, 58, 59, 60, 61, 62, 63, 64,
955 65, 66, 67, 68, 69, 70, 71, 72, 73, 74,
956 75, 76, 77, 78, 79, 80, 81, 82, 83, 84,
957 85, 86, 87, 88, 89, 90, 91, 92, 93, 94,
958 95, 96, 97, 98, 99, 100, 101, 102, 103, 104,
959 105, 106, 107
960 };
961
962 #if YYDEBUG
963 /* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
964 YYRHS. */
965 static const yytype_uint16 yyprhs[] =
966 {
967 0, 0, 3, 10, 11, 12, 16, 19, 23, 27,
968 31, 36, 41, 45, 49, 53, 57, 61, 64, 65,
969 71, 72, 78, 79, 85, 86, 94, 96, 97, 101,
970 106, 111, 115, 119, 123, 127, 131, 135, 139, 143,
971 147, 151, 155, 159, 162, 166, 167, 170, 173, 176,
972 179, 182, 185, 186, 188, 194, 195, 196, 201, 206,
973 208, 210, 212, 216, 217, 221, 225, 229, 233, 237,
974 241, 245, 249, 254, 258, 262, 266, 270, 274, 278,
975 282, 286, 290, 294, 298, 302, 306, 310, 314, 318,
976 322, 326, 329, 332, 335, 338, 341, 344, 347, 350,
977 354, 357, 360, 363, 366, 369, 372, 375, 378, 381,
978 384, 387, 390, 393, 396, 399, 402, 405, 408, 411,
979 414, 419, 424, 429, 436, 443, 448, 453, 458, 463,
980 468, 473, 479, 484, 485, 488, 493, 498, 509, 514,
981 519, 523, 527, 535, 536, 540, 541, 545, 547, 551,
982 553, 563, 571, 573, 575, 577, 579, 581, 583, 584,
983 587, 590, 595, 599, 602, 606, 610, 614, 619, 622,
984 624, 627, 631, 633, 636, 639, 642, 645, 648, 651,
985 654, 656, 661, 665, 667, 670, 671, 674, 677, 680,
986 683, 686, 689, 695, 697, 699, 701, 703, 705, 707,
987 712, 714, 716, 718, 720, 725, 727, 729, 734, 736,
988 738, 743, 745, 747, 749, 751, 753, 755
989 };
990
991 /* YYRHS -- A `-1'-separated list of the rules' RHS. */
992 static const yytype_int16 yyrhs[] =
993 {
994 109, 0, -1, 110, 111, 112, 113, 114, 115, -1,
995 -1, -1, 111, 12, 4, -1, 111, 12, -1, 111,
996 8, 4, -1, 111, 9, 4, -1, 111, 33, 3,
997 -1, 111, 11, 7, 7, -1, 111, 10, 7, 7,
998 -1, 111, 14, 4, -1, 111, 13, 4, -1, 111,
999 15, 4, -1, 111, 16, 4, -1, 111, 17, 7,
1000 -1, 111, 6, -1, -1, 19, 155, 47, 126, 23,
1001 -1, -1, 20, 155, 47, 126, 23, -1, -1, 21,
1002 155, 47, 126, 23, -1, -1, 115, 18, 116, 24,
1003 117, 119, 120, -1, 7, -1, -1, 117, 25, 3,
1004 -1, 117, 26, 7, 7, -1, 117, 27, 7, 7,
1005 -1, 117, 28, 7, -1, 117, 29, 7, -1, 117,
1006 30, 7, -1, 117, 31, 4, -1, 117, 37, 4,
1007 -1, 117, 32, 4, -1, 117, 33, 3, -1, 117,
1008 14, 4, -1, 117, 13, 4, -1, 117, 15, 4,
1009 -1, 117, 16, 4, -1, 117, 17, 7, -1, 117,
1010 6, -1, 117, 34, 118, -1, -1, 118, 38, -1,
1011 118, 40, -1, 118, 39, -1, 118, 41, -1, 118,
1012 42, -1, 118, 43, -1, -1, 23, -1, 22, 121,
1013 44, 122, 23, -1, -1, -1, 122, 123, 48, 125,
1014 -1, 122, 124, 48, 125, -1, 45, -1, 46, -1,
1015 7, -1, 47, 126, 23, -1, -1, 126, 49, 128,
1016 -1, 126, 35, 145, -1, 126, 36, 147, -1, 126,
1017 50, 129, -1, 126, 51, 130, -1, 126, 66, 131,
1018 -1, 126, 67, 132, -1, 126, 68, 133, -1, 126,
1019 56, 166, 172, -1, 126, 57, 170, -1, 126, 27,
1020 134, -1, 126, 26, 135, -1, 126, 31, 137, -1,
1021 126, 37, 149, -1, 126, 33, 136, -1, 126, 52,
1022 138, -1, 126, 53, 139, -1, 126, 54, 140, -1,
1023 126, 55, 141, -1, 126, 83, 142, -1, 126, 84,
1024 143, -1, 126, 77, 144, -1, 126, 80, 146, -1,
1025 126, 93, 150, -1, 126, 96, 151, -1, 126, 99,
1026 152, -1, 126, 58, 148, -1, 49, 128, -1, 35,
1027 145, -1, 36, 147, -1, 50, 129, -1, 51, 130,
1028 -1, 66, 131, -1, 67, 132, -1, 68, 133, -1,
1029 56, 166, 172, -1, 57, 170, -1, 27, 134, -1,
1030 26, 135, -1, 31, 137, -1, 37, 149, -1, 33,
1031 136, -1, 52, 138, -1, 53, 139, -1, 54, 140,
1032 -1, 55, 141, -1, 83, 142, -1, 84, 143, -1,
1033 77, 144, -1, 80, 146, -1, 96, 151, -1, 99,
1034 152, -1, 58, 148, -1, 166, 168, -1, 166, 170,
1035 -1, 166, 170, -1, 166, 170, 166, 170, -1, 166,
1036 170, 166, 170, -1, 166, 170, 166, 170, -1, 166,
1037 170, 166, 170, 166, 170, -1, 166, 170, 166, 170,
1038 166, 170, -1, 166, 170, 166, 171, -1, 166, 170,
1039 166, 172, -1, 166, 170, 166, 168, -1, 166, 170,
1040 166, 172, -1, 166, 170, 166, 172, -1, 166, 170,
1041 166, 170, -1, 166, 173, 82, 166, 168, -1, 166,
1042 170, 166, 170, -1, -1, 166, 170, -1, 166, 170,
1043 166, 168, -1, 166, 171, 166, 168, -1, 166, 171,
1044 166, 171, 166, 170, 166, 170, 166, 168, -1, 166,
1045 170, 166, 172, -1, 153, 155, 156, 154, -1, 158,
1046 155, 157, -1, 159, 155, 157, -1, 166, 169, 166,
1047 174, 166, 169, 94, -1, -1, 95, 155, 157, -1,
1048 -1, 47, 126, 23, -1, 127, -1, 47, 126, 23,
1049 -1, 127, -1, 166, 173, 82, 166, 169, 97, 166,
1050 169, 98, -1, 166, 169, 166, 174, 166, 169, 98,
1051 -1, 5, -1, 3, -1, 4, -1, 7, -1, 45,
1052 -1, 46, -1, -1, 59, 170, -1, 72, 170, -1,
1053 73, 172, 170, 170, -1, 75, 170, 170, -1, 76,
1054 172, -1, 69, 170, 170, -1, 71, 170, 170, -1,
1055 70, 170, 170, -1, 74, 172, 170, 170, -1, 78,
1056 172, -1, 79, -1, 81, 170, -1, 85, 170, 170,
1057 -1, 86, -1, 87, 170, -1, 62, 170, -1, 63,
1058 170, -1, 64, 170, -1, 65, 170, -1, 60, 170,
1059 -1, 61, 170, -1, 88, -1, 89, 172, 172, 170,
1060 -1, 90, 172, 170, -1, 91, -1, 92, 172, -1,
1061 -1, 164, 168, -1, 165, 168, -1, 160, 168, -1,
1062 162, 168, -1, 161, 168, -1, 163, 168, -1, 100,
1063 166, 167, 101, 168, -1, 160, -1, 164, -1, 165,
1064 -1, 162, -1, 161, -1, 163, -1, 100, 166, 167,
1065 101, -1, 164, -1, 165, -1, 163, -1, 160, -1,
1066 100, 166, 167, 101, -1, 160, -1, 161, -1, 100,
1067 166, 167, 101, -1, 160, -1, 162, -1, 100, 166,
1068 167, 101, -1, 160, -1, 105, -1, 103, -1, 102,
1069 -1, 104, -1, 106, -1, 107, -1
1070 };
1071
1072 /* YYRLINE[YYN] -- source line where rule number YYN was defined. */
1073 static const yytype_uint16 yyrline[] =
1074 {
1075 0, 393, 393, 396, 400, 401, 406, 412, 417, 422,
1076 426, 432, 438, 444, 450, 456, 462, 467, 473, 474,
1077 479, 480, 485, 486, 495, 496, 499, 515, 516, 520,
1078 524, 529, 532, 535, 538, 541, 544, 547, 550, 554,
1079 558, 562, 566, 570, 573, 575, 576, 579, 582, 585,
1080 588, 591, 597, 608, 609, 612, 614, 615, 616, 619,
1081 620, 623, 626, 631, 632, 633, 634, 635, 636, 637,
1082 638, 639, 640, 641, 642, 643, 644, 645, 646, 647,
1083 648, 649, 650, 651, 652, 653, 654, 655, 656, 657,
1084 658, 662, 663, 664, 665, 666, 667, 668, 669, 670,
1085 671, 672, 673, 674, 675, 676, 677, 678, 679, 680,
1086 681, 682, 683, 684, 685, 686, 687, 690, 692, 694,
1087 696, 698, 700, 702, 704, 706, 708, 710, 712, 714,
1088 716, 718, 720, 722, 724, 726, 728, 730, 732, 734,
1089 736, 738, 742, 744, 745, 747, 749, 750, 753, 754,
1090 758, 762, 767, 769, 771, 773, 775, 777, 779, 781,
1091 782, 783, 784, 785, 786, 787, 788, 789, 790, 791,
1092 792, 793, 794, 795, 796, 797, 798, 799, 800, 801,
1093 802, 803, 804, 805, 806, 811, 812, 813, 814, 815,
1094 816, 817, 818, 822, 823, 824, 825, 826, 827, 828,
1095 832, 833, 834, 835, 836, 840, 841, 842, 846, 847,
1096 848, 852, 856, 857, 858, 859, 860, 861
1097 };
1098 #endif
1099
1100 #if YYDEBUG || YYERROR_VERBOSE || YYTOKEN_TABLE
1101 /* YYTNAME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
1102 First, the terminals, then, starting at YYNTOKENS, nonterminals. */
1103 static const char *const yytname[] =
1104 {
1105 "$end", "error", "$undefined", "STR", "GSTR", "VAR", "FONT", "NUMBER",
1106 "WINDOWTITLE", "WINDOWLOCALETITLE", "WINDOWSIZE", "WINDOWPOSITION",
1107 "USEGETTEXT", "FORECOLOR", "BACKCOLOR", "SHADCOLOR", "LICOLOR",
1108 "COLORSET", "OBJECT", "INIT", "PERIODICTASK", "QUITFUNC", "MAIN", "END",
1109 "PROP", "TYPE", "SIZE", "POSITION", "VALUE", "VALUEMIN", "VALUEMAX",
1110 "TITLE", "SWALLOWEXEC", "ICON", "FLAGS", "WARP", "WRITETOFILE",
1111 "LOCALETITLE", "HIDDEN", "NOFOCUS", "NORELIEFSTRING", "CENTER", "LEFT",
1112 "RIGHT", "CASE", "SINGLECLIC", "DOUBLECLIC", "BEG", "POINT", "EXEC",
1113 "HIDE", "SHOW", "CHFONT", "CHFORECOLOR", "CHBACKCOLOR", "CHCOLORSET",
1114 "CHWINDOWTITLE", "CHWINDOWTITLEFARG", "KEY", "GETVALUE", "GETMINVALUE",
1115 "GETMAXVALUE", "GETFORE", "GETBACK", "GETHILIGHT", "GETSHADOW",
1116 "CHVALUE", "CHVALUEMAX", "CHVALUEMIN", "ADD", "DIV", "MULT", "GETTITLE",
1117 "GETOUTPUT", "STRCOPY", "NUMTOHEX", "HEXTONUM", "QUIT", "LAUNCHSCRIPT",
1118 "GETSCRIPTFATHER", "SENDTOSCRIPT", "RECEIVFROMSCRIPT", "GET", "SET",
1119 "SENDSIGN", "REMAINDEROFDIV", "GETTIME", "GETSCRIPTARG", "GETPID",
1120 "SENDMSGANDGET", "PARSE", "LASTSTRING", "GETTEXT", "IF", "THEN", "ELSE",
1121 "FOR", "TO", "DO", "WHILE", "BEGF", "ENDF", "EQUAL", "INFEQ", "SUPEQ",
1122 "INF", "SUP", "DIFF", "$accept", "script", "initvar", "head", "initbloc",
1123 "periodictask", "quitfunc", "object", "id", "init", "flags", "verify",
1124 "mainloop", "addtabcase", "case", "clic", "number", "bloc", "instr",
1125 "oneinstr", "exec", "hide", "show", "chvalue", "chvaluemax",
1126 "chvaluemin", "position", "size", "icon", "title", "font", "chforecolor",
1127 "chbackcolor", "chcolorset", "set", "sendsign", "quit", "warp",
1128 "sendtoscript", "writetofile", "key", "localetitle", "ifthenelse",
1129 "loop", "while", "headif", "else", "creerbloc", "bloc1", "bloc2",
1130 "headloop", "headwhile", "var", "str", "gstr", "num", "singleclic2",
1131 "doubleclic2", "addlbuff", "function", "args", "arg", "numarg", "strarg",
1132 "gstrarg", "vararg", "compare", 0
1133 };
1134 #endif
1135
1136 # ifdef YYPRINT
1137 /* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
1138 token YYLEX-NUM. */
1139 static const yytype_uint16 yytoknum[] =
1140 {
1141 0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
1142 265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
1143 275, 276, 277, 278, 279, 280, 281, 282, 283, 284,
1144 285, 286, 287, 288, 289, 290, 291, 292, 293, 294,
1145 295, 296, 297, 298, 299, 300, 301, 302, 303, 304,
1146 305, 306, 307, 308, 309, 310, 311, 312, 313, 314,
1147 315, 316, 317, 318, 319, 320, 321, 322, 323, 324,
1148 325, 326, 327, 328, 329, 330, 331, 332, 333, 334,
1149 335, 336, 337, 338, 339, 340, 341, 342, 343, 344,
1150 345, 346, 347, 348, 349, 350, 351, 352, 353, 354,
1151 355, 356, 357, 358, 359, 360, 361, 362
1152 };
1153 # endif
1154
1155 /* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
1156 static const yytype_uint8 yyr1[] =
1157 {
1158 0, 108, 109, 110, 111, 111, 111, 111, 111, 111,
1159 111, 111, 111, 111, 111, 111, 111, 111, 112, 112,
1160 113, 113, 114, 114, 115, 115, 116, 117, 117, 117,
1161 117, 117, 117, 117, 117, 117, 117, 117, 117, 117,
1162 117, 117, 117, 117, 117, 118, 118, 118, 118, 118,
1163 118, 118, 119, 120, 120, 121, 122, 122, 122, 123,
1164 123, 124, 125, 126, 126, 126, 126, 126, 126, 126,
1165 126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
1166 126, 126, 126, 126, 126, 126, 126, 126, 126, 126,
1167 126, 127, 127, 127, 127, 127, 127, 127, 127, 127,
1168 127, 127, 127, 127, 127, 127, 127, 127, 127, 127,
1169 127, 127, 127, 127, 127, 127, 127, 128, 129, 130,
1170 131, 132, 133, 134, 135, 136, 137, 138, 139, 140,
1171 141, 142, 143, 144, 145, 146, 147, 148, 149, 150,
1172 151, 152, 153, 154, 154, 155, 156, 156, 157, 157,
1173 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,
1174 167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
1175 167, 167, 167, 167, 167, 167, 167, 167, 167, 167,
1176 167, 167, 167, 167, 167, 168, 168, 168, 168, 168,
1177 168, 168, 168, 169, 169, 169, 169, 169, 169, 169,
1178 170, 170, 170, 170, 170, 171, 171, 171, 172, 172,
1179 172, 173, 174, 174, 174, 174, 174, 174
1180 };
1181
1182 /* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
1183 static const yytype_uint8 yyr2[] =
1184 {
1185 0, 2, 6, 0, 0, 3, 2, 3, 3, 3,
1186 4, 4, 3, 3, 3, 3, 3, 2, 0, 5,
1187 0, 5, 0, 5, 0, 7, 1, 0, 3, 4,
1188 4, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1189 3, 3, 3, 2, 3, 0, 2, 2, 2, 2,
1190 2, 2, 0, 1, 5, 0, 0, 4, 4, 1,
1191 1, 1, 3, 0, 3, 3, 3, 3, 3, 3,
1192 3, 3, 4, 3, 3, 3, 3, 3, 3, 3,
1193 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
1194 3, 2, 2, 2, 2, 2, 2, 2, 2, 3,
1195 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1196 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
1197 4, 4, 4, 6, 6, 4, 4, 4, 4, 4,
1198 4, 5, 4, 0, 2, 4, 4, 10, 4, 4,
1199 3, 3, 7, 0, 3, 0, 3, 1, 3, 1,
1200 9, 7, 1, 1, 1, 1, 1, 1, 0, 2,
1201 2, 4, 3, 2, 3, 3, 3, 4, 2, 1,
1202 2, 3, 1, 2, 2, 2, 2, 2, 2, 2,
1203 1, 4, 3, 1, 2, 0, 2, 2, 2, 2,
1204 2, 2, 5, 1, 1, 1, 1, 1, 1, 4,
1205 1, 1, 1, 1, 4, 1, 1, 4, 1, 1,
1206 4, 1, 1, 1, 1, 1, 1, 1
1207 };
1208
1209 /* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
1210 STATE-NUM when YYTABLE doesn't specify something else to do. Zero
1211 means the default is an error. */
1212 static const yytype_uint8 yydefact[] =
1213 {
1214 3, 0, 4, 1, 18, 17, 0, 0, 0, 0,
1215 6, 0, 0, 0, 0, 0, 145, 0, 20, 7,
1216 8, 0, 0, 5, 13, 12, 14, 15, 16, 0,
1217 9, 145, 22, 11, 10, 63, 0, 145, 24, 0,
1218 63, 0, 2, 19, 158, 158, 158, 158, 158, 158,
1219 158, 158, 158, 158, 158, 158, 158, 158, 158, 0,
1220 158, 158, 158, 158, 133, 158, 158, 158, 158, 158,
1221 158, 0, 63, 0, 75, 0, 74, 0, 76, 0,
1222 78, 0, 65, 0, 66, 0, 77, 0, 64, 185,
1223 67, 0, 68, 0, 79, 0, 80, 0, 81, 0,
1224 82, 0, 0, 152, 155, 156, 157, 158, 203, 202,
1225 200, 201, 73, 90, 0, 69, 0, 70, 0, 71,
1226 0, 85, 86, 0, 83, 0, 84, 0, 87, 145,
1227 0, 88, 145, 0, 89, 145, 0, 21, 0, 26,
1228 0, 158, 158, 158, 158, 134, 153, 158, 205, 206,
1229 158, 158, 154, 158, 185, 185, 185, 185, 185, 185,
1230 117, 118, 119, 158, 158, 158, 158, 158, 208, 209,
1231 72, 0, 158, 158, 158, 158, 158, 211, 0, 158,
1232 0, 158, 193, 197, 196, 198, 194, 195, 158, 0,
1233 0, 0, 158, 23, 27, 0, 0, 0, 0, 0,
1234 185, 0, 0, 188, 190, 189, 191, 186, 187, 185,
1235 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1236 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1237 169, 0, 0, 172, 0, 180, 0, 0, 183, 0,
1238 0, 0, 0, 0, 0, 185, 158, 0, 158, 158,
1239 158, 158, 158, 158, 158, 63, 158, 158, 158, 158,
1240 158, 158, 158, 158, 0, 158, 158, 158, 158, 133,
1241 158, 158, 158, 158, 158, 147, 143, 0, 0, 63,
1242 149, 140, 158, 141, 0, 52, 158, 158, 126, 125,
1243 0, 136, 138, 0, 127, 128, 129, 130, 0, 159,
1244 178, 179, 174, 175, 176, 177, 0, 0, 0, 160,
1245 0, 0, 0, 163, 168, 170, 0, 173, 0, 0,
1246 184, 204, 158, 120, 121, 122, 135, 185, 132, 102,
1247 101, 103, 105, 92, 93, 104, 0, 91, 94, 95,
1248 106, 107, 108, 109, 0, 100, 116, 96, 97, 98,
1249 112, 113, 110, 111, 114, 115, 145, 139, 0, 214,
1250 213, 215, 212, 216, 217, 158, 0, 0, 158, 43,
1251 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1252 0, 0, 0, 0, 45, 0, 0, 0, 0, 207,
1253 185, 210, 164, 166, 165, 0, 0, 162, 171, 0,
1254 182, 0, 131, 146, 99, 0, 199, 0, 148, 0,
1255 0, 39, 38, 40, 41, 42, 28, 0, 0, 31,
1256 32, 33, 34, 36, 37, 44, 35, 55, 53, 25,
1257 124, 123, 192, 161, 167, 181, 158, 144, 0, 158,
1258 0, 29, 30, 46, 48, 47, 49, 50, 51, 0,
1259 0, 142, 0, 151, 56, 158, 0, 0, 185, 150,
1260 61, 54, 59, 60, 0, 0, 137, 0, 0, 63,
1261 57, 58, 0, 62
1262 };
1263
1264 /* YYDEFGOTO[NTERM-NUM]. */
1265 static const yytype_int16 yydefgoto[] =
1266 {
1267 -1, 1, 2, 4, 18, 32, 38, 42, 140, 285,
1268 425, 386, 429, 449, 457, 464, 465, 470, 39, 280,
1269 88, 90, 92, 115, 117, 119, 76, 74, 80, 78,
1270 94, 96, 98, 100, 124, 126, 121, 82, 122, 84,
1271 113, 86, 128, 131, 134, 129, 357, 29, 276, 281,
1272 132, 135, 108, 155, 169, 109, 110, 111, 75, 240,
1273 160, 188, 112, 150, 170, 178, 365
1274 };
1275
1276 /* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
1277 STATE-NUM. */
1278 #define YYPACT_NINF -307
1279 static const yytype_int16 yypact[] =
1280 {
1281 -307, 8, -307, -307, 584, -307, -2, 10, -1, 9,
1282 13, 14, 15, 19, 21, 22, -307, 31, 35, -307,
1283 -307, 28, 57, -307, -307, -307, -307, -307, -307, 18,
1284 -307, -307, 58, -307, -307, -307, 36, -307, -307, 759,
1285 -307, 39, 64, -307, -307, -307, -307, -307, -307, -307,
1286 -307, -307, -307, -307, -307, -307, -307, -307, -307, 26,
1287 -307, -307, -307, -307, -307, -307, -307, -307, -307, -307,
1288 -307, 814, -307, 80, -307, 26, -307, 26, -307, 26,
1289 -307, 26, -307, 26, -307, 2, -307, 26, -307, 17,
1290 -307, 26, -307, 26, -307, 26, -307, 26, -307, 26,
1291 -307, 26, 6, -307, -307, -307, -307, -307, -307, -307,
1292 -307, -307, -307, -307, 2, -307, 26, -307, 26, -307,
1293 26, -307, -307, 26, -307, 85, -307, 26, -307, -307,
1294 23, -307, -307, 85, -307, -307, 23, -307, 869, -307,
1295 67, -307, -307, -307, -307, -307, -307, -307, -307, -307,
1296 -307, -307, -307, -307, 17, 17, 17, 17, 17, 17,
1297 -307, -307, -307, -307, -307, -307, -307, -307, -307, -307,
1298 -307, 1185, -307, -307, -307, -307, -307, -307, 32, -307,
1299 1089, -307, -307, -307, -307, -307, -307, -307, -307, 1144,
1300 33, 1144, -307, -307, -307, 26, 26, 6, 2, 1185,
1301 17, 6, 1185, -307, -307, -307, -307, -307, -307, 17,
1302 6, 6, 26, 1185, 26, 26, 26, 26, 26, 26,
1303 26, 26, 26, 26, 26, 6, 6, 26, 6, 6,
1304 -307, 26, 26, -307, 26, -307, 6, 6, -307, 6,
1305 -6, 2, 26, 26, 26, 17, -307, 26, -307, -307,
1306 -307, -307, -307, -307, -307, -307, -307, -307, -307, -307,
1307 -307, -307, -307, -307, 26, -307, -307, -307, -307, -307,
1308 -307, -307, -307, -307, -307, -307, -3, 1185, -29, -307,
1309 -307, -307, -307, -307, -29, 277, -307, -307, -307, -307,
1310 -5, -307, -307, -4, -307, -307, -307, -307, 4, -307,
1311 -307, -307, -307, -307, -307, -307, 26, 26, 26, -307,
1312 26, 26, 26, -307, -307, -307, 26, -307, 6, 26,
1313 -307, -307, -307, -307, -307, -307, -307, 17, -307, -307,
1314 -307, -307, -307, -307, -307, -307, 924, -307, -307, -307,
1315 -307, -307, -307, -307, 6, -307, -307, -307, -307, -307,
1316 -307, -307, -307, -307, -307, -307, -307, -307, 12, -307,
1317 -307, -307, -307, -307, -307, -307, 979, 23, -307, -307,
1318 95, 96, 99, 106, 109, 115, 114, 117, 118, 120,
1319 122, 126, 127, 133, -307, 135, -10, 26, 26, -307,
1320 17, -307, -307, -307, -307, 26, 26, -307, -307, 26,
1321 -307, 26, -307, -307, -307, 1144, -307, 23, -307, 40,
1322 23, -307, -307, -307, -307, -307, -307, 136, 145, -307,
1323 -307, -307, -307, -307, -307, 108, -307, -307, -307, -307,
1324 -307, -307, -307, -307, -307, -307, -307, -307, 46, -307,
1325 55, -307, -307, -307, -307, -307, -307, -307, -307, 116,
1326 26, -307, 23, -307, -307, -307, 61, 43, 17, -307,
1327 -307, -307, -307, -307, 113, 121, -307, 124, 124, -307,
1328 -307, -307, 1034, -307
1329 };
1330
1331 /* YYPGOTO[NTERM-NUM]. */
1332 static const yytype_int16 yypgoto[] =
1333 {
1334 -307, -307, -307, -307, -307, -307, -307, -307, -307, -307,
1335 -307, -307, -307, -307, -307, -307, -307, -306, -40, -12,
1336 -83, -82, -84, -90, -86, -91, -64, -60, -62, -59,
1337 -67, -65, -68, -63, -74, -69, -61, -47, -58, -46,
1338 -56, -48, -307, -53, -57, -307, -307, -28, -307, -187,
1339 -307, -307, 247, 102, 240, 296, 370, 377, -9, -132,
1340 360, -121, 103, -113, -117, 77, -73
1341 };
1342
1343 /* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
1344 positive, shift that token. If negative, reduce the rule which
1345 number is the opposite. If zero, do what YYDEFACT says.
1346 If YYTABLE_NINF, syntax error. */
1347 #define YYTABLE_NINF -1
1348 static const yytype_uint16 yytable[] =
1349 {
1350 71, 172, 19, 36, 283, 146, 21, 103, 3, 41,
1351 152, 103, 427, 428, 20, 192, 22, 23, 24, 25,
1352 146, 152, 103, 26, 104, 27, 146, 152, 103, 28,
1353 104, 103, 138, 104, 30, 33, 77, 79, 81, 83,
1354 85, 87, 89, 91, 93, 95, 97, 99, 101, 102,
1355 460, 114, 116, 118, 120, 31, 123, 125, 127, 130,
1356 133, 136, 105, 106, 34, 35, 461, 290, 105, 106,
1357 293, 105, 106, 359, 360, 361, 362, 363, 364, 37,
1358 288, 298, 73, 40, 292, 289, 72, 139, 462, 463,
1359 103, 194, 356, 295, 296, 321, 389, 390, 171, 411,
1360 412, 180, 147, 413, 189, 391, 167, 191, 310, 311,
1361 414, 313, 314, 406, 246, 282, 415, 153, 416, 318,
1362 319, 417, 320, 181, 418, 419, 107, 420, 322, 421,
1363 422, 423, 195, 196, 197, 198, 424, 439, 199, 426,
1364 451, 200, 201, 441, 202, 358, 443, 444, 445, 446,
1365 447, 448, 442, 453, 209, 210, 211, 212, 213, 459,
1366 454, 467, 471, 241, 242, 243, 244, 245, 275, 468,
1367 247, 469, 277, 337, 339, 338, 347, 349, 141, 278,
1368 142, 348, 143, 284, 144, 330, 145, 149, 329, 332,
1369 151, 331, 340, 342, 161, 341, 162, 352, 163, 343,
1370 164, 399, 165, 353, 166, 333, 335, 334, 350, 346,
1371 190, 368, 351, 0, 0, 336, 149, 355, 437, 173,
1372 354, 174, 0, 175, 0, 0, 176, 404, 0, 0,
1373 179, 0, 183, 0, 0, 0, 0, 327, 183, 366,
1374 77, 79, 81, 83, 85, 87, 409, 89, 91, 93,
1375 95, 97, 99, 101, 344, 0, 114, 116, 118, 120,
1376 0, 123, 125, 127, 133, 136, 0, 0, 0, 0,
1377 0, 0, 0, 367, 0, 0, 0, 387, 388, 0,
1378 0, 0, 0, 369, 0, 0, 438, 0, 0, 440,
1379 370, 371, 372, 373, 374, 0, 0, 0, 286, 287,
1380 149, 0, 375, 376, 377, 378, 379, 380, 381, 382,
1381 383, 384, 0, 401, 385, 297, 0, 299, 300, 301,
1382 302, 303, 304, 305, 306, 307, 308, 309, 405, 156,
1383 312, 456, 148, 0, 315, 316, 154, 317, 0, 0,
1384 0, 0, 0, 149, 0, 323, 324, 325, 0, 168,
1385 328, 0, 0, 0, 0, 0, 407, 0, 0, 410,
1386 0, 148, 0, 0, 0, 0, 0, 345, 0, 0,
1387 184, 0, 177, 0, 0, 0, 184, 182, 0, 0,
1388 177, 0, 0, 182, 0, 157, 0, 0, 0, 0,
1389 0, 0, 0, 0, 156, 156, 156, 156, 156, 156,
1390 0, 154, 154, 154, 154, 154, 154, 0, 0, 392,
1391 393, 394, 0, 395, 396, 397, 0, 0, 0, 398,
1392 0, 0, 400, 0, 0, 0, 185, 450, 0, 472,
1393 452, 0, 185, 0, 0, 0, 0, 0, 0, 0,
1394 156, 0, 0, 0, 168, 148, 458, 154, 168, 156,
1395 157, 157, 157, 157, 157, 157, 154, 168, 168, 158,
1396 0, 0, 0, 0, 0, 0, 159, 0, 0, 183,
1397 0, 0, 168, 168, 0, 168, 168, 0, 0, 0,
1398 0, 0, 0, 168, 168, 156, 168, 0, 148, 0,
1399 430, 431, 154, 0, 0, 0, 157, 0, 433, 434,
1400 186, 0, 435, 0, 436, 157, 186, 187, 0, 183,
1401 0, 0, 183, 187, 203, 204, 205, 206, 207, 208,
1402 0, 0, 0, 0, 158, 158, 158, 158, 158, 158,
1403 0, 159, 159, 159, 159, 159, 159, 0, 0, 0,
1404 0, 157, 0, 0, 0, 0, 0, 0, 0, 0,
1405 0, 0, 0, 455, 183, 0, 0, 0, 0, 0,
1406 291, 0, 0, 0, 0, 168, 0, 156, 0, 294,
1407 158, 0, 0, 0, 154, 0, 0, 159, 0, 158,
1408 0, 0, 0, 0, 0, 0, 159, 0, 0, 0,
1409 5, 168, 6, 7, 8, 9, 10, 11, 12, 13,
1410 14, 15, 0, 16, 0, 326, 0, 184, 0, 0,
1411 0, 0, 0, 0, 182, 158, 0, 17, 0, 0,
1412 0, 0, 159, 157, 0, 0, 0, 0, 0, 0,
1413 156, 0, 0, 0, 0, 0, 0, 154, 0, 0,
1414 0, 0, 0, 0, 0, 0, 0, 184, 0, 0,
1415 184, 0, 0, 0, 182, 0, 0, 182, 0, 0,
1416 0, 0, 0, 185, 0, 0, 0, 0, 0, 0,
1417 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1418 0, 0, 0, 0, 0, 0, 157, 402, 0, 0,
1419 0, 0, 184, 0, 0, 0, 0, 158, 156, 182,
1420 0, 0, 0, 185, 159, 154, 185, 0, 0, 0,
1421 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1422 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1423 0, 0, 0, 0, 0, 0, 0, 186, 0, 0,
1424 0, 0, 0, 0, 187, 0, 0, 0, 185, 0,
1425 432, 0, 0, 0, 157, 0, 0, 0, 0, 0,
1426 158, 0, 0, 0, 0, 0, 0, 159, 0, 0,
1427 0, 0, 0, 0, 0, 0, 0, 186, 0, 0,
1428 186, 0, 43, 0, 187, 44, 45, 187, 0, 0,
1429 46, 0, 47, 0, 48, 49, 50, 0, 0, 0,
1430 0, 0, 0, 0, 0, 0, 0, 0, 51, 52,
1431 53, 54, 55, 56, 57, 58, 59, 60, 466, 0,
1432 0, 0, 186, 0, 0, 61, 62, 63, 158, 187,
1433 0, 0, 0, 0, 0, 159, 64, 137, 0, 65,
1434 44, 45, 66, 67, 0, 46, 0, 47, 0, 48,
1435 49, 50, 68, 0, 0, 69, 0, 0, 70, 0,
1436 0, 0, 0, 51, 52, 53, 54, 55, 56, 57,
1437 58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
1438 61, 62, 63, 0, 0, 0, 0, 0, 0, 0,
1439 0, 64, 193, 0, 65, 44, 45, 66, 67, 0,
1440 46, 0, 47, 0, 48, 49, 50, 68, 0, 0,
1441 69, 0, 0, 70, 0, 0, 0, 0, 51, 52,
1442 53, 54, 55, 56, 57, 58, 59, 60, 0, 0,
1443 0, 0, 0, 0, 0, 61, 62, 63, 0, 0,
1444 0, 0, 0, 0, 0, 0, 64, 403, 0, 65,
1445 44, 45, 66, 67, 0, 46, 0, 47, 0, 48,
1446 49, 50, 68, 0, 0, 69, 0, 0, 70, 0,
1447 0, 0, 0, 51, 52, 53, 54, 55, 56, 57,
1448 58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
1449 61, 62, 63, 0, 0, 0, 0, 0, 0, 0,
1450 0, 64, 408, 0, 65, 44, 45, 66, 67, 0,
1451 46, 0, 47, 0, 48, 49, 50, 68, 0, 0,
1452 69, 0, 0, 70, 0, 0, 0, 0, 51, 52,
1453 53, 54, 55, 56, 57, 58, 59, 60, 0, 0,
1454 0, 0, 0, 0, 0, 61, 62, 63, 0, 0,
1455 0, 0, 0, 0, 0, 0, 64, 473, 0, 65,
1456 44, 45, 66, 67, 0, 46, 0, 47, 0, 48,
1457 49, 50, 68, 0, 0, 69, 0, 0, 70, 0,
1458 0, 0, 0, 51, 52, 53, 54, 55, 56, 57,
1459 58, 59, 60, 0, 0, 0, 0, 0, 0, 0,
1460 61, 62, 63, 0, 0, 0, 0, 0, 0, 0,
1461 0, 64, 0, 0, 65, 248, 249, 66, 67, 0,
1462 250, 0, 251, 0, 252, 253, 254, 68, 0, 0,
1463 69, 0, 0, 70, 0, 0, 255, 0, 256, 257,
1464 258, 259, 260, 261, 262, 263, 264, 265, 0, 0,
1465 0, 0, 0, 0, 0, 266, 267, 268, 0, 0,
1466 0, 0, 0, 0, 0, 0, 269, 0, 0, 270,
1467 248, 249, 271, 272, 0, 250, 0, 251, 0, 252,
1468 253, 254, 0, 0, 0, 273, 0, 0, 274, 0,
1469 0, 279, 0, 256, 257, 258, 259, 260, 261, 262,
1470 263, 264, 265, 0, 0, 0, 0, 0, 0, 0,
1471 266, 267, 268, 0, 0, 0, 0, 0, 0, 0,
1472 0, 269, 0, 0, 270, 0, 0, 271, 272, 0,
1473 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
1474 273, 0, 0, 274, 214, 215, 216, 217, 218, 219,
1475 220, 0, 0, 0, 221, 222, 223, 224, 225, 226,
1476 227, 228, 0, 229, 230, 0, 231, 0, 0, 0,
1477 232, 233, 234, 235, 236, 237, 238, 239
1478 };
1479
1480 static const yytype_int16 yycheck[] =
1481 {
1482 40, 114, 4, 31, 191, 3, 7, 5, 0, 37,
1483 4, 5, 22, 23, 4, 136, 7, 4, 4, 4,
1484 3, 4, 5, 4, 7, 4, 3, 4, 5, 7,
1485 7, 5, 72, 7, 3, 7, 45, 46, 47, 48,
1486 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,
1487 7, 60, 61, 62, 63, 20, 65, 66, 67, 68,
1488 69, 70, 45, 46, 7, 47, 23, 199, 45, 46,
1489 202, 45, 46, 102, 103, 104, 105, 106, 107, 21,
1490 197, 213, 18, 47, 201, 198, 47, 7, 45, 46,
1491 5, 24, 95, 210, 211, 101, 101, 101, 107, 4,
1492 4, 129, 100, 4, 132, 101, 100, 135, 225, 226,
1493 4, 228, 229, 101, 82, 82, 7, 100, 3, 236,
1494 237, 7, 239, 100, 7, 7, 100, 7, 241, 7,
1495 4, 4, 141, 142, 143, 144, 3, 97, 147, 4,
1496 94, 150, 151, 7, 153, 277, 38, 39, 40, 41,
1497 42, 43, 7, 98, 163, 164, 165, 166, 167, 98,
1498 44, 48, 468, 172, 173, 174, 175, 176, 180, 48,
1499 179, 47, 181, 256, 258, 257, 266, 268, 75, 188,
1500 77, 267, 79, 192, 81, 249, 83, 85, 248, 251,
1501 87, 250, 259, 261, 91, 260, 93, 271, 95, 262,
1502 97, 318, 99, 272, 101, 252, 254, 253, 269, 265,
1503 133, 284, 270, -1, -1, 255, 114, 274, 405, 116,
1504 273, 118, -1, 120, -1, -1, 123, 344, -1, -1,
1505 127, -1, 130, -1, -1, -1, -1, 246, 136, 279,
1506 249, 250, 251, 252, 253, 254, 367, 256, 257, 258,
1507 259, 260, 261, 262, 263, -1, 265, 266, 267, 268,
1508 -1, 270, 271, 272, 273, 274, -1, -1, -1, -1,
1509 -1, -1, -1, 282, -1, -1, -1, 286, 287, -1,
1510 -1, -1, -1, 6, -1, -1, 407, -1, -1, 410,
1511 13, 14, 15, 16, 17, -1, -1, -1, 195, 196,
1512 198, -1, 25, 26, 27, 28, 29, 30, 31, 32,
1513 33, 34, -1, 322, 37, 212, -1, 214, 215, 216,
1514 217, 218, 219, 220, 221, 222, 223, 224, 356, 89,
1515 227, 452, 85, -1, 231, 232, 89, 234, -1, -1,
1516 -1, -1, -1, 241, -1, 242, 243, 244, -1, 102,
1517 247, -1, -1, -1, -1, -1, 365, -1, -1, 368,
1518 -1, 114, -1, -1, -1, -1, -1, 264, -1, -1,
1519 130, -1, 125, -1, -1, -1, 136, 130, -1, -1,
1520 133, -1, -1, 136, -1, 89, -1, -1, -1, -1,
1521 -1, -1, -1, -1, 154, 155, 156, 157, 158, 159,
1522 -1, 154, 155, 156, 157, 158, 159, -1, -1, 306,
1523 307, 308, -1, 310, 311, 312, -1, -1, -1, 316,
1524 -1, -1, 319, -1, -1, -1, 130, 436, -1, 469,
1525 439, -1, 136, -1, -1, -1, -1, -1, -1, -1,
1526 200, -1, -1, -1, 197, 198, 455, 200, 201, 209,
1527 154, 155, 156, 157, 158, 159, 209, 210, 211, 89,
1528 -1, -1, -1, -1, -1, -1, 89, -1, -1, 367,
1529 -1, -1, 225, 226, -1, 228, 229, -1, -1, -1,
1530 -1, -1, -1, 236, 237, 245, 239, -1, 241, -1,
1531 387, 388, 245, -1, -1, -1, 200, -1, 395, 396,
1532 130, -1, 399, -1, 401, 209, 136, 130, -1, 407,
1533 -1, -1, 410, 136, 154, 155, 156, 157, 158, 159,
1534 -1, -1, -1, -1, 154, 155, 156, 157, 158, 159,
1535 -1, 154, 155, 156, 157, 158, 159, -1, -1, -1,
1536 -1, 245, -1, -1, -1, -1, -1, -1, -1, -1,
1537 -1, -1, -1, 450, 452, -1, -1, -1, -1, -1,
1538 200, -1, -1, -1, -1, 318, -1, 327, -1, 209,
1539 200, -1, -1, -1, 327, -1, -1, 200, -1, 209,
1540 -1, -1, -1, -1, -1, -1, 209, -1, -1, -1,
1541 6, 344, 8, 9, 10, 11, 12, 13, 14, 15,
1542 16, 17, -1, 19, -1, 245, -1, 367, -1, -1,
1543 -1, -1, -1, -1, 367, 245, -1, 33, -1, -1,
1544 -1, -1, 245, 327, -1, -1, -1, -1, -1, -1,
1545 390, -1, -1, -1, -1, -1, -1, 390, -1, -1,
1546 -1, -1, -1, -1, -1, -1, -1, 407, -1, -1,
1547 410, -1, -1, -1, 407, -1, -1, 410, -1, -1,
1548 -1, -1, -1, 367, -1, -1, -1, -1, -1, -1,
1549 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1550 -1, -1, -1, -1, -1, -1, 390, 327, -1, -1,
1551 -1, -1, 452, -1, -1, -1, -1, 327, 458, 452,
1552 -1, -1, -1, 407, 327, 458, 410, -1, -1, -1,
1553 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1554 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1555 -1, -1, -1, -1, -1, -1, -1, 367, -1, -1,
1556 -1, -1, -1, -1, 367, -1, -1, -1, 452, -1,
1557 390, -1, -1, -1, 458, -1, -1, -1, -1, -1,
1558 390, -1, -1, -1, -1, -1, -1, 390, -1, -1,
1559 -1, -1, -1, -1, -1, -1, -1, 407, -1, -1,
1560 410, -1, 23, -1, 407, 26, 27, 410, -1, -1,
1561 31, -1, 33, -1, 35, 36, 37, -1, -1, -1,
1562 -1, -1, -1, -1, -1, -1, -1, -1, 49, 50,
1563 51, 52, 53, 54, 55, 56, 57, 58, 458, -1,
1564 -1, -1, 452, -1, -1, 66, 67, 68, 458, 452,
1565 -1, -1, -1, -1, -1, 458, 77, 23, -1, 80,
1566 26, 27, 83, 84, -1, 31, -1, 33, -1, 35,
1567 36, 37, 93, -1, -1, 96, -1, -1, 99, -1,
1568 -1, -1, -1, 49, 50, 51, 52, 53, 54, 55,
1569 56, 57, 58, -1, -1, -1, -1, -1, -1, -1,
1570 66, 67, 68, -1, -1, -1, -1, -1, -1, -1,
1571 -1, 77, 23, -1, 80, 26, 27, 83, 84, -1,
1572 31, -1, 33, -1, 35, 36, 37, 93, -1, -1,
1573 96, -1, -1, 99, -1, -1, -1, -1, 49, 50,
1574 51, 52, 53, 54, 55, 56, 57, 58, -1, -1,
1575 -1, -1, -1, -1, -1, 66, 67, 68, -1, -1,
1576 -1, -1, -1, -1, -1, -1, 77, 23, -1, 80,
1577 26, 27, 83, 84, -1, 31, -1, 33, -1, 35,
1578 36, 37, 93, -1, -1, 96, -1, -1, 99, -1,
1579 -1, -1, -1, 49, 50, 51, 52, 53, 54, 55,
1580 56, 57, 58, -1, -1, -1, -1, -1, -1, -1,
1581 66, 67, 68, -1, -1, -1, -1, -1, -1, -1,
1582 -1, 77, 23, -1, 80, 26, 27, 83, 84, -1,
1583 31, -1, 33, -1, 35, 36, 37, 93, -1, -1,
1584 96, -1, -1, 99, -1, -1, -1, -1, 49, 50,
1585 51, 52, 53, 54, 55, 56, 57, 58, -1, -1,
1586 -1, -1, -1, -1, -1, 66, 67, 68, -1, -1,
1587 -1, -1, -1, -1, -1, -1, 77, 23, -1, 80,
1588 26, 27, 83, 84, -1, 31, -1, 33, -1, 35,
1589 36, 37, 93, -1, -1, 96, -1, -1, 99, -1,
1590 -1, -1, -1, 49, 50, 51, 52, 53, 54, 55,
1591 56, 57, 58, -1, -1, -1, -1, -1, -1, -1,
1592 66, 67, 68, -1, -1, -1, -1, -1, -1, -1,
1593 -1, 77, -1, -1, 80, 26, 27, 83, 84, -1,
1594 31, -1, 33, -1, 35, 36, 37, 93, -1, -1,
1595 96, -1, -1, 99, -1, -1, 47, -1, 49, 50,
1596 51, 52, 53, 54, 55, 56, 57, 58, -1, -1,
1597 -1, -1, -1, -1, -1, 66, 67, 68, -1, -1,
1598 -1, -1, -1, -1, -1, -1, 77, -1, -1, 80,
1599 26, 27, 83, 84, -1, 31, -1, 33, -1, 35,
1600 36, 37, -1, -1, -1, 96, -1, -1, 99, -1,
1601 -1, 47, -1, 49, 50, 51, 52, 53, 54, 55,
1602 56, 57, 58, -1, -1, -1, -1, -1, -1, -1,
1603 66, 67, 68, -1, -1, -1, -1, -1, -1, -1,
1604 -1, 77, -1, -1, 80, -1, -1, 83, 84, -1,
1605 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
1606 96, -1, -1, 99, 59, 60, 61, 62, 63, 64,
1607 65, -1, -1, -1, 69, 70, 71, 72, 73, 74,
1608 75, 76, -1, 78, 79, -1, 81, -1, -1, -1,
1609 85, 86, 87, 88, 89, 90, 91, 92
1610 };
1611
1612 /* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
1613 symbol of state STATE-NUM. */
1614 static const yytype_uint8 yystos[] =
1615 {
1616 0, 109, 110, 0, 111, 6, 8, 9, 10, 11,
1617 12, 13, 14, 15, 16, 17, 19, 33, 112, 4,
1618 4, 7, 7, 4, 4, 4, 4, 4, 7, 155,
1619 3, 20, 113, 7, 7, 47, 155, 21, 114, 126,
1620 47, 155, 115, 23, 26, 27, 31, 33, 35, 36,
1621 37, 49, 50, 51, 52, 53, 54, 55, 56, 57,
1622 58, 66, 67, 68, 77, 80, 83, 84, 93, 96,
1623 99, 126, 47, 18, 135, 166, 134, 166, 137, 166,
1624 136, 166, 145, 166, 147, 166, 149, 166, 128, 166,
1625 129, 166, 130, 166, 138, 166, 139, 166, 140, 166,
1626 141, 166, 166, 5, 7, 45, 46, 100, 160, 163,
1627 164, 165, 170, 148, 166, 131, 166, 132, 166, 133,
1628 166, 144, 146, 166, 142, 166, 143, 166, 150, 153,
1629 166, 151, 158, 166, 152, 159, 166, 23, 126, 7,
1630 116, 170, 170, 170, 170, 170, 3, 100, 160, 161,
1631 171, 170, 4, 100, 160, 161, 162, 163, 164, 165,
1632 168, 170, 170, 170, 170, 170, 170, 100, 160, 162,
1633 172, 166, 171, 170, 170, 170, 170, 160, 173, 170,
1634 155, 100, 160, 161, 162, 163, 164, 165, 169, 155,
1635 173, 155, 169, 23, 24, 166, 166, 166, 166, 166,
1636 166, 166, 166, 168, 168, 168, 168, 168, 168, 166,
1637 166, 166, 166, 166, 59, 60, 61, 62, 63, 64,
1638 65, 69, 70, 71, 72, 73, 74, 75, 76, 78,
1639 79, 81, 85, 86, 87, 88, 89, 90, 91, 92,
1640 167, 166, 166, 166, 166, 166, 82, 166, 26, 27,
1641 31, 33, 35, 36, 37, 47, 49, 50, 51, 52,
1642 53, 54, 55, 56, 57, 58, 66, 67, 68, 77,
1643 80, 83, 84, 96, 99, 127, 156, 166, 166, 47,
1644 127, 157, 82, 157, 166, 117, 170, 170, 172, 171,
1645 167, 168, 172, 167, 168, 172, 172, 170, 167, 170,
1646 170, 170, 170, 170, 170, 170, 170, 170, 170, 170,
1647 172, 172, 170, 172, 172, 170, 170, 170, 172, 172,
1648 172, 101, 171, 170, 170, 170, 168, 166, 170, 135,
1649 134, 137, 136, 145, 147, 149, 126, 128, 129, 130,
1650 138, 139, 140, 141, 166, 170, 148, 131, 132, 133,
1651 144, 146, 142, 143, 151, 152, 95, 154, 167, 102,
1652 103, 104, 105, 106, 107, 174, 126, 166, 174, 6,
1653 13, 14, 15, 16, 17, 25, 26, 27, 28, 29,
1654 30, 31, 32, 33, 34, 37, 119, 166, 166, 101,
1655 101, 101, 170, 170, 170, 170, 170, 170, 170, 172,
1656 170, 166, 168, 23, 172, 155, 101, 166, 23, 169,
1657 166, 4, 4, 4, 4, 7, 3, 7, 7, 7,
1658 7, 7, 4, 4, 3, 118, 4, 22, 23, 120,
1659 170, 170, 168, 170, 170, 170, 170, 157, 169, 97,
1660 169, 7, 7, 38, 39, 40, 41, 42, 43, 121,
1661 166, 94, 166, 98, 44, 170, 169, 122, 166, 98,
1662 7, 23, 45, 46, 123, 124, 168, 48, 48, 47,
1663 125, 125, 126, 23
1664 };
1665
1666 #define yyerrok (yyerrstatus = 0)
1667 #define yyclearin (yychar = YYEMPTY)
1668 #define YYEMPTY (-2)
1669 #define YYEOF 0
1670
1671 #define YYACCEPT goto yyacceptlab
1672 #define YYABORT goto yyabortlab
1673 #define YYERROR goto yyerrorlab
1674
1675
1676 /* Like YYERROR except do call yyerror. This remains here temporarily
1677 to ease the transition to the new meaning of YYERROR, for GCC.
1678 Once GCC version 2 has supplanted version 1, this can go. */
1679
1680 #define YYFAIL goto yyerrlab
1681
1682 #define YYRECOVERING() (!!yyerrstatus)
1683
1684 #define YYBACKUP(Token, Value) \
1685 do \
1686 if (yychar == YYEMPTY && yylen == 1) \
1687 { \
1688 yychar = (Token); \
1689 yylval = (Value); \
1690 yytoken = YYTRANSLATE (yychar); \
1691 YYPOPSTACK (1); \
1692 goto yybackup; \
1693 } \
1694 else \
1695 { \
1696 yyerror (YY_("syntax error: cannot back up")); \
1697 YYERROR; \
1698 } \
1699 while (YYID (0))
1700
1701
1702 #define YYTERROR 1
1703 #define YYERRCODE 256
1704
1705
1706 /* YYLLOC_DEFAULT -- Set CURRENT to span from RHS[1] to RHS[N].
1707 If N is 0, then set CURRENT to the empty location which ends
1708 the previous symbol: RHS[0] (always defined). */
1709
1710 #define YYRHSLOC(Rhs, K) ((Rhs)[K])
1711 #ifndef YYLLOC_DEFAULT
1712 # define YYLLOC_DEFAULT(Current, Rhs, N) \
1713 do \
1714 if (YYID (N)) \
1715 { \
1716 (Current).first_line = YYRHSLOC (Rhs, 1).first_line; \
1717 (Current).first_column = YYRHSLOC (Rhs, 1).first_column; \
1718 (Current).last_line = YYRHSLOC (Rhs, N).last_line; \
1719 (Current).last_column = YYRHSLOC (Rhs, N).last_column; \
1720 } \
1721 else \
1722 { \
1723 (Current).first_line = (Current).last_line = \
1724 YYRHSLOC (Rhs, 0).last_line; \
1725 (Current).first_column = (Current).last_column = \
1726 YYRHSLOC (Rhs, 0).last_column; \
1727 } \
1728 while (YYID (0))
1729 #endif
1730
1731
1732 /* YY_LOCATION_PRINT -- Print the location on the stream.
1733 This macro was not mandated originally: define only if we know
1734 we won't break user code: when these are the locations we know. */
1735
1736 #ifndef YY_LOCATION_PRINT
1737 # if YYLTYPE_IS_TRIVIAL
1738 # define YY_LOCATION_PRINT(File, Loc) \
1739 fprintf (File, "%d.%d-%d.%d", \
1740 (Loc).first_line, (Loc).first_column, \
1741 (Loc).last_line, (Loc).last_column)
1742 # else
1743 # define YY_LOCATION_PRINT(File, Loc) ((void) 0)
1744 # endif
1745 #endif
1746
1747
1748 /* YYLEX -- calling `yylex' with the right arguments. */
1749
1750 #ifdef YYLEX_PARAM
1751 # define YYLEX yylex (YYLEX_PARAM)
1752 #else
1753 # define YYLEX yylex ()
1754 #endif
1755
1756 /* Enable debugging if requested. */
1757 #if YYDEBUG
1758
1759 # ifndef YYFPRINTF
1760 # include <stdio.h> /* INFRINGES ON USER NAME SPACE */
1761 # define YYFPRINTF fprintf
1762 # endif
1763
1764 # define YYDPRINTF(Args) \
1765 do { \
1766 if (yydebug) \
1767 YYFPRINTF Args; \
1768 } while (YYID (0))
1769
1770 # define YY_SYMBOL_PRINT(Title, Type, Value, Location) \
1771 do { \
1772 if (yydebug) \
1773 { \
1774 YYFPRINTF (stderr, "%s ", Title); \
1775 yy_symbol_print (stderr, \
1776 Type, Value); \
1777 YYFPRINTF (stderr, "\n"); \
1778 } \
1779 } while (YYID (0))
1780
1781
1782 /*--------------------------------.
1783 | Print this symbol on YYOUTPUT. |
1784 `--------------------------------*/
1785
1786 /*ARGSUSED*/
1787 #if (defined __STDC__ || defined __C99__FUNC__ \
1788 || defined __cplusplus || defined _MSC_VER)
1789 static void
yy_symbol_value_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)1790 yy_symbol_value_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1791 #else
1792 static void
1793 yy_symbol_value_print (yyoutput, yytype, yyvaluep)
1794 FILE *yyoutput;
1795 int yytype;
1796 YYSTYPE const * const yyvaluep;
1797 #endif
1798 {
1799 if (!yyvaluep)
1800 return;
1801 # ifdef YYPRINT
1802 if (yytype < YYNTOKENS)
1803 YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
1804 # else
1805 YYUSE (yyoutput);
1806 # endif
1807 switch (yytype)
1808 {
1809 default:
1810 break;
1811 }
1812 }
1813
1814
1815 /*--------------------------------.
1816 | Print this symbol on YYOUTPUT. |
1817 `--------------------------------*/
1818
1819 #if (defined __STDC__ || defined __C99__FUNC__ \
1820 || defined __cplusplus || defined _MSC_VER)
1821 static void
yy_symbol_print(FILE * yyoutput,int yytype,YYSTYPE const * const yyvaluep)1822 yy_symbol_print (FILE *yyoutput, int yytype, YYSTYPE const * const yyvaluep)
1823 #else
1824 static void
1825 yy_symbol_print (yyoutput, yytype, yyvaluep)
1826 FILE *yyoutput;
1827 int yytype;
1828 YYSTYPE const * const yyvaluep;
1829 #endif
1830 {
1831 if (yytype < YYNTOKENS)
1832 YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
1833 else
1834 YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
1835
1836 yy_symbol_value_print (yyoutput, yytype, yyvaluep);
1837 YYFPRINTF (yyoutput, ")");
1838 }
1839
1840 /*------------------------------------------------------------------.
1841 | yy_stack_print -- Print the state stack from its BOTTOM up to its |
1842 | TOP (included). |
1843 `------------------------------------------------------------------*/
1844
1845 #if (defined __STDC__ || defined __C99__FUNC__ \
1846 || defined __cplusplus || defined _MSC_VER)
1847 static void
yy_stack_print(yytype_int16 * bottom,yytype_int16 * top)1848 yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
1849 #else
1850 static void
1851 yy_stack_print (bottom, top)
1852 yytype_int16 *bottom;
1853 yytype_int16 *top;
1854 #endif
1855 {
1856 YYFPRINTF (stderr, "Stack now");
1857 for (; bottom <= top; ++bottom)
1858 YYFPRINTF (stderr, " %d", *bottom);
1859 YYFPRINTF (stderr, "\n");
1860 }
1861
1862 # define YY_STACK_PRINT(Bottom, Top) \
1863 do { \
1864 if (yydebug) \
1865 yy_stack_print ((Bottom), (Top)); \
1866 } while (YYID (0))
1867
1868
1869 /*------------------------------------------------.
1870 | Report that the YYRULE is going to be reduced. |
1871 `------------------------------------------------*/
1872
1873 #if (defined __STDC__ || defined __C99__FUNC__ \
1874 || defined __cplusplus || defined _MSC_VER)
1875 static void
yy_reduce_print(YYSTYPE * yyvsp,int yyrule)1876 yy_reduce_print (YYSTYPE *yyvsp, int yyrule)
1877 #else
1878 static void
1879 yy_reduce_print (yyvsp, yyrule)
1880 YYSTYPE *yyvsp;
1881 int yyrule;
1882 #endif
1883 {
1884 int yynrhs = yyr2[yyrule];
1885 int yyi;
1886 unsigned long int yylno = yyrline[yyrule];
1887 YYFPRINTF (stderr, "Reducing stack by rule %d (line %lu):\n",
1888 yyrule - 1, yylno);
1889 /* The symbols being reduced. */
1890 for (yyi = 0; yyi < yynrhs; yyi++)
1891 {
1892 fvwm_debug(__func__, " $%d = ", yyi + 1);
1893 yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1894 &(yyvsp[(yyi + 1) - (yynrhs)])
1895 );
1896 fvwm_debug(__func__, "\n");
1897 }
1898 }
1899
1900 # define YY_REDUCE_PRINT(Rule) \
1901 do { \
1902 if (yydebug) \
1903 yy_reduce_print (yyvsp, Rule); \
1904 } while (YYID (0))
1905
1906 /* Nonzero means print parse trace. It is left uninitialized so that
1907 multiple parsers can coexist. */
1908 int yydebug;
1909 #else /* !YYDEBUG */
1910 # define YYDPRINTF(Args)
1911 # define YY_SYMBOL_PRINT(Title, Type, Value, Location)
1912 # define YY_STACK_PRINT(Bottom, Top)
1913 # define YY_REDUCE_PRINT(Rule)
1914 #endif /* !YYDEBUG */
1915
1916
1917 /* YYINITDEPTH -- initial size of the parser's stacks. */
1918 #ifndef YYINITDEPTH
1919 # define YYINITDEPTH 200
1920 #endif
1921
1922 /* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
1923 if the built-in stack extension method is used).
1924
1925 Do not make this value too large; the results are undefined if
1926 YYSTACK_ALLOC_MAXIMUM < YYSTACK_BYTES (YYMAXDEPTH)
1927 evaluated with infinite-precision integer arithmetic. */
1928
1929 #ifndef YYMAXDEPTH
1930 # define YYMAXDEPTH 10000
1931 #endif
1932
1933
1934
1935 #if YYERROR_VERBOSE
1936
1937 # ifndef yystrlen
1938 # if defined __GLIBC__ && defined _STRING_H
1939 # define yystrlen strlen
1940 # else
1941 /* Return the length of YYSTR. */
1942 #if (defined __STDC__ || defined __C99__FUNC__ \
1943 || defined __cplusplus || defined _MSC_VER)
1944 static YYSIZE_T
yystrlen(const char * yystr)1945 yystrlen (const char *yystr)
1946 #else
1947 static YYSIZE_T
1948 yystrlen (yystr)
1949 const char *yystr;
1950 #endif
1951 {
1952 YYSIZE_T yylen;
1953 for (yylen = 0; yystr[yylen]; yylen++)
1954 continue;
1955 return yylen;
1956 }
1957 # endif
1958 # endif
1959
1960 # ifndef yystpcpy
1961 # if defined __GLIBC__ && defined _STRING_H && defined _GNU_SOURCE
1962 # define yystpcpy stpcpy
1963 # else
1964 /* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
1965 YYDEST. */
1966 #if (defined __STDC__ || defined __C99__FUNC__ \
1967 || defined __cplusplus || defined _MSC_VER)
1968 static char *
yystpcpy(char * yydest,const char * yysrc)1969 yystpcpy (char *yydest, const char *yysrc)
1970 #else
1971 static char *
1972 yystpcpy (yydest, yysrc)
1973 char *yydest;
1974 const char *yysrc;
1975 #endif
1976 {
1977 char *yyd = yydest;
1978 const char *yys = yysrc;
1979
1980 while ((*yyd++ = *yys++) != '\0')
1981 continue;
1982
1983 return yyd - 1;
1984 }
1985 # endif
1986 # endif
1987
1988 # ifndef yytnamerr
1989 /* Copy to YYRES the contents of YYSTR after stripping away unnecessary
1990 quotes and backslashes, so that it's suitable for yyerror. The
1991 heuristic is that double-quoting is unnecessary unless the string
1992 contains an apostrophe, a comma, or backslash (other than
1993 backslash-backslash). YYSTR is taken from yytname. If YYRES is
1994 null, do not copy; instead, return the length of what the result
1995 would have been. */
1996 static YYSIZE_T
yytnamerr(char * yyres,const char * yystr)1997 yytnamerr (char *yyres, const char *yystr)
1998 {
1999 if (*yystr == '"')
2000 {
2001 YYSIZE_T yyn = 0;
2002 char const *yyp = yystr;
2003
2004 for (;;)
2005 switch (*++yyp)
2006 {
2007 case '\'':
2008 case ',':
2009 goto do_not_strip_quotes;
2010
2011 case '\\':
2012 if (*++yyp != '\\')
2013 goto do_not_strip_quotes;
2014 /* Fall through. */
2015 default:
2016 if (yyres)
2017 yyres[yyn] = *yyp;
2018 yyn++;
2019 break;
2020
2021 case '"':
2022 if (yyres)
2023 yyres[yyn] = '\0';
2024 return yyn;
2025 }
2026 do_not_strip_quotes: ;
2027 }
2028
2029 if (! yyres)
2030 return yystrlen (yystr);
2031
2032 return yystpcpy (yyres, yystr) - yyres;
2033 }
2034 # endif
2035
2036 /* Copy into YYRESULT an error message about the unexpected token
2037 YYCHAR while in state YYSTATE. Return the number of bytes copied,
2038 including the terminating null byte. If YYRESULT is null, do not
2039 copy anything; just return the number of bytes that would be
2040 copied. As a special case, return 0 if an ordinary "syntax error"
2041 message will do. Return YYSIZE_MAXIMUM if overflow occurs during
2042 size calculation. */
2043 static YYSIZE_T
yysyntax_error(char * yyresult,int yystate,int yychar)2044 yysyntax_error (char *yyresult, int yystate, int yychar)
2045 {
2046 int yyn = yypact[yystate];
2047
2048 if (! (YYPACT_NINF < yyn && yyn <= YYLAST))
2049 return 0;
2050 else
2051 {
2052 int yytype = YYTRANSLATE (yychar);
2053 YYSIZE_T yysize0 = yytnamerr (0, yytname[yytype]);
2054 YYSIZE_T yysize = yysize0;
2055 YYSIZE_T yysize1;
2056 int yysize_overflow = 0;
2057 enum { YYERROR_VERBOSE_ARGS_MAXIMUM = 5 };
2058 char const *yyarg[YYERROR_VERBOSE_ARGS_MAXIMUM];
2059 int yyx;
2060
2061 # if 0
2062 /* This is so xgettext sees the translatable formats that are
2063 constructed on the fly. */
2064 YY_("syntax error, unexpected %s");
2065 YY_("syntax error, unexpected %s, expecting %s");
2066 YY_("syntax error, unexpected %s, expecting %s or %s");
2067 YY_("syntax error, unexpected %s, expecting %s or %s or %s");
2068 YY_("syntax error, unexpected %s, expecting %s or %s or %s or %s");
2069 # endif
2070 char *yyfmt;
2071 char const *yyf;
2072 static char const yyunexpected[] = "syntax error, unexpected %s";
2073 static char const yyexpecting[] = ", expecting %s";
2074 static char const yyor[] = " or %s";
2075 char yyformat[sizeof yyunexpected
2076 + sizeof yyexpecting - 1
2077 + ((YYERROR_VERBOSE_ARGS_MAXIMUM - 2)
2078 * (sizeof yyor - 1))];
2079 char const *yyprefix = yyexpecting;
2080
2081 /* Start YYX at -YYN if negative to avoid negative indexes in
2082 YYCHECK. */
2083 int yyxbegin = yyn < 0 ? -yyn : 0;
2084
2085 /* Stay within bounds of both yycheck and yytname. */
2086 int yychecklim = YYLAST - yyn + 1;
2087 int yyxend = yychecklim < YYNTOKENS ? yychecklim : YYNTOKENS;
2088 int yycount = 1;
2089
2090 yyarg[0] = yytname[yytype];
2091 yyfmt = yystpcpy (yyformat, yyunexpected);
2092
2093 for (yyx = yyxbegin; yyx < yyxend; ++yyx)
2094 if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
2095 {
2096 if (yycount == YYERROR_VERBOSE_ARGS_MAXIMUM)
2097 {
2098 yycount = 1;
2099 yysize = yysize0;
2100 yyformat[sizeof yyunexpected - 1] = '\0';
2101 break;
2102 }
2103 yyarg[yycount++] = yytname[yyx];
2104 yysize1 = yysize + yytnamerr (0, yytname[yyx]);
2105 yysize_overflow |= (yysize1 < yysize);
2106 yysize = yysize1;
2107 yyfmt = yystpcpy (yyfmt, yyprefix);
2108 yyprefix = yyor;
2109 }
2110
2111 yyf = YY_(yyformat);
2112 yysize1 = yysize + yystrlen (yyf);
2113 yysize_overflow |= (yysize1 < yysize);
2114 yysize = yysize1;
2115
2116 if (yysize_overflow)
2117 return YYSIZE_MAXIMUM;
2118
2119 if (yyresult)
2120 {
2121 /* Avoid sprintf, as that infringes on the user's name space.
2122 Don't have undefined behavior even if the translation
2123 produced a string with the wrong number of "%s"s. */
2124 char *yyp = yyresult;
2125 int yyi = 0;
2126 while ((*yyp = *yyf) != '\0')
2127 {
2128 if (*yyp == '%' && yyf[1] == 's' && yyi < yycount)
2129 {
2130 yyp += yytnamerr (yyp, yyarg[yyi++]);
2131 yyf += 2;
2132 }
2133 else
2134 {
2135 yyp++;
2136 yyf++;
2137 }
2138 }
2139 }
2140 return yysize;
2141 }
2142 }
2143 #endif /* YYERROR_VERBOSE */
2144
2145
2146 /*-----------------------------------------------.
2147 | Release the memory associated to this symbol. |
2148 `-----------------------------------------------*/
2149
2150 /*ARGSUSED*/
2151 #if (defined __STDC__ || defined __C99__FUNC__ \
2152 || defined __cplusplus || defined _MSC_VER)
2153 static void
yydestruct(const char * yymsg,int yytype,YYSTYPE * yyvaluep)2154 yydestruct (const char *yymsg, int yytype, YYSTYPE *yyvaluep)
2155 #else
2156 static void
2157 yydestruct (yymsg, yytype, yyvaluep)
2158 const char *yymsg;
2159 int yytype;
2160 YYSTYPE *yyvaluep;
2161 #endif
2162 {
2163 YYUSE (yyvaluep);
2164
2165 if (!yymsg)
2166 yymsg = "Deleting";
2167 YY_SYMBOL_PRINT (yymsg, yytype, yyvaluep, yylocationp);
2168
2169 switch (yytype)
2170 {
2171
2172 default:
2173 break;
2174 }
2175 }
2176
2177
2178 /* Prevent warnings from -Wmissing-prototypes. */
2179
2180 #ifdef YYPARSE_PARAM
2181 #if defined __STDC__ || defined __cplusplus
2182 int yyparse (void *YYPARSE_PARAM);
2183 #else
2184 int yyparse ();
2185 #endif
2186 #else /* ! YYPARSE_PARAM */
2187 #if defined __STDC__ || defined __cplusplus
2188 int yyparse (void);
2189 #else
2190 int yyparse ();
2191 #endif
2192 #endif /* ! YYPARSE_PARAM */
2193
2194
2195
2196 /* The look-ahead symbol. */
2197 int yychar;
2198
2199 /* The semantic value of the look-ahead symbol. */
2200 YYSTYPE yylval;
2201
2202 /* Number of syntax errors so far. */
2203 int yynerrs;
2204
2205
2206
2207 /*----------.
2208 | yyparse. |
2209 `----------*/
2210
2211 #ifdef YYPARSE_PARAM
2212 #if (defined __STDC__ || defined __C99__FUNC__ \
2213 || defined __cplusplus || defined _MSC_VER)
2214 int
yyparse(void * YYPARSE_PARAM)2215 yyparse (void *YYPARSE_PARAM)
2216 #else
2217 int
2218 yyparse (YYPARSE_PARAM)
2219 void *YYPARSE_PARAM;
2220 #endif
2221 #else /* ! YYPARSE_PARAM */
2222 #if (defined __STDC__ || defined __C99__FUNC__ \
2223 || defined __cplusplus || defined _MSC_VER)
2224 int
2225 yyparse (void)
2226 #else
2227 int
2228 yyparse ()
2229
2230 #endif
2231 #endif
2232 {
2233
2234 int yystate;
2235 int yyn;
2236 int yyresult;
2237 /* Number of tokens to shift before error messages enabled. */
2238 int yyerrstatus;
2239 /* Look-ahead token as an internal (translated) token number. */
2240 int yytoken = 0;
2241 #if YYERROR_VERBOSE
2242 /* Buffer for error messages, and its allocated size. */
2243 char yymsgbuf[128];
2244 char *yymsg = yymsgbuf;
2245 YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
2246 #endif
2247
2248 /* Three stacks and their tools:
2249 `yyss': related to states,
2250 `yyvs': related to semantic values,
2251 `yyls': related to locations.
2252
2253 Refer to the stacks thru separate pointers, to allow yyoverflow
2254 to reallocate them elsewhere. */
2255
2256 /* The state stack. */
2257 yytype_int16 yyssa[YYINITDEPTH];
2258 yytype_int16 *yyss = yyssa;
2259 yytype_int16 *yyssp;
2260
2261 /* The semantic value stack. */
2262 YYSTYPE yyvsa[YYINITDEPTH];
2263 YYSTYPE *yyvs = yyvsa;
2264 YYSTYPE *yyvsp;
2265
2266
2267
2268 #define YYPOPSTACK(N) (yyvsp -= (N), yyssp -= (N))
2269
2270 YYSIZE_T yystacksize = YYINITDEPTH;
2271
2272 /* The variables used to return semantic value and location from the
2273 action routines. */
2274 YYSTYPE yyval;
2275
2276
2277 /* The number of symbols on the RHS of the reduced rule.
2278 Keep to zero when no symbol should be popped. */
2279 int yylen = 0;
2280
2281 YYDPRINTF ((stderr, "Starting parse\n"));
2282
2283 yystate = 0;
2284 yyerrstatus = 0;
2285 yynerrs = 0;
2286 yychar = YYEMPTY; /* Cause a token to be read. */
2287
2288 /* Initialize stack pointers.
2289 Waste one element of value and location stack
2290 so that they stay on the same level as the state stack.
2291 The wasted elements are never initialized. */
2292
2293 yyssp = yyss;
2294 yyvsp = yyvs;
2295
2296 goto yysetstate;
2297
2298 /*------------------------------------------------------------.
2299 | yynewstate -- Push a new state, which is found in yystate. |
2300 `------------------------------------------------------------*/
2301 yynewstate:
2302 /* In all cases, when you get here, the value and location stacks
2303 have just been pushed. So pushing a state here evens the stacks. */
2304 yyssp++;
2305
2306 yysetstate:
2307 *yyssp = yystate;
2308
2309 if (yyss + yystacksize - 1 <= yyssp)
2310 {
2311 /* Get the current used size of the three stacks, in elements. */
2312 YYSIZE_T yysize = yyssp - yyss + 1;
2313
2314 #ifdef yyoverflow
2315 {
2316 /* Give user a chance to reallocate the stack. Use copies of
2317 these so that the &'s don't force the real ones into
2318 memory. */
2319 YYSTYPE *yyvs1 = yyvs;
2320 yytype_int16 *yyss1 = yyss;
2321
2322
2323 /* Each stack pointer address is followed by the size of the
2324 data in use in that stack, in bytes. This used to be a
2325 conditional around just the two extra args, but that might
2326 be undefined if yyoverflow is a macro. */
2327 yyoverflow (YY_("memory exhausted"),
2328 &yyss1, yysize * sizeof (*yyssp),
2329 &yyvs1, yysize * sizeof (*yyvsp),
2330
2331 &yystacksize);
2332
2333 yyss = yyss1;
2334 yyvs = yyvs1;
2335 }
2336 #else /* no yyoverflow */
2337 # ifndef YYSTACK_RELOCATE
2338 goto yyexhaustedlab;
2339 # else
2340 /* Extend the stack our own way. */
2341 if (YYMAXDEPTH <= yystacksize)
2342 goto yyexhaustedlab;
2343 yystacksize *= 2;
2344 if (YYMAXDEPTH < yystacksize)
2345 yystacksize = YYMAXDEPTH;
2346
2347 {
2348 yytype_int16 *yyss1 = yyss;
2349 union yyalloc *yyptr =
2350 (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
2351 if (! yyptr)
2352 goto yyexhaustedlab;
2353 YYSTACK_RELOCATE (yyss);
2354 YYSTACK_RELOCATE (yyvs);
2355
2356 # undef YYSTACK_RELOCATE
2357 if (yyss1 != yyssa)
2358 YYSTACK_FREE (yyss1);
2359 }
2360 # endif
2361 #endif /* no yyoverflow */
2362
2363 yyssp = yyss + yysize - 1;
2364 yyvsp = yyvs + yysize - 1;
2365
2366
2367 YYDPRINTF ((stderr, "Stack size increased to %lu\n",
2368 (unsigned long int) yystacksize));
2369
2370 if (yyss + yystacksize - 1 <= yyssp)
2371 YYABORT;
2372 }
2373
2374 YYDPRINTF ((stderr, "Entering state %d\n", yystate));
2375
2376 goto yybackup;
2377
2378 /*-----------.
2379 | yybackup. |
2380 `-----------*/
2381 yybackup:
2382
2383 /* Do appropriate processing given the current state. Read a
2384 look-ahead token if we need one and don't already have one. */
2385
2386 /* First try to decide what to do without reference to look-ahead token. */
2387 yyn = yypact[yystate];
2388 if (yyn == YYPACT_NINF)
2389 goto yydefault;
2390
2391 /* Not known => get a look-ahead token if don't already have one. */
2392
2393 /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol. */
2394 if (yychar == YYEMPTY)
2395 {
2396 YYDPRINTF ((stderr, "Reading a token: "));
2397 yychar = YYLEX;
2398 }
2399
2400 if (yychar <= YYEOF)
2401 {
2402 yychar = yytoken = YYEOF;
2403 YYDPRINTF ((stderr, "Now at end of input.\n"));
2404 }
2405 else
2406 {
2407 yytoken = YYTRANSLATE (yychar);
2408 YY_SYMBOL_PRINT ("Next token is", yytoken, &yylval, &yylloc);
2409 }
2410
2411 /* If the proper action on seeing token YYTOKEN is to reduce or to
2412 detect an error, take that action. */
2413 yyn += yytoken;
2414 if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
2415 goto yydefault;
2416 yyn = yytable[yyn];
2417 if (yyn <= 0)
2418 {
2419 if (yyn == 0 || yyn == YYTABLE_NINF)
2420 goto yyerrlab;
2421 yyn = -yyn;
2422 goto yyreduce;
2423 }
2424
2425 if (yyn == YYFINAL)
2426 YYACCEPT;
2427
2428 /* Count tokens shifted since error; after three, turn off error
2429 status. */
2430 if (yyerrstatus)
2431 yyerrstatus--;
2432
2433 /* Shift the look-ahead token. */
2434 YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
2435
2436 /* Discard the shifted token unless it is eof. */
2437 if (yychar != YYEOF)
2438 yychar = YYEMPTY;
2439
2440 yystate = yyn;
2441 *++yyvsp = yylval;
2442
2443 goto yynewstate;
2444
2445
2446 /*-----------------------------------------------------------.
2447 | yydefault -- do the default action for the current state. |
2448 `-----------------------------------------------------------*/
2449 yydefault:
2450 yyn = yydefact[yystate];
2451 if (yyn == 0)
2452 goto yyerrlab;
2453 goto yyreduce;
2454
2455
2456 /*-----------------------------.
2457 | yyreduce -- Do a reduction. |
2458 `-----------------------------*/
2459 yyreduce:
2460 /* yyn is the number of a rule to reduce with. */
2461 yylen = yyr2[yyn];
2462
2463 /* If YYLEN is nonzero, implement the default value of the action:
2464 `$$ = $1'.
2465
2466 Otherwise, the following line sets YYVAL to garbage.
2467 This behavior is undocumented and Bison
2468 users should not rely upon it. Assigning to YYVAL
2469 unconditionally makes the parser a bit smaller, and it avoids a
2470 GCC warning that YYVAL may be used uninitialized. */
2471 yyval = yyvsp[1-yylen];
2472
2473
2474 YY_REDUCE_PRINT (yyn);
2475 switch (yyn)
2476 {
2477 case 3:
2478 #line 396 "script.y"
2479 { InitVarGlob(); }
2480 break;
2481
2482 case 5:
2483 #line 402 "script.y"
2484 {
2485 FGettextInit("FvwmScript", LOCALEDIR, "FvwmScript");
2486 FGettextSetLocalePath((yyvsp[(3) - (3)].str));
2487 }
2488 break;
2489
2490 case 6:
2491 #line 407 "script.y"
2492 {
2493 fprintf(stderr,"UseGettext!\n");
2494 FGettextInit("FvwmScript", LOCALEDIR, "FvwmScript");
2495 }
2496 break;
2497
2498 case 7:
2499 #line 413 "script.y"
2500 {
2501 /* Window Title */
2502 scriptprop->titlewin=(yyvsp[(3) - (3)].str);
2503 }
2504 break;
2505
2506 case 8:
2507 #line 418 "script.y"
2508 {
2509 /* Window Title */
2510 scriptprop->titlewin=(char *)FGettext((yyvsp[(3) - (3)].str));
2511 }
2512 break;
2513
2514 case 9:
2515 #line 423 "script.y"
2516 {
2517 scriptprop->icon=(yyvsp[(3) - (3)].str);
2518 }
2519 break;
2520
2521 case 10:
2522 #line 427 "script.y"
2523 {
2524 /* Window Position and Size */
2525 scriptprop->x=(yyvsp[(3) - (4)].number);
2526 scriptprop->y=(yyvsp[(4) - (4)].number);
2527 }
2528 break;
2529
2530 case 11:
2531 #line 433 "script.y"
2532 {
2533 /* Window Position and Size */
2534 scriptprop->width=(yyvsp[(3) - (4)].number);
2535 scriptprop->height=(yyvsp[(4) - (4)].number);
2536 }
2537 break;
2538
2539 case 12:
2540 #line 439 "script.y"
2541 {
2542 /* Background Color */
2543 scriptprop->backcolor=(yyvsp[(3) - (3)].str);
2544 scriptprop->colorset = -1;
2545 }
2546 break;
2547
2548 case 13:
2549 #line 445 "script.y"
2550 {
2551 /* Foreground Color */
2552 scriptprop->forecolor=(yyvsp[(3) - (3)].str);
2553 scriptprop->colorset = -1;
2554 }
2555 break;
2556
2557 case 14:
2558 #line 451 "script.y"
2559 {
2560 /* Shaded Color */
2561 scriptprop->shadcolor=(yyvsp[(3) - (3)].str);
2562 scriptprop->colorset = -1;
2563 }
2564 break;
2565
2566 case 15:
2567 #line 457 "script.y"
2568 {
2569 /* Highlighted Color */
2570 scriptprop->hilicolor=(yyvsp[(3) - (3)].str);
2571 scriptprop->colorset = -1;
2572 }
2573 break;
2574
2575 case 16:
2576 #line 463 "script.y"
2577 {
2578 scriptprop->colorset = (yyvsp[(3) - (3)].number);
2579 AllocColorset((yyvsp[(3) - (3)].number));
2580 }
2581 break;
2582
2583 case 17:
2584 #line 468 "script.y"
2585 {
2586 scriptprop->font=(yyvsp[(2) - (2)].str);
2587 }
2588 break;
2589
2590 case 19:
2591 #line 474 "script.y"
2592 {
2593 scriptprop->initbloc=PileBloc[TopPileB];
2594 TopPileB--;
2595 }
2596 break;
2597
2598 case 21:
2599 #line 480 "script.y"
2600 {
2601 scriptprop->periodictasks=PileBloc[TopPileB];
2602 TopPileB--;
2603 }
2604 break;
2605
2606 case 23:
2607 #line 486 "script.y"
2608 {
2609 scriptprop->quitfunc=PileBloc[TopPileB];
2610 TopPileB--;
2611 }
2612 break;
2613
2614 case 26:
2615 #line 499 "script.y"
2616 { nbobj++;
2617 if (nbobj>1000)
2618 { yyerror("Too many items\n");
2619 exit(1);}
2620 if (((yyvsp[(1) - (1)].number)<1)||((yyvsp[(1) - (1)].number)>1000))
2621 { yyerror("Choose item id between 1 and 1000\n");
2622 exit(1);}
2623 if (TabIdObj[(yyvsp[(1) - (1)].number)]!=-1)
2624 { i=(yyvsp[(1) - (1)].number); fprintf(stderr,"Line %d: item id %d already used:\n",numligne,(yyvsp[(1) - (1)].number));
2625 exit(1);}
2626 TabIdObj[(yyvsp[(1) - (1)].number)]=nbobj;
2627 (*tabobj)[nbobj].id=(yyvsp[(1) - (1)].number);
2628 (*tabobj)[nbobj].colorset = -1;
2629 }
2630 break;
2631
2632 case 28:
2633 #line 516 "script.y"
2634 {
2635 (*tabobj)[nbobj].type=(yyvsp[(3) - (3)].str);
2636 HasType=1;
2637 }
2638 break;
2639
2640 case 29:
2641 #line 520 "script.y"
2642 {
2643 (*tabobj)[nbobj].width=(yyvsp[(3) - (4)].number);
2644 (*tabobj)[nbobj].height=(yyvsp[(4) - (4)].number);
2645 }
2646 break;
2647
2648 case 30:
2649 #line 524 "script.y"
2650 {
2651 (*tabobj)[nbobj].x=(yyvsp[(3) - (4)].number);
2652 (*tabobj)[nbobj].y=(yyvsp[(4) - (4)].number);
2653 HasPosition=1;
2654 }
2655 break;
2656
2657 case 31:
2658 #line 529 "script.y"
2659 {
2660 (*tabobj)[nbobj].value=(yyvsp[(3) - (3)].number);
2661 }
2662 break;
2663
2664 case 32:
2665 #line 532 "script.y"
2666 {
2667 (*tabobj)[nbobj].value2=(yyvsp[(3) - (3)].number);
2668 }
2669 break;
2670
2671 case 33:
2672 #line 535 "script.y"
2673 {
2674 (*tabobj)[nbobj].value3=(yyvsp[(3) - (3)].number);
2675 }
2676 break;
2677
2678 case 34:
2679 #line 538 "script.y"
2680 {
2681 (*tabobj)[nbobj].title= (yyvsp[(3) - (3)].str);
2682 }
2683 break;
2684
2685 case 35:
2686 #line 541 "script.y"
2687 {
2688 (*tabobj)[nbobj].title= FGettextCopy((yyvsp[(3) - (3)].str));
2689 }
2690 break;
2691
2692 case 36:
2693 #line 544 "script.y"
2694 {
2695 (*tabobj)[nbobj].swallow=(yyvsp[(3) - (3)].str);
2696 }
2697 break;
2698
2699 case 37:
2700 #line 547 "script.y"
2701 {
2702 (*tabobj)[nbobj].icon=(yyvsp[(3) - (3)].str);
2703 }
2704 break;
2705
2706 case 38:
2707 #line 550 "script.y"
2708 {
2709 (*tabobj)[nbobj].backcolor=(yyvsp[(3) - (3)].str);
2710 (*tabobj)[nbobj].colorset = -1;
2711 }
2712 break;
2713
2714 case 39:
2715 #line 554 "script.y"
2716 {
2717 (*tabobj)[nbobj].forecolor=(yyvsp[(3) - (3)].str);
2718 (*tabobj)[nbobj].colorset = -1;
2719 }
2720 break;
2721
2722 case 40:
2723 #line 558 "script.y"
2724 {
2725 (*tabobj)[nbobj].shadcolor=(yyvsp[(3) - (3)].str);
2726 (*tabobj)[nbobj].colorset = -1;
2727 }
2728 break;
2729
2730 case 41:
2731 #line 562 "script.y"
2732 {
2733 (*tabobj)[nbobj].hilicolor=(yyvsp[(3) - (3)].str);
2734 (*tabobj)[nbobj].colorset = -1;
2735 }
2736 break;
2737
2738 case 42:
2739 #line 566 "script.y"
2740 {
2741 (*tabobj)[nbobj].colorset = (yyvsp[(3) - (3)].number);
2742 AllocColorset((yyvsp[(3) - (3)].number));
2743 }
2744 break;
2745
2746 case 43:
2747 #line 570 "script.y"
2748 {
2749 (*tabobj)[nbobj].font=(yyvsp[(2) - (2)].str);
2750 }
2751 break;
2752
2753 case 46:
2754 #line 576 "script.y"
2755 {
2756 (*tabobj)[nbobj].flags[0]=True;
2757 }
2758 break;
2759
2760 case 47:
2761 #line 579 "script.y"
2762 {
2763 (*tabobj)[nbobj].flags[1]=True;
2764 }
2765 break;
2766
2767 case 48:
2768 #line 582 "script.y"
2769 {
2770 (*tabobj)[nbobj].flags[2]=True;
2771 }
2772 break;
2773
2774 case 49:
2775 #line 585 "script.y"
2776 {
2777 (*tabobj)[nbobj].flags[3]=TEXT_POS_CENTER;
2778 }
2779 break;
2780
2781 case 50:
2782 #line 588 "script.y"
2783 {
2784 (*tabobj)[nbobj].flags[3]=TEXT_POS_LEFT;
2785 }
2786 break;
2787
2788 case 51:
2789 #line 591 "script.y"
2790 {
2791 (*tabobj)[nbobj].flags[3]=TEXT_POS_RIGHT;
2792 }
2793 break;
2794
2795 case 52:
2796 #line 597 "script.y"
2797 {
2798 if (!HasPosition)
2799 { yyerror("No position for object");
2800 exit(1);}
2801 if (!HasType)
2802 { yyerror("No type for object");
2803 exit(1);}
2804 HasPosition=0;
2805 HasType=0;
2806 }
2807 break;
2808
2809 case 53:
2810 #line 608 "script.y"
2811 { InitObjTabCase(0); }
2812 break;
2813
2814 case 55:
2815 #line 612 "script.y"
2816 { InitObjTabCase(1); }
2817 break;
2818
2819 case 59:
2820 #line 619 "script.y"
2821 { InitCase(-1); }
2822 break;
2823
2824 case 60:
2825 #line 620 "script.y"
2826 { InitCase(-2); }
2827 break;
2828
2829 case 61:
2830 #line 623 "script.y"
2831 { InitCase((yyvsp[(1) - (1)].number)); }
2832 break;
2833
2834 case 72:
2835 #line 640 "script.y"
2836 {AddCom(27,1);}
2837 break;
2838
2839 case 73:
2840 #line 641 "script.y"
2841 {AddCom(28,1);}
2842 break;
2843
2844 case 99:
2845 #line 670 "script.y"
2846 {AddCom(27,1);}
2847 break;
2848
2849 case 100:
2850 #line 671 "script.y"
2851 {AddCom(28,1);}
2852 break;
2853
2854 case 117:
2855 #line 690 "script.y"
2856 { AddCom(1,1); }
2857 break;
2858
2859 case 118:
2860 #line 692 "script.y"
2861 { AddCom(2,1);}
2862 break;
2863
2864 case 119:
2865 #line 694 "script.y"
2866 { AddCom(3,1);}
2867 break;
2868
2869 case 120:
2870 #line 696 "script.y"
2871 { AddCom(4,2);}
2872 break;
2873
2874 case 121:
2875 #line 698 "script.y"
2876 { AddCom(21,2);}
2877 break;
2878
2879 case 122:
2880 #line 700 "script.y"
2881 { AddCom(22,2);}
2882 break;
2883
2884 case 123:
2885 #line 702 "script.y"
2886 { AddCom(5,3);}
2887 break;
2888
2889 case 124:
2890 #line 704 "script.y"
2891 { AddCom(6,3);}
2892 break;
2893
2894 case 125:
2895 #line 706 "script.y"
2896 { AddCom(7,2);}
2897 break;
2898
2899 case 126:
2900 #line 708 "script.y"
2901 { AddCom(8,2);}
2902 break;
2903
2904 case 127:
2905 #line 710 "script.y"
2906 { AddCom(9,2);}
2907 break;
2908
2909 case 128:
2910 #line 712 "script.y"
2911 { AddCom(10,2);}
2912 break;
2913
2914 case 129:
2915 #line 714 "script.y"
2916 { AddCom(19,2);}
2917 break;
2918
2919 case 130:
2920 #line 716 "script.y"
2921 { AddCom(24,2);}
2922 break;
2923
2924 case 131:
2925 #line 718 "script.y"
2926 { AddCom(11,2);}
2927 break;
2928
2929 case 132:
2930 #line 720 "script.y"
2931 { AddCom(12,2);}
2932 break;
2933
2934 case 133:
2935 #line 722 "script.y"
2936 { AddCom(13,0);}
2937 break;
2938
2939 case 134:
2940 #line 724 "script.y"
2941 { AddCom(17,1);}
2942 break;
2943
2944 case 135:
2945 #line 726 "script.y"
2946 { AddCom(23,2);}
2947 break;
2948
2949 case 136:
2950 #line 728 "script.y"
2951 { AddCom(18,2);}
2952 break;
2953
2954 case 137:
2955 #line 730 "script.y"
2956 { AddCom(25,5);}
2957 break;
2958
2959 case 138:
2960 #line 732 "script.y"
2961 { AddCom(26,2);}
2962 break;
2963
2964 case 142:
2965 #line 742 "script.y"
2966 { AddComBloc(14,3,2); }
2967 break;
2968
2969 case 145:
2970 #line 747 "script.y"
2971 { EmpilerBloc(); }
2972 break;
2973
2974 case 146:
2975 #line 749 "script.y"
2976 { DepilerBloc(2); }
2977 break;
2978
2979 case 147:
2980 #line 750 "script.y"
2981 { DepilerBloc(2); }
2982 break;
2983
2984 case 148:
2985 #line 753 "script.y"
2986 { DepilerBloc(1); }
2987 break;
2988
2989 case 149:
2990 #line 754 "script.y"
2991 { DepilerBloc(1); }
2992 break;
2993
2994 case 150:
2995 #line 758 "script.y"
2996 { AddComBloc(15,3,1); }
2997 break;
2998
2999 case 151:
3000 #line 762 "script.y"
3001 { AddComBloc(16,3,1); }
3002 break;
3003
3004 case 152:
3005 #line 767 "script.y"
3006 { AddVar((yyvsp[(1) - (1)].str)); }
3007 break;
3008
3009 case 153:
3010 #line 769 "script.y"
3011 { AddConstStr((yyvsp[(1) - (1)].str)); }
3012 break;
3013
3014 case 154:
3015 #line 771 "script.y"
3016 { AddConstStr((yyvsp[(1) - (1)].str)); }
3017 break;
3018
3019 case 155:
3020 #line 773 "script.y"
3021 { AddConstNum((yyvsp[(1) - (1)].number)); }
3022 break;
3023
3024 case 156:
3025 #line 775 "script.y"
3026 { AddConstNum(-1); }
3027 break;
3028
3029 case 157:
3030 #line 777 "script.y"
3031 { AddConstNum(-2); }
3032 break;
3033
3034 case 158:
3035 #line 779 "script.y"
3036 { AddLevelBufArg(); }
3037 break;
3038
3039 case 159:
3040 #line 781 "script.y"
3041 { AddFunct(1,1); }
3042 break;
3043
3044 case 160:
3045 #line 782 "script.y"
3046 { AddFunct(2,1); }
3047 break;
3048
3049 case 161:
3050 #line 783 "script.y"
3051 { AddFunct(3,1); }
3052 break;
3053
3054 case 162:
3055 #line 784 "script.y"
3056 { AddFunct(4,1); }
3057 break;
3058
3059 case 163:
3060 #line 785 "script.y"
3061 { AddFunct(5,1); }
3062 break;
3063
3064 case 164:
3065 #line 786 "script.y"
3066 { AddFunct(6,1); }
3067 break;
3068
3069 case 165:
3070 #line 787 "script.y"
3071 { AddFunct(7,1); }
3072 break;
3073
3074 case 166:
3075 #line 788 "script.y"
3076 { AddFunct(8,1); }
3077 break;
3078
3079 case 167:
3080 #line 789 "script.y"
3081 { AddFunct(9,1); }
3082 break;
3083
3084 case 168:
3085 #line 790 "script.y"
3086 { AddFunct(10,1); }
3087 break;
3088
3089 case 169:
3090 #line 791 "script.y"
3091 { AddFunct(11,1); }
3092 break;
3093
3094 case 170:
3095 #line 792 "script.y"
3096 { AddFunct(12,1); }
3097 break;
3098
3099 case 171:
3100 #line 793 "script.y"
3101 { AddFunct(13,1); }
3102 break;
3103
3104 case 172:
3105 #line 794 "script.y"
3106 { AddFunct(14,1); }
3107 break;
3108
3109 case 173:
3110 #line 795 "script.y"
3111 { AddFunct(15,1); }
3112 break;
3113
3114 case 174:
3115 #line 796 "script.y"
3116 { AddFunct(16,1); }
3117 break;
3118
3119 case 175:
3120 #line 797 "script.y"
3121 { AddFunct(17,1); }
3122 break;
3123
3124 case 176:
3125 #line 798 "script.y"
3126 { AddFunct(18,1); }
3127 break;
3128
3129 case 177:
3130 #line 799 "script.y"
3131 { AddFunct(19,1); }
3132 break;
3133
3134 case 178:
3135 #line 800 "script.y"
3136 { AddFunct(20,1); }
3137 break;
3138
3139 case 179:
3140 #line 801 "script.y"
3141 { AddFunct(21,1); }
3142 break;
3143
3144 case 180:
3145 #line 802 "script.y"
3146 { AddFunct(22,1); }
3147 break;
3148
3149 case 181:
3150 #line 803 "script.y"
3151 { AddFunct(23,1); }
3152 break;
3153
3154 case 182:
3155 #line 804 "script.y"
3156 { AddFunct(24,1); }
3157 break;
3158
3159 case 183:
3160 #line 805 "script.y"
3161 { AddFunct(25,1); }
3162 break;
3163
3164 case 184:
3165 #line 806 "script.y"
3166 { AddFunct(26,1); }
3167 break;
3168
3169 case 185:
3170 #line 811 "script.y"
3171 { }
3172 break;
3173
3174 case 212:
3175 #line 856 "script.y"
3176 { l=1-250000; AddBufArg(&l,1); }
3177 break;
3178
3179 case 213:
3180 #line 857 "script.y"
3181 { l=2-250000; AddBufArg(&l,1); }
3182 break;
3183
3184 case 214:
3185 #line 858 "script.y"
3186 { l=3-250000; AddBufArg(&l,1); }
3187 break;
3188
3189 case 215:
3190 #line 859 "script.y"
3191 { l=4-250000; AddBufArg(&l,1); }
3192 break;
3193
3194 case 216:
3195 #line 860 "script.y"
3196 { l=5-250000; AddBufArg(&l,1); }
3197 break;
3198
3199 case 217:
3200 #line 861 "script.y"
3201 { l=6-250000; AddBufArg(&l,1); }
3202 break;
3203
3204
3205 /* Line 1267 of yacc.c. */
3206 #line 3210 "y.tab.c"
3207 default: break;
3208 }
3209 YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
3210
3211 YYPOPSTACK (yylen);
3212 yylen = 0;
3213 YY_STACK_PRINT (yyss, yyssp);
3214
3215 *++yyvsp = yyval;
3216
3217
3218 /* Now `shift' the result of the reduction. Determine what state
3219 that goes to, based on the state we popped back to and the rule
3220 number reduced by. */
3221
3222 yyn = yyr1[yyn];
3223
3224 yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
3225 if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
3226 yystate = yytable[yystate];
3227 else
3228 yystate = yydefgoto[yyn - YYNTOKENS];
3229
3230 goto yynewstate;
3231
3232
3233 /*------------------------------------.
3234 | yyerrlab -- here on detecting error |
3235 `------------------------------------*/
3236 yyerrlab:
3237 /* If not already recovering from an error, report this error. */
3238 if (!yyerrstatus)
3239 {
3240 ++yynerrs;
3241 #if ! YYERROR_VERBOSE
3242 yyerror (YY_("syntax error"));
3243 #else
3244 {
3245 YYSIZE_T yysize = yysyntax_error (0, yystate, yychar);
3246 if (yymsg_alloc < yysize && yymsg_alloc < YYSTACK_ALLOC_MAXIMUM)
3247 {
3248 YYSIZE_T yyalloc = 2 * yysize;
3249 if (! (yysize <= yyalloc && yyalloc <= YYSTACK_ALLOC_MAXIMUM))
3250 yyalloc = YYSTACK_ALLOC_MAXIMUM;
3251 if (yymsg != yymsgbuf)
3252 YYSTACK_FREE (yymsg);
3253 yymsg = (char *) YYSTACK_ALLOC (yyalloc);
3254 if (yymsg)
3255 yymsg_alloc = yyalloc;
3256 else
3257 {
3258 yymsg = yymsgbuf;
3259 yymsg_alloc = sizeof yymsgbuf;
3260 }
3261 }
3262
3263 if (0 < yysize && yysize <= yymsg_alloc)
3264 {
3265 (void) yysyntax_error (yymsg, yystate, yychar);
3266 yyerror (yymsg);
3267 }
3268 else
3269 {
3270 yyerror (YY_("syntax error"));
3271 if (yysize != 0)
3272 goto yyexhaustedlab;
3273 }
3274 }
3275 #endif
3276 }
3277
3278
3279
3280 if (yyerrstatus == 3)
3281 {
3282 /* If just tried and failed to reuse look-ahead token after an
3283 error, discard it. */
3284
3285 if (yychar <= YYEOF)
3286 {
3287 /* Return failure if at end of input. */
3288 if (yychar == YYEOF)
3289 YYABORT;
3290 }
3291 else
3292 {
3293 yydestruct ("Error: discarding",
3294 yytoken, &yylval);
3295 yychar = YYEMPTY;
3296 }
3297 }
3298
3299 /* Else will try to reuse look-ahead token after shifting the error
3300 token. */
3301 goto yyerrlab1;
3302
3303
3304 /*---------------------------------------------------.
3305 | yyerrorlab -- error raised explicitly by YYERROR. |
3306 `---------------------------------------------------*/
3307 yyerrorlab:
3308
3309 /* Pacify compilers like GCC when the user code never invokes
3310 YYERROR and the label yyerrorlab therefore never appears in user
3311 code. */
3312 if (/*CONSTCOND*/ 0)
3313 goto yyerrorlab;
3314
3315 /* Do not reclaim the symbols of the rule which action triggered
3316 this YYERROR. */
3317 YYPOPSTACK (yylen);
3318 yylen = 0;
3319 YY_STACK_PRINT (yyss, yyssp);
3320 yystate = *yyssp;
3321 goto yyerrlab1;
3322
3323
3324 /*-------------------------------------------------------------.
3325 | yyerrlab1 -- common code for both syntax error and YYERROR. |
3326 `-------------------------------------------------------------*/
3327 yyerrlab1:
3328 yyerrstatus = 3; /* Each real token shifted decrements this. */
3329
3330 for (;;)
3331 {
3332 yyn = yypact[yystate];
3333 if (yyn != YYPACT_NINF)
3334 {
3335 yyn += YYTERROR;
3336 if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
3337 {
3338 yyn = yytable[yyn];
3339 if (0 < yyn)
3340 break;
3341 }
3342 }
3343
3344 /* Pop the current state because it cannot handle the error token. */
3345 if (yyssp == yyss)
3346 YYABORT;
3347
3348
3349 yydestruct ("Error: popping",
3350 yystos[yystate], yyvsp);
3351 YYPOPSTACK (1);
3352 yystate = *yyssp;
3353 YY_STACK_PRINT (yyss, yyssp);
3354 }
3355
3356 if (yyn == YYFINAL)
3357 YYACCEPT;
3358
3359 *++yyvsp = yylval;
3360
3361
3362 /* Shift the error token. */
3363 YY_SYMBOL_PRINT ("Shifting", yystos[yyn], yyvsp, yylsp);
3364
3365 yystate = yyn;
3366 goto yynewstate;
3367
3368
3369 /*-------------------------------------.
3370 | yyacceptlab -- YYACCEPT comes here. |
3371 `-------------------------------------*/
3372 yyacceptlab:
3373 yyresult = 0;
3374 goto yyreturn;
3375
3376 /*-----------------------------------.
3377 | yyabortlab -- YYABORT comes here. |
3378 `-----------------------------------*/
3379 yyabortlab:
3380 yyresult = 1;
3381 goto yyreturn;
3382
3383 #ifndef yyoverflow
3384 /*-------------------------------------------------.
3385 | yyexhaustedlab -- memory exhaustion comes here. |
3386 `-------------------------------------------------*/
3387 yyexhaustedlab:
3388 yyerror (YY_("memory exhausted"));
3389 yyresult = 2;
3390 /* Fall through. */
3391 #endif
3392
3393 yyreturn:
3394 if (yychar != YYEOF && yychar != YYEMPTY)
3395 yydestruct ("Cleanup: discarding lookahead",
3396 yytoken, &yylval);
3397 /* Do not reclaim the symbols of the rule which action triggered
3398 this YYABORT or YYACCEPT. */
3399 YYPOPSTACK (yylen);
3400 YY_STACK_PRINT (yyss, yyssp);
3401 while (yyssp != yyss)
3402 {
3403 yydestruct ("Cleanup: popping",
3404 yystos[*yyssp], yyvsp);
3405 YYPOPSTACK (1);
3406 }
3407 #ifndef yyoverflow
3408 if (yyss != yyssa)
3409 YYSTACK_FREE (yyss);
3410 #endif
3411 #if YYERROR_VERBOSE
3412 if (yymsg != yymsgbuf)
3413 YYSTACK_FREE (yymsg);
3414 #endif
3415 /* Make sure YYID is used. */
3416 return YYID (yyresult);
3417 }
3418
3419
3420 #line 864 "script.y"
3421
3422
3423