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