extern char *malloc(), *realloc();
# line 2 "lang.y"
/*
* This is the grammar definition of LPC. Expect one shift/reduce conflict,
* because of if-then-else. The default, to shift this conflict, is the
* correct solution.
*/
#include <string.h>
#include <stdio.h>
#include "lint.h"
#include "lnode.h"
#include "config.h"
#include "interpret.h"
#include "object.h"
#define YYMAXDEPTH 600
struct lnode *prog, *heart_beat;
int variable_count;
void yyerror(), free_all_local_names(), add_local_name(), smart_log();
extern int yylex(), check_deklared();
static void copy_variables();
int static_variable_flag;
char *argument_name; /* The name of the current argument. */
char *xalloc(), *string_copy();
extern int current_line;
/*
* 'inherit_file' is used as a flag. If it is set to a string
* after yyparse(), this string should be loaded as an object,
* and the original object must be loaded again.
* 'inherit_ob' will point to the super class object. This value is saved
* so that load_object() can set up pointers to it.
*/
extern char *current_file, *inherit_file;
extern struct object *find_object2();
struct object *inherit_ob;
char *local_names[MAX_LOCAL];
int current_number_of_locals = 0;
static int num_arg;
# line 75 "lang.y"
typedef union
{
struct lnode *lnode;
int number;
char *string;
} YYSTYPE;
# define F_THIS_PLAYER 257
# define F_IF 258
# define F_IDENTIFIER 259
# define F_LAND 260
# define F_LOR 261
# define F_STATUS 262
# define F_SET_TRUE 263
# define F_SET_FALSE 264
# define F_CONS 265
# define F_RETURN 266
# define F_NOT 267
# define F_WRITE 268
# define F_STRING 269
# define F_ADD_VERB 270
# define F_ADD_ADJ 271
# define F_ADD_SUBST 272
# define F_ADD_ACTION 273
# define F_MOVE_OBJECT 274
# define F_INC 275
# define F_DEC 276
# define F_POST_INC 277
# define F_POST_DEC 278
# define F_COMMA 279
# define F_COND 280
# define F_QUERY_LOAD_AVERAGE 281
# define F_THIS_VERB 282
# define F_NUMBER 283
# define F_ASSIGN 284
# define F_INT 285
# define F_CALL_OTHER 286
# define F_ADD 287
# define F_SUBTRACT 288
# define F_MULTIPLY 289
# define F_DIVIDE 290
# define F_LT 291
# define F_GT 292
# define F_EQ 293
# define F_GE 294
# define F_LE 295
# define F_ARGUMENT 296
# define F_FUNCTION 297
# define F_CLONE_OBJECT 298
# define F_THIS_OBJECT 299
# define F_SAVE_OBJECT 300
# define F_RESTORE_OBJECT 301
# define F_NE 302
# define F_ENVIRONMENT 303
# define F_ADD_EQ 304
# define F_SUB_EQ 305
# define F_DIV_EQ 306
# define F_MULT_EQ 307
# define F_PRESENT 308
# define F_COMMAND 309
# define F_SET_LIGHT 310
# define F_DESTRUCT 311
# define F_CREATE_WIZARD 312
# define F_NEGATE 313
# define F_SAY 314
# define F_STRLEN 315
# define F_SUBSCRIPT 316
# define F_WHILE 317
# define F_BREAK 318
# define F_SHUTDOWN 319
# define F_LOG_FILE 320
# define F_DO 321
# define F_FOR 322
# define F_ADD_XVERB 323
# define F_FIND_CALL_OUT 324
# define F_READ_FILE 325
# define F_FILTER_OBJECTS 326
# define F_SSCANF 327
# define F_SHOUT 328
# define F_STRING_DECL 329
# define F_LOCAL_NAME 330
# define F_FIRST_INVENTORY 331
# define F_NEXT_INVENTORY 332
# define F_ENABLE_COMMANDS 333
# define F_RANDOM 334
# define F_INPUT_TO 335
# define F_CRYPT 336
# define F_LS 337
# define F_CAT 338
# define F_FIND_LIVING 339
# define F_TELL_OBJECT 340
# define F_PEOPLE 341
# define F_ED 342
# define F_LIVING 343
# define F_LOWER_CASE 344
# define F_ELSE 345
# define F_CAPITALIZE 346
# define F_SET_HEART_BEAT 347
# define F_SNOOP 348
# define F_TELL_ROOM 349
# define F_FIND_OBJECT 350
# define F_RM 351
# define F_CONST0 352
# define F_CONST1 353
# define F_BLOCK 354
# define F_TRANSFER 355
# define F_REGCOMP 356
# define F_REGEXEC 357
# define F_LOCALCMD 358
# define F_SWAP 359
# define F_CONTINUE 360
# define F_ADD_WORTH 361
# define F_TIME 362
# define F_MOD 363
# define F_MOD_EQ 364
# define F_QUERY_IP_NUMBER 365
# define F_INHERIT 366
# define F_COLON_COLON 367
# define F_CREATOR 368
# define F_STATIC 369
# define F_CALL_OUT 370
# define F_REMOVE_CALL_OUT 371
# define F_COMBINE_FREE_LIST 372
# define F_ALLOCATE 373
# define F_SIZEOF 374
# define F_DISABLE_COMMANDS 375
# define F_CTIME 376
# define F_INTP 377
# define F_STRINGP 378
# define F_OBJECTP 379
# define F_POINTERP 380
# define F_USERS 381
# define F_ARROW 382
# define F_PREVIOUS_OBJECT 383
# define F_AGGREGATE 384
# define F_EXTRACT 385
# define F_FILE_NAME 386
# define F_QUERY_VERB 387
# define F_TAIL 388
# define F_QUERY_HOST_NAME 389
# define F_EXPLODE 390
# define F_COMPL 391
# define F_AND 392
# define F_AND_EQ 393
# define F_OR 394
# define F_OR_EQ 395
# define F_XOR 396
# define F_XOR_EQ 397
# define F_CP 398
# define F_RENAME 399
# define F_LSH 400
# define F_LSH_EQ 401
# define F_RSH 402
# define F_RSH_EQ 403
# define F_MKDIR 404
# define F_RMDIR 405
# define F_QUERY_SNOOP 406
# define F_THROW 407
# define F_FIND_PLAYER 408
# define F_WRITE_FILE 409
# define F_FILE_SIZE 410
# define F_PARSE_COMMAND 411
# define F_IMPLODE 412
# define F_QUERY_IDLE 413
# define F_REMOTE_COMMAND 414
# define F_INTERACTIVE 415
# define F_CALLER 416
# define F_TYPEOF 417
# define F_CATCH 418
# define F_NOTIFY_FAIL 419
# define F_SET_LIVING_NAME 420
# define F_SET_BIT 421
# define F_CLEAR_BIT 422
# define F_TEST_BIT 423
# define F_REALLOCATE 424
# define F_INDEX 425
# define F_SEARCHA 426
# define F_CONTENTS 427
# define F_IN_EDITOR 428
# define F_GREP 429
#define yyclearin yychar = -1
#define yyerrok yyerrflag = 0
extern int yychar;
extern int yyerrflag;
#ifndef YYMAXDEPTH
#define YYMAXDEPTH 150
#endif
YYSTYPE yylval, yyval;
# define YYERRCODE 256
# line 484 "lang.y"
void yyerror(str)
char *str;
{
extern int num_parse_error;
if (num_parse_error > 5)
return;
(void)fprintf(stderr, "%s: %s line %d\n", current_file, str,
current_line);
fflush(stderr);
smart_log(current_file, current_line, str);
if (num_parse_error == 0)
save_error(str, current_file, current_line);
num_parse_error++;
}
int check_deklared(str)
char *str;
{
struct lnode_var_def *p;
char buff[100];
for (p = prog_status; p; p = p->next) {
if (strcmp(p->name, str) == 0)
return p->num_var;
}
(void)sprintf(buff, "Variable %s not declared !", str);
yyerror(buff);
return 0;
}
void free_all_local_names()
{
int i;
for (i=0; i<current_number_of_locals; i++) {
free(local_names[i]);
local_names[i] = 0;
}
current_number_of_locals = 0;
}
void add_local_name(str)
char *str;
{
if (current_number_of_locals == MAX_LOCAL)
yyerror("Too many local variables\n");
else
local_names[current_number_of_locals++] = str;
}
int num_val(p)
struct lnode_number *p;
{
switch(p->type) {
case F_NUMBER:
return p->number;
case F_CONST0:
return 0;
case F_CONST1:
return 1;
default:
fatal("Illegal type of number.\n");
}
/*NOTREACHED*/
}
/*
* It could be possible to do '#include "/etc/passwd"' in the definition
* of an object. The compilation would fail, but the .i file would remain
* with interesting data.
* Prevent this by checking the name of teh include file.
*/
int illegal_include_file(str)
char *str;
{
char *p;
int i;
if (str[0] == '/')
return 1;
if (strlen(str) < 3)
return 0;
for (p = str + 3, i = 0; *p; p++)
if (p[0] == '/' && p[-1] == '.' && p[-2] == '.' && p[-3] == '/')
i += 1;
if (i > 3)
return 1;
return 0;
}
static void copy_one_variable(p)
struct lnode_var_def *p;
{
if (p->next)
copy_one_variable(p->next);
static_variable_flag = p->is_static;
alloc_lnode_var_def(F_STATUS, string_copy(p->name), variable_count++);
}
static void copy_variables(from)
struct object *from;
{
if (variable_count > 0)
yyerror("Illegal to declare variables before the inherit statement");
if (!from->status)
return;
copy_one_variable(from->status);
}
int yyexca[] ={
-1, 0,
0, 3,
-2, 17,
-1, 1,
0, -1,
-2, 0,
-1, 115,
0, 3,
-2, 17,
-1, 149,
125, 37,
-2, 0,
-1, 153,
125, 37,
-2, 0,
-1, 170,
59, 72,
-2, 0,
-1, 175,
40, 130,
-2, 122,
-1, 233,
59, 53,
-2, 0,
-1, 244,
125, 74,
-2, 0,
-1, 247,
41, 74,
-2, 0,
-1, 248,
41, 74,
-2, 0,
-1, 265,
382, 117,
91, 117,
-2, 108,
-1, 267,
382, 117,
91, 117,
-2, 109,
-1, 312,
59, 53,
-2, 0,
-1, 315,
41, 74,
-2, 0,
-1, 317,
41, 74,
125, 74,
-2, 0,
-1, 330,
41, 53,
-2, 0,
};
# define YYNPROD 240
# define YYLAST 1925
int yyact[]={
183, 258, 286, 259, 328, 205, 129, 124, 278, 236,
237, 120, 226, 279, 241, 256, 239, 254, 246, 250,
146, 143, 117, 186, 210, 128, 151, 161, 134, 316,
125, 123, 206, 145, 127, 178, 185, 5, 249, 2,
314, 139, 227, 130, 330, 312, 274, 223, 222, 141,
132, 116, 313, 263, 317, 260, 227, 261, 262, 229,
335, 142, 139, 264, 137, 331, 329, 326, 319, 318,
310, 309, 287, 140, 126, 288, 138, 131, 315, 311,
248, 247, 233, 145, 231, 230, 204, 122, 119, 251,
149, 136, 135, 118, 147, 6, 115, 1, 4, 198,
182, 193, 191, 197, 184, 159, 158, 157, 194, 195,
192, 181, 171, 200, 160, 3, 174, 180, 156, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 5, 179, 245, 121, 0, 133, 0, 0,
0, 0, 0, 0, 0, 0, 144, 0, 0, 0,
0, 148, 0, 0, 0, 150, 0, 228, 207, 183,
208, 152, 0, 0, 205, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 235, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 240, 0, 154, 8, 166, 175,
272, 0, 124, 23, 10, 0, 170, 203, 11, 187,
12, 16, 14, 20, 21, 201, 202, 266, 266, 0,
0, 37, 32, 188, 0, 125, 18, 0, 252, 255,
257, 0, 0, 0, 0, 0, 176, 253, 19, 9,
24, 84, 145, 25, 0, 204, 285, 0, 26, 29,
78, 79, 80, 0, 81, 101, 0, 167, 163, 17,
22, 168, 169, 13, 99, 108, 38, 85, 83, 126,
177, 76, 77, 71, 74, 70, 45, 48, 46, 55,
60, 69, 15, 73, 59, 242, 72, 28, 75, 82,
61, 49, 189, 190, 0, 62, 63, 64, 65, 66,
164, 67, 68, 292, 293, 86, 323, 192, 27, 199,
91, 98, 100, 87, 88, 90, 89, 93, 92, 94,
95, 96, 333, 44, 334, 97, 30, 31, 39, 43,
34, 0, 282, 0, 196, 258, 0, 259, 106, 107,
304, 305, 302, 303, 40, 41, 42, 162, 56, 57,
58, 33, 35, 36, 102, 103, 104, 105, 173, 113,
112, 109, 110, 111, 50, 52, 53, 51, 54, 47,
0, 325, 0, 327, 283, 225, 8, 166, 175, 290,
0, 0, 23, 10, 0, 170, 203, 11, 187, 12,
16, 14, 20, 21, 201, 202, 0, 0, 0, 183,
37, 32, 188, 0, 205, 18, 324, 0, 0, 0,
0, 0, 0, 0, 0, 176, 0, 19, 9, 24,
84, 0, 25, 0, 0, 0, 0, 26, 29, 78,
79, 80, 0, 81, 101, 0, 167, 163, 17, 22,
168, 169, 13, 99, 108, 38, 85, 83, 0, 177,
76, 77, 71, 74, 70, 45, 48, 46, 55, 60,
69, 15, 73, 59, 0, 72, 28, 75, 82, 61,
49, 189, 190, 0, 62, 63, 64, 65, 66, 164,
67, 68, 145, 0, 86, 204, 192, 27, 0, 91,
98, 100, 87, 88, 90, 89, 93, 92, 94, 95,
96, 0, 44, 0, 97, 30, 31, 39, 43, 34,
0, 0, 0, 268, 270, 271, 0, 106, 107, 0,
0, 0, 0, 40, 41, 42, 162, 56, 57, 58,
33, 35, 36, 102, 103, 104, 105, 173, 113, 112,
109, 110, 111, 50, 52, 53, 51, 54, 47, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 306, 307, 308, 0, 0, 0, 183, 0,
0, 291, 0, 205, 294, 0, 295, 296, 297, 298,
299, 300, 301, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 154, 8, 166, 175, 0,
0, 0, 23, 10, 0, 170, 203, 11, 187, 12,
16, 14, 20, 21, 201, 202, 0, 0, 0, 0,
37, 32, 188, 0, 0, 18, 0, 0, 0, 0,
0, 0, 0, 0, 0, 176, 0, 19, 9, 24,
84, 244, 25, 0, 204, 0, 0, 26, 29, 78,
79, 80, 0, 81, 101, 0, 167, 163, 17, 22,
168, 169, 13, 99, 108, 38, 85, 83, 0, 177,
76, 77, 71, 74, 70, 45, 48, 46, 55, 60,
69, 15, 73, 59, 0, 72, 28, 75, 82, 61,
49, 189, 190, 0, 62, 63, 64, 65, 66, 164,
67, 68, 0, 0, 86, 0, 192, 27, 0, 91,
98, 100, 87, 88, 90, 89, 93, 92, 94, 95,
96, 0, 44, 0, 97, 30, 31, 39, 43, 34,
0, 0, 0, 0, 183, 0, 0, 106, 107, 205,
0, 0, 0, 40, 41, 42, 162, 56, 57, 58,
33, 35, 36, 102, 103, 104, 105, 173, 113, 112,
109, 110, 111, 50, 52, 53, 51, 54, 47, 0,
0, 0, 0, 0, 225, 8, 0, 175, 0, 0,
0, 23, 10, 0, 0, 203, 11, 187, 12, 16,
14, 20, 21, 201, 202, 0, 0, 0, 0, 37,
32, 188, 0, 0, 18, 0, 0, 0, 0, 0,
0, 0, 0, 0, 176, 0, 19, 9, 24, 84,
204, 25, 0, 0, 0, 0, 26, 29, 78, 79,
80, 0, 81, 101, 0, 0, 0, 17, 22, 0,
0, 13, 99, 108, 38, 85, 83, 0, 177, 76,
77, 71, 74, 70, 45, 48, 46, 55, 60, 69,
15, 73, 59, 0, 72, 28, 75, 82, 61, 49,
189, 190, 0, 62, 63, 64, 65, 66, 0, 67,
68, 0, 0, 86, 0, 192, 27, 0, 91, 98,
100, 87, 88, 90, 89, 93, 92, 94, 95, 96,
0, 44, 0, 97, 30, 31, 39, 43, 34, 0,
183, 0, 0, 0, 0, 205, 106, 107, 0, 0,
0, 0, 40, 41, 42, 0, 56, 57, 58, 33,
35, 36, 102, 103, 104, 105, 173, 113, 112, 109,
110, 111, 50, 52, 53, 51, 54, 47, 0, 0,
225, 8, 0, 175, 0, 0, 0, 23, 10, 0,
0, 203, 11, 187, 12, 16, 14, 20, 21, 201,
202, 0, 0, 0, 0, 37, 32, 188, 0, 0,
18, 0, 0, 0, 0, 0, 0, 0, 0, 0,
176, 0, 19, 9, 24, 84, 204, 25, 0, 0,
0, 0, 26, 29, 78, 79, 80, 0, 81, 101,
0, 0, 0, 17, 22, 0, 0, 13, 99, 108,
38, 85, 83, 0, 177, 76, 77, 71, 74, 70,
45, 48, 46, 55, 60, 69, 15, 73, 59, 0,
72, 28, 75, 82, 61, 49, 189, 190, 0, 62,
63, 64, 65, 66, 0, 67, 68, 0, 0, 86,
0, 192, 27, 0, 91, 98, 100, 87, 88, 90,
89, 93, 92, 94, 95, 96, 0, 44, 0, 97,
30, 31, 39, 43, 34, 183, 0, 0, 0, 0,
0, 0, 106, 107, 0, 0, 0, 0, 40, 41,
42, 0, 56, 57, 58, 33, 35, 36, 102, 103,
104, 105, 173, 113, 112, 109, 110, 111, 50, 52,
53, 51, 54, 47, 0, 0, 0, 8, 0, 175,
0, 0, 0, 23, 10, 0, 0, 203, 11, 187,
12, 16, 14, 20, 21, 201, 202, 0, 0, 0,
0, 37, 32, 188, 0, 0, 18, 0, 0, 0,
0, 0, 0, 0, 0, 0, 176, 0, 19, 9,
24, 84, 0, 25, 0, 0, 0, 0, 26, 29,
78, 79, 80, 0, 81, 101, 0, 0, 0, 17,
22, 0, 0, 13, 99, 108, 38, 85, 83, 0,
177, 76, 77, 71, 74, 70, 45, 48, 46, 55,
60, 69, 15, 73, 59, 0, 72, 28, 75, 82,
61, 49, 189, 190, 0, 62, 63, 64, 65, 66,
0, 67, 68, 0, 0, 86, 0, 192, 27, 0,
91, 98, 100, 87, 88, 90, 89, 93, 92, 94,
95, 96, 0, 44, 0, 97, 30, 31, 39, 43,
34, 0, 0, 0, 0, 0, 0, 0, 106, 107,
0, 0, 0, 0, 40, 41, 42, 0, 56, 57,
58, 33, 35, 36, 102, 103, 104, 105, 0, 113,
112, 109, 110, 111, 50, 52, 53, 51, 54, 47,
0, 0, 8, 0, 175, 0, 0, 0, 23, 10,
0, 0, 0, 11, 187, 12, 16, 14, 20, 21,
0, 0, 0, 0, 0, 0, 37, 32, 188, 0,
0, 18, 0, 0, 0, 0, 0, 0, 0, 0,
0, 176, 0, 19, 9, 24, 84, 0, 25, 0,
0, 153, 0, 26, 29, 78, 79, 80, 0, 81,
101, 0, 0, 0, 17, 22, 0, 211, 13, 99,
108, 38, 85, 83, 0, 177, 76, 77, 71, 74,
70, 45, 48, 46, 55, 60, 69, 15, 73, 59,
0, 72, 28, 75, 82, 61, 49, 189, 190, 0,
62, 63, 64, 65, 66, 0, 67, 68, 0, 209,
86, 211, 192, 27, 0, 91, 98, 100, 87, 88,
90, 89, 93, 92, 94, 95, 96, 0, 44, 211,
97, 30, 31, 39, 43, 34, 0, 0, 0, 0,
165, 0, 0, 106, 107, 0, 0, 0, 0, 40,
41, 42, 0, 56, 57, 58, 33, 35, 36, 102,
103, 104, 105, 0, 113, 112, 109, 110, 111, 50,
52, 53, 51, 54, 47, 8, 0, 0, 0, 0,
0, 23, 10, 0, 0, 0, 11, 155, 12, 16,
14, 20, 21, 0, 0, 0, 0, 0, 0, 37,
32, 0, 0, 0, 18, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 19, 9, 24, 84,
232, 25, 0, 0, 0, 238, 26, 29, 78, 79,
80, 0, 81, 101, 0, 0, 0, 17, 22, 0,
0, 13, 99, 108, 38, 85, 83, 0, 0, 76,
77, 71, 74, 70, 45, 48, 46, 55, 60, 69,
15, 73, 59, 0, 72, 28, 75, 82, 61, 49,
172, 0, 0, 62, 63, 64, 65, 66, 0, 67,
68, 236, 237, 86, 114, 0, 27, 7, 91, 98,
100, 87, 88, 90, 89, 93, 92, 94, 95, 96,
0, 44, 0, 97, 30, 31, 39, 43, 34, 0,
217, 218, 221, 219, 0, 0, 106, 107, 0, 0,
0, 0, 40, 41, 42, 0, 56, 57, 58, 33,
35, 36, 102, 103, 104, 105, 0, 113, 112, 109,
110, 111, 50, 52, 53, 51, 54, 47, 0, 0,
224, 273, 0, 0, 217, 218, 221, 219, 234, 0,
0, 320, 321, 0, 0, 0, 0, 0, 0, 0,
220, 243, 217, 218, 221, 219, 281, 0, 0, 0,
332, 0, 0, 0, 0, 289, 0, 336, 289, 289,
0, 0, 0, 0, 0, 0, 0, 0, 0, 212,
0, 213, 0, 214, 0, 0, 0, 215, 0, 216,
0, 0, 0, 0, 220, 0, 0, 275, 276, 277,
0, 280, 0, 0, 0, 0, 0, 0, 0, 284,
0, 0, 220, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 212, 0, 213, 0, 214, 0, 0,
0, 215, 0, 216, 0, 0, 289, 0, 289, 0,
0, 212, 0, 213, 0, 214, 0, 0, 0, 215,
0, 216, 265, 267, 269, 269, 269, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 322,
280, 0, 0, 0, 0, 0, 0, 0, 0, 0,
269, 269, 0, 0, 0, 0, 269, 269, 280, 0,
269, 0, 269, 269, 269, 269, 269, 269, 269, 269,
269, 269, 269, 269, 269, 269, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 269 };
int yypact[]={
1258, -1000, -1000, -8, -237, 48, -1000, -1000, -1000, -1000,
-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-1000, -1000, -1000, -1000, -258, 1258, -1000, 47, -255, -253,
-9, -1000, -253, 22, -1000, -1000, -1000, 35, 18, -1000,
-1000, -1000, -1000, 32, -10, 17, -238, -1000, -90, -239,
-1000, -1000, 22, -1000, -1000, -1000, -1000, -90, -1000, -40,
-1000, -93, -253, 379, 1390, -11, -1000, -1000, -1000, -1000,
-12, -1000, 734, -17, -17, 15, 45, 44, 139, 42,
734, -1000, 1346, 139, -47, -1000, -1000, -1000, -77, -1000,
-1000, -1000, -1000, 558, -106, 41, 40, -1000, -1000, -1000,
-1000, -56, -240, 51, -1000, -1000, -45, 12, 16, -1000,
-1000, 1085, 1085, 910, 910, 910, -1000, -3, -1000, -1000,
734, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000, -1000,
-1000, -1000, -1000, -1000, -13, 1408, -1000, -1000, -1000, 734,
734, 734, -309, 734, -1000, 734, -1000, -1000, -1000, 910,
910, 734, -257, 31, 734, 910, 910, 734, 734, 910,
-1000, 910, 910, 910, 910, 910, 910, 910, 910, 910,
910, 910, 910, 910, 910, -1000, -77, -1000, -1000, -266,
-1000, -1000, -1000, -1000, -1000, -1000, 30, 29, 39, -14,
-1000, -1000, -6, -1000, -53, 38, -1000, -1000, -96, 10,
-1000, -399, 28, 27, -399, -399, -399, -399, -399, -399,
-399, -399, 12, 12, 16, 16, -1000, -1000, -1000, 139,
139, 734, 734, 910, -1000, 734, 26, 734, -1000, -1000,
-341, -1000, 25, -15, -1000, 24, -1000, -1000, 139, -17,
734, -1000, -1000, -1000, 19, 139, -1000 };
int yypgo[]={
0, 118, 112, 75, 153, 329, 117, 1610, 116, 26,
1391, 39, 115, 114, 35, 113, 111, 1480, 103, 99,
109, 108, 107, 106, 105, 354, 104, 102, 101, 1527,
13, 27, 100, 36, 24, 98, 23, 97, 96, 95,
34, 94, 93, 31, 28, 12, 25, 92, 91, 90 };
int yyr1[]={
0, 37, 11, 11, 38, 38, 39, 32, 32, 32,
41, 12, 12, 42, 12, 12, 35, 35, 45, 45,
40, 40, 43, 43, 43, 44, 44, 47, 48, 48,
31, 49, 49, 46, 46, 46, 46, 9, 9, 9,
10, 10, 10, 10, 10, 10, 10, 10, 10, 10,
22, 23, 24, 30, 30, 29, 29, 17, 17, 17,
17, 34, 34, 34, 34, 34, 34, 34, 34, 34,
34, 34, 13, 13, 3, 3, 3, 2, 2, 8,
8, 4, 4, 26, 26, 27, 27, 28, 28, 21,
21, 21, 20, 20, 20, 20, 20, 25, 25, 25,
18, 18, 18, 19, 19, 19, 19, 5, 5, 5,
5, 5, 5, 15, 15, 15, 14, 14, 14, 14,
14, 14, 7, 7, 7, 7, 16, 6, 6, 6,
36, 36, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 33, 33, 33, 33,
33, 33, 33, 33, 33, 33, 33, 33, 1, 1 };
int yyr2[]={
0, 3, 7, 1, 0, 3, 7, 2, 2, 2,
1, 15, 11, 1, 11, 3, 3, 1, 2, 1,
0, 2, 2, 2, 2, 2, 6, 5, 2, 0,
9, 0, 8, 3, 7, 3, 3, 1, 5, 5,
5, 2, 2, 2, 2, 5, 2, 7, 5, 5,
11, 15, 19, 1, 3, 3, 7, 2, 7, 5,
7, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 5, 1, 3, 7, 2, 11, 2,
7, 2, 7, 2, 7, 2, 7, 2, 7, 2,
7, 7, 2, 7, 7, 7, 7, 2, 7, 7,
2, 7, 7, 2, 7, 7, 7, 2, 5, 5,
5, 5, 5, 2, 5, 5, 2, 2, 2, 2,
7, 11, 3, 3, 2, 9, 3, 9, 9, 13,
2, 5, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
3, 3, 3, 3, 3, 3, 3, 3, 11, 15 };
int yychk[]={
-1000, -37, -11, -12, -35, -33, -39, 369, 257, 299,
264, 268, 270, 323, 272, 342, 271, 319, 286, 298,
273, 274, 320, 263, 300, 303, 308, 368, 347, 309,
386, 387, 282, 411, 390, 412, 413, 281, 326, 388,
404, 405, 406, 389, 383, 336, 338, 429, 337, 351,
424, 427, 425, 426, 428, 339, 408, 409, 410, 344,
340, 350, 355, 356, 357, 358, 359, 361, 362, 341,
335, 333, 346, 343, 334, 348, 331, 332, 310, 311,
312, 314, 349, 328, 301, 327, 365, 373, 374, 376,
375, 370, 378, 377, 379, 380, 381, 385, 371, 324,
372, 315, 414, 415, 416, 417, 398, 399, 325, 421,
422, 423, 420, 419, 366, -38, 59, 259, -42, 40,
269, -11, 40, -43, 262, 285, 329, -40, -46, 259,
296, 330, 59, -40, -44, -47, -48, 42, 41, 44,
41, 59, 44, 259, -31, 123, 259, -41, -44, -49,
-31, -9, -43, -10, 256, -29, -1, -22, -23, -24,
-13, -31, 407, 318, 360, -17, 258, 317, 321, 322,
266, -2, -7, 418, -8, 259, 296, 330, -14, -4,
-6, -16, -32, 40, -26, -33, -36, 269, 283, 352,
353, -27, 367, -28, -21, -20, -25, -18, -19, -5,
-15, 275, 276, 267, 126, 45, 125, -46, -9, 59,
-34, 61, 393, 395, 397, 401, 403, 304, 305, 307,
364, 306, 59, 59, -29, 256, -45, 59, -45, 44,
40, 40, -10, 40, -29, -34, 275, 276, -10, 63,
261, 91, 382, -29, 123, 260, 124, 40, 40, 94,
259, 38, 293, 302, 62, 294, 60, 295, 400, 402,
43, 45, 42, 37, 47, -7, -14, -7, -5, -7,
-5, -5, -45, -17, 59, -29, -29, -29, 317, -30,
-29, -17, -2, -4, -29, -36, 259, 41, -3, -17,
-4, -25, -3, -3, -25, -25, -25, -25, -25, -25,
-25, -25, -18, -18, -19, -19, -5, -5, -5, 41,
41, 40, 59, 58, 93, 40, 125, 44, 41, 41,
-10, -10, -29, -30, -2, -3, 41, -3, 345, 41,
59, 41, -10, -45, -30, 41, -10 };
int yydef[]={
-2, -2, 1, 4, 13, 0, 15, 16, 132, 133,
134, 135, 136, 137, 138, 139, 140, 141, 142, 143,
144, 145, 146, 147, 148, 149, 150, 151, 152, 153,
154, 155, 156, 157, 158, 159, 160, 161, 162, 163,
164, 165, 166, 167, 168, 169, 170, 171, 172, 173,
174, 175, 176, 177, 178, 179, 180, 181, 182, 183,
184, 185, 186, 187, 188, 189, 190, 191, 192, 193,
194, 195, 196, 197, 198, 199, 200, 201, 202, 203,
204, 205, 206, 207, 208, 209, 210, 211, 212, 213,
214, 215, 216, 217, 218, 219, 220, 221, 222, 223,
224, 225, 226, 227, 228, 229, 230, 231, 232, 233,
234, 235, 236, 237, 0, -2, 5, 0, 0, 20,
0, 2, 20, 29, 22, 23, 24, 0, 21, 33,
35, 36, 6, 0, 0, 25, 0, 28, 0, 0,
10, 14, 29, 27, 12, 31, 34, 0, 26, -2,
11, 0, 0, -2, 0, 0, 41, 42, 43, 44,
0, 46, 0, 19, 19, 55, 0, 0, 0, 0,
-2, 57, 117, 0, 77, -2, 123, 124, 113, 79,
116, 118, 119, 0, 81, 0, 0, 126, 7, 8,
9, 83, 0, 85, 87, 89, 92, 97, 100, 103,
107, 0, 0, 0, 0, 0, 30, 19, 38, 39,
0, 61, 62, 63, 64, 65, 66, 67, 68, 69,
70, 71, 40, 45, 0, 0, 48, 18, 49, 0,
0, 0, 0, -2, 73, 0, 114, 115, 59, 0,
0, 0, 0, 0, -2, 0, 0, -2, -2, 0,
131, 0, 0, 0, 0, 0, 0, 0, 0, 0,
0, 0, 0, 0, 0, -2, 0, -2, 110, 117,
111, 112, 32, 60, 47, 56, 0, 0, 0, 0,
54, 58, 0, 80, 0, 0, 130, 120, 0, 75,
82, 84, 0, 0, 86, 88, 90, 91, 93, 94,
95, 96, 98, 99, 101, 102, 104, 105, 106, 0,
0, 0, -2, 0, 125, -2, 0, -2, 127, 128,
238, 50, 0, 0, 78, 0, 121, 76, 0, 19,
-2, 129, 239, 51, 0, 0, 52 };
typedef struct { char *t_name; int t_val; } yytoktype;
#ifndef YYDEBUG
# define YYDEBUG 0 /* don't allow debugging */
#endif
#if YYDEBUG
yytoktype yytoks[] =
{
"F_THIS_PLAYER", 257,
"F_IF", 258,
"F_IDENTIFIER", 259,
"F_LAND", 260,
"F_LOR", 261,
"F_STATUS", 262,
"F_SET_TRUE", 263,
"F_SET_FALSE", 264,
"F_CONS", 265,
"F_RETURN", 266,
"F_NOT", 267,
"F_WRITE", 268,
"F_STRING", 269,
"F_ADD_VERB", 270,
"F_ADD_ADJ", 271,
"F_ADD_SUBST", 272,
"F_ADD_ACTION", 273,
"F_MOVE_OBJECT", 274,
"F_INC", 275,
"F_DEC", 276,
"F_POST_INC", 277,
"F_POST_DEC", 278,
"F_COMMA", 279,
"F_COND", 280,
"F_QUERY_LOAD_AVERAGE", 281,
"F_THIS_VERB", 282,
"F_NUMBER", 283,
"F_ASSIGN", 284,
"F_INT", 285,
"F_CALL_OTHER", 286,
"F_ADD", 287,
"F_SUBTRACT", 288,
"F_MULTIPLY", 289,
"F_DIVIDE", 290,
"F_LT", 291,
"F_GT", 292,
"F_EQ", 293,
"F_GE", 294,
"F_LE", 295,
"F_ARGUMENT", 296,
"F_FUNCTION", 297,
"F_CLONE_OBJECT", 298,
"F_THIS_OBJECT", 299,
"F_SAVE_OBJECT", 300,
"F_RESTORE_OBJECT", 301,
"F_NE", 302,
"F_ENVIRONMENT", 303,
"F_ADD_EQ", 304,
"F_SUB_EQ", 305,
"F_DIV_EQ", 306,
"F_MULT_EQ", 307,
"F_PRESENT", 308,
"F_COMMAND", 309,
"F_SET_LIGHT", 310,
"F_DESTRUCT", 311,
"F_CREATE_WIZARD", 312,
"F_NEGATE", 313,
"F_SAY", 314,
"F_STRLEN", 315,
"F_SUBSCRIPT", 316,
"F_WHILE", 317,
"F_BREAK", 318,
"F_SHUTDOWN", 319,
"F_LOG_FILE", 320,
"F_DO", 321,
"F_FOR", 322,
"F_ADD_XVERB", 323,
"F_FIND_CALL_OUT", 324,
"F_READ_FILE", 325,
"F_FILTER_OBJECTS", 326,
"F_SSCANF", 327,
"F_SHOUT", 328,
"F_STRING_DECL", 329,
"F_LOCAL_NAME", 330,
"F_FIRST_INVENTORY", 331,
"F_NEXT_INVENTORY", 332,
"F_ENABLE_COMMANDS", 333,
"F_RANDOM", 334,
"F_INPUT_TO", 335,
"F_CRYPT", 336,
"F_LS", 337,
"F_CAT", 338,
"F_FIND_LIVING", 339,
"F_TELL_OBJECT", 340,
"F_PEOPLE", 341,
"F_ED", 342,
"F_LIVING", 343,
"F_LOWER_CASE", 344,
"F_ELSE", 345,
"F_CAPITALIZE", 346,
"F_SET_HEART_BEAT", 347,
"F_SNOOP", 348,
"F_TELL_ROOM", 349,
"F_FIND_OBJECT", 350,
"F_RM", 351,
"F_CONST0", 352,
"F_CONST1", 353,
"F_BLOCK", 354,
"F_TRANSFER", 355,
"F_REGCOMP", 356,
"F_REGEXEC", 357,
"F_LOCALCMD", 358,
"F_SWAP", 359,
"F_CONTINUE", 360,
"F_ADD_WORTH", 361,
"F_TIME", 362,
"F_MOD", 363,
"F_MOD_EQ", 364,
"F_QUERY_IP_NUMBER", 365,
"F_INHERIT", 366,
"F_COLON_COLON", 367,
"F_CREATOR", 368,
"F_STATIC", 369,
"F_CALL_OUT", 370,
"F_REMOVE_CALL_OUT", 371,
"F_COMBINE_FREE_LIST", 372,
"F_ALLOCATE", 373,
"F_SIZEOF", 374,
"F_DISABLE_COMMANDS", 375,
"F_CTIME", 376,
"F_INTP", 377,
"F_STRINGP", 378,
"F_OBJECTP", 379,
"F_POINTERP", 380,
"F_USERS", 381,
"F_ARROW", 382,
"F_PREVIOUS_OBJECT", 383,
"F_AGGREGATE", 384,
"F_EXTRACT", 385,
"F_FILE_NAME", 386,
"F_QUERY_VERB", 387,
"F_TAIL", 388,
"F_QUERY_HOST_NAME", 389,
"F_EXPLODE", 390,
"F_COMPL", 391,
"F_AND", 392,
"F_AND_EQ", 393,
"F_OR", 394,
"F_OR_EQ", 395,
"F_XOR", 396,
"F_XOR_EQ", 397,
"F_CP", 398,
"F_RENAME", 399,
"F_LSH", 400,
"F_LSH_EQ", 401,
"F_RSH", 402,
"F_RSH_EQ", 403,
"F_MKDIR", 404,
"F_RMDIR", 405,
"F_QUERY_SNOOP", 406,
"F_THROW", 407,
"F_FIND_PLAYER", 408,
"F_WRITE_FILE", 409,
"F_FILE_SIZE", 410,
"F_PARSE_COMMAND", 411,
"F_IMPLODE", 412,
"F_QUERY_IDLE", 413,
"F_REMOTE_COMMAND", 414,
"F_INTERACTIVE", 415,
"F_CALLER", 416,
"F_TYPEOF", 417,
"F_CATCH", 418,
"F_NOTIFY_FAIL", 419,
"F_SET_LIVING_NAME", 420,
"F_SET_BIT", 421,
"F_CLEAR_BIT", 422,
"F_TEST_BIT", 423,
"F_REALLOCATE", 424,
"F_INDEX", 425,
"F_SEARCHA", 426,
"F_CONTENTS", 427,
"F_IN_EDITOR", 428,
"F_GREP", 429,
"-unknown-", -1 /* ends search */
};
char * yyreds[] =
{
"-no such reduction-",
"all : program",
"program : def possible_semi_colon program",
"program : /* empty */",
"possible_semi_colon : /* empty */",
"possible_semi_colon : ';'",
"inheritance : F_INHERIT F_STRING ';'",
"number : F_NUMBER",
"number : F_CONST0",
"number : F_CONST1",
"def : static F_IDENTIFIER '(' argument ')'",
"def : static F_IDENTIFIER '(' argument ')' block",
"def : name '(' argument ')' block",
"def : static",
"def : static type name_list ';'",
"def : inheritance",
"static : F_STATIC",
"static : /* empty */",
"req_semi : ';'",
"req_semi : /* empty */",
"argument : /* empty */",
"argument : local_list",
"type : F_STATUS",
"type : F_INT",
"type : F_STRING_DECL",
"name_list : new_name",
"name_list : new_name ',' name_list",
"new_name : optional_star F_IDENTIFIER",
"optional_star : '*'",
"optional_star : /* empty */",
"block : '{' local_declarations statements '}'",
"local_declarations : /* empty */",
"local_declarations : local_declarations type local_list req_semi",
"local_list : F_IDENTIFIER",
"local_list : local_list ',' F_IDENTIFIER",
"local_list : F_ARGUMENT",
"local_list : F_LOCAL_NAME",
"statements : /* empty */",
"statements : statement statements",
"statements : error ';'",
"statement : comma_expr ';'",
"statement : cond",
"statement : while",
"statement : do",
"statement : for",
"statement : return ';'",
"statement : block",
"statement : F_THROW comma_expr ';'",
"statement : F_BREAK req_semi",
"statement : F_CONTINUE req_semi",
"while : F_WHILE '(' comma_expr ')' statement",
"do : F_DO statement F_WHILE '(' comma_expr ')' req_semi",
"for : F_FOR '(' for_expr ';' for_expr ';' for_expr ')' statement",
"for_expr : /* empty */",
"for_expr : comma_expr",
"comma_expr : expr0",
"comma_expr : expr0 ',' comma_expr",
"expr0 : expr1",
"expr0 : variable assign expr0",
"expr0 : F_CATCH statement",
"expr0 : error assign expr0",
"assign : '='",
"assign : F_AND_EQ",
"assign : F_OR_EQ",
"assign : F_XOR_EQ",
"assign : F_LSH_EQ",
"assign : F_RSH_EQ",
"assign : F_ADD_EQ",
"assign : F_SUB_EQ",
"assign : F_MULT_EQ",
"assign : F_MOD_EQ",
"assign : F_DIV_EQ",
"return : F_RETURN",
"return : F_RETURN comma_expr",
"expr_list : /* empty */",
"expr_list : expr0",
"expr_list : expr0 ',' expr_list",
"expr1 : expr11",
"expr1 : expr11 '?' expr1 ':' expr1",
"expr11 : expr2",
"expr11 : expr11 F_LOR expr2",
"expr2 : expr211",
"expr2 : expr211 F_LAND expr2",
"expr211 : expr212",
"expr211 : expr211 '|' expr24",
"expr212 : expr213",
"expr212 : expr212 '^' expr24",
"expr213 : expr22",
"expr213 : expr213 '&' expr24",
"expr22 : expr23",
"expr22 : expr24 F_EQ expr24",
"expr22 : expr24 F_NE expr24",
"expr23 : expr24",
"expr23 : expr24 '>' expr24",
"expr23 : expr24 F_GE expr24",
"expr23 : expr24 '<' expr24",
"expr23 : expr24 F_LE expr24",
"expr24 : expr25",
"expr24 : expr24 F_LSH expr25",
"expr24 : expr24 F_RSH expr25",
"expr25 : expr27",
"expr25 : expr25 '+' expr27",
"expr25 : expr25 '-' expr27",
"expr27 : expr3",
"expr27 : expr27 '*' expr3",
"expr27 : expr27 '%' expr3",
"expr27 : expr27 '/' expr3",
"expr3 : expr31",
"expr3 : F_INC variable",
"expr3 : F_DEC variable",
"expr3 : F_NOT expr3",
"expr3 : '~' expr3",
"expr3 : '-' expr3",
"expr31 : expr4",
"expr31 : variable F_INC",
"expr31 : variable F_DEC",
"expr4 : function_call",
"expr4 : variable",
"expr4 : string",
"expr4 : number",
"expr4 : '(' comma_expr ')'",
"expr4 : '(' '{' expr_list '}' ')'",
"variable : F_IDENTIFIER",
"variable : F_ARGUMENT",
"variable : F_LOCAL_NAME",
"variable : expr4 '[' comma_expr ']'",
"string : F_STRING",
"function_call : name '(' expr_list ')'",
"function_call : function_name '(' expr_list ')'",
"function_call : expr4 F_ARROW function_name '(' expr_list ')'",
"function_name : F_IDENTIFIER",
"function_name : F_COLON_COLON F_IDENTIFIER",
"name : F_THIS_PLAYER",
"name : F_THIS_OBJECT",
"name : F_SET_FALSE",
"name : F_WRITE",
"name : F_ADD_VERB",
"name : F_ADD_XVERB",
"name : F_ADD_SUBST",
"name : F_ED",
"name : F_ADD_ADJ",
"name : F_SHUTDOWN",
"name : F_CALL_OTHER",
"name : F_CLONE_OBJECT",
"name : F_ADD_ACTION",
"name : F_MOVE_OBJECT",
"name : F_LOG_FILE",
"name : F_SET_TRUE",
"name : F_SAVE_OBJECT",
"name : F_ENVIRONMENT",
"name : F_PRESENT",
"name : F_CREATOR",
"name : F_SET_HEART_BEAT",
"name : F_COMMAND",
"name : F_FILE_NAME",
"name : F_QUERY_VERB",
"name : F_THIS_VERB",
"name : F_PARSE_COMMAND",
"name : F_EXPLODE",
"name : F_IMPLODE",
"name : F_QUERY_IDLE",
"name : F_QUERY_LOAD_AVERAGE",
"name : F_FILTER_OBJECTS",
"name : F_TAIL",
"name : F_MKDIR",
"name : F_RMDIR",
"name : F_QUERY_SNOOP",
"name : F_QUERY_HOST_NAME",
"name : F_PREVIOUS_OBJECT",
"name : F_CRYPT",
"name : F_CAT",
"name : F_GREP",
"name : F_LS",
"name : F_RM",
"name : F_REALLOCATE",
"name : F_CONTENTS",
"name : F_INDEX",
"name : F_SEARCHA",
"name : F_IN_EDITOR",
"name : F_FIND_LIVING",
"name : F_FIND_PLAYER",
"name : F_WRITE_FILE",
"name : F_FILE_SIZE",
"name : F_LOWER_CASE",
"name : F_TELL_OBJECT",
"name : F_FIND_OBJECT",
"name : F_TRANSFER",
"name : F_REGCOMP",
"name : F_REGEXEC",
"name : F_LOCALCMD",
"name : F_SWAP",
"name : F_ADD_WORTH",
"name : F_TIME",
"name : F_PEOPLE",
"name : F_INPUT_TO",
"name : F_ENABLE_COMMANDS",
"name : F_CAPITALIZE",
"name : F_LIVING",
"name : F_RANDOM",
"name : F_SNOOP",
"name : F_FIRST_INVENTORY",
"name : F_NEXT_INVENTORY",
"name : F_SET_LIGHT",
"name : F_DESTRUCT",
"name : F_CREATE_WIZARD",
"name : F_SAY",
"name : F_TELL_ROOM",
"name : F_SHOUT",
"name : F_RESTORE_OBJECT",
"name : F_SSCANF",
"name : F_QUERY_IP_NUMBER",
"name : F_ALLOCATE",
"name : F_SIZEOF",
"name : F_CTIME",
"name : F_DISABLE_COMMANDS",
"name : F_CALL_OUT",
"name : F_STRINGP",
"name : F_INTP",
"name : F_OBJECTP",
"name : F_POINTERP",
"name : F_USERS",
"name : F_EXTRACT",
"name : F_REMOVE_CALL_OUT",
"name : F_FIND_CALL_OUT",
"name : F_COMBINE_FREE_LIST",
"name : F_STRLEN",
"name : F_REMOTE_COMMAND",
"name : F_INTERACTIVE",
"name : F_CALLER",
"name : F_TYPEOF",
"name : F_CP",
"name : F_RENAME",
"name : F_READ_FILE",
"name : F_SET_BIT",
"name : F_CLEAR_BIT",
"name : F_TEST_BIT",
"name : F_SET_LIVING_NAME",
"name : F_NOTIFY_FAIL",
"cond : F_IF '(' comma_expr ')' statement",
"cond : F_IF '(' comma_expr ')' statement F_ELSE statement",
};
#endif /* YYDEBUG */
#line 1 "/usr/lib/yaccpar"
/* @(#)yaccpar 1.10 89/04/04 SMI; from S5R3 1.10 */
/*
** Skeleton parser driver for yacc output
*/
/*
** yacc user known macros and defines
*/
#define YYERROR goto yyerrlab
#define YYACCEPT { free(yys); free(yyv); return(0); }
#define YYABORT { free(yys); free(yyv); return(1); }
#define YYBACKUP( newtoken, newvalue )\
{\
if ( yychar >= 0 || ( yyr2[ yytmp ] >> 1 ) != 1 )\
{\
yyerror( "syntax error - cannot backup" );\
goto yyerrlab;\
}\
yychar = newtoken;\
yystate = *yyps;\
yylval = newvalue;\
goto yynewstate;\
}
#define YYRECOVERING() (!!yyerrflag)
#ifndef YYDEBUG
# define YYDEBUG 1 /* make debugging available */
#endif
/*
** user known globals
*/
int yydebug; /* set to 1 to get debugging */
/*
** driver internal defines
*/
#define YYFLAG (-1000)
/*
** static variables used by the parser
*/
static YYSTYPE *yyv; /* value stack */
static int *yys; /* state stack */
static YYSTYPE *yypv; /* top of value stack */
static int *yyps; /* top of state stack */
static int yystate; /* current state */
static int yytmp; /* extra var (lasts between blocks) */
int yynerrs; /* number of errors */
int yyerrflag; /* error recovery flag */
int yychar; /* current input token number */
/*
** yyparse - return 0 if worked, 1 if syntax error not recovered from
*/
int
yyparse()
{
register YYSTYPE *yypvt; /* top of value stack for $vars */
unsigned yymaxdepth = YYMAXDEPTH;
/*
** Initialize externals - yyparse may be called more than once
*/
yyv = (YYSTYPE*)malloc(yymaxdepth*sizeof(YYSTYPE));
yys = (int*)malloc(yymaxdepth*sizeof(int));
if (!yyv || !yys)
{
yyerror( "out of memory" );
return(1);
}
yypv = &yyv[-1];
yyps = &yys[-1];
yystate = 0;
yytmp = 0;
yynerrs = 0;
yyerrflag = 0;
yychar = -1;
goto yystack;
{
register YYSTYPE *yy_pv; /* top of value stack */
register int *yy_ps; /* top of state stack */
register int yy_state; /* current state */
register int yy_n; /* internal state number info */
/*
** get globals into registers.
** branch to here only if YYBACKUP was called.
*/
yynewstate:
yy_pv = yypv;
yy_ps = yyps;
yy_state = yystate;
goto yy_newstate;
/*
** get globals into registers.
** either we just started, or we just finished a reduction
*/
yystack:
yy_pv = yypv;
yy_ps = yyps;
yy_state = yystate;
/*
** top of for (;;) loop while no reductions done
*/
yy_stack:
/*
** put a state and value onto the stacks
*/
#if YYDEBUG
/*
** if debugging, look up token value in list of value vs.
** name pairs. 0 and negative (-1) are special values.
** Note: linear search is used since time is not a real
** consideration while debugging.
*/
if ( yydebug )
{
register int yy_i;
(void)printf( "State %d, token ", yy_state );
if ( yychar == 0 )
(void)printf( "end-of-file\n" );
else if ( yychar < 0 )
(void)printf( "-none-\n" );
else
{
for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
yy_i++ )
{
if ( yytoks[yy_i].t_val == yychar )
break;
}
(void)printf( "%s\n", yytoks[yy_i].t_name );
}
}
#endif /* YYDEBUG */
if ( ++yy_ps >= &yys[ yymaxdepth ] ) /* room on stack? */
{
/*
** reallocate and recover. Note that pointers
** have to be reset, or bad things will happen
*/
int yyps_index = (yy_ps - yys);
int yypv_index = (yy_pv - yyv);
int yypvt_index = (yypvt - yyv);
yymaxdepth += YYMAXDEPTH;
yyv = (YYSTYPE*)realloc((char*)yyv,
yymaxdepth * sizeof(YYSTYPE));
yys = (int*)realloc((char*)yys,
yymaxdepth * sizeof(int));
if (!yyv || !yys)
{
yyerror( "yacc stack overflow" );
return(1);
}
yy_ps = yys + yyps_index;
yy_pv = yyv + yypv_index;
yypvt = yyv + yypvt_index;
}
*yy_ps = yy_state;
*++yy_pv = yyval;
/*
** we have a new state - find out what to do
*/
yy_newstate:
if ( ( yy_n = yypact[ yy_state ] ) <= YYFLAG )
goto yydefault; /* simple state */
#if YYDEBUG
/*
** if debugging, need to mark whether new token grabbed
*/
yytmp = yychar < 0;
#endif
if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
yychar = 0; /* reached EOF */
#if YYDEBUG
if ( yydebug && yytmp )
{
register int yy_i;
(void)printf( "Received token " );
if ( yychar == 0 )
(void)printf( "end-of-file\n" );
else if ( yychar < 0 )
(void)printf( "-none-\n" );
else
{
for ( yy_i = 0; yytoks[yy_i].t_val >= 0;
yy_i++ )
{
if ( yytoks[yy_i].t_val == yychar )
break;
}
(void)printf( "%s\n", yytoks[yy_i].t_name );
}
}
#endif /* YYDEBUG */
if ( ( ( yy_n += yychar ) < 0 ) || ( yy_n >= YYLAST ) )
goto yydefault;
if ( yychk[ yy_n = yyact[ yy_n ] ] == yychar ) /*valid shift*/
{
yychar = -1;
yyval = yylval;
yy_state = yy_n;
if ( yyerrflag > 0 )
yyerrflag--;
goto yy_stack;
}
yydefault:
if ( ( yy_n = yydef[ yy_state ] ) == -2 )
{
#if YYDEBUG
yytmp = yychar < 0;
#endif
if ( ( yychar < 0 ) && ( ( yychar = yylex() ) < 0 ) )
yychar = 0; /* reached EOF */
#if YYDEBUG
if ( yydebug && yytmp )
{
register int yy_i;
(void)printf( "Received token " );
if ( yychar == 0 )
(void)printf( "end-of-file\n" );
else if ( yychar < 0 )
(void)printf( "-none-\n" );
else
{
for ( yy_i = 0;
yytoks[yy_i].t_val >= 0;
yy_i++ )
{
if ( yytoks[yy_i].t_val
== yychar )
{
break;
}
}
(void)printf( "%s\n", yytoks[yy_i].t_name );
}
}
#endif /* YYDEBUG */
/*
** look through exception table
*/
{
register int *yyxi = yyexca;
while ( ( *yyxi != -1 ) ||
( yyxi[1] != yy_state ) )
{
yyxi += 2;
}
while ( ( *(yyxi += 2) >= 0 ) &&
( *yyxi != yychar ) )
;
if ( ( yy_n = yyxi[1] ) < 0 )
YYACCEPT;
}
}
/*
** check for syntax error
*/
if ( yy_n == 0 ) /* have an error */
{
/* no worry about speed here! */
switch ( yyerrflag )
{
case 0: /* new error */
yyerror( "syntax error" );
goto skip_init;
yyerrlab:
/*
** get globals into registers.
** we have a user generated syntax type error
*/
yy_pv = yypv;
yy_ps = yyps;
yy_state = yystate;
yynerrs++;
skip_init:
case 1:
case 2: /* incompletely recovered error */
/* try again... */
yyerrflag = 3;
/*
** find state where "error" is a legal
** shift action
*/
while ( yy_ps >= yys )
{
yy_n = yypact[ *yy_ps ] + YYERRCODE;
if ( yy_n >= 0 && yy_n < YYLAST &&
yychk[yyact[yy_n]] == YYERRCODE) {
/*
** simulate shift of "error"
*/
yy_state = yyact[ yy_n ];
goto yy_stack;
}
/*
** current state has no shift on
** "error", pop stack
*/
#if YYDEBUG
# define _POP_ "Error recovery pops state %d, uncovers state %d\n"
if ( yydebug )
(void)printf( _POP_, *yy_ps,
yy_ps[-1] );
# undef _POP_
#endif
yy_ps--;
yy_pv--;
}
/*
** there is no state on stack with "error" as
** a valid shift. give up.
*/
YYABORT;
case 3: /* no shift yet; eat a token */
#if YYDEBUG
/*
** if debugging, look up token in list of
** pairs. 0 and negative shouldn't occur,
** but since timing doesn't matter when
** debugging, it doesn't hurt to leave the
** tests here.
*/
if ( yydebug )
{
register int yy_i;
(void)printf( "Error recovery discards " );
if ( yychar == 0 )
(void)printf( "token end-of-file\n" );
else if ( yychar < 0 )
(void)printf( "token -none-\n" );
else
{
for ( yy_i = 0;
yytoks[yy_i].t_val >= 0;
yy_i++ )
{
if ( yytoks[yy_i].t_val
== yychar )
{
break;
}
}
(void)printf( "token %s\n",
yytoks[yy_i].t_name );
}
}
#endif /* YYDEBUG */
if ( yychar == 0 ) /* reached EOF. quit */
YYABORT;
yychar = -1;
goto yy_newstate;
}
}/* end if ( yy_n == 0 ) */
/*
** reduction by production yy_n
** put stack tops, etc. so things right after switch
*/
#if YYDEBUG
/*
** if debugging, print the string that is the user's
** specification of the reduction which is just about
** to be done.
*/
if ( yydebug )
(void)printf( "Reduce by (%d) \"%s\"\n",
yy_n, yyreds[ yy_n ] );
#endif
yytmp = yy_n; /* value to switch over */
yypvt = yy_pv; /* $vars top of value stack */
/*
** Look in goto table for next state
** Sorry about using yy_state here as temporary
** register variable, but why not, if it works...
** If yyr2[ yy_n ] doesn't have the low order bit
** set, then there is no action to be done for
** this reduction. So, no saving & unsaving of
** registers done. The only difference between the
** code just after the if and the body of the if is
** the goto yy_stack in the body. This way the test
** can be made before the choice of what to do is needed.
*/
{
/* length of production doubled with extra bit */
register int yy_len = yyr2[ yy_n ];
if ( !( yy_len & 01 ) )
{
yy_len >>= 1;
yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
*( yy_ps -= yy_len ) + 1;
if ( yy_state >= YYLAST ||
yychk[ yy_state =
yyact[ yy_state ] ] != -yy_n )
{
yy_state = yyact[ yypgo[ yy_n ] ];
}
goto yy_stack;
}
yy_len >>= 1;
yyval = ( yy_pv -= yy_len )[1]; /* $$ = $1 */
yy_state = yypgo[ yy_n = yyr1[ yy_n ] ] +
*( yy_ps -= yy_len ) + 1;
if ( yy_state >= YYLAST ||
yychk[ yy_state = yyact[ yy_state ] ] != -yy_n )
{
yy_state = yyact[ yypgo[ yy_n ] ];
}
}
/* save until reenter driver code */
yystate = yy_state;
yyps = yy_ps;
yypv = yy_pv;
}
/*
** code supplied by user is placed in this switch
*/
switch( yytmp )
{
case 1:
# line 95 "lang.y"
{ prog = yypvt[-0].lnode; } break;
case 2:
# line 98 "lang.y"
{ if (yypvt[-2].lnode != 0) {
struct lnode_def *p = (struct lnode_def *)yypvt[-2].lnode;
p->next = (struct lnode_def *)yypvt[-0].lnode;
yyval.lnode = (struct lnode *)p;
} else
yyval.lnode = yypvt[-0].lnode;
} break;
case 3:
# line 105 "lang.y"
{ yyval.lnode = 0; } break;
case 5:
# line 108 "lang.y"
{ yyerror("Extra ';'. Ignored."); } break;
case 6:
# line 111 "lang.y"
{
if (inherit_ob || inherit_file) {
yyerror("Multiple inheritance not allowed.\n");
free(yypvt[-1].string);
} else if (prog) {
yyerror("inherit must come first.\n");
free(yypvt[-1].string);
} else {
inherit_ob = find_object2(yypvt[-1].string);
if (inherit_ob == 0) {
inherit_file = yypvt[-1].string;
return 0;
}
free(yypvt[-1].string);
copy_variables(inherit_ob);
}
} break;
case 10:
# line 132 "lang.y"
{ num_arg = current_number_of_locals; } break;
case 11:
# line 134 "lang.y"
{ struct lnode_def *p;
p = alloc_lnode_def(F_IDENTIFIER,yypvt[-5].string,yypvt[-0].lnode,
current_number_of_locals);
p->num_arg = num_arg;
if (yypvt[-6].number)
p->is_static = 1;
yyval.lnode = (struct lnode *)p;
if (strcmp(p->name, "heart_beat") == 0) heart_beat = yyval.lnode;
if (argument_name) free(argument_name);
argument_name = 0; free_all_local_names(); } break;
case 12:
# line 145 "lang.y"
{ yyerror("Predefined function name.\n"); yyval.lnode = 0; } break;
case 13:
# line 146 "lang.y"
{ static_variable_flag = yypvt[-0].number; } break;
case 14:
# line 147 "lang.y"
{ yyval.lnode = 0; static_variable_flag = 0; } break;
case 15:
# line 148 "lang.y"
{ yyval.lnode = 0; } break;
case 16:
# line 150 "lang.y"
{ yyval.number = 1; } break;
case 17:
# line 151 "lang.y"
{ yyval.number = 0; } break;
case 19:
# line 155 "lang.y"
{ yyerror("Missing ';'"); } break;
case 27:
# line 166 "lang.y"
{ alloc_lnode_var_def(F_STATUS, yypvt[-0].string, variable_count++); } break;
case 30:
# line 171 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_block(yypvt[-1].lnode); } break;
case 33:
# line 176 "lang.y"
{ add_local_name(yypvt[-0].string); } break;
case 34:
# line 177 "lang.y"
{ add_local_name(yypvt[-0].string); } break;
case 35:
# line 178 "lang.y"
{ yyerror("Illegal to redeclare argument"); } break;
case 36:
# line 179 "lang.y"
{ yyerror("Illegal to redeclare local name"); } break;
case 37:
# line 181 "lang.y"
{ yyval.lnode = 0; } break;
case 38:
# line 183 "lang.y"
{ if (yypvt[-1].lnode == 0)
yyval.lnode = yypvt[-0].lnode;
else
yyval.lnode = (struct lnode *)alloc_lnode_2(F_CONS, yypvt[-1].lnode, yypvt[-0].lnode);
} break;
case 39:
# line 188 "lang.y"
{ yyval.lnode = 0; } break;
case 40:
# line 190 "lang.y"
{ yyval.lnode = yypvt[-1].lnode; } break;
case 45:
# line 191 "lang.y"
{ yyval.lnode = yypvt[-1].lnode; } break;
case 47:
# line 194 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(F_THROW, yypvt[-1].lnode); } break;
case 48:
# line 195 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_single(F_BREAK);
} break;
case 49:
# line 197 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_single(F_CONTINUE);
} break;
case 50:
# line 201 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_WHILE, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 51:
# line 204 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_DO, yypvt[-5].lnode, yypvt[-2].lnode); } break;
case 52:
# line 207 "lang.y"
{ yyval.lnode = (struct lnode *)
alloc_lnode_2(F_CONS,yypvt[-6].lnode,
(struct lnode *)
alloc_lnode_2(F_CONS,
(struct lnode *)alloc_lnode_3(F_FOR,yypvt[-4].lnode,
yypvt[-2].lnode,yypvt[-0].lnode),
(struct lnode *)0)); } break;
case 53:
# line 216 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_single(F_CONST1); } break;
case 54:
# line 218 "lang.y"
{ yyval.lnode=yypvt[-0].lnode; } break;
case 55:
# line 221 "lang.y"
{ yyval.lnode=yypvt[-0].lnode; } break;
case 56:
# line 223 "lang.y"
{
if(yypvt[-0].lnode->type==F_COMMA)
yyval.lnode = (struct lnode *)alloc_lnode_2(F_COMMA, yypvt[-2].lnode, yypvt[-0].lnode);
else
yyval.lnode = (struct lnode *)alloc_lnode_2(F_COMMA, yypvt[-2].lnode,
(struct lnode *)alloc_lnode_2(F_COMMA, yypvt[-0].lnode, 0));
} break;
case 58:
# line 233 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(yypvt[-1].number, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 59:
# line 235 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(F_CATCH, yypvt[-0].lnode); } break;
case 60:
# line 236 "lang.y"
{ yyerror("Illegal LHS"); yyval.lnode = 0; } break;
case 61:
# line 238 "lang.y"
{ yyval.number = F_ASSIGN; } break;
case 62:
# line 239 "lang.y"
{ yyval.number = F_AND_EQ; } break;
case 63:
# line 240 "lang.y"
{ yyval.number = F_OR_EQ; } break;
case 64:
# line 241 "lang.y"
{ yyval.number = F_XOR_EQ; } break;
case 65:
# line 242 "lang.y"
{ yyval.number = F_LSH_EQ; } break;
case 66:
# line 243 "lang.y"
{ yyval.number = F_RSH_EQ; } break;
case 67:
# line 244 "lang.y"
{ yyval.number = F_ADD_EQ; } break;
case 68:
# line 245 "lang.y"
{ yyval.number = F_SUB_EQ; } break;
case 69:
# line 246 "lang.y"
{ yyval.number = F_MULT_EQ; } break;
case 70:
# line 247 "lang.y"
{ yyval.number = F_MOD; } break;
case 71:
# line 248 "lang.y"
{ yyval.number = F_DIV_EQ; } break;
case 72:
# line 250 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(F_RETURN, 0); } break;
case 73:
# line 251 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(F_RETURN, yypvt[-0].lnode); } break;
case 74:
# line 253 "lang.y"
{ yyval.lnode = 0; } break;
case 75:
# line 255 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_CONS, yypvt[-0].lnode, 0); } break;
case 76:
# line 257 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_CONS, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 78:
# line 261 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_3(F_COND, yypvt[-4].lnode, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 80:
# line 265 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_LOR, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 82:
# line 269 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_LAND, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 84:
# line 273 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_OR, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 86:
# line 277 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_XOR, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 88:
# line 281 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_AND, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 90:
# line 285 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_EQ, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 91:
# line 287 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_NE, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 93:
# line 291 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_GT, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 94:
# line 293 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_GE, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 95:
# line 295 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_LT, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 96:
# line 297 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_LE, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 98:
# line 301 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_LSH, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 99:
# line 303 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_RSH, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 101:
# line 307 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_ADD, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 102:
# line 309 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_SUBTRACT, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 104:
# line 313 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_MULTIPLY, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 105:
# line 315 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_MOD, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 106:
# line 317 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_DIVIDE, yypvt[-2].lnode, yypvt[-0].lnode); } break;
case 108:
# line 321 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(F_INC, yypvt[-0].lnode); } break;
case 109:
# line 323 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(F_DEC, yypvt[-0].lnode); } break;
case 110:
# line 325 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(F_NOT, yypvt[-0].lnode); } break;
case 111:
# line 327 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(F_COMPL, yypvt[-0].lnode); } break;
case 112:
# line 329 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(F_NEGATE, yypvt[-0].lnode); } break;
case 114:
# line 333 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(F_POST_INC, yypvt[-1].lnode); } break;
case 115:
# line 335 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(F_POST_DEC, yypvt[-1].lnode); } break;
case 120:
# line 338 "lang.y"
{ yyval.lnode = yypvt[-1].lnode; } break;
case 121:
# line 339 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(F_AGGREGATE, yypvt[-2].lnode); } break;
case 122:
# line 342 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_number(F_IDENTIFIER,
check_deklared(yypvt[-0].string));
free(yypvt[-0].string); } break;
case 123:
# line 345 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_single(F_ARGUMENT); } break;
case 125:
# line 348 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_2(F_SUBSCRIPT, yypvt[-3].lnode, yypvt[-1].lnode); } break;
case 126:
# line 351 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_name(F_STRING, yypvt[-0].string); } break;
case 127:
# line 354 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_1(yypvt[-3].number, yypvt[-1].lnode); } break;
case 128:
# line 356 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_funcall(F_FUNCTION, yypvt[-3].string, yypvt[-1].lnode); } break;
case 129:
# line 358 "lang.y"
{
struct lnode *p;
p = (struct lnode *)alloc_lnode_name(F_STRING, yypvt[-3].string),
p = (struct lnode *)alloc_lnode_2(F_CONS, p, yypvt[-1].lnode);
p = (struct lnode *)alloc_lnode_2(F_CONS, yypvt[-5].lnode, p);
yyval.lnode = (struct lnode *)alloc_lnode_1(F_CALL_OTHER, p);
} break;
case 131:
# line 368 "lang.y"
{
char *p = xalloc(strlen(yypvt[-0].string) + 3);
strcpy(p, "::"); strcat(p, yypvt[-0].string); free(yypvt[-0].string);
yyval.string = p;
} break;
case 132:
# line 374 "lang.y"
{ yyval.number = F_THIS_PLAYER; } break;
case 133:
# line 375 "lang.y"
{ yyval.number = F_THIS_OBJECT; } break;
case 134:
# line 376 "lang.y"
{ yyval.number = F_SET_FALSE; } break;
case 135:
# line 377 "lang.y"
{ yyval.number = F_WRITE; } break;
case 136:
# line 378 "lang.y"
{ yyval.number = F_ADD_VERB; } break;
case 137:
# line 379 "lang.y"
{ yyval.number = F_ADD_XVERB; } break;
case 138:
# line 380 "lang.y"
{ yyval.number = F_ADD_SUBST; } break;
case 139:
# line 381 "lang.y"
{ yyval.number = F_ED; } break;
case 140:
# line 382 "lang.y"
{ yyval.number = F_ADD_ADJ; } break;
case 141:
# line 383 "lang.y"
{ yyval.number = F_SHUTDOWN; } break;
case 142:
# line 384 "lang.y"
{ yyval.number = F_CALL_OTHER; } break;
case 143:
# line 385 "lang.y"
{ yyval.number = F_CLONE_OBJECT; } break;
case 144:
# line 386 "lang.y"
{ yyval.number = F_ADD_ACTION; } break;
case 145:
# line 387 "lang.y"
{ yyval.number = F_MOVE_OBJECT; } break;
case 146:
# line 388 "lang.y"
{ yyval.number = F_LOG_FILE; } break;
case 147:
# line 389 "lang.y"
{ yyval.number = F_SET_TRUE; } break;
case 148:
# line 390 "lang.y"
{ yyval.number = F_SAVE_OBJECT; } break;
case 149:
# line 391 "lang.y"
{ yyval.number = F_ENVIRONMENT; } break;
case 150:
# line 392 "lang.y"
{ yyval.number = F_PRESENT; } break;
case 151:
# line 393 "lang.y"
{ yyval.number = F_CREATOR; } break;
case 152:
# line 394 "lang.y"
{ yyval.number = F_SET_HEART_BEAT; } break;
case 153:
# line 395 "lang.y"
{ yyval.number = F_COMMAND; } break;
case 154:
# line 396 "lang.y"
{ yyval.number = F_FILE_NAME; } break;
case 155:
# line 397 "lang.y"
{ yyval.number = F_QUERY_VERB; } break;
case 156:
# line 398 "lang.y"
{ yyval.number = F_QUERY_VERB; } break;
case 157:
# line 399 "lang.y"
{ yyval.number = F_PARSE_COMMAND; } break;
case 158:
# line 400 "lang.y"
{ yyval.number = F_EXPLODE; } break;
case 159:
# line 401 "lang.y"
{ yyval.number = F_IMPLODE; } break;
case 160:
# line 402 "lang.y"
{ yyval.number = F_QUERY_IDLE; } break;
case 161:
# line 403 "lang.y"
{ yyval.number = F_QUERY_LOAD_AVERAGE; } break;
case 162:
# line 404 "lang.y"
{ yyval.number = F_FILTER_OBJECTS; } break;
case 163:
# line 405 "lang.y"
{ yyval.number = F_TAIL; } break;
case 164:
# line 406 "lang.y"
{ yyval.number = F_MKDIR; } break;
case 165:
# line 407 "lang.y"
{ yyval.number = F_RMDIR; } break;
case 166:
# line 408 "lang.y"
{ yyval.number = F_QUERY_SNOOP; } break;
case 167:
# line 409 "lang.y"
{ yyval.number = F_QUERY_HOST_NAME; } break;
case 168:
# line 410 "lang.y"
{ yyval.number = F_PREVIOUS_OBJECT; } break;
case 169:
# line 411 "lang.y"
{ yyval.number = F_CRYPT; } break;
case 170:
# line 412 "lang.y"
{ yyval.number = F_CAT; } break;
case 171:
# line 413 "lang.y"
{ yyval.number = F_GREP; } break;
case 172:
# line 414 "lang.y"
{ yyval.number = F_LS; } break;
case 173:
# line 415 "lang.y"
{ yyval.number = F_RM; } break;
case 174:
# line 416 "lang.y"
{ yyval.number = F_REALLOCATE; } break;
case 175:
# line 417 "lang.y"
{ yyval.number = F_CONTENTS; } break;
case 176:
# line 418 "lang.y"
{ yyval.number = F_INDEX; } break;
case 177:
# line 419 "lang.y"
{ yyval.number = F_SEARCHA; } break;
case 178:
# line 420 "lang.y"
{ yyval.number = F_IN_EDITOR; } break;
case 179:
# line 421 "lang.y"
{ yyval.number = F_FIND_LIVING; } break;
case 180:
# line 422 "lang.y"
{ yyval.number = F_FIND_PLAYER; } break;
case 181:
# line 423 "lang.y"
{ yyval.number = F_WRITE_FILE; } break;
case 182:
# line 424 "lang.y"
{ yyval.number = F_FILE_SIZE; } break;
case 183:
# line 425 "lang.y"
{ yyval.number = F_LOWER_CASE; } break;
case 184:
# line 426 "lang.y"
{ yyval.number = F_TELL_OBJECT; } break;
case 185:
# line 427 "lang.y"
{ yyval.number = F_FIND_OBJECT; } break;
case 186:
# line 428 "lang.y"
{ yyval.number = F_TRANSFER; } break;
case 187:
# line 429 "lang.y"
{ yyval.number = F_REGCOMP; } break;
case 188:
# line 430 "lang.y"
{ yyval.number = F_REGEXEC; } break;
case 189:
# line 431 "lang.y"
{ yyval.number = F_LOCALCMD; } break;
case 190:
# line 432 "lang.y"
{ yyval.number = F_SWAP; } break;
case 191:
# line 433 "lang.y"
{ yyval.number = F_ADD_WORTH; } break;
case 192:
# line 434 "lang.y"
{ yyval.number = F_TIME; } break;
case 193:
# line 435 "lang.y"
{ yyval.number = F_PEOPLE; } break;
case 194:
# line 436 "lang.y"
{ yyval.number = F_INPUT_TO; } break;
case 195:
# line 437 "lang.y"
{ yyval.number = F_ENABLE_COMMANDS; } break;
case 196:
# line 438 "lang.y"
{ yyval.number = F_CAPITALIZE; } break;
case 197:
# line 439 "lang.y"
{ yyval.number = F_LIVING; } break;
case 198:
# line 440 "lang.y"
{ yyval.number = F_RANDOM; } break;
case 199:
# line 441 "lang.y"
{ yyval.number = F_SNOOP; } break;
case 200:
# line 442 "lang.y"
{ yyval.number = F_FIRST_INVENTORY; } break;
case 201:
# line 443 "lang.y"
{ yyval.number = F_NEXT_INVENTORY; } break;
case 202:
# line 444 "lang.y"
{ yyval.number = F_SET_LIGHT; } break;
case 203:
# line 445 "lang.y"
{ yyval.number = F_DESTRUCT; } break;
case 204:
# line 446 "lang.y"
{ yyval.number = F_CREATE_WIZARD; } break;
case 205:
# line 447 "lang.y"
{ yyval.number = F_SAY; } break;
case 206:
# line 448 "lang.y"
{ yyval.number = F_TELL_ROOM; } break;
case 207:
# line 449 "lang.y"
{ yyval.number = F_SHOUT; } break;
case 208:
# line 450 "lang.y"
{ yyval.number = F_RESTORE_OBJECT; } break;
case 209:
# line 451 "lang.y"
{ yyval.number = F_SSCANF; } break;
case 210:
# line 452 "lang.y"
{ yyval.number = F_QUERY_IP_NUMBER; } break;
case 211:
# line 453 "lang.y"
{ yyval.number = F_ALLOCATE; } break;
case 212:
# line 454 "lang.y"
{ yyval.number = F_SIZEOF; } break;
case 213:
# line 455 "lang.y"
{ yyval.number = F_CTIME; } break;
case 214:
# line 456 "lang.y"
{ yyval.number = F_DISABLE_COMMANDS; } break;
case 215:
# line 457 "lang.y"
{ yyval.number = F_CALL_OUT; } break;
case 216:
# line 458 "lang.y"
{ yyval.number = F_STRINGP; } break;
case 217:
# line 459 "lang.y"
{ yyval.number = F_INTP; } break;
case 218:
# line 460 "lang.y"
{ yyval.number = F_OBJECTP; } break;
case 219:
# line 461 "lang.y"
{ yyval.number = F_POINTERP; } break;
case 220:
# line 462 "lang.y"
{ yyval.number = F_USERS; } break;
case 221:
# line 463 "lang.y"
{ yyval.number = F_EXTRACT; } break;
case 222:
# line 464 "lang.y"
{ yyval.number = F_REMOVE_CALL_OUT; } break;
case 223:
# line 465 "lang.y"
{ yyval.number = F_FIND_CALL_OUT; } break;
case 224:
# line 466 "lang.y"
{ yyval.number = F_COMBINE_FREE_LIST; } break;
case 225:
# line 467 "lang.y"
{ yyval.number = F_STRLEN; } break;
case 226:
# line 468 "lang.y"
{ yyval.number = F_REMOTE_COMMAND; } break;
case 227:
# line 469 "lang.y"
{ yyval.number = F_INTERACTIVE; } break;
case 228:
# line 470 "lang.y"
{ yyval.number = F_CALLER; } break;
case 229:
# line 471 "lang.y"
{ yyval.number = F_TYPEOF; } break;
case 230:
# line 472 "lang.y"
{ yyval.number = F_CP; } break;
case 231:
# line 473 "lang.y"
{ yyval.number = F_RENAME; } break;
case 232:
# line 474 "lang.y"
{ yyval.number = F_READ_FILE; } break;
case 233:
# line 475 "lang.y"
{ yyval.number = F_SET_BIT; } break;
case 234:
# line 476 "lang.y"
{ yyval.number = F_CLEAR_BIT; } break;
case 235:
# line 477 "lang.y"
{ yyval.number = F_TEST_BIT; } break;
case 236:
# line 478 "lang.y"
{ yyval.number = F_SET_LIVING_NAME; } break;
case 237:
# line 479 "lang.y"
{ yyval.number = F_NOTIFY_FAIL; } break;
case 238:
# line 481 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_3(F_IF, yypvt[-2].lnode, yypvt[-0].lnode, 0); } break;
case 239:
# line 483 "lang.y"
{ yyval.lnode = (struct lnode *)alloc_lnode_3(F_IF, yypvt[-4].lnode, yypvt[-2].lnode, yypvt[-0].lnode); } break;
}
goto yystack; /* reset registers in driver code */
}