%{

/* NetHack 3.6 lev_comp.y $NHDT-Date: 1543371691 2018/11/28 02:21:31 $ $NHDT-Branch: NetHack-3.6.2-beta01 $:$NHDT-Revision: 1.22 $ */

/* 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 *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

%token <i> 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

%type <i> 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

%type <i> 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(vardefs);

vardefs = 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 {

int bg = (int) 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

{

int filling = (int) $5.ter;

if (filling == INVALID_TYPE || filling >= MAX_TYPE)

lc_error("INIT_MAP: Invalid fill char type.");

add_opvars(splev, "iiiiiiiio",

VA_PASS9(LVLINIT_SOLIDFILL, filling,

0, (int) $5.lit,

0,0,0,0, SPO_INITLEVEL));

max_x_map = COLNO-1;

max_y_map = ROWNO;

}

| LEV_INIT_ID ':' MAZE_GRID_ID ',' CHAR

{

int filling = (int) 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

{

int fg = (int) what_map_char((char) $5),

bg = (int) what_map_char((char) $7);

int smoothed = (int) $9,

joined = (int) $11,

lit = (int) $13,

walled = (int) $15,

filling = (int) $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((int) $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(vardefs, $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

{

vardefs = add_vardef_type(vardefs, $1, SPOVAR_INT);

add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));

Free($1);

}

| any_var_or_arr '=' selection_ID ':' ter_selection

{

vardefs = add_vardef_type(vardefs, $1, SPOVAR_SEL);

add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));

Free($1);

}

| any_var_or_arr '=' string_expr

{

vardefs = add_vardef_type(vardefs, $1, SPOVAR_STRING);

add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));

Free($1);

}

| any_var_or_arr '=' terrainid ':' mapchar_or_var

{

vardefs = add_vardef_type(vardefs, $1, SPOVAR_MAPCHAR);

add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));

Free($1);

}

| any_var_or_arr '=' monsterid ':' monster_or_var

{

vardefs = add_vardef_type(vardefs, $1, SPOVAR_MONST);

add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));

Free($1);

}

| any_var_or_arr '=' objectid ':' object_or_var

{

vardefs = add_vardef_type(vardefs, $1, SPOVAR_OBJ);

add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));

Free($1);

}

| any_var_or_arr '=' coord_or_var

{

vardefs = add_vardef_type(vardefs, $1, SPOVAR_COORD);

add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));

Free($1);

}

| any_var_or_arr '=' region_or_var

{

vardefs = add_vardef_type(vardefs, $1, SPOVAR_REGION);

add_opvars(splev, "iso", VA_PASS3(0, $1, SPO_VAR_INIT));

Free($1);

}

| any_var_or_arr '=' '{' integer_list '}'

{

int n_items = (int) $4;

vardefs = add_vardef_type(vardefs, $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 '}'

{

int n_items = (int) $4;

vardefs = add_vardef_type(vardefs, $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 '}'

{

int n_items = (int) $4;

vardefs = add_vardef_type(vardefs, $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 '}'

{

int n_items = (int) $6;

vardefs = add_vardef_type(vardefs, $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 '}'

{

int n_items = (int) $6;

vardefs = add_vardef_type(vardefs, $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 '}'

{

int n_items = (int) $6;

vardefs = add_vardef_type(vardefs, $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 '}'

{

int n_items = (int) $4;

vardefs = add_vardef_type(vardefs, $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 = vardefs;

vardefs = 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(vardefs);

vardefs = function_tmp_var_defs;

}

;

function_call : NQSTRING '(' func_call_params_list ')'

{

struct lc_funcdefs *tmpfunc;

tmpfunc = funcdef_defined(function_definitions, $1, 1);

if (tmpfunc) {

int l;

int nparams = (int) 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);

/* we must jump past it first, then CALL it, due to RETURN. */

add_opcode(splev, SPO_JMP, NULL);

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 = (int) (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((int) $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