/* A Bison parser, made from parser.y with Bison version GNU Bison version 1.22
*/
#define BFBISON 1 /* Identify Bison output. */
#define BREAK 258
#define DO 259
#define ELIF 260
#define ELSE 261
#define END 262
#define FOR 263
#define FUNCTION 264
#define GLOBAL 265
#define IF 266
#define IN 267
#define NEXT 268
#define RETURN 269
#define SHARED 270
#define THEN 271
#define WHILE 272
#define ASSIGN 273
#define OR 274
#define AND 275
#define EQ 276
#define NE 277
#define LT 278
#define GT 279
#define LE 280
#define GE 281
#define COLON 282
#define PLUS 283
#define MINUS 284
#define MULT 285
#define DIV 286
#define MOD 287
#define BKSLV 288
#define POW 289
#define TRANS 290
#define NOT 291
#define DOT 292
#define LPAREN 293
#define RPAREN 294
#define LBRACK 295
#define RBRACK 296
#define COMMA 297
#define SEMICOL 298
#define ID 299
#define STRLIT 300
#define NUMLIT 301
#define CONSTANT 302
#line 1 "parser.y"
/*
This file is part of the FElt finite element analysis package.
Copyright (C) 1993-2000 Jason I. Gobat and Darren C. Atkinson
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/************************************************************************
* File: parser.y *
* *
* Description: This file contains the specification for the parser for *
* burlap - a mathematical notation / language for finite *
* element analysis. *
************************************************************************/
# include <stdio.h>
# include "loop.h"
# include "debug.h"
# include "error.h"
# include "lexer.h"
# include "parser.h"
# include "globals.h"
# include "execute.h"
# include "allocate.h"
# if !defined (__GNUC__) && !defined (__sparc__)
# define alloca malloc /* prevents alloca from being called */
# endif
Code global_cs;
static st *vars;
static st local_st;
static void emitloc PROTO ((bfloc));
static char arg_types [256]; /* should be plenty */
static int last_line_num = -1;
static int last_file_num = -1;
static int syntax_error;
#line 56 "parser.y"
typedef union {
int ival;
Address addr;
char *sval;
descriptor *desc;
bfloc loc;
void *ptr;
} BFSTYPE;
#ifndef BFLTYPE
typedef
struct bfltype
{
int timestamp;
int first_line;
int first_column;
int last_line;
int last_column;
char *text;
}
bfltype;
#define BFLTYPE bfltype
#endif
#include <stdio.h>
#ifndef __cplusplus
#ifndef __STDC__
#define const
#endif
#endif
#define BFFINAL 171
#define BFFLAG -32768
#define BFNTBASE 48
#define BFTRANSLATE(x) ((unsigned)(x) <= 302 ? bftranslate[x] : 96)
static const char bftranslate[] = { 0,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 1, 2, 3, 4, 5,
6, 7, 8, 9, 10, 11, 12, 13, 14, 15,
16, 17, 18, 19, 20, 21, 22, 23, 24, 25,
26, 27, 28, 29, 30, 31, 32, 33, 34, 35,
36, 37, 38, 39, 40, 41, 42, 43, 44, 45,
46, 47
};
#if BFDEBUG != 0
static const short bfprhs[] = { 0,
0, 2, 6, 7, 11, 15, 18, 19, 27, 30,
32, 33, 36, 41, 43, 44, 47, 52, 53, 57,
59, 61, 64, 69, 71, 72, 76, 78, 80, 81,
83, 86, 89, 93, 95, 99, 101, 105, 107, 111,
115, 117, 121, 125, 129, 133, 135, 139, 145, 147,
151, 155, 157, 161, 165, 169, 173, 175, 179, 181,
184, 186, 189, 192, 195, 197, 201, 205, 210, 212,
214, 216, 218, 219, 223, 225, 227, 229, 236, 243,
250, 252, 254, 258, 266, 270, 274, 276, 279, 281,
283, 285, 287, 289, 290, 292, 294, 296, 298, 299,
300, 303, 305, 307
};
static const short bfrhs[] = { 50,
0, 1, 49, 50, 0, 0, 50, 51, 43, 0,
50, 63, 43, 0, 50, 43, 0, 0, 52, 38,
53, 39, 43, 56, 7, 0, 9, 44, 0, 54,
0, 0, 55, 44, 0, 54, 42, 55, 44, 0,
15, 0, 0, 57, 60, 0, 57, 10, 58, 43,
0, 0, 58, 42, 59, 0, 59, 0, 44, 0,
60, 43, 0, 60, 43, 85, 63, 0, 63, 0,
0, 61, 42, 63, 0, 63, 0, 63, 0, 0,
64, 0, 93, 62, 0, 14, 62, 0, 65, 18,
64, 0, 65, 0, 65, 86, 66, 0, 66, 0,
66, 87, 67, 0, 67, 0, 67, 21, 68, 0,
67, 22, 68, 0, 68, 0, 68, 23, 69, 0,
68, 24, 69, 0, 68, 25, 69, 0, 68, 26,
69, 0, 69, 0, 69, 27, 70, 0, 69, 27,
70, 27, 70, 0, 70, 0, 70, 28, 71, 0,
70, 29, 71, 0, 71, 0, 71, 30, 72, 0,
71, 31, 72, 0, 71, 32, 72, 0, 71, 33,
72, 0, 72, 0, 73, 34, 72, 0, 73, 0,
73, 35, 0, 74, 0, 36, 74, 0, 29, 74,
0, 28, 74, 0, 75, 0, 38, 60, 39, 0,
75, 37, 44, 0, 75, 38, 76, 39, 0, 79,
0, 81, 0, 84, 0, 77, 0, 0, 77, 42,
78, 0, 78, 0, 63, 0, 27, 0, 88, 63,
91, 16, 60, 80, 0, 17, 90, 63, 94, 60,
7, 0, 8, 63, 92, 95, 60, 7, 0, 13,
0, 7, 0, 89, 60, 7, 0, 89, 5, 63,
91, 16, 60, 80, 0, 40, 82, 41, 0, 82,
83, 61, 0, 61, 0, 83, 43, 0, 43, 0,
44, 0, 45, 0, 46, 0, 47, 0, 0, 19,
0, 20, 0, 11, 0, 6, 0, 0, 0, 12,
63, 0, 3, 0, 4, 0, 4, 0
};
#endif
#if BFDEBUG != 0
static const short bfrline[] = { 0,
89, 92, 98, 113, 115, 128, 130, 139, 169, 196,
198, 204, 211, 227, 230, 236, 241, 242, 247, 248,
253, 263, 264, 265, 266, 272, 274, 280, 281, 287,
288, 290, 302, 304, 309, 311, 316, 318, 323, 325,
327, 332, 334, 336, 338, 340, 345, 347, 349, 354,
356, 358, 362, 364, 366, 368, 370, 375, 377, 382,
384, 389, 391, 393, 395, 400, 403, 411, 414, 415,
416, 421, 422, 428, 430, 436, 437, 443, 444, 447,
450, 456, 458, 460, 466, 472, 474, 480, 482, 488,
495, 502, 509, 523, 529, 536, 543, 548, 554, 560,
566, 572, 578, 584
};
static const char * const bftname[] = { "$","error","$illegal.","BREAK","DO",
"ELIF","ELSE","END","FOR","FUNCTION","GLOBAL","IF","IN","NEXT","RETURN","SHARED",
"THEN","WHILE","ASSIGN","OR","AND","EQ","NE","LT","GT","LE","GE","COLON","PLUS",
"MINUS","MULT","DIV","MOD","BKSLV","POW","TRANS","NOT","DOT","LPAREN","RPAREN",
"LBRACK","RBRACK","COMMA","SEMICOL","ID","STRLIT","NUMLIT","CONSTANT","program",
"error_action","function_or_expression_list","function_definition","function_id",
"opt_formal_list","formal_list","arg_type","function_body","global_declarations",
"global_id_list","global_id","expression_block","expression_list","opt_expression",
"expression","assignment_expression","or_expression","and_expression","equality_expression",
"relational_expression","range_expression","additive_expression","multiplicative_expression",
"exponentiation_expression","postfix_expression","prefix_expression","primary_expression",
"opt_index_expression_list","index_expression_list","index_expression","control_expression",
"else_expression","matrix_expression","matrix_row_list","semicol_list","literal",
"pop","or","and","if","else","mark","fail","in_expression","break","do_while",
"do_for",""
};
#endif
static const short bfr1[] = { 0,
48, 48, 49, 50, 50, 50, 50, 51, 52, 53,
53, 54, 54, 55, 55, 56, 57, 57, 58, 58,
59, 60, 60, 60, 60, 61, 61, 62, 62, 63,
63, 63, 64, 64, 65, 65, 66, 66, 67, 67,
67, 68, 68, 68, 68, 68, 69, 69, 69, 70,
70, 70, 71, 71, 71, 71, 71, 72, 72, 73,
73, 74, 74, 74, 74, 75, 75, 75, 75, 75,
75, 76, 76, 77, 77, 78, 78, 79, 79, 79,
79, 80, 80, 80, 81, 82, 82, 83, 83, 84,
84, 84, 84, 85, 86, 87, 88, 89, 90, 91,
92, 93, 94, 95
};
static const short bfr2[] = { 0,
1, 3, 0, 3, 3, 2, 0, 7, 2, 1,
0, 2, 4, 1, 0, 2, 4, 0, 3, 1,
1, 2, 4, 1, 0, 3, 1, 1, 0, 1,
2, 2, 3, 1, 3, 1, 3, 1, 3, 3,
1, 3, 3, 3, 3, 1, 3, 5, 1, 3,
3, 1, 3, 3, 3, 3, 1, 3, 1, 2,
1, 2, 2, 2, 1, 3, 3, 4, 1, 1,
1, 1, 0, 3, 1, 1, 1, 6, 6, 6,
1, 1, 3, 7, 3, 3, 1, 2, 1, 1,
1, 1, 1, 0, 1, 1, 1, 1, 0, 0,
2, 1, 1, 1
};
static const short bfdefact[] = { 0,
3, 1, 7, 102, 0, 0, 97, 81, 29, 99,
0, 0, 0, 25, 0, 6, 90, 91, 92, 93,
0, 0, 0, 30, 34, 36, 38, 41, 46, 49,
52, 57, 59, 61, 65, 69, 70, 71, 0, 29,
2, 0, 9, 32, 28, 0, 64, 63, 62, 0,
24, 87, 27, 0, 4, 11, 5, 0, 95, 0,
96, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 60, 0, 73, 100,
31, 0, 0, 0, 66, 94, 0, 85, 89, 0,
14, 0, 10, 0, 33, 35, 37, 39, 40, 42,
43, 44, 45, 47, 50, 51, 53, 54, 55, 56,
58, 67, 77, 76, 0, 72, 75, 0, 101, 104,
25, 103, 25, 0, 26, 88, 86, 0, 15, 12,
0, 68, 0, 25, 0, 0, 23, 18, 0, 48,
74, 0, 80, 79, 0, 25, 13, 98, 82, 78,
25, 8, 0, 16, 0, 0, 21, 0, 20, 100,
83, 0, 17, 0, 19, 25, 0, 84, 0, 0,
0
};
static const short bfdefgoto[] = { 169,
3, 2, 21, 22, 92, 93, 94, 145, 146, 158,
159, 50, 52, 44, 51, 24, 25, 26, 27, 28,
29, 30, 31, 32, 33, 34, 35, 115, 116, 117,
36, 150, 37, 54, 90, 38, 124, 60, 62, 39,
151, 46, 118, 83, 40, 123, 121
};
static const short bfpact[] = { 14,
-32768, 73,-32768,-32768, 232, -20,-32768,-32768, 232,-32768,
245, 245, 245, 232, 232,-32768,-32768,-32768,-32768,-32768,
-17, 8, 10,-32768, 11, 36, -1, 46, 48, 7,
65,-32768, 80,-32768, -5,-32768,-32768,-32768, 232, 232,
73, 61,-32768,-32768,-32768, 232,-32768,-32768,-32768, -37,
-32768, 41,-32768, -25,-32768, -10,-32768, 245,-32768, 245,
-32768, 245, 245, 245, 245, 245, 245, 245, 245, 245,
245, 245, 245, 245, 245, 245,-32768, 34, 121,-32768,
-32768, 232, 85, 106,-32768, 2, 232,-32768,-32768, 161,
-32768, 82, 70, 79,-32768, 36, -1, 46, 46, 48,
48, 48, 48, 64, 65, 65,-32768,-32768,-32768,-32768,
-32768,-32768,-32768,-32768, 89, 88,-32768, 117,-32768,-32768,
232,-32768, 232, 232,-32768,-32768, 41, 96, 125,-32768,
245,-32768, 121, 232, -3, 5,-32768,-32768, 97, 7,
-32768, 4,-32768,-32768, 135, 174,-32768,-32768,-32768,-32768,
219,-32768, 99, 101, 232, 12,-32768, 57,-32768,-32768,
-32768, 99,-32768, 129,-32768, 232, 4,-32768, 146, 147,
-32768
};
static const short bfpgoto[] = {-32768,
-32768, 148,-32768,-32768,-32768,-32768, 23,-32768,-32768,-32768,
-7, -72, 68, 116, -2, 102,-32768, 94, 100, 44,
38, -68, 66, -8,-32768, 114,-32768,-32768,-32768, 30,
-32768, 3,-32768,-32768,-32768,-32768,-32768,-32768,-32768,-32768,
-32768,-32768, 13,-32768,-32768,-32768,-32768
};
#define BFLAST 292
static const short bftable[] = { 23,
104, 85, 42, 143, 91, 86, 45, -22, -22, 148,
149, 144, 53, -7, 1, 88, -7, 89, 161, 63,
64, -7, -7, 43, -7, 55, -7, -7, 58, 59,
-7, 78, 79, -15, 70, 71, 80, 45, 23, 86,
-22, -7, -7, 84, -22, 56, 86, 86, 135, -7,
136, -7, 57, -7, 86, 61, -7, -7, -7, -7,
-7, 142, 140, 107, 108, 109, 110, 111, 65, 66,
67, 68, 82, 154, 69, 4, 114, 112, 156, 119,
5, 6, 87, 7, 125, 8, 9, 53, 120, 10,
131, 70, 71, 167, 72, 73, 74, 75, 162, 163,
11, 12, 100, 101, 102, 103, 98, 99, 13, 122,
14, 129, 15, 76, 77, 16, 17, 18, 19, 20,
128, 137, 130, 4, 47, 48, 49, 132, 5, 133,
114, 7, 134, 8, 9, 105, 106, 10, 138, 91,
147, 152, 157, 86, 166, 170, 171, 113, 11, 12,
41, 139, 160, 96, 165, 81, 13, 127, 14, 95,
15, 97, 141, 4, 17, 18, 19, 20, 5, 168,
0, 7, 164, 8, 9, 0, 4, 10, 0, 0,
0, 5, 0, 153, 7, 0, 8, 9, 11, 12,
10, 0, 0, 0, 0, 0, 13, 0, 14, 0,
15, 11, 12, 126, 17, 18, 19, 20, 0, 13,
0, 14, 0, 15, 0, 0, 0, 17, 18, 19,
20, 4, 0, 155, 0, 0, 5, 0, 0, 7,
0, 8, 9, 0, 4, 10, 0, 0, 0, 5,
0, 0, 7, 0, 8, 9, 11, 12, 10, 0,
0, 0, 5, 0, 13, 7, 14, 8, 15, 11,
12, 10, 17, 18, 19, 20, 0, 13, 0, 14,
0, 15, 11, 12, 0, 17, 18, 19, 20, 0,
13, 0, 14, 0, 15, 0, 0, 0, 17, 18,
19, 20
};
static const short bfcheck[] = { 2,
69, 39, 5, 7, 15, 43, 9, 6, 7, 6,
7, 7, 15, 0, 1, 41, 3, 43, 7, 21,
22, 8, 9, 44, 11, 43, 13, 14, 18, 19,
17, 37, 38, 44, 28, 29, 39, 40, 41, 43,
39, 28, 29, 46, 43, 38, 43, 43, 121, 36,
123, 38, 43, 40, 43, 20, 43, 44, 45, 46,
47, 134, 131, 72, 73, 74, 75, 76, 23, 24,
25, 26, 12, 146, 27, 3, 79, 44, 151, 82,
8, 9, 42, 11, 87, 13, 14, 90, 4, 17,
27, 28, 29, 166, 30, 31, 32, 33, 42, 43,
28, 29, 65, 66, 67, 68, 63, 64, 36, 4,
38, 42, 40, 34, 35, 43, 44, 45, 46, 47,
39, 124, 44, 3, 11, 12, 13, 39, 8, 42,
133, 11, 16, 13, 14, 70, 71, 17, 43, 15,
44, 7, 44, 43, 16, 0, 0, 27, 28, 29,
3, 129, 155, 60, 162, 40, 36, 90, 38, 58,
40, 62, 133, 3, 44, 45, 46, 47, 8, 167,
-1, 11, 160, 13, 14, -1, 3, 17, -1, -1,
-1, 8, -1, 10, 11, -1, 13, 14, 28, 29,
17, -1, -1, -1, -1, -1, 36, -1, 38, -1,
40, 28, 29, 43, 44, 45, 46, 47, -1, 36,
-1, 38, -1, 40, -1, -1, -1, 44, 45, 46,
47, 3, -1, 5, -1, -1, 8, -1, -1, 11,
-1, 13, 14, -1, 3, 17, -1, -1, -1, 8,
-1, -1, 11, -1, 13, 14, 28, 29, 17, -1,
-1, -1, 8, -1, 36, 11, 38, 13, 40, 28,
29, 17, 44, 45, 46, 47, -1, 36, -1, 38,
-1, 40, 28, 29, -1, 44, 45, 46, 47, -1,
36, -1, 38, -1, 40, -1, -1, -1, 44, 45,
46, 47
};
#define BFPURE 1
/* -*-C-*- Note some compilers choke on comments on `#line' lines. */
#line 3 "/usr/lib/bison.simple"
/* Skeleton output parser for bison,
Copyright (C) 1984, 1989, 1990 Bob Corbett and Richard Stallman
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 1, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */
#ifndef alloca
#ifdef __GNUC__
#define alloca __builtin_alloca
#else /* not GNU C. */
#if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi)
#include <alloca.h>
#else /* not sparc */
#if defined (MSDOS) && !defined (__TURBOC__)
#include <stdlib.h>
#else /* not MSDOS, or __TURBOC__ */
#if defined(_AIX)
#include <stdlib.h>
#pragma alloca
#else /* not MSDOS, __TURBOC__, or _AIX */
#ifdef __hpux
#ifdef __cplusplus
extern "C" {
void *alloca (unsigned int);
};
#else /* not __cplusplus */
void *alloca ();
#endif /* not __cplusplus */
#endif /* __hpux */
#endif /* not _AIX */
#endif /* not MSDOS, or __TURBOC__ */
#endif /* not sparc. */
#endif /* not GNU C. */
#endif /* alloca not defined. */
/* This is the parser code that is written into each bison parser
when the %semantic_parser declaration is not specified in the grammar.
It was written by Richard Stallman by simplifying the hairy parser
used when %semantic_parser is specified. */
/* Note: there must be only one dollar sign in this file.
It is replaced by the list of actions, each action
as one case of the switch. */
#define bferrok (bferrstatus = 0)
#define bfclearin (bfchar = BFEMPTY)
#define BFEMPTY -2
#define BFEOF 0
#define BFACCEPT return(0)
#define BFABORT return(1)
#define BFERROR goto bferrlab1
/* Like BFERROR except do call bferror.
This remains here temporarily to ease the
transition to the new meaning of BFERROR, for GCC.
Once GCC version 2 has supplanted version 1, this can go. */
#define BFFAIL goto bferrlab
#define BFRECOVERING() (!!bferrstatus)
#define BFBACKUP(token, value) \
do \
if (bfchar == BFEMPTY && bflen == 1) \
{ bfchar = (token), bflval = (value); \
bfchar1 = BFTRANSLATE (bfchar); \
BFPOPSTACK; \
goto bfbackup; \
} \
else \
{ bferror ("syntax error: cannot back up"); BFERROR; } \
while (0)
#define BFTERROR 1
#define BFERRCODE 256
#ifndef BFPURE
#define BFLEX bflex()
#endif
#ifdef BFPURE
#ifdef BFLSP_NEEDED
#define BFLEX bflex(&bflval, &bflloc)
#else
#define BFLEX bflex(&bflval)
#endif
#endif
/* If nonreentrant, generate the variables here */
#ifndef BFPURE
int bfchar; /* the lookahead symbol */
BFSTYPE bflval; /* the semantic value of the */
/* lookahead symbol */
#ifdef BFLSP_NEEDED
BFLTYPE bflloc; /* location data for the lookahead */
/* symbol */
#endif
int bfnerrs; /* number of parse errors so far */
#endif /* not BFPURE */
#if BFDEBUG != 0
int bfdebug; /* nonzero means print parse trace */
/* Since this is uninitialized, it does not stop multiple parsers
from coexisting. */
#endif
/* BFINITDEPTH indicates the initial size of the parser's stacks */
#ifndef BFINITDEPTH
#define BFINITDEPTH 200
#endif
/* BFMAXDEPTH is the maximum size the stacks can grow to
(effective only if the built-in stack extension method is used). */
#if BFMAXDEPTH == 0
#undef BFMAXDEPTH
#endif
#ifndef BFMAXDEPTH
#define BFMAXDEPTH 10000
#endif
/* Prevent warning if -Wstrict-prototypes. */
#ifdef __GNUC__
int bfparse (void);
#endif
#if __GNUC__ > 1 /* GNU C and GNU C++ define this. */
#define __bf_bcopy(FROM,TO,COUNT) __builtin_memcpy(TO,FROM,COUNT)
#else /* not GNU C or C++ */
#ifndef __cplusplus
/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
__bf_bcopy (from, to, count)
char *from;
char *to;
int count;
{
register char *f = from;
register char *t = to;
register int i = count;
while (i-- > 0)
*t++ = *f++;
}
#else /* __cplusplus */
/* This is the most reliable way to avoid incompatibilities
in available built-in functions on various systems. */
static void
__bf_bcopy (char *from, char *to, int count)
{
register char *f = from;
register char *t = to;
register int i = count;
while (i-- > 0)
*t++ = *f++;
}
#endif
#endif
#line 184 "/usr/lib/bison.simple"
int
bfparse()
{
register int bfstate;
register int bfn;
register short *bfssp;
register BFSTYPE *bfvsp;
int bferrstatus; /* number of tokens to shift before error messages enabled */
int bfchar1 = 0; /* lookahead token as an internal (translated) token number */
short bfssa[BFINITDEPTH]; /* the state stack */
BFSTYPE bfvsa[BFINITDEPTH]; /* the semantic value stack */
short *bfss = bfssa; /* refer to the stacks thru separate pointers */
BFSTYPE *bfvs = bfvsa; /* to allow bfoverflow to reallocate them elsewhere */
#ifdef BFLSP_NEEDED
BFLTYPE bflsa[BFINITDEPTH]; /* the location stack */
BFLTYPE *bfls = bflsa;
BFLTYPE *bflsp;
#define BFPOPSTACK (bfvsp--, bfssp--, bflsp--)
#else
#define BFPOPSTACK (bfvsp--, bfssp--)
#endif
int bfstacksize = BFINITDEPTH;
#ifdef BFPURE
int bfchar;
BFSTYPE bflval;
int bfnerrs;
#ifdef BFLSP_NEEDED
BFLTYPE bflloc;
#endif
#endif
BFSTYPE bfval; /* the variable used to return */
/* semantic values from the action */
/* routines */
int bflen;
#if BFDEBUG != 0
if (bfdebug)
fprintf(stderr, "Starting parse\n");
#endif
bfstate = 0;
bferrstatus = 0;
bfnerrs = 0;
bfchar = BFEMPTY; /* Cause a token to be read. */
/* Initialize stack pointers.
Waste one element of value and location stack
so that they stay on the same level as the state stack.
The wasted elements are never initialized. */
bfssp = bfss - 1;
bfvsp = bfvs;
#ifdef BFLSP_NEEDED
bflsp = bfls;
#endif
/* Push a new state, which is found in bfstate . */
/* In all cases, when you get here, the value and location stacks
have just been pushed. so pushing a state here evens the stacks. */
bfnewstate:
*++bfssp = bfstate;
if (bfssp >= bfss + bfstacksize - 1)
{
/* Give user a chance to reallocate the stack */
/* Use copies of these so that the &'s don't force the real ones into memory. */
BFSTYPE *bfvs1 = bfvs;
short *bfss1 = bfss;
#ifdef BFLSP_NEEDED
BFLTYPE *bfls1 = bfls;
#endif
/* Get the current used size of the three stacks, in elements. */
int size = bfssp - bfss + 1;
#ifdef bfoverflow
/* Each stack pointer address is followed by the size of
the data in use in that stack, in bytes. */
#ifdef BFLSP_NEEDED
/* This used to be a conditional around just the two extra args,
but that might be undefined if bfoverflow is a macro. */
bfoverflow("parser stack overflow",
&bfss1, size * sizeof (*bfssp),
&bfvs1, size * sizeof (*bfvsp),
&bfls1, size * sizeof (*bflsp),
&bfstacksize);
#else
bfoverflow("parser stack overflow",
&bfss1, size * sizeof (*bfssp),
&bfvs1, size * sizeof (*bfvsp),
&bfstacksize);
#endif
bfss = bfss1; bfvs = bfvs1;
#ifdef BFLSP_NEEDED
bfls = bfls1;
#endif
#else /* no bfoverflow */
/* Extend the stack our own way. */
if (bfstacksize >= BFMAXDEPTH)
{
bferror("parser stack overflow");
return 2;
}
bfstacksize *= 2;
if (bfstacksize > BFMAXDEPTH)
bfstacksize = BFMAXDEPTH;
bfss = (short *) alloca (bfstacksize * sizeof (*bfssp));
__bf_bcopy ((char *)bfss1, (char *)bfss, size * sizeof (*bfssp));
bfvs = (BFSTYPE *) alloca (bfstacksize * sizeof (*bfvsp));
__bf_bcopy ((char *)bfvs1, (char *)bfvs, size * sizeof (*bfvsp));
#ifdef BFLSP_NEEDED
bfls = (BFLTYPE *) alloca (bfstacksize * sizeof (*bflsp));
__bf_bcopy ((char *)bfls1, (char *)bfls, size * sizeof (*bflsp));
#endif
#endif /* no bfoverflow */
bfssp = bfss + size - 1;
bfvsp = bfvs + size - 1;
#ifdef BFLSP_NEEDED
bflsp = bfls + size - 1;
#endif
#if BFDEBUG != 0
if (bfdebug)
fprintf(stderr, "Stack size increased to %d\n", bfstacksize);
#endif
if (bfssp >= bfss + bfstacksize - 1)
BFABORT;
}
#if BFDEBUG != 0
if (bfdebug)
fprintf(stderr, "Entering state %d\n", bfstate);
#endif
goto bfbackup;
bfbackup:
/* Do appropriate processing given the current state. */
/* Read a lookahead token if we need one and don't already have one. */
/* bfresume: */
/* First try to decide what to do without reference to lookahead token. */
bfn = bfpact[bfstate];
if (bfn == BFFLAG)
goto bfdefault;
/* Not known => get a lookahead token if don't already have one. */
/* bfchar is either BFEMPTY or BFEOF
or a valid token in external form. */
if (bfchar == BFEMPTY)
{
#if BFDEBUG != 0
if (bfdebug)
fprintf(stderr, "Reading a token: ");
#endif
bfchar = BFLEX;
}
/* Convert token to internal form (in bfchar1) for indexing tables with */
if (bfchar <= 0) /* This means end of input. */
{
bfchar1 = 0;
bfchar = BFEOF; /* Don't call BFLEX any more */
#if BFDEBUG != 0
if (bfdebug)
fprintf(stderr, "Now at end of input.\n");
#endif
}
else
{
bfchar1 = BFTRANSLATE(bfchar);
#if BFDEBUG != 0
if (bfdebug)
{
fprintf (stderr, "Next token is %d (%s", bfchar, bftname[bfchar1]);
/* Give the individual parser a way to print the precise meaning
of a token, for further debugging info. */
#ifdef BFPRINT
BFPRINT (stderr, bfchar, bflval);
#endif
fprintf (stderr, ")\n");
}
#endif
}
bfn += bfchar1;
if (bfn < 0 || bfn > BFLAST || bfcheck[bfn] != bfchar1)
goto bfdefault;
bfn = bftable[bfn];
/* bfn is what to do for this token type in this state.
Negative => reduce, -bfn is rule number.
Positive => shift, bfn is new state.
New state is final state => don't bother to shift,
just return success.
0, or most negative number => error. */
if (bfn < 0)
{
if (bfn == BFFLAG)
goto bferrlab;
bfn = -bfn;
goto bfreduce;
}
else if (bfn == 0)
goto bferrlab;
if (bfn == BFFINAL)
BFACCEPT;
/* Shift the lookahead token. */
#if BFDEBUG != 0
if (bfdebug)
fprintf(stderr, "Shifting token %d (%s), ", bfchar, bftname[bfchar1]);
#endif
/* Discard the token being shifted unless it is eof. */
if (bfchar != BFEOF)
bfchar = BFEMPTY;
*++bfvsp = bflval;
#ifdef BFLSP_NEEDED
*++bflsp = bflloc;
#endif
/* count tokens shifted since error; after three, turn off error status. */
if (bferrstatus) bferrstatus--;
bfstate = bfn;
goto bfnewstate;
/* Do the default action for the current state. */
bfdefault:
bfn = bfdefact[bfstate];
if (bfn == 0)
goto bferrlab;
/* Do a reduction. bfn is the number of a rule to reduce with. */
bfreduce:
bflen = bfr2[bfn];
if (bflen > 0)
bfval = bfvsp[1-bflen]; /* implement default value of the action */
#if BFDEBUG != 0
if (bfdebug)
{
int i;
fprintf (stderr, "Reducing via rule %d (line %d), ",
bfn, bfrline[bfn]);
/* Print the symbols being reduced, and their result. */
for (i = bfprhs[bfn]; bfrhs[i] > 0; i++)
fprintf (stderr, "%s ", bftname[bfrhs[i]]);
fprintf (stderr, " -> %s\n", bftname[bfr1[bfn]]);
}
#endif
switch (bfn) {
case 1:
#line 90 "parser.y"
{syntax_error = 0;;
break;}
case 2:
#line 93 "parser.y"
{syntax_error = 0;;
break;}
case 3:
#line 99 "parser.y"
{
bferrok;
bfclearin;
cs = global_cs;
exit_all ( );
reset ( );
if (!interactive)
syntax_error = 1;
;
break;}
case 5:
#line 116 "parser.y"
{
if (!syntax_error) {
emit (HaltOp);
if (execute (cs, var_array, NULL) != -1 && !interactive)
return 1;
}
reset ( );
last_line_num = -1;
last_file_num = -1;
;
break;}
case 7:
#line 131 "parser.y"
{
vars = &var_st;
reset ( );
;
break;}
case 8:
#line 140 "parser.y"
{
int i;
D_Function (bfvsp[-6].desc) -> num_args = bfvsp[-4].ival;
D_Function (bfvsp[-6].desc) -> num_locals = vars -> num_syms;
D_Function (bfvsp[-6].desc) -> local_names = st_names (vars);
D_Function (bfvsp[-6].desc) -> arg_types = Allocate (char, bfvsp[-4].ival);
for (i = 0; i < bfvsp[-4].ival; i ++)
D_Function (bfvsp[-6].desc) -> arg_types [i] = arg_types [i];
emit (RtnOp);
st_fini (vars);
st_fini (&import_st);
d_dump (cs);
cs = global_cs;
vars = &var_st;
st_init (&import_st);
reset ( );
last_file_num = -1;
last_line_num = -1;
;
break;}
case 9:
#line 170 "parser.y"
{
ste *s;
descriptor d;
s = add_literal (&var_st, bfvsp[0].sval, GlblOp);
d = *(bfval.desc = &var_array [s -> idx]);
Deallocate (bfvsp[0].sval);
FreeData (bfval.desc);
CreateData (bfval.desc, NULL, NULL, T_Function, s -> name);
D_Temp (bfval.desc) = F_False;
cs = D_Function (bfval.desc) -> cs;
st_init (vars = &local_st);
st_init (&import_st);
reset ( );
last_file_num = -1;
last_line_num = -1;
emitloc (bfvsp[-1].loc);
;
break;}
case 11:
#line 199 "parser.y"
{bfval.ival = 0;;
break;}
case 12:
#line 205 "parser.y"
{
st_insert (&import_st, bfvsp[0].sval, ArgOp);
arg_types [0] = bfvsp[-1].ival; bfval.ival = 1;
Deallocate (bfvsp[0].sval);
;
break;}
case 13:
#line 212 "parser.y"
{
ste *s = st_lookup (&import_st, bfvsp[0].sval);
if (s) {
cterror ("duplicate argument '%s'", bfvsp[0].sval);
bfval.ival = -1;
} else if (bfvsp[-3].ival > 0) {
st_insert (&import_st, bfvsp[0].sval, ArgOp);
arg_types [bfvsp[-3].ival] = bfvsp[-1].ival; bfval.ival = bfvsp[-3].ival + 1;
}
Deallocate (bfvsp[0].sval);
;
break;}
case 14:
#line 228 "parser.y"
{bfval.ival = SharedArg;;
break;}
case 15:
#line 231 "parser.y"
{bfval.ival = ValueArg;;
break;}
case 21:
#line 254 "parser.y"
{
ste *s = add_literal (&var_st, bfvsp[0].sval, GlblOp);
add_literal (&import_st, bfvsp[0].sval, GlblOp) -> idx = s -> idx;
Deallocate (bfvsp[0].sval);
;
break;}
case 25:
#line 267 "parser.y"
{emit (DblOp, 0);;
break;}
case 26:
#line 273 "parser.y"
{bfval.ival = bfvsp[-2].ival + 1;;
break;}
case 27:
#line 275 "parser.y"
{bfval.ival = 1;;
break;}
case 29:
#line 282 "parser.y"
{emit (NullOp);;
break;}
case 31:
#line 289 "parser.y"
{end_break (BREAK, bfvsp[-1].ptr);;
break;}
case 32:
#line 291 "parser.y"
{
if (cs == global_cs) {
cterror ("return not within a function");
emit (NullOp);
} else
emitloc (bfvsp[-1].loc); emit (RtnOp);
;
break;}
case 33:
#line 303 "parser.y"
{emitloc (bfvsp[-1].loc); emit (AsgnOp);;
break;}
case 35:
#line 310 "parser.y"
{patch (bfvsp[-1].addr, JnzOp, ip); emit (TestOp);;
break;}
case 37:
#line 317 "parser.y"
{patch (bfvsp[-1].addr, JzOp, ip); emit (TestOp);;
break;}
case 39:
#line 324 "parser.y"
{emitloc (bfvsp[-1].loc); emit (EqOp);;
break;}
case 40:
#line 326 "parser.y"
{emitloc (bfvsp[-1].loc); emit (NeOp);;
break;}
case 42:
#line 333 "parser.y"
{emitloc (bfvsp[-1].loc); emit (LtOp);;
break;}
case 43:
#line 335 "parser.y"
{emitloc (bfvsp[-1].loc); emit (GtOp);;
break;}
case 44:
#line 337 "parser.y"
{emitloc (bfvsp[-1].loc); emit (LeOp);;
break;}
case 45:
#line 339 "parser.y"
{emitloc (bfvsp[-1].loc); emit (GeOp);;
break;}
case 47:
#line 346 "parser.y"
{emitloc (bfvsp[-1].loc); emit (RangeOp, 2);;
break;}
case 48:
#line 348 "parser.y"
{emitloc (bfvsp[-3].loc); emit (RangeOp, 3);;
break;}
case 50:
#line 355 "parser.y"
{emitloc (bfvsp[-1].loc); emit (AddOp);;
break;}
case 51:
#line 357 "parser.y"
{emitloc (bfvsp[-1].loc); emit (SubOp);;
break;}
case 53:
#line 363 "parser.y"
{emitloc (bfvsp[-1].loc); emit (MulOp);;
break;}
case 54:
#line 365 "parser.y"
{emitloc (bfvsp[-1].loc); emit (DivOp);;
break;}
case 55:
#line 367 "parser.y"
{emitloc (bfvsp[-1].loc); emit (ModOp);;
break;}
case 56:
#line 369 "parser.y"
{emitloc (bfvsp[-1].loc); emit (BkslvOp);;
break;}
case 58:
#line 376 "parser.y"
{emitloc (bfvsp[-1].loc); emit (PowOp);;
break;}
case 60:
#line 383 "parser.y"
{emitloc (bfvsp[0].loc); emit (TransOp);;
break;}
case 62:
#line 390 "parser.y"
{emitloc (bfvsp[-1].loc); emit (NotOp);;
break;}
case 63:
#line 392 "parser.y"
{emitloc (bfvsp[-1].loc); emit (NegOp);;
break;}
case 64:
#line 394 "parser.y"
{emitloc (bfvsp[-1].loc); emit (PlusOp);;
break;}
case 66:
#line 401 "parser.y"
{/* prevents warnings */;
break;}
case 67:
#line 404 "parser.y"
{
ste *s = st_lookup (&field_st, bfvsp[0].sval);
emitloc (bfvsp[-1].loc);
emit (FieldOp, s ? s -> idx : 0);
Deallocate (bfvsp[0].sval);
;
break;}
case 68:
#line 412 "parser.y"
{emitloc (bfvsp[-2].loc); emit (ApplyOp, bfvsp[-1].ival);;
break;}
case 73:
#line 423 "parser.y"
{bfval.ival = 0;;
break;}
case 74:
#line 429 "parser.y"
{bfval.ival = bfvsp[-2].ival + 1;;
break;}
case 75:
#line 431 "parser.y"
{bfval.ival = 1;;
break;}
case 77:
#line 438 "parser.y"
{emitloc (bfvsp[0].loc); emit (RangeOp, 0);;
break;}
case 79:
#line 445 "parser.y"
{emit (PopOp, 1); emit (JmpOp, bfvsp[-4].addr); patch (bfvsp[-2].addr, FailOp, ip);
exit_loop (bfvsp[-4].addr, ip);;
break;}
case 80:
#line 448 "parser.y"
{emit (PopOp, 1); emit (JmpOp, bfvsp[-3].addr); patch (bfvsp[-3].addr, GenOp, ip);
exit_loop (bfvsp[-3].addr, ip);;
break;}
case 81:
#line 451 "parser.y"
{end_break (NEXT, start_break (NEXT));;
break;}
case 82:
#line 457 "parser.y"
{patch (bfvsp[-3].ival, FailOp, ip);;
break;}
case 83:
#line 459 "parser.y"
{patch (bfvsp[-2].addr, JmpOp, ip);;
break;}
case 84:
#line 461 "parser.y"
{patch (bfvsp[-6].addr, JmpOp, ip);;
break;}
case 85:
#line 467 "parser.y"
{emitloc (bfvsp[-2].loc); emit (MtxOp, bfvsp[-1].ival);;
break;}
case 86:
#line 473 "parser.y"
{emitloc (bfvsp[-1].loc); emit (RowOp, bfvsp[0].ival); bfval.ival = bfvsp[-2].ival + 1;;
break;}
case 87:
#line 475 "parser.y"
{emit (RowOp, bfvsp[0].ival); bfval.ival = 1;;
break;}
case 88:
#line 481 "parser.y"
{bfval.loc = bfvsp[0].loc;;
break;}
case 89:
#line 483 "parser.y"
{bfval.loc = bfvsp[0].loc;;
break;}
case 90:
#line 489 "parser.y"
{
ste *s = add_literal (vars, bfvsp[0].sval, LocalOp);
emit (s -> op, s -> idx);
Deallocate (bfvsp[0].sval);
;
break;}
case 91:
#line 496 "parser.y"
{
ste *s = add_literal (&str_st, bfvsp[0].sval, StrOp);
emit (StrOp, s -> idx);
Deallocate (bfvsp[0].sval);
;
break;}
case 92:
#line 503 "parser.y"
{
ste *s = add_literal (&dbl_st, bfvsp[0].sval, DblOp);
emit (DblOp, s -> idx);
Deallocate (bfvsp[0].sval);
;
break;}
case 93:
#line 510 "parser.y"
{
ste *s = st_lookup (&var_st, bfvsp[0].sval);
if (!s) {
cterror ("unknown constant '%s' (using null value)", bfvsp[0].sval);
s = add_literal (vars, bfvsp[0].sval, NullOp);
}
emit (s -> op, s -> idx);
Deallocate (bfvsp[0].sval);
;
break;}
case 94:
#line 524 "parser.y"
{emit (PopOp, 1);;
break;}
case 95:
#line 530 "parser.y"
{emitloc (bfvsp[0].loc); emit (CopyOp); bfval.addr = ip; emit (JnzOp, 0);
emit (PopOp, 1);;
break;}
case 96:
#line 537 "parser.y"
{emitloc (bfvsp[0].loc); emit (CopyOp); bfval.addr = ip; emit (JzOp, 0);
emit (PopOp, 1);;
break;}
case 97:
#line 544 "parser.y"
{emitloc (bfvsp[0].loc);;
break;}
case 98:
#line 549 "parser.y"
{bfval.addr = ip; emit (JmpOp, 0); patch (bfvsp[-3].ival, JzOp, ip);;
break;}
case 99:
#line 555 "parser.y"
{bfval.addr = ip;;
break;}
case 100:
#line 561 "parser.y"
{bfval.addr = ip; emit (FailOp, 0);;
break;}
case 101:
#line 567 "parser.y"
{emit (DblOp, 1); emitloc (bfvsp[-1].loc); bfval.addr = ip; emit (GenOp, 0);;
break;}
case 102:
#line 573 "parser.y"
{bfval.ptr = (void *) start_break (BREAK);;
break;}
case 103:
#line 579 "parser.y"
{emitloc (bfvsp[0].loc); enter_loop (WHILE); bfval.addr = ip; emit (FailOp, 0);;
break;}
case 104:
#line 585 "parser.y"
{enter_loop (FOR);;
break;}
}
/* the action file gets copied in in place of this dollarsign */
#line 465 "/usr/lib/bison.simple"
bfvsp -= bflen;
bfssp -= bflen;
#ifdef BFLSP_NEEDED
bflsp -= bflen;
#endif
#if BFDEBUG != 0
if (bfdebug)
{
short *ssp1 = bfss - 1;
fprintf (stderr, "state stack now");
while (ssp1 != bfssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif
*++bfvsp = bfval;
#ifdef BFLSP_NEEDED
bflsp++;
if (bflen == 0)
{
bflsp->first_line = bflloc.first_line;
bflsp->first_column = bflloc.first_column;
bflsp->last_line = (bflsp-1)->last_line;
bflsp->last_column = (bflsp-1)->last_column;
bflsp->text = 0;
}
else
{
bflsp->last_line = (bflsp+bflen-1)->last_line;
bflsp->last_column = (bflsp+bflen-1)->last_column;
}
#endif
/* Now "shift" the result of the reduction.
Determine what state that goes to,
based on the state we popped back to
and the rule number reduced by. */
bfn = bfr1[bfn];
bfstate = bfpgoto[bfn - BFNTBASE] + *bfssp;
if (bfstate >= 0 && bfstate <= BFLAST && bfcheck[bfstate] == *bfssp)
bfstate = bftable[bfstate];
else
bfstate = bfdefgoto[bfn - BFNTBASE];
goto bfnewstate;
bferrlab: /* here on detecting error */
if (! bferrstatus)
/* If not already recovering from an error, report this error. */
{
++bfnerrs;
#ifdef BFERROR_VERBOSE
bfn = bfpact[bfstate];
if (bfn > BFFLAG && bfn < BFLAST)
{
int size = 0;
char *msg;
int x, count;
count = 0;
/* Start X at -bfn if nec to avoid negative indexes in bfcheck. */
for (x = (bfn < 0 ? -bfn : 0);
x < (sizeof(bftname) / sizeof(char *)); x++)
if (bfcheck[x + bfn] == x)
size += strlen(bftname[x]) + 15, count++;
msg = (char *) malloc(size + 15);
if (msg != 0)
{
strcpy(msg, "parse error");
if (count < 5)
{
count = 0;
for (x = (bfn < 0 ? -bfn : 0);
x < (sizeof(bftname) / sizeof(char *)); x++)
if (bfcheck[x + bfn] == x)
{
strcat(msg, count == 0 ? ", expecting `" : " or `");
strcat(msg, bftname[x]);
strcat(msg, "'");
count++;
}
}
bferror(msg);
free(msg);
}
else
bferror ("parse error; also virtual memory exceeded");
}
else
#endif /* BFERROR_VERBOSE */
bferror("parse error");
}
goto bferrlab1;
bferrlab1: /* here on error raised explicitly by an action */
if (bferrstatus == 3)
{
/* if just tried and failed to reuse lookahead token after an error, discard it. */
/* return failure if at end of input */
if (bfchar == BFEOF)
BFABORT;
#if BFDEBUG != 0
if (bfdebug)
fprintf(stderr, "Discarding token %d (%s).\n", bfchar, bftname[bfchar1]);
#endif
bfchar = BFEMPTY;
}
/* Else will try to reuse lookahead token
after shifting the error token. */
bferrstatus = 3; /* Each real token shifted decrements this */
goto bferrhandle;
bferrdefault: /* current state does not do anything special for the error token. */
#if 0
/* This is wrong; only states that explicitly want error tokens
should shift them. */
bfn = bfdefact[bfstate]; /* If its default is to accept any token, ok. Otherwise pop it.*/
if (bfn) goto bfdefault;
#endif
bferrpop: /* pop the current state because it cannot handle the error token */
if (bfssp == bfss) BFABORT;
bfvsp--;
bfstate = *--bfssp;
#ifdef BFLSP_NEEDED
bflsp--;
#endif
#if BFDEBUG != 0
if (bfdebug)
{
short *ssp1 = bfss - 1;
fprintf (stderr, "Error: state stack now");
while (ssp1 != bfssp)
fprintf (stderr, " %d", *++ssp1);
fprintf (stderr, "\n");
}
#endif
bferrhandle:
bfn = bfpact[bfstate];
if (bfn == BFFLAG)
goto bferrdefault;
bfn += BFTERROR;
if (bfn < 0 || bfn > BFLAST || bfcheck[bfn] != BFTERROR)
goto bferrdefault;
bfn = bftable[bfn];
if (bfn < 0)
{
if (bfn == BFFLAG)
goto bferrpop;
bfn = -bfn;
goto bfreduce;
}
else if (bfn == 0)
goto bferrpop;
if (bfn == BFFINAL)
BFACCEPT;
#if BFDEBUG != 0
if (bfdebug)
fprintf(stderr, "Shifting error token, ");
#endif
*++bfvsp = bflval;
#ifdef BFLSP_NEEDED
*++bflsp = bflloc;
#endif
bfstate = bfn;
goto bfnewstate;
}
#line 588 "parser.y"
/************************************************************************
* Function: emitloc *
* *
* Description: Emits a file and/or line instruction if they have *
* changed since the last time that they were emitted. *
************************************************************************/
static void emitloc (loc)
bfloc loc;
{
if (last_file_num != loc.file)
emit (FileOp, last_file_num = loc.file);
if (last_line_num != loc.line)
emit (LineOp, last_line_num = loc.line);
}
syntax highlighted by Code2HTML, v. 0.9.1