%{
/* NetHack 3.6  lev_comp.y	$NHDT-Date: 1455746893 2016/02/17 22:08:13 $  $NHDT-Branch: NetHack-3.6.0 $:$NHDT-Revision: 1.21 $ */
/*      Copyright (c) 1989 by Jean-Christophe Collet */
/* NetHack may be freely redistributed.  See license for details. */

/*
 * This file contains the Level Compiler code
 * It may handle special mazes & special room-levels
 */

/* In case we're using bison in AIX.  This definition must be
 * placed before any other C-language construct in the file
 * excluding comments and preprocessor directives (thanks IBM
 * for this wonderful feature...).
 *
 * Note: some cpps barf on this 'undefined control' (#pragma).
 * Addition of the leading space seems to prevent barfage for now,
 * and AIX will still see the directive.
 */
#ifdef _AIX
 #pragma alloca         /* keep leading space! */
#endif

#define SPEC_LEV    /* for USE_OLDARGS (sp_lev.h) */
#include "hack.h"
#include "sp_lev.h"

#define ERR             (-1)
/* many types of things are put in chars for transference to NetHack.
 * since some systems will use signed chars, limit everybody to the
 * same number for portability.
 */
#define MAX_OF_TYPE     128

#define MAX_NESTED_IFS   20
#define MAX_SWITCH_CASES 20

#define New(type) \
        (type *) memset((genericptr_t) alloc(sizeof (type)), 0, sizeof (type))
#define NewTab(type, size)      (type **) alloc(sizeof (type *) * size)
#define Free(ptr)               free((genericptr_t) ptr)

extern void VDECL(lc_error, (const char *, ...));
extern void VDECL(lc_warning, (const char *, ...));
extern void FDECL(yyerror, (const char *));
extern void FDECL(yywarning, (const char *));
extern int NDECL(yylex);
int NDECL(yyparse);

extern int FDECL(get_floor_type, (CHAR_P));
extern int FDECL(get_room_type, (char *));
extern int FDECL(get_trap_type, (char *));
extern int FDECL(get_monster_id, (char *,CHAR_P));
extern int FDECL(get_object_id, (char *,CHAR_P));
extern boolean FDECL(check_monster_char, (CHAR_P));
extern boolean FDECL(check_object_char, (CHAR_P));
extern char FDECL(what_map_char, (CHAR_P));
extern void FDECL(scan_map, (char *, sp_lev *));
extern void FDECL(add_opcode, (sp_lev *, int, genericptr_t));
extern genericptr_t FDECL(get_last_opcode_data1, (sp_lev *, int));
extern genericptr_t FDECL(get_last_opcode_data2, (sp_lev *, int, int));
extern boolean FDECL(check_subrooms, (sp_lev *));
extern boolean FDECL(write_level_file, (char *,sp_lev *));
extern struct opvar *FDECL(set_opvar_int, (struct opvar *, long));
extern void VDECL(add_opvars, (sp_lev *, const char *, ...));
extern void FDECL(start_level_def, (sp_lev * *, char *));

extern struct lc_funcdefs *FDECL(funcdef_new, (long,char *));
extern void FDECL(funcdef_free_all, (struct lc_funcdefs *));
extern struct lc_funcdefs *FDECL(funcdef_defined, (struct lc_funcdefs *,
                                                   char *, int));
extern char *FDECL(funcdef_paramtypes, (struct lc_funcdefs *));
extern char *FDECL(decode_parm_str, (char *));

extern struct lc_vardefs *FDECL(vardef_new, (long,char *));
extern void FDECL(vardef_free_all, (struct lc_vardefs *));
extern struct lc_vardefs *FDECL(vardef_defined, (struct lc_vardefs *,
                                                 char *, int));

extern void NDECL(break_stmt_start);
extern void FDECL(break_stmt_end, (sp_lev *));
extern void FDECL(break_stmt_new, (sp_lev *, long));

extern void FDECL(splev_add_from, (sp_lev *, sp_lev *));

extern void FDECL(check_vardef_type, (struct lc_vardefs *, char *, long));
extern void FDECL(vardef_used, (struct lc_vardefs *, char *));
extern struct lc_vardefs *FDECL(add_vardef_type, (struct lc_vardefs *,
                                                  char *, long));

extern int FDECL(reverse_jmp_opcode, (int));

struct coord {
    long x;
    long y;
};

struct forloopdef {
    char *varname;
    long jmp_point;
};
static struct forloopdef forloop_list[MAX_NESTED_IFS];
static short n_forloops = 0;


sp_lev *splev = NULL;

static struct opvar *if_list[MAX_NESTED_IFS];

static short n_if_list = 0;

unsigned int max_x_map, max_y_map;
int obj_containment = 0;

int in_container_obj = 0;

/* integer value is possibly an inconstant value (eg. dice notation or a variable) */
int is_inconstant_number = 0;

int in_switch_statement = 0;
static struct opvar *switch_check_jump = NULL;
static struct opvar *switch_default_case = NULL;
static struct opvar *switch_case_list[MAX_SWITCH_CASES];
static long switch_case_value[MAX_SWITCH_CASES];
int n_switch_case_list = 0;

int allow_break_statements = 0;
struct lc_breakdef *break_list = NULL;

extern struct lc_vardefs *variable_definitions;


struct lc_vardefs *function_tmp_var_defs = NULL;
extern struct lc_funcdefs *function_definitions;
struct lc_funcdefs *curr_function = NULL;
struct lc_funcdefs_parm * curr_function_param = NULL;
int in_function_definition = 0;
sp_lev *function_splev_backup = NULL;

extern int fatal_error;
extern int got_errors;
extern int line_number;
extern const char *fname;

extern char curr_token[512];

%}

%union
{
	long	i;
	char*	map;
	struct {
		long room;
		long wall;
		long door;
	} corpos;
    struct {
	long area;
	long x1;
	long y1;
	long x2;
	long y2;
    } lregn;
    struct {
	long x;
	long y;
    } crd;
    struct {
	long ter;
	long lit;
    } terr;
    struct {
	long height;
	long width;
    } sze;
    struct {
	long die;
	long num;
    } dice;
    struct {
	long cfunc;
	char *varstr;
    } meth;
}


%token	<i> CHAR INTEGER BOOLEAN PERCENT SPERCENT
%token	<i> MINUS_INTEGER PLUS_INTEGER
%token	<i> MAZE_GRID_ID SOLID_FILL_ID MINES_ID ROGUELEV_ID
%token	<i> MESSAGE_ID MAZE_ID LEVEL_ID LEV_INIT_ID GEOMETRY_ID NOMAP_ID
%token	<i> OBJECT_ID COBJECT_ID MONSTER_ID TRAP_ID DOOR_ID DRAWBRIDGE_ID
%token	<i> object_ID monster_ID terrain_ID
%token	<i> MAZEWALK_ID WALLIFY_ID REGION_ID FILLING IRREGULAR JOINED
%token	<i> ALTAR_ID LADDER_ID STAIR_ID NON_DIGGABLE_ID NON_PASSWALL_ID ROOM_ID
%token	<i> PORTAL_ID TELEPRT_ID BRANCH_ID LEV MINERALIZE_ID
%token	<i> CORRIDOR_ID GOLD_ID ENGRAVING_ID FOUNTAIN_ID POOL_ID SINK_ID NONE
%token	<i> RAND_CORRIDOR_ID DOOR_STATE LIGHT_STATE CURSE_TYPE ENGRAVING_TYPE
%token	<i> DIRECTION RANDOM_TYPE RANDOM_TYPE_BRACKET A_REGISTER
%token	<i> ALIGNMENT LEFT_OR_RIGHT CENTER TOP_OR_BOT ALTAR_TYPE UP_OR_DOWN
%token	<i> SUBROOM_ID NAME_ID FLAGS_ID FLAG_TYPE MON_ATTITUDE MON_ALERTNESS
%token	<i> MON_APPEARANCE ROOMDOOR_ID IF_ID ELSE_ID
%token	<i> TERRAIN_ID HORIZ_OR_VERT REPLACE_TERRAIN_ID
%token	<i> EXIT_ID SHUFFLE_ID
%token	<i> QUANTITY_ID BURIED_ID LOOP_ID
%token	<i> FOR_ID TO_ID
%token	<i> SWITCH_ID CASE_ID BREAK_ID DEFAULT_ID
%token	<i> ERODED_ID TRAPPED_STATE RECHARGED_ID INVIS_ID GREASED_ID
%token	<i> FEMALE_ID CANCELLED_ID REVIVED_ID AVENGE_ID FLEEING_ID BLINDED_ID
%token	<i> PARALYZED_ID STUNNED_ID CONFUSED_ID SEENTRAPS_ID ALL_ID
%token	<i> MONTYPE_ID
%token	<i> GRAVE_ID ERODEPROOF_ID
%token	<i> FUNCTION_ID
%token	<i> MSG_OUTPUT_TYPE
%token	<i> COMPARE_TYPE
%token  <i> UNKNOWN_TYPE
%token	<i> rect_ID fillrect_ID line_ID randline_ID grow_ID selection_ID flood_ID
%token	<i> rndcoord_ID circle_ID ellipse_ID filter_ID complement_ID
%token	<i> gradient_ID GRADIENT_TYPE LIMITED HUMIDITY_TYPE
%token	<i> ',' ':' '(' ')' '[' ']' '{' '}'
%token	<map> STRING MAP_ID
%token	<map> NQSTRING VARSTRING
%token	<map> CFUNC CFUNC_INT CFUNC_STR CFUNC_COORD CFUNC_REGION
%token	<map> VARSTRING_INT VARSTRING_INT_ARRAY
%token	<map> VARSTRING_STRING VARSTRING_STRING_ARRAY
%token	<map> VARSTRING_VAR VARSTRING_VAR_ARRAY
%token	<map> VARSTRING_COORD VARSTRING_COORD_ARRAY
%token	<map> VARSTRING_REGION VARSTRING_REGION_ARRAY
%token	<map> VARSTRING_MAPCHAR VARSTRING_MAPCHAR_ARRAY
%token	<map> VARSTRING_MONST VARSTRING_MONST_ARRAY
%token	<map> VARSTRING_OBJ VARSTRING_OBJ_ARRAY
%token	<map> VARSTRING_SEL VARSTRING_SEL_ARRAY
%token	<meth> METHOD_INT METHOD_INT_ARRAY
%token	<meth> METHOD_STRING METHOD_STRING_ARRAY
%token	<meth> METHOD_VAR METHOD_VAR_ARRAY
%token	<meth> METHOD_COORD METHOD_COORD_ARRAY
%token	<meth> METHOD_REGION METHOD_REGION_ARRAY
%token	<meth> METHOD_MAPCHAR METHOD_MAPCHAR_ARRAY
%token	<meth> METHOD_MONST METHOD_MONST_ARRAY
%token	<meth> METHOD_OBJ METHOD_OBJ_ARRAY
%token	<meth> METHOD_SEL METHOD_SEL_ARRAY
%token	<dice> DICE
%type	<i> h_justif v_justif trap_name room_type door_state light_state
%type	<i> alignment altar_type a_register roomfill door_pos
%type	<i> alignment_prfx
%type	<i> door_wall walled secret
%type	<i> dir_list teleprt_detail
%type	<i> object_infos object_info monster_infos monster_info
%type	<i> levstatements stmt_block region_detail_end
%type	<i> engraving_type flag_list roomregionflag roomregionflags optroomregionflags
%type	<i> humidity_flags
%type	<i> comparestmt encodecoord encoderegion mapchar
%type	<i> seen_trap_mask
%type	<i> encodemonster encodeobj encodeobj_list
%type	<i> integer_list string_list encodecoord_list encoderegion_list mapchar_list encodemonster_list
%type	<i> opt_percent opt_fillchar
%type	<i> all_integers
%type	<i> ter_selection ter_selection_x
%type	<i> func_param_type
%type	<i> objectid monsterid terrainid
%type	<i> opt_coord_or_var opt_limited
%type   <i> mazefiller
%type	<map> level_def
%type	<map> any_var any_var_array any_var_or_arr any_var_or_unk
%type	<map> func_call_params_list func_call_param_list
%type	<i> func_call_param_part
%type	<corpos> corr_spec
%type	<lregn> region lev_region
%type	<crd> room_pos subroom_pos room_align
%type	<sze> room_size
%type	<terr> terrain_type
%left  '+' '-'
%left  '*' '/' '%'
%start	file

%%
file		: /* nothing */
		| levels
		;

levels		: level
		| level levels
		;

level		: level_def flags levstatements
		  {
			if (fatal_error > 0) {
				(void) fprintf(stderr,
				"%s: %d errors detected for level \"%s\". No output created!\n",
					       fname, fatal_error, $1);
				fatal_error = 0;
				got_errors++;
			} else if (!got_errors) {
				if (!write_level_file($1, splev)) {
				    lc_error("Can't write output file for '%s'!", $1);
				    exit(EXIT_FAILURE);
				}
			}
			Free($1);
			Free(splev);
			splev = NULL;
			vardef_free_all(variable_definitions);
			variable_definitions = NULL;
		  }
		;

level_def	: LEVEL_ID ':' STRING
		  {
		      start_level_def(&splev, $3);
		      $$ = $3;
		  }
		| MAZE_ID ':' STRING ',' mazefiller
		  {
		      start_level_def(&splev, $3);
		      if ($5 == -1) {
			  add_opvars(splev, "iiiiiiiio",
				     VA_PASS9(LVLINIT_MAZEGRID,HWALL,0,0,
					      0,0,0,0, SPO_INITLEVEL));
		      } else {
			  long bg = what_map_char((char) $5);
			  add_opvars(splev, "iiiiiiiio",
				     VA_PASS9(LVLINIT_SOLIDFILL, bg, 0,0,
					      0,0,0,0, SPO_INITLEVEL));
		      }
		      add_opvars(splev, "io",
				 VA_PASS2(MAZELEVEL, SPO_LEVEL_FLAGS));
		      max_x_map = COLNO-1;
		      max_y_map = ROWNO;
		      $$ = $3;
		  }
		;

mazefiller	: RANDOM_TYPE
		  {
		      $$ = -1;
		  }
		| CHAR
		  {
		      $$ = what_map_char((char) $1);
		  }
		;

lev_init	: LEV_INIT_ID ':' SOLID_FILL_ID ',' terrain_type
		  {
		      long filling = $5.ter;
		      if (filling == INVALID_TYPE || filling >= MAX_TYPE)
			  lc_error("INIT_MAP: Invalid fill char type.");
		      add_opvars(splev, "iiiiiiiio",
				 LVLINIT_SOLIDFILL,filling,0,(long)$5.lit, 0,0,0,0, SPO_INITLEVEL);
		      max_x_map = COLNO-1;
		      max_y_map = ROWNO;
		  }
		| LEV_INIT_ID ':' MAZE_GRID_ID ',' CHAR
		  {
		      long filling = what_map_char((char) $5);
		      if (filling == INVALID_TYPE || filling >= MAX_TYPE)
			  lc_error("INIT_MAP: Invalid fill char type.");
		      add_opvars(splev, "iiiiiiiio",
				 VA_PASS9(LVLINIT_MAZEGRID,filling,0,0,
					  0,0,0,0, SPO_INITLEVEL));
		      max_x_map = COLNO-1;
		      max_y_map = ROWNO;
		  }
		| LEV_INIT_ID ':' ROGUELEV_ID
		  {
		      add_opvars(splev, "iiiiiiiio",
				 VA_PASS9(LVLINIT_ROGUE,0,0,0,
					  0,0,0,0, SPO_INITLEVEL));
		  }
		| LEV_INIT_ID ':' MINES_ID ',' CHAR ',' CHAR ',' BOOLEAN ',' BOOLEAN ',' light_state ',' walled opt_fillchar
		  {
		      long fg = what_map_char((char) $5);
		      long bg = what_map_char((char) $7);
		      long smoothed = $9;
		      long joined = $11;
		      long lit = $13;
		      long walled = $15;
		      long filling = $16;
		      if (fg == INVALID_TYPE || fg >= MAX_TYPE)
			  lc_error("INIT_MAP: Invalid foreground type.");
		      if (bg == INVALID_TYPE || bg >= MAX_TYPE)
			  lc_error("INIT_MAP: Invalid background type.");
		      if (joined && fg != CORR && fg != ROOM)
			  lc_error("INIT_MAP: Invalid foreground type for joined map.");

		      if (filling == INVALID_TYPE)
			  lc_error("INIT_MAP: Invalid fill char type.");

		      add_opvars(splev, "iiiiiiiio",
				 VA_PASS9(LVLINIT_MINES,filling,walled,lit,
					  joined,smoothed,bg,fg,
					  SPO_INITLEVEL));
			max_x_map = COLNO-1;
			max_y_map = ROWNO;
		  }
		;

opt_limited	: /* nothing */
		  {
		      $$ = 0;
		  }
		| ',' LIMITED
		  {
		      $$ = $2;
		  }
		;

opt_coord_or_var	: /* nothing */
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_COPY));
		      $$ = 0;
		  }
		| ',' coord_or_var
		  {
		      $$ = 1;
		  }
		;

opt_fillchar	: /* nothing */
		  {
		      $$ = -1;
		  }
		| ',' CHAR
		  {
		      $$ = what_map_char((char) $2);
		  }
		;


walled		: BOOLEAN
		| RANDOM_TYPE
		;

flags		: /* nothing */
		  {
		      add_opvars(splev, "io", VA_PASS2(0, SPO_LEVEL_FLAGS));
		  }
		| FLAGS_ID ':' flag_list
		  {
		      add_opvars(splev, "io", VA_PASS2($3, SPO_LEVEL_FLAGS));
		  }
		;

flag_list	: FLAG_TYPE ',' flag_list
		  {
		      $$ = ($1 | $3);
		  }
		| FLAG_TYPE
		  {
		      $$ = $1;
		  }
		;

levstatements	: /* nothing */
		  {
		      $$ = 0;
		  }
		| levstatement levstatements
		  {
		      $$ = 1 + $2;
		  }
		;

stmt_block	: '{' levstatements '}'
		  {
		      $$ = $2;
		  }
		;

levstatement 	: message
		| lev_init
		| altar_detail
		| grave_detail
		| branch_region
		| corridor
		| variable_define
		| shuffle_detail
		| diggable_detail
		| door_detail
		| drawbridge_detail
		| engraving_detail
		| mineralize
		| fountain_detail
		| gold_detail
		| switchstatement
		| forstatement
		| loopstatement
		| ifstatement
		| chancestatement
		| exitstatement
		| breakstatement
		| function_define
		| function_call
		| ladder_detail
		| map_definition
		| mazewalk_detail
		| monster_detail
		| object_detail
		| passwall_detail
		| pool_detail
		| portal_region
		| random_corridors
		| region_detail
		| room_def
		| subroom_def
		| sink_detail
		| terrain_detail
		| replace_terrain_detail
		| stair_detail
		| stair_region
		| teleprt_region
		| trap_detail
		| wallify_detail
		;

any_var_array	: VARSTRING_INT_ARRAY
		| VARSTRING_STRING_ARRAY
		| VARSTRING_VAR_ARRAY
		| VARSTRING_COORD_ARRAY
		| VARSTRING_REGION_ARRAY
		| VARSTRING_MAPCHAR_ARRAY
		| VARSTRING_MONST_ARRAY
		| VARSTRING_OBJ_ARRAY
		| VARSTRING_SEL_ARRAY
		;

any_var		: VARSTRING_INT
		| VARSTRING_STRING
		| VARSTRING_VAR
		| VARSTRING_COORD
		| VARSTRING_REGION
		| VARSTRING_MAPCHAR
		| VARSTRING_MONST
		| VARSTRING_OBJ
		| VARSTRING_SEL
		;

any_var_or_arr	: any_var_array
		| any_var
		| VARSTRING
		;

any_var_or_unk	: VARSTRING
		| any_var
		;

shuffle_detail	: SHUFFLE_ID ':' any_var_array
		  {
		      struct lc_vardefs *vd;
		      if ((vd = vardef_defined(variable_definitions, $3, 1))) {
			  if (!(vd->var_type & SPOVAR_ARRAY))
			      lc_error("Trying to shuffle non-array variable '%s'", $3);
		      } else lc_error("Trying to shuffle undefined variable '%s'", $3);
		      add_opvars(splev, "so", VA_PASS2($3, SPO_SHUFFLE_ARRAY));
		      Free($3);
		  }
		;

variable_define	: any_var_or_arr '=' math_expr_var
		  {
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_INT);
		      add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' selection_ID ':' ter_selection
		  {
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_SEL);
		      add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' string_expr
		  {
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_STRING);
		      add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' terrainid ':' mapchar_or_var
		  {
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_MAPCHAR);
		      add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' monsterid ':' monster_or_var
		  {
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_MONST);
		      add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' objectid ':' object_or_var
		  {
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_OBJ);
		      add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' coord_or_var
		  {
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_COORD);
		      add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' region_or_var
		  {
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_REGION);
		      add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' '{' integer_list '}'
		  {
		      long n_items = $4;
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_INT|SPOVAR_ARRAY);
		      add_opvars(splev, "iso",
				 VA_PASS3(n_items, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' '{' encodecoord_list '}'
		  {
		      long n_items = $4;
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_COORD|SPOVAR_ARRAY);
		      add_opvars(splev, "iso",
				 VA_PASS3(n_items, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' '{' encoderegion_list '}'
		  {
		      long n_items = $4;
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_REGION|SPOVAR_ARRAY);
		      add_opvars(splev, "iso",
				 VA_PASS3(n_items, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' terrainid ':' '{' mapchar_list '}'
		  {
		      long n_items = $6;
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_MAPCHAR|SPOVAR_ARRAY);
		      add_opvars(splev, "iso",
				 VA_PASS3(n_items, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' monsterid ':' '{' encodemonster_list '}'
		  {
		      long n_items = $6;
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_MONST|SPOVAR_ARRAY);
		      add_opvars(splev, "iso",
				 VA_PASS3(n_items, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' objectid ':' '{' encodeobj_list '}'
		  {
		      long n_items = $6;
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_OBJ|SPOVAR_ARRAY);
		      add_opvars(splev, "iso",
				 VA_PASS3(n_items, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		| any_var_or_arr '=' '{' string_list '}'
		  {
		      long n_items = $4;
		      variable_definitions = add_vardef_type(variable_definitions, $1, SPOVAR_STRING|SPOVAR_ARRAY);
		      add_opvars(splev, "iso",
				 VA_PASS3(n_items, $1, SPO_VAR_INIT));
		      Free($1);
		  }
		;

encodeobj_list	: encodeobj
		  {
		      add_opvars(splev, "O", VA_PASS1($1));
		      $$ = 1;
		  }
		| encodeobj_list ',' encodeobj
		  {
		      add_opvars(splev, "O", VA_PASS1($3));
		      $$ = 1 + $1;
		  }
		;

encodemonster_list	: encodemonster
		  {
		      add_opvars(splev, "M", VA_PASS1($1));
		      $$ = 1;
		  }
		| encodemonster_list ',' encodemonster
		  {
		      add_opvars(splev, "M", VA_PASS1($3));
		      $$ = 1 + $1;
		  }
		;

mapchar_list	: mapchar
		  {
		      add_opvars(splev, "m", VA_PASS1($1));
		      $$ = 1;
		  }
		| mapchar_list ',' mapchar
		  {
		      add_opvars(splev, "m", VA_PASS1($3));
		      $$ = 1 + $1;
		  }
		;

encoderegion_list	: encoderegion
		  {
		      $$ = 1;
		  }
		| encoderegion_list ',' encoderegion
		  {
		      $$ = 1 + $1;
		  }
		;

encodecoord_list	: encodecoord
		  {
		      add_opvars(splev, "c", VA_PASS1($1));
		      $$ = 1;
		  }
		| encodecoord_list ',' encodecoord
		  {
		      add_opvars(splev, "c", VA_PASS1($3));
		      $$ = 1 + $1;
		  }
		;

integer_list	: math_expr_var
		  {
		      $$ = 1;
		  }
		| integer_list ',' math_expr_var
		  {
		      $$ = 1 + $1;
		  }
		;

string_list	: string_expr
		  {
		      $$ = 1;
		  }
		| string_list ',' string_expr
		  {
		      $$ = 1 + $1;
		  }
		;

function_define	: FUNCTION_ID NQSTRING '('
		  {
		      struct lc_funcdefs *funcdef;

		      if (in_function_definition)
			  lc_error("Recursively defined functions not allowed (function %s).", $2);

		      in_function_definition++;

		      if (funcdef_defined(function_definitions, $2, 1))
			  lc_error("Function '%s' already defined once.", $2);

		      funcdef = funcdef_new(-1, $2);
		      funcdef->next = function_definitions;
		      function_definitions = funcdef;
		      function_splev_backup = splev;
		      splev = &(funcdef->code);
		      Free($2);
		      curr_function = funcdef;
		      function_tmp_var_defs = variable_definitions;
		      variable_definitions = NULL;
		  }
		func_params_list ')'
		  {
		      /* nothing */
		  }
		stmt_block
		  {
		      add_opvars(splev, "io", VA_PASS2(0, SPO_RETURN));
		      splev = function_splev_backup;
		      in_function_definition--;
		      curr_function = NULL;
		      vardef_free_all(variable_definitions);
		      variable_definitions = function_tmp_var_defs;
		  }
		;

function_call	: NQSTRING '(' func_call_params_list ')'
		  {
		      struct lc_funcdefs *tmpfunc;
		      tmpfunc = funcdef_defined(function_definitions, $1, 1);
		      if (tmpfunc) {
			  long l;
			  long nparams = strlen( $3 );
			  char *fparamstr = funcdef_paramtypes(tmpfunc);
			  if (strcmp($3, fparamstr)) {
			      char *tmps = strdup(decode_parm_str(fparamstr));
			      lc_error("Function '%s' requires params '%s', got '%s' instead.", $1, tmps, decode_parm_str($3));
			      Free(tmps);
			  }
			  Free(fparamstr);
			  Free($3);
			  if (!(tmpfunc->n_called)) {
			      /* we haven't called the function yet, so insert it in the code */
			      struct opvar *jmp = New(struct opvar);
			      set_opvar_int(jmp, splev->n_opcodes+1);
			      add_opcode(splev, SPO_PUSH, jmp);
			      add_opcode(splev, SPO_JMP, NULL); /* we must jump past it first, then CALL it, due to RETURN. */

			      tmpfunc->addr = splev->n_opcodes;

			      { /* init function parameter variables */
				  struct lc_funcdefs_parm *tfp = tmpfunc->params;
				  while (tfp) {
				      add_opvars(splev, "iso",
						 VA_PASS3(0, tfp->name,
							  SPO_VAR_INIT));
				      tfp = tfp->next;
				  }
			      }

			      splev_add_from(splev, &(tmpfunc->code));
			      set_opvar_int(jmp, splev->n_opcodes - jmp->vardata.l);
			  }
			  l = tmpfunc->addr - splev->n_opcodes - 2;
			  add_opvars(splev, "iio",
				     VA_PASS3(nparams, l, SPO_CALL));
			  tmpfunc->n_called++;
		      } else {
			  lc_error("Function '%s' not defined.", $1);
		      }
		      Free($1);
		  }
		;

exitstatement	: EXIT_ID
		  {
		      add_opcode(splev, SPO_EXIT, NULL);
		  }
		;

opt_percent	: /* nothing */
		  {
		      $$ = 100;
		  }
		| PERCENT
		  {
		      $$ = $1;
		  }
		;

comparestmt     : PERCENT
                  {
		      /* val > rn2(100) */
		      add_opvars(splev, "iio",
				 VA_PASS3((long)$1, 100, SPO_RN2));
		      $$ = SPO_JG;
                  }
		| '[' math_expr_var COMPARE_TYPE math_expr_var ']'
                  {
		      $$ = $3;
                  }
		| '[' math_expr_var ']'
                  {
		      /* boolean, explicit foo != 0 */
		      add_opvars(splev, "i", VA_PASS1(0));
		      $$ = SPO_JNE;
                  }
		;

switchstatement	: SWITCH_ID
		  {
		      is_inconstant_number = 0;
		  }
		  '[' integer_or_var ']'
		  {
		      struct opvar *chkjmp;
		      if (in_switch_statement > 0)
			  lc_error("Cannot nest switch-statements.");

		      in_switch_statement++;

		      n_switch_case_list = 0;
		      switch_default_case = NULL;

		      if (!is_inconstant_number)
			  add_opvars(splev, "o", VA_PASS1(SPO_RN2));
		      is_inconstant_number = 0;

		      chkjmp = New(struct opvar);
		      set_opvar_int(chkjmp, splev->n_opcodes+1);
		      switch_check_jump = chkjmp;
		      add_opcode(splev, SPO_PUSH, chkjmp);
		      add_opcode(splev, SPO_JMP, NULL);
		      break_stmt_start();
		  }
		'{' switchcases '}'
		  {
		      struct opvar *endjump = New(struct opvar);
		      int i;

		      set_opvar_int(endjump, splev->n_opcodes+1);

		      add_opcode(splev, SPO_PUSH, endjump);
		      add_opcode(splev, SPO_JMP, NULL);

		      set_opvar_int(switch_check_jump,
			     splev->n_opcodes - switch_check_jump->vardata.l);

		      for (i = 0; i < n_switch_case_list; i++) {
			  add_opvars(splev, "oio",
				     VA_PASS3(SPO_COPY,
					      switch_case_value[i], SPO_CMP));
			  set_opvar_int(switch_case_list[i],
			 switch_case_list[i]->vardata.l - splev->n_opcodes-1);
			  add_opcode(splev, SPO_PUSH, switch_case_list[i]);
			  add_opcode(splev, SPO_JE, NULL);
		      }

		      if (switch_default_case) {
			  set_opvar_int(switch_default_case,
			 switch_default_case->vardata.l - splev->n_opcodes-1);
			  add_opcode(splev, SPO_PUSH, switch_default_case);
			  add_opcode(splev, SPO_JMP, NULL);
		      }

		      set_opvar_int(endjump, splev->n_opcodes - endjump->vardata.l);

		      break_stmt_end(splev);

		      add_opcode(splev, SPO_POP, NULL); /* get rid of the value in stack */
		      in_switch_statement--;


		  }
		;

switchcases	: /* nothing */
		| switchcase switchcases
		;

switchcase	: CASE_ID all_integers ':'
		  {
		      if (n_switch_case_list < MAX_SWITCH_CASES) {
			  struct opvar *tmppush = New(struct opvar);
			  set_opvar_int(tmppush, splev->n_opcodes);
			  switch_case_value[n_switch_case_list] = $2;
			  switch_case_list[n_switch_case_list++] = tmppush;
		      } else lc_error("Too many cases in a switch.");
		  }
		levstatements
		  {
		  }
		| DEFAULT_ID ':'
		  {
		      struct opvar *tmppush = New(struct opvar);

		      if (switch_default_case)
			  lc_error("Switch default case already used.");

		      set_opvar_int(tmppush, splev->n_opcodes);
		      switch_default_case = tmppush;
		  }
		levstatements
		  {
		  }
		;

breakstatement	: BREAK_ID
		  {
		      if (!allow_break_statements)
			  lc_error("Cannot use BREAK outside a statement block.");
		      else {
			  break_stmt_new(splev, splev->n_opcodes);
		      }
		  }
		;

for_to_span	: '.' '.'
		| TO_ID
		;

forstmt_start	: FOR_ID any_var_or_unk '=' math_expr_var for_to_span math_expr_var
		  {
		      char buf[256], buf2[256];

		      if (n_forloops >= MAX_NESTED_IFS) {
			  lc_error("FOR: Too deeply nested loops.");
			  n_forloops = MAX_NESTED_IFS - 1;
		      }

		      /* first, define a variable for the for-loop end value */
		      Sprintf(buf, "%s end", $2);
		      /* the value of which is already in stack (the 2nd math_expr) */
		      add_opvars(splev, "iso", VA_PASS3(0, buf, SPO_VAR_INIT));

		      variable_definitions = add_vardef_type(variable_definitions,
							     $2, SPOVAR_INT);
		      /* define the for-loop variable. value is in stack (1st math_expr) */
		      add_opvars(splev, "iso", VA_PASS3(0, $2, SPO_VAR_INIT));

		      /* calculate value for the loop "step" variable */
		      Sprintf(buf2, "%s step", $2);
		      /* end - start */
		      add_opvars(splev, "vvo",
				 VA_PASS3(buf, $2, SPO_MATH_SUB));
		      /* sign of that */
		      add_opvars(splev, "o", VA_PASS1(SPO_MATH_SIGN));
		      /* save the sign into the step var */
		      add_opvars(splev, "iso",
				 VA_PASS3(0, buf2, SPO_VAR_INIT));

		      forloop_list[n_forloops].varname = strdup($2);
		      forloop_list[n_forloops].jmp_point = splev->n_opcodes;

		      n_forloops++;
		      Free($2);
		  }
		;

forstatement	: forstmt_start
		  {
		      /* nothing */
		      break_stmt_start();
		  }
		 stmt_block
		  {
		      char buf[256], buf2[256];

		      n_forloops--;
		      Sprintf(buf, "%s step", forloop_list[n_forloops].varname);
		      Sprintf(buf2, "%s end", forloop_list[n_forloops].varname);
		      /* compare for-loop var to end value */
		      add_opvars(splev, "vvo",
				 VA_PASS3(forloop_list[n_forloops].varname,
					  buf2, SPO_CMP));
		      /* var + step */
		      add_opvars(splev, "vvo",
				VA_PASS3(buf, forloop_list[n_forloops].varname,
					 SPO_MATH_ADD));
		      /* for-loop var = (for-loop var + step) */
		      add_opvars(splev, "iso",
				 VA_PASS3(0, forloop_list[n_forloops].varname,
					  SPO_VAR_INIT));
		      /* jump back if compared values were not equal */
		      add_opvars(splev, "io",
				 VA_PASS2(
		    forloop_list[n_forloops].jmp_point - splev->n_opcodes - 1,
					  SPO_JNE));
		      Free(forloop_list[n_forloops].varname);
		      break_stmt_end(splev);
		  }
		;

loopstatement	: LOOP_ID '[' integer_or_var ']'
		  {
		      struct opvar *tmppush = New(struct opvar);

		      if (n_if_list >= MAX_NESTED_IFS) {
			  lc_error("LOOP: Too deeply nested conditionals.");
			  n_if_list = MAX_NESTED_IFS - 1;
		      }
		      set_opvar_int(tmppush, splev->n_opcodes);
		      if_list[n_if_list++] = tmppush;

		      add_opvars(splev, "o", VA_PASS1(SPO_DEC));
		      break_stmt_start();
		  }
		 stmt_block
		  {
		      struct opvar *tmppush;

		      add_opvars(splev, "oio", VA_PASS3(SPO_COPY, 0, SPO_CMP));

		      tmppush = (struct opvar *) if_list[--n_if_list];
		      set_opvar_int(tmppush, tmppush->vardata.l - splev->n_opcodes-1);
		      add_opcode(splev, SPO_PUSH, tmppush);
		      add_opcode(splev, SPO_JG, NULL);
		      add_opcode(splev, SPO_POP, NULL); /* get rid of the count value in stack */
		      break_stmt_end(splev);
		  }
		;

chancestatement	: comparestmt ':'
		  {
		      struct opvar *tmppush2 = New(struct opvar);

		      if (n_if_list >= MAX_NESTED_IFS) {
			  lc_error("IF: Too deeply nested conditionals.");
			  n_if_list = MAX_NESTED_IFS - 1;
		      }

		      add_opcode(splev, SPO_CMP, NULL);

		      set_opvar_int(tmppush2, splev->n_opcodes+1);

		      if_list[n_if_list++] = tmppush2;

		      add_opcode(splev, SPO_PUSH, tmppush2);

		      add_opcode(splev, reverse_jmp_opcode( $1 ), NULL);

		  }
		levstatement
		  {
		      if (n_if_list > 0) {
			  struct opvar *tmppush;
			  tmppush = (struct opvar *) if_list[--n_if_list];
			  set_opvar_int(tmppush, splev->n_opcodes - tmppush->vardata.l);
		      } else lc_error("IF: Huh?!  No start address?");
		  }
		;

ifstatement 	: IF_ID comparestmt
		  {
		      struct opvar *tmppush2 = New(struct opvar);

		      if (n_if_list >= MAX_NESTED_IFS) {
			  lc_error("IF: Too deeply nested conditionals.");
			  n_if_list = MAX_NESTED_IFS - 1;
		      }

		      add_opcode(splev, SPO_CMP, NULL);

		      set_opvar_int(tmppush2, splev->n_opcodes+1);

		      if_list[n_if_list++] = tmppush2;

		      add_opcode(splev, SPO_PUSH, tmppush2);

		      add_opcode(splev, reverse_jmp_opcode( $2 ), NULL);

		  }
		 if_ending
		  {
		     /* do nothing */
		  }
		;

if_ending	: stmt_block
		  {
		      if (n_if_list > 0) {
			  struct opvar *tmppush;
			  tmppush = (struct opvar *) if_list[--n_if_list];
			  set_opvar_int(tmppush, splev->n_opcodes - tmppush->vardata.l);
		      } else lc_error("IF: Huh?!  No start address?");
		  }
		| stmt_block
		  {
		      if (n_if_list > 0) {
			  struct opvar *tmppush = New(struct opvar);
			  struct opvar *tmppush2;

			  set_opvar_int(tmppush, splev->n_opcodes+1);
			  add_opcode(splev, SPO_PUSH, tmppush);

			  add_opcode(splev, SPO_JMP, NULL);

			  tmppush2 = (struct opvar *) if_list[--n_if_list];

			  set_opvar_int(tmppush2, splev->n_opcodes - tmppush2->vardata.l);
			  if_list[n_if_list++] = tmppush;
		      } else lc_error("IF: Huh?!  No else-part address?");
		  }
		 ELSE_ID stmt_block
		  {
		      if (n_if_list > 0) {
			  struct opvar *tmppush;
			  tmppush = (struct opvar *) if_list[--n_if_list];
			  set_opvar_int(tmppush, splev->n_opcodes - tmppush->vardata.l);
		      } else lc_error("IF: Huh?! No end address?");
		  }
		;

message		: MESSAGE_ID ':' string_expr
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_MESSAGE));
		  }
		;

random_corridors: RAND_CORRIDOR_ID
		  {
		      add_opvars(splev, "iiiiiio",
			      VA_PASS7(-1,  0, -1, -1, -1, -1, SPO_CORRIDOR));
		  }
		| RAND_CORRIDOR_ID ':' all_integers
		  {
		      add_opvars(splev, "iiiiiio",
			      VA_PASS7(-1, $3, -1, -1, -1, -1, SPO_CORRIDOR));
		  }
		| RAND_CORRIDOR_ID ':' RANDOM_TYPE
		  {
		      add_opvars(splev, "iiiiiio",
			      VA_PASS7(-1, -1, -1, -1, -1, -1, SPO_CORRIDOR));
		  }
		;

corridor	: CORRIDOR_ID ':' corr_spec ',' corr_spec
		  {
		      add_opvars(splev, "iiiiiio",
				 VA_PASS7($3.room, $3.door, $3.wall,
					  $5.room, $5.door, $5.wall,
					  SPO_CORRIDOR));
		  }
		| CORRIDOR_ID ':' corr_spec ',' all_integers
		  {
		      add_opvars(splev, "iiiiiio",
				 VA_PASS7($3.room, $3.door, $3.wall,
					  -1, -1, (long)$5,
					  SPO_CORRIDOR));
		  }
		;

corr_spec	: '(' INTEGER ',' DIRECTION ',' door_pos ')'
		  {
			$$.room = $2;
			$$.wall = $4;
			$$.door = $6;
		  }
		;

room_begin      : room_type opt_percent ',' light_state
                  {
		      if (($2 < 100) && ($1 == OROOM))
			  lc_error("Only typed rooms can have a chance.");
		      else {
			  add_opvars(splev, "iii",
				     VA_PASS3((long)$1, (long)$2, (long)$4));
		      }
                  }
                ;

subroom_def	: SUBROOM_ID ':' room_begin ',' subroom_pos ',' room_size optroomregionflags
		  {
		      long rflags = $8;

		      if (rflags == -1) rflags = (1 << 0);
		      add_opvars(splev, "iiiiiiio",
				 VA_PASS8(rflags, ERR, ERR,
					  $5.x, $5.y, $7.width, $7.height,
					  SPO_SUBROOM));
		      break_stmt_start();
		  }
		  stmt_block
		  {
		      break_stmt_end(splev);
		      add_opcode(splev, SPO_ENDROOM, NULL);
		  }
		;

room_def	: ROOM_ID ':' room_begin ',' room_pos ',' room_align ',' room_size optroomregionflags
		  {
		      long rflags = $8;

		      if (rflags == -1) rflags = (1 << 0);
		      add_opvars(splev, "iiiiiiio",
				 VA_PASS8(rflags,
					  $7.x, $7.y, $5.x, $5.y,
					  $9.width, $9.height, SPO_ROOM));
		      break_stmt_start();
		  }
		  stmt_block
		  {
		      break_stmt_end(splev);
		      add_opcode(splev, SPO_ENDROOM, NULL);
		  }
		;

roomfill	: /* nothing */
		  {
			$$ = 1;
		  }
		| ',' BOOLEAN
		  {
			$$ = $2;
		  }
		;

room_pos	: '(' INTEGER ',' INTEGER ')'
		  {
			if ( $2 < 1 || $2 > 5 ||
			    $4 < 1 || $4 > 5 ) {
			    lc_error("Room positions should be between 1-5: (%li,%li)!", $2, $4);
			} else {
			    $$.x = $2;
			    $$.y = $4;
			}
		  }
		| RANDOM_TYPE
		  {
			$$.x = $$.y = ERR;
		  }
		;

subroom_pos	: '(' INTEGER ',' INTEGER ')'
		  {
			if ( $2 < 0 || $4 < 0) {
			    lc_error("Invalid subroom position (%li,%li)!", $2, $4);
			} else {
			    $$.x = $2;
			    $$.y = $4;
			}
		  }
		| RANDOM_TYPE
		  {
			$$.x = $$.y = ERR;
		  }
		;

room_align	: '(' h_justif ',' v_justif ')'
		  {
		      $$.x = $2;
		      $$.y = $4;
		  }
		| RANDOM_TYPE
		  {
		      $$.x = $$.y = ERR;
		  }
		;

room_size	: '(' INTEGER ',' INTEGER ')'
		  {
			$$.width = $2;
			$$.height = $4;
		  }
		| RANDOM_TYPE
		  {
			$$.height = $$.width = ERR;
		  }
		;

door_detail	: ROOMDOOR_ID ':' secret ',' door_state ',' door_wall ',' door_pos
		  {
			/* ERR means random here */
			if ($7 == ERR && $9 != ERR) {
			    lc_error("If the door wall is random, so must be its pos!");
			} else {
			    add_opvars(splev, "iiiio",
				       VA_PASS5((long)$9, (long)$5, (long)$3,
						(long)$7, SPO_ROOM_DOOR));
			}
		  }
		| DOOR_ID ':' door_state ',' ter_selection
		  {
		      add_opvars(splev, "io", VA_PASS2((long)$3, SPO_DOOR));
		  }
		;

secret		: BOOLEAN
		| RANDOM_TYPE
		;

door_wall	: dir_list
		| RANDOM_TYPE
		;

dir_list	: DIRECTION
		  {
		      $$ = $1;
		  }
		| DIRECTION '|' dir_list
		  {
		      $$ = ($1 | $3);
		  }
		;

door_pos	: INTEGER
		| RANDOM_TYPE
		;

map_definition	: NOMAP_ID
		  {
		      add_opvars(splev, "ciisiio",
				 VA_PASS7(0, 0, 1, (char *)0, 0, 0, SPO_MAP));
		      max_x_map = COLNO-1;
		      max_y_map = ROWNO;
		  }
		| GEOMETRY_ID ':' h_justif ',' v_justif roomfill MAP_ID
		  {
		      add_opvars(splev, "cii",
				 VA_PASS3(SP_COORD_PACK(($3),($5)),
					  1, (long)$6));
		      scan_map($7, splev);
		      Free($7);
		  }
		| GEOMETRY_ID ':' coord_or_var roomfill MAP_ID
		  {
		      add_opvars(splev, "ii", VA_PASS2(2, (long)$4));
		      scan_map($5, splev);
		      Free($5);
		  }
		;

h_justif	: LEFT_OR_RIGHT
		| CENTER
		;

v_justif	: TOP_OR_BOT
		| CENTER
		;

monster_detail	: MONSTER_ID ':' monster_desc
		  {
		      add_opvars(splev, "io", VA_PASS2(0, SPO_MONSTER));
		  }
		| MONSTER_ID ':' monster_desc
		  {
		      add_opvars(splev, "io", VA_PASS2(1, SPO_MONSTER));
		      in_container_obj++;
		      break_stmt_start();
		  }
		stmt_block
		 {
		     break_stmt_end(splev);
		     in_container_obj--;
		     add_opvars(splev, "o", VA_PASS1(SPO_END_MONINVENT));
		 }
		;

monster_desc	: monster_or_var ',' coord_or_var monster_infos
		  {
		      /* nothing */
		  }
		;

monster_infos	: /* nothing */
		  {
		      struct opvar *stopit = New(struct opvar);
		      set_opvar_int(stopit, SP_M_V_END);
		      add_opcode(splev, SPO_PUSH, stopit);
		      $$ = 0x0000;
		  }
		| monster_infos ',' monster_info
		  {
		      if (( $1 & $3 ))
			  lc_error("MONSTER extra info defined twice.");
		      $$ = ( $1 | $3 );
		  }
		;

monster_info	: string_expr
		  {
		      add_opvars(splev, "i", VA_PASS1(SP_M_V_NAME));
		      $$ = 0x0001;
		  }
		| MON_ATTITUDE
		  {
		      add_opvars(splev, "ii",
				 VA_PASS2((long)$<i>1, SP_M_V_PEACEFUL));
		      $$ = 0x0002;
		  }
		| MON_ALERTNESS
		  {
		      add_opvars(splev, "ii",
				 VA_PASS2((long)$<i>1, SP_M_V_ASLEEP));
		      $$ = 0x0004;
		  }
		| alignment_prfx
		  {
		      add_opvars(splev, "ii",
				 VA_PASS2((long)$1, SP_M_V_ALIGN));
		      $$ = 0x0008;
		  }
		| MON_APPEARANCE string_expr
		  {
		      add_opvars(splev, "ii",
				 VA_PASS2((long)$<i>1, SP_M_V_APPEAR));
		      $$ = 0x0010;
		  }
		| FEMALE_ID
		  {
		      add_opvars(splev, "ii", VA_PASS2(1, SP_M_V_FEMALE));
		      $$ = 0x0020;
		  }
		| INVIS_ID
		  {
		      add_opvars(splev, "ii", VA_PASS2(1, SP_M_V_INVIS));
		      $$ = 0x0040;
		  }
		| CANCELLED_ID
		  {
		      add_opvars(splev, "ii", VA_PASS2(1, SP_M_V_CANCELLED));
		      $$ = 0x0080;
		  }
		| REVIVED_ID
		  {
		      add_opvars(splev, "ii", VA_PASS2(1, SP_M_V_REVIVED));
		      $$ = 0x0100;
		  }
		| AVENGE_ID
		  {
		      add_opvars(splev, "ii", VA_PASS2(1, SP_M_V_AVENGE));
		      $$ = 0x0200;
		  }
		| FLEEING_ID ':' integer_or_var
		  {
		      add_opvars(splev, "i", VA_PASS1(SP_M_V_FLEEING));
		      $$ = 0x0400;
		  }
		| BLINDED_ID ':' integer_or_var
		  {
		      add_opvars(splev, "i", VA_PASS1(SP_M_V_BLINDED));
		      $$ = 0x0800;
		  }
		| PARALYZED_ID ':' integer_or_var
		  {
		      add_opvars(splev, "i", VA_PASS1(SP_M_V_PARALYZED));
		      $$ = 0x1000;
		  }
		| STUNNED_ID
		  {
		      add_opvars(splev, "ii", VA_PASS2(1, SP_M_V_STUNNED));
		      $$ = 0x2000;
		  }
		| CONFUSED_ID
		  {
		      add_opvars(splev, "ii", VA_PASS2(1, SP_M_V_CONFUSED));
		      $$ = 0x4000;
		  }
		| SEENTRAPS_ID ':' seen_trap_mask
		  {
		      add_opvars(splev, "ii",
				 VA_PASS2((long)$3, SP_M_V_SEENTRAPS));
		      $$ = 0x8000;
		  }
		;

seen_trap_mask	: STRING
		  {
		      int token = get_trap_type($1);
		      if (token == ERR || token == 0)
			  lc_error("Unknown trap type '%s'!", $1);
                      Free($1);
		      $$ = (1L << (token - 1));
		  }
		| ALL_ID
		  {
		      $$ = (long) ~0;
		  }
		| STRING '|' seen_trap_mask
		  {
		      int token = get_trap_type($1);
		      if (token == ERR || token == 0)
			  lc_error("Unknown trap type '%s'!", $1);

		      if ((1L << (token - 1)) & $3)
			  lc_error("Monster seen_traps, trap '%s' listed twice.", $1);
                      Free($1);
		      $$ = ((1L << (token - 1)) | $3);
		  }
		;

object_detail	: OBJECT_ID ':' object_desc
		  {
		      long cnt = 0;
		      if (in_container_obj) cnt |= SP_OBJ_CONTENT;
		      add_opvars(splev, "io", VA_PASS2(cnt, SPO_OBJECT));
		  }
		| COBJECT_ID ':' object_desc
		  {
		      long cnt = SP_OBJ_CONTAINER;
		      if (in_container_obj) cnt |= SP_OBJ_CONTENT;
		      add_opvars(splev, "io", VA_PASS2(cnt, SPO_OBJECT));
		      in_container_obj++;
		      break_stmt_start();
		  }
		stmt_block
		 {
		     break_stmt_end(splev);
		     in_container_obj--;
		     add_opcode(splev, SPO_POP_CONTAINER, NULL);
		 }
		;

object_desc	: object_or_var object_infos
		  {
		      if (( $2 & 0x4000) && in_container_obj)
                          lc_error("Object cannot have a coord when contained.");
		      else if (!( $2 & 0x4000) && !in_container_obj)
                          lc_error("Object needs a coord when not contained.");
		  }
		;

object_infos	: /* nothing */
		  {
		      struct opvar *stopit = New(struct opvar);
		      set_opvar_int(stopit, SP_O_V_END);
		      add_opcode(splev, SPO_PUSH, stopit);
		      $$ = 0x00;
		  }
		| object_infos ',' object_info
		  {
		      if (( $1 & $3 ))
			  lc_error("OBJECT extra info '%s' defined twice.", curr_token);
		      $$ = ( $1 | $3 );
		  }
		;

object_info	: CURSE_TYPE
		  {
		      add_opvars(splev, "ii",
				 VA_PASS2((long)$1, SP_O_V_CURSE));
		      $$ = 0x0001;
		  }
		| MONTYPE_ID ':' monster_or_var
		  {
		      add_opvars(splev, "i", VA_PASS1(SP_O_V_CORPSENM));
		      $$ = 0x0002;
		  }
		| all_ints_push
		  {
		      add_opvars(splev, "i", VA_PASS1(SP_O_V_SPE));
		      $$ = 0x0004;
		  }
		| NAME_ID ':' string_expr
		  {
		      add_opvars(splev, "i", VA_PASS1(SP_O_V_NAME));
		      $$ = 0x0008;
		  }
		| QUANTITY_ID ':' integer_or_var
		  {
		      add_opvars(splev, "i", VA_PASS1(SP_O_V_QUAN));
		      $$ = 0x0010;
		  }
		| BURIED_ID
		  {
		      add_opvars(splev, "ii", VA_PASS2(1, SP_O_V_BURIED));
		      $$ = 0x0020;
		  }
		| LIGHT_STATE
		  {
		      add_opvars(splev, "ii", VA_PASS2((long)$1, SP_O_V_LIT));
		      $$ = 0x0040;
		  }
		| ERODED_ID ':' integer_or_var
		  {
		      add_opvars(splev, "i", VA_PASS1(SP_O_V_ERODED));
		      $$ = 0x0080;
		  }
		| ERODEPROOF_ID
		  {
		      add_opvars(splev, "ii", VA_PASS2(-1, SP_O_V_ERODED));
		      $$ = 0x0080;
		  }
		| DOOR_STATE
		  {
		      if ($1 == D_LOCKED) {
			  add_opvars(splev, "ii", VA_PASS2(1, SP_O_V_LOCKED));
			  $$ = 0x0100;
		      } else if ($1 == D_BROKEN) {
			  add_opvars(splev, "ii", VA_PASS2(1, SP_O_V_BROKEN));
			  $$ = 0x0200;
		      } else
			  lc_error("DOOR state can only be locked or broken.");
		  }
		| TRAPPED_STATE
		  {
		      add_opvars(splev, "ii", VA_PASS2($1, SP_O_V_TRAPPED));
		      $$ = 0x0400;
		  }
		| RECHARGED_ID ':' integer_or_var
		  {
		      add_opvars(splev, "i", VA_PASS1(SP_O_V_RECHARGED));
		      $$ = 0x0800;
		  }
		| INVIS_ID
		  {
		      add_opvars(splev, "ii", VA_PASS2(1, SP_O_V_INVIS));
		      $$ = 0x1000;
		  }
		| GREASED_ID
		  {
		      add_opvars(splev, "ii", VA_PASS2(1, SP_O_V_GREASED));
		      $$ = 0x2000;
		  }
		| coord_or_var
		  {
		      add_opvars(splev, "i", VA_PASS1(SP_O_V_COORD));
		      $$ = 0x4000;
		  }
		;

trap_detail	: TRAP_ID ':' trap_name ',' coord_or_var
		  {
		      add_opvars(splev, "io", VA_PASS2((long)$3, SPO_TRAP));
		  }
		;

drawbridge_detail: DRAWBRIDGE_ID ':' coord_or_var ',' DIRECTION ',' door_state
		   {
		       long dir, state = 0;

		       /* convert dir from a DIRECTION to a DB_DIR */
		       dir = $5;
		       switch (dir) {
		       case W_NORTH: dir = DB_NORTH; break;
		       case W_SOUTH: dir = DB_SOUTH; break;
		       case W_EAST:  dir = DB_EAST;  break;
		       case W_WEST:  dir = DB_WEST;  break;
		       default:
			   lc_error("Invalid drawbridge direction.");
			   break;
		       }

		       if ( $7 == D_ISOPEN )
			   state = 1;
		       else if ( $7 == D_CLOSED )
			   state = 0;
		       else if ( $7 == -1 )
			   state = -1;
		       else
			   lc_error("A drawbridge can only be open, closed or random!");
		       add_opvars(splev, "iio",
				  VA_PASS3(state, dir, SPO_DRAWBRIDGE));
		   }
		;

mazewalk_detail : MAZEWALK_ID ':' coord_or_var ',' DIRECTION
		  {
		      add_opvars(splev, "iiio",
				 VA_PASS4((long)$5, 1, 0, SPO_MAZEWALK));
		  }
		| MAZEWALK_ID ':' coord_or_var ',' DIRECTION ',' BOOLEAN opt_fillchar
		  {
		      add_opvars(splev, "iiio",
				 VA_PASS4((long)$5, (long)$<i>7,
					  (long)$8, SPO_MAZEWALK));
		  }
		;

wallify_detail	: WALLIFY_ID
		  {
		      add_opvars(splev, "rio",
				 VA_PASS3(SP_REGION_PACK(-1,-1,-1,-1),
					  0, SPO_WALLIFY));
		  }
		| WALLIFY_ID ':' ter_selection
		  {
		      add_opvars(splev, "io", VA_PASS2(1, SPO_WALLIFY));
		  }
		;

ladder_detail	: LADDER_ID ':' coord_or_var ',' UP_OR_DOWN
		  {
		      add_opvars(splev, "io",
				 VA_PASS2((long)$<i>5, SPO_LADDER));
		  }
		;

stair_detail	: STAIR_ID ':' coord_or_var ',' UP_OR_DOWN
		  {
		      add_opvars(splev, "io",
				 VA_PASS2((long)$<i>5, SPO_STAIR));
		  }
		;

stair_region	: STAIR_ID ':' lev_region ',' lev_region ',' UP_OR_DOWN
		  {
		      add_opvars(splev, "iiiii iiiii iiso",
				 VA_PASS14($3.x1, $3.y1, $3.x2, $3.y2, $3.area,
					   $5.x1, $5.y1, $5.x2, $5.y2, $5.area,
				     (long) (($7) ? LR_UPSTAIR : LR_DOWNSTAIR),
					   0, (char *) 0, SPO_LEVREGION));
		  }
		;

portal_region	: PORTAL_ID ':' lev_region ',' lev_region ',' STRING
		  {
		      add_opvars(splev, "iiiii iiiii iiso",
				 VA_PASS14($3.x1, $3.y1, $3.x2, $3.y2, $3.area,
					   $5.x1, $5.y1, $5.x2, $5.y2, $5.area,
					   LR_PORTAL, 0, $7, SPO_LEVREGION));
		      Free($7);
		  }
		;

teleprt_region	: TELEPRT_ID ':' lev_region ',' lev_region teleprt_detail
		  {
		      long rtyp = 0;
		      switch($6) {
		      case -1: rtyp = LR_TELE; break;
		      case  0: rtyp = LR_DOWNTELE; break;
		      case  1: rtyp = LR_UPTELE; break;
		      }
		      add_opvars(splev, "iiiii iiiii iiso",
				 VA_PASS14($3.x1, $3.y1, $3.x2, $3.y2, $3.area,
					   $5.x1, $5.y1, $5.x2, $5.y2, $5.area,
					   rtyp, 0, (char *)0, SPO_LEVREGION));
		  }
		;

branch_region	: BRANCH_ID ':' lev_region ',' lev_region
		  {
		      add_opvars(splev, "iiiii iiiii iiso",
				 VA_PASS14($3.x1, $3.y1, $3.x2, $3.y2, $3.area,
					   $5.x1, $5.y1, $5.x2, $5.y2, $5.area,
					   (long) LR_BRANCH, 0,
					   (char *) 0, SPO_LEVREGION));
		  }
		;

teleprt_detail	: /* empty */
		  {
			$$ = -1;
		  }
		| ',' UP_OR_DOWN
		  {
			$$ = $2;
		  }
		;

fountain_detail : FOUNTAIN_ID ':' ter_selection
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_FOUNTAIN));
		  }
		;

sink_detail : SINK_ID ':' ter_selection
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_SINK));
		  }
		;

pool_detail : POOL_ID ':' ter_selection
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_POOL));
		  }
		;

terrain_type	: CHAR
		  {
		      $$.lit = -2;
		      $$.ter = what_map_char((char) $<i>1);
		  }
		| '(' CHAR ',' light_state ')'
		  {
		      $$.lit = $4;
		      $$.ter = what_map_char((char) $<i>2);
		  }
		;

replace_terrain_detail : REPLACE_TERRAIN_ID ':' region_or_var ',' mapchar_or_var ',' mapchar_or_var ',' SPERCENT
		  {
		      add_opvars(splev, "io",
				 VA_PASS2($9, SPO_REPLACETERRAIN));
		  }
		;

terrain_detail : TERRAIN_ID ':' ter_selection ',' mapchar_or_var
		 {
		     add_opvars(splev, "o", VA_PASS1(SPO_TERRAIN));
		 }
	       ;

diggable_detail : NON_DIGGABLE_ID ':' region_or_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_NON_DIGGABLE));
		  }
		;

passwall_detail : NON_PASSWALL_ID ':' region_or_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_NON_PASSWALL));
		  }
		;

region_detail	: REGION_ID ':' region_or_var ',' light_state ',' room_type optroomregionflags
		  {
		      long irr;
		      long rt = $7;
		      long rflags = $8;

		      if (rflags == -1) rflags = (1 << 0);
		      if (!(rflags & 1)) rt += MAXRTYPE+1;
		      irr = ((rflags & 2) != 0);
		      add_opvars(splev, "iiio",
				 VA_PASS4((long)$5, rt, rflags, SPO_REGION));
		      $<i>$ = (irr || (rflags & 1) || rt != OROOM);
		      break_stmt_start();
		  }
		  region_detail_end
		  {
		      break_stmt_end(splev);
		      if ( $<i>9 ) {
			  add_opcode(splev, SPO_ENDROOM, NULL);
		      } else if ( $<i>10 )
			  lc_error("Cannot use lev statements in non-permanent REGION");
		  }
		;

region_detail_end : /* nothing */
		  {
		      $$ = 0;
		  }
		| stmt_block
		  {
		      $$ = $1;
		  }
		;

altar_detail	: ALTAR_ID ':' coord_or_var ',' alignment ',' altar_type
		  {
		      add_opvars(splev, "iio",
				 VA_PASS3((long)$7, (long)$5, SPO_ALTAR));
		  }
		;

grave_detail	: GRAVE_ID ':' coord_or_var ',' string_expr
		  {
		      add_opvars(splev, "io", VA_PASS2(2, SPO_GRAVE));
		  }
		| GRAVE_ID ':' coord_or_var ',' RANDOM_TYPE
		  {
		      add_opvars(splev, "sio",
				 VA_PASS3((char *)0, 1, SPO_GRAVE));
		  }
		| GRAVE_ID ':' coord_or_var
		  {
		      add_opvars(splev, "sio",
				 VA_PASS3((char *)0, 0, SPO_GRAVE));
		  }
		;

gold_detail	: GOLD_ID ':' math_expr_var ',' coord_or_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_GOLD));
		  }
		;

engraving_detail: ENGRAVING_ID ':' coord_or_var ',' engraving_type ',' string_expr
		  {
		      add_opvars(splev, "io",
				 VA_PASS2((long)$5, SPO_ENGRAVING));
		  }
		;

mineralize	: MINERALIZE_ID ':' integer_or_var ',' integer_or_var ',' integer_or_var ',' integer_or_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_MINERALIZE));
		  }
		| MINERALIZE_ID
		  {
		      add_opvars(splev, "iiiio",
				 VA_PASS5(-1L, -1L, -1L, -1L, SPO_MINERALIZE));
		  }
		;

trap_name	: STRING
		  {
			int token = get_trap_type($1);
			if (token == ERR)
			    lc_error("Unknown trap type '%s'!", $1);
			$$ = token;
			Free($1);
		  }
		| RANDOM_TYPE
		;

room_type	: STRING
		  {
			int token = get_room_type($1);
			if (token == ERR) {
			    lc_warning("Unknown room type \"%s\"!  Making ordinary room...", $1);
				$$ = OROOM;
			} else
				$$ = token;
			Free($1);
		  }
		| RANDOM_TYPE
		;

optroomregionflags : /* empty */
		  {
			$$ = -1;
		  }
		| ',' roomregionflags
		  {
			$$ = $2;
		  }
		;

roomregionflags : roomregionflag
		  {
			$$ = $1;
		  }
		| roomregionflag ',' roomregionflags
		  {
			$$ = $1 | $3;
		  }
		;

/* 0 is the "default" here */
roomregionflag : FILLING
		  {
		      $$ = ($1 << 0);
		  }
		| IRREGULAR
		  {
		      $$ = ($1 << 1);
		  }
		| JOINED
		  {
		      $$ = ($1 << 2);
		  }
		;

door_state	: DOOR_STATE
		| RANDOM_TYPE
		;

light_state	: LIGHT_STATE
		| RANDOM_TYPE
		;

alignment	: ALIGNMENT
		| a_register
		| RANDOM_TYPE
		  {
			$$ = - MAX_REGISTERS - 1;
		  }
		;

alignment_prfx	: ALIGNMENT
		| a_register
		| A_REGISTER ':' RANDOM_TYPE
		  {
			$$ = - MAX_REGISTERS - 1;
		  }
		;

altar_type	: ALTAR_TYPE
		| RANDOM_TYPE
		;

a_register	: A_REGISTER '[' INTEGER ']'
		  {
			if ( $3 >= 3 )
				lc_error("Register Index overflow!");
			else
				$$ = - $3 - 1;
		  }
		;

string_or_var	: STRING
		  {
		      add_opvars(splev, "s", VA_PASS1($1));
		      Free($1);
		  }
		| VARSTRING_STRING
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_STRING);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		| VARSTRING_STRING_ARRAY '[' math_expr_var ']'
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_STRING|SPOVAR_ARRAY);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		;


integer_or_var	: math_expr_var
		  {
		      /* nothing */
		  }
		;

coord_or_var	: encodecoord
		  {
		      add_opvars(splev, "c", VA_PASS1($1));
		  }
		| rndcoord_ID '(' ter_selection ')'
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_SEL_RNDCOORD));
		  }
		| VARSTRING_COORD
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_COORD);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		| VARSTRING_COORD_ARRAY '[' math_expr_var ']'
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_COORD|SPOVAR_ARRAY);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		;

encodecoord	: '(' INTEGER ',' INTEGER ')'
		  {
		      if ($2 < 0 || $4 < 0 || $2 >= COLNO || $4 >= ROWNO)
			  lc_error("Coordinates (%li,%li) out of map range!", $2, $4);
		      $$ = SP_COORD_PACK($2, $4);
		  }
		| RANDOM_TYPE
		  {
		      $$ = SP_COORD_PACK_RANDOM(0);
		  }
		| RANDOM_TYPE_BRACKET humidity_flags ']'
		  {
		      $$ = SP_COORD_PACK_RANDOM( $2 );
		  }
		;

humidity_flags	: HUMIDITY_TYPE
		  {
		      $$ = $1;
		  }
		| HUMIDITY_TYPE ',' humidity_flags
		  {
		      if (($1 & $3))
			  lc_warning("Humidity flag used twice.");
		      $$ = ($1 | $3);
		  }
		;

region_or_var	: encoderegion
		  {
		      /* nothing */
		  }
		| VARSTRING_REGION
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_REGION);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		| VARSTRING_REGION_ARRAY '[' math_expr_var ']'
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_REGION|SPOVAR_ARRAY);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		;

encoderegion	: '(' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ')'
		  {
		      long r = SP_REGION_PACK($2, $4, $6, $8);
		      if ( $2 > $6 || $4 > $8 )
			  lc_error("Region start > end: (%li,%li,%li,%li)!", $2, $4, $6, $8);

		      add_opvars(splev, "r", VA_PASS1(r));
		      $$ = r;
		  }
		;

mapchar_or_var	: mapchar
		  {
		      add_opvars(splev, "m", VA_PASS1($1));
		  }
		| VARSTRING_MAPCHAR
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_MAPCHAR);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		| VARSTRING_MAPCHAR_ARRAY '[' math_expr_var ']'
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_MAPCHAR|SPOVAR_ARRAY);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		;

mapchar		: CHAR
		  {
		      if (what_map_char((char) $1) != INVALID_TYPE)
			  $$ = SP_MAPCHAR_PACK(what_map_char((char) $1), -2);
		      else {
			  lc_error("Unknown map char type '%c'!", $1);
			  $$ = SP_MAPCHAR_PACK(STONE, -2);
		      }
		  }
		| '(' CHAR ',' light_state ')'
		  {
		      if (what_map_char((char) $2) != INVALID_TYPE)
			  $$ = SP_MAPCHAR_PACK(what_map_char((char) $2), $4);
		      else {
			  lc_error("Unknown map char type '%c'!", $2);
			  $$ = SP_MAPCHAR_PACK(STONE, $4);
		      }
		  }
		;

monster_or_var	: encodemonster
		  {
		      add_opvars(splev, "M", VA_PASS1($1));
		  }
		| VARSTRING_MONST
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_MONST);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		| VARSTRING_MONST_ARRAY '[' math_expr_var ']'
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_MONST|SPOVAR_ARRAY);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		;

encodemonster	: STRING
                  {
                      long m = get_monster_id($1, (char)0);
                      if (m == ERR) {
                          lc_error("Unknown monster \"%s\"!", $1);
                          $$ = -1;
                      } else
                          $$ = SP_MONST_PACK(m,
                                         def_monsyms[(int) mons[m].mlet].sym);
                      Free($1);
                  }
                | CHAR
                  {
                        if (check_monster_char((char) $1))
                            $$ = SP_MONST_PACK(-1, $1);
                        else {
                            lc_error("Unknown monster class '%c'!", $1);
                            $$ = -1;
                        }
                  }
                | '(' CHAR ',' STRING ')'
                  {
                      long m = get_monster_id($4, (char) $2);
                      if (m == ERR) {
                          lc_error("Unknown monster ('%c', \"%s\")!", $2, $4);
                          $$ = -1;
                      } else
                          $$ = SP_MONST_PACK(m, $2);
                      Free($4);
                  }
                | RANDOM_TYPE
                  {
                      $$ = -1;
                  }
                ;

object_or_var	: encodeobj
		  {
		      add_opvars(splev, "O", VA_PASS1($1));
		  }
		| VARSTRING_OBJ
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_OBJ);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		| VARSTRING_OBJ_ARRAY '[' math_expr_var ']'
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_OBJ|SPOVAR_ARRAY);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		;

encodeobj	: STRING
		  {
		      long m = get_object_id($1, (char)0);
		      if (m == ERR) {
			  lc_error("Unknown object \"%s\"!", $1);
			  $$ = -1;
		      } else
			  $$ = SP_OBJ_PACK(m, 1); /* obj class != 0 to force generation of a specific item */
                      Free($1);
		  }
		| CHAR
		  {
			if (check_object_char((char) $1))
			    $$ = SP_OBJ_PACK(-1, $1);
			else {
			    lc_error("Unknown object class '%c'!", $1);
			    $$ = -1;
			}
		  }
		| '(' CHAR ',' STRING ')'
		  {
		      long m = get_object_id($4, (char) $2);
		      if (m == ERR) {
			  lc_error("Unknown object ('%c', \"%s\")!", $2, $4);
			  $$ = -1;
		      } else
			  $$ = SP_OBJ_PACK(m, $2);
                      Free($4);
		  }
		| RANDOM_TYPE
		  {
		      $$ = -1;
		  }
		;


string_expr	: string_or_var                 { }
		| string_expr '.' string_or_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_MATH_ADD));
		  }
		;

math_expr_var	: INTEGER
		  {
		      add_opvars(splev, "i", VA_PASS1($1));
		  }
		| dice
		  {
		      is_inconstant_number = 1;
		  }
		| '(' MINUS_INTEGER ')'
		  {
		      add_opvars(splev, "i", VA_PASS1($2));
		  }
		| VARSTRING_INT
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_INT);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		      is_inconstant_number = 1;
		  }
		| VARSTRING_INT_ARRAY '[' math_expr_var ']'
		  {
		      check_vardef_type(variable_definitions,
					$1, SPOVAR_INT|SPOVAR_ARRAY);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		      is_inconstant_number = 1;
		  }
		| math_expr_var '+' math_expr_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_MATH_ADD));
		  }
		| math_expr_var '-' math_expr_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_MATH_SUB));
		  }
		| math_expr_var '*' math_expr_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_MATH_MUL));
		  }
		| math_expr_var '/' math_expr_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_MATH_DIV));
		  }
		| math_expr_var '%' math_expr_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_MATH_MOD));
		  }
		| '(' math_expr_var ')'             { }
		;

func_param_type	: CFUNC_INT
		  {
		      if (!strcmp("int", $1) || !strcmp("integer", $1)) {
			  $$ = (int)'i';
		      } else
			  lc_error("Unknown function parameter type '%s'", $1);
		  }
		| CFUNC_STR
		  {
		      if (!strcmp("str", $1) || !strcmp("string", $1)) {
			  $$ = (int)'s';
		      } else
			  lc_error("Unknown function parameter type '%s'", $1);
		  }
		;

func_param_part	: any_var_or_arr ':' func_param_type
		  {
		      struct lc_funcdefs_parm *tmp = New(struct lc_funcdefs_parm);

		      if (!curr_function) {
			  lc_error("Function parameters outside function definition.");
		      } else if (!tmp) {
			  lc_error("Could not alloc function params.");
		      } else {
			  long vt = SPOVAR_NULL;

			  tmp->name = strdup($1);
			  tmp->parmtype = (char) $3;
			  tmp->next = curr_function->params;
			  curr_function->params = tmp;
			  curr_function->n_params++;
			  switch (tmp->parmtype) {
			  case 'i':
                              vt = SPOVAR_INT;
                              break;
			  case 's':
                              vt = SPOVAR_STRING;
                              break;
			  default:
                              lc_error("Unknown func param conversion.");
                              break;
			  }
			  variable_definitions = add_vardef_type(
							 variable_definitions,
								 $1, vt);
		      }
		      Free($1);
		  }
		;

func_param_list		: func_param_part
			| func_param_list ',' func_param_part
			;

func_params_list	: /* nothing */
			| func_param_list
			;

func_call_param_part	: math_expr_var
			  {
			      $$ = (int)'i';
			  }
			| string_expr
			  {
			      $$ = (int)'s';
			  }
			;


func_call_param_list   	: func_call_param_part
			  {
			      char tmpbuf[2];
			      tmpbuf[0] = (char) $1;
			      tmpbuf[1] = '\0';
			      $$ = strdup(tmpbuf);
			  }
			| func_call_param_list ',' func_call_param_part
			  {
			      long len = strlen( $1 );
			      char *tmp = (char *) alloc(len + 2);
			      sprintf(tmp, "%c%s", (char) $3, $1 );
			      Free( $1 );
			      $$ = tmp;
			  }
			;

func_call_params_list	: /* nothing */
			  {
			      $$ = strdup("");
			  }
			| func_call_param_list
			  {
			      char *tmp = strdup( $1 );
			      Free( $1 );
			      $$ = tmp;
			  }
			;

ter_selection_x	: coord_or_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_SEL_POINT));
		  }
		| rect_ID region_or_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_SEL_RECT));
		  }
		| fillrect_ID region_or_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_SEL_FILLRECT));
		  }
		| line_ID coord_or_var ',' coord_or_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_SEL_LINE));
		  }
		| randline_ID coord_or_var ',' coord_or_var ',' math_expr_var
		  {
		      /* randline (x1,y1),(x2,y2), roughness */
		      add_opvars(splev, "o", VA_PASS1(SPO_SEL_RNDLINE));
		  }
		| grow_ID '(' ter_selection ')'
		  {
		      add_opvars(splev, "io", VA_PASS2(W_ANY, SPO_SEL_GROW));
		  }
		| grow_ID '(' dir_list ',' ter_selection ')'
		  {
		      add_opvars(splev, "io", VA_PASS2($3, SPO_SEL_GROW));
		  }
		| filter_ID '(' SPERCENT ',' ter_selection ')'
		  {
		      add_opvars(splev, "iio",
			     VA_PASS3($3, SPOFILTER_PERCENT, SPO_SEL_FILTER));
		  }
		| filter_ID '(' ter_selection ',' ter_selection ')'
		  {
		      add_opvars(splev, "io",
			       VA_PASS2(SPOFILTER_SELECTION, SPO_SEL_FILTER));
		  }
		| filter_ID '(' mapchar_or_var ',' ter_selection ')'
		  {
		      add_opvars(splev, "io",
				 VA_PASS2(SPOFILTER_MAPCHAR, SPO_SEL_FILTER));
		  }
		| flood_ID coord_or_var
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_SEL_FLOOD));
		  }
		| circle_ID '(' coord_or_var ',' math_expr_var ')'
		  {
		      add_opvars(splev, "oio",
				 VA_PASS3(SPO_COPY, 1, SPO_SEL_ELLIPSE));
		  }
		| circle_ID '(' coord_or_var ',' math_expr_var ',' FILLING ')'
		  {
		      add_opvars(splev, "oio",
				 VA_PASS3(SPO_COPY, $7, SPO_SEL_ELLIPSE));
		  }
		| ellipse_ID '(' coord_or_var ',' math_expr_var ',' math_expr_var ')'
		  {
		      add_opvars(splev, "io", VA_PASS2(1, SPO_SEL_ELLIPSE));
		  }
		| ellipse_ID '(' coord_or_var ',' math_expr_var ',' math_expr_var ',' FILLING ')'
		  {
		      add_opvars(splev, "io", VA_PASS2($9, SPO_SEL_ELLIPSE));
		  }
		| gradient_ID '(' GRADIENT_TYPE ',' '(' math_expr_var '-' math_expr_var opt_limited ')' ',' coord_or_var opt_coord_or_var ')'
		  {
		      add_opvars(splev, "iio",
				 VA_PASS3($9, $3, SPO_SEL_GRADIENT));
		  }
		| complement_ID ter_selection_x
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_SEL_COMPLEMENT));
		  }
		| VARSTRING_SEL
		  {
		      check_vardef_type(variable_definitions, $1, SPOVAR_SEL);
		      vardef_used(variable_definitions, $1);
		      add_opvars(splev, "v", VA_PASS1($1));
		      Free($1);
		  }
		| '(' ter_selection ')'
		  {
		      /* nothing */
		  }
		;

ter_selection	: ter_selection_x
		  {
		      /* nothing */
		  }
		| ter_selection_x '&' ter_selection
		  {
		      add_opvars(splev, "o", VA_PASS1(SPO_SEL_ADD));
		  }
		;

dice		: DICE
		  {
		      add_opvars(splev, "iio",
				 VA_PASS3($1.num, $1.die, SPO_DICE));
		  }
		;

all_integers	: MINUS_INTEGER
		| PLUS_INTEGER
		| INTEGER
		;

all_ints_push	: MINUS_INTEGER
		  {
		      add_opvars(splev, "i", VA_PASS1($1));
		  }
		| PLUS_INTEGER
		  {
		      add_opvars(splev, "i", VA_PASS1($1));
		  }
		| INTEGER
		  {
		      add_opvars(splev, "i", VA_PASS1($1));
		  }
		| dice
		  {
		      /* nothing */
		  }
		;

objectid	: object_ID
		| OBJECT_ID
		;

monsterid	: monster_ID
		| MONSTER_ID
		;

terrainid	: terrain_ID
		| TERRAIN_ID
		;

engraving_type	: ENGRAVING_TYPE
		| RANDOM_TYPE
		;

lev_region	: region
		  {
			$$ = $1;
		  }
		| LEV '(' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ')'
		  {
			if ($3 <= 0 || $3 >= COLNO)
			    lc_error(
                          "Region (%ld,%ld,%ld,%ld) out of level range (x1)!",
                                     $3, $5, $7, $9);
			else if ($5 < 0 || $5 >= ROWNO)
			    lc_error(
                          "Region (%ld,%ld,%ld,%ld) out of level range (y1)!",
                                     $3, $5, $7, $9);
			else if ($7 <= 0 || $7 >= COLNO)
			    lc_error(
                          "Region (%ld,%ld,%ld,%ld) out of level range (x2)!",
                                     $3, $5, $7, $9);
			else if ($9 < 0 || $9 >= ROWNO)
			    lc_error(
                          "Region (%ld,%ld,%ld,%ld) out of level range (y2)!",
                                     $3, $5, $7, $9);
			$$.x1 = $3;
			$$.y1 = $5;
			$$.x2 = $7;
			$$.y2 = $9;
			$$.area = 1;
		  }
		;

region		: '(' INTEGER ',' INTEGER ',' INTEGER ',' INTEGER ')'
		  {
/* This series of if statements is a hack for MSC 5.1.  It seems that its
   tiny little brain cannot compile if these are all one big if statement. */
			if ($2 < 0 || $2 > (int) max_x_map)
			    lc_error(
                            "Region (%ld,%ld,%ld,%ld) out of map range (x1)!",
                                     $2, $4, $6, $8);
			else if ($4 < 0 || $4 > (int) max_y_map)
			    lc_error(
                            "Region (%ld,%ld,%ld,%ld) out of map range (y1)!",
                                     $2, $4, $6, $8);
			else if ($6 < 0 || $6 > (int) max_x_map)
			    lc_error(
                            "Region (%ld,%ld,%ld,%ld) out of map range (x2)!",
                                     $2, $4, $6, $8);
			else if ($8 < 0 || $8 > (int) max_y_map)
			    lc_error(
                            "Region (%ld,%ld,%ld,%ld) out of map range (y2)!",
                                     $2, $4, $6, $8);
			$$.area = 0;
			$$.x1 = $2;
			$$.y1 = $4;
			$$.x2 = $6;
			$$.y2 = $8;
		  }
		;


%%

/*lev_comp.y*/