« back to all changes in this revision
Viewing changes to src/raster/r.binfer/y.tab.c
- browse files at revision 2
- compare with another revision
- download diff
- download tarball
- view history from revision 2
- Committer: Bazaar Package Importer
- Author(s): LaMont Jones
- Date: 2004-08-24 13:21:59 UTC
- Revision ID: james.westby@ubuntu.com-20040824132159-p7saiyxvxw3qlkrg
Tags: 5.0.3-4ubuntu1
Build-depend: libtiff4-dev
- files added:
- confdefs.h
- debian
- debian/patches
- files modified:
- config.guess
added
removed
src/raster/r.binfer/y.tab.c
1
/* A Bison parser, made by GNU Bison 1.875a. */
2
3
/* Skeleton parser for Yacc-like parsing with Bison,
4
Copyright (C) 1984, 1989, 1990, 2000, 2001, 2002, 2003 Free Software Foundation, Inc.
5
6
This program is free software; you can redistribute it and/or modify
7
it under the terms of the GNU General Public License as published by
8
the Free Software Foundation; either version 2, or (at your option)
9
any later version.
10
11
This program is distributed in the hope that it will be useful,
12
but WITHOUT ANY WARRANTY; without even the implied warranty of
13
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14
GNU General Public License for more details.
15
16
You should have received a copy of the GNU General Public License
17
along with this program; if not, write to the Free Software
18
Foundation, Inc., 59 Temple Place - Suite 330,
19
Boston, MA 02111-1307, USA. */
20
21
/* As a special exception, when this file is copied by Bison into a
22
Bison output file, you may use that output file without restriction.
23
This special exception was added by the Free Software Foundation
24
in version 1.24 of Bison. */
25
26
/* Written by Richard Stallman by simplifying the original so called
27
``semantic'' parser. */
28
29
/* All symbols defined below should begin with yy or YY, to avoid
30
infringing on user name space. This should be done even for local
31
variables, as they might otherwise be expanded by user macros.
32
There are some unavoidable exceptions within include files to
33
define necessary library symbols; they are noted "INFRINGES ON
34
USER NAME SPACE" below. */
35
36
/* Identify Bison output. */
37
#define YYBISON 1
38
39
/* Skeleton name. */
40
#define YYSKELETON_NAME "yacc.c"
41
42
/* Pure parsers. */
43
#define YYPURE 0
44
45
/* Using locations. */
46
#define YYLSP_NEEDED 0
47
48
49
50
/* Tokens. */
51
#ifndef YYTOKENTYPE
52
# define YYTOKENTYPE
53
/* Put the tokens into the symbol table, so that GDB and other debuggers
54
know about them. */
55
enum yytokentype {
56
Identifier = 258,
57
String = 259,
58
Constant = 260,
59
LAYER = 261,
60
CONTEXT = 262,
61
SUBJECTIVE = 263,
62
INFERRED = 264,
63
QUESTION = 265,
64
THRU = 266,
65
NO_COMBINED_MAP = 267,
66
NO_PROBABILITY_MAPS = 268,
67
COMBINED_MAP = 269,
68
ASPECT = 270,
69
GREY = 271,
70
HISTO = 272,
71
RAINBOW = 273,
72
RAMP = 274,
73
RANDOM = 275,
74
REDYELLOWGREEN = 276,
75
WAVE = 277
76
};
77
#endif
78
#define Identifier 258
79
#define String 259
80
#define Constant 260
81
#define LAYER 261
82
#define CONTEXT 262
83
#define SUBJECTIVE 263
84
#define INFERRED 264
85
#define QUESTION 265
86
#define THRU 266
87
#define NO_COMBINED_MAP 267
88
#define NO_PROBABILITY_MAPS 268
89
#define COMBINED_MAP 269
90
#define ASPECT 270
91
#define GREY 271
92
#define HISTO 272
93
#define RAINBOW 273
94
#define RAMP 274
95
#define RANDOM 275
96
#define REDYELLOWGREEN 276
97
#define WAVE 277
98
99
100
101
102
/* Copy the first part of user declarations. */
103
#line 12 "binfer.y"
104
105
106
#include "symtab.h"
107
#include <stdlib.h>
108
#include <math.h>
109
#include "local_proto.h"
110
struct symtab table;
111
struct symtab *cur_sym;
112
struct symtab *cur_att;
113
struct names namelist;
114
struct names problist;
115
char probbuf[256];
116
char reclassbuf[256];
117
int valno = 1;
118
int expected_type;
119
int value_type;
120
extern int verbose;
121
extern int probabilitymaps;
122
extern int combinedmap;
123
extern int colortable;
124
125
126
127
/* Enabling traces. */
128
#ifndef YYDEBUG
129
# define YYDEBUG 0
130
#endif
131
132
/* Enabling verbose error messages. */
133
#ifdef YYERROR_VERBOSE
134
# undef YYERROR_VERBOSE
135
# define YYERROR_VERBOSE 1
136
#else
137
# define YYERROR_VERBOSE 0
138
#endif
139
140
#if ! defined (YYSTYPE) && ! defined (YYSTYPE_IS_DECLARED)
141
#line 35 "binfer.y"
142
typedef union YYSTYPE {
143
char *y_sym;
144
} YYSTYPE;
145
/* Line 191 of yacc.c. */
146
#line 147 "y.tab.c"
147
# define yystype YYSTYPE /* obsolescent; will be withdrawn */
148
# define YYSTYPE_IS_DECLARED 1
149
# define YYSTYPE_IS_TRIVIAL 1
150
#endif
151
152
153
154
/* Copy the second part of user declarations. */
155
156
157
/* Line 214 of yacc.c. */
158
#line 159 "y.tab.c"
159
160
#if ! defined (yyoverflow) || YYERROR_VERBOSE
161
162
/* The parser invokes alloca or malloc; define the necessary symbols. */
163
164
# if YYSTACK_USE_ALLOCA
165
# define YYSTACK_ALLOC alloca
166
# else
167
# ifndef YYSTACK_USE_ALLOCA
168
# if defined (alloca) || defined (_ALLOCA_H)
169
# define YYSTACK_ALLOC alloca
170
# else
171
# ifdef __GNUC__
172
# define YYSTACK_ALLOC __builtin_alloca
173
# endif
174
# endif
175
# endif
176
# endif
177
178
# ifdef YYSTACK_ALLOC
179
/* Pacify GCC's `empty if-body' warning. */
180
# define YYSTACK_FREE(Ptr) do { /* empty */; } while (0)
181
# else
182
# if defined (__STDC__) || defined (__cplusplus)
183
# include <stdlib.h> /* INFRINGES ON USER NAME SPACE */
184
# define YYSIZE_T size_t
185
# endif
186
# define YYSTACK_ALLOC malloc
187
# define YYSTACK_FREE free
188
# endif
189
#endif /* ! defined (yyoverflow) || YYERROR_VERBOSE */
190
191
192
#if (! defined (yyoverflow) \
193
&& (! defined (__cplusplus) \
194
|| (YYSTYPE_IS_TRIVIAL)))
195
196
/* A type that is properly aligned for any stack member. */
197
union yyalloc
198
{
199
short yyss;
200
YYSTYPE yyvs;
201
};
202
203
/* The size of the maximum gap between one aligned stack and the next. */
204
# define YYSTACK_GAP_MAXIMUM (sizeof (union yyalloc) - 1)
205
206
/* The size of an array large to enough to hold all stacks, each with
207
N elements. */
208
# define YYSTACK_BYTES(N) \
209
((N) * (sizeof (short) + sizeof (YYSTYPE)) \
210
+ YYSTACK_GAP_MAXIMUM)
211
212
/* Copy COUNT objects from FROM to TO. The source and destination do
213
not overlap. */
214
# ifndef YYCOPY
215
# if 1 < __GNUC__
216
# define YYCOPY(To, From, Count) \
217
__builtin_memcpy (To, From, (Count) * sizeof (*(From)))
218
# else
219
# define YYCOPY(To, From, Count) \
220
do \
221
{ \
222
register YYSIZE_T yyi; \
223
for (yyi = 0; yyi < (Count); yyi++) \
224
(To)[yyi] = (From)[yyi]; \
225
} \
226
while (0)
227
# endif
228
# endif
229
230
/* Relocate STACK from its old location to the new one. The
231
local variables YYSIZE and YYSTACKSIZE give the old and new number of
232
elements in the stack, and YYPTR gives the new location of the
233
stack. Advance YYPTR to a properly aligned location for the next
234
stack. */
235
# define YYSTACK_RELOCATE(Stack) \
236
do \
237
{ \
238
YYSIZE_T yynewbytes; \
239
YYCOPY (&yyptr->Stack, Stack, yysize); \
240
Stack = &yyptr->Stack; \
241
yynewbytes = yystacksize * sizeof (*Stack) + YYSTACK_GAP_MAXIMUM; \
242
yyptr += yynewbytes / sizeof (*yyptr); \
243
} \
244
while (0)
245
246
#endif
247
248
#if defined (__STDC__) || defined (__cplusplus)
249
typedef signed char yysigned_char;
250
#else
251
typedef short yysigned_char;
252
#endif
253
254
/* YYFINAL -- State number of the termination state. */
255
#define YYFINAL 3
256
/* YYLAST -- Last index in YYTABLE. */
257
#define YYLAST 117
258
259
/* YYNTOKENS -- Number of terminals. */
260
#define YYNTOKENS 36
261
/* YYNNTS -- Number of nonterminals. */
262
#define YYNNTS 53
263
/* YYNRULES -- Number of rules. */
264
#define YYNRULES 89
265
/* YYNRULES -- Number of states. */
266
#define YYNSTATES 155
267
268
/* YYTRANSLATE(YYLEX) -- Bison symbol number corresponding to YYLEX. */
269
#define YYUNDEFTOK 2
270
#define YYMAXUTOK 277
271
272
#define YYTRANSLATE(YYX) \
273
((unsigned int) (YYX) <= YYMAXUTOK ? yytranslate[YYX] : YYUNDEFTOK)
274
275
/* YYTRANSLATE[YYLEX] -- Bison symbol number corresponding to YYLEX. */
276
static const unsigned char yytranslate[] =
277
{
278
0, 2, 2, 2, 2, 2, 2, 2, 2, 2,
279
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
280
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
281
2, 2, 2, 2, 2, 2, 2, 33, 2, 2,
282
23, 24, 2, 2, 31, 2, 32, 2, 2, 2,
283
2, 2, 2, 2, 2, 2, 2, 2, 34, 35,
284
29, 2, 30, 2, 2, 2, 2, 2, 2, 2,
285
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
286
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
287
2, 25, 2, 26, 2, 2, 2, 2, 2, 2,
288
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
289
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
290
2, 2, 2, 27, 2, 28, 2, 2, 2, 2,
291
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
292
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
293
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
294
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
295
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
296
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
297
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
298
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
299
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
300
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
301
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
302
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
303
2, 2, 2, 2, 2, 2, 1, 2, 3, 4,
304
5, 6, 7, 8, 9, 10, 11, 12, 13, 14,
305
15, 16, 17, 18, 19, 20, 21, 22
306
};
307
308
#if YYDEBUG
309
/* YYPRHS[YYN] -- Index of the first RHS symbol of rule number YYN in
310
YYRHS. */
311
static const unsigned short yyprhs[] =
312
{
313
0, 0, 3, 4, 7, 10, 11, 14, 16, 18,
314
21, 24, 27, 30, 33, 36, 39, 42, 45, 49,
315
54, 55, 61, 64, 68, 69, 75, 76, 81, 84,
316
88, 89, 94, 95, 99, 101, 104, 106, 109, 113,
317
116, 118, 120, 121, 127, 130, 134, 135, 141, 146,
318
149, 153, 154, 158, 159, 166, 167, 173, 174, 183,
319
184, 188, 190, 194, 196, 200, 201, 211, 212, 214,
320
216, 218, 220, 222, 224, 226, 228, 232, 235, 239,
321
241, 245, 247, 248, 253, 255, 257, 259, 261, 263
322
};
323
324
/* YYRHS -- A `-1'-separated list of the rules' RHS. */
325
static const yysigned_char yyrhs[] =
326
{
327
37, 0, -1, -1, 38, 39, -1, 40, 42, -1,
328
-1, 40, 41, -1, 12, -1, 13, -1, 14, 15,
329
-1, 14, 16, -1, 14, 17, -1, 14, 18, -1,
330
14, 19, -1, 14, 20, -1, 14, 21, -1, 14,
331
22, -1, 43, 68, -1, 43, 57, 68, -1, 43,
332
57, 66, 68, -1, -1, 6, 34, 44, 45, 88,
333
-1, 46, 85, -1, 45, 46, 85, -1, -1, 83,
334
34, 47, 48, 82, -1, -1, 23, 50, 49, 84,
335
-1, 31, 50, -1, 49, 31, 50, -1, -1, 83,
336
51, 52, 82, -1, -1, 25, 53, 87, -1, 55,
337
-1, 55, 54, -1, 54, -1, 54, 55, -1, 56,
338
11, 56, -1, 55, 56, -1, 56, -1, 5, -1,
339
-1, 7, 34, 58, 59, 88, -1, 60, 85, -1,
340
59, 60, 85, -1, -1, 83, 34, 61, 62, 82,
341
-1, 23, 64, 63, 84, -1, 31, 64, -1, 63,
342
31, 64, -1, -1, 83, 65, 82, -1, -1, 8,
343
34, 67, 60, 85, 88, -1, -1, 9, 34, 69,
344
70, 88, -1, -1, 83, 34, 71, 72, 23, 74,
345
84, 85, -1, -1, 27, 73, 86, -1, 83, -1,
346
73, 31, 83, -1, 75, -1, 74, 31, 75, -1,
347
-1, 83, 76, 77, 78, 25, 80, 79, 35, 87,
348
-1, -1, 15, -1, 16, -1, 17, -1, 18, -1,
349
19, -1, 20, -1, 21, -1, 22, -1, 29, 5,
350
30, -1, 35, 80, -1, 79, 35, 80, -1, 81,
351
-1, 80, 31, 81, -1, 5, -1, -1, 27, 10,
352
4, 86, -1, 3, -1, 24, -1, 32, -1, 28,
353
-1, 26, -1, 33, -1
354
};
355
356
/* YYRLINE[YYN] -- source line where rule number YYN was defined. */
357
static const unsigned short yyrline[] =
358
{
359
0, 80, 80, 80, 88, 90, 92, 95, 100, 106,
360
116, 126, 136, 146, 156, 166, 176, 188, 189, 190,
361
194, 194, 204, 205, 208, 208, 221, 223, 226, 227,
362
230, 230, 240, 242, 251, 252, 254, 255, 260, 264,
363
266, 269, 273, 273, 283, 284, 287, 287, 300, 303,
364
304, 307, 307, 318, 318, 329, 329, 340, 340, 350,
365
352, 355, 358, 365, 366, 369, 369, 380, 382, 392,
366
402, 412, 422, 432, 442, 452, 464, 471, 476, 483,
367
487, 494, 497, 498, 502, 504, 505, 506, 507, 508
368
};
369
#endif
370
371
#if YYDEBUG || YYERROR_VERBOSE
372
/* YYTNME[SYMBOL-NUM] -- String name of the symbol SYMBOL-NUM.
373
First, the terminals, then, starting at YYNTOKENS, nonterminals. */
374
static const char *const yytname[] =
375
{
376
"$end", "error", "$undefined", "Identifier", "String", "Constant",
377
"LAYER", "CONTEXT", "SUBJECTIVE", "INFERRED", "QUESTION", "THRU",
378
"NO_COMBINED_MAP", "NO_PROBABILITY_MAPS", "COMBINED_MAP", "ASPECT",
379
"GREY", "HISTO", "RAINBOW", "RAMP", "RANDOM", "REDYELLOWGREEN", "WAVE",
380
"'('", "')'", "'['", "']'", "'{'", "'}'", "'<'", "'>'", "','", "'.'",
381
"'%'", "':'", "';'", "$accept", "Program", "@1", "Script",
382
"Output_Options", "Output_Option", "MainScript", "Layer_Section", "@2",
383
"Layer_Att_Declarations", "Layer_Att_Declaration", "@3",
384
"Layer_Value_List", "Layer_Value_Sublist", "Layer_Value", "@4",
385
"Category_Range", "Reclass_Rule", "Input_Cat_Range", "Input_Cat_List",
386
"Input_Cat", "Context_Section", "@5", "Context_Att_Declarations",
387
"Context_Att_Declaration", "@6", "Context_Value_List",
388
"Context_Value_Sublist", "Context_Value", "@7", "Subjective_Section",
389
"@8", "Inferred_Section", "@9", "Inferred_Att_Declaration", "@10",
390
"Determinant_List", "Att_List", "Inferred_Value_List", "Inferred_Value",
391
"@11", "Optional_Color_Table", "Prior_Probability",
392
"Conditional_Probability_Table", "Probability_List", "Probability",
393
"Question_Attachment", "Name", "rp", "ep", "rb", "rbr", "end", 0
394
};
395
#endif
396
397
# ifdef YYPRINT
398
/* YYTOKNUM[YYLEX-NUM] -- Internal token number corresponding to
399
token YYLEX-NUM. */
400
static const unsigned short yytoknum[] =
401
{
402
0, 256, 257, 258, 259, 260, 261, 262, 263, 264,
403
265, 266, 267, 268, 269, 270, 271, 272, 273, 274,
404
275, 276, 277, 40, 41, 91, 93, 123, 125, 60,
405
62, 44, 46, 37, 58, 59
406
};
407
# endif
408
409
/* YYR1[YYN] -- Symbol number of symbol that rule YYN derives. */
410
static const unsigned char yyr1[] =
411
{
412
0, 36, 38, 37, 39, 40, 40, 41, 41, 41,
413
41, 41, 41, 41, 41, 41, 41, 42, 42, 42,
414
44, 43, 45, 45, 47, 46, 48, 48, 49, 49,
415
51, 50, 52, 52, 53, 53, 53, 53, 54, 55,
416
55, 56, 58, 57, 59, 59, 61, 60, 62, 63,
417
63, 65, 64, 67, 66, 69, 68, 71, 70, 72,
418
72, 73, 73, 74, 74, 76, 75, 77, 77, 77,
419
77, 77, 77, 77, 77, 77, 78, 79, 79, 80,
420
80, 81, 82, 82, 83, 84, 85, 86, 87, 88
421
};
422
423
/* YYR2[YYN] -- Number of symbols composing right hand side of rule YYN. */
424
static const unsigned char yyr2[] =
425
{
426
0, 2, 0, 2, 2, 0, 2, 1, 1, 2,
427
2, 2, 2, 2, 2, 2, 2, 2, 3, 4,
428
0, 5, 2, 3, 0, 5, 0, 4, 2, 3,
429
0, 4, 0, 3, 1, 2, 1, 2, 3, 2,
430
1, 1, 0, 5, 2, 3, 0, 5, 4, 2,
431
3, 0, 3, 0, 6, 0, 5, 0, 8, 0,
432
3, 1, 3, 1, 3, 0, 9, 0, 1, 1,
433
1, 1, 1, 1, 1, 1, 3, 2, 3, 1,
434
3, 1, 0, 4, 1, 1, 1, 1, 1, 1
435
};
436
437
/* YYDEFACT[STATE-NAME] -- Default rule to reduce with in state
438
STATE-NUM when YYTABLE doesn't specify something else to do. Zero
439
means the default is an error. */
440
static const unsigned char yydefact[] =
441
{
442
2, 0, 5, 1, 3, 0, 0, 7, 8, 0,
443
6, 4, 0, 20, 9, 10, 11, 12, 13, 14,
444
15, 16, 0, 0, 0, 17, 0, 42, 55, 0,
445
0, 18, 84, 0, 0, 0, 0, 0, 53, 19,
446
89, 0, 21, 86, 22, 24, 0, 0, 0, 0,
447
0, 0, 23, 26, 0, 43, 44, 46, 56, 57,
448
0, 0, 82, 45, 0, 59, 0, 0, 30, 0,
449
25, 0, 82, 0, 0, 54, 0, 0, 32, 0,
450
0, 51, 47, 0, 61, 0, 28, 85, 0, 27,
451
0, 82, 0, 0, 0, 82, 87, 0, 60, 0,
452
63, 65, 29, 41, 0, 36, 34, 40, 31, 83,
453
49, 0, 48, 52, 62, 0, 0, 67, 88, 33,
454
37, 40, 35, 39, 0, 50, 64, 58, 68, 69,
455
70, 71, 72, 73, 74, 75, 0, 39, 38, 0,
456
0, 0, 0, 76, 81, 0, 79, 0, 0, 0,
457
80, 77, 0, 78, 66
458
};
459
460
/* YYDEFGOTO[NTERM-NUM]. */
461
static const short yydefgoto[] =
462
{
463
-1, 1, 2, 4, 5, 10, 11, 12, 26, 33,
464
34, 53, 62, 77, 67, 78, 91, 104, 105, 106,
465
107, 24, 36, 46, 47, 64, 72, 94, 80, 95,
466
30, 51, 25, 37, 49, 65, 74, 83, 99, 100,
467
117, 136, 140, 149, 145, 146, 70, 48, 89, 44,
468
98, 119, 42
469
};
470
471
/* YYPACT[STATE-NUM] -- Index in YYTABLE of the portion describing
472
STATE-NUM. */
473
#define YYPACT_NINF -101
474
static const yysigned_char yypact[] =
475
{
476
-101, 33, -101, -101, -101, 26, 15, -101, -101, 36,
477
-101, -101, 54, -101, -101, -101, -101, -101, -101, -101,
478
-101, -101, 34, 35, 57, -101, 67, -101, -101, 38,
479
64, -101, -101, -2, 42, 41, 67, 67, -101, -101,
480
-101, 42, -101, -101, -101, -101, -2, 42, 44, 43,
481
45, 67, -101, 58, 42, -101, -101, -101, -101, -101,
482
42, 67, 53, -101, 59, 56, 43, 55, -101, 74,
483
-101, 67, 53, 67, 65, -101, 67, -8, 62, 94,
484
68, -101, -101, -14, -101, 67, -101, -101, 67, -101,
485
95, 53, 73, 67, 3, 53, -101, 67, -101, 12,
486
-101, -101, -101, -101, 76, 95, 95, 92, -101, -101,
487
-101, 67, -101, -101, -101, 67, 42, 75, -101, -101,
488
95, -101, -101, 92, 95, -101, -101, -101, -101, -101,
489
-101, -101, -101, -101, -101, -101, 77, -101, -101, 99,
490
80, 78, 102, -101, -101, 13, -101, 102, 102, 79,
491
-101, 81, -1, 81, -101
492
};
493
494
/* YYPGOTO[NTERM-NUM]. */
495
static const yysigned_char yypgoto[] =
496
{
497
-101, -101, -101, -101, -101, -101, -101, -101, -101, -101,
498
82, -101, -101, -101, -58, -101, -101, -101, 4, 6,
499
-100, -101, -101, -101, -9, -101, -101, -101, -83, -101,
500
-101, -101, -11, -101, -101, -101, -101, -101, -101, -6,
501
-101, -101, -101, -101, -88, -34, -69, -26, -53, -39,
502
24, -35, -37
503
};
504
505
/* YYTABLE[YYPACT[STATE-NUM]]. What to do in state STATE-NUM. If
506
positive, shift that token. If negative, reduce the rule which
507
number is the opposite. If zero, do what YYDEFACT says.
508
If YYTABLE_NINF, syntax error. */
509
#define YYTABLE_NINF -1
510
static const unsigned char yytable[] =
511
{
512
35, 32, 52, 82, 144, 121, 123, 35, 56, 55,
513
110, 50, 58, 31, 96, 63, 87, 97, 86, 39,
514
137, 66, 108, 88, 138, 118, 113, 87, 125, 75,
515
102, 40, 6, 3, 111, 68, 87, 54, 7, 8,
516
9, 112, 60, 115, 147, 81, 116, 84, 148, 13,
517
68, 14, 15, 16, 17, 18, 19, 20, 21, 101,
518
151, 22, 68, 23, 153, 29, 23, 81, 27, 28,
519
32, 114, 38, 23, 43, 45, 40, 127, 57, 59,
520
69, 61, 71, 73, 79, 81, 76, 90, 85, 101,
521
128, 129, 130, 131, 132, 133, 134, 135, 92, 93,
522
103, 96, 118, 124, 141, 142, 139, 144, 143, 126,
523
122, 120, 147, 150, 152, 41, 109, 154
524
};
525
526
static const unsigned char yycheck[] =
527
{
528
26, 3, 41, 72, 5, 105, 106, 33, 47, 46,
529
93, 37, 49, 24, 28, 54, 24, 31, 76, 30,
530
120, 60, 91, 31, 124, 26, 95, 24, 111, 66,
531
88, 33, 6, 0, 31, 61, 24, 46, 12, 13,
532
14, 94, 51, 31, 31, 71, 99, 73, 35, 34,
533
76, 15, 16, 17, 18, 19, 20, 21, 22, 85,
534
148, 7, 88, 9, 152, 8, 9, 93, 34, 34,
535
3, 97, 34, 9, 32, 34, 33, 116, 34, 34,
536
27, 23, 23, 27, 10, 111, 31, 25, 23, 115,
537
15, 16, 17, 18, 19, 20, 21, 22, 4, 31,
538
5, 28, 26, 11, 5, 25, 29, 5, 30, 115,
539
106, 105, 31, 147, 35, 33, 92, 152
540
};
541
542
/* YYSTOS[STATE-NUM] -- The (internal number of the) accessing
543
symbol of state STATE-NUM. */
544
static const unsigned char yystos[] =
545
{
546
0, 37, 38, 0, 39, 40, 6, 12, 13, 14,
547
41, 42, 43, 34, 15, 16, 17, 18, 19, 20,
548
21, 22, 7, 9, 57, 68, 44, 34, 34, 8,
549
66, 68, 3, 45, 46, 83, 58, 69, 34, 68,
550
33, 46, 88, 32, 85, 34, 59, 60, 83, 70,
551
83, 67, 85, 47, 60, 88, 85, 34, 88, 34,
552
60, 23, 48, 85, 61, 71, 85, 50, 83, 27,
553
82, 23, 62, 27, 72, 88, 31, 49, 51, 10,
554
64, 83, 82, 73, 83, 23, 50, 24, 31, 84,
555
25, 52, 4, 31, 63, 65, 28, 31, 86, 74,
556
75, 83, 50, 5, 53, 54, 55, 56, 82, 86,
557
64, 31, 84, 82, 83, 31, 84, 76, 26, 87,
558
55, 56, 54, 56, 11, 64, 75, 85, 15, 16,
559
17, 18, 19, 20, 21, 22, 77, 56, 56, 29,
560
78, 5, 25, 30, 5, 80, 81, 31, 35, 79,
561
81, 80, 35, 80, 87
562
};
563
564
#if ! defined (YYSIZE_T) && defined (__SIZE_TYPE__)
565
# define YYSIZE_T __SIZE_TYPE__
566
#endif
567
#if ! defined (YYSIZE_T) && defined (size_t)
568
# define YYSIZE_T size_t
569
#endif
570
#if ! defined (YYSIZE_T)
571
# if defined (__STDC__) || defined (__cplusplus)
572
# include <stddef.h> /* INFRINGES ON USER NAME SPACE */
573
# define YYSIZE_T size_t
574
# endif
575
#endif
576
#if ! defined (YYSIZE_T)
577
# define YYSIZE_T unsigned int
578
#endif
579
580
#define yyerrok (yyerrstatus = 0)
581
#define yyclearin (yychar = YYEMPTY)
582
#define YYEMPTY (-2)
583
#define YYEOF 0
584
585
#define YYACCEPT goto yyacceptlab
586
#define YYABORT goto yyabortlab
587
#define YYERROR goto yyerrlab1
588
589
590
/* Like YYERROR except do call yyerror. This remains here temporarily
591
to ease the transition to the new meaning of YYERROR, for GCC.
592
Once GCC version 2 has supplanted version 1, this can go. */
593
594
#define YYFAIL goto yyerrlab
595
596
#define YYRECOVERING() (!!yyerrstatus)
597
598
#define YYBACKUP(Token, Value) \
599
do \
600
if (yychar == YYEMPTY && yylen == 1) \
601
{ \
602
yychar = (Token); \
603
yylval = (Value); \
604
yytoken = YYTRANSLATE (yychar); \
605
YYPOPSTACK; \
606
goto yybackup; \
607
} \
608
else \
609
{ \
610
yyerror ("syntax error: cannot back up");\
611
YYERROR; \
612
} \
613
while (0)
614
615
#define YYTERROR 1
616
#define YYERRCODE 256
617
618
/* YYLLOC_DEFAULT -- Compute the default location (before the actions
619
are run). */
620
621
#ifndef YYLLOC_DEFAULT
622
# define YYLLOC_DEFAULT(Current, Rhs, N) \
623
Current.first_line = Rhs[1].first_line; \
624
Current.first_column = Rhs[1].first_column; \
625
Current.last_line = Rhs[N].last_line; \
626
Current.last_column = Rhs[N].last_column;
627
#endif
628
629
/* YYLEX -- calling `yylex' with the right arguments. */
630
631
#ifdef YYLEX_PARAM
632
# define YYLEX yylex (YYLEX_PARAM)
633
#else
634
# define YYLEX yylex ()
635
#endif
636
637
/* Enable debugging if requested. */
638
#if YYDEBUG
639
640
# ifndef YYFPRINTF
641
# include <stdio.h> /* INFRINGES ON USER NAME SPACE */
642
# define YYFPRINTF fprintf
643
# endif
644
645
# define YYDPRINTF(Args) \
646
do { \
647
if (yydebug) \
648
YYFPRINTF Args; \
649
} while (0)
650
651
# define YYDSYMPRINT(Args) \
652
do { \
653
if (yydebug) \
654
yysymprint Args; \
655
} while (0)
656
657
# define YYDSYMPRINTF(Title, Token, Value, Location) \
658
do { \
659
if (yydebug) \
660
{ \
661
YYFPRINTF (stderr, "%s ", Title); \
662
yysymprint (stderr, \
663
Token, Value); \
664
YYFPRINTF (stderr, "\n"); \
665
} \
666
} while (0)
667
668
/*------------------------------------------------------------------.
669
| yy_stack_print -- Print the state stack from its BOTTOM up to its |
670
| TOP (cinluded). |
671
`------------------------------------------------------------------*/
672
673
#if defined (__STDC__) || defined (__cplusplus)
674
static void
675
yy_stack_print (short *bottom, short *top)
676
#else
677
static void
678
yy_stack_print (bottom, top)
679
short *bottom;
680
short *top;
681
#endif
682
{
683
YYFPRINTF (stderr, "Stack now");
684
for (/* Nothing. */; bottom <= top; ++bottom)
685
YYFPRINTF (stderr, " %d", *bottom);
686
YYFPRINTF (stderr, "\n");
687
}
688
689
# define YY_STACK_PRINT(Bottom, Top) \
690
do { \
691
if (yydebug) \
692
yy_stack_print ((Bottom), (Top)); \
693
} while (0)
694
695
696
/*------------------------------------------------.
697
| Report that the YYRULE is going to be reduced. |
698
`------------------------------------------------*/
699
700
#if defined (__STDC__) || defined (__cplusplus)
701
static void
702
yy_reduce_print (int yyrule)
703
#else
704
static void
705
yy_reduce_print (yyrule)
706
int yyrule;
707
#endif
708
{
709
int yyi;
710
unsigned int yylineno = yyrline[yyrule];
711
YYFPRINTF (stderr, "Reducing stack by rule %d (line %u), ",
712
yyrule - 1, yylineno);
713
/* Print the symbols being reduced, and their result. */
714
for (yyi = yyprhs[yyrule]; 0 <= yyrhs[yyi]; yyi++)
715
YYFPRINTF (stderr, "%s ", yytname [yyrhs[yyi]]);
716
YYFPRINTF (stderr, "-> %s\n", yytname [yyr1[yyrule]]);
717
}
718
719
# define YY_REDUCE_PRINT(Rule) \
720
do { \
721
if (yydebug) \
722
yy_reduce_print (Rule); \
723
} while (0)
724
725
/* Nonzero means print parse trace. It is left uninitialized so that
726
multiple parsers can coexist. */
727
int yydebug;
728
#else /* !YYDEBUG */
729
# define YYDPRINTF(Args)
730
# define YYDSYMPRINT(Args)
731
# define YYDSYMPRINTF(Title, Token, Value, Location)
732
# define YY_STACK_PRINT(Bottom, Top)
733
# define YY_REDUCE_PRINT(Rule)
734
#endif /* !YYDEBUG */
735
736
737
/* YYINITDEPTH -- initial size of the parser's stacks. */
738
#ifndef YYINITDEPTH
739
# define YYINITDEPTH 200
740
#endif
741
742
/* YYMAXDEPTH -- maximum size the stacks can grow to (effective only
743
if the built-in stack extension method is used).
744
745
Do not make this value too large; the results are undefined if
746
SIZE_MAX < YYSTACK_BYTES (YYMAXDEPTH)
747
evaluated with infinite-precision integer arithmetic. */
748
749
#if YYMAXDEPTH == 0
750
# undef YYMAXDEPTH
751
#endif
752
753
#ifndef YYMAXDEPTH
754
# define YYMAXDEPTH 10000
755
#endif
756
757
758
759
#if YYERROR_VERBOSE
760
761
# ifndef yystrlen
762
# if defined (__GLIBC__) && defined (_STRING_H)
763
# define yystrlen strlen
764
# else
765
/* Return the length of YYSTR. */
766
static YYSIZE_T
767
# if defined (__STDC__) || defined (__cplusplus)
768
yystrlen (const char *yystr)
769
# else
770
yystrlen (yystr)
771
const char *yystr;
772
# endif
773
{
774
register const char *yys = yystr;
775
776
while (*yys++ != '\0')
777
continue;
778
779
return yys - yystr - 1;
780
}
781
# endif
782
# endif
783
784
# ifndef yystpcpy
785
# if defined (__GLIBC__) && defined (_STRING_H) && defined (_GNU_SOURCE)
786
# define yystpcpy stpcpy
787
# else
788
/* Copy YYSRC to YYDEST, returning the address of the terminating '\0' in
789
YYDEST. */
790
static char *
791
# if defined (__STDC__) || defined (__cplusplus)
792
yystpcpy (char *yydest, const char *yysrc)
793
# else
794
yystpcpy (yydest, yysrc)
795
char *yydest;
796
const char *yysrc;
797
# endif
798
{
799
register char *yyd = yydest;
800
register const char *yys = yysrc;
801
802
while ((*yyd++ = *yys++) != '\0')
803
continue;
804
805
return yyd - 1;
806
}
807
# endif
808
# endif
809
810
#endif /* !YYERROR_VERBOSE */
811
812
813
814
#if YYDEBUG
815
/*--------------------------------.
816
| Print this symbol on YYOUTPUT. |
817
`--------------------------------*/
818
819
#if defined (__STDC__) || defined (__cplusplus)
820
static void
821
yysymprint (FILE *yyoutput, int yytype, YYSTYPE *yyvaluep)
822
#else
823
static void
824
yysymprint (yyoutput, yytype, yyvaluep)
825
FILE *yyoutput;
826
int yytype;
827
YYSTYPE *yyvaluep;
828
#endif
829
{
830
/* Pacify ``unused variable'' warnings. */
831
(void) yyvaluep;
832
833
if (yytype < YYNTOKENS)
834
{
835
YYFPRINTF (yyoutput, "token %s (", yytname[yytype]);
836
# ifdef YYPRINT
837
YYPRINT (yyoutput, yytoknum[yytype], *yyvaluep);
838
# endif
839
}
840
else
841
YYFPRINTF (yyoutput, "nterm %s (", yytname[yytype]);
842
843
switch (yytype)
844
{
845
default:
846
break;
847
}
848
YYFPRINTF (yyoutput, ")");
849
}
850
851
#endif /* ! YYDEBUG */
852
/*-----------------------------------------------.
853
| Release the memory associated to this symbol. |
854
`-----------------------------------------------*/
855
856
#if defined (__STDC__) || defined (__cplusplus)
857
static void
858
yydestruct (int yytype, YYSTYPE *yyvaluep)
859
#else
860
static void
861
yydestruct (yytype, yyvaluep)
862
int yytype;
863
YYSTYPE *yyvaluep;
864
#endif
865
{
866
/* Pacify ``unused variable'' warnings. */
867
(void) yyvaluep;
868
869
switch (yytype)
870
{
871
872
default:
873
break;
874
}
875
}
876
877
878
/* Prevent warnings from -Wmissing-prototypes. */
879
880
#ifdef YYPARSE_PARAM
881
# if defined (__STDC__) || defined (__cplusplus)
882
int yyparse (void *YYPARSE_PARAM);
883
# else
884
int yyparse ();
885
# endif
886
#else /* ! YYPARSE_PARAM */
887
#if defined (__STDC__) || defined (__cplusplus)
888
int yyparse (void);
889
#else
890
int yyparse ();
891
#endif
892
#endif /* ! YYPARSE_PARAM */
893
894
895
896
/* The lookahead symbol. */
897
int yychar;
898
899
/* The semantic value of the lookahead symbol. */
900
YYSTYPE yylval;
901
902
/* Number of syntax errors so far. */
903
int yynerrs;
904
905
906
907
/*----------.
908
| yyparse. |
909
`----------*/
910
911
#ifdef YYPARSE_PARAM
912
# if defined (__STDC__) || defined (__cplusplus)
913
int yyparse (void *YYPARSE_PARAM)
914
# else
915
int yyparse (YYPARSE_PARAM)
916
void *YYPARSE_PARAM;
917
# endif
918
#else /* ! YYPARSE_PARAM */
919
#if defined (__STDC__) || defined (__cplusplus)
920
int
921
yyparse (void)
922
#else
923
int
924
yyparse ()
925
926
#endif
927
#endif
928
{
929
930
register int yystate;
931
register int yyn;
932
int yyresult;
933
/* Number of tokens to shift before error messages enabled. */
934
int yyerrstatus;
935
/* Lookahead token as an internal (translated) token number. */
936
int yytoken = 0;
937
938
/* Three stacks and their tools:
939
`yyss': related to states,
940
`yyvs': related to semantic values,
941
`yyls': related to locations.
942
943
Refer to the stacks thru separate pointers, to allow yyoverflow
944
to reallocate them elsewhere. */
945
946
/* The state stack. */
947
short yyssa[YYINITDEPTH];
948
short *yyss = yyssa;
949
register short *yyssp;
950
951
/* The semantic value stack. */
952
YYSTYPE yyvsa[YYINITDEPTH];
953
YYSTYPE *yyvs = yyvsa;
954
register YYSTYPE *yyvsp;
955
956
957
958
#define YYPOPSTACK (yyvsp--, yyssp--)
959
960
YYSIZE_T yystacksize = YYINITDEPTH;
961
962
/* The variables used to return semantic value and location from the
963
action routines. */
964
YYSTYPE yyval;
965
966
967
/* When reducing, the number of symbols on the RHS of the reduced
968
rule. */
969
int yylen;
970
971
YYDPRINTF ((stderr, "Starting parse\n"));
972
973
yystate = 0;
974
yyerrstatus = 0;
975
yynerrs = 0;
976
yychar = YYEMPTY; /* Cause a token to be read. */
977
978
/* Initialize stack pointers.
979
Waste one element of value and location stack
980
so that they stay on the same level as the state stack.
981
The wasted elements are never initialized. */
982
983
yyssp = yyss;
984
yyvsp = yyvs;
985
986
goto yysetstate;
987
988
/*------------------------------------------------------------.
989
| yynewstate -- Push a new state, which is found in yystate. |
990
`------------------------------------------------------------*/
991
yynewstate:
992
/* In all cases, when you get here, the value and location stacks
993
have just been pushed. so pushing a state here evens the stacks.
994
*/
995
yyssp++;
996
997
yysetstate:
998
*yyssp = yystate;
999
1000
if (yyss + yystacksize - 1 <= yyssp)
1001
{
1002
/* Get the current used size of the three stacks, in elements. */
1003
YYSIZE_T yysize = yyssp - yyss + 1;
1004
1005
#ifdef yyoverflow
1006
{
1007
/* Give user a chance to reallocate the stack. Use copies of
1008
these so that the &'s don't force the real ones into
1009
memory. */
1010
YYSTYPE *yyvs1 = yyvs;
1011
short *yyss1 = yyss;
1012
1013
1014
/* Each stack pointer address is followed by the size of the
1015
data in use in that stack, in bytes. This used to be a
1016
conditional around just the two extra args, but that might
1017
be undefined if yyoverflow is a macro. */
1018
yyoverflow ("parser stack overflow",
1019
&yyss1, yysize * sizeof (*yyssp),
1020
&yyvs1, yysize * sizeof (*yyvsp),
1021
1022
&yystacksize);
1023
1024
yyss = yyss1;
1025
yyvs = yyvs1;
1026
}
1027
#else /* no yyoverflow */
1028
# ifndef YYSTACK_RELOCATE
1029
goto yyoverflowlab;
1030
# else
1031
/* Extend the stack our own way. */
1032
if (YYMAXDEPTH <= yystacksize)
1033
goto yyoverflowlab;
1034
yystacksize *= 2;
1035
if (YYMAXDEPTH < yystacksize)
1036
yystacksize = YYMAXDEPTH;
1037
1038
{
1039
short *yyss1 = yyss;
1040
union yyalloc *yyptr =
1041
(union yyalloc *) YYSTACK_ALLOC (YYSTACK_BYTES (yystacksize));
1042
if (! yyptr)
1043
goto yyoverflowlab;
1044
YYSTACK_RELOCATE (yyss);
1045
YYSTACK_RELOCATE (yyvs);
1046
1047
# undef YYSTACK_RELOCATE
1048
if (yyss1 != yyssa)
1049
YYSTACK_FREE (yyss1);
1050
}
1051
# endif
1052
#endif /* no yyoverflow */
1053
1054
yyssp = yyss + yysize - 1;
1055
yyvsp = yyvs + yysize - 1;
1056
1057
1058
YYDPRINTF ((stderr, "Stack size increased to %lu\n",
1059
(unsigned long int) yystacksize));
1060
1061
if (yyss + yystacksize - 1 <= yyssp)
1062
YYABORT;
1063
}
1064
1065
YYDPRINTF ((stderr, "Entering state %d\n", yystate));
1066
1067
goto yybackup;
1068
1069
/*-----------.
1070
| yybackup. |
1071
`-----------*/
1072
yybackup:
1073
1074
/* Do appropriate processing given the current state. */
1075
/* Read a lookahead token if we need one and don't already have one. */
1076
/* yyresume: */
1077
1078
/* First try to decide what to do without reference to lookahead token. */
1079
1080
yyn = yypact[yystate];
1081
if (yyn == YYPACT_NINF)
1082
goto yydefault;
1083
1084
/* Not known => get a lookahead token if don't already have one. */
1085
1086
/* YYCHAR is either YYEMPTY or YYEOF or a valid lookahead symbol. */
1087
if (yychar == YYEMPTY)
1088
{
1089
YYDPRINTF ((stderr, "Reading a token: "));
1090
yychar = YYLEX;
1091
}
1092
1093
if (yychar <= YYEOF)
1094
{
1095
yychar = yytoken = YYEOF;
1096
YYDPRINTF ((stderr, "Now at end of input.\n"));
1097
}
1098
else
1099
{
1100
yytoken = YYTRANSLATE (yychar);
1101
YYDSYMPRINTF ("Next token is", yytoken, &yylval, &yylloc);
1102
}
1103
1104
/* If the proper action on seeing token YYTOKEN is to reduce or to
1105
detect an error, take that action. */
1106
yyn += yytoken;
1107
if (yyn < 0 || YYLAST < yyn || yycheck[yyn] != yytoken)
1108
goto yydefault;
1109
yyn = yytable[yyn];
1110
if (yyn <= 0)
1111
{
1112
if (yyn == 0 || yyn == YYTABLE_NINF)
1113
goto yyerrlab;
1114
yyn = -yyn;
1115
goto yyreduce;
1116
}
1117
1118
if (yyn == YYFINAL)
1119
YYACCEPT;
1120
1121
/* Shift the lookahead token. */
1122
YYDPRINTF ((stderr, "Shifting token %s, ", yytname[yytoken]));
1123
1124
/* Discard the token being shifted unless it is eof. */
1125
if (yychar != YYEOF)
1126
yychar = YYEMPTY;
1127
1128
*++yyvsp = yylval;
1129
1130
1131
/* Count tokens shifted since error; after three, turn off error
1132
status. */
1133
if (yyerrstatus)
1134
yyerrstatus--;
1135
1136
yystate = yyn;
1137
goto yynewstate;
1138
1139
1140
/*-----------------------------------------------------------.
1141
| yydefault -- do the default action for the current state. |
1142
`-----------------------------------------------------------*/
1143
yydefault:
1144
yyn = yydefact[yystate];
1145
if (yyn == 0)
1146
goto yyerrlab;
1147
goto yyreduce;
1148
1149
1150
/*-----------------------------.
1151
| yyreduce -- Do a reduction. |
1152
`-----------------------------*/
1153
yyreduce:
1154
/* yyn is the number of a rule to reduce with. */
1155
yylen = yyr2[yyn];
1156
1157
/* If YYLEN is nonzero, implement the default value of the action:
1158
`$$ = $1'.
1159
1160
Otherwise, the following line sets YYVAL to garbage.
1161
This behavior is undocumented and Bison
1162
users should not rely upon it. Assigning to YYVAL
1163
unconditionally makes the parser a bit smaller, and it avoids a
1164
GCC warning that YYVAL may be used uninitialized. */
1165
yyval = yyvsp[1-yylen];
1166
1167
1168
YY_REDUCE_PRINT (yyn);
1169
switch (yyn)
1170
{
1171
case 2:
1172
#line 80 "binfer.y"
1173
{ init(); }
1174
break;
1175
1176
case 3:
1177
#line 81 "binfer.y"
1178
{
1179
check_table(&table,verbose);
1180
if ( verbose ) fprintf(stderr,"\nAll input parsed.\n");
1181
return(-1);
1182
}
1183
break;
1184
1185
case 7:
1186
#line 95 "binfer.y"
1187
{
1188
combinedmap = 0;
1189
fprintf(stderr,"NoCombinedMap option set.\n");
1190
}
1191
break;
1192
1193
case 8:
1194
#line 101 "binfer.y"
1195
{
1196
probabilitymaps = 0;
1197
fprintf(stderr,"NoProbabiltyMaps option set.\n");
1198
}
1199
break;
1200
1201
case 9:
1202
#line 107 "binfer.y"
1203
{
1204
if ( combinedmap ) {
1205
colortable = AspectColors;
1206
fprintf(stderr,"Combined map colortable set to aspect colors.\n");
1207
} else {
1208
fprintf(stderr,"Warning: Combined map colortable not set.\n");
1209
fprintf(stderr,"NoCombinedMap option is set.\n");
1210
}
1211
}
1212
break;
1213
1214
case 10:
1215
#line 117 "binfer.y"
1216
{
1217
if ( combinedmap ) {
1218
colortable = GreyScale;
1219
fprintf(stderr,"Combined map colortable set to grey scale.\n");
1220
} else {
1221
fprintf(stderr,"Warning: Combined map colortable not set.\n");
1222
fprintf(stderr,"NoCombinedMap option is set.\n");
1223
}
1224
}
1225
break;
1226
1227
case 11:
1228
#line 127 "binfer.y"
1229
{
1230
if ( combinedmap ) {
1231
colortable = HistoGreyScale;
1232
fprintf(stderr,"Combined map colortable set to histogram stretched grey scale.\n");
1233
} else {
1234
fprintf(stderr,"Warning: Combined map colortable not set.\n");
1235
fprintf(stderr,"NoCombinedMap option is set.\n");
1236
}
1237
}
1238
break;
1239
1240
case 12:
1241
#line 137 "binfer.y"
1242
{
1243
if ( combinedmap ) {
1244
colortable = Rainbow;
1245
fprintf(stderr,"Combined map colortable set to rainbow colors.\n");
1246
} else {
1247
fprintf(stderr,"Warning: Combined map colortable not set.\n");
1248
fprintf(stderr,"NoCombinedMap option is set.\n");
1249
}
1250
}
1251
break;
1252
1253
case 13:
1254
#line 147 "binfer.y"
1255
{
1256
if ( combinedmap ) {
1257
colortable = Ramp;
1258
fprintf(stderr,"Combined map colortable set to color ramp.\n");
1259
} else {
1260
fprintf(stderr,"Warning: Combined map colortable not set.\n");
1261
fprintf(stderr,"NoCombinedMap option is set.\n");
1262
}
1263
}
1264
break;
1265
1266
case 14:
1267
#line 157 "binfer.y"
1268
{
1269
if ( combinedmap ) {
1270
colortable = Random;
1271
fprintf(stderr,"Combined map colortable set to random colors.\n");
1272
} else {
1273
fprintf(stderr,"Warning: Combined map colortable not set.\n");
1274
fprintf(stderr,"NoCombinedMap option is set.\n");
1275
}
1276
}
1277
break;
1278
1279
case 15:
1280
#line 167 "binfer.y"
1281
{
1282
if ( combinedmap ) {
1283
colortable = RYG;
1284
fprintf(stderr,"Combined map colortable set to red yellow green.\n");
1285
} else {
1286
fprintf(stderr,"Warning: Combined map colortable not set.\n");
1287
fprintf(stderr,"NoCombinedMap option is set.\n");
1288
}
1289
}
1290
break;
1291
1292
case 16:
1293
#line 177 "binfer.y"
1294
{
1295
if ( combinedmap ) {
1296
colortable = Wave;
1297
fprintf(stderr,"Combined map colortable set to color wave.\n");
1298
} else {
1299
fprintf(stderr,"Warning: Combined map colortable not set.\n");
1300
fprintf(stderr,"NoCombinedMap option is set.\n");
1301
}
1302
}
1303
break;
1304
1305
case 20:
1306
#line 194 "binfer.y"
1307
{
1308
expected_type = AttributeSymbol;
1309
value_type = LayerAttribute;
1310
}
1311
break;
1312
1313
case 21:
1314
#line 199 "binfer.y"
1315
{
1316
if ( verbose ) fprintf(stderr,"\nParsed layers section.\n");
1317
}
1318
break;
1319
1320
case 24:
1321
#line 208 "binfer.y"
1322
{
1323
cur_sym = s_create(yyvsp[-1].y_sym,expected_type,value_type);
1324
expected_type = ValueSymbol;
1325
}
1326
break;
1327
1328
case 25:
1329
#line 214 "binfer.y"
1330
{
1331
expected_type = AttributeSymbol;
1332
if ( yyvsp[0].y_sym != (char *)0 )
1333
cur_att->question = strsave(yyvsp[0].y_sym);
1334
valno = 1;
1335
}
1336
break;
1337
1338
case 30:
1339
#line 230 "binfer.y"
1340
{
1341
cur_sym = s_create(yyvsp[0].y_sym,expected_type,value_type);
1342
}
1343
break;
1344
1345
case 31:
1346
#line 234 "binfer.y"
1347
{
1348
if ( yyvsp[0].y_sym != (char *)0 )
1349
cur_sym->question = strsave(yyvsp[0].y_sym);
1350
}
1351
break;
1352
1353
case 33:
1354
#line 243 "binfer.y"
1355
{
1356
cur_sym->element.val->desc.layer->cat_num = (CELL)valno;
1357
1358
sprintf(cur_sym->reclass,"%s = %d %s",strsave(yyvsp[-1].y_sym),valno++,
1359
cur_sym->name);
1360
}
1361
break;
1362
1363
case 34:
1364
#line 251 "binfer.y"
1365
{ yyval.y_sym = strsave(yyvsp[0].y_sym); }
1366
break;
1367
1368
case 35:
1369
#line 252 "binfer.y"
1370
{ sprintf(reclassbuf,"%s %s",yyvsp[-1].y_sym,yyvsp[0].y_sym);
1371
yyval.y_sym = strsave(reclassbuf); }
1372
break;
1373
1374
case 36:
1375
#line 254 "binfer.y"
1376
{ yyval.y_sym = strsave(yyvsp[0].y_sym); }
1377
break;
1378
1379
case 37:
1380
#line 255 "binfer.y"
1381
{ sprintf(reclassbuf,"%s %s",yyvsp[-1].y_sym,yyvsp[0].y_sym);
1382
yyval.y_sym = strsave(reclassbuf); }
1383
break;
1384
1385
case 38:
1386
#line 260 "binfer.y"
1387
{ sprintf(reclassbuf,"%s thru %s",yyvsp[-2].y_sym,yyvsp[0].y_sym);
1388
yyval.y_sym = strsave(reclassbuf); }
1389
break;
1390
1391
case 39:
1392
#line 264 "binfer.y"
1393
{ sprintf(reclassbuf,"%s %s",yyvsp[-1].y_sym,yyvsp[0].y_sym);
1394
yyval.y_sym = strsave(reclassbuf); }
1395
break;
1396
1397
case 40:
1398
#line 266 "binfer.y"
1399
{ yyval.y_sym = strsave(yyvsp[0].y_sym); }
1400
break;
1401
1402
case 41:
1403
#line 269 "binfer.y"
1404
{ yyval.y_sym = strsave(yyvsp[0].y_sym);}
1405
break;
1406
1407
case 42:
1408
#line 273 "binfer.y"
1409
{
1410
expected_type = AttributeSymbol;
1411
value_type = ContextAttribute;
1412
}
1413
break;
1414
1415
case 43:
1416
#line 278 "binfer.y"
1417
{
1418
if ( verbose ) fprintf(stderr,"\nParsed context section.\n");
1419
}
1420
break;
1421
1422
case 46:
1423
#line 287 "binfer.y"
1424
{
1425
cur_att = cur_sym = s_create(yyvsp[-1].y_sym,expected_type,value_type);
1426
expected_type = ValueSymbol;
1427
}
1428
break;
1429
1430
case 47:
1431
#line 292 "binfer.y"
1432
{
1433
expected_type = AttributeSymbol;
1434
if ( yyvsp[0].y_sym != (char *)0 )
1435
cur_att->question = strsave(yyvsp[0].y_sym);
1436
}
1437
break;
1438
1439
case 51:
1440
#line 307 "binfer.y"
1441
{
1442
cur_sym = s_create(yyvsp[0].y_sym,expected_type,value_type);
1443
}
1444
break;
1445
1446
case 52:
1447
#line 311 "binfer.y"
1448
{
1449
if ( yyvsp[0].y_sym != (char *)0 )
1450
cur_sym->question = strsave(yyvsp[0].y_sym);
1451
}
1452
break;
1453
1454
case 53:
1455
#line 318 "binfer.y"
1456
{
1457
expected_type = AttributeSymbol;
1458
value_type = SubjectiveAttribute;
1459
}
1460
break;
1461
1462
case 54:
1463
#line 323 "binfer.y"
1464
{
1465
if ( verbose )
1466
fprintf(stderr,"\nParsed subjective section.\n");
1467
}
1468
break;
1469
1470
case 55:
1471
#line 329 "binfer.y"
1472
{
1473
expected_type = AttributeSymbol;
1474
value_type = InferredAttribute;
1475
}
1476
break;
1477
1478
case 56:
1479
#line 334 "binfer.y"
1480
{
1481
if ( verbose )
1482
fprintf(stderr,"\nParsed inferred section.\n");
1483
}
1484
break;
1485
1486
case 57:
1487
#line 340 "binfer.y"
1488
{
1489
cur_sym = s_create(yyvsp[-1].y_sym,expected_type,value_type);
1490
expected_type = ValueSymbol;
1491
}
1492
break;
1493
1494
case 58:
1495
#line 345 "binfer.y"
1496
{
1497
expected_type = AttributeSymbol;
1498
}
1499
break;
1500
1501
case 61:
1502
#line 355 "binfer.y"
1503
{
1504
if (!add_name(yyvsp[0].y_sym)) yyerror("Name not stored");
1505
}
1506
break;
1507
1508
case 62:
1509
#line 359 "binfer.y"
1510
{
1511
if (!add_name(yyvsp[0].y_sym)) yyerror("Name not stored");
1512
}
1513
break;
1514
1515
case 65:
1516
#line 369 "binfer.y"
1517
{
1518
cur_sym = s_create(yyvsp[0].y_sym,expected_type,value_type);
1519
}
1520
break;
1521
1522
case 66:
1523
#line 374 "binfer.y"
1524
{
1525
sprintf(probbuf,"%s%s;",yyvsp[-3].y_sym,yyvsp[-2].y_sym);
1526
if (!add_prob_list(probbuf)) yyerror("Problist not stored");
1527
}
1528
break;
1529
1530
case 68:
1531
#line 382 "binfer.y"
1532
{
1533
if ( probabilitymaps ) {
1534
cur_sym->colortable = AspectColors;
1535
} else {
1536
fprintf(stderr,
1537
"Warning: %s probability map colortable not set.\n"
1538
,cur_sym->name);
1539
fprintf(stderr,"NoProbabilityMaps option is set.\n");
1540
}
1541
}
1542
break;
1543
1544
case 69:
1545
#line 392 "binfer.y"
1546
{
1547
if ( probabilitymaps ) {
1548
cur_sym->colortable = GreyScale;
1549
} else {
1550
fprintf(stderr,
1551
"Warning: %s probability map colortable not set.\n"
1552
,cur_sym->name);
1553
fprintf(stderr,"NoProbabilityMaps option is set.\n");
1554
}
1555
}
1556
break;
1557
1558
case 70:
1559
#line 402 "binfer.y"
1560
{
1561
if ( probabilitymaps ) {
1562
cur_sym->colortable = HistoGreyScale;
1563
} else {
1564
fprintf(stderr,
1565
"Warning: %s probability map colortable not set.\n"
1566
,cur_sym->name);
1567
fprintf(stderr,"NoProbabilityMaps option is set.\n");
1568
}
1569
}
1570
break;
1571
1572
case 71:
1573
#line 412 "binfer.y"
1574
{
1575
if ( probabilitymaps ) {
1576
cur_sym->colortable = Rainbow;
1577
} else {
1578
fprintf(stderr,
1579
"Warning: %s probability map colortable not set.\n"
1580
,cur_sym->name);
1581
fprintf(stderr,"NoProbabilityMaps option is set.\n");
1582
}
1583
}
1584
break;
1585
1586
case 72:
1587
#line 422 "binfer.y"
1588
{
1589
if ( probabilitymaps ) {
1590
cur_sym->colortable = Ramp;
1591
} else {
1592
fprintf(stderr,
1593
"Warning: %s probability map colortable not set.\n"
1594
,cur_sym->name);
1595
fprintf(stderr,"NoProbabilityMaps option is set.\n");
1596
}
1597
}
1598
break;
1599
1600
case 73:
1601
#line 432 "binfer.y"
1602
{
1603
if ( probabilitymaps ) {
1604
cur_sym->colortable = Random;
1605
} else {
1606
fprintf(stderr,
1607
"Warning: %s probability map colortable not set.\n"
1608
,cur_sym->name);
1609
fprintf(stderr,"NoProbabilityMaps option is set.\n");
1610
}
1611
}
1612
break;
1613
1614
case 74:
1615
#line 442 "binfer.y"
1616
{
1617
if ( probabilitymaps ) {
1618
cur_sym->colortable = RYG;
1619
} else {
1620
fprintf(stderr,
1621
"Warning: %s probability map colortable not set.\n"
1622
,cur_sym->name);
1623
fprintf(stderr,"NoProbabilityMaps option is set.\n");
1624
}
1625
}
1626
break;
1627
1628
case 75:
1629
#line 452 "binfer.y"
1630
{
1631
if ( probabilitymaps ) {
1632
cur_sym->colortable = Wave;
1633
} else {
1634
fprintf(stderr,
1635
"Warning: %s probability map colortable not set.\n"
1636
,cur_sym->name);
1637
fprintf(stderr,"NoProbabilityMaps option is set.\n");
1638
}
1639
}
1640
break;
1641
1642
case 76:
1643
#line 465 "binfer.y"
1644
{
1645
cur_sym->element.val->desc.infr->prior_prob = atof(yyvsp[-1].y_sym);
1646
}
1647
break;
1648
1649
case 77:
1650
#line 472 "binfer.y"
1651
{
1652
sprintf(probbuf,";%s",yyvsp[0].y_sym);
1653
yyval.y_sym = strsave(probbuf);
1654
}
1655
break;
1656
1657
case 78:
1658
#line 477 "binfer.y"
1659
{
1660
sprintf(probbuf,"%s;%s",yyvsp[-2].y_sym,yyvsp[0].y_sym);
1661
yyval.y_sym = strsave(probbuf);
1662
}
1663
break;
1664
1665
case 79:
1666
#line 484 "binfer.y"
1667
{
1668
yyval.y_sym = strsave(yyvsp[0].y_sym);
1669
}
1670
break;
1671
1672
case 80:
1673
#line 488 "binfer.y"
1674
{
1675
sprintf(probbuf,"%s,%s",yyvsp[-2].y_sym,yyvsp[0].y_sym);
1676
yyval.y_sym = strsave(probbuf);
1677
}
1678
break;
1679
1680
case 81:
1681
#line 494 "binfer.y"
1682
{ yyval.y_sym = strsave(yyvsp[0].y_sym); }
1683
break;
1684
1685
case 82:
1686
#line 497 "binfer.y"
1687
{ yyval.y_sym = (char *)0; }
1688
break;
1689
1690
case 83:
1691
#line 498 "binfer.y"
1692
{ yyval.y_sym = strsave(yyvsp[-1].y_sym); }
1693
break;
1694
1695
case 85:
1696
#line 504 "binfer.y"
1697
{ yyerrok; }
1698
break;
1699
1700
case 86:
1701
#line 505 "binfer.y"
1702
{ yyerrok; }
1703
break;
1704
1705
case 87:
1706
#line 506 "binfer.y"
1707
{ yyerrok; }
1708
break;
1709
1710
case 88:
1711
#line 507 "binfer.y"
1712
{ yyerrok; }
1713
break;
1714
1715
case 89:
1716
#line 508 "binfer.y"
1717
{ yyerrok; }
1718
break;
1719
1720
1721
}
1722
1723
/* Line 999 of yacc.c. */
1724
#line 1725 "y.tab.c"
1725
1726
yyvsp -= yylen;
1727
yyssp -= yylen;
1728
1729
1730
YY_STACK_PRINT (yyss, yyssp);
1731
1732
*++yyvsp = yyval;
1733
1734
1735
/* Now `shift' the result of the reduction. Determine what state
1736
that goes to, based on the state we popped back to and the rule
1737
number reduced by. */
1738
1739
yyn = yyr1[yyn];
1740
1741
yystate = yypgoto[yyn - YYNTOKENS] + *yyssp;
1742
if (0 <= yystate && yystate <= YYLAST && yycheck[yystate] == *yyssp)
1743
yystate = yytable[yystate];
1744
else
1745
yystate = yydefgoto[yyn - YYNTOKENS];
1746
1747
goto yynewstate;
1748
1749
1750
/*------------------------------------.
1751
| yyerrlab -- here on detecting error |
1752
`------------------------------------*/
1753
yyerrlab:
1754
/* If not already recovering from an error, report this error. */
1755
if (!yyerrstatus)
1756
{
1757
++yynerrs;
1758
#if YYERROR_VERBOSE
1759
yyn = yypact[yystate];
1760
1761
if (YYPACT_NINF < yyn && yyn < YYLAST)
1762
{
1763
YYSIZE_T yysize = 0;
1764
int yytype = YYTRANSLATE (yychar);
1765
char *yymsg;
1766
int yyx, yycount;
1767
1768
yycount = 0;
1769
/* Start YYX at -YYN if negative to avoid negative indexes in
1770
YYCHECK. */
1771
for (yyx = yyn < 0 ? -yyn : 0;
1772
yyx < (int) (sizeof (yytname) / sizeof (char *)); yyx++)
1773
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1774
yysize += yystrlen (yytname[yyx]) + 15, yycount++;
1775
yysize += yystrlen ("syntax error, unexpected ") + 1;
1776
yysize += yystrlen (yytname[yytype]);
1777
yymsg = (char *) YYSTACK_ALLOC (yysize);
1778
if (yymsg != 0)
1779
{
1780
char *yyp = yystpcpy (yymsg, "syntax error, unexpected ");
1781
yyp = yystpcpy (yyp, yytname[yytype]);
1782
1783
if (yycount < 5)
1784
{
1785
yycount = 0;
1786
for (yyx = yyn < 0 ? -yyn : 0;
1787
yyx < (int) (sizeof (yytname) / sizeof (char *));
1788
yyx++)
1789
if (yycheck[yyx + yyn] == yyx && yyx != YYTERROR)
1790
{
1791
const char *yyq = ! yycount ? ", expecting " : " or ";
1792
yyp = yystpcpy (yyp, yyq);
1793
yyp = yystpcpy (yyp, yytname[yyx]);
1794
yycount++;
1795
}
1796
}
1797
yyerror (yymsg);
1798
YYSTACK_FREE (yymsg);
1799
}
1800
else
1801
yyerror ("syntax error; also virtual memory exhausted");
1802
}
1803
else
1804
#endif /* YYERROR_VERBOSE */
1805
yyerror ("syntax error");
1806
}
1807
1808
1809
1810
if (yyerrstatus == 3)
1811
{
1812
/* If just tried and failed to reuse lookahead token after an
1813
error, discard it. */
1814
1815
/* Return failure if at end of input. */
1816
if (yychar == YYEOF)
1817
{
1818
/* Pop the error token. */
1819
YYPOPSTACK;
1820
/* Pop the rest of the stack. */
1821
while (yyss < yyssp)
1822
{
1823
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1824
yydestruct (yystos[*yyssp], yyvsp);
1825
YYPOPSTACK;
1826
}
1827
YYABORT;
1828
}
1829
1830
YYDSYMPRINTF ("Error: discarding", yytoken, &yylval, &yylloc);
1831
yydestruct (yytoken, &yylval);
1832
yychar = YYEMPTY;
1833
1834
}
1835
1836
/* Else will try to reuse lookahead token after shifting the error
1837
token. */
1838
goto yyerrlab1;
1839
1840
1841
/*----------------------------------------------------.
1842
| yyerrlab1 -- error raised explicitly by an action. |
1843
`----------------------------------------------------*/
1844
yyerrlab1:
1845
yyerrstatus = 3; /* Each real token shifted decrements this. */
1846
1847
for (;;)
1848
{
1849
yyn = yypact[yystate];
1850
if (yyn != YYPACT_NINF)
1851
{
1852
yyn += YYTERROR;
1853
if (0 <= yyn && yyn <= YYLAST && yycheck[yyn] == YYTERROR)
1854
{
1855
yyn = yytable[yyn];
1856
if (0 < yyn)
1857
break;
1858
}
1859
}
1860
1861
/* Pop the current state because it cannot handle the error token. */
1862
if (yyssp == yyss)
1863
YYABORT;
1864
1865
YYDSYMPRINTF ("Error: popping", yystos[*yyssp], yyvsp, yylsp);
1866
yydestruct (yystos[yystate], yyvsp);
1867
yyvsp--;
1868
yystate = *--yyssp;
1869
1870
YY_STACK_PRINT (yyss, yyssp);
1871
}
1872
1873
if (yyn == YYFINAL)
1874
YYACCEPT;
1875
1876
YYDPRINTF ((stderr, "Shifting error token, "));
1877
1878
*++yyvsp = yylval;
1879
1880
1881
yystate = yyn;
1882
goto yynewstate;
1883
1884
1885
/*-------------------------------------.
1886
| yyacceptlab -- YYACCEPT comes here. |
1887
`-------------------------------------*/
1888
yyacceptlab:
1889
yyresult = 0;
1890
goto yyreturn;
1891
1892
/*-----------------------------------.
1893
| yyabortlab -- YYABORT comes here. |
1894
`-----------------------------------*/
1895
yyabortlab:
1896
yyresult = 1;
1897
goto yyreturn;
1898
1899
#ifndef yyoverflow
1900
/*----------------------------------------------.
1901
| yyoverflowlab -- parser overflow comes here. |
1902
`----------------------------------------------*/
1903
yyoverflowlab:
1904
yyerror ("parser stack overflow");
1905
yyresult = 2;
1906
/* Fall through. */
1907
#endif
1908
1909
yyreturn:
1910
#ifndef yyoverflow
1911
if (yyss != yyssa)
1912
YYSTACK_FREE (yyss);
1913
#endif
1914
return yyresult;
1915
}
1916
1917
1918
#line 510 "binfer.y"
1919
1920
1921
1922
#include <stdio.h>
1923
Loggerhead is a web-based interface for Breezy
Version: 2.0.1