1
2 /* A Bison parser, made from Compiler/bisonin
3 by GNU Bison version 1.25
4 */
5
6 int yylex (void);
7
8 #define YYBISON 1 /* Identify Bison output. */
9
10 #define STR 258
11 #define GSTR 259
12 #define VAR 260
13 #define NUMBER 261
14 #define WINDOWTITLE 262
15 #define WINDOWSIZE 263
16 #define WINDOWPOSITION 264
17 #define FONT 265
18 #define FORECOLOR 266
19 #define BACKCOLOR 267
20 #define SHADCOLOR 268
21 #define LICOLOR 269
22 #define OBJECT 270
23 #define INIT 271
24 #define PERIODICTASK 272
25 #define MAIN 273
26 #define END 274
27 #define PROP 275
28 #define TYPE 276
29 #define SIZE 277
30 #define POSITION 278
31 #define VALUE 279
32 #define VALUEMIN 280
33 #define VALUEMAX 281
34 #define TITLE 282
35 #define SWALLOWEXEC 283
36 #define ICON 284
37 #define FLAGS 285
38 #define WARP 286
39 #define WRITETOFILE 287
40 #define HIDDEN 288
41 #define CANBESELECTED 289
42 #define NORELIEFSTRING 290
43 #define CASE 291
44 #define SINGLECLIC 292
45 #define DOUBLECLIC 293
46 #define BEG 294
47 #define POINT 295
48 #define EXEC 296
49 #define HIDE 297
50 #define SHOW 298
51 #define CHFORECOLOR 299
52 #define CHBACKCOLOR 300
53 #define GETVALUE 301
54 #define CHVALUE 302
55 #define CHVALUEMAX 303
56 #define CHVALUEMIN 304
57 #define ADD 305
58 #define DIV 306
59 #define MULT 307
60 #define GETTITLE 308
61 #define GETOUTPUT 309
62 #define GETASOPTION 310
63 #define SETASOPTION 311
64 #define STRCOPY 312
65 #define NUMTOHEX 313
66 #define HEXTONUM 314
67 #define QUIT 315
68 #define LAUNCHSCRIPT 316
69 #define GETSCRIPTFATHER 317
70 #define SENDTOSCRIPT 318
71 #define RECEIVFROMSCRIPT 319
72 #define GET 320
73 #define SET 321
74 #define SENDSIGN 322
75 #define REMAINDEROFDIV 323
76 #define GETTIME 324
77 #define GETSCRIPTARG 325
78 #define IF 326
79 #define THEN 327
80 #define ELSE 328
81 #define FOR 329
82 #define TO 330
83 #define DO 331
84 #define WHILE 332
85 #define BEGF 333
86 #define ENDF 334
87 #define EQUAL 335
88 #define INFEQ 336
89 #define SUPEQ 337
90 #define INF 338
91 #define SUP 339
92 #define DIFF 340
93
94 #line 1 "Compiler/bisonin"
95
96 #include "types.h"
97
98 extern int numligne;
99 ScriptProp *scriptprop;
100 int nbobj = -1; /* Nombre d'objets */
101 int HasPosition, HasType = 0;
102 TabObj *tabobj; /* Tableau d'objets, limite=100 */
103 int TabIdObj[101]; /* Tableau d'indice des objets */
104 Bloc **TabIObj; /* TabIObj[Obj][Case] -> bloc attache au case */
105 Bloc *PileBloc[10]; /* Au maximum 10 imbrications de boucle conditionnelle */
106 int TopPileB = 0; /* Sommet de la pile des blocs */
107 CaseObj *TabCObj; /* Struct pour enregistrer les valeurs des cases et leur nb */
108 int CurrCase;
109 int i;
110 char **TabNVar; /* Tableau des noms de variables */
111 char **TabVVar; /* Tableau des valeurs de variables */
112 int NbVar;
113 long BuffArg[6][20]; /* Les arguments s'ajoute par couche pour chaque fonction imbriquee */
114 int NbArg[6]; /* Tableau: nb d'args pour chaque couche */
115 int SPileArg; /* Taille de la pile d'arguments */
116 long l;
117
118 /* Initialisation globale */
119 void
InitVarGlob()120 InitVarGlob ()
121 {
122 scriptprop = (ScriptProp *) calloc (1, sizeof (ScriptProp));
123 scriptprop->x = -1;
124 scriptprop->y = -1;
125 scriptprop->initbloc = NULL;
126
127 tabobj = (TabObj *) calloc (1, sizeof (TabObj));
128 for (i = 0; i < 101; i++)
129 TabIdObj[i] = -1;
130 TabNVar = NULL;
131 TabVVar = NULL;
132 NbVar = -1;
133
134 SPileArg = -1;
135 scriptprop->periodictasks = NULL;
136 }
137
138 /* Initialisation pour un objet */
139 void
InitObjTabCase(int HasMainLoop)140 InitObjTabCase (int HasMainLoop)
141 {
142 if (nbobj == 0)
143 {
144 TabIObj = (Bloc **) calloc (1, sizeof (long));
145 TabCObj = (CaseObj *) calloc (1, sizeof (CaseObj));
146 }
147 else
148 {
149 TabIObj = (Bloc **) realloc (TabIObj, sizeof (long) * (nbobj + 1));
150 TabCObj = (CaseObj *) realloc (TabCObj, sizeof (CaseObj) * (nbobj + 1));
151 }
152
153 if (!HasMainLoop)
154 TabIObj[nbobj] = NULL;
155 CurrCase = -1;
156 TabCObj[nbobj].NbCase = -1;
157 }
158
159 /* Ajout d'un case dans la table TabCase */
160 /* Initialisation d'un case of: agrandissement de la table */
161 void
InitCase(int cond)162 InitCase (int cond)
163 {
164 CurrCase++;
165
166 /* On enregistre la condition du case */
167 TabCObj[nbobj].NbCase++;
168 if (TabCObj[nbobj].NbCase == 0)
169 TabCObj[nbobj].LstCase = (int *) calloc (1, sizeof (int));
170 else
171 TabCObj[nbobj].LstCase = (int *) realloc (TabCObj[nbobj].LstCase, sizeof (int) * (CurrCase + 1));
172 TabCObj[nbobj].LstCase[CurrCase] = cond;
173
174 if (CurrCase == 0)
175 TabIObj[nbobj] = (Bloc *) calloc (1, sizeof (Bloc));
176 else
177 TabIObj[nbobj] = (Bloc *) realloc (TabIObj[nbobj], sizeof (Bloc) * (CurrCase + 1));
178
179 TabIObj[nbobj][CurrCase].NbInstr = -1;
180 TabIObj[nbobj][CurrCase].TabInstr = NULL;
181
182 /* Ce case correspond au bloc courant d'instruction: on l'empile */
183 PileBloc[0] = &TabIObj[nbobj][CurrCase];
184 TopPileB = 0;
185 }
186
187 /* Enleve un niveau d'args dans la pile BuffArg */
188 void
RmLevelBufArg()189 RmLevelBufArg ()
190 {
191 SPileArg--;
192 }
193
194 /* Fonction de concatenation des n derniers etage de la pile */
195 /* Retourne les elts trie et depile et la taille */
196 long *
Depile(int NbLevelArg,int * s)197 Depile (int NbLevelArg, int *s)
198 {
199 long *Temp;
200 int j;
201 int i;
202 int size;
203
204 if (NbLevelArg > 0)
205 {
206 Temp = (long *) calloc (1, sizeof (long));
207 size = 0;
208 for (i = SPileArg - NbLevelArg + 1; i <= SPileArg; i++)
209 {
210 size = NbArg[i] + size + 1;
211 Temp = (long *) realloc (Temp, sizeof (long) * size);
212 for (j = 0; j <= NbArg[i]; j++)
213 {
214 Temp[j + size - NbArg[i] - 1] = BuffArg[i][j];
215 }
216 }
217 *s = size;
218 for (i = 0; i < NbLevelArg; i++) /* On depile les couches d'arguments */
219 RmLevelBufArg ();
220 return Temp;
221 }
222 else
223 {
224 return NULL;
225 *s = 0;
226 }
227 }
228
229 /* Ajout d'une commande */
230 void
AddCom(int Type,int NbLevelArg)231 AddCom (int Type, int NbLevelArg)
232 {
233 int CurrInstr;
234
235
236 PileBloc[TopPileB]->NbInstr++;
237 CurrInstr = PileBloc[TopPileB]->NbInstr;
238
239 if (CurrInstr == 0)
240 PileBloc[TopPileB]->TabInstr = (Instr *) calloc (1, sizeof (Instr) * (CurrInstr + 1));
241 else
242 PileBloc[TopPileB]->TabInstr = (Instr *) realloc (PileBloc[TopPileB]->TabInstr,
243 sizeof (Instr) * (CurrInstr + 1));
244 /* Rangement des instructions dans le bloc */
245 PileBloc[TopPileB]->TabInstr[CurrInstr].Type = Type;
246 /* On enleve la derniere couche d'argument et on la range dans la commande */
247
248 PileBloc[TopPileB]->TabInstr[CurrInstr].TabArg = Depile (NbLevelArg,
249 &PileBloc[TopPileB]->TabInstr[CurrInstr].NbArg);
250 }
251
252 /* Initialisation du buffer contenant les arguments de la commande courante */
253 /* Ajout d'une couche d'argument dans la pile */
254 void
AddLevelBufArg()255 AddLevelBufArg ()
256 {
257 /* Agrandissment de la pile */
258 SPileArg++;
259 NbArg[SPileArg] = -1;
260 }
261
262 /* Ajout d'un arg dans la couche arg qui est au sommet de la pile TabArg */
263 void
AddBufArg(long * TabLong,int NbLong)264 AddBufArg (long *TabLong, int NbLong)
265 {
266 int i;
267
268 for (i = 0; i < NbLong; i++)
269 {
270 BuffArg[SPileArg][i + NbArg[SPileArg] + 1] = TabLong[i];
271 }
272 NbArg[SPileArg] = NbArg[SPileArg] + NbLong;
273 }
274
275 /* Recheche d'un nom de var dans TabVar, s'il n'existe pas il le cree */
276 /* Retourne un Id */
277 void
AddVar(char * Name)278 AddVar (char *Name) /* ajout de variable a la fin de la derniere commande pointee */
279 {
280 int i;
281
282 /* Comparaison avec les variables deja existante */
283 for (i = 0; i <= NbVar; i++)
284 if (strcmp (TabNVar[i], Name) == 0)
285 {
286 l = (long) i;
287 AddBufArg (&l, 1);
288 return;
289 }
290
291 if (NbVar > 58)
292 {
293 fprintf (stderr, "Line %d: too many variables (>60)\n", numligne);
294 exit (1);
295 }
296
297 /* La variable n'a pas ete trouvee: creation */
298 NbVar++;
299
300 if (NbVar == 0)
301 {
302 TabNVar = (char **) calloc (1, sizeof (long));
303 TabVVar = (char **) calloc (1, sizeof (long));
304 }
305 else
306 {
307 TabNVar = (char **) realloc (TabNVar, sizeof (long) * (NbVar + 1));
308 TabVVar = (char **) realloc (TabVVar, sizeof (long) * (NbVar + 1));
309 }
310
311 TabNVar[NbVar] = (char *) strdup (Name);
312 TabVVar[NbVar] = (char *) calloc (1, sizeof (char));
313 TabVVar[NbVar][0] = '\0';
314
315
316 /* Ajout de la variable dans le buffer Arg */
317 l = (long) NbVar;
318 AddBufArg (&l, 1);
319 return;
320 }
321
322 /* Ajout d'une constante str comme argument */
323 void
AddConstStr(char * Name)324 AddConstStr (char *Name)
325 {
326 /* On cree une nouvelle variable et on range la constante dedans */
327 NbVar++;
328 if (NbVar == 0)
329 {
330 TabVVar = (char **) calloc (1, sizeof (long));
331 TabNVar = (char **) calloc (1, sizeof (long));
332 }
333 else
334 {
335 TabVVar = (char **) realloc (TabVVar, sizeof (long) * (NbVar + 1));
336 TabNVar = (char **) realloc (TabNVar, sizeof (long) * (NbVar + 1));
337 }
338
339 TabNVar[NbVar] = (char *) calloc (1, sizeof (char));
340 TabNVar[NbVar][0] = '\0';
341 TabVVar[NbVar] = (char *) strdup (Name);
342
343 /* Ajout de l'id de la constante dans la liste courante des arguments */
344 l = (long) NbVar;
345 AddBufArg (&l, 1);
346 }
347
348 /* Ajout d'une constante numerique comme argument */
349 void
AddConstNum(long num)350 AddConstNum (long num)
351 {
352
353 /* On ne cree pas de nouvelle variable */
354 /* On code la valeur numerique afin de le ranger sous forme d'id */
355 l = num + 200000;
356 /* Ajout de la constante dans la liste courante des arguments */
357 AddBufArg (&l, 1);
358 }
359
360 /* Ajout d'une fonction comme argument */
361 /* Enleve les args de func de la pile, */
362 /* le concate, et les range dans la pile */
363 void
AddFunct(int code,int NbLevelArg)364 AddFunct (int code, int NbLevelArg)
365 {
366 int size;
367 long *l;
368 int i;
369
370 /* Methode: depiler BuffArg et completer le niveau inferieur de BuffArg */
371 l = Depile (NbLevelArg, &size);
372
373 size++;
374 if (size == 1)
375 l = (long *) calloc (1, sizeof (long));
376 else
377 {
378 l = (long *) realloc (l, sizeof (long) * (size));
379 for (i = size - 2; i > -1; i--) /* Deplacement des args */
380 {
381 l[i + 1] = l[i];
382 }
383 }
384 l[0] = (long) code - 150000;
385
386 AddBufArg (l, size);
387 }
388
389 /* Ajout d'une instruction de test pour executer un ou plusieurs blocs */
390 /* enregistre l'instruction et le champs de ces blocs = NULL */
391 void
AddComBloc(int TypeCond,int NbLevelArg,int NbBloc)392 AddComBloc (int TypeCond, int NbLevelArg, int NbBloc)
393 {
394 int i;
395 int OldNA;
396 int CurrInstr;
397
398 /* Ajout de l'instruction de teste comme d'une commande */
399 AddCom (TypeCond, NbLevelArg);
400
401 /* On initialise ensuite les deux champs reserve � bloc1 et bloc2 */
402 CurrInstr = PileBloc[TopPileB]->NbInstr;
403 /* Attention NbArg peur changer si on utilise en arg une fonction */
404 OldNA = PileBloc[TopPileB]->TabInstr[CurrInstr].NbArg;
405
406 PileBloc[TopPileB]->TabInstr[CurrInstr].TabArg = (long *) realloc (
407 PileBloc[TopPileB]->TabInstr[CurrInstr].TabArg, sizeof (long) * (OldNA + NbBloc));
408 for (i = 0; i < NbBloc; i++)
409 {
410 PileBloc[TopPileB]->TabInstr[CurrInstr].TabArg[OldNA + i] = 0;
411 }
412 PileBloc[TopPileB]->TabInstr[CurrInstr].NbArg = OldNA + NbBloc;
413 }
414
415 /* Creer un nouveau bloc, et l'empile: il devient le bloc courant */
416 void
EmpilerBloc()417 EmpilerBloc ()
418 {
419 Bloc *TmpBloc;
420
421 TmpBloc = (Bloc *) calloc (1, sizeof (Bloc));
422 TmpBloc->NbInstr = -1;
423 TmpBloc->TabInstr = NULL;
424 TopPileB++;
425 PileBloc[TopPileB] = TmpBloc;
426
427 }
428
429 /* Depile le bloc d'initialisation du script et le range a sa place speciale */
430 void
DepilerBloc(int IdBloc)431 DepilerBloc (int IdBloc)
432 {
433 Bloc *Bloc1;
434 Instr *IfInstr;
435
436 Bloc1 = PileBloc[TopPileB];
437 TopPileB--;
438 IfInstr = &PileBloc[TopPileB]->TabInstr[PileBloc[TopPileB]->NbInstr];
439 IfInstr->TabArg[IfInstr->NbArg - IdBloc] = (long) Bloc1;
440 }
441
442 /* Gestion des erreurs de syntaxes */
443 int
yyerror(char * errmsg)444 yyerror (char *errmsg)
445 {
446 fprintf (stderr, "Line %d: %s\n", numligne, errmsg);
447 return 0;
448 }
449
450
451
452 #line 346 "Compiler/bisonin"
453 typedef union
454 {
455 char *str;
456 int number;
457 }
458 YYSTYPE;
459 #include <stdio.h>
460
461 #ifndef __cplusplus
462 #ifndef __STDC__
463 #define const
464 #endif
465 #endif
466
467
468
469 #define YYFINAL 454
470 #define YYFLAG -32768
471 #define YYNTBASE 86
472
473 #define YYTRANSLATE(x) ((unsigned)(x) <= 340 ? yytranslate[x] : 148)
474
475 static const char yytranslate[] =
476 {0,
477 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
478 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
479 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
480 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
481 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
482 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
483 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
484 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
485 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
486 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
487 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
488 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
489 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
490 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
491 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
492 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
493 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
494 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
495 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
496 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
497 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
498 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
499 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
500 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
501 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
502 2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
503 6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
504 16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
505 26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
506 36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
507 46, 47, 48, 49, 50, 51, 52, 53, 54, 55,
508 56, 57, 58, 59, 60, 61, 62, 63, 64, 65,
509 66, 67, 68, 69, 70, 71, 72, 73, 74, 75,
510 76, 77, 78, 79, 80, 81, 82, 83, 84, 85
511 };
512
513 #if YYDEBUG != 0
514 static const short yyprhs[] =
515 {0,
516 0, 6, 7, 8, 12, 16, 21, 26, 30, 34,
517 38, 42, 46, 47, 53, 54, 60, 61, 69, 71,
518 72, 76, 81, 86, 90, 94, 98, 102, 106, 110,
519 114, 118, 122, 126, 130, 134, 135, 138, 141, 144,
520 145, 147, 153, 154, 155, 160, 165, 167, 169, 171,
521 175, 176, 180, 184, 188, 192, 196, 200, 204, 208,
522 212, 216, 220, 224, 228, 232, 236, 240, 244, 248,
523 252, 256, 260, 264, 267, 270, 273, 276, 279, 282,
524 285, 288, 291, 294, 297, 300, 303, 306, 309, 312,
525 315, 318, 321, 324, 327, 330, 333, 336, 341, 346,
526 351, 358, 365, 370, 375, 380, 385, 390, 396, 401,
527 402, 405, 410, 415, 420, 424, 428, 436, 437, 441,
528 442, 446, 448, 452, 454, 464, 472, 474, 476, 478,
529 480, 482, 484, 485, 488, 491, 496, 501, 506, 510,
530 513, 517, 521, 525, 530, 533, 535, 538, 542, 544,
531 547, 548, 551, 554, 557, 560, 563, 566, 572, 574,
532 576, 578, 580, 582, 584, 589, 591, 593, 595, 597,
533 602, 604, 606, 611, 613, 615, 620, 622, 624, 626,
534 628, 630, 632
535 };
536
537 static const short yyrhs[] =
538 {87,
539 88, 89, 90, 91, 0, 0, 0, 7, 4, 88,
540 0, 29, 3, 88, 0, 9, 6, 6, 88, 0,
541 8, 6, 6, 88, 0, 12, 4, 88, 0, 11,
542 4, 88, 0, 13, 4, 88, 0, 14, 4, 88,
543 0, 10, 3, 88, 0, 0, 16, 128, 39, 102,
544 19, 0, 0, 17, 128, 39, 102, 19, 0, 0,
545 15, 92, 20, 93, 95, 96, 91, 0, 6, 0,
546 0, 21, 3, 93, 0, 22, 6, 6, 93, 0,
547 23, 6, 6, 93, 0, 24, 6, 93, 0, 25,
548 6, 93, 0, 26, 6, 93, 0, 27, 4, 93,
549 0, 28, 4, 93, 0, 29, 3, 93, 0, 12,
550 4, 93, 0, 11, 4, 93, 0, 13, 4, 93,
551 0, 14, 4, 93, 0, 10, 3, 93, 0, 30,
552 94, 93, 0, 0, 33, 94, 0, 35, 94, 0,
553 34, 94, 0, 0, 19, 0, 18, 97, 36, 98,
554 19, 0, 0, 0, 99, 40, 101, 98, 0, 100,
555 40, 101, 98, 0, 37, 0, 38, 0, 6, 0,
556 39, 102, 19, 0, 0, 41, 104, 102, 0, 31,
557 120, 102, 0, 32, 122, 102, 0, 42, 105, 102,
558 0, 43, 106, 102, 0, 47, 107, 102, 0, 48,
559 108, 102, 0, 49, 109, 102, 0, 23, 110, 102,
560 0, 22, 111, 102, 0, 27, 113, 102, 0, 29,
561 112, 102, 0, 10, 114, 102, 0, 44, 115, 102,
562 0, 45, 116, 102, 0, 66, 117, 102, 0, 67,
563 118, 102, 0, 60, 119, 102, 0, 63, 121, 102,
564 0, 71, 123, 102, 0, 74, 124, 102, 0, 77,
565 125, 102, 0, 41, 104, 0, 31, 120, 0, 32,
566 122, 0, 42, 105, 0, 43, 106, 0, 47, 107,
567 0, 48, 108, 0, 49, 109, 0, 23, 110, 0,
568 22, 111, 0, 27, 113, 0, 29, 112, 0, 10,
569 114, 0, 44, 115, 0, 45, 116, 0, 66, 117,
570 0, 67, 118, 0, 60, 119, 0, 63, 121, 0,
571 74, 124, 0, 77, 125, 0, 139, 141, 0, 139,
572 143, 0, 139, 143, 0, 139, 143, 139, 143, 0,
573 139, 143, 139, 143, 0, 139, 143, 139, 143, 0,
574 139, 143, 139, 143, 139, 143, 0, 139, 143, 139,
575 143, 139, 143, 0, 139, 143, 139, 144, 0, 139,
576 143, 139, 145, 0, 139, 143, 139, 144, 0, 139,
577 143, 139, 145, 0, 139, 143, 139, 145, 0, 139,
578 146, 65, 139, 141, 0, 139, 143, 139, 143, 0,
579 0, 139, 143, 0, 139, 143, 139, 141, 0, 139,
580 144, 139, 141, 0, 126, 128, 129, 127, 0, 131,
581 128, 130, 0, 132, 128, 130, 0, 139, 142, 139,
582 147, 139, 142, 72, 0, 0, 73, 128, 130, 0,
583 0, 39, 102, 19, 0, 103, 0, 39, 102, 19,
584 0, 103, 0, 139, 146, 65, 139, 142, 75, 139,
585 142, 76, 0, 139, 142, 139, 147, 139, 142, 76,
586 0, 5, 0, 3, 0, 4, 0, 6, 0, 37,
587 0, 38, 0, 0, 46, 143, 0, 53, 143, 0,
588 54, 145, 143, 143, 0, 55, 145, 145, 143, 0,
589 56, 145, 145, 143, 0, 58, 143, 143, 0, 59,
590 145, 0, 50, 143, 143, 0, 52, 143, 143, 0,
591 51, 143, 143, 0, 57, 145, 143, 143, 0, 61,
592 145, 0, 62, 0, 64, 143, 0, 68, 143, 143,
593 0, 69, 0, 70, 143, 0, 0, 137, 141, 0,
594 138, 141, 0, 133, 141, 0, 135, 141, 0, 134,
595 141, 0, 136, 141, 0, 78, 139, 140, 79, 141,
596 0, 133, 0, 137, 0, 138, 0, 135, 0, 134,
597 0, 136, 0, 78, 139, 140, 79, 0, 137, 0,
598 138, 0, 136, 0, 133, 0, 78, 139, 140, 79,
599 0, 133, 0, 134, 0, 78, 139, 140, 79, 0,
600 133, 0, 135, 0, 78, 139, 140, 79, 0, 133,
601 0, 83, 0, 81, 0, 80, 0, 82, 0, 84,
602 0, 85, 0
603 };
604
605 #endif
606
607 #if YYDEBUG != 0
608 static const short yyrline[] =
609 {0,
610 369, 372, 376, 377, 380, 383, 388, 393, 396, 399,
611 402, 405, 411, 412, 417, 418, 427, 428, 431, 446,
612 447, 451, 455, 460, 463, 466, 469, 472, 475, 478,
613 481, 484, 487, 490, 493, 495, 496, 499, 502, 508,
614 519, 520, 523, 525, 526, 527, 530, 531, 534, 537,
615 542, 543, 544, 545, 546, 547, 548, 549, 550, 551,
616 552, 553, 554, 555, 556, 557, 558, 559, 560, 561,
617 562, 563, 564, 568, 569, 570, 571, 572, 573, 574,
618 575, 576, 577, 578, 579, 580, 581, 582, 583, 584,
619 585, 586, 587, 588, 591, 593, 595, 597, 599, 601,
620 603, 605, 607, 609, 611, 613, 615, 617, 619, 621,
621 623, 625, 627, 629, 631, 633, 637, 639, 640, 642,
622 644, 645, 648, 649, 653, 657, 662, 664, 666, 668,
623 670, 672, 674, 676, 677, 678, 679, 680, 681, 682,
624 683, 684, 685, 686, 687, 688, 689, 690, 691, 692,
625 697, 698, 699, 700, 701, 702, 703, 704, 709, 710,
626 711, 712, 713, 714, 715, 719, 720, 721, 722, 723,
627 727, 728, 729, 733, 734, 735, 739, 743, 744, 745,
628 746, 747, 748
629 };
630 #endif
631
632
633 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)
634
635 static const char *const yytname[] =
636 {"$", "error", "$undefined.", "STR", "GSTR",
637 "VAR", "NUMBER", "WINDOWTITLE", "WINDOWSIZE", "WINDOWPOSITION", "FONT", "FORECOLOR",
638 "BACKCOLOR", "SHADCOLOR", "LICOLOR", "OBJECT", "INIT", "PERIODICTASK", "MAIN", "END",
639 "PROP", "TYPE", "SIZE", "POSITION", "VALUE", "VALUEMIN", "VALUEMAX", "TITLE", "SWALLOWEXEC",
640 "ICON", "FLAGS", "WARP", "WRITETOFILE", "HIDDEN", "CANBESELECTED", "NORELIEFSTRING",
641 "CASE", "SINGLECLIC", "DOUBLECLIC", "BEG", "POINT", "EXEC", "HIDE", "SHOW", "CHFORECOLOR",
642 "CHBACKCOLOR", "GETVALUE", "CHVALUE", "CHVALUEMAX", "CHVALUEMIN", "ADD", "DIV", "MULT",
643 "GETTITLE", "GETOUTPUT", "GETASOPTION", "SETASOPTION", "STRCOPY", "NUMTOHEX", "HEXTONUM",
644 "QUIT", "LAUNCHSCRIPT", "GETSCRIPTFATHER", "SENDTOSCRIPT", "RECEIVFROMSCRIPT", "GET",
645 "SET", "SENDSIGN", "REMAINDEROFDIV", "GETTIME", "GETSCRIPTARG", "IF", "THEN", "ELSE",
646 "FOR", "TO", "DO", "WHILE", "BEGF", "ENDF", "EQUAL", "INFEQ", "SUPEQ", "INF", "SUP", "DIFF",
647 "script", "initvar", "head", "initbloc", "periodictask", "object", "id", "init", "flags",
648 "verify", "mainloop", "addtabcase", "case", "clic", "number", "bloc", "instr", "oneinstr",
649 "exec", "hide", "show", "chvalue", "chvaluemax", "chvaluemin", "position", "size", "icon",
650 "title", "font", "chforecolor", "chbackcolor", "set", "sendsign", "quit", "warp", "sendtoscript",
651 "writetofile", "ifthenelse", "loop", "while", "headif", "else", "creerbloc", "bloc1",
652 "bloc2", "headloop", "headwhile", "var", "str", "gstr", "num", "singleclic2", "doubleclic2",
653 "addlbuff", "function", "args", "arg", "numarg", "strarg", "gstrarg", "vararg", "compare", NULL
654 };
655 #endif
656
657 static const short yyr1[] =
658 {0,
659 86, 87, 88, 88, 88, 88, 88, 88, 88, 88,
660 88, 88, 89, 89, 90, 90, 91, 91, 92, 93,
661 93, 93, 93, 93, 93, 93, 93, 93, 93, 93,
662 93, 93, 93, 93, 93, 94, 94, 94, 94, 95,
663 96, 96, 97, 98, 98, 98, 99, 99, 100, 101,
664 102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
665 102, 102, 102, 102, 102, 102, 102, 102, 102, 102,
666 102, 102, 102, 103, 103, 103, 103, 103, 103, 103,
667 103, 103, 103, 103, 103, 103, 103, 103, 103, 103,
668 103, 103, 103, 103, 104, 105, 106, 107, 108, 109,
669 110, 111, 112, 113, 114, 115, 116, 117, 118, 119,
670 120, 121, 122, 123, 124, 125, 126, 127, 127, 128,
671 129, 129, 130, 130, 131, 132, 133, 134, 135, 136,
672 137, 138, 139, 140, 140, 140, 140, 140, 140, 140,
673 140, 140, 140, 140, 140, 140, 140, 140, 140, 140,
674 141, 141, 141, 141, 141, 141, 141, 141, 142, 142,
675 142, 142, 142, 142, 142, 143, 143, 143, 143, 143,
676 144, 144, 144, 145, 145, 145, 146, 147, 147, 147,
677 147, 147, 147
678 };
679
680 static const short yyr2[] =
681 {0,
682 5, 0, 0, 3, 3, 4, 4, 3, 3, 3,
683 3, 3, 0, 5, 0, 5, 0, 7, 1, 0,
684 3, 4, 4, 3, 3, 3, 3, 3, 3, 3,
685 3, 3, 3, 3, 3, 0, 2, 2, 2, 0,
686 1, 5, 0, 0, 4, 4, 1, 1, 1, 3,
687 0, 3, 3, 3, 3, 3, 3, 3, 3, 3,
688 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
689 3, 3, 3, 2, 2, 2, 2, 2, 2, 2,
690 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
691 2, 2, 2, 2, 2, 2, 2, 4, 4, 4,
692 6, 6, 4, 4, 4, 4, 4, 5, 4, 0,
693 2, 4, 4, 4, 3, 3, 7, 0, 3, 0,
694 3, 1, 3, 1, 9, 7, 1, 1, 1, 1,
695 1, 1, 0, 2, 2, 4, 4, 4, 3, 2,
696 3, 3, 3, 4, 2, 1, 2, 3, 1, 2,
697 0, 2, 2, 2, 2, 2, 2, 5, 1, 1,
698 1, 1, 1, 1, 4, 1, 1, 1, 1, 4,
699 1, 1, 4, 1, 1, 4, 1, 1, 1, 1,
700 1, 1, 1
701 };
702
703 static const short yydefact[] =
704 {2,
705 3, 0, 0, 0, 0, 0, 0, 0, 0, 0,
706 13, 3, 0, 0, 3, 3, 3, 3, 3, 3,
707 120, 15, 4, 3, 3, 12, 9, 8, 10, 11,
708 5, 0, 120, 17, 7, 6, 51, 0, 0, 1,
709 133, 133, 133, 133, 133, 133, 133, 133, 133, 133,
710 133, 133, 133, 133, 133, 110, 133, 133, 133, 133,
711 133, 133, 0, 51, 19, 0, 51, 0, 51, 0,
712 51, 0, 51, 0, 51, 0, 51, 0, 51, 0,
713 51, 151, 51, 0, 51, 0, 51, 0, 51, 0,
714 51, 0, 51, 0, 51, 0, 51, 51, 0, 51,
715 0, 51, 0, 51, 120, 0, 51, 120, 0, 51,
716 120, 0, 14, 0, 20, 64, 127, 130, 131, 132,
717 133, 169, 168, 166, 167, 133, 61, 133, 60, 133,
718 62, 133, 63, 133, 53, 111, 54, 128, 133, 171,
719 172, 133, 52, 129, 133, 151, 151, 151, 151, 151,
720 151, 95, 55, 96, 56, 97, 65, 133, 66, 133,
721 57, 133, 58, 133, 59, 133, 69, 70, 133, 67,
722 177, 0, 68, 133, 71, 0, 133, 159, 163, 162,
723 164, 160, 161, 133, 72, 0, 0, 73, 0, 133,
724 16, 0, 0, 0, 0, 0, 0, 0, 0, 0,
725 0, 0, 0, 0, 0, 36, 40, 0, 0, 0,
726 0, 0, 0, 0, 151, 0, 154, 156, 155, 157,
727 152, 153, 0, 0, 0, 0, 0, 151, 133, 0,
728 133, 133, 133, 133, 133, 133, 133, 51, 133, 133,
729 133, 133, 133, 133, 133, 133, 110, 133, 133, 133,
730 133, 133, 122, 118, 0, 0, 51, 124, 115, 133,
731 116, 0, 20, 20, 20, 20, 20, 20, 0, 0,
732 20, 20, 20, 20, 20, 20, 36, 36, 36, 20,
733 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
734 0, 0, 0, 146, 0, 0, 149, 0, 0, 105,
735 133, 133, 133, 174, 175, 104, 103, 0, 113, 0,
736 106, 107, 98, 99, 100, 112, 151, 109, 86, 83,
737 82, 84, 85, 75, 76, 0, 74, 77, 78, 87,
738 88, 79, 80, 81, 91, 92, 89, 90, 93, 94,
739 120, 114, 0, 180, 179, 181, 178, 182, 183, 133,
740 0, 0, 133, 34, 31, 30, 32, 33, 21, 20,
741 20, 24, 25, 26, 27, 28, 29, 37, 39, 38,
742 35, 43, 41, 17, 134, 0, 0, 0, 135, 0,
743 0, 0, 0, 0, 140, 145, 147, 0, 150, 170,
744 0, 0, 0, 173, 151, 108, 121, 0, 165, 0,
745 123, 0, 0, 22, 23, 0, 18, 141, 143, 142,
746 0, 0, 0, 0, 139, 148, 102, 101, 0, 158,
747 119, 0, 133, 0, 44, 136, 137, 138, 144, 176,
748 117, 0, 126, 49, 47, 48, 0, 0, 0, 0,
749 42, 0, 0, 125, 51, 44, 44, 0, 45, 46,
750 50, 0, 0, 0
751 };
752
753 static const short yydefgoto[] =
754 {452,
755 1, 11, 22, 34, 40, 66, 207, 280, 281, 374,
756 406, 437, 438, 439, 446, 63, 258, 81, 83, 85,
757 91, 93, 95, 71, 69, 75, 73, 67, 87, 89,
758 100, 102, 97, 77, 98, 79, 104, 107, 110, 105,
759 342, 32, 254, 259, 108, 111, 122, 147, 148, 123,
760 124, 125, 68, 299, 152, 184, 126, 142, 306, 172,
761 350
762 };
763
764 static const short yypact[] =
765 {-32768,
766 275, 37, 39, 43, 26, 47, 51, 53, 55, 36,
767 27, 275, 57, 60, 275, 275, 275, 275, 275, 275,
768 -32768, 44, -32768, 275, 275, -32768, -32768, -32768, -32768, -32768,
769 -32768, 29, -32768, 70, -32768, -32768, 560, 31, 69, -32768,
770 -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
771 -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
772 -32768, -32768, 68, 560, -32768, 71, 560, 151, 560, 151,
773 560, 151, 560, 151, 560, 151, 560, 151, 560, 20,
774 560, 77, 560, 151, 560, 151, 560, 151, 560, 151,
775 560, 151, 560, 151, 560, 151, 560, 560, 151, 560,
776 84, 560, 151, 560, -32768, 261, 560, -32768, 84, 560,
777 -32768, 261, -32768, 74, 462, -32768, -32768, -32768, -32768, -32768,
778 -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
779 -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
780 -32768, -32768, -32768, -32768, -32768, 77, 77, 77, 77, 77,
781 77, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
782 -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
783 -32768, 41, -32768, -32768, -32768, 666, -32768, -32768, -32768, -32768,
784 -32768, -32768, -32768, -32768, -32768, 715, 56, -32768, 715, -32768,
785 -32768, 91, 100, 104, 119, 129, 133, 132, 134, 137,
786 138, 140, 145, 147, 149, 78, -32768, 589, 20, 151,
787 151, 23, 20, 589, 77, 589, -32768, -32768, -32768, -32768,
788 -32768, -32768, 23, 23, 151, 151, 151, 77, -32768, 151,
789 -32768, -32768, -32768, -32768, -32768, -32768, -32768, 560, -32768, -32768,
790 -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
791 -32768, -32768, -32768, 80, 589, 85, 560, -32768, -32768, -32768,
792 -32768, 85, 462, 462, 462, 462, 462, 462, 152, 171,
793 462, 462, 462, 462, 462, 462, 78, 78, 78, 462,
794 14, 151, 151, 151, 151, 151, 23, 23, 23, 23,
795 151, 23, 23, -32768, 151, 151, -32768, 151, 99, -32768,
796 -32768, -32768, -32768, -32768, -32768, -32768, -32768, 101, -32768, 117,
797 -32768, -32768, -32768, -32768, -32768, -32768, 77, -32768, -32768, -32768,
798 -32768, -32768, -32768, -32768, -32768, 160, -32768, -32768, -32768, -32768,
799 -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
800 -32768, -32768, 136, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
801 192, 261, -32768, -32768, -32768, -32768, -32768, -32768, -32768, 462,
802 462, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768, -32768,
803 -32768, -32768, -32768, 70, -32768, 151, 151, 151, -32768, 151,
804 23, 23, 151, 151, -32768, -32768, -32768, 151, -32768, -32768,
805 151, 151, 589, -32768, 77, -32768, -32768, 715, -32768, 261,
806 -32768, 141, 261, -32768, -32768, 177, -32768, -32768, -32768, -32768,
807 151, 151, 151, 151, -32768, -32768, -32768, -32768, 142, -32768,
808 -32768, 148, -32768, 143, 72, -32768, -32768, -32768, -32768, -32768,
809 -32768, 261, -32768, -32768, -32768, -32768, 198, 182, 183, 150,
810 -32768, 186, 186, -32768, 560, 72, 72, 208, -32768, -32768,
811 -32768, 230, 232, -32768
812 };
813
814 static const short yypgoto[] =
815 {-32768,
816 -32768, 487, -32768, -32768, -141, -32768, 188, -149, -32768, -32768,
817 -32768, -374, -32768, -32768, -208, -33, 63, 4, 6, 3,
818 7, 2, 9, 19, 30, 40, 24, 59, 49, 52,
819 45, 18, 50, 64, 48, 66, -32768, 58, 54, -32768,
820 -32768, -9, -32768, -167, -32768, -32768, 25, -59, 33, 13,
821 35, 130, -42, -179, 123, -98, 290, -183, 112, 201,
822 62
823 };
824
825
826 #define YYLAST 792
827
828
829 static const short yytable[] =
830 {70,
831 72, 74, 76, 78, 80, 82, 84, 86, 88, 90,
832 92, 94, 96, 190, 99, 101, 103, 106, 109, 112,
833 141, 261, 138, 38, 117, 300, 144, 117, 15, 307,
834 114, 372, 373, 116, 308, 127, 310, 129, 20, 131,
835 12, 133, 21, 135, 13, 137, 179, 143, 14, 153,
836 16, 155, 179, 157, 17, 159, 18, 161, 19, 163,
837 33, 165, 24, 167, 168, 25, 170, 37, 173, 64,
838 175, 449, 450, 185, 65, 343, 188, 434, 208, 138,
839 144, 117, 118, 209, 39, 210, 113, 211, 117, 212,
840 115, 213, 191, 263, 149, 176, 214, 139, 186, 215,
841 303, 189, 216, 264, 140, 229, 146, 265, 435, 436,
842 277, 278, 279, 119, 120, 223, 150, 224, 181, 225,
843 260, 226, 266, 227, 181, 171, 228, 368, 369, 370,
844 178, 230, 267, 171, 255, 268, 178, 269, 180, 270,
845 182, 256, 271, 272, 180, 273, 182, 262, 274, 141,
846 275, 276, 341, 141, 145, 117, 118, 360, 149, 149,
847 149, 149, 149, 149, 344, 345, 346, 347, 348, 349,
848 146, 146, 146, 146, 146, 146, 361, 390, 397, 394,
849 150, 150, 150, 150, 150, 150, 317, 119, 120, 70,
850 72, 74, 76, 78, 80, 395, 82, 84, 86, 88,
851 90, 92, 94, 96, 326, 99, 101, 103, 109, 112,
852 401, 151, 425, 419, 399, 423, 441, 352, 433, 431,
853 430, 442, 443, 351, 445, 444, 451, 149, 121, 453,
854 421, 454, 407, 140, 447, 183, 304, 140, 253, 146,
855 149, 183, 327, 329, 305, 328, 333, 304, 304, 150,
856 332, 321, 146, 402, 334, 305, 305, 322, 391, 392,
857 393, 320, 150, 138, 144, 117, 118, 338, 217, 218,
858 219, 220, 221, 222, 323, 151, 151, 151, 151, 151,
859 151, 2, 3, 4, 5, 6, 7, 8, 9, 319,
860 330, 0, 179, 337, 331, 336, 335, 119, 120, 324,
861 0, 422, 325, 10, 424, 340, 0, 400, 339, 187,
862 403, 304, 304, 304, 304, 0, 304, 304, 0, 305,
863 305, 305, 305, 353, 305, 305, 0, 0, 0, 149,
864 0, 398, 0, 440, 311, 312, 0, 309, 177, 0,
865 179, 146, 0, 179, 151, 0, 0, 0, 0, 0,
866 316, 150, 0, 0, 0, 0, 0, 151, 0, 128,
867 0, 130, 0, 132, 181, 134, 0, 136, 0, 0,
868 0, 0, 179, 154, 0, 156, 178, 158, 0, 160,
869 432, 162, 0, 164, 180, 166, 182, 0, 169, 0,
870 0, 0, 174, 0, 0, 0, 0, 0, 380, 381,
871 382, 383, 0, 385, 386, 304, 304, 149, 0, 0,
872 0, 448, 181, 305, 305, 181, 0, 0, 0, 146,
873 0, 0, 0, 0, 178, 0, 0, 178, 0, 150,
874 0, 0, 180, 0, 182, 180, 0, 182, 0, 396,
875 0, 0, 0, 0, 181, 0, 151, 0, 0, 0,
876 354, 355, 356, 357, 358, 359, 178, 0, 362, 363,
877 364, 365, 366, 367, 180, 0, 182, 371, 0, 0,
878 0, 192, 193, 194, 195, 196, 0, 0, 0, 0,
879 0, 183, 197, 198, 199, 200, 201, 202, 203, 204,
880 205, 206, 412, 413, 0, 0, 0, 0, 23, 301,
881 302, 26, 27, 28, 29, 30, 31, 0, 0, 0,
882 35, 36, 0, 0, 313, 314, 315, 420, 0, 318,
883 0, 0, 0, 0, 151, 0, 0, 0, 0, 183,
884 0, 0, 183, 0, 0, 0, 0, 0, 0, 0,
885 0, 0, 0, 0, 0, 0, 0, 404, 405, 0,
886 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
887 0, 183, 0, 0, 0, 0, 0, 0, 0, 41,
888 0, 375, 376, 377, 378, 379, 0, 0, 0, 0,
889 384, 42, 43, 0, 387, 388, 44, 389, 45, 0,
890 46, 47, 0, 0, 0, 0, 0, 0, 0, 0,
891 48, 49, 50, 51, 52, 0, 53, 54, 55, 0,
892 0, 0, 0, 0, 0, 0, 0, 0, 0, 56,
893 0, 0, 57, 0, 0, 58, 59, 0, 0, 0,
894 60, 0, 0, 61, 282, 0, 62, 0, 283, 284,
895 285, 286, 287, 288, 289, 290, 291, 292, 0, 293,
896 294, 0, 295, 0, 0, 0, 296, 297, 298, 0,
897 0, 0, 0, 0, 0, 408, 409, 410, 0, 411,
898 0, 0, 414, 415, 0, 231, 0, 416, 0, 0,
899 417, 418, 0, 0, 0, 0, 0, 232, 233, 0,
900 0, 0, 234, 0, 235, 0, 236, 237, 0, 0,
901 426, 427, 428, 429, 238, 0, 239, 240, 241, 242,
902 243, 0, 244, 245, 246, 0, 0, 0, 0, 0,
903 0, 0, 0, 0, 231, 247, 0, 0, 248, 0,
904 0, 249, 250, 0, 0, 0, 232, 233, 0, 251,
905 0, 234, 252, 235, 0, 236, 237, 0, 0, 0,
906 0, 0, 0, 257, 0, 239, 240, 241, 242, 243,
907 0, 244, 245, 246, 0, 0, 0, 0, 0, 0,
908 0, 0, 0, 0, 247, 0, 0, 248, 0, 0,
909 249, 250, 0, 0, 0, 0, 0, 0, 251, 0,
910 0, 252
911 };
912
913 static const short yycheck[] =
914 {42,
915 43, 44, 45, 46, 47, 48, 49, 50, 51, 52,
916 53, 54, 55, 112, 57, 58, 59, 60, 61, 62,
917 80, 189, 3, 33, 5, 209, 4, 5, 3, 213,
918 64, 18, 19, 67, 214, 69, 216, 71, 3, 73,
919 4, 75, 16, 77, 6, 79, 106, 81, 6, 83,
920 4, 85, 112, 87, 4, 89, 4, 91, 4, 93,
921 17, 95, 6, 97, 98, 6, 100, 39, 102, 39,
922 104, 446, 447, 107, 6, 255, 110, 6, 121, 3,
923 4, 5, 6, 126, 15, 128, 19, 130, 5, 132,
924 20, 134, 19, 3, 82, 105, 139, 78, 108, 142,
925 78, 111, 145, 4, 80, 65, 82, 4, 37, 38,
926 33, 34, 35, 37, 38, 158, 82, 160, 106, 162,
927 65, 164, 4, 166, 112, 101, 169, 277, 278, 279,
928 106, 174, 4, 109, 177, 3, 112, 6, 106, 6,
929 106, 184, 6, 6, 112, 6, 112, 190, 4, 209,
930 4, 3, 73, 213, 78, 5, 6, 6, 146, 147,
931 148, 149, 150, 151, 80, 81, 82, 83, 84, 85,
932 146, 147, 148, 149, 150, 151, 6, 79, 19, 79,
933 146, 147, 148, 149, 150, 151, 229, 37, 38, 232,
934 233, 234, 235, 236, 237, 79, 239, 240, 241, 242,
935 243, 244, 245, 246, 238, 248, 249, 250, 251, 252,
936 19, 82, 36, 393, 79, 75, 19, 260, 76, 72,
937 79, 40, 40, 257, 39, 76, 19, 215, 78, 0,
938 398, 0, 374, 209, 443, 106, 212, 213, 176, 215,
939 228, 112, 239, 241, 212, 240, 245, 223, 224, 215,
940 244, 233, 228, 352, 246, 223, 224, 234, 301, 302,
941 303, 232, 228, 3, 4, 5, 6, 250, 146, 147,
942 148, 149, 150, 151, 235, 146, 147, 148, 149, 150,
943 151, 7, 8, 9, 10, 11, 12, 13, 14, 231,
944 242, -1, 352, 249, 243, 248, 247, 37, 38, 236,
945 -1, 400, 237, 29, 403, 252, -1, 350, 251, 109,
946 353, 287, 288, 289, 290, -1, 292, 293, -1, 287,
947 288, 289, 290, 262, 292, 293, -1, -1, -1, 317,
948 -1, 341, -1, 432, 223, 224, -1, 215, 78, -1,
949 400, 317, -1, 403, 215, -1, -1, -1, -1, -1,
950 228, 317, -1, -1, -1, -1, -1, 228, -1, 70,
951 -1, 72, -1, 74, 352, 76, -1, 78, -1, -1,
952 -1, -1, 432, 84, -1, 86, 352, 88, -1, 90,
953 423, 92, -1, 94, 352, 96, 352, -1, 99, -1,
954 -1, -1, 103, -1, -1, -1, -1, -1, 287, 288,
955 289, 290, -1, 292, 293, 381, 382, 395, -1, -1,
956 -1, 445, 400, 381, 382, 403, -1, -1, -1, 395,
957 -1, -1, -1, -1, 400, -1, -1, 403, -1, 395,
958 -1, -1, 400, -1, 400, 403, -1, 403, -1, 317,
959 -1, -1, -1, -1, 432, -1, 317, -1, -1, -1,
960 263, 264, 265, 266, 267, 268, 432, -1, 271, 272,
961 273, 274, 275, 276, 432, -1, 432, 280, -1, -1,
962 -1, 10, 11, 12, 13, 14, -1, -1, -1, -1,
963 -1, 352, 21, 22, 23, 24, 25, 26, 27, 28,
964 29, 30, 381, 382, -1, -1, -1, -1, 12, 210,
965 211, 15, 16, 17, 18, 19, 20, -1, -1, -1,
966 24, 25, -1, -1, 225, 226, 227, 395, -1, 230,
967 -1, -1, -1, -1, 395, -1, -1, -1, -1, 400,
968 -1, -1, 403, -1, -1, -1, -1, -1, -1, -1,
969 -1, -1, -1, -1, -1, -1, -1, 360, 361, -1,
970 -1, -1, -1, -1, -1, -1, -1, -1, -1, -1,
971 -1, 432, -1, -1, -1, -1, -1, -1, -1, 10,
972 -1, 282, 283, 284, 285, 286, -1, -1, -1, -1,
973 291, 22, 23, -1, 295, 296, 27, 298, 29, -1,
974 31, 32, -1, -1, -1, -1, -1, -1, -1, -1,
975 41, 42, 43, 44, 45, -1, 47, 48, 49, -1,
976 -1, -1, -1, -1, -1, -1, -1, -1, -1, 60,
977 -1, -1, 63, -1, -1, 66, 67, -1, -1, -1,
978 71, -1, -1, 74, 46, -1, 77, -1, 50, 51,
979 52, 53, 54, 55, 56, 57, 58, 59, -1, 61,
980 62, -1, 64, -1, -1, -1, 68, 69, 70, -1,
981 -1, -1, -1, -1, -1, 376, 377, 378, -1, 380,
982 -1, -1, 383, 384, -1, 10, -1, 388, -1, -1,
983 391, 392, -1, -1, -1, -1, -1, 22, 23, -1,
984 -1, -1, 27, -1, 29, -1, 31, 32, -1, -1,
985 411, 412, 413, 414, 39, -1, 41, 42, 43, 44,
986 45, -1, 47, 48, 49, -1, -1, -1, -1, -1,
987 -1, -1, -1, -1, 10, 60, -1, -1, 63, -1,
988 -1, 66, 67, -1, -1, -1, 22, 23, -1, 74,
989 -1, 27, 77, 29, -1, 31, 32, -1, -1, -1,
990 -1, -1, -1, 39, -1, 41, 42, 43, 44, 45,
991 -1, 47, 48, 49, -1, -1, -1, -1, -1, -1,
992 -1, -1, -1, -1, 60, -1, -1, 63, -1, -1,
993 66, 67, -1, -1, -1, -1, -1, -1, 74, -1,
994 -1, 77
995 };
996 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */
997 #line 3 "/usr/share/bison.simple"
998
999 /* Skeleton output parser for bison,
1000 Copyright (C) 1984, 1989, 1990 Free Software Foundation, Inc.
1001
1002 This program is free software; you can redistribute it and/or modify
1003 it under the terms of the GNU General Public License as published by
1004 the Free Software Foundation; either version 2, or (at your option)
1005 any later version.
1006
1007 This program is distributed in the hope that it will be useful,
1008 but WITHOUT ANY WARRANTY; without even the implied warranty of
1009 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
1010 GNU General Public License for more details.
1011
1012 You should have received a copy of the GNU General Public License
1013 along with this program; if not, write to the Free Software
1014 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
1015
1016 /* As a special exception, when this file is copied by Bison into a
1017 Bison output file, you may use that output file without restriction.
1018 This special exception was added by the Free Software Foundation
1019 in version 1.24 of Bison. */
1020
1021 #ifndef alloca
1022 #ifdef __GNUC__
1023 #define alloca __builtin_alloca
1024 #else /* not GNU C. */
1025 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
1026 #include <alloca.h>
1027 #else /* not sparc */
1028 #if defined (MSDOS) && !defined (__TURBOC__)
1029 #include <malloc.h>
1030 #else /* not MSDOS, or __TURBOC__ */
1031 #if defined(_AIX)
1032 #include <malloc.h>
1033 #pragma alloca
1034 #else /* not MSDOS, __TURBOC__, or _AIX */
1035 #ifdef __hpux
1036 #ifdef __cplusplus
1037 extern "C"
1038 {
1039 void *alloca (unsigned int);
1040 };
1041 #else /* not __cplusplus */
1042 void *alloca ();
1043 #endif /* not __cplusplus */
1044 #endif /* __hpux */
1045 #endif /* not _AIX */
1046 #endif /* not MSDOS, or __TURBOC__ */
1047 #endif /* not sparc. */
1048 #endif /* not GNU C. */
1049 #endif /* alloca not defined. */
1050
1051 /* This is the parser code that is written into each bison parser
1052 when the %semantic_parser declaration is not specified in the grammar.
1053 It was written by Richard Stallman by simplifying the hairy parser
1054 used when %semantic_parser is specified. */
1055
1056 /* Note: there must be only one dollar sign in this file.
1057 It is replaced by the list of actions, each action
1058 as one case of the switch. */
1059
1060 #define yyerrok (yyerrstatus = 0)
1061 #define yyclearin (yychar = YYEMPTY)
1062 #define YYEMPTY -2
1063 #define YYEOF 0
1064 #define YYACCEPT return(0)
1065 #define YYABORT return(1)
1066 #define YYERROR goto yyerrlab1
1067 /* Like YYERROR except do call yyerror.
1068 This remains here temporarily to ease the
1069 transition to the new meaning of YYERROR, for GCC.
1070 Once GCC version 2 has supplanted version 1, this can go. */
1071 #define YYFAIL goto yyerrlab
1072 #define YYRECOVERING() (!!yyerrstatus)
1073 #define YYBACKUP(token, value) \
1074 do \
1075 if (yychar == YYEMPTY && yylen == 1) \
1076 { yychar = (token), yylval = (value); \
1077 yychar1 = YYTRANSLATE (yychar); \
1078 YYPOPSTACK; \
1079 goto yybackup; \
1080 } \
1081 else \
1082 { yyerror ("syntax error: cannot back up"); YYERROR; } \
1083 while (0)
1084
1085 #define YYTERROR 1
1086 #define YYERRCODE 256
1087
1088 #ifndef YYPURE
1089 #define YYLEX yylex()
1090 #endif
1091
1092 #ifdef YYPURE
1093 #ifdef YYLSP_NEEDED
1094 #ifdef YYLEX_PARAM
1095 #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)
1096 #else
1097 #define YYLEX yylex(&yylval, &yylloc)
1098 #endif
1099 #else /* not YYLSP_NEEDED */
1100 #ifdef YYLEX_PARAM
1101 #define YYLEX yylex(&yylval, YYLEX_PARAM)
1102 #else
1103 #define YYLEX yylex(&yylval)
1104 #endif
1105 #endif /* not YYLSP_NEEDED */
1106 #endif
1107
1108 /* If nonreentrant, generate the variables here */
1109
1110 #ifndef YYPURE
1111
1112 int yychar; /* the lookahead symbol */
1113 YYSTYPE yylval; /* the semantic value of the */
1114 /* lookahead symbol */
1115
1116 #ifdef YYLSP_NEEDED
1117 YYLTYPE yylloc; /* location data for the lookahead */
1118 /* symbol */
1119 #endif
1120
1121 int yynerrs; /* number of parse errors so far */
1122 #endif /* not YYPURE */
1123
1124 #if YYDEBUG != 0
1125 int yydebug; /* nonzero means print parse trace */
1126 /* Since this is uninitialized, it does not stop multiple parsers
1127 from coexisting. */
1128 #endif
1129
1130 /* YYINITDEPTH indicates the initial size of the parser's stacks */
1131
1132 #ifndef YYINITDEPTH
1133 #define YYINITDEPTH 200
1134 #endif
1135
1136 /* YYMAXDEPTH is the maximum size the stacks can grow to
1137 (effective only if the built-in stack extension method is used). */
1138
1139 #if YYMAXDEPTH == 0
1140 #undef YYMAXDEPTH
1141 #endif
1142
1143 #ifndef YYMAXDEPTH
1144 #define YYMAXDEPTH 10000
1145 #endif
1146
1147 /* Prevent warning if -Wstrict-prototypes. */
1148 #ifdef __GNUC__
1149 int yyparse (void);
1150 #endif
1151
1152 #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
1153 #define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)
1154 #else /* not GNU C or C++ */
1155 #ifndef __cplusplus
1156
1157 /* This is the most reliable way to avoid incompatibilities
1158 in available built-in functions on various systems. */
1159 static void
__yy_memcpy(to,from,count)1160 __yy_memcpy (to, from, count)
1161 char *to;
1162 char *from;
1163 int count;
1164 {
1165 register char *f = from;
1166 register char *t = to;
1167 register int i = count;
1168
1169 while (i-- > 0)
1170 *t++ = *f++;
1171 }
1172
1173 #else /* __cplusplus */
1174
1175 /* This is the most reliable way to avoid incompatibilities
1176 in available built-in functions on various systems. */
1177 static void
__yy_memcpy(char * to,char * from,int count)1178 __yy_memcpy (char *to, char *from, int count)
1179 {
1180 register char *f = from;
1181 register char *t = to;
1182 register int i = count;
1183
1184 while (i-- > 0)
1185 *t++ = *f++;
1186 }
1187
1188 #endif
1189 #endif
1190
1191 #line 196 "/usr/share/bison.simple"
1192
1193 /* The user can define YYPARSE_PARAM as the name of an argument to be passed
1194 into yyparse. The argument should have type void *.
1195 It should actually point to an object.
1196 Grammar actions can access the variable by casting it
1197 to the proper pointer type. */
1198
1199 #ifdef YYPARSE_PARAM
1200 #ifdef __cplusplus
1201 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM
1202 #define YYPARSE_PARAM_DECL
1203 #else /* not __cplusplus */
1204 #define YYPARSE_PARAM_ARG YYPARSE_PARAM
1205 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;
1206 #endif /* not __cplusplus */
1207 #else /* not YYPARSE_PARAM */
1208 #define YYPARSE_PARAM_ARG
1209 #define YYPARSE_PARAM_DECL
1210 #endif /* not YYPARSE_PARAM */
1211
1212 int
yyparse(YYPARSE_PARAM_ARG)1213 yyparse (YYPARSE_PARAM_ARG)
1214 YYPARSE_PARAM_DECL
1215 {
1216 register int yystate;
1217 register int yyn;
1218 register short *yyssp;
1219 register YYSTYPE *yyvsp;
1220 int yyerrstatus; /* number of tokens to shift before error messages enabled */
1221 int yychar1 = 0; /* lookahead token as an internal (translated) token number */
1222
1223 short yyssa[YYINITDEPTH]; /* the state stack */
1224 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */
1225
1226 short *yyss = yyssa; /* refer to the stacks thru separate pointers */
1227 YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */
1228
1229 #ifdef YYLSP_NEEDED
1230 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */
1231 YYLTYPE *yyls = yylsa;
1232 YYLTYPE *yylsp;
1233
1234 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)
1235 #else
1236 #define YYPOPSTACK (yyvsp--, yyssp--)
1237 #endif
1238
1239 int yystacksize = YYINITDEPTH;
1240
1241 #ifdef YYPURE
1242 int yychar;
1243 YYSTYPE yylval;
1244 int yynerrs;
1245 #ifdef YYLSP_NEEDED
1246 YYLTYPE yylloc;
1247 #endif
1248 #endif
1249
1250 YYSTYPE yyval; /* the variable used to return */
1251 /* semantic values from the action */
1252 /* routines */
1253
1254 int yylen;
1255
1256 #if YYDEBUG != 0
1257 if (yydebug)
1258 fprintf (stderr, "Starting parse\n");
1259 #endif
1260
1261 yystate = 0;
1262 yyerrstatus = 0;
1263 yynerrs = 0;
1264 yychar = YYEMPTY; /* Cause a token to be read. */
1265
1266 /* Initialize stack pointers.
1267 Waste one element of value and location stack
1268 so that they stay on the same level as the state stack.
1269 The wasted elements are never initialized. */
1270
1271 yyssp = yyss - 1;
1272 yyvsp = yyvs;
1273 #ifdef YYLSP_NEEDED
1274 yylsp = yyls;
1275 #endif
1276
1277 /* Push a new state, which is found in yystate . */
1278 /* In all cases, when you get here, the value and location stacks
1279 have just been pushed. so pushing a state here evens the stacks. */
1280 yynewstate:
1281
1282 *++yyssp = yystate;
1283
1284 if (yyssp >= yyss + yystacksize - 1)
1285 {
1286 /* Give user a chance to reallocate the stack */
1287 /* Use copies of these so that the &'s don't force the real ones into memory. */
1288 YYSTYPE *yyvs1 = yyvs;
1289 short *yyss1 = yyss;
1290 #ifdef YYLSP_NEEDED
1291 YYLTYPE *yyls1 = yyls;
1292 #endif
1293
1294 /* Get the current used size of the three stacks, in elements. */
1295 int size = yyssp - yyss + 1;
1296
1297 #ifdef yyoverflow
1298 /* Each stack pointer address is followed by the size of
1299 the data in use in that stack, in bytes. */
1300 #ifdef YYLSP_NEEDED
1301 /* This used to be a conditional around just the two extra args,
1302 but that might be undefined if yyoverflow is a macro. */
1303 yyoverflow ("parser stack overflow",
1304 &yyss1, size * sizeof (*yyssp),
1305 &yyvs1, size * sizeof (*yyvsp),
1306 &yyls1, size * sizeof (*yylsp),
1307 &yystacksize);
1308 #else
1309 yyoverflow ("parser stack overflow",
1310 &yyss1, size * sizeof (*yyssp),
1311 &yyvs1, size * sizeof (*yyvsp),
1312 &yystacksize);
1313 #endif
1314
1315 yyss = yyss1;
1316 yyvs = yyvs1;
1317 #ifdef YYLSP_NEEDED
1318 yyls = yyls1;
1319 #endif
1320 #else /* no yyoverflow */
1321 /* Extend the stack our own way. */
1322 if (yystacksize >= YYMAXDEPTH)
1323 {
1324 yyerror ("parser stack overflow");
1325 return 2;
1326 }
1327 yystacksize *= 2;
1328 if (yystacksize > YYMAXDEPTH)
1329 yystacksize = YYMAXDEPTH;
1330 yyss = (short *) alloca (yystacksize * sizeof (*yyssp));
1331 __yy_memcpy ((char *) yyss, (char *) yyss1, size * sizeof (*yyssp));
1332 yyvs = (YYSTYPE *) alloca (yystacksize * sizeof (*yyvsp));
1333 __yy_memcpy ((char *) yyvs, (char *) yyvs1, size * sizeof (*yyvsp));
1334 #ifdef YYLSP_NEEDED
1335 yyls = (YYLTYPE *) alloca (yystacksize * sizeof (*yylsp));
1336 __yy_memcpy ((char *) yyls, (char *) yyls1, size * sizeof (*yylsp));
1337 #endif
1338 #endif /* no yyoverflow */
1339
1340 yyssp = yyss + size - 1;
1341 yyvsp = yyvs + size - 1;
1342 #ifdef YYLSP_NEEDED
1343 yylsp = yyls + size - 1;
1344 #endif
1345
1346 #if YYDEBUG != 0
1347 if (yydebug)
1348 fprintf (stderr, "Stack size increased to %d\n", yystacksize);
1349 #endif
1350
1351 if (yyssp >= yyss + yystacksize - 1)
1352 YYABORT;
1353 }
1354
1355 #if YYDEBUG != 0
1356 if (yydebug)
1357 fprintf (stderr, "Entering state %d\n", yystate);
1358 #endif
1359
1360 goto yybackup;
1361 yybackup:
1362
1363 /* Do appropriate processing given the current state. */
1364 /* Read a lookahead token if we need one and don't already have one. */
1365 /* yyresume: */
1366
1367 /* First try to decide what to do without reference to lookahead token. */
1368
1369 yyn = yypact[yystate];
1370 if (yyn == YYFLAG)
1371 goto yydefault;
1372
1373 /* Not known => get a lookahead token if don't already have one. */
1374
1375 /* yychar is either YYEMPTY or YYEOF
1376 or a valid token in external form. */
1377
1378 if (yychar == YYEMPTY)
1379 {
1380 #if YYDEBUG != 0
1381 if (yydebug)
1382 fprintf (stderr, "Reading a token: ");
1383 #endif
1384 yychar = YYLEX;
1385 }
1386
1387 /* Convert token to internal form (in yychar1) for indexing tables with */
1388
1389 if (yychar <= 0) /* This means end of input. */
1390 {
1391 yychar1 = 0;
1392 yychar = YYEOF; /* Don't call YYLEX any more */
1393
1394 #if YYDEBUG != 0
1395 if (yydebug)
1396 fprintf (stderr, "Now at end of input.\n");
1397 #endif
1398 }
1399 else
1400 {
1401 yychar1 = YYTRANSLATE (yychar);
1402
1403 #if YYDEBUG != 0
1404 if (yydebug)
1405 {
1406 fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);
1407 /* Give the individual parser a way to print the precise meaning
1408 of a token, for further debugging info. */
1409 #ifdef YYPRINT
1410 YYPRINT (stderr, yychar, yylval);
1411 #endif
1412 fprintf (stderr, ")\n");
1413 }
1414 #endif
1415 }
1416
1417 yyn += yychar1;
1418 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)
1419 goto yydefault;
1420
1421 yyn = yytable[yyn];
1422
1423 /* yyn is what to do for this token type in this state.
1424 Negative => reduce, -yyn is rule number.
1425 Positive => shift, yyn is new state.
1426 New state is final state => don't bother to shift,
1427 just return success.
1428 0, or most negative number => error. */
1429
1430 if (yyn < 0)
1431 {
1432 if (yyn == YYFLAG)
1433 goto yyerrlab;
1434 yyn = -yyn;
1435 goto yyreduce;
1436 }
1437 else if (yyn == 0)
1438 goto yyerrlab;
1439
1440 if (yyn == YYFINAL)
1441 YYACCEPT;
1442
1443 /* Shift the lookahead token. */
1444
1445 #if YYDEBUG != 0
1446 if (yydebug)
1447 fprintf (stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);
1448 #endif
1449
1450 /* Discard the token being shifted unless it is eof. */
1451 if (yychar != YYEOF)
1452 yychar = YYEMPTY;
1453
1454 *++yyvsp = yylval;
1455 #ifdef YYLSP_NEEDED
1456 *++yylsp = yylloc;
1457 #endif
1458
1459 /* count tokens shifted since error; after three, turn off error status. */
1460 if (yyerrstatus)
1461 yyerrstatus--;
1462
1463 yystate = yyn;
1464 goto yynewstate;
1465
1466 /* Do the default action for the current state. */
1467 yydefault:
1468
1469 yyn = yydefact[yystate];
1470 if (yyn == 0)
1471 goto yyerrlab;
1472
1473 /* Do a reduction. yyn is the number of a rule to reduce with. */
1474 yyreduce:
1475 yylen = yyr2[yyn];
1476 if (yylen > 0)
1477 yyval = yyvsp[1 - yylen]; /* implement default value of the action */
1478
1479 #if YYDEBUG != 0
1480 if (yydebug)
1481 {
1482 int i;
1483
1484 fprintf (stderr, "Reducing via rule %d (line %d), ",
1485 yyn, yyrline[yyn]);
1486
1487 /* Print the symbols being reduced, and their result. */
1488 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)
1489 fprintf (stderr, "%s ", yytname[yyrhs[i]]);
1490 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);
1491 }
1492 #endif
1493
1494
1495 switch (yyn)
1496 {
1497
1498 case 2:
1499 #line 372 "Compiler/bisonin"
1500 {
1501 InitVarGlob ();;
1502 break;
1503 }
1504 case 4:
1505 #line 377 "Compiler/bisonin"
1506 { /* Titre de la fenetre */
1507 scriptprop->titlewin = yyvsp[-1].str;
1508 ;
1509 break;
1510 }
1511 case 5:
1512 #line 380 "Compiler/bisonin"
1513 {
1514 scriptprop->icon = yyvsp[-1].str;
1515 ;
1516 break;
1517 }
1518 case 6:
1519 #line 384 "Compiler/bisonin"
1520 { /* Position et taille de la fenetre */
1521 scriptprop->x = yyvsp[-2].number;
1522 scriptprop->y = yyvsp[-1].number;
1523 ;
1524 break;
1525 }
1526 case 7:
1527 #line 389 "Compiler/bisonin"
1528 { /* Position et taille de la fenetre */
1529 scriptprop->width = yyvsp[-2].number;
1530 scriptprop->height = yyvsp[-1].number;
1531 ;
1532 break;
1533 }
1534 case 8:
1535 #line 393 "Compiler/bisonin"
1536 { /* Couleur de fond */
1537 scriptprop->backcolor = yyvsp[-1].str;
1538 ;
1539 break;
1540 }
1541 case 9:
1542 #line 396 "Compiler/bisonin"
1543 { /* Couleur des lignes */
1544 scriptprop->forecolor = yyvsp[-1].str;
1545 ;
1546 break;
1547 }
1548 case 10:
1549 #line 399 "Compiler/bisonin"
1550 { /* Couleur des lignes */
1551 scriptprop->shadcolor = yyvsp[-1].str;
1552 ;
1553 break;
1554 }
1555 case 11:
1556 #line 402 "Compiler/bisonin"
1557 { /* Couleur des lignes */
1558 scriptprop->licolor = yyvsp[-1].str;
1559 ;
1560 break;
1561 }
1562 case 12:
1563 #line 405 "Compiler/bisonin"
1564 {
1565 scriptprop->font = yyvsp[-1].str;
1566 ;
1567 break;
1568 }
1569 case 14:
1570 #line 412 "Compiler/bisonin"
1571 {
1572 scriptprop->initbloc = PileBloc[TopPileB];
1573 TopPileB--;
1574 ;
1575 break;
1576 }
1577 case 16:
1578 #line 418 "Compiler/bisonin"
1579 {
1580 scriptprop->periodictasks = PileBloc[TopPileB];
1581 TopPileB--;
1582 ;
1583 break;
1584 }
1585 case 19:
1586 #line 431 "Compiler/bisonin"
1587 {
1588 nbobj++;
1589 if (nbobj > 100)
1590 {
1591 yyerror ("Too many items\n");
1592 exit (1);
1593 }
1594 if ((yyvsp[0].number < 1) || (yyvsp[0].number > 100))
1595 {
1596 yyerror ("Choose item id between 1 and 100\n");
1597 exit (1);
1598 }
1599 if (TabIdObj[yyvsp[0].number] != -1)
1600 {
1601 i = yyvsp[0].number;
1602 fprintf (stderr, "Line %d: item id %d already used:\n", numligne, yyvsp[0].number);
1603 exit (1);
1604 }
1605 TabIdObj[yyvsp[0].number] = nbobj;
1606 (*tabobj)[nbobj].id = yyvsp[0].number;
1607 ;
1608 break;
1609 }
1610 case 21:
1611 #line 447 "Compiler/bisonin"
1612 {
1613 (*tabobj)[nbobj].type = yyvsp[-1].str;
1614 HasType = 1;
1615 ;
1616 break;
1617 }
1618 case 22:
1619 #line 451 "Compiler/bisonin"
1620 {
1621 (*tabobj)[nbobj].width = yyvsp[-2].number;
1622 (*tabobj)[nbobj].height = yyvsp[-1].number;
1623 ;
1624 break;
1625 }
1626 case 23:
1627 #line 455 "Compiler/bisonin"
1628 {
1629 (*tabobj)[nbobj].x = yyvsp[-2].number;
1630 (*tabobj)[nbobj].y = yyvsp[-1].number;
1631 HasPosition = 1;
1632 ;
1633 break;
1634 }
1635 case 24:
1636 #line 460 "Compiler/bisonin"
1637 {
1638 (*tabobj)[nbobj].value = yyvsp[-1].number;
1639 ;
1640 break;
1641 }
1642 case 25:
1643 #line 463 "Compiler/bisonin"
1644 {
1645 (*tabobj)[nbobj].value2 = yyvsp[-1].number;
1646 ;
1647 break;
1648 }
1649 case 26:
1650 #line 466 "Compiler/bisonin"
1651 {
1652 (*tabobj)[nbobj].value3 = yyvsp[-1].number;
1653 ;
1654 break;
1655 }
1656 case 27:
1657 #line 469 "Compiler/bisonin"
1658 {
1659 (*tabobj)[nbobj].title = yyvsp[-1].str;
1660 ;
1661 break;
1662 }
1663 case 28:
1664 #line 472 "Compiler/bisonin"
1665 {
1666 (*tabobj)[nbobj].swallow = yyvsp[-1].str;
1667 ;
1668 break;
1669 }
1670 case 29:
1671 #line 475 "Compiler/bisonin"
1672 {
1673 (*tabobj)[nbobj].icon = yyvsp[-1].str;
1674 ;
1675 break;
1676 }
1677 case 30:
1678 #line 478 "Compiler/bisonin"
1679 {
1680 (*tabobj)[nbobj].backcolor = yyvsp[-1].str;
1681 ;
1682 break;
1683 }
1684 case 31:
1685 #line 481 "Compiler/bisonin"
1686 {
1687 (*tabobj)[nbobj].forecolor = yyvsp[-1].str;
1688 ;
1689 break;
1690 }
1691 case 32:
1692 #line 484 "Compiler/bisonin"
1693 {
1694 (*tabobj)[nbobj].shadcolor = yyvsp[-1].str;
1695 ;
1696 break;
1697 }
1698 case 33:
1699 #line 487 "Compiler/bisonin"
1700 {
1701 (*tabobj)[nbobj].licolor = yyvsp[-1].str;
1702 ;
1703 break;
1704 }
1705 case 34:
1706 #line 490 "Compiler/bisonin"
1707 {
1708 (*tabobj)[nbobj].font = yyvsp[-1].str;
1709 ;
1710 break;
1711 }
1712 case 37:
1713 #line 496 "Compiler/bisonin"
1714 {
1715 (*tabobj)[nbobj].flags[0] = True;
1716 ;
1717 break;
1718 }
1719 case 38:
1720 #line 499 "Compiler/bisonin"
1721 {
1722 (*tabobj)[nbobj].flags[1] = True;
1723 ;
1724 break;
1725 }
1726 case 39:
1727 #line 502 "Compiler/bisonin"
1728 {
1729 (*tabobj)[nbobj].flags[2] = True;
1730 ;
1731 break;
1732 }
1733 case 40:
1734 #line 508 "Compiler/bisonin"
1735 {
1736 if (!HasPosition)
1737 {
1738 yyerror ("No position for object");
1739 exit (1);
1740 }
1741 if (!HasType)
1742 {
1743 yyerror ("No type for object");
1744 exit (1);
1745 }
1746 HasPosition = 0;
1747 HasType = 0;
1748 ;
1749 break;
1750 }
1751 case 41:
1752 #line 519 "Compiler/bisonin"
1753 {
1754 InitObjTabCase (0);;
1755 break;
1756 }
1757 case 43:
1758 #line 523 "Compiler/bisonin"
1759 {
1760 InitObjTabCase (1);;
1761 break;
1762 }
1763 case 47:
1764 #line 530 "Compiler/bisonin"
1765 {
1766 InitCase (-1);;
1767 break;
1768 }
1769 case 48:
1770 #line 531 "Compiler/bisonin"
1771 {
1772 InitCase (-2);;
1773 break;
1774 }
1775 case 49:
1776 #line 534 "Compiler/bisonin"
1777 {
1778 InitCase (yyvsp[0].number);;
1779 break;
1780 }
1781 case 95:
1782 #line 591 "Compiler/bisonin"
1783 {
1784 AddCom (1, 1);;
1785 break;
1786 }
1787 case 96:
1788 #line 593 "Compiler/bisonin"
1789 {
1790 AddCom (2, 1);;
1791 break;
1792 }
1793 case 97:
1794 #line 595 "Compiler/bisonin"
1795 {
1796 AddCom (3, 1);;
1797 break;
1798 }
1799 case 98:
1800 #line 597 "Compiler/bisonin"
1801 {
1802 AddCom (4, 2);;
1803 break;
1804 }
1805 case 99:
1806 #line 599 "Compiler/bisonin"
1807 {
1808 AddCom (21, 2);;
1809 break;
1810 }
1811 case 100:
1812 #line 601 "Compiler/bisonin"
1813 {
1814 AddCom (22, 2);;
1815 break;
1816 }
1817 case 101:
1818 #line 603 "Compiler/bisonin"
1819 {
1820 AddCom (5, 3);;
1821 break;
1822 }
1823 case 102:
1824 #line 605 "Compiler/bisonin"
1825 {
1826 AddCom (6, 3);;
1827 break;
1828 }
1829 case 103:
1830 #line 607 "Compiler/bisonin"
1831 {
1832 AddCom (7, 2);;
1833 break;
1834 }
1835 case 104:
1836 #line 609 "Compiler/bisonin"
1837 {
1838 AddCom (8, 2);;
1839 break;
1840 }
1841 case 105:
1842 #line 611 "Compiler/bisonin"
1843 {
1844 AddCom (9, 2);;
1845 break;
1846 }
1847 case 106:
1848 #line 613 "Compiler/bisonin"
1849 {
1850 AddCom (10, 2);;
1851 break;
1852 }
1853 case 107:
1854 #line 615 "Compiler/bisonin"
1855 {
1856 AddCom (19, 2);;
1857 break;
1858 }
1859 case 108:
1860 #line 617 "Compiler/bisonin"
1861 {
1862 AddCom (11, 2);;
1863 break;
1864 }
1865 case 109:
1866 #line 619 "Compiler/bisonin"
1867 {
1868 AddCom (12, 2);;
1869 break;
1870 }
1871 case 110:
1872 #line 621 "Compiler/bisonin"
1873 {
1874 AddCom (13, 0);;
1875 break;
1876 }
1877 case 111:
1878 #line 623 "Compiler/bisonin"
1879 {
1880 AddCom (17, 1);;
1881 break;
1882 }
1883 case 112:
1884 #line 625 "Compiler/bisonin"
1885 {
1886 AddCom (23, 2);;
1887 break;
1888 }
1889 case 113:
1890 #line 627 "Compiler/bisonin"
1891 {
1892 AddCom (18, 2);;
1893 break;
1894 }
1895 case 117:
1896 #line 637 "Compiler/bisonin"
1897 {
1898 AddComBloc (14, 3, 2);;
1899 break;
1900 }
1901 case 120:
1902 #line 642 "Compiler/bisonin"
1903 {
1904 EmpilerBloc ();;
1905 break;
1906 }
1907 case 121:
1908 #line 644 "Compiler/bisonin"
1909 {
1910 DepilerBloc (2);;
1911 break;
1912 }
1913 case 122:
1914 #line 645 "Compiler/bisonin"
1915 {
1916 DepilerBloc (2);;
1917 break;
1918 }
1919 case 123:
1920 #line 648 "Compiler/bisonin"
1921 {
1922 DepilerBloc (1);;
1923 break;
1924 }
1925 case 124:
1926 #line 649 "Compiler/bisonin"
1927 {
1928 DepilerBloc (1);;
1929 break;
1930 }
1931 case 125:
1932 #line 653 "Compiler/bisonin"
1933 {
1934 AddComBloc (15, 3, 1);;
1935 break;
1936 }
1937 case 126:
1938 #line 657 "Compiler/bisonin"
1939 {
1940 AddComBloc (16, 3, 1);;
1941 break;
1942 }
1943 case 127:
1944 #line 662 "Compiler/bisonin"
1945 {
1946 AddVar (yyvsp[0].str);;
1947 break;
1948 }
1949 case 128:
1950 #line 664 "Compiler/bisonin"
1951 {
1952 AddConstStr (yyvsp[0].str);;
1953 break;
1954 }
1955 case 129:
1956 #line 666 "Compiler/bisonin"
1957 {
1958 AddConstStr (yyvsp[0].str);;
1959 break;
1960 }
1961 case 130:
1962 #line 668 "Compiler/bisonin"
1963 {
1964 AddConstNum (yyvsp[0].number);;
1965 break;
1966 }
1967 case 131:
1968 #line 670 "Compiler/bisonin"
1969 {
1970 AddConstNum (-1);;
1971 break;
1972 }
1973 case 132:
1974 #line 672 "Compiler/bisonin"
1975 {
1976 AddConstNum (-2);;
1977 break;
1978 }
1979 case 133:
1980 #line 674 "Compiler/bisonin"
1981 {
1982 AddLevelBufArg ();;
1983 break;
1984 }
1985 case 134:
1986 #line 676 "Compiler/bisonin"
1987 {
1988 AddFunct (1, 1);;
1989 break;
1990 }
1991 case 135:
1992 #line 677 "Compiler/bisonin"
1993 {
1994 AddFunct (2, 1);;
1995 break;
1996 }
1997 case 136:
1998 #line 678 "Compiler/bisonin"
1999 {
2000 AddFunct (3, 1);;
2001 break;
2002 }
2003 case 137:
2004 #line 679 "Compiler/bisonin"
2005 {
2006 AddFunct (4, 1);;
2007 break;
2008 }
2009 case 138:
2010 #line 680 "Compiler/bisonin"
2011 {
2012 AddFunct (5, 1);;
2013 break;
2014 }
2015 case 139:
2016 #line 681 "Compiler/bisonin"
2017 {
2018 AddFunct (6, 1);;
2019 break;
2020 }
2021 case 140:
2022 #line 682 "Compiler/bisonin"
2023 {
2024 AddFunct (7, 1);;
2025 break;
2026 }
2027 case 141:
2028 #line 683 "Compiler/bisonin"
2029 {
2030 AddFunct (8, 1);;
2031 break;
2032 }
2033 case 142:
2034 #line 684 "Compiler/bisonin"
2035 {
2036 AddFunct (9, 1);;
2037 break;
2038 }
2039 case 143:
2040 #line 685 "Compiler/bisonin"
2041 {
2042 AddFunct (10, 1);;
2043 break;
2044 }
2045 case 144:
2046 #line 686 "Compiler/bisonin"
2047 {
2048 AddFunct (11, 1);;
2049 break;
2050 }
2051 case 145:
2052 #line 687 "Compiler/bisonin"
2053 {
2054 AddFunct (12, 1);;
2055 break;
2056 }
2057 case 146:
2058 #line 688 "Compiler/bisonin"
2059 {
2060 AddFunct (13, 1);;
2061 break;
2062 }
2063 case 147:
2064 #line 689 "Compiler/bisonin"
2065 {
2066 AddFunct (14, 1);;
2067 break;
2068 }
2069 case 148:
2070 #line 690 "Compiler/bisonin"
2071 {
2072 AddFunct (15, 1);;
2073 break;
2074 }
2075 case 149:
2076 #line 691 "Compiler/bisonin"
2077 {
2078 AddFunct (16, 1);;
2079 break;
2080 }
2081 case 150:
2082 #line 692 "Compiler/bisonin"
2083 {
2084 AddFunct (17, 1);;
2085 break;
2086 }
2087 case 151:
2088 #line 697 "Compiler/bisonin"
2089 {;
2090 break;
2091 }
2092 case 178:
2093 #line 743 "Compiler/bisonin"
2094 {
2095 l = 1 - 250000;
2096 AddBufArg (&l, 1);;
2097 break;
2098 }
2099 case 179:
2100 #line 744 "Compiler/bisonin"
2101 {
2102 l = 2 - 250000;
2103 AddBufArg (&l, 1);;
2104 break;
2105 }
2106 case 180:
2107 #line 745 "Compiler/bisonin"
2108 {
2109 l = 3 - 250000;
2110 AddBufArg (&l, 1);;
2111 break;
2112 }
2113 case 181:
2114 #line 746 "Compiler/bisonin"
2115 {
2116 l = 4 - 250000;
2117 AddBufArg (&l, 1);;
2118 break;
2119 }
2120 case 182:
2121 #line 747 "Compiler/bisonin"
2122 {
2123 l = 5 - 250000;
2124 AddBufArg (&l, 1);;
2125 break;
2126 }
2127 case 183:
2128 #line 748 "Compiler/bisonin"
2129 {
2130 l = 6 - 250000;
2131 AddBufArg (&l, 1);;
2132 break;
2133 }
2134 }
2135 /* the action file gets copied in in place of this dollarsign */
2136 #line 498 "/usr/share/bison.simple"
2137
2138 yyvsp -= yylen;
2139 yyssp -= yylen;
2140 #ifdef YYLSP_NEEDED
2141 yylsp -= yylen;
2142 #endif
2143
2144 #if YYDEBUG != 0
2145 if (yydebug)
2146 {
2147 short *ssp1 = yyss - 1;
2148 fprintf (stderr, "state stack now");
2149 while (ssp1 != yyssp)
2150 fprintf (stderr, " %d", *++ssp1);
2151 fprintf (stderr, "\n");
2152 }
2153 #endif
2154
2155 *++yyvsp = yyval;
2156
2157 #ifdef YYLSP_NEEDED
2158 yylsp++;
2159 if (yylen == 0)
2160 {
2161 yylsp->first_line = yylloc.first_line;
2162 yylsp->first_column = yylloc.first_column;
2163 yylsp->last_line = (yylsp - 1)->last_line;
2164 yylsp->last_column = (yylsp - 1)->last_column;
2165 yylsp->text = 0;
2166 }
2167 else
2168 {
2169 yylsp->last_line = (yylsp + yylen - 1)->last_line;
2170 yylsp->last_column = (yylsp + yylen - 1)->last_column;
2171 }
2172 #endif
2173
2174 /* Now "shift" the result of the reduction.
2175 Determine what state that goes to,
2176 based on the state we popped back to
2177 and the rule number reduced by. */
2178
2179 yyn = yyr1[yyn];
2180
2181 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;
2182 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)
2183 yystate = yytable[yystate];
2184 else
2185 yystate = yydefgoto[yyn - YYNTBASE];
2186
2187 goto yynewstate;
2188
2189 yyerrlab: /* here on detecting error */
2190
2191 if (!yyerrstatus)
2192 /* If not already recovering from an error, report this error. */
2193 {
2194 ++yynerrs;
2195
2196 #ifdef YYERROR_VERBOSE
2197 yyn = yypact[yystate];
2198
2199 if (yyn > YYFLAG && yyn < YYLAST)
2200 {
2201 int size = 0;
2202 char *msg;
2203 int x, count;
2204
2205 count = 0;
2206 /* Start X at -yyn if nec to avoid negative indexes in yycheck. */
2207 for (x = (yyn < 0 ? -yyn : 0);
2208 x < (sizeof (yytname) / sizeof (char *)); x++)
2209 if (yycheck[x + yyn] == x)
2210 size += strlen (yytname[x]) + 15, count++;
2211 msg = (char *) malloc (size + 15);
2212 if (msg != 0)
2213 {
2214 strcpy (msg, "parse error");
2215
2216 if (count < 5)
2217 {
2218 count = 0;
2219 for (x = (yyn < 0 ? -yyn : 0);
2220 x < (sizeof (yytname) / sizeof (char *)); x++)
2221 if (yycheck[x + yyn] == x)
2222 {
2223 strcat (msg, count == 0 ? ", expecting `" : " or `");
2224 strcat (msg, yytname[x]);
2225 strcat (msg, "'");
2226 count++;
2227 }
2228 }
2229 yyerror (msg);
2230 free (msg);
2231 }
2232 else
2233 yyerror ("parse error; also virtual memory exceeded");
2234 }
2235 else
2236 #endif /* YYERROR_VERBOSE */
2237 yyerror ("parse error");
2238 }
2239
2240 goto yyerrlab1;
2241 yyerrlab1: /* here on error raised explicitly by an action */
2242
2243 if (yyerrstatus == 3)
2244 {
2245 /* if just tried and failed to reuse lookahead token after an error, discard it. */
2246
2247 /* return failure if at end of input */
2248 if (yychar == YYEOF)
2249 YYABORT;
2250
2251 #if YYDEBUG != 0
2252 if (yydebug)
2253 fprintf (stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);
2254 #endif
2255
2256 yychar = YYEMPTY;
2257 }
2258
2259 /* Else will try to reuse lookahead token
2260 after shifting the error token. */
2261
2262 yyerrstatus = 3; /* Each real token shifted decrements this */
2263
2264 goto yyerrhandle;
2265
2266 yyerrdefault: /* current state does not do anything special for the error token. */
2267
2268 #if 0
2269 /* This is wrong; only states that explicitly want error tokens
2270 should shift them. */
2271 yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it. */
2272 if (yyn)
2273 goto yydefault;
2274 #endif
2275
2276 yyerrpop: /* pop the current state because it cannot handle the error token */
2277
2278 if (yyssp == yyss)
2279 YYABORT;
2280 yyvsp--;
2281 yystate = *--yyssp;
2282 #ifdef YYLSP_NEEDED
2283 yylsp--;
2284 #endif
2285
2286 #if YYDEBUG != 0
2287 if (yydebug)
2288 {
2289 short *ssp1 = yyss - 1;
2290 fprintf (stderr, "Error: state stack now");
2291 while (ssp1 != yyssp)
2292 fprintf (stderr, " %d", *++ssp1);
2293 fprintf (stderr, "\n");
2294 }
2295 #endif
2296
2297 yyerrhandle:
2298
2299 yyn = yypact[yystate];
2300 if (yyn == YYFLAG)
2301 goto yyerrdefault;
2302
2303 yyn += YYTERROR;
2304 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)
2305 goto yyerrdefault;
2306
2307 yyn = yytable[yyn];
2308 if (yyn < 0)
2309 {
2310 if (yyn == YYFLAG)
2311 goto yyerrpop;
2312 yyn = -yyn;
2313 goto yyreduce;
2314 }
2315 else if (yyn == 0)
2316 goto yyerrpop;
2317
2318 if (yyn == YYFINAL)
2319 YYACCEPT;
2320
2321 #if YYDEBUG != 0
2322 if (yydebug)
2323 fprintf (stderr, "Shifting error token, ");
2324 #endif
2325
2326 *++yyvsp = yylval;
2327 #ifdef YYLSP_NEEDED
2328 *++yylsp = yylloc;
2329 #endif
2330
2331 yystate = yyn;
2332 goto yynewstate;
2333 }
2334 #line 751 "Compiler/bisonin"
2335