Savannah Git Hosting - enscript.git/blob

1

2 /* A Bison parser, made from gram.y

3 by GNU Bison version 1.28 */

4

5 #define YYBISON 1 /* Identify Bison output. */

6

7 #define tSYMBOL 257

8 #define tREGEXP 258

9 #define tSTRING 259

10 #define tINTEGER 260

11 #define tREAL 261

12 #define tSUB 262

13 #define tSTATE 263

14 #define tSTART 264

15 #define tSTARTRULES 265

16 #define tNAMERULES 266

17 #define tBEGIN 267

18 #define tEND 268

19 #define tRETURN 269

20 #define tIF 270

21 #define tELSE 271

22 #define tLOCAL 272

23 #define tWHILE 273

24 #define tFOR 274

25 #define tEXTENDS 275

26 #define tADDASSIGN 276

27 #define tSUBASSIGN 277

28 #define tMULASSIGN 278

29 #define tDIVASSIGN 279

30 #define tOR 280

31 #define tAND 281

32 #define tEQ 282

33 #define tNE 283

34 #define tGE 284

35 #define tLE 285

36 #define tDIV 286

37 #define tPLUSPLUS 287

38 #define tMINUSMINUS 288

39

40 #line 1 "gram.y"

41

42 /* -*- c -*-

43 * Grammar for states.

45 *

46 * Author: Markku Rossi <mtr@iki.fi>

47 */

48

49 /*

50 * This file is part of GNU enscript.

51 *

52 * This program is free software; you can redistribute it and/or modify

53 * it under the terms of the GNU General Public License as published by

54 * the Free Software Foundation; either version 2, or (at your option)

55 * any later version.

56 *

57 * This program is distributed in the hope that it will be useful,

58 * but WITHOUT ANY WARRANTY; without even the implied warranty of

59 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

60 * GNU General Public License for more details.

61 *

62 * You should have received a copy of the GNU General Public License

63 * along with this program; see the file COPYING. If not, write to

64 * the Free Software Foundation, 51 Franklin Street, Fifth Floor,

65 * Boston, MA 02110-1301, USA.

66 */

67

68 /*

69 * $Id: gram.c,v 1.1.1.1 2003/03/05 07:25:52 mtr Exp $

70 */

71

72 #include "defs.h"

73

74 #line 35 "gram.y"

75 typedef union

76 {

77 List *lst;

78 Node *node;

79 Cons *cons;

80 Stmt *stmt;

81 Expr *expr;

82 } YYSTYPE;

83 #include <stdio.h>

84

85 #ifndef __cplusplus

86 #ifndef __STDC__

87 #define const

88 #endif

89 #endif

90

91

92

93 #define YYFINAL 167

94 #define YYFLAG -32768

95 #define YYNTBASE 52

96

97 #define YYTRANSLATE(x) ((unsigned)(x) <= 288 ? yytranslate[x] : 68)

98

99 static const char yytranslate[] = { 0,

100 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

101 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

102 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

103 2, 2, 41, 2, 2, 2, 2, 2, 2, 50,

104 51, 39, 37, 49, 38, 2, 2, 2, 2, 2,

105 2, 2, 2, 2, 2, 2, 2, 28, 48, 33,

106 22, 34, 27, 2, 2, 2, 2, 2, 2, 2,

107 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

108 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

109 44, 2, 45, 2, 2, 2, 2, 2, 2, 2,

110 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

111 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

112 2, 2, 46, 2, 47, 2, 2, 2, 2, 2,

113 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

114 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

115 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

116 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

117 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

118 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

119 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

120 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

121 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

122 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

123 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

124 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,

125 2, 2, 2, 2, 2, 1, 3, 4, 5, 6,

126 7, 8, 9, 10, 11, 12, 13, 14, 15, 16,

127 17, 18, 19, 20, 21, 23, 24, 25, 26, 29,

128 30, 31, 32, 35, 36, 40, 42, 43

129 };

130

131 #if YYDEBUG != 0

132 static const short yyprhs[] = { 0,

133 0, 1, 4, 9, 14, 19, 25, 33, 35, 36,

134 41, 42, 45, 50, 55, 60, 65, 66, 68, 70,

135 74, 75, 79, 81, 85, 87, 91, 92, 95, 98,

136 102, 112, 116, 122, 130, 136, 146, 149, 151, 153,

137 155, 157, 159, 162, 166, 170, 175, 179, 183, 187,

138 191, 195, 198, 201, 204, 207, 214, 218, 223, 229,

139 233, 237, 241, 245, 249, 253, 257, 261, 265, 269,

140 270, 272, 273, 275, 277

141 };

142

143 static const short yyrhs[] = { -1,

144 52, 53, 0, 10, 46, 62, 47, 0, 11, 46,

145 54, 47, 0, 12, 46, 54, 47, 0, 9, 3,

146 46, 55, 47, 0, 9, 3, 21, 3, 46, 55,

147 47, 0, 63, 0, 0, 54, 4, 3, 48, 0,

148 0, 55, 56, 0, 13, 46, 62, 47, 0, 14,

149 46, 62, 47, 0, 4, 46, 62, 47, 0, 3,

150 46, 62, 47, 0, 0, 58, 0, 3, 0, 58,

151 49, 3, 0, 0, 18, 60, 48, 0, 61, 0,

152 60, 49, 61, 0, 3, 0, 3, 22, 64, 0,

153 0, 62, 63, 0, 15, 48, 0, 15, 64, 48,

154 0, 8, 3, 50, 57, 51, 46, 59, 62, 47,

155 0, 46, 62, 47, 0, 16, 50, 64, 51, 63,

156 0, 16, 50, 64, 51, 63, 17, 63, 0, 19,

157 50, 64, 51, 63, 0, 20, 50, 65, 48, 64,

158 48, 65, 51, 63, 0, 64, 48, 0, 5, 0,

159 4, 0, 6, 0, 7, 0, 3, 0, 41, 64,

160 0, 64, 30, 64, 0, 64, 29, 64, 0, 3,

161 50, 66, 51, 0, 3, 22, 64, 0, 3, 23,

162 64, 0, 3, 24, 64, 0, 3, 25, 64, 0,

163 3, 26, 64, 0, 3, 42, 0, 3, 43, 0,

164 42, 3, 0, 43, 3, 0, 64, 44, 64, 45,

165 22, 64, 0, 50, 64, 51, 0, 64, 44, 64,

166 45, 0, 64, 27, 64, 28, 64, 0, 64, 39,

167 64, 0, 64, 40, 64, 0, 64, 37, 64, 0,

168 64, 38, 64, 0, 64, 33, 64, 0, 64, 34,

169 64, 0, 64, 31, 64, 0, 64, 32, 64, 0,

170 64, 35, 64, 0, 64, 36, 64, 0, 0, 64,

171 0, 0, 67, 0, 64, 0, 67, 49, 64, 0

172 };

173

174 #endif

175

176 #if YYDEBUG != 0

177 static const short yyrline[] = { 0,

178 67, 68, 71, 72, 74, 76, 78, 80, 83, 84,

179 88, 89, 91, 92, 93, 94, 97, 98, 101, 102,

180 105, 106, 109, 110, 113, 114, 117, 118, 121, 123,

181 125, 130, 132, 134, 137, 139, 142, 146, 148, 150,

182 152, 154, 156, 158, 159, 160, 162, 164, 166, 168,

183 170, 172, 174, 176, 178, 180, 182, 183, 185, 187,

184 188, 189, 190, 192, 193, 194, 195, 196, 197, 200,

185 201, 204, 205, 208, 209

186 };

187 #endif

188

189

190 #if YYDEBUG != 0 || defined (YYERROR_VERBOSE)

191

192 static const char * const yytname[] = { "$","error","$undefined.","tSYMBOL",

193 "tREGEXP","tSTRING","tINTEGER","tREAL","tSUB","tSTATE","tSTART","tSTARTRULES",

194 "tNAMERULES","tBEGIN","tEND","tRETURN","tIF","tELSE","tLOCAL","tWHILE","tFOR",

195 "tEXTENDS","'='","tADDASSIGN","tSUBASSIGN","tMULASSIGN","tDIVASSIGN","'?'","':'",

196 "tOR","tAND","tEQ","tNE","'<'","'>'","tGE","tLE","'+'","'-'","'*'","tDIV","'!'",

197 "tPLUSPLUS","tMINUSMINUS","'['","']'","'{'","'}'","';'","','","'('","')'","file",

198 "toplevel","regexp_sym_list","staterules","staterule","symbol_list","rest_symbol_list",

199 "locals","locals_rest","local_def","stmt_list","stmt","expr","cond_expr","expr_list",

200 "rest_expr_list", NULL

201 };

202 #endif

203

204 static const short yyr1[] = { 0,

205 52, 52, 53, 53, 53, 53, 53, 53, 54, 54,

206 55, 55, 56, 56, 56, 56, 57, 57, 58, 58,

207 59, 59, 60, 60, 61, 61, 62, 62, 63, 63,

208 63, 63, 63, 63, 63, 63, 63, 64, 64, 64,

209 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

210 64, 64, 64, 64, 64, 64, 64, 64, 64, 64,

211 64, 64, 64, 64, 64, 64, 64, 64, 64, 65,

212 65, 66, 66, 67, 67

213 };

214

215 static const short yyr2[] = { 0,

216 0, 2, 4, 4, 4, 5, 7, 1, 0, 4,

217 0, 2, 4, 4, 4, 4, 0, 1, 1, 3,

218 0, 3, 1, 3, 1, 3, 0, 2, 2, 3,

219 9, 3, 5, 7, 5, 9, 2, 1, 1, 1,

220 1, 1, 2, 3, 3, 4, 3, 3, 3, 3,

221 3, 2, 2, 2, 2, 6, 3, 4, 5, 3,

222 3, 3, 3, 3, 3, 3, 3, 3, 3, 0,

223 1, 0, 1, 1, 3

224 };

225

226 static const short yydefact[] = { 1,

227 0, 42, 39, 38, 40, 41, 0, 0, 0, 0,

228 0, 0, 0, 0, 0, 0, 0, 0, 27, 0,

229 2, 8, 0, 0, 0, 0, 0, 0, 52, 53,

230 72, 0, 0, 27, 9, 9, 29, 0, 0, 0,

231 70, 43, 54, 55, 0, 0, 0, 0, 0, 0,

232 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,

233 37, 47, 48, 49, 50, 51, 74, 0, 73, 17,

234 0, 11, 0, 0, 0, 30, 0, 0, 71, 0,

235 32, 28, 57, 0, 45, 44, 66, 67, 64, 65,

236 68, 69, 62, 63, 60, 61, 0, 46, 0, 19,

237 0, 18, 0, 0, 3, 0, 4, 5, 0, 0,

238 0, 0, 58, 75, 0, 0, 11, 0, 0, 0,

239 0, 6, 12, 0, 33, 35, 0, 59, 0, 21,

240 20, 0, 27, 27, 27, 27, 10, 0, 70, 56,

241 0, 27, 7, 0, 0, 0, 0, 34, 0, 25,

242 0, 23, 0, 16, 15, 13, 14, 0, 0, 22,

243 0, 31, 36, 26, 24, 0, 0

244 };

245

246 static const short yydefgoto[] = { 1,

247 21, 74, 104, 123, 101, 102, 142, 151, 152, 45,

248 82, 23, 80, 68, 69

249 };

250

251 static const short yypact[] = {-32768,

252 71, 270,-32768,-32768,-32768,-32768, 1, 9, -40, -28,

253 -27, 18, -24, -18, -17, 90, 28, 31,-32768, 90,

254 -32768,-32768, 374, 90, 90, 90, 90, 90,-32768,-32768,

255 90, -15, -19,-32768,-32768,-32768,-32768, 394, 90, 90,

256 90, 12,-32768,-32768, 119, 305, 90, 90, 90, 90,

257 90, 90, 90, 90, 90, 90, 90, 90, 90, 90,

258 -32768, 469, 469, 469, 469, 469, 469, 7, 20, 64,

259 67,-32768, 139, 3, 4,-32768, 328, 351, 469, 36,

260 -32768,-32768,-32768, 453, 484, 498, 510, 510, 112, 112,

261 112, 112, 13, 13, 12, 12, 434,-32768, 90,-32768,

262 34, 40, 46, 51,-32768, 96,-32768,-32768, 283, 283,

263 90, 90, 85, 469, 69, 107,-32768, 70, 73, 74,

264 83,-32768,-32768, 82, 124,-32768, 414, 469, 90, 118,

265 -32768, 59,-32768,-32768,-32768,-32768,-32768, 283, 90, 469,

266 150,-32768,-32768, 168, 187, 216, 235,-32768, 113, 141,

267 -38,-32768, 264,-32768,-32768,-32768,-32768, 283, 90,-32768,

268 150,-32768,-32768, 469,-32768, 167,-32768

269 };

270

271 static const short yypgoto[] = {-32768,

272 -32768, 132, 53,-32768,-32768,-32768,-32768,-32768, 16, -31,

273 -1, -11, 39,-32768,-32768

274 };

275

276

277 #define YYLAST 554

278

279

280 static const short yytable[] = { 22,

281 38, 71, 73, 32, 42, 34, 106, 106, 46, 160,

282 161, 33, 62, 63, 64, 65, 66, 35, 36, 67,

283 2, 3, 4, 5, 6, 39, 72, 77, 78, 79,

284 43, 40, 41, 44, 70, 84, 85, 86, 87, 88,

285 89, 90, 91, 92, 93, 94, 95, 96, 97, 107,

286 108, 58, 59, 118, 119, 60, 60, 98, 16, 17,

287 18, 118, 119, 120, 121, 37, 100, 20, 99, 103,

288 166, 120, 121, 2, 3, 4, 5, 6, 7, 8,

289 9, 10, 11, 111, 115, 12, 13, 114, 116, 14,

290 15, 117, 2, 3, 4, 5, 6, 122, 124, 127,

291 128, 144, 145, 146, 147, 143, 129, 125, 126, 131,

292 153, 16, 17, 18, 130, 133, 19, 140, 134, 135,

293 20, 2, 3, 4, 5, 6, 7, 79, 136, 137,

294 16, 17, 18, 12, 13, 141, 148, 14, 15, 20,

295 138, 2, 3, 4, 5, 6, 7, 164, 56, 57,

296 58, 59, 150, 12, 13, 60, 163, 14, 15, 16,

297 17, 18, 159, 158, 19, 81, 167, 75, 20, 132,

298 2, 3, 4, 5, 6, 7, 165, 149, 0, 16,

299 17, 18, 12, 13, 19, 105, 14, 15, 20, 2,

300 3, 4, 5, 6, 7, 0, 0, 0, 0, 0,

301 0, 12, 13, 0, 0, 14, 15, 0, 16, 17,

302 18, 0, 0, 19, 154, 0, 0, 20, 2, 3,

303 4, 5, 6, 7, 0, 0, 0, 16, 17, 18,

304 12, 13, 19, 155, 14, 15, 20, 2, 3, 4,

305 5, 6, 7, 0, 0, 0, 0, 0, 0, 12,

306 13, 0, 0, 14, 15, 0, 16, 17, 18, 0,

307 0, 19, 156, 0, 0, 20, 2, 3, 4, 5,

308 6, 7, 0, 0, 0, 16, 17, 18, 12, 13,

309 19, 157, 14, 15, 20, 2, 3, 4, 5, 6,

310 7, 24, 25, 26, 27, 28, 0, 12, 13, 0,

311 0, 14, 15, 0, 16, 17, 18, 0, 0, 19,

312 162, 29, 30, 20, 0, 0, 0, 0, 0, 31,

313 0, 0, 0, 16, 17, 18, 0, 0, 19, 0,

314 0, 47, 20, 48, 49, 50, 51, 52, 53, 54,

315 55, 56, 57, 58, 59, 0, 0, 0, 60, 0,

316 0, 0, 0, 0, 47, 83, 48, 49, 50, 51,

317 52, 53, 54, 55, 56, 57, 58, 59, 0, 0,

318 0, 60, 0, 0, 0, 0, 0, 47, 109, 48,

319 49, 50, 51, 52, 53, 54, 55, 56, 57, 58,

320 59, 0, 0, 0, 60, 0, 0, 0, 0, 0,

321 47, 110, 48, 49, 50, 51, 52, 53, 54, 55,

322 56, 57, 58, 59, 0, 0, 0, 60, 0, 0,

323 47, 61, 48, 49, 50, 51, 52, 53, 54, 55,

324 56, 57, 58, 59, 0, 0, 0, 60, 0, 0,

325 47, 76, 48, 49, 50, 51, 52, 53, 54, 55,

326 56, 57, 58, 59, 0, 0, 0, 60, 0, 0,

327 47, 139, 48, 49, 50, 51, 52, 53, 54, 55,

328 56, 57, 58, 59, 0, 0, 0, 60, 113, 47,

329 112, 48, 49, 50, 51, 52, 53, 54, 55, 56,

330 57, 58, 59, 0, 0, 47, 60, 48, 49, 50,

331 51, 52, 53, 54, 55, 56, 57, 58, 59, 0,

332 0, 0, 60, 49, 50, 51, 52, 53, 54, 55,

333 56, 57, 58, 59, 0, 0, 0, 60, 50, 51,

334 52, 53, 54, 55, 56, 57, 58, 59, 0, 0,

335 0, 60, 52, 53, 54, 55, 56, 57, 58, 59,

336 0, 0, 0, 60

337 };

338

339 static const short yycheck[] = { 1,

340 12, 21, 34, 3, 16, 46, 4, 4, 20, 48,

341 49, 3, 24, 25, 26, 27, 28, 46, 46, 31,

342 3, 4, 5, 6, 7, 50, 46, 39, 40, 41,

343 3, 50, 50, 3, 50, 47, 48, 49, 50, 51,

344 52, 53, 54, 55, 56, 57, 58, 59, 60, 47,

345 47, 39, 40, 3, 4, 44, 44, 51, 41, 42,

346 43, 3, 4, 13, 14, 48, 3, 50, 49, 3,

347 0, 13, 14, 3, 4, 5, 6, 7, 8, 9,

348 10, 11, 12, 48, 51, 15, 16, 99, 49, 19,

349 20, 46, 3, 4, 5, 6, 7, 47, 3, 111,

350 112, 133, 134, 135, 136, 47, 22, 109, 110, 3,

351 142, 41, 42, 43, 46, 46, 46, 129, 46, 46,

352 50, 3, 4, 5, 6, 7, 8, 139, 46, 48,

353 41, 42, 43, 15, 16, 18, 138, 19, 20, 50,

354 17, 3, 4, 5, 6, 7, 8, 159, 37, 38,

355 39, 40, 3, 15, 16, 44, 158, 19, 20, 41,

356 42, 43, 22, 51, 46, 47, 0, 36, 50, 117,

357 3, 4, 5, 6, 7, 8, 161, 139, -1, 41,

358 42, 43, 15, 16, 46, 47, 19, 20, 50, 3,

359 4, 5, 6, 7, 8, -1, -1, -1, -1, -1,

360 -1, 15, 16, -1, -1, 19, 20, -1, 41, 42,

361 43, -1, -1, 46, 47, -1, -1, 50, 3, 4,

362 5, 6, 7, 8, -1, -1, -1, 41, 42, 43,

363 15, 16, 46, 47, 19, 20, 50, 3, 4, 5,

364 6, 7, 8, -1, -1, -1, -1, -1, -1, 15,

365 16, -1, -1, 19, 20, -1, 41, 42, 43, -1,

366 -1, 46, 47, -1, -1, 50, 3, 4, 5, 6,

367 7, 8, -1, -1, -1, 41, 42, 43, 15, 16,

368 46, 47, 19, 20, 50, 3, 4, 5, 6, 7,

369 8, 22, 23, 24, 25, 26, -1, 15, 16, -1,

370 -1, 19, 20, -1, 41, 42, 43, -1, -1, 46,

371 47, 42, 43, 50, -1, -1, -1, -1, -1, 50,

372 -1, -1, -1, 41, 42, 43, -1, -1, 46, -1,

373 -1, 27, 50, 29, 30, 31, 32, 33, 34, 35,

374 36, 37, 38, 39, 40, -1, -1, -1, 44, -1,

375 -1, -1, -1, -1, 27, 51, 29, 30, 31, 32,

376 33, 34, 35, 36, 37, 38, 39, 40, -1, -1,

377 -1, 44, -1, -1, -1, -1, -1, 27, 51, 29,

378 30, 31, 32, 33, 34, 35, 36, 37, 38, 39,

379 40, -1, -1, -1, 44, -1, -1, -1, -1, -1,

380 27, 51, 29, 30, 31, 32, 33, 34, 35, 36,

381 37, 38, 39, 40, -1, -1, -1, 44, -1, -1,

382 27, 48, 29, 30, 31, 32, 33, 34, 35, 36,

383 37, 38, 39, 40, -1, -1, -1, 44, -1, -1,

384 27, 48, 29, 30, 31, 32, 33, 34, 35, 36,

385 37, 38, 39, 40, -1, -1, -1, 44, -1, -1,

386 27, 48, 29, 30, 31, 32, 33, 34, 35, 36,

387 37, 38, 39, 40, -1, -1, -1, 44, 45, 27,

388 28, 29, 30, 31, 32, 33, 34, 35, 36, 37,

389 38, 39, 40, -1, -1, 27, 44, 29, 30, 31,

390 32, 33, 34, 35, 36, 37, 38, 39, 40, -1,

391 -1, -1, 44, 30, 31, 32, 33, 34, 35, 36,

392 37, 38, 39, 40, -1, -1, -1, 44, 31, 32,

393 33, 34, 35, 36, 37, 38, 39, 40, -1, -1,

394 -1, 44, 33, 34, 35, 36, 37, 38, 39, 40,

395 -1, -1, -1, 44

396 };

397 /* -*-C-*- Note some compilers choke on comments on `#line' lines. */

398 #line 3 "/l/mtr/gnu/share/bison.simple"

399 /* This file comes from bison-1.28. */

400

401 /* Skeleton output parser for bison,

403

404 This program is free software; you can redistribute it and/or modify

405 it under the terms of the GNU General Public License as published by

406 the Free Software Foundation; either version 2, or (at your option)

407 any later version.

408

409 This program is distributed in the hope that it will be useful,

410 but WITHOUT ANY WARRANTY; without even the implied warranty of

411 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

412 GNU General Public License for more details.

413

414 You should have received a copy of the GNU General Public License

415 along with this program; if not, write to the Free Software

416 Foundation, Inc., 51 Franklin Street, Fifth Floor,

417 Boston, MA 02110-1301, USA. */

418

419 /* As a special exception, when this file is copied by Bison into a

420 Bison output file, you may use that output file without restriction.

421 This special exception was added by the Free Software Foundation

422 in version 1.24 of Bison. */

423

424 /* This is the parser code that is written into each bison parser

425 when the %semantic_parser declaration is not specified in the grammar.

426 It was written by Richard Stallman by simplifying the hairy parser

427 used when %semantic_parser is specified. */

428

429 #ifndef YYSTACK_USE_ALLOCA

430 #ifdef alloca

431 #define YYSTACK_USE_ALLOCA

432 #else /* alloca not defined */

433 #ifdef __GNUC__

434 #define YYSTACK_USE_ALLOCA

435 #define alloca __builtin_alloca

436 #else /* not GNU C. */

437 #if (!defined (__STDC__) && defined (sparc)) || defined (__sparc__) || defined (__sparc) || defined (__sgi) || (defined (__sun) && defined (__i386))

438 #define YYSTACK_USE_ALLOCA

439 #include <alloca.h>

440 #else /* not sparc */

441 /* We think this test detects Watcom and Microsoft C. */

442 /* This used to test MSDOS, but that is a bad idea

443 since that symbol is in the user namespace. */

444 #if (defined (_MSDOS) || defined (_MSDOS_)) && !defined (__TURBOC__)

445 #if 0 /* No need for malloc.h, which pollutes the namespace;

446 instead, just don't use alloca. */

447 #include <malloc.h>

448 #endif

449 #else /* not MSDOS, or __TURBOC__ */

450 #if defined(_AIX)

451 /* I don't know what this was needed for, but it pollutes the namespace.

452 So I turned it off. rms, 2 May 1997. */

453 /* #include <malloc.h> */

454 #pragma alloca

455 #define YYSTACK_USE_ALLOCA

456 #else /* not MSDOS, or __TURBOC__, or _AIX */

457 #if 0

458 #ifdef __hpux /* haible@ilog.fr says this works for HPUX 9.05 and up,

459 and on HPUX 10. Eventually we can turn this on. */

460 #define YYSTACK_USE_ALLOCA

461 #define alloca __builtin_alloca

462 #endif /* __hpux */

463 #endif

464 #endif /* not _AIX */

465 #endif /* not MSDOS, or __TURBOC__ */

466 #endif /* not sparc */

467 #endif /* not GNU C */

468 #endif /* alloca not defined */

469 #endif /* YYSTACK_USE_ALLOCA not defined */

470

471 #ifdef YYSTACK_USE_ALLOCA

472 #define YYSTACK_ALLOC alloca

473 #else

474 #define YYSTACK_ALLOC malloc

475 #endif

476

477 /* Note: there must be only one dollar sign in this file.

478 It is replaced by the list of actions, each action

479 as one case of the switch. */

480

481 #define yyerrok (yyerrstatus = 0)

482 #define yyclearin (yychar = YYEMPTY)

483 #define YYEMPTY -2

484 #define YYEOF 0

485 #define YYACCEPT goto yyacceptlab

486 #define YYABORT goto yyabortlab

487 #define YYERROR goto yyerrlab1

488 /* Like YYERROR except do call yyerror.

489 This remains here temporarily to ease the

490 transition to the new meaning of YYERROR, for GCC.

491 Once GCC version 2 has supplanted version 1, this can go. */

492 #define YYFAIL goto yyerrlab

493 #define YYRECOVERING() (!!yyerrstatus)

494 #define YYBACKUP(token, value) \

495 do \

496 if (yychar == YYEMPTY && yylen == 1) \

497 { yychar = (token), yylval = (value); \

498 yychar1 = YYTRANSLATE (yychar); \

499 YYPOPSTACK; \

500 goto yybackup; \

501 } \

502 else \

503 { yyerror ("syntax error: cannot back up"); YYERROR; } \

504 while (0)

505

506 #define YYTERROR 1

507 #define YYERRCODE 256

508

509 #ifndef YYPURE

510 #define YYLEX yylex()

511 #endif

512

513 #ifdef YYPURE

514 #ifdef YYLSP_NEEDED

515 #ifdef YYLEX_PARAM

516 #define YYLEX yylex(&yylval, &yylloc, YYLEX_PARAM)

517 #else

518 #define YYLEX yylex(&yylval, &yylloc)

519 #endif

520 #else /* not YYLSP_NEEDED */

521 #ifdef YYLEX_PARAM

522 #define YYLEX yylex(&yylval, YYLEX_PARAM)

523 #else

524 #define YYLEX yylex(&yylval)

525 #endif

526 #endif /* not YYLSP_NEEDED */

527 #endif

528

529 /* If nonreentrant, generate the variables here */

530

531 #ifndef YYPURE

532

533 int yychar; /* the lookahead symbol */

534 YYSTYPE yylval; /* the semantic value of the */

535 /* lookahead symbol */

536

537 #ifdef YYLSP_NEEDED

538 YYLTYPE yylloc; /* location data for the lookahead */

539 /* symbol */

540 #endif

541

542 int yynerrs; /* number of parse errors so far */

543 #endif /* not YYPURE */

544

545 #if YYDEBUG != 0

546 int yydebug; /* nonzero means print parse trace */

547 /* Since this is uninitialized, it does not stop multiple parsers

548 from coexisting. */

549 #endif

550

551 /* YYINITDEPTH indicates the initial size of the parser's stacks */

552

553 #ifndef YYINITDEPTH

554 #define YYINITDEPTH 200

555 #endif

556

557 /* YYMAXDEPTH is the maximum size the stacks can grow to

558 (effective only if the built-in stack extension method is used). */

559

560 #if YYMAXDEPTH == 0

561 #undef YYMAXDEPTH

562 #endif

563

564 #ifndef YYMAXDEPTH

565 #define YYMAXDEPTH 10000

566 #endif

567 \f

568 /* Define __yy_memcpy. Note that the size argument

569 should be passed with type unsigned int, because that is what the non-GCC

570 definitions require. With GCC, __builtin_memcpy takes an arg

571 of type size_t, but it can handle unsigned int. */

572

573 #if __GNUC__ > 1 /* GNU C and GNU C++ define this. */

574 #define __yy_memcpy(TO,FROM,COUNT) __builtin_memcpy(TO,FROM,COUNT)

575 #else /* not GNU C or C++ */

576 #ifndef __cplusplus

577

578 /* This is the most reliable way to avoid incompatibilities

579 in available built-in functions on various systems. */

580 static void

581 __yy_memcpy (to, from, count)

582 char *to;

583 char *from;

584 unsigned int count;

585 {

586 register char *f = from;

587 register char *t = to;

588 register int i = count;

589

590 while (i-- > 0)

591 *t++ = *f++;

592 }

593

594 #else /* __cplusplus */

595

596 /* This is the most reliable way to avoid incompatibilities

597 in available built-in functions on various systems. */

598 static void

599 __yy_memcpy (char *to, char *from, unsigned int count)

600 {

601 register char *t = to;

602 register char *f = from;

603 register int i = count;

604

605 while (i-- > 0)

606 *t++ = *f++;

607 }

608

609 #endif

610 #endif

611 \f

612 #line 217 "/l/mtr/gnu/share/bison.simple"

613

614 /* The user can define YYPARSE_PARAM as the name of an argument to be passed

615 into yyparse. The argument should have type void *.

616 It should actually point to an object.

617 Grammar actions can access the variable by casting it

618 to the proper pointer type. */

619

620 #ifdef YYPARSE_PARAM

621 #ifdef __cplusplus

622 #define YYPARSE_PARAM_ARG void *YYPARSE_PARAM

623 #define YYPARSE_PARAM_DECL

624 #else /* not __cplusplus */

625 #define YYPARSE_PARAM_ARG YYPARSE_PARAM

626 #define YYPARSE_PARAM_DECL void *YYPARSE_PARAM;

627 #endif /* not __cplusplus */

628 #else /* not YYPARSE_PARAM */

629 #define YYPARSE_PARAM_ARG

630 #define YYPARSE_PARAM_DECL

631 #endif /* not YYPARSE_PARAM */

632

633 /* Prevent warning if -Wstrict-prototypes. */

634 #ifdef __GNUC__

635 #ifdef YYPARSE_PARAM

636 int yyparse (void *);

637 #else

638 int yyparse (void);

639 #endif

640 #endif

641

642 int

643 yyparse(YYPARSE_PARAM_ARG)

644 YYPARSE_PARAM_DECL

645 {

646 register int yystate;

647 register int yyn;

648 register short *yyssp;

649 register YYSTYPE *yyvsp;

650 int yyerrstatus; /* number of tokens to shift before error messages enabled */

651 int yychar1 = 0; /* lookahead token as an internal (translated) token number */

652

653 short yyssa[YYINITDEPTH]; /* the state stack */

654 YYSTYPE yyvsa[YYINITDEPTH]; /* the semantic value stack */

655

656 short *yyss = yyssa; /* refer to the stacks thru separate pointers */

657 YYSTYPE *yyvs = yyvsa; /* to allow yyoverflow to reallocate them elsewhere */

658

659 #ifdef YYLSP_NEEDED

660 YYLTYPE yylsa[YYINITDEPTH]; /* the location stack */

661 YYLTYPE *yyls = yylsa;

662 YYLTYPE *yylsp;

663

664 #define YYPOPSTACK (yyvsp--, yyssp--, yylsp--)

665 #else

666 #define YYPOPSTACK (yyvsp--, yyssp--)

667 #endif

668

669 int yystacksize = YYINITDEPTH;

670 int yyfree_stacks = 0;

671

672 #ifdef YYPURE

673 int yychar;

674 YYSTYPE yylval;

675 int yynerrs;

676 #ifdef YYLSP_NEEDED

677 YYLTYPE yylloc;

678 #endif

679 #endif

680

681 YYSTYPE yyval; /* the variable used to return */

682 /* semantic values from the action */

683 /* routines */

684

685 int yylen;

686

687 #if YYDEBUG != 0

688 if (yydebug)

689 fprintf(stderr, "Starting parse\n");

690 #endif

691

692 yystate = 0;

693 yyerrstatus = 0;

694 yynerrs = 0;

695 yychar = YYEMPTY; /* Cause a token to be read. */

696

697 /* Initialize stack pointers.

698 Waste one element of value and location stack

699 so that they stay on the same level as the state stack.

700 The wasted elements are never initialized. */

701

702 yyssp = yyss - 1;

703 yyvsp = yyvs;

704 #ifdef YYLSP_NEEDED

705 yylsp = yyls;

706 #endif

707

708 /* Push a new state, which is found in yystate . */

709 /* In all cases, when you get here, the value and location stacks

710 have just been pushed. so pushing a state here evens the stacks. */

711 yynewstate:

712

713 *++yyssp = yystate;

714

715 if (yyssp >= yyss + yystacksize - 1)

716 {

717 /* Give user a chance to reallocate the stack */

718 /* Use copies of these so that the &'s don't force the real ones into memory. */

719 YYSTYPE *yyvs1 = yyvs;

720 short *yyss1 = yyss;

721 #ifdef YYLSP_NEEDED

722 YYLTYPE *yyls1 = yyls;

723 #endif

724

725 /* Get the current used size of the three stacks, in elements. */

726 int size = yyssp - yyss + 1;

727

728 #ifdef yyoverflow

729 /* Each stack pointer address is followed by the size of

730 the data in use in that stack, in bytes. */

731 #ifdef YYLSP_NEEDED

732 /* This used to be a conditional around just the two extra args,

733 but that might be undefined if yyoverflow is a macro. */

734 yyoverflow("parser stack overflow",

735 &yyss1, size * sizeof (*yyssp),

736 &yyvs1, size * sizeof (*yyvsp),

737 &yyls1, size * sizeof (*yylsp),

738 &yystacksize);

739 #else

740 yyoverflow("parser stack overflow",

741 &yyss1, size * sizeof (*yyssp),

742 &yyvs1, size * sizeof (*yyvsp),

743 &yystacksize);

744 #endif

745

746 yyss = yyss1; yyvs = yyvs1;

747 #ifdef YYLSP_NEEDED

748 yyls = yyls1;

749 #endif

750 #else /* no yyoverflow */

751 /* Extend the stack our own way. */

752 if (yystacksize >= YYMAXDEPTH)

753 {

754 yyerror("parser stack overflow");

755 if (yyfree_stacks)

756 {

757 free (yyss);

758 free (yyvs);

759 #ifdef YYLSP_NEEDED

760 free (yyls);

761 #endif

762 }

763 return 2;

764 }

765 yystacksize *= 2;

766 if (yystacksize > YYMAXDEPTH)

767 yystacksize = YYMAXDEPTH;

768 #ifndef YYSTACK_USE_ALLOCA

769 yyfree_stacks = 1;

770 #endif

771 yyss = (short *) YYSTACK_ALLOC (yystacksize * sizeof (*yyssp));

772 __yy_memcpy ((char *)yyss, (char *)yyss1,

773 size * (unsigned int) sizeof (*yyssp));

774 yyvs = (YYSTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yyvsp));

775 __yy_memcpy ((char *)yyvs, (char *)yyvs1,

776 size * (unsigned int) sizeof (*yyvsp));

777 #ifdef YYLSP_NEEDED

778 yyls = (YYLTYPE *) YYSTACK_ALLOC (yystacksize * sizeof (*yylsp));

779 __yy_memcpy ((char *)yyls, (char *)yyls1,

780 size * (unsigned int) sizeof (*yylsp));

781 #endif

782 #endif /* no yyoverflow */

783

784 yyssp = yyss + size - 1;

785 yyvsp = yyvs + size - 1;

786 #ifdef YYLSP_NEEDED

787 yylsp = yyls + size - 1;

788 #endif

789

790 #if YYDEBUG != 0

791 if (yydebug)

792 fprintf(stderr, "Stack size increased to %d\n", yystacksize);

793 #endif

794

795 if (yyssp >= yyss + yystacksize - 1)

796 YYABORT;

797 }

798

799 #if YYDEBUG != 0

800 if (yydebug)

801 fprintf(stderr, "Entering state %d\n", yystate);

802 #endif

803

804 goto yybackup;

805 yybackup:

806

807 /* Do appropriate processing given the current state. */

808 /* Read a lookahead token if we need one and don't already have one. */

809 /* yyresume: */

810

811 /* First try to decide what to do without reference to lookahead token. */

812

813 yyn = yypact[yystate];

814 if (yyn == YYFLAG)

815 goto yydefault;

816

817 /* Not known => get a lookahead token if don't already have one. */

818

819 /* yychar is either YYEMPTY or YYEOF

820 or a valid token in external form. */

821

822 if (yychar == YYEMPTY)

823 {

824 #if YYDEBUG != 0

825 if (yydebug)

826 fprintf(stderr, "Reading a token: ");

827 #endif

828 yychar = YYLEX;

829 }

830

831 /* Convert token to internal form (in yychar1) for indexing tables with */

832

833 if (yychar <= 0) /* This means end of input. */

834 {

835 yychar1 = 0;

836 yychar = YYEOF; /* Don't call YYLEX any more */

837

838 #if YYDEBUG != 0

839 if (yydebug)

840 fprintf(stderr, "Now at end of input.\n");

841 #endif

842 }

843 else

844 {

845 yychar1 = YYTRANSLATE(yychar);

846

847 #if YYDEBUG != 0

848 if (yydebug)

849 {

850 fprintf (stderr, "Next token is %d (%s", yychar, yytname[yychar1]);

851 /* Give the individual parser a way to print the precise meaning

852 of a token, for further debugging info. */

853 #ifdef YYPRINT

854 YYPRINT (stderr, yychar, yylval);

855 #endif

856 fprintf (stderr, ")\n");

857 }

858 #endif

859 }

860

861 yyn += yychar1;

862 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != yychar1)

863 goto yydefault;

864

865 yyn = yytable[yyn];

866

867 /* yyn is what to do for this token type in this state.

868 Negative => reduce, -yyn is rule number.

869 Positive => shift, yyn is new state.

870 New state is final state => don't bother to shift,

871 just return success.

872 0, or most negative number => error. */

873

874 if (yyn < 0)

875 {

876 if (yyn == YYFLAG)

877 goto yyerrlab;

878 yyn = -yyn;

879 goto yyreduce;

880 }

881 else if (yyn == 0)

882 goto yyerrlab;

883

884 if (yyn == YYFINAL)

885 YYACCEPT;

886

887 /* Shift the lookahead token. */

888

889 #if YYDEBUG != 0

890 if (yydebug)

891 fprintf(stderr, "Shifting token %d (%s), ", yychar, yytname[yychar1]);

892 #endif

893

894 /* Discard the token being shifted unless it is eof. */

895 if (yychar != YYEOF)

896 yychar = YYEMPTY;

897

898 *++yyvsp = yylval;

899 #ifdef YYLSP_NEEDED

900 *++yylsp = yylloc;

901 #endif

902

903 /* count tokens shifted since error; after three, turn off error status. */

904 if (yyerrstatus) yyerrstatus--;

905

906 yystate = yyn;

907 goto yynewstate;

908

909 /* Do the default action for the current state. */

910 yydefault:

911

912 yyn = yydefact[yystate];

913 if (yyn == 0)

914 goto yyerrlab;

915

916 /* Do a reduction. yyn is the number of a rule to reduce with. */

917 yyreduce:

918 yylen = yyr2[yyn];

919 if (yylen > 0)

920 yyval = yyvsp[1-yylen]; /* implement default value of the action */

921

922 #if YYDEBUG != 0

923 if (yydebug)

924 {

925 int i;

926

927 fprintf (stderr, "Reducing via rule %d (line %d), ",

928 yyn, yyrline[yyn]);

929

930 /* Print the symbols being reduced, and their result. */

931 for (i = yyprhs[yyn]; yyrhs[i] > 0; i++)

932 fprintf (stderr, "%s ", yytname[yyrhs[i]]);

933 fprintf (stderr, " -> %s\n", yytname[yyr1[yyn]]);

934 }

935 #endif

936

937

938 switch (yyn) {

939

940 case 3:

941 #line 71 "gram.y"

942 { start_stmts = yyvsp[-1].lst; ;

943 break;}

944 case 4:

945 #line 73 "gram.y"

946 { startrules = yyvsp[-1].lst; ;

947 break;}

948 case 5:

949 #line 75 "gram.y"

950 { namerules = yyvsp[-1].lst; ;

951 break;}

952 case 6:

953 #line 77 "gram.y"

954 { define_state (yyvsp[-3].node, NULL, yyvsp[-1].lst); ;

955 break;}

956 case 7:

957 #line 79 "gram.y"

958 { define_state (yyvsp[-5].node, yyvsp[-3].node, yyvsp[-1].lst); ;

959 break;}

960 case 8:

961 #line 80 "gram.y"

962 { list_append (global_stmts, yyvsp[0].stmt); ;

963 break;}

964 case 9:

965 #line 83 "gram.y"

966 { yyval.lst = list (); ;

967 break;}

968 case 10:

969 #line 85 "gram.y"

970 { list_append (yyvsp[-3].lst, cons (yyvsp[-2].node, yyvsp[-1].node)); ;

971 break;}

972 case 11:

973 #line 88 "gram.y"

974 { yyval.lst = list (); ;

975 break;}

976 case 12:

977 #line 89 "gram.y"

978 { list_append (yyvsp[-1].lst, yyvsp[0].cons); ;

979 break;}

980 case 13:

981 #line 91 "gram.y"

982 { yyval.cons = cons (RULE_BEGIN, yyvsp[-1].lst); ;

983 break;}

984 case 14:

985 #line 92 "gram.y"

986 { yyval.cons = cons (RULE_END, yyvsp[-1].lst); ;

987 break;}

988 case 15:

989 #line 93 "gram.y"

990 { yyval.cons = cons (yyvsp[-3].node, yyvsp[-1].lst); ;

991 break;}

992 case 16:

993 #line 94 "gram.y"

994 { yyval.cons = cons (yyvsp[-3].node, yyvsp[-1].lst); ;

995 break;}

996 case 17:

997 #line 97 "gram.y"

998 { yyval.lst = list (); ;

999 break;}

1000 case 18:

1001 #line 98 "gram.y"

1002 { yyval.lst = yyvsp[0].lst; ;

1003 break;}

1004 case 19:

1005 #line 101 "gram.y"

1006 { yyval.lst = list (); list_append (yyval.lst, yyvsp[0].node); ;

1007 break;}

1008 case 20:

1009 #line 102 "gram.y"

1010 { list_append (yyvsp[-2].lst, yyvsp[0].node); ;

1011 break;}

1012 case 21:

1013 #line 105 "gram.y"

1014 { yyval.lst = list (); ;

1015 break;}

1016 case 22:

1017 #line 106 "gram.y"

1018 { yyval.lst = yyvsp[-1].lst; ;

1019 break;}

1020 case 23:

1021 #line 109 "gram.y"

1022 { yyval.lst = list (); list_append (yyval.lst, yyvsp[0].cons); ;

1023 break;}

1024 case 24:

1025 #line 110 "gram.y"

1026 { list_append (yyvsp[-2].lst, yyvsp[0].cons); ;

1027 break;}

1028 case 25:

1029 #line 113 "gram.y"

1030 { yyval.cons = cons (yyvsp[0].node, NULL); ;

1031 break;}

1032 case 26:

1033 #line 114 "gram.y"

1034 { yyval.cons = cons (yyvsp[-2].node, yyvsp[0].expr); ;

1035 break;}

1036 case 27:

1037 #line 117 "gram.y"

1038 { yyval.lst = list (); ;

1039 break;}

1040 case 28:

1041 #line 118 "gram.y"

1042 { list_append (yyvsp[-1].lst, yyvsp[0].stmt); ;

1043 break;}

1044 case 29:

1045 #line 121 "gram.y"

1046 { yyval.stmt = mk_stmt (sRETURN, NULL, NULL,

1047 NULL, NULL); ;

1048 break;}

1049 case 30:

1050 #line 123 "gram.y"

1051 { yyval.stmt = mk_stmt (sRETURN, yyvsp[-1].expr, NULL,

1052 NULL, NULL); ;

1053 break;}

1054 case 31:

1055 #line 126 "gram.y"

1056 { yyval.stmt = mk_stmt (sDEFSUB, yyvsp[-7].node,

1057 cons (cons (yyvsp[-5].lst, yyvsp[-2].lst),

1058 yyvsp[-1].lst),

1059 NULL, NULL); ;

1060 break;}

1061 case 32:

1062 #line 130 "gram.y"

1063 { yyval.stmt = mk_stmt (sBLOCK, yyvsp[-1].lst, NULL,

1064 NULL, NULL); ;

1065 break;}

1066 case 33:

1067 #line 132 "gram.y"

1068 { yyval.stmt = mk_stmt (sIF, yyvsp[-2].expr, yyvsp[0].stmt, NULL,

1069 NULL); ;

1070 break;}

1071 case 34:

1072 #line 135 "gram.y"

1073 { yyval.stmt = mk_stmt (sIF, yyvsp[-4].expr, yyvsp[-2].stmt, yyvsp[0].stmt,

1074 NULL); ;

1075 break;}

1076 case 35:

1077 #line 137 "gram.y"

1078 { yyval.stmt = mk_stmt (sWHILE, yyvsp[-2].expr, yyvsp[0].stmt,

1079 NULL, NULL); ;

1080 break;}

1081 case 36:

1082 #line 140 "gram.y"

1083 { yyval.stmt = mk_stmt (sFOR, yyvsp[-6].expr, yyvsp[-4].expr, yyvsp[-2].expr,

1084 yyvsp[0].stmt); ;

1085 break;}

1086 case 37:

1087 #line 142 "gram.y"

1088 { yyval.stmt = mk_stmt (sEXPR, yyvsp[-1].expr, NULL,

1089 NULL, NULL); ;

1090 break;}

1091 case 38:

1092 #line 146 "gram.y"

1093 { yyval.expr = mk_expr (eSTRING, yyvsp[0].node, NULL,

1094 NULL); ;

1095 break;}

1096 case 39:

1097 #line 148 "gram.y"

1098 { yyval.expr = mk_expr (eREGEXP, yyvsp[0].node, NULL,

1099 NULL); ;

1100 break;}

1101 case 40:

1102 #line 150 "gram.y"

1103 { yyval.expr = mk_expr (eINTEGER, yyvsp[0].node, NULL,

1104 NULL); ;

1105 break;}

1106 case 41:

1107 #line 152 "gram.y"

1108 { yyval.expr = mk_expr (eREAL, yyvsp[0].node, NULL,

1109 NULL); ;

1110 break;}

1111 case 42:

1112 #line 154 "gram.y"

1113 { yyval.expr = mk_expr (eSYMBOL, yyvsp[0].node, NULL,

1114 NULL); ;

1115 break;}

1116 case 43:

1117 #line 156 "gram.y"

1118 { yyval.expr = mk_expr (eNOT, yyvsp[0].expr, NULL,

1119 NULL); ;

1120 break;}

1121 case 44:

1122 #line 158 "gram.y"

1123 { yyval.expr = mk_expr (eAND, yyvsp[-2].expr, yyvsp[0].expr, NULL); ;

1124 break;}

1125 case 45:

1126 #line 159 "gram.y"

1127 { yyval.expr = mk_expr (eOR, yyvsp[-2].expr, yyvsp[0].expr, NULL); ;

1128 break;}

1129 case 46:

1130 #line 160 "gram.y"

1131 { yyval.expr = mk_expr (eFCALL, yyvsp[-3].node, yyvsp[-1].lst,

1132 NULL); ;

1133 break;}

1134 case 47:

1135 #line 162 "gram.y"

1136 { yyval.expr = mk_expr (eASSIGN, yyvsp[-2].node, yyvsp[0].expr,

1137 NULL); ;

1138 break;}

1139 case 48:

1140 #line 164 "gram.y"

1141 { yyval.expr = mk_expr (eADDASSIGN, yyvsp[-2].node, yyvsp[0].expr,

1142 NULL); ;

1143 break;}

1144 case 49:

1145 #line 166 "gram.y"

1146 { yyval.expr = mk_expr (eSUBASSIGN, yyvsp[-2].node, yyvsp[0].expr,

1147 NULL); ;

1148 break;}

1149 case 50:

1150 #line 168 "gram.y"

1151 { yyval.expr = mk_expr (eMULASSIGN, yyvsp[-2].node, yyvsp[0].expr,

1152 NULL); ;

1153 break;}

1154 case 51:

1155 #line 170 "gram.y"

1156 { yyval.expr = mk_expr (eDIVASSIGN, yyvsp[-2].node, yyvsp[0].expr,

1157 NULL); ;

1158 break;}

1159 case 52:

1160 #line 172 "gram.y"

1161 { yyval.expr = mk_expr (ePOSTFIXADD, yyvsp[-1].node, NULL,

1162 NULL); ;

1163 break;}

1164 case 53:

1165 #line 174 "gram.y"

1166 { yyval.expr = mk_expr (ePOSTFIXSUB, yyvsp[-1].node, NULL,

1167 NULL); ;

1168 break;}

1169 case 54:

1170 #line 176 "gram.y"

1171 { yyval.expr = mk_expr (ePREFIXADD, yyvsp[0].node, NULL,

1172 NULL); ;

1173 break;}

1174 case 55:

1175 #line 178 "gram.y"

1176 { yyval.expr = mk_expr (ePREFIXSUB, yyvsp[0].node, NULL,

1177 NULL); ;

1178 break;}

1179 case 56:

1180 #line 180 "gram.y"

1181 { yyval.expr = mk_expr (eARRAYASSIGN, yyvsp[-5].expr, yyvsp[-3].expr,

1182 yyvsp[0].expr); ;

1183 break;}

1184 case 57:

1185 #line 182 "gram.y"

1186 { yyval.expr = yyvsp[-1].expr; ;

1187 break;}

1188 case 58:

1189 #line 183 "gram.y"

1190 { yyval.expr = mk_expr (eARRAYREF, yyvsp[-3].expr, yyvsp[-1].expr,

1191 NULL); ;

1192 break;}

1193 case 59:

1194 #line 185 "gram.y"

1195 { yyval.expr = mk_expr (eQUESTCOLON, yyvsp[-4].expr, yyvsp[-2].expr,

1196 yyvsp[0].expr); ;

1197 break;}

1198 case 60:

1199 #line 187 "gram.y"

1200 { yyval.expr = mk_expr (eMULT, yyvsp[-2].expr, yyvsp[0].expr, NULL); ;

1201 break;}

1202 case 61:

1203 #line 188 "gram.y"

1204 { yyval.expr = mk_expr (eDIV, yyvsp[-2].expr, yyvsp[0].expr, NULL); ;

1205 break;}

1206 case 62:

1207 #line 189 "gram.y"

1208 { yyval.expr = mk_expr (ePLUS, yyvsp[-2].expr, yyvsp[0].expr, NULL); ;

1209 break;}

1210 case 63:

1211 #line 190 "gram.y"

1212 { yyval.expr = mk_expr (eMINUS, yyvsp[-2].expr, yyvsp[0].expr,

1213 NULL); ;

1214 break;}

1215 case 64:

1216 #line 192 "gram.y"

1217 { yyval.expr = mk_expr (eLT, yyvsp[-2].expr, yyvsp[0].expr, NULL); ;

1218 break;}

1219 case 65:

1220 #line 193 "gram.y"

1221 { yyval.expr = mk_expr (eGT, yyvsp[-2].expr, yyvsp[0].expr, NULL); ;

1222 break;}

1223 case 66:

1224 #line 194 "gram.y"

1225 { yyval.expr = mk_expr (eEQ, yyvsp[-2].expr, yyvsp[0].expr, NULL); ;

1226 break;}

1227 case 67:

1228 #line 195 "gram.y"

1229 { yyval.expr = mk_expr (eNE, yyvsp[-2].expr, yyvsp[0].expr, NULL); ;

1230 break;}

1231 case 68:

1232 #line 196 "gram.y"

1233 { yyval.expr = mk_expr (eGE, yyvsp[-2].expr, yyvsp[0].expr, NULL); ;

1234 break;}

1235 case 69:

1236 #line 197 "gram.y"

1237 { yyval.expr = mk_expr (eLE, yyvsp[-2].expr, yyvsp[0].expr, NULL); ;

1238 break;}

1239 case 70:

1240 #line 200 "gram.y"

1241 { yyval.expr = NULL; ;

1242 break;}

1243 case 71:

1244 #line 201 "gram.y"

1245 { yyval.expr = yyvsp[0].expr; ;

1246 break;}

1247 case 72:

1248 #line 204 "gram.y"

1249 { yyval.lst = list (); ;

1250 break;}

1251 case 73:

1252 #line 205 "gram.y"

1253 { yyval.lst = yyvsp[0].lst; ;

1254 break;}

1255 case 74:

1256 #line 208 "gram.y"

1257 { yyval.lst = list (); list_append (yyval.lst, yyvsp[0].expr); ;

1258 break;}

1259 case 75:

1260 #line 209 "gram.y"

1261 { list_append (yyvsp[-2].lst, yyvsp[0].expr); ;

1262 break;}

1263 }

1264 /* the action file gets copied in in place of this dollarsign */

1265 #line 543 "/l/mtr/gnu/share/bison.simple"

1266 \f

1267 yyvsp -= yylen;

1268 yyssp -= yylen;

1269 #ifdef YYLSP_NEEDED

1270 yylsp -= yylen;

1271 #endif

1272

1273 #if YYDEBUG != 0

1274 if (yydebug)

1275 {

1276 short *ssp1 = yyss - 1;

1277 fprintf (stderr, "state stack now");

1278 while (ssp1 != yyssp)

1279 fprintf (stderr, " %d", *++ssp1);

1280 fprintf (stderr, "\n");

1281 }

1282 #endif

1283

1284 *++yyvsp = yyval;

1285

1286 #ifdef YYLSP_NEEDED

1287 yylsp++;

1288 if (yylen == 0)

1289 {

1290 yylsp->first_line = yylloc.first_line;

1291 yylsp->first_column = yylloc.first_column;

1292 yylsp->last_line = (yylsp-1)->last_line;

1293 yylsp->last_column = (yylsp-1)->last_column;

1294 yylsp->text = 0;

1295 }

1296 else

1297 {

1298 yylsp->last_line = (yylsp+yylen-1)->last_line;

1299 yylsp->last_column = (yylsp+yylen-1)->last_column;

1300 }

1301 #endif

1302

1303 /* Now "shift" the result of the reduction.

1304 Determine what state that goes to,

1305 based on the state we popped back to

1306 and the rule number reduced by. */

1307

1308 yyn = yyr1[yyn];

1309

1310 yystate = yypgoto[yyn - YYNTBASE] + *yyssp;

1311 if (yystate >= 0 && yystate <= YYLAST && yycheck[yystate] == *yyssp)

1312 yystate = yytable[yystate];

1313 else

1314 yystate = yydefgoto[yyn - YYNTBASE];

1315

1316 goto yynewstate;

1317

1318 yyerrlab: /* here on detecting error */

1319

1320 if (! yyerrstatus)

1321 /* If not already recovering from an error, report this error. */

1322 {

1323 ++yynerrs;

1324

1325 #ifdef YYERROR_VERBOSE

1326 yyn = yypact[yystate];

1327

1328 if (yyn > YYFLAG && yyn < YYLAST)

1329 {

1330 int size = 0;

1331 char *msg;

1332 int x, count;

1333

1334 count = 0;

1335 /* Start X at -yyn if nec to avoid negative indexes in yycheck. */

1336 for (x = (yyn < 0 ? -yyn : 0);

1337 x < (sizeof(yytname) / sizeof(char *)); x++)

1338 if (yycheck[x + yyn] == x)

1339 size += strlen(yytname[x]) + 15, count++;

1340 msg = (char *) malloc(size + 15);

1341 if (msg != 0)

1342 {

1343 strcpy(msg, "parse error");

1344

1345 if (count < 5)

1346 {

1347 count = 0;

1348 for (x = (yyn < 0 ? -yyn : 0);

1349 x < (sizeof(yytname) / sizeof(char *)); x++)

1350 if (yycheck[x + yyn] == x)

1351 {

1352 strcat(msg, count == 0 ? ", expecting `" : " or `");

1353 strcat(msg, yytname[x]);

1354 strcat(msg, "'");

1355 count++;

1356 }

1357 }

1358 yyerror(msg);

1359 free(msg);

1360 }

1361 else

1362 yyerror ("parse error; also virtual memory exceeded");

1363 }

1364 else

1365 #endif /* YYERROR_VERBOSE */

1366 yyerror("parse error");

1367 }

1368

1369 goto yyerrlab1;

1370 yyerrlab1: /* here on error raised explicitly by an action */

1371

1372 if (yyerrstatus == 3)

1373 {

1374 /* if just tried and failed to reuse lookahead token after an error, discard it. */

1375

1376 /* return failure if at end of input */

1377 if (yychar == YYEOF)

1378 YYABORT;

1379

1380 #if YYDEBUG != 0

1381 if (yydebug)

1382 fprintf(stderr, "Discarding token %d (%s).\n", yychar, yytname[yychar1]);

1383 #endif

1384

1385 yychar = YYEMPTY;

1386 }

1387

1388 /* Else will try to reuse lookahead token

1389 after shifting the error token. */

1390

1391 yyerrstatus = 3; /* Each real token shifted decrements this */

1392

1393 goto yyerrhandle;

1394

1395 yyerrdefault: /* current state does not do anything special for the error token. */

1396

1397 #if 0

1398 /* This is wrong; only states that explicitly want error tokens

1399 should shift them. */

1400 yyn = yydefact[yystate]; /* If its default is to accept any token, ok. Otherwise pop it.*/

1401 if (yyn) goto yydefault;

1402 #endif

1403

1404 yyerrpop: /* pop the current state because it cannot handle the error token */

1405

1406 if (yyssp == yyss) YYABORT;

1407 yyvsp--;

1408 yystate = *--yyssp;

1409 #ifdef YYLSP_NEEDED

1410 yylsp--;

1411 #endif

1412

1413 #if YYDEBUG != 0

1414 if (yydebug)

1415 {

1416 short *ssp1 = yyss - 1;

1417 fprintf (stderr, "Error: state stack now");

1418 while (ssp1 != yyssp)

1419 fprintf (stderr, " %d", *++ssp1);

1420 fprintf (stderr, "\n");

1421 }

1422 #endif

1423

1424 yyerrhandle:

1425

1426 yyn = yypact[yystate];

1427 if (yyn == YYFLAG)

1428 goto yyerrdefault;

1429

1430 yyn += YYTERROR;

1431 if (yyn < 0 || yyn > YYLAST || yycheck[yyn] != YYTERROR)

1432 goto yyerrdefault;

1433

1434 yyn = yytable[yyn];

1435 if (yyn < 0)

1436 {

1437 if (yyn == YYFLAG)

1438 goto yyerrpop;

1439 yyn = -yyn;

1440 goto yyreduce;

1441 }

1442 else if (yyn == 0)

1443 goto yyerrpop;

1444

1445 if (yyn == YYFINAL)

1446 YYACCEPT;

1447

1448 #if YYDEBUG != 0

1449 if (yydebug)

1450 fprintf(stderr, "Shifting error token, ");

1451 #endif

1452

1453 *++yyvsp = yylval;

1454 #ifdef YYLSP_NEEDED

1455 *++yylsp = yylloc;

1456 #endif

1457

1458 yystate = yyn;

1459 goto yynewstate;

1460

1461 yyacceptlab:

1462 /* YYACCEPT comes here. */

1463 if (yyfree_stacks)

1464 {

1465 free (yyss);

1466 free (yyvs);

1467 #ifdef YYLSP_NEEDED

1468 free (yyls);

1469 #endif

1470 }

1471 return 0;

1472

1473 yyabortlab:

1474 /* YYABORT comes here. */

1475 if (yyfree_stacks)

1476 {

1477 free (yyss);

1478 free (yyvs);

1479 #ifdef YYLSP_NEEDED

1480 free (yyls);

1481 #endif

1482 }

1483 return 1;

1484 }

1485 #line 212 "gram.y"

1486

1487

1488 void

1489 yyerror (msg)

1490 char *msg;

1491 {

1492 fprintf (stderr, "%s:%d: %s\n", yyin_name, linenum, msg);

1493 }