← Back to branch summary

~ubuntu-branches/ubuntu/saucy/cuyo/saucy

« back to all changes in this revision

Viewing changes to src/parser.cc

  • Committer: Bazaar Package Importer
  • Author(s): Angel Abad
  • Date: 2010-07-19 09:54:44 UTC
  • mfrom: (4.1.3 sid)
  • Revision ID: james.westby@ubuntu.com-20100719095444-ecoegzo1vvvdwra9
Tags: 2.~-1.1.brl3-1ubuntu1
https://launchpad.net/bugs/607106
* Merge from debian unstable (LP: #607106). Remaining changes:
  - Don't register MimeType=application/x-executable in
    the .desktop file.
  - Remove UTF-8 in the .desktop file
  - 

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/parser.cc
1
 
/* A Bison parser, made by GNU Bison 2.3.  */
 
1
 
 
2
/* A Bison parser, made by GNU Bison 2.4.1.  */
2
3
 
3
4
/* Skeleton implementation for Bison's Yacc-like parsers in C
4
 
 
5
 
   Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
 
5
   
 
6
      Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003, 2004, 2005, 2006
6
7
   Free Software Foundation, Inc.
7
 
 
8
 
   This program is free software; you can redistribute it and/or modify
 
8
   
 
9
   This program is free software: you can redistribute it and/or modify
9
10
   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
 
 
 
11
   the Free Software Foundation, either version 3 of the License, or
 
12
   (at your option) any later version.
 
13
   
13
14
   This program is distributed in the hope that it will be useful,
14
15
   but WITHOUT ANY WARRANTY; without even the implied warranty of
15
16
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16
17
   GNU General Public License for more details.
17
 
 
 
18
   
18
19
   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.  */
 
20
   along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
22
21
 
23
22
/* As a special exception, you may create a larger work that contains
24
23
   part or all of the Bison parser skeleton and distribute that work
29
28
   special exception, which will cause the skeleton and the resulting
30
29
   Bison output files to be licensed under the GNU General Public
31
30
   License without this special exception.
32
 
 
 
31
   
33
32
   This special exception was added by the Free Software Foundation in
34
33
   version 2.2 of Bison.  */
35
34
 
47
46
#define YYBISON 1
48
47
 
49
48
/* Bison version.  */
50
 
#define YYBISON_VERSION "2.3"
 
49
#define YYBISON_VERSION "2.4.1"
51
50
 
52
51
/* Skeleton name.  */
53
52
#define YYSKELETON_NAME "yacc.c"
55
54
/* Pure parsers.  */
56
55
#define YYPURE 1
57
56
 
 
57
/* Push parsers.  */
 
58
#define YYPUSH 0
 
59
 
 
60
/* Pull parsers.  */
 
61
#define YYPULL 1
 
62
 
58
63
/* Using locations.  */
59
64
#define YYLSP_NEEDED 0
60
65
 
61
66
 
62
67
 
 
68
/* Copy the first part of user declarations.  */
 
69
 
 
70
/* Line 189 of yacc.c  */
 
71
#line 2 "parser.yy"
 
72
 
 
73
 
 
74
/***************************************************************************
 
75
                          parser.yy  -  description
 
76
                             -------------------
 
77
    begin                : Mit Jul 12 22:54:51 MEST 2000
 
78
    copyright            : (C) 2000 by Immi
 
79
    email                : cuyo@pcpool.mathematik.uni-freiburg.de
 
80
 ***************************************************************************/
 
81
 
 
82
/***************************************************************************
 
83
 *                                                                         *
 
84
 *   This program is free software; you can redistribute it and/or modify  *
 
85
 *   it under the terms of the GNU General Public License as published by  *
 
86
 *   the Free Software Foundation; either version 2 of the License, or     *
 
87
 *   (at your option) any later version.                                   *
 
88
 *                                                                         *
 
89
 ***************************************************************************/
 
90
 
 
91
#include <cstdlib>
 
92
 
 
93
#include "cuyointl.h"
 
94
#include "code.h"
 
95
#include "fehler.h"
 
96
#include "knoten.h"
 
97
#include "variable.h"
 
98
#include "ort.h"
 
99
#include "version.h"
 
100
#include "global.h"
 
101
#include "leveldaten.h"
 
102
#include "sound.h"
 
103
 
 
104
#define YYMALLOC malloc
 
105
#define YYFREE free
 
106
 
 
107
 
 
108
/***********************************************************************/
 
109
/* Globale Parse-Variablen */
 
110
 
 
111
/** F�r Fehlerausgabe: Aktueller Dateiname */
 
112
Str gDateiName;
 
113
/** F�r Fehlerausgabe: Aktuelle Zeilen-Nummer */
 
114
int gZeilenNr;
 
115
 
 
116
/** True, wenn es w�hrend des Parsens (mindestens) einen Fehler gab. */
 
117
bool gGabFehler;
 
118
 
 
119
 
 
120
/** Wenn der Parser aufgerufen wird, muss in DefKnoten schon ein DefKnoten
 
121
    stehen, an den alles geparste angef�gt wird. Normalerweise erzeugt man
 
122
    einen neuen Defknoten. Beim Includen will man da aber schon was drin
 
123
    haben.
 
124
    Siehe auch %type <defknoten> alles */
 
125
static DefKnoten * gAktDefKnoten;
 
126
 
 
127
//#define MAX_INCLUDE_TIEFE 16
 
128
/** YY_BUFFER_STATE ist ein flex-Datentyp f�r eine Datei, an der grade
 
129
    geparst wird. */
 
130
//static YY_BUFFER_STATE gIncludeStack[MAX_INCLUDE_TIEFE];
 
131
/** Aktuelle Include-Tiefe. (0 bei Hauptdatei) */
 
132
//static int gIncludeTiefe;
 
133
 
 
134
//static DefKnoten * gIncludeMerk;
 
135
 
 
136
 
 
137
/* Beim Erzeugen eines Codes m�ssen einige Variablen jedes Mal �bergeben
 
138
   werden:
 
139
   - der zugeh�rige DefKnoten, damit ggf. noch Variablen reserviert werden
 
140
     k�nnen (genauer: die Busy-Variable).
 
141
   - Dateiname und Zeilennummer, damit der Code sch�nere Fehlermeldungen
 
142
     ausgeben kann.
 
143
   Damit ich das aber nicht jedes Mal eintippen muss, hier ein paar Macros:
 
144
 */
 
145
#define newCode0(ART) new Code(\
 
146
  gAktDefKnoten, gDateiName, gZeilenNr, ART)
 
147
#define newCode1(ART, X1) new Code(\
 
148
  gAktDefKnoten, gDateiName, gZeilenNr, ART, X1)
 
149
#define newCode2(ART, X1, X2) new Code(\
 
150
  gAktDefKnoten, gDateiName, gZeilenNr, ART, X1, X2)
 
151
#define newCode3(ART, X1, X2, X3) new Code(\
 
152
  gAktDefKnoten, gDateiName, gZeilenNr, ART, X1, X2, X3)
 
153
#define newCode4(ART, X1, X2, X3, X4) new Code(\
 
154
  gAktDefKnoten, gDateiName, gZeilenNr, ART, X1, X2, X3, X4)
 
155
 
 
156
 
 
157
 
 
158
/***********************************************************************/
 
159
 
 
160
 
 
161
#define VIEL 32767
 
162
 
 
163
 
 
164
/* PBEGIN_TRY und PEND_TRY() fangen Fehler ab und geben sie aus, damit
 
165
   weitergeparst werden kann und mehrere Fehler gleichzeitig ausgegeben
 
166
   werden k�nnen. Sie werden in fehler.h definiert. */
 
167
 
 
168
 
 
169
#define YYDEBUG 1
 
170
 
 
171
 
 
172
/* Bug in Bison? Er scheint den Stack nicht automatisch vergr��ern zu wollen,
 
173
   wenn er voll ist. Es sieht so aus, als h�tte er angst, dass da c++-Variablen
 
174
   vorkommen, wo er (wegen constructor und so) nicht einfach so rumalloziieren
 
175
   kann. (Ich wei� nicht, was der LTYPE ist, von dem er nicht festgestellt hat,
 
176
   das er trivial ist.) */
 
177
#define YYLTYPE_IS_TRIVIAL 1
 
178
 
 
179
 
 
180
 
 
181
/* Line 189 of yacc.c  */
 
182
#line 183 "parser.cc"
 
183
 
 
184
/* Enabling traces.  */
 
185
#ifndef YYDEBUG
 
186
# define YYDEBUG 0
 
187
#endif
 
188
 
 
189
/* Enabling verbose error messages.  */
 
190
#ifdef YYERROR_VERBOSE
 
191
# undef YYERROR_VERBOSE
 
192
# define YYERROR_VERBOSE 1
 
193
#else
 
194
# define YYERROR_VERBOSE 0
 
195
#endif
 
196
 
 
197
/* Enabling the token table.  */
 
198
#ifndef YYTOKEN_TABLE
 
199
# define YYTOKEN_TABLE 0
 
200
#endif
 
201
 
 
202
 
63
203
/* Tokens.  */
64
204
#ifndef YYTOKENTYPE
65
205
# define YYTOKENTYPE
161
301
 
162
302
 
163
303
 
164
 
/* Copy the first part of user declarations.  */
165
 
#line 2 "parser.yy"
166
 
 
167
 
 
168
 
/***************************************************************************
169
 
                          parser.yy  -  description
170
 
                             -------------------
171
 
    begin                : Mit Jul 12 22:54:51 MEST 2000
172
 
    copyright            : (C) 2000 by Immi
173
 
    email                : cuyo@pcpool.mathematik.uni-freiburg.de
174
 
 ***************************************************************************/
175
 
 
176
 
/***************************************************************************
177
 
 *                                                                         *
178
 
 *   This program is free software; you can redistribute it and/or modify  *
179
 
 *   it under the terms of the GNU General Public License as published by  *
180
 
 *   the Free Software Foundation; either version 2 of the License, or     *
181
 
 *   (at your option) any later version.                                   *
182
 
 *                                                                         *
183
 
 ***************************************************************************/
184
 
 
185
 
#include <cstdlib>
186
 
 
187
 
#include "cuyointl.h"
188
 
#include "code.h"
189
 
#include "fehler.h"
190
 
#include "knoten.h"
191
 
#include "variable.h"
192
 
#include "ort.h"
193
 
#include "version.h"
194
 
#include "global.h"
195
 
#include "leveldaten.h"
196
 
#include "sound.h"
197
 
 
198
 
#define YYMALLOC malloc
199
 
#define YYFREE free
200
 
 
201
 
 
202
 
/***********************************************************************/
203
 
/* Globale Parse-Variablen */
204
 
 
205
 
/** F�r Fehlerausgabe: Aktueller Dateiname */
206
 
Str gDateiName;
207
 
/** F�r Fehlerausgabe: Aktuelle Zeilen-Nummer */
208
 
int gZeilenNr;
209
 
 
210
 
/** True, wenn es w�hrend des Parsens (mindestens) einen Fehler gab. */
211
 
bool gGabFehler;
212
 
 
213
 
 
214
 
/** Wenn der Parser aufgerufen wird, muss in DefKnoten schon ein DefKnoten
215
 
    stehen, an den alles geparste angef�gt wird. Normalerweise erzeugt man
216
 
    einen neuen Defknoten. Beim Includen will man da aber schon was drin
217
 
    haben.
218
 
    Siehe auch %type <defknoten> alles */
219
 
static DefKnoten * gAktDefKnoten;
220
 
 
221
 
//#define MAX_INCLUDE_TIEFE 16
222
 
/** YY_BUFFER_STATE ist ein flex-Datentyp f�r eine Datei, an der grade
223
 
    geparst wird. */
224
 
//static YY_BUFFER_STATE gIncludeStack[MAX_INCLUDE_TIEFE];
225
 
/** Aktuelle Include-Tiefe. (0 bei Hauptdatei) */
226
 
//static int gIncludeTiefe;
227
 
 
228
 
//static DefKnoten * gIncludeMerk;
229
 
 
230
 
 
231
 
/* Beim Erzeugen eines Codes m�ssen einige Variablen jedes Mal �bergeben
232
 
   werden:
233
 
   - der zugeh�rige DefKnoten, damit ggf. noch Variablen reserviert werden
234
 
     k�nnen (genauer: die Busy-Variable).
235
 
   - Dateiname und Zeilennummer, damit der Code sch�nere Fehlermeldungen
236
 
     ausgeben kann.
237
 
   Damit ich das aber nicht jedes Mal eintippen muss, hier ein paar Macros:
238
 
 */
239
 
#define newCode0(ART) new Code(\
240
 
  gAktDefKnoten, gDateiName, gZeilenNr, ART)
241
 
#define newCode1(ART, X1) new Code(\
242
 
  gAktDefKnoten, gDateiName, gZeilenNr, ART, X1)
243
 
#define newCode2(ART, X1, X2) new Code(\
244
 
  gAktDefKnoten, gDateiName, gZeilenNr, ART, X1, X2)
245
 
#define newCode3(ART, X1, X2, X3) new Code(\
246
 
  gAktDefKnoten, gDateiName, gZeilenNr, ART, X1, X2, X3)
247
 
#define newCode4(ART, X1, X2, X3, X4) new Code(\
248
 
  gAktDefKnoten, gDateiName, gZeilenNr, ART, X1, X2, X3, X4)
249
 
 
250
 
 
251
 
 
252
 
/***********************************************************************/
253
 
 
254
 
 
255
 
#define VIEL 32767
256
 
 
257
 
 
258
 
/* PBEGIN_TRY und PEND_TRY() fangen Fehler ab und geben sie aus, damit
259
 
   weitergeparst werden kann und mehrere Fehler gleichzeitig ausgegeben
260
 
   werden k�nnen. Sie werden in fehler.h definiert. */
261
 
 
262
 
 
263
 
#define YYDEBUG 1
264
 
 
265
 
 
266
 
/* Bug in Bison? Er scheint den Stack nicht automatisch vergr��ern zu wollen,
267
 
   wenn er voll ist. Es sieht so aus, als h�tte er angst, dass da c++-Variablen
268
 
   vorkommen, wo er (wegen constructor und so) nicht einfach so rumalloziieren
269
 
   kann. (Ich wei� nicht, was der LTYPE ist, von dem er nicht festgestellt hat,
270
 
   das er trivial ist.) */
271
 
#define YYLTYPE_IS_TRIVIAL 1
272
 
 
273
 
 
274
 
 
275
 
/* Enabling traces.  */
276
 
#ifndef YYDEBUG
277
 
# define YYDEBUG 0
278
 
#endif
279
 
 
280
 
/* Enabling verbose error messages.  */
281
 
#ifdef YYERROR_VERBOSE
282
 
# undef YYERROR_VERBOSE
283
 
# define YYERROR_VERBOSE 1
284
 
#else
285
 
# define YYERROR_VERBOSE 0
286
 
#endif
287
 
 
288
 
/* Enabling the token table.  */
289
 
#ifndef YYTOKEN_TABLE
290
 
# define YYTOKEN_TABLE 0
291
 
#endif
292
 
 
293
304
#if ! defined YYSTYPE && ! defined YYSTYPE_IS_DECLARED
294
305
typedef union YYSTYPE
 
306
{
 
307
 
 
308
/* Line 214 of yacc.c  */
295
309
#line 113 "parser.yy"
296
 
{
 
310
 
297
311
  Code * code;
298
312
  Code * codepaar[2];
299
313
  Str * str;
308
322
  Version * version;
309
323
  CodeArt codeart;
310
324
  OrtHaelfte haelfte;
311
 
}
312
 
/* Line 187 of yacc.c.  */
313
 
#line 314 "parser.cc"
314
 
        YYSTYPE;
 
325
 
 
326
 
 
327
 
 
328
/* Line 214 of yacc.c  */
 
329
#line 330 "parser.cc"
 
330
} YYSTYPE;
 
331
# define YYSTYPE_IS_TRIVIAL 1
315
332
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
316
333
# define YYSTYPE_IS_DECLARED 1
317
 
# define YYSTYPE_IS_TRIVIAL 1
318
334
#endif
319
335
 
320
336
 
321
 
 
322
337
/* Copy the second part of user declarations.  */
 
338
 
 
339
/* Line 264 of yacc.c  */
323
340
#line 208 "parser.yy"
324
341
 
325
342
int yyerror(const char * s);
333
350
void popLex(void * merkBuf);
334
351
 
335
352
 
336
 
/* Line 216 of yacc.c.  */
337
 
#line 338 "parser.cc"
 
353
/* Line 264 of yacc.c  */
 
354
#line 355 "parser.cc"
338
355
 
339
356
#ifdef short
340
357
# undef short
409
426
#if (defined __STDC__ || defined __C99__FUNC__ \
410
427
     || defined __cplusplus || defined _MSC_VER)
411
428
static int
412
 
YYID (int i)
 
429
YYID (int yyi)
413
430
#else
414
431
static int
415
 
YYID (i)
416
 
    int i;
 
432
YYID (yyi)
 
433
    int yyi;
417
434
#endif
418
435
{
419
 
  return i;
 
436
  return yyi;
420
437
}
421
438
#endif
422
439
 
497
514
/* A type that is properly aligned for any stack member.  */
498
515
union yyalloc
499
516
{
500
 
  yytype_int16 yyss;
501
 
  YYSTYPE yyvs;
502
 
  };
 
517
  yytype_int16 yyss_alloc;
 
518
  YYSTYPE yyvs_alloc;
 
519
};
503
520
 
504
521
/* The size of the maximum gap between one aligned stack and the next.  */
505
522
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
533
550
   elements in the stack, and YYPTR gives the new location of the
534
551
   stack.  Advance YYPTR to a properly aligned location for the next
535
552
   stack.  */
536
 
# define YYSTACK_RELOCATE(Stack)                                        \
 
553
# define YYSTACK_RELOCATE(Stack_alloc, Stack)                           \
537
554
    do                                                                  \
538
555
      {                                                                 \
539
556
        YYSIZE_T yynewbytes;                                            \
540
 
        YYCOPY (&yyptr->Stack, Stack, yysize);                          \
541
 
        Stack = &yyptr->Stack;                                          \
 
557
        YYCOPY (&yyptr->Stack_alloc, Stack, yysize);                    \
 
558
        Stack = &yyptr->Stack_alloc;                                    \
542
559
        yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
543
560
        yyptr += yynewbytes / sizeof (*yyptr);                          \
544
561
      }                                                                 \
1275
1292
#if (defined __STDC__ || defined __C99__FUNC__ \
1276
1293
     || defined __cplusplus || defined _MSC_VER)
1277
1294
static void
1278
 
yy_stack_print (yytype_int16 *bottom, yytype_int16 *top)
 
1295
yy_stack_print (yytype_int16 *yybottom, yytype_int16 *yytop)
1279
1296
#else
1280
1297
static void
1281
 
yy_stack_print (bottom, top)
1282
 
    yytype_int16 *bottom;
1283
 
    yytype_int16 *top;
 
1298
yy_stack_print (yybottom, yytop)
 
1299
    yytype_int16 *yybottom;
 
1300
    yytype_int16 *yytop;
1284
1301
#endif
1285
1302
{
1286
1303
  YYFPRINTF (stderr, "Stack now");
1287
 
  for (; bottom <= top; ++bottom)
1288
 
    YYFPRINTF (stderr, " %d", *bottom);
 
1304
  for (; yybottom <= yytop; yybottom++)
 
1305
    {
 
1306
      int yybot = *yybottom;
 
1307
      YYFPRINTF (stderr, " %d", yybot);
 
1308
    }
1289
1309
  YYFPRINTF (stderr, "\n");
1290
1310
}
1291
1311
 
1319
1339
  /* The symbols being reduced.  */
1320
1340
  for (yyi = 0; yyi < yynrhs; yyi++)
1321
1341
    {
1322
 
      fprintf (stderr, "   $%d = ", yyi + 1);
 
1342
      YYFPRINTF (stderr, "   $%d = ", yyi + 1);
1323
1343
      yy_symbol_print (stderr, yyrhs[yyprhs[yyrule] + yyi],
1324
1344
                       &(yyvsp[(yyi + 1) - (yynrhs)])
1325
1345
                                       );
1326
 
      fprintf (stderr, "\n");
 
1346
      YYFPRINTF (stderr, "\n");
1327
1347
    }
1328
1348
}
1329
1349
 
1603
1623
        break;
1604
1624
    }
1605
1625
}
1606
 
 
1607
1626
 
1608
1627
/* Prevent warnings from -Wmissing-prototypes.  */
1609
 
 
1610
1628
#ifdef YYPARSE_PARAM
1611
1629
#if defined __STDC__ || defined __cplusplus
1612
1630
int yyparse (void *YYPARSE_PARAM);
1625
1643
 
1626
1644
 
1627
1645
 
1628
 
 
1629
 
/*----------.
1630
 
| yyparse.  |
1631
 
`----------*/
 
1646
/*-------------------------.
 
1647
| yyparse or yypush_parse.  |
 
1648
`-------------------------*/
1632
1649
 
1633
1650
#ifdef YYPARSE_PARAM
1634
1651
#if (defined __STDC__ || defined __C99__FUNC__ \
1652
1669
#endif
1653
1670
#endif
1654
1671
{
1655
 
  /* The look-ahead symbol.  */
 
1672
/* The lookahead symbol.  */
1656
1673
int yychar;
1657
1674
 
1658
 
/* The semantic value of the look-ahead symbol.  */
 
1675
/* The semantic value of the lookahead symbol.  */
1659
1676
YYSTYPE yylval;
1660
1677
 
1661
 
/* Number of syntax errors so far.  */
1662
 
int yynerrs;
1663
 
 
1664
 
  int yystate;
 
1678
    /* Number of syntax errors so far.  */
 
1679
    int yynerrs;
 
1680
 
 
1681
    int yystate;
 
1682
    /* Number of tokens to shift before error messages enabled.  */
 
1683
    int yyerrstatus;
 
1684
 
 
1685
    /* The stacks and their tools:
 
1686
       `yyss': related to states.
 
1687
       `yyvs': related to semantic values.
 
1688
 
 
1689
       Refer to the stacks thru separate pointers, to allow yyoverflow
 
1690
       to reallocate them elsewhere.  */
 
1691
 
 
1692
    /* The state stack.  */
 
1693
    yytype_int16 yyssa[YYINITDEPTH];
 
1694
    yytype_int16 *yyss;
 
1695
    yytype_int16 *yyssp;
 
1696
 
 
1697
    /* The semantic value stack.  */
 
1698
    YYSTYPE yyvsa[YYINITDEPTH];
 
1699
    YYSTYPE *yyvs;
 
1700
    YYSTYPE *yyvsp;
 
1701
 
 
1702
    YYSIZE_T yystacksize;
 
1703
 
1665
1704
  int yyn;
1666
1705
  int yyresult;
1667
 
  /* Number of tokens to shift before error messages enabled.  */
1668
 
  int yyerrstatus;
1669
 
  /* Look-ahead token as an internal (translated) token number.  */
1670
 
  int yytoken = 0;
 
1706
  /* Lookahead token as an internal (translated) token number.  */
 
1707
  int yytoken;
 
1708
  /* The variables used to return semantic value and location from the
 
1709
     action routines.  */
 
1710
  YYSTYPE yyval;
 
1711
 
1671
1712
#if YYERROR_VERBOSE
1672
1713
  /* Buffer for error messages, and its allocated size.  */
1673
1714
  char yymsgbuf[128];
1675
1716
  YYSIZE_T yymsg_alloc = sizeof yymsgbuf;
1676
1717
#endif
1677
1718
 
1678
 
  /* Three stacks and their tools:
1679
 
     `yyss': related to states,
1680
 
     `yyvs': related to semantic values,
1681
 
     `yyls': related to locations.
1682
 
 
1683
 
     Refer to the stacks thru separate pointers, to allow yyoverflow
1684
 
     to reallocate them elsewhere.  */
1685
 
 
1686
 
  /* The state stack.  */
1687
 
  yytype_int16 yyssa[YYINITDEPTH];
1688
 
  yytype_int16 *yyss = yyssa;
1689
 
  yytype_int16 *yyssp;
1690
 
 
1691
 
  /* The semantic value stack.  */
1692
 
  YYSTYPE yyvsa[YYINITDEPTH];
1693
 
  YYSTYPE *yyvs = yyvsa;
1694
 
  YYSTYPE *yyvsp;
1695
 
 
1696
 
 
1697
 
 
1698
1719
#define YYPOPSTACK(N)   (yyvsp -= (N), yyssp -= (N))
1699
1720
 
1700
 
  YYSIZE_T yystacksize = YYINITDEPTH;
1701
 
 
1702
 
  /* The variables used to return semantic value and location from the
1703
 
     action routines.  */
1704
 
  YYSTYPE yyval;
1705
 
 
1706
 
 
1707
1721
  /* The number of symbols on the RHS of the reduced rule.
1708
1722
     Keep to zero when no symbol should be popped.  */
1709
1723
  int yylen = 0;
1710
1724
 
 
1725
  yytoken = 0;
 
1726
  yyss = yyssa;
 
1727
  yyvs = yyvsa;
 
1728
  yystacksize = YYINITDEPTH;
 
1729
 
1711
1730
  YYDPRINTF ((stderr, "Starting parse\n"));
1712
1731
 
1713
1732
  yystate = 0;
1714
1733
  yyerrstatus = 0;
1715
1734
  yynerrs = 0;
1716
 
  yychar = YYEMPTY;             /* Cause a token to be read.  */
 
1735
  yychar = YYEMPTY; /* Cause a token to be read.  */
1717
1736
 
1718
1737
  /* Initialize stack pointers.
1719
1738
     Waste one element of value and location stack
1720
1739
     so that they stay on the same level as the state stack.
1721
1740
     The wasted elements are never initialized.  */
1722
 
 
1723
1741
  yyssp = yyss;
1724
1742
  yyvsp = yyvs;
1725
1743
 
1749
1767
        YYSTYPE *yyvs1 = yyvs;
1750
1768
        yytype_int16 *yyss1 = yyss;
1751
1769
 
1752
 
 
1753
1770
        /* Each stack pointer address is followed by the size of the
1754
1771
           data in use in that stack, in bytes.  This used to be a
1755
1772
           conditional around just the two extra args, but that might
1757
1774
        yyoverflow (YY_("memory exhausted"),
1758
1775
                    &yyss1, yysize * sizeof (*yyssp),
1759
1776
                    &yyvs1, yysize * sizeof (*yyvsp),
1760
 
 
1761
1777
                    &yystacksize);
1762
1778
 
1763
1779
        yyss = yyss1;
1780
1796
          (union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1781
1797
        if (! yyptr)
1782
1798
          goto yyexhaustedlab;
1783
 
        YYSTACK_RELOCATE (yyss);
1784
 
        YYSTACK_RELOCATE (yyvs);
1785
 
 
 
1799
        YYSTACK_RELOCATE (yyss_alloc, yyss);
 
1800
        YYSTACK_RELOCATE (yyvs_alloc, yyvs);
1786
1801
#  undef YYSTACK_RELOCATE
1787
1802
        if (yyss1 != yyssa)
1788
1803
          YYSTACK_FREE (yyss1);
1793
1808
      yyssp = yyss + yysize - 1;
1794
1809
      yyvsp = yyvs + yysize - 1;
1795
1810
 
1796
 
 
1797
1811
      YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1798
1812
                  (unsigned long int) yystacksize));
1799
1813
 
1803
1817
 
1804
1818
  YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1805
1819
 
 
1820
  if (yystate == YYFINAL)
 
1821
    YYACCEPT;
 
1822
 
1806
1823
  goto yybackup;
1807
1824
 
1808
1825
/*-----------.
1811
1828
yybackup:
1812
1829
 
1813
1830
  /* Do appropriate processing given the current state.  Read a
1814
 
     look-ahead token if we need one and don't already have one.  */
 
1831
     lookahead token if we need one and don't already have one.  */
1815
1832
 
1816
 
  /* First try to decide what to do without reference to look-ahead token.  */
 
1833
  /* First try to decide what to do without reference to lookahead token.  */
1817
1834
  yyn = yypact[yystate];
1818
1835
  if (yyn == YYPACT_NINF)
1819
1836
    goto yydefault;
1820
1837
 
1821
 
  /* Not known => get a look-ahead token if don't already have one.  */
 
1838
  /* Not known => get a lookahead token if don't already have one.  */
1822
1839
 
1823
 
  /* YYCHAR is either YYEMPTY or YYEOF or a valid look-ahead symbol.  */
 
1840
  /* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol.  */
1824
1841
  if (yychar == YYEMPTY)
1825
1842
    {
1826
1843
      YYDPRINTF ((stderr, "Reading a token: "));
1852
1869
      goto yyreduce;
1853
1870
    }
1854
1871
 
1855
 
  if (yyn == YYFINAL)
1856
 
    YYACCEPT;
1857
 
 
1858
1872
  /* Count tokens shifted since error; after three, turn off error
1859
1873
     status.  */
1860
1874
  if (yyerrstatus)
1861
1875
    yyerrstatus--;
1862
1876
 
1863
 
  /* Shift the look-ahead token.  */
 
1877
  /* Shift the lookahead token.  */
1864
1878
  YY_SYMBOL_PRINT ("Shifting", yytoken, &yylval, &yylloc);
1865
1879
 
1866
 
  /* Discard the shifted token unless it is eof.  */
1867
 
  if (yychar != YYEOF)
1868
 
    yychar = YYEMPTY;
 
1880
  /* Discard the shifted token.  */
 
1881
  yychar = YYEMPTY;
1869
1882
 
1870
1883
  yystate = yyn;
1871
1884
  *++yyvsp = yylval;
1905
1918
  switch (yyn)
1906
1919
    {
1907
1920
        case 2:
 
1921
 
 
1922
/* Line 1455 of yacc.c  */
1908
1923
#line 229 "parser.yy"
1909
1924
    { /* Nix zu tun. */ }
1910
1925
    break;
1911
1926
 
1912
1927
  case 3:
 
1928
 
 
1929
/* Line 1455 of yacc.c  */
1913
1930
#line 230 "parser.yy"
1914
1931
    {
1915
1932
        
1922
1939
    break;
1923
1940
 
1924
1941
  case 4:
 
1942
 
 
1943
/* Line 1455 of yacc.c  */
1925
1944
#line 238 "parser.yy"
1926
1945
    {
1927
1946
                           
1931
1950
    break;
1932
1951
 
1933
1952
  case 5:
 
1953
 
 
1954
/* Line 1455 of yacc.c  */
1934
1955
#line 249 "parser.yy"
1935
1956
    {
1936
1957
      PBEGIN_TRY
1972
1993
    break;
1973
1994
 
1974
1995
  case 6:
 
1996
 
 
1997
/* Line 1455 of yacc.c  */
1975
1998
#line 292 "parser.yy"
1976
1999
    { (yyval.str) = (yyvsp[(1) - (1)].str); }
1977
2000
    break;
1978
2001
 
1979
2002
  case 7:
 
2003
 
 
2004
/* Line 1455 of yacc.c  */
1980
2005
#line 293 "parser.yy"
1981
2006
    { (yyval.str) = new Str(_sprintf("%d",(yyvsp[(1) - (1)].zahl))); }
1982
2007
    break;
1983
2008
 
1984
2009
  case 8:
 
2010
 
 
2011
/* Line 1455 of yacc.c  */
1985
2012
#line 299 "parser.yy"
1986
2013
    {
1987
2014
      (yyval.version) = new Version();
1991
2018
    break;
1992
2019
 
1993
2020
  case 9:
 
2021
 
 
2022
/* Line 1455 of yacc.c  */
1994
2023
#line 304 "parser.yy"
1995
2024
    {
1996
2025
      (yyval.version) = (yyvsp[(3) - (3)].version);
2000
2029
    break;
2001
2030
 
2002
2031
  case 10:
 
2032
 
 
2033
/* Line 1455 of yacc.c  */
2003
2034
#line 312 "parser.yy"
2004
2035
    { (yyval.version) = new Version(); }
2005
2036
    break;
2006
2037
 
2007
2038
  case 11:
 
2039
 
 
2040
/* Line 1455 of yacc.c  */
2008
2041
#line 313 "parser.yy"
2009
2042
    { (yyval.version) = (yyvsp[(2) - (3)].version); }
2010
2043
    break;
2011
2044
 
2012
2045
  case 12:
 
2046
 
 
2047
/* Line 1455 of yacc.c  */
2013
2048
#line 317 "parser.yy"
2014
2049
    { (yyval.zahl) = (yyvsp[(1) - (1)].zahl); }
2015
2050
    break;
2016
2051
 
2017
2052
  case 13:
 
2053
 
 
2054
/* Line 1455 of yacc.c  */
2018
2055
#line 318 "parser.yy"
2019
2056
    { (yyval.zahl) = (yyvsp[(2) - (3)].zahl); }
2020
2057
    break;
2021
2058
 
2022
2059
  case 14:
 
2060
 
 
2061
/* Line 1455 of yacc.c  */
2023
2062
#line 321 "parser.yy"
2024
2063
    {
2025
2064
      /* OK, hier wird ein neuer Defknoten er�ffnet. Der alte wird
2033
2072
    break;
2034
2073
 
2035
2074
  case 15:
 
2075
 
 
2076
/* Line 1455 of yacc.c  */
2036
2077
#line 329 "parser.yy"
2037
2078
    {
2038
2079
                    
2045
2086
    break;
2046
2087
 
2047
2088
  case 16:
 
2089
 
 
2090
/* Line 1455 of yacc.c  */
2048
2091
#line 337 "parser.yy"
2049
2092
    { (yyval.knoten) = (yyvsp[(1) - (1)].listenknoten); }
2050
2093
    break;
2051
2094
 
2052
2095
  case 17:
 
2096
 
 
2097
/* Line 1455 of yacc.c  */
2053
2098
#line 340 "parser.yy"
2054
2099
    {
2055
2100
      (yyval.listenknoten) = new ListenKnoten(gDateiName, gZeilenNr);
2058
2103
    break;
2059
2104
 
2060
2105
  case 18:
 
2106
 
 
2107
/* Line 1455 of yacc.c  */
2061
2108
#line 344 "parser.yy"
2062
2109
    {
2063
2110
      (yyval.listenknoten) = (yyvsp[(1) - (3)].listenknoten);
2066
2113
    break;
2067
2114
 
2068
2115
  case 19:
 
2116
 
 
2117
/* Line 1455 of yacc.c  */
2069
2118
#line 350 "parser.yy"
2070
2119
    {
2071
2120
      (yyval.knoten) = new WortKnoten(gDateiName, gZeilenNr, *(yyvsp[(1) - (1)].str)); delete (yyvsp[(1) - (1)].str);
2073
2122
    break;
2074
2123
 
2075
2124
  case 20:
 
2125
 
 
2126
/* Line 1455 of yacc.c  */
2076
2127
#line 353 "parser.yy"
2077
2128
    {
2078
2129
      (yyval.knoten) = new ZahlKnoten(gDateiName, gZeilenNr, (yyvsp[(1) - (1)].zahl));
2080
2131
    break;
2081
2132
 
2082
2133
  case 21:
 
2134
 
 
2135
/* Line 1455 of yacc.c  */
2083
2136
#line 356 "parser.yy"
2084
2137
    {
2085
2138
      (yyval.knoten) = new VielfachheitKnoten(gDateiName, gZeilenNr, *(yyvsp[(1) - (3)].str), (yyvsp[(3) - (3)].zahl)); delete (yyvsp[(1) - (3)].str);
2087
2140
    break;
2088
2141
 
2089
2142
  case 22:
 
2143
 
 
2144
/* Line 1455 of yacc.c  */
2090
2145
#line 362 "parser.yy"
2091
2146
    { (yyval.zahl) = (yyvsp[(1) - (1)].zahl); }
2092
2147
    break;
2093
2148
 
2094
2149
  case 23:
 
2150
 
 
2151
/* Line 1455 of yacc.c  */
2095
2152
#line 363 "parser.yy"
2096
2153
    {
2097
2154
      Knoten * def = gAktDefKnoten->getVerwandten(*(yyvsp[(1) - (1)].str), ld->mVersion, false);
2111
2168
    break;
2112
2169
 
2113
2170
  case 24:
 
2171
 
 
2172
/* Line 1455 of yacc.c  */
2114
2173
#line 378 "parser.yy"
2115
2174
    { (yyval.zahl) = (yyvsp[(2) - (3)].zahl); }
2116
2175
    break;
2117
2176
 
2118
2177
  case 25:
 
2178
 
 
2179
/* Line 1455 of yacc.c  */
2119
2180
#line 379 "parser.yy"
2120
2181
    { (yyval.zahl) = -(yyvsp[(2) - (2)].zahl); }
2121
2182
    break;
2122
2183
 
2123
2184
  case 26:
 
2185
 
 
2186
/* Line 1455 of yacc.c  */
2124
2187
#line 380 "parser.yy"
2125
2188
    { (yyval.zahl) = (yyvsp[(1) - (3)].zahl) + (yyvsp[(3) - (3)].zahl); }
2126
2189
    break;
2127
2190
 
2128
2191
  case 27:
 
2192
 
 
2193
/* Line 1455 of yacc.c  */
2129
2194
#line 381 "parser.yy"
2130
2195
    { (yyval.zahl) = (yyvsp[(1) - (3)].zahl) - (yyvsp[(3) - (3)].zahl); }
2131
2196
    break;
2132
2197
 
2133
2198
  case 28:
 
2199
 
 
2200
/* Line 1455 of yacc.c  */
2134
2201
#line 382 "parser.yy"
2135
2202
    { (yyval.zahl) = (yyvsp[(1) - (3)].zahl) * (yyvsp[(3) - (3)].zahl); }
2136
2203
    break;
2137
2204
 
2138
2205
  case 29:
 
2206
 
 
2207
/* Line 1455 of yacc.c  */
2139
2208
#line 383 "parser.yy"
2140
2209
    { (yyval.zahl) = divv((yyvsp[(1) - (3)].zahl),(yyvsp[(3) - (3)].zahl)); }
2141
2210
    break;
2142
2211
 
2143
2212
  case 30:
 
2213
 
 
2214
/* Line 1455 of yacc.c  */
2144
2215
#line 384 "parser.yy"
2145
2216
    { (yyval.zahl) = modd((yyvsp[(1) - (3)].zahl),(yyvsp[(3) - (3)].zahl)); }
2146
2217
    break;
2147
2218
 
2148
2219
  case 33:
 
2220
 
 
2221
/* Line 1455 of yacc.c  */
2149
2222
#line 397 "parser.yy"
2150
2223
    {
2151
2224
      gAktDefKnoten->speicherDefinition(namespace_prozedur, *(yyvsp[(1) - (5)].str),
2155
2228
    break;
2156
2229
 
2157
2230
  case 36:
 
2231
 
 
2232
/* Line 1455 of yacc.c  */
2158
2233
#line 413 "parser.yy"
2159
2234
    { (yyval.str) = (yyvsp[(1) - (1)].str); }
2160
2235
    break;
2161
2236
 
2162
2237
  case 37:
 
2238
 
 
2239
/* Line 1455 of yacc.c  */
2163
2240
#line 414 "parser.yy"
2164
2241
    {
2165
2242
      /* Wie gibt man einen Fehler m�glichst umst�ndlich aus?
2171
2248
    break;
2172
2249
 
2173
2250
  case 40:
 
2251
 
 
2252
/* Line 1455 of yacc.c  */
2174
2253
#line 429 "parser.yy"
2175
2254
    { (yyval.zahlpaar)[0]=(yyvsp[(1) - (1)].zahl); (yyval.zahlpaar)[1]=da_init; }
2176
2255
    break;
2177
2256
 
2178
2257
  case 41:
 
2258
 
 
2259
/* Line 1455 of yacc.c  */
2179
2260
#line 430 "parser.yy"
2180
2261
    { (yyval.zahlpaar)[0]=(yyvsp[(1) - (3)].zahl); (yyval.zahlpaar)[1]=da_kind; }
2181
2262
    break;
2182
2263
 
2183
2264
  case 42:
 
2265
 
 
2266
/* Line 1455 of yacc.c  */
2184
2267
#line 434 "parser.yy"
2185
2268
    { (yyval.zahlpaar)[0]=0;  (yyval.zahlpaar)[1]=da_init; }
2186
2269
    break;
2187
2270
 
2188
2271
  case 43:
 
2272
 
 
2273
/* Line 1455 of yacc.c  */
2189
2274
#line 435 "parser.yy"
2190
2275
    { (yyval.zahlpaar)[0]=(yyvsp[(2) - (2)].zahlpaar)[0];  (yyval.zahlpaar)[1]=(yyvsp[(2) - (2)].zahlpaar)[1];}
2191
2276
    break;
2192
2277
 
2193
2278
  case 44:
 
2279
 
 
2280
/* Line 1455 of yacc.c  */
2194
2281
#line 439 "parser.yy"
2195
2282
    {
2196
2283
      PBEGIN_TRY
2201
2288
    break;
2202
2289
 
2203
2290
  case 45:
 
2291
 
 
2292
/* Line 1455 of yacc.c  */
2204
2293
#line 449 "parser.yy"
2205
2294
    { (yyval.str) = (yyvsp[(1) - (1)].str); }
2206
2295
    break;
2207
2296
 
2208
2297
  case 46:
 
2298
 
 
2299
/* Line 1455 of yacc.c  */
2209
2300
#line 450 "parser.yy"
2210
2301
    {
2211
2302
      /* Wie gibt man einen Fehler m�glichst umst�ndlich aus?
2217
2308
    break;
2218
2309
 
2219
2310
  case 49:
 
2311
 
 
2312
/* Line 1455 of yacc.c  */
2220
2313
#line 466 "parser.yy"
2221
2314
    {
2222
2315
      PBEGIN_TRY
2231
2324
    break;
2232
2325
 
2233
2326
  case 50:
 
2327
 
 
2328
/* Line 1455 of yacc.c  */
2234
2329
#line 485 "parser.yy"
2235
2330
    { (yyval.code) = (yyvsp[(1) - (1)].code); }
2236
2331
    break;
2237
2332
 
2238
2333
  case 51:
 
2334
 
 
2335
/* Line 1455 of yacc.c  */
2239
2336
#line 486 "parser.yy"
2240
2337
    { (yyval.code) = newCode2(stapel_code, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2241
2338
    break;
2242
2339
 
2243
2340
  case 52:
 
2341
 
 
2342
/* Line 1455 of yacc.c  */
2244
2343
#line 490 "parser.yy"
2245
2344
    { (yyval.code) = (yyvsp[(3) - (4)].code); }
2246
2345
    break;
2247
2346
 
2248
2347
  case 53:
 
2348
 
 
2349
/* Line 1455 of yacc.c  */
2249
2350
#line 491 "parser.yy"
2250
2351
    {
2251
2352
      (yyval.code) = newCode4(bedingung_code, (yyvsp[(2) - (4)].code), (yyvsp[(4) - (4)].code),
2255
2356
    break;
2256
2357
 
2257
2358
  case 54:
 
2359
 
 
2360
/* Line 1455 of yacc.c  */
2258
2361
#line 496 "parser.yy"
2259
2362
    {
2260
2363
      if ((yyvsp[(3) - (6)].zahl)==ohne_merk_pfeil)
2267
2370
    break;
2268
2371
 
2269
2372
  case 55:
 
2373
 
 
2374
/* Line 1455 of yacc.c  */
2270
2375
#line 504 "parser.yy"
2271
2376
    {
2272
2377
      /* Nach else kann, muss aber kein Pfeil stehen.
2279
2384
    break;
2280
2385
 
2281
2386
  case 56:
 
2387
 
 
2388
/* Line 1455 of yacc.c  */
2282
2389
#line 512 "parser.yy"
2283
2390
    { (yyval.code) = (yyvsp[(2) - (3)].code); }
2284
2391
    break;
2285
2392
 
2286
2393
  case 57:
 
2394
 
 
2395
/* Line 1455 of yacc.c  */
2287
2396
#line 513 "parser.yy"
2288
2397
    { (yyval.code) = newCode2(folge_code, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2289
2398
    break;
2290
2399
 
2291
2400
  case 58:
 
2401
 
 
2402
/* Line 1455 of yacc.c  */
2292
2403
#line 514 "parser.yy"
2293
2404
    { (yyval.code) = newCode1(zahl_code, (yyvsp[(1) - (1)].zahl)); }
2294
2405
    break;
2295
2406
 
2296
2407
  case 59:
 
2408
 
 
2409
/* Line 1455 of yacc.c  */
2297
2410
#line 515 "parser.yy"
2298
2411
    { (yyval.code) = (yyvsp[(1) - (1)].code); }
2299
2412
    break;
2300
2413
 
2301
2414
  case 60:
 
2415
 
 
2416
/* Line 1455 of yacc.c  */
2302
2417
#line 516 "parser.yy"
2303
2418
    {
2304
2419
      (yyval.code) = newCode2(stapel_code, newCode1(zahl_code, (yyvsp[(1) - (2)].zahl)), (yyvsp[(2) - (2)].code));
2306
2421
    break;
2307
2422
 
2308
2423
  case 61:
 
2424
 
 
2425
/* Line 1455 of yacc.c  */
2309
2426
#line 519 "parser.yy"
2310
2427
    {
2311
2428
      PBEGIN_TRY
2319
2436
    break;
2320
2437
 
2321
2438
  case 62:
 
2439
 
 
2440
/* Line 1455 of yacc.c  */
2322
2441
#line 528 "parser.yy"
2323
2442
    {
2324
2443
      PBEGIN_TRY
2333
2452
    break;
2334
2453
 
2335
2454
  case 63:
 
2455
 
 
2456
/* Line 1455 of yacc.c  */
2336
2457
#line 538 "parser.yy"
2337
2458
    { (yyval.code) = newCode0(nop_code); }
2338
2459
    break;
2339
2460
 
2340
2461
  case 64:
 
2462
 
 
2463
/* Line 1455 of yacc.c  */
2341
2464
#line 539 "parser.yy"
2342
2465
    { (yyval.code) = (yyvsp[(1) - (1)].code); }
2343
2466
    break;
2344
2467
 
2345
2468
  case 65:
 
2469
 
 
2470
/* Line 1455 of yacc.c  */
2346
2471
#line 540 "parser.yy"
2347
2472
    {
2348
2473
      PBEGIN_TRY
2356
2481
    break;
2357
2482
 
2358
2483
  case 66:
 
2484
 
 
2485
/* Line 1455 of yacc.c  */
2359
2486
#line 549 "parser.yy"
2360
2487
    { (yyval.code) = newCode0(busy_code); }
2361
2488
    break;
2362
2489
 
2363
2490
  case 67:
 
2491
 
 
2492
/* Line 1455 of yacc.c  */
2364
2493
#line 550 "parser.yy"
2365
2494
    {
2366
2495
      (yyval.code) = newCode1(bonus_code, (yyvsp[(3) - (4)].code));
2368
2497
    break;
2369
2498
 
2370
2499
  case 68:
 
2500
 
 
2501
/* Line 1455 of yacc.c  */
2371
2502
#line 553 "parser.yy"
2372
2503
    {
2373
 
      (yyval.code) = newCode1(message_code, *(yyvsp[(3) - (4)].str));
 
2504
      (yyval.code) = newCode1(message_code, _((yyvsp[(3) - (4)].str)->data()));
2374
2505
      delete (yyvsp[(3) - (4)].str);
2375
2506
    }
2376
2507
    break;
2377
2508
 
2378
2509
  case 69:
 
2510
 
 
2511
/* Line 1455 of yacc.c  */
2379
2512
#line 557 "parser.yy"
2380
2513
    {
2381
2514
      (yyval.code) = newCode1(sound_code, Sound::ladSample(*(yyvsp[(3) - (4)].str)));
2384
2517
    break;
2385
2518
 
2386
2519
  case 70:
 
2520
 
 
2521
/* Line 1455 of yacc.c  */
2387
2522
#line 561 "parser.yy"
2388
2523
    {
2389
2524
      (yyval.code) = newCode0(explode_code);
2391
2526
    break;
2392
2527
 
2393
2528
  case 71:
 
2529
 
 
2530
/* Line 1455 of yacc.c  */
2394
2531
#line 567 "parser.yy"
2395
2532
    {
2396
2533
      PBEGIN_TRY
2403
2540
    break;
2404
2541
 
2405
2542
  case 72:
 
2543
 
 
2544
/* Line 1455 of yacc.c  */
2406
2545
#line 577 "parser.yy"
2407
2546
    { (yyval.codeart) = set_code; }
2408
2547
    break;
2409
2548
 
2410
2549
  case 73:
 
2550
 
 
2551
/* Line 1455 of yacc.c  */
2411
2552
#line 578 "parser.yy"
2412
2553
    { (yyval.codeart) = add_code; }
2413
2554
    break;
2414
2555
 
2415
2556
  case 74:
 
2557
 
 
2558
/* Line 1455 of yacc.c  */
2416
2559
#line 579 "parser.yy"
2417
2560
    { (yyval.codeart) = sub_code; }
2418
2561
    break;
2419
2562
 
2420
2563
  case 75:
 
2564
 
 
2565
/* Line 1455 of yacc.c  */
2421
2566
#line 580 "parser.yy"
2422
2567
    { (yyval.codeart) = mul_code; }
2423
2568
    break;
2424
2569
 
2425
2570
  case 76:
 
2571
 
 
2572
/* Line 1455 of yacc.c  */
2426
2573
#line 581 "parser.yy"
2427
2574
    { (yyval.codeart) = div_code; }
2428
2575
    break;
2429
2576
 
2430
2577
  case 77:
 
2578
 
 
2579
/* Line 1455 of yacc.c  */
2431
2580
#line 582 "parser.yy"
2432
2581
    { (yyval.codeart) = mod_code; }
2433
2582
    break;
2434
2583
 
2435
2584
  case 78:
 
2585
 
 
2586
/* Line 1455 of yacc.c  */
2436
2587
#line 583 "parser.yy"
2437
2588
    { (yyval.codeart) = bitset_code; }
2438
2589
    break;
2439
2590
 
2440
2591
  case 79:
 
2592
 
 
2593
/* Line 1455 of yacc.c  */
2441
2594
#line 584 "parser.yy"
2442
2595
    { (yyval.codeart) = bitunset_code; }
2443
2596
    break;
2444
2597
 
2445
2598
  case 80:
 
2599
 
 
2600
/* Line 1455 of yacc.c  */
2446
2601
#line 589 "parser.yy"
2447
2602
    { (yyval.code) = newCode0(mal_code); }
2448
2603
    break;
2449
2604
 
2450
2605
  case 81:
 
2606
 
 
2607
/* Line 1455 of yacc.c  */
2451
2608
#line 590 "parser.yy"
2452
2609
    { (yyval.code) = newCode2(mal_code_fremd, (yyvsp[(2) - (2)].ort), 1); }
2453
2610
    break;
2454
2611
 
2455
2612
  case 82:
 
2613
 
 
2614
/* Line 1455 of yacc.c  */
2456
2615
#line 591 "parser.yy"
2457
2616
    { (yyval.code) = newCode2(mal_code_fremd, (yyvsp[(1) - (2)].ort), -1); }
2458
2617
    break;
2459
2618
 
2460
2619
  case 83:
 
2620
 
 
2621
/* Line 1455 of yacc.c  */
2461
2622
#line 595 "parser.yy"
2462
2623
    { (yyval.code) = newCode1(buchstabe_code, (yyvsp[(1) - (1)].zahl)); }
2463
2624
    break;
2464
2625
 
2465
2626
  case 84:
 
2627
 
 
2628
/* Line 1455 of yacc.c  */
2466
2629
#line 596 "parser.yy"
2467
2630
    {
2468
2631
      (yyval.code) = newCode2(stapel_code, newCode1(buchstabe_code, (yyvsp[(1) - (2)].zahl)),
2471
2634
    break;
2472
2635
 
2473
2636
  case 85:
 
2637
 
 
2638
/* Line 1455 of yacc.c  */
2474
2639
#line 600 "parser.yy"
2475
2640
    { (yyval.code) = (yyvsp[(1) - (1)].code); }
2476
2641
    break;
2477
2642
 
2478
2643
  case 86:
 
2644
 
 
2645
/* Line 1455 of yacc.c  */
2479
2646
#line 605 "parser.yy"
2480
2647
    {
2481
2648
      (yyval.code) = newCode4(bedingung_code, (yyvsp[(1) - (4)].code), (yyvsp[(3) - (4)].code),
2485
2652
    break;
2486
2653
 
2487
2654
  case 87:
 
2655
 
 
2656
/* Line 1455 of yacc.c  */
2488
2657
#line 610 "parser.yy"
2489
2658
    {
2490
2659
      (yyval.code) = newCode4(bedingung_code, (yyvsp[(1) - (7)].code), (yyvsp[(3) - (7)].code),
2494
2663
    break;
2495
2664
 
2496
2665
  case 88:
 
2666
 
 
2667
/* Line 1455 of yacc.c  */
2497
2668
#line 615 "parser.yy"
2498
2669
    {
2499
2670
      (yyval.code) = newCode4(bedingung_code, (yyvsp[(1) - (5)].code), (yyvsp[(3) - (5)].code),
2503
2674
    break;
2504
2675
 
2505
2676
  case 89:
 
2677
 
 
2678
/* Line 1455 of yacc.c  */
2506
2679
#line 626 "parser.yy"
2507
2680
    { (yyval.str) = (yyvsp[(1) - (1)].str); }
2508
2681
    break;
2509
2682
 
2510
2683
  case 90:
 
2684
 
 
2685
/* Line 1455 of yacc.c  */
2511
2686
#line 627 "parser.yy"
2512
2687
    {
2513
2688
      *(yyvsp[(1) - (3)].str) += '.';  *(yyvsp[(1) - (3)].str) += *(yyvsp[(3) - (3)].str);  (yyval.str) = (yyvsp[(1) - (3)].str);
2516
2691
    break;
2517
2692
 
2518
2693
  case 91:
 
2694
 
 
2695
/* Line 1455 of yacc.c  */
2519
2696
#line 631 "parser.yy"
2520
2697
    {
2521
2698
      *(yyvsp[(1) - (3)].str) += '.';  *(yyvsp[(1) - (3)].str) += ((yyvsp[(3) - (3)].zahl)>=26 ? 'a'+(yyvsp[(3) - (3)].zahl)-26 : 'A'+(yyvsp[(3) - (3)].zahl));  (yyval.str) = (yyvsp[(1) - (3)].str);
2523
2700
    break;
2524
2701
 
2525
2702
  case 92:
 
2703
 
 
2704
/* Line 1455 of yacc.c  */
2526
2705
#line 637 "parser.yy"
2527
2706
    { (yyval.str) = (yyvsp[(1) - (1)].str); }
2528
2707
    break;
2529
2708
 
2530
2709
  case 93:
 
2710
 
 
2711
/* Line 1455 of yacc.c  */
2531
2712
#line 638 "parser.yy"
2532
2713
    { (yyval.str) = (yyvsp[(1) - (1)].str); }
2533
2714
    break;
2534
2715
 
2535
2716
  case 94:
 
2717
 
 
2718
/* Line 1455 of yacc.c  */
2536
2719
#line 645 "parser.yy"
2537
2720
    {
2538
2721
      if ((yyvsp[(1) - (1)].variable)->istKonstante()) {
2546
2729
    break;
2547
2730
 
2548
2731
  case 95:
 
2732
 
 
2733
/* Line 1455 of yacc.c  */
2549
2734
#line 654 "parser.yy"
2550
2735
    { (yyval.code) = newCode1(zahl_acode, (yyvsp[(1) - (1)].zahl)); }
2551
2736
    break;
2552
2737
 
2553
2738
  case 96:
 
2739
 
 
2740
/* Line 1455 of yacc.c  */
2554
2741
#line 655 "parser.yy"
2555
2742
    { (yyval.code) = (yyvsp[(2) - (3)].code); }
2556
2743
    break;
2557
2744
 
2558
2745
  case 97:
 
2746
 
 
2747
/* Line 1455 of yacc.c  */
2559
2748
#line 656 "parser.yy"
2560
2749
    {
2561
2750
      (yyval.code) = newNachbarCode(gAktDefKnoten, gDateiName, gZeilenNr, (yyvsp[(1) - (1)].str));
2563
2752
    break;
2564
2753
 
2565
2754
  case 98:
 
2755
 
 
2756
/* Line 1455 of yacc.c  */
2566
2757
#line 659 "parser.yy"
2567
2758
    {
2568
2759
      (yyval.code) = newNachbarCode(gAktDefKnoten, gDateiName, gZeilenNr, (yyvsp[(1) - (1)].str));
2570
2761
    break;
2571
2762
 
2572
2763
  case 99:
 
2764
 
 
2765
/* Line 1455 of yacc.c  */
2573
2766
#line 666 "parser.yy"
2574
2767
    { (yyval.code) = newCode2(manchmal_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2575
2768
    break;
2576
2769
 
2577
2770
  case 100:
 
2771
 
 
2772
/* Line 1455 of yacc.c  */
2578
2773
#line 667 "parser.yy"
2579
2774
    { (yyval.code) = newCode2(add_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2580
2775
    break;
2581
2776
 
2582
2777
  case 101:
 
2778
 
 
2779
/* Line 1455 of yacc.c  */
2583
2780
#line 668 "parser.yy"
2584
2781
    { (yyval.code) = newCode1(neg_acode, (yyvsp[(2) - (2)].code));}
2585
2782
    break;
2586
2783
 
2587
2784
  case 102:
 
2785
 
 
2786
/* Line 1455 of yacc.c  */
2588
2787
#line 669 "parser.yy"
2589
2788
    { (yyval.code) = newCode2(sub_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2590
2789
    break;
2591
2790
 
2592
2791
  case 103:
 
2792
 
 
2793
/* Line 1455 of yacc.c  */
2593
2794
#line 670 "parser.yy"
2594
2795
    { (yyval.code) = newCode2(mul_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2595
2796
    break;
2596
2797
 
2597
2798
  case 104:
 
2799
 
 
2800
/* Line 1455 of yacc.c  */
2598
2801
#line 671 "parser.yy"
2599
2802
    { (yyval.code) = newCode2(div_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2600
2803
    break;
2601
2804
 
2602
2805
  case 105:
 
2806
 
 
2807
/* Line 1455 of yacc.c  */
2603
2808
#line 672 "parser.yy"
2604
2809
    { (yyval.code) = newCode2(mod_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2605
2810
    break;
2606
2811
 
2607
2812
  case 106:
 
2813
 
 
2814
/* Line 1455 of yacc.c  */
2608
2815
#line 673 "parser.yy"
2609
2816
    { (yyval.code) = newCode2(bitset_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2610
2817
    break;
2611
2818
 
2612
2819
  case 107:
 
2820
 
 
2821
/* Line 1455 of yacc.c  */
2613
2822
#line 674 "parser.yy"
2614
2823
    { (yyval.code) = newCode2(bitunset_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2615
2824
    break;
2616
2825
 
2617
2826
  case 108:
 
2827
 
 
2828
/* Line 1455 of yacc.c  */
2618
2829
#line 675 "parser.yy"
2619
2830
    { (yyval.code) = newCode2(bittest_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2620
2831
    break;
2621
2832
 
2622
2833
  case 109:
 
2834
 
 
2835
/* Line 1455 of yacc.c  */
2623
2836
#line 676 "parser.yy"
2624
2837
    { (yyval.code) = newCode2(eq_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2625
2838
    break;
2626
2839
 
2627
2840
  case 110:
 
2841
 
 
2842
/* Line 1455 of yacc.c  */
2628
2843
#line 677 "parser.yy"
2629
2844
    { (yyval.code) = newCode2(ne_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2630
2845
    break;
2631
2846
 
2632
2847
  case 111:
 
2848
 
 
2849
/* Line 1455 of yacc.c  */
2633
2850
#line 678 "parser.yy"
2634
2851
    { (yyval.code) = newCode2(ge_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2635
2852
    break;
2636
2853
 
2637
2854
  case 112:
 
2855
 
 
2856
/* Line 1455 of yacc.c  */
2638
2857
#line 679 "parser.yy"
2639
2858
    { (yyval.code) = newCode2(le_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2640
2859
    break;
2641
2860
 
2642
2861
  case 113:
 
2862
 
 
2863
/* Line 1455 of yacc.c  */
2643
2864
#line 680 "parser.yy"
2644
2865
    { (yyval.code) = newCode2(gt_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2645
2866
    break;
2646
2867
 
2647
2868
  case 114:
 
2869
 
 
2870
/* Line 1455 of yacc.c  */
2648
2871
#line 681 "parser.yy"
2649
2872
    { (yyval.code) = newCode2(lt_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2650
2873
    break;
2651
2874
 
2652
2875
  case 115:
 
2876
 
 
2877
/* Line 1455 of yacc.c  */
2653
2878
#line 682 "parser.yy"
2654
2879
    { (yyval.code) = newCode2(bitand_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2655
2880
    break;
2656
2881
 
2657
2882
  case 116:
 
2883
 
 
2884
/* Line 1455 of yacc.c  */
2658
2885
#line 683 "parser.yy"
2659
2886
    { (yyval.code) = newCode2(bitor_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2660
2887
    break;
2661
2888
 
2662
2889
  case 117:
 
2890
 
 
2891
/* Line 1455 of yacc.c  */
2663
2892
#line 684 "parser.yy"
2664
2893
    { (yyval.code) = newCode1(not_acode, (yyvsp[(2) - (2)].code));}
2665
2894
    break;
2666
2895
 
2667
2896
  case 118:
 
2897
 
 
2898
/* Line 1455 of yacc.c  */
2668
2899
#line 685 "parser.yy"
2669
2900
    { (yyval.code) = newCode2(und_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2670
2901
    break;
2671
2902
 
2672
2903
  case 119:
 
2904
 
 
2905
/* Line 1455 of yacc.c  */
2673
2906
#line 686 "parser.yy"
2674
2907
    { (yyval.code) = newCode2(oder_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code));}
2675
2908
    break;
2676
2909
 
2677
2910
  case 120:
 
2911
 
 
2912
/* Line 1455 of yacc.c  */
2678
2913
#line 687 "parser.yy"
2679
2914
    {
2680
2915
      (yyval.code) = newCode3(intervall_acode, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].codepaar)[0], (yyvsp[(3) - (3)].codepaar)[1]);
2682
2917
    break;
2683
2918
 
2684
2919
  case 121:
 
2920
 
 
2921
/* Line 1455 of yacc.c  */
2685
2922
#line 690 "parser.yy"
2686
2923
    {
2687
2924
      (yyval.code) = newCode1(rnd_acode, (yyvsp[(3) - (4)].code));
2689
2926
    break;
2690
2927
 
2691
2928
  case 122:
 
2929
 
 
2930
/* Line 1455 of yacc.c  */
2692
2931
#line 693 "parser.yy"
2693
2932
    {
2694
2933
      (yyval.code) = newCode2(ggt_acode, (yyvsp[(3) - (6)].code), (yyvsp[(5) - (6)].code));
2696
2935
    break;
2697
2936
 
2698
2937
  case 123:
 
2938
 
 
2939
/* Line 1455 of yacc.c  */
2699
2940
#line 700 "parser.yy"
2700
2941
    { (yyval.codepaar)[0]=(yyvsp[(1) - (2)].code); (yyval.codepaar)[1]=newCode1(zahl_acode, VIEL); }
2701
2942
    break;
2702
2943
 
2703
2944
  case 124:
 
2945
 
 
2946
/* Line 1455 of yacc.c  */
2704
2947
#line 701 "parser.yy"
2705
2948
    { (yyval.codepaar)[0]=newCode1(zahl_acode, -VIEL); (yyval.codepaar)[1]=(yyvsp[(2) - (2)].code); }
2706
2949
    break;
2707
2950
 
2708
2951
  case 125:
 
2952
 
 
2953
/* Line 1455 of yacc.c  */
2709
2954
#line 702 "parser.yy"
2710
2955
    { (yyval.codepaar)[0]=(yyvsp[(1) - (3)].code); (yyval.codepaar)[1]=(yyvsp[(3) - (3)].code); }
2711
2956
    break;
2712
2957
 
2713
2958
  case 126:
 
2959
 
 
2960
/* Line 1455 of yacc.c  */
2714
2961
#line 706 "parser.yy"
2715
2962
    {
2716
2963
      PBEGIN_TRY
2726
2973
    break;
2727
2974
 
2728
2975
  case 127:
 
2976
 
 
2977
/* Line 1455 of yacc.c  */
2729
2978
#line 717 "parser.yy"
2730
2979
    {
2731
2980
      /* Wie gibt man einen Fehler m�glichst umst�ndlich aus?
2737
2986
    break;
2738
2987
 
2739
2988
  case 128:
 
2989
 
 
2990
/* Line 1455 of yacc.c  */
2740
2991
#line 727 "parser.yy"
2741
2992
    { (yyval.variable) = (yyvsp[(1) - (1)].variable); }
2742
2993
    break;
2743
2994
 
2744
2995
  case 129:
 
2996
 
 
2997
/* Line 1455 of yacc.c  */
2745
2998
#line 728 "parser.yy"
2746
2999
    {
2747
3000
      PBEGIN_TRY
2756
3009
    break;
2757
3010
 
2758
3011
  case 130:
 
3012
 
 
3013
/* Line 1455 of yacc.c  */
2759
3014
#line 741 "parser.yy"
2760
3015
    { (yyval.code) = (yyvsp[(1) - (1)].code); }
2761
3016
    break;
2762
3017
 
2763
3018
  case 131:
 
3019
 
 
3020
/* Line 1455 of yacc.c  */
2764
3021
#line 742 "parser.yy"
2765
3022
    { (yyval.code) = newCode1(zahl_acode, (yyvsp[(1) - (1)].zahl)); }
2766
3023
    break;
2767
3024
 
2768
3025
  case 132:
 
3026
 
 
3027
/* Line 1455 of yacc.c  */
2769
3028
#line 746 "parser.yy"
2770
3029
    { (yyval.haelfte) = haelfte_hier; }
2771
3030
    break;
2772
3031
 
2773
3032
  case 133:
 
3033
 
 
3034
/* Line 1455 of yacc.c  */
2774
3035
#line 747 "parser.yy"
2775
3036
    { (yyval.haelfte) = haelfte_drueben; }
2776
3037
    break;
2777
3038
 
2778
3039
  case 134:
 
3040
 
 
3041
/* Line 1455 of yacc.c  */
2779
3042
#line 748 "parser.yy"
2780
3043
    { (yyval.haelfte) = haelfte_links; }
2781
3044
    break;
2782
3045
 
2783
3046
  case 135:
 
3047
 
 
3048
/* Line 1455 of yacc.c  */
2784
3049
#line 749 "parser.yy"
2785
3050
    { (yyval.haelfte) = haelfte_rechts; }
2786
3051
    break;
2787
3052
 
2788
3053
  case 136:
 
3054
 
 
3055
/* Line 1455 of yacc.c  */
2789
3056
#line 753 "parser.yy"
2790
3057
    { (yyval.ort) = new Ort(absort_semiglobal); }
2791
3058
    break;
2792
3059
 
2793
3060
  case 137:
 
3061
 
 
3062
/* Line 1455 of yacc.c  */
2794
3063
#line 754 "parser.yy"
2795
3064
    { (yyval.ort) = new Ort(absort_fall, newCode1(zahl_acode, (yyvsp[(1) - (1)].zahl))); }
2796
3065
    break;
2797
3066
 
2798
3067
  case 138:
 
3068
 
 
3069
/* Line 1455 of yacc.c  */
2799
3070
#line 758 "parser.yy"
2800
3071
    { (yyval.ort) = new Ort(absort_semiglobal); }
2801
3072
    break;
2802
3073
 
2803
3074
  case 139:
 
3075
 
 
3076
/* Line 1455 of yacc.c  */
2804
3077
#line 759 "parser.yy"
2805
3078
    { (yyval.ort) = new Ort(absort_fall, (yyvsp[(1) - (1)].code)); }
2806
3079
    break;
2807
3080
 
2808
3081
  case 140:
 
3082
 
 
3083
/* Line 1455 of yacc.c  */
2809
3084
#line 760 "parser.yy"
2810
3085
    { (yyval.ort) = new Ort(absort_feld, (yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code)); }
2811
3086
    break;
2812
3087
 
2813
3088
  case 141:
 
3089
 
 
3090
/* Line 1455 of yacc.c  */
2814
3091
#line 764 "parser.yy"
2815
3092
    { (yyval.ort) = (yyvsp[(1) - (1)].ort); }
2816
3093
    break;
2817
3094
 
2818
3095
  case 142:
 
3096
 
 
3097
/* Line 1455 of yacc.c  */
2819
3098
#line 765 "parser.yy"
2820
3099
    { (yyval.ort) = (yyvsp[(2) - (3)].ort); }
2821
3100
    break;
2822
3101
 
2823
3102
  case 143:
 
3103
 
 
3104
/* Line 1455 of yacc.c  */
2824
3105
#line 766 "parser.yy"
2825
3106
    {
2826
3107
      (yyvsp[(2) - (5)].ort)->setzeHaelfte((yyvsp[(4) - (5)].haelfte));
2829
3110
    break;
2830
3111
 
2831
3112
  case 144:
 
3113
 
 
3114
/* Line 1455 of yacc.c  */
2832
3115
#line 773 "parser.yy"
2833
3116
    { (yyval.ort) = new Ort(absort_global); }
2834
3117
    break;
2835
3118
 
2836
3119
  case 145:
 
3120
 
 
3121
/* Line 1455 of yacc.c  */
2837
3122
#line 774 "parser.yy"
2838
3123
    { (yyval.ort) = new Ort(newCode1(zahl_acode, (yyvsp[(1) - (1)].zahl))); }
2839
3124
    break;
2840
3125
 
2841
3126
  case 146:
 
3127
 
 
3128
/* Line 1455 of yacc.c  */
2842
3129
#line 778 "parser.yy"
2843
3130
    { (yyval.ort) = new Ort(absort_global); }
2844
3131
    break;
2845
3132
 
2846
3133
  case 147:
 
3134
 
 
3135
/* Line 1455 of yacc.c  */
2847
3136
#line 779 "parser.yy"
2848
3137
    { (yyval.ort) = new Ort((yyvsp[(1) - (1)].code)); }
2849
3138
    break;
2850
3139
 
2851
3140
  case 148:
 
3141
 
 
3142
/* Line 1455 of yacc.c  */
2852
3143
#line 780 "parser.yy"
2853
3144
    { (yyval.ort) = new Ort((yyvsp[(1) - (3)].code), (yyvsp[(3) - (3)].code)); }
2854
3145
    break;
2855
3146
 
2856
3147
  case 149:
 
3148
 
 
3149
/* Line 1455 of yacc.c  */
2857
3150
#line 784 "parser.yy"
2858
3151
    { (yyval.ort) = (yyvsp[(1) - (1)].ort); }
2859
3152
    break;
2860
3153
 
2861
3154
  case 150:
 
3155
 
 
3156
/* Line 1455 of yacc.c  */
2862
3157
#line 785 "parser.yy"
2863
3158
    { (yyval.ort) = (yyvsp[(2) - (3)].ort); }
2864
3159
    break;
2865
3160
 
2866
3161
  case 151:
 
3162
 
 
3163
/* Line 1455 of yacc.c  */
2867
3164
#line 786 "parser.yy"
2868
3165
    {
2869
3166
      (yyvsp[(2) - (5)].ort)->setzeHaelfte((yyvsp[(4) - (5)].haelfte));
2872
3169
    break;
2873
3170
 
2874
3171
  case 152:
 
3172
 
 
3173
/* Line 1455 of yacc.c  */
2875
3174
#line 793 "parser.yy"
2876
3175
    { (yyval.ort) = (yyvsp[(2) - (2)].ort); }
2877
3176
    break;
2878
3177
 
2879
3178
  case 153:
 
3179
 
 
3180
/* Line 1455 of yacc.c  */
2880
3181
#line 794 "parser.yy"
2881
3182
    { (yyval.ort) = (yyvsp[(2) - (2)].ort); }
2882
3183
    break;
2883
3184
 
2884
3185
  case 154:
 
3186
 
 
3187
/* Line 1455 of yacc.c  */
2885
3188
#line 801 "parser.yy"
2886
3189
    { (yyval.zahl) = (yyvsp[(1) - (1)].zahl); }
2887
3190
    break;
2888
3191
 
2889
3192
  case 155:
 
3193
 
 
3194
/* Line 1455 of yacc.c  */
2890
3195
#line 802 "parser.yy"
2891
3196
    { (yyval.zahl) = (yyvsp[(1) - (1)].zahl); }
2892
3197
    break;
2893
3198
 
2894
3199
  case 156:
 
3200
 
 
3201
/* Line 1455 of yacc.c  */
2895
3202
#line 808 "parser.yy"
2896
3203
    {
2897
3204
       /* Halbzahlen sollen intern aufgerundet gespeichert werden... */
2900
3207
    break;
2901
3208
 
2902
3209
  case 157:
 
3210
 
 
3211
/* Line 1455 of yacc.c  */
2903
3212
#line 812 "parser.yy"
2904
3213
    { (yyval.zahl) = -(yyvsp[(2) - (2)].zahl); }
2905
3214
    break;
2906
3215
 
2907
3216
  case 158:
 
3217
 
 
3218
/* Line 1455 of yacc.c  */
2908
3219
#line 815 "parser.yy"
2909
3220
    { (yyval.zahl) = (yyvsp[(1) - (1)].zahl); }
2910
3221
    break;
2911
3222
 
2912
3223
  case 159:
 
3224
 
 
3225
/* Line 1455 of yacc.c  */
2913
3226
#line 816 "parser.yy"
2914
3227
    { (yyval.zahl) = -(yyvsp[(2) - (2)].zahl); }
2915
3228
    break;
2916
3229
 
2917
3230
 
2918
 
/* Line 1267 of yacc.c.  */
2919
 
#line 2920 "parser.cc"
 
3231
 
 
3232
/* Line 1455 of yacc.c  */
 
3233
#line 3234 "parser.cc"
2920
3234
      default: break;
2921
3235
    }
2922
3236
  YY_SYMBOL_PRINT ("-> $$ =", yyr1[yyn], &yyval, &yyloc);
2927
3241
 
2928
3242
  *++yyvsp = yyval;
2929
3243
 
2930
 
 
2931
3244
  /* Now `shift' the result of the reduction.  Determine what state
2932
3245
     that goes to, based on the state we popped back to and the rule
2933
3246
     number reduced by.  */
2992
3305
 
2993
3306
  if (yyerrstatus == 3)
2994
3307
    {
2995
 
      /* If just tried and failed to reuse look-ahead token after an
 
3308
      /* If just tried and failed to reuse lookahead token after an
2996
3309
         error, discard it.  */
2997
3310
 
2998
3311
      if (yychar <= YYEOF)
3009
3322
        }
3010
3323
    }
3011
3324
 
3012
 
  /* Else will try to reuse look-ahead token after shifting the error
 
3325
  /* Else will try to reuse lookahead token after shifting the error
3013
3326
     token.  */
3014
3327
  goto yyerrlab1;
3015
3328
 
3066
3379
      YY_STACK_PRINT (yyss, yyssp);
3067
3380
    }
3068
3381
 
3069
 
  if (yyn == YYFINAL)
3070
 
    YYACCEPT;
3071
 
 
3072
3382
  *++yyvsp = yylval;
3073
3383
 
3074
3384
 
3093
3403
  yyresult = 1;
3094
3404
  goto yyreturn;
3095
3405
 
3096
 
#ifndef yyoverflow
 
3406
#if !defined(yyoverflow) || YYERROR_VERBOSE
3097
3407
/*-------------------------------------------------.
3098
3408
| yyexhaustedlab -- memory exhaustion comes here.  |
3099
3409
`-------------------------------------------------*/
3104
3414
#endif
3105
3415
 
3106
3416
yyreturn:
3107
 
  if (yychar != YYEOF && yychar != YYEMPTY)
 
3417
  if (yychar != YYEMPTY)
3108
3418
     yydestruct ("Cleanup: discarding lookahead",
3109
3419
                 yytoken, &yylval);
3110
3420
  /* Do not reclaim the symbols of the rule which action triggered
3130
3440
}
3131
3441
 
3132
3442
 
 
3443
 
 
3444
/* Line 1675 of yacc.c  */
3133
3445
#line 820 "parser.yy"
3134
3446
 
3135
3447
/*****************************************************************************/