/* SCCS Id: @(#)lev_main.c 3.4 2002/03/27 */

/* Copyright (c) 1989 by Jean-Christophe Collet */

/* NetHack may be freely redistributed. See license for details. */

/*

* This file contains the main function for the parser

* and some useful functions needed by yacc

*/

#define SPEC_LEV /* for MPW */

/* although, why don't we move those special defines here.. and in dgn_main? */

#include <stdarg.h>

#include "hack.h"

#include "date.h"

#include "sp_lev.h"

#ifdef STRICT_REF_DEF

#include "tcap.h"

#endif

#ifdef MAC

# if defined(__SC__) || defined(__MRC__)

# define MPWTOOL

# define PREFIX ":dungeon:" /* place output files here */

# include <CursorCtl.h>

# else

# if !defined(__MACH__)

# define PREFIX ":lib:" /* place output files here */

# endif

# endif

#endif

#ifdef WIN_CE

#define PREFIX "\\nethack\\dat\\"

#endif

#ifndef MPWTOOL

# define SpinCursor(x)

#endif

#if defined(AMIGA) && defined(DLB)

# define PREFIX "NH:slib/"

#endif

#ifndef O_WRONLY

#include <fcntl.h>

#endif

#ifndef O_CREAT /* some older BSD systems do not define O_CREAT in <fcntl.h> */

#include <sys/file.h>

#endif

#ifndef O_BINARY /* used for micros, no-op for others */

# define O_BINARY 0

#endif

#if defined(MICRO) || defined(WIN32)

# define OMASK FCMASK

#else

# define OMASK 0644

#endif

#define ERR (-1)

#define NewTab(type, size) (type **) alloc(sizeof(type *) * size)

#define Free(ptr) if(ptr) free((genericptr_t) (ptr))

#define Write(fd, item, size) if ((size_t)(write(fd, (genericptr_t)(item), size)) != size) return FALSE;

#if defined(__BORLANDC__) && !defined(_WIN32)

extern unsigned _stklen = STKSIZ;

#endif

#define MAX_ERRORS 25

extern int yyparse(void);

extern void init_yyin(FILE *);

extern void init_yyout(FILE *);

int main(int, char **);

void yyerror(const char *);

void yywarning(const char *);

int yywrap(void);

int get_floor_type(char);

int get_room_type(char *);

int get_trap_type(char *);

int get_monster_id(char *,char);

int get_object_id(char *,char);

boolean check_monster_char(char);

boolean check_object_char(char);

char what_map_char(char);

void scan_map(char *, sp_lev *);

boolean check_subrooms(sp_lev *);

boolean write_level_file(char *,sp_lev *);

struct lc_funcdefs *funcdef_new(long,char *);

void funcdef_free_all(struct lc_funcdefs *);

struct lc_funcdefs *funcdef_defined(struct lc_funcdefs *,char *, int);

struct lc_vardefs *vardef_new(long,char *);

void vardef_free_all(struct lc_vardefs *);

struct lc_vardefs *vardef_defined(struct lc_vardefs *,char *, int);

void splev_add_from(sp_lev *, sp_lev *);

extern void monst_init(void);

extern void objects_init(void);

extern void decl_init(void);

void add_opcode(sp_lev *, int, genericptr_t);

static boolean write_common_data(int,sp_lev *);

static boolean write_maze(int,sp_lev *);

static void init_obj_classes(void);

void lc_error(const char *, ...);

void add_opvars(sp_lev *, const char *, ...);

static const struct {

long functype;

long objtyp;

const char *methodname;

long retval;

} core_methods[] = {

{COREFUNC_COORD_X, SPOVAR_COORD, "x", SPOVAR_INT}, /* $coord.x */

{COREFUNC_COORD_Y, SPOVAR_COORD, "y", SPOVAR_INT}, /* $coord.y */

{COREFUNC_ARRAY_LEN, SPOVAR_INT|SPOVAR_ARRAY, "length", SPOVAR_INT},

{COREFUNC_ARRAY_LEN, SPOVAR_STRING|SPOVAR_ARRAY, "length", SPOVAR_INT},

{COREFUNC_ARRAY_LEN, SPOVAR_COORD|SPOVAR_ARRAY, "length", SPOVAR_INT},

{COREFUNC_ARRAY_LEN, SPOVAR_REGION|SPOVAR_ARRAY, "length", SPOVAR_INT},

{COREFUNC_ARRAY_LEN, SPOVAR_MAPCHAR|SPOVAR_ARRAY, "length", SPOVAR_INT},

{COREFUNC_ARRAY_LEN, SPOVAR_MONST|SPOVAR_ARRAY, "length", SPOVAR_INT},

{COREFUNC_ARRAY_LEN, SPOVAR_OBJ|SPOVAR_ARRAY, "length", SPOVAR_INT},

{COREFUNC_ARRAY_LEN, SPOVAR_SEL|SPOVAR_ARRAY, "length", SPOVAR_INT},

{0, 0, NULL, 0}

};

long

method_defined(char *methname, long o, long *ftyp)

{

int i;

for (i = 0; core_methods[i].methodname; i++) {

if (core_methods[i].objtyp == o && !strcmp(core_methods[i].methodname, methname)) {

*ftyp = core_methods[i].functype;

return core_methods[i].retval;

}

}

return 0;

}

static const struct {

int functype;

const char *name;

const char *params;

char retval;

} core_vars[] = {

{COREFUNC_DISCORDIAN_HOLIDAY, "time.discordian_holiday", "", 'i'},

{COREFUNC_PIRATEDAY, "time.pirateday", "", 'i'},

{COREFUNC_APRILFOOLSDAY, "time.aprilfoolsday", "", 'i'},

{COREFUNC_PIDAY, "time.piday", "", 'i'},

{COREFUNC_TOWELDAY, "time.towelday", "", 'i'},

{COREFUNC_MIDNIGHT, "time.midnight", "", 'i'},

{COREFUNC_NIGHT, "time.night", "", 'i'},

{COREFUNC_FRIDAY_13TH, "time.friday_13th", "", 'i'},

{COREFUNC_POM, "time.phase_of_the_moon", "", 'i'},

{COREFUNC_YYYYMMDD, "time.yyyymmdd", "", 'i'},

{COREFUNC_LEVEL_DIFFICULTY, "level.difficulty", "", 'i'},

{COREFUNC_LEVEL_DEPTH, "level.depth", "", 'i'},

{COREFUNC_SOBJ_AT, "level.obj_at", "Oc", 'i'},

{COREFUNC_MON_AT, "level.mon_at", "Mc", 'i'},

{COREFUNC_PLNAME, "hero.name", "", 's'},

{COREFUNC_ROLE, "hero.role", "", 's'},

{COREFUNC_RACE, "hero.race", "", 's'},

{COREFUNC_CARRYING, "hero.carrying", "O", 'i'},

{COREFUNC_TOSTRING, "string", "i", 's'},

{COREFUNC_TOSTRING, "str", "i", 's'},

{COREFUNC_TOINT, "integer", "s", 'i'},

{COREFUNC_TOINT, "int", "s", 'i'},

{COREFUNC_TOCOORD, "coord", "ii", 'c'},

{COREFUNC_TOREGION, "region", "iiii", 'r'},

{COREFUNC_RN2, "rnd", "i", 'i'},

{COREFUNC_ROOM_WID, "room.width", "", 'i'},

{COREFUNC_ROOM_HEI, "room.height", "", 'i'},

{COREFUNC_ROOM_X, "room.x", "", 'i'},

{COREFUNC_ROOM_Y, "room.y", "", 'i'},

{0, NULL, NULL, 0}

};

static struct {

const char *name;

int type;

} trap_types[] = {

{ "arrow", ARROW_TRAP },

{ "dart", DART_TRAP },

{ "falling rock", ROCKTRAP },

{ "board", SQKY_BOARD },

{ "bear", BEAR_TRAP },

{ "land mine", LANDMINE },

{ "rolling boulder", ROLLING_BOULDER_TRAP },

{ "sleep gas", SLP_GAS_TRAP },

{ "rust", RUST_TRAP },

{ "fire", FIRE_TRAP },

{ "pit", PIT },

{ "spiked pit", SPIKED_PIT },

{ "hole", HOLE },

{ "trap door", TRAPDOOR },

{ "teleport", TELEP_TRAP },

{ "level teleport", LEVEL_TELEP },

{ "magic portal", MAGIC_PORTAL },

{ "web", WEB },

{ "statue", STATUE_TRAP },

{ "magic", MAGIC_TRAP },

{ "anti magic", ANTI_MAGIC },

{ "polymorph", POLY_TRAP },

{ "cold", ICE_TRAP},

{ 0, 0 }

};

static struct {

const char *name;

int type;

} room_types[] = {

/* for historical reasons, room types are not contiguous numbers */

/* (type 1 is skipped) */

{ "ordinary", OROOM },

{ "rndvault", RNDVAULT },

{ "throne", COURT },

{ "swamp", SWAMP },

{ "vault", VAULT },

{ "beehive", BEEHIVE },

{ "morgue", MORGUE },

{ "barracks", BARRACKS },

{ "zoo", ZOO },

{ "delphi", DELPHI },

{ "temple", TEMPLE },

{ "lemurepit", LEMUREPIT },

{ "anthole", ANTHOLE },

{ "cocknest", COCKNEST },

{ "garden", GARDEN },

{ "leprehall", LEPREHALL },

{ "shop", SHOPBASE },

{ "armor shop", ARMORSHOP },

{ "scroll shop", SCROLLSHOP },

{ "potion shop", POTIONSHOP },

{ "weapon shop", WEAPONSHOP },

{ "food shop", FOODSHOP },

{ "ring shop", RINGSHOP },

{ "wand shop", WANDSHOP },

{ "tool shop", TOOLSHOP },

{ "book shop", BOOKSHOP },

{ "tin shop", TINSHOP },

{ "music shop", INSTRUMENTSHOP },

{ "candle shop", CANDLESHOP },

{ "pet shop", PETSHOP }, /* Stephen White */

#ifdef BLACKMARKET

{ "black market", BLACKSHOP },

{ "black market foyer", BLACKFOYER },

#endif /* BLACKMARKET */

{ 0, 0 }

};

const char *fname = "(stdin)";

int fatal_error = 0;

int got_errors = 0;

int be_verbose = 0;

int decompile = 0;

int is_rnd_vault = 0;

int rnd_vault_freq = 1;

int fname_counter = 1;

#ifdef FLEX23_BUG

/* Flex 2.3 bug work around; not needed for 2.3.6 or later */

int yy_more_len = 0;

#endif

extern unsigned int max_x_map, max_y_map;

extern int line_number, colon_line_number;

extern int token_start_pos;

extern char curr_token[512];

struct lc_vardefs *variable_definitions = NULL;

struct lc_funcdefs *function_definitions = NULL;

extern int allow_break_statements;

extern struct lc_breakdef *break_list;

int

main(int argc, char **argv)

{

FILE *fin;

int i;

boolean errors_encountered = FALSE;

#if defined(MAC) && (defined(THINK_C) || defined(__MWERKS__))

static char *mac_argv[] = { "lev_comp", /* dummy argv[0] */

":dat:Arch.des",

":dat:Barb.des",

":dat:Caveman.des",

":dat:Healer.des",

":dat:Knight.des",

":dat:Monk.des",

":dat:Priest.des",

":dat:Ranger.des",

":dat:Rogue.des",

":dat:Samurai.des",

":dat:Tourist.des",

":dat:Valkyrie.des",

":dat:Wizard.des",

":dat:bigroom.des",

":dat:castle.des",

":dat:endgame.des",

":dat:gehennom.des",

":dat:knox.des",

":dat:medusa.des",

":dat:mines.des",

":dat:oracle.des",

":dat:sheol.des",

":dat:sokoban.des",

":dat:tower.des",

":dat:yendor.des"

};

argc = SIZE(mac_argv);

argv = mac_argv;

#endif

/* Note: these initializers don't do anything except guarantee that

we're linked properly.

*/

monst_init();

objects_init();

decl_init();

/* this one does something... */

init_obj_classes();

init_yyout(stdout);

if (argc == 1) { /* Read standard input */

init_yyin(stdin);

(void) yyparse();

if (fatal_error > 0 || got_errors > 0) {

errors_encountered = TRUE;

}

} else { /* Otherwise every argument is a filename */

for (i = 1; i < argc; i++) {

fname = argv[i];

if(!strcmp(fname, "-v")) {

be_verbose++;

continue;

}

if(!strcmp(fname, "-d")) {

decompile = 1;

continue;

}

fin = freopen(fname, "r", stdin);

if (!fin) {

(void) fprintf(stderr,"Can't open \"%s\" for input.\n",

fname);

perror(fname);

errors_encountered = TRUE;

} else {

fname_counter = 1;

init_yyin(fin);

(void) yyparse();

line_number = 1;

if (fatal_error > 0 || got_errors > 0) {

errors_encountered = TRUE;

fatal_error = 0;

}

}

(void) fclose(fin);

funcdef_free_all(function_definitions);

}

}

exit(errors_encountered ? EXIT_FAILURE : EXIT_SUCCESS);

/*NOTREACHED*/

return 0;

}

/*

* Each time the parser detects an error, it uses this function.

* Here we take count of the errors. To continue farther than

* MAX_ERRORS wouldn't be reasonable.

*/

void

yyerror(const char *s)

{

char *e = ((char *)s + strlen(s) - 1);

(void) fprintf(stderr, "%s: line %d, pos %zu : %s",

fname, line_number,

token_start_pos-strlen(curr_token), s);

if (*e != '.' && *e != '!')

(void) fprintf(stderr, " at \"%s\"", curr_token);

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

if (++fatal_error > MAX_ERRORS) {

(void) fprintf(stderr,"Too many errors, good bye!\n");

exit(EXIT_FAILURE);

}

}

void

lc_error(const char *fmt, ...)

{

char buf[512];

va_list argp;

va_start(argp, fmt);

(void) vsnprintf(buf, 511, fmt, argp);

va_end(argp);

yyerror(buf);

}

/*

* Just display a warning (that is : a non fatal error)

*/

void

yywarning(const char *s)

{

(void) fprintf(stderr, "%s: line %d : WARNING : %s\n",

fname, line_number, s);

}

void

lc_warning(const char *fmt, ...)

{

char buf[512];

va_list argp;

va_start(argp, fmt);

(void) vsnprintf(buf, 511, fmt, argp);

va_end(argp);

yywarning(buf);

}

char *

decode_parm_chr(char chr)

{

static char buf[32];

switch (chr) {

default: sprintf(buf, "unknown"); break;

case 'i': sprintf(buf, "int"); break;

case 'r': sprintf(buf, "region"); break;

case 's': sprintf(buf, "str"); break;

case 'O': sprintf(buf, "obj"); break;

case 'c': sprintf(buf, "coord"); break;

case ' ': sprintf(buf, "nothing"); break;

case 'm': sprintf(buf, "mapchar"); break;

case 'M': sprintf(buf, "monster"); break;

}

return buf;

}

char *

decode_parm_str(char *str)

{

static char tmpbuf[1024];

char *p = str;

tmpbuf[0] = '\0';

if (str) {

for ( ; *p; p++) {

Strcat(tmpbuf, decode_parm_chr(*p));

if (*(p + 1)) Strcat(tmpbuf, ", ");

}

}

return tmpbuf;

}

int

is_core_func(char *str)

{

int i;

for (i = 0; core_vars[i].name; i++) {

if (!strcmp(core_vars[i].name, str)) {

return core_vars[i].functype;

}

}

return 0;

}

int

core_func_idx(char *str)

{

int i;

for (i = 0; core_vars[i].name; i++) {

if (!strcmp(core_vars[i].name, str)) {

return i;

}

}

return -1;

}

char

core_func_retval(int idx)

{

return core_vars[idx].retval;

}

const char *

core_func_params(int idx)

{

return core_vars[idx].params;

}

const char *

core_func_name(int idx)

{

return core_vars[idx].name;

}

int

handle_corefunc(sp_lev *splev, char *funcname, char *parmlist, char retc)

{

int f = is_core_func(funcname);

int i;

char *p, *dp;

if (!f) {

lc_error("Unknown core function '%s'", funcname);

return 0;

}

i = core_func_idx(funcname);

p = (char *)core_func_params(i);

if (strcmp(parmlist, p)) {

if (!strcmp(p, "")) {

lc_error("Core function '%s' takes no parameters.", funcname);

} else {

dp = strdup(decode_parm_str(p));

lc_error("Core function '%s' requires '%s' parameter%s, got '%s' instead.",

funcname, dp,

(strlen(p) > 1 ? "s" : ""),

decode_parm_str(parmlist));

free(dp);

}

return 0;

}

if (core_func_retval(i) != retc) {

lc_error("Core function '%s' does not return '%s' value.", funcname, decode_parm_chr(retc));

return 0;

}

add_opvars(splev, "io", f, SPO_COREFUNC);

return 1;

}

struct opvar *

set_opvar_int(struct opvar *ov, long val)

{

if (ov) {

ov->spovartyp = SPOVAR_INT;

ov->vardata.l = val;

}

return ov;

}

struct opvar *

set_opvar_coord(struct opvar *ov, long val)

{

if (ov) {

ov->spovartyp = SPOVAR_COORD;

ov->vardata.l = val;

}

return ov;

}

struct opvar *

set_opvar_region(struct opvar *ov, long val)

{

if (ov) {

ov->spovartyp = SPOVAR_REGION;

ov->vardata.l = val;

}

return ov;

}

struct opvar *

set_opvar_mapchar(struct opvar *ov, long val)

{

if (ov) {

ov->spovartyp = SPOVAR_MAPCHAR;

ov->vardata.l = val;

}

return ov;

}

struct opvar *

set_opvar_monst(struct opvar *ov, long val)

{

if (ov) {

ov->spovartyp = SPOVAR_MONST;

ov->vardata.l = val;

}

return ov;

}

struct opvar *

set_opvar_obj(struct opvar *ov, long val)

{

if (ov) {

ov->spovartyp = SPOVAR_OBJ;

ov->vardata.l = val;

}

return ov;

}

struct opvar *

set_opvar_str(struct opvar *ov, char *val)

{

if (ov) {

ov->spovartyp = SPOVAR_STRING;

ov->vardata.str = (val) ? strdup(val) : NULL;

}

return ov;

}

struct opvar *

set_opvar_var(struct opvar *ov, char *val)

{

if (ov) {

ov->spovartyp = SPOVAR_VARIABLE;

ov->vardata.str = (val) ? strdup(val) : NULL;

}

return ov;

}

#define New(type) \

(type *) memset((genericptr_t)alloc(sizeof(type)), 0, sizeof(type))

void

add_opvars(sp_lev *sp, const char *fmt, ...)

{

const char *p;

va_list argp;

va_start(argp, fmt);

for (p = fmt; *p != '\0'; p++) {

switch(*p) {

case ' ': break;

case 'i':

{

struct opvar *ov = New(struct opvar);

set_opvar_int(ov, va_arg(argp, long));

add_opcode(sp, SPO_PUSH, ov);

break;

}

case 'c':

{

struct opvar *ov = New(struct opvar);

set_opvar_coord(ov, va_arg(argp, long));

add_opcode(sp, SPO_PUSH, ov);

break;

}

case 'r':

{

struct opvar *ov = New(struct opvar);

set_opvar_region(ov, va_arg(argp, long));

add_opcode(sp, SPO_PUSH, ov);

break;

}

case 'm':

{

struct opvar *ov = New(struct opvar);

set_opvar_mapchar(ov, va_arg(argp, long));

add_opcode(sp, SPO_PUSH, ov);

break;

}

case 'M':

{

struct opvar *ov = New(struct opvar);

set_opvar_monst(ov, va_arg(argp, long));

add_opcode(sp, SPO_PUSH, ov);

break;

}

case 'O':

{

struct opvar *ov = New(struct opvar);

set_opvar_obj(ov, va_arg(argp, long));

add_opcode(sp, SPO_PUSH, ov);

break;

}

case 's':

{

struct opvar *ov = New(struct opvar);

set_opvar_str(ov, va_arg(argp, char *));

add_opcode(sp, SPO_PUSH, ov);

break;

}

case 'v':

{

struct opvar *ov = New(struct opvar);

set_opvar_var(ov, va_arg(argp, char *));

add_opcode(sp, SPO_PUSH, ov);

break;

}

case 'o':

{

long i = va_arg(argp, int);

if (i < 0 || i >= MAX_SP_OPCODES)

fprintf(stderr, "add_opvars: unknown opcode '%li'.\n", i);

add_opcode(sp, i, NULL);

break;

}

default:

fprintf(stderr, "add_opvars: illegal format character '%c'.\n", *p);

break;

}

}

va_end(argp);

}

void

break_stmt_start(void)

{

allow_break_statements++;

}

void

break_stmt_end(sp_lev *splev)

{

struct lc_breakdef *tmp = break_list;

struct lc_breakdef *prv = NULL;

while (tmp) {

if (tmp->break_depth == allow_break_statements) {

struct lc_breakdef *nxt = tmp->next;

set_opvar_int(tmp->breakpoint, splev->n_opcodes - tmp->breakpoint->vardata.l-1);

tmp->next = NULL;

Free(tmp);

if (!prv) break_list = NULL;

else prv->next = nxt;

tmp = nxt;

} else {

prv = tmp;

tmp = tmp->next;

}

}

allow_break_statements--;

}

void

break_stmt_new(sp_lev *splev, long i)

{

struct lc_breakdef *tmp = New(struct lc_breakdef);

tmp->breakpoint = New(struct opvar);

tmp->break_depth = allow_break_statements;

tmp->next = break_list;

break_list = tmp;

set_opvar_int(tmp->breakpoint, i);

add_opcode(splev, SPO_PUSH, tmp->breakpoint);

add_opcode(splev, SPO_JMP, NULL);

}

struct lc_funcdefs *

funcdef_new(long addr, char *name)

{

struct lc_funcdefs *f = New(struct lc_funcdefs);

if (!f) {

lc_error("Could not alloc function definition for '%s'.", name);

return NULL;

}

f->next = NULL;

f->addr = addr;

f->name = strdup(name);

f->n_called = 0;

f->n_params = 0;

f->params = NULL;

f->code.opcodes = NULL;

f->code.n_opcodes = 0;

return f;

}

void

funcdef_free_all(struct lc_funcdefs *fchain)

{

struct lc_funcdefs *tmp = fchain;

struct lc_funcdefs *nxt;

struct lc_funcdefs_parm *tmpparam;

while (tmp) {

nxt = tmp->next;

Free(tmp->name);

for (int i = 0; i < tmp->code.n_opcodes; i++) {

Free(tmp->code.opcodes[i].opdat);

}

Free(tmp->code.opcodes);

while (tmp->params) {

tmpparam = tmp->params->next;

Free(tmp->params->name);

tmp->params = tmpparam;

}

/* FIXME: free tmp->code */

Free(tmp);

tmp = nxt;

}

}

char *

funcdef_paramtypes(struct lc_funcdefs *f)

{

int i = 0;

struct lc_funcdefs_parm *fp = f->params;

char *tmp = (char *)alloc((f->n_params) + 1);

if (!tmp) return NULL;

while (fp) {

tmp[i++] = fp->parmtype;

fp = fp->next;

}

tmp[i] = '\0';

return tmp;

}

struct lc_funcdefs *

funcdef_defined(struct lc_funcdefs *f, char *name, int casesense)

{

while (f) {

if (casesense) {

if (!strcmp(name, f->name)) return f;

} else {

if (!strcasecmp(name, f->name)) return f;

}

f = f->next;

}

return NULL;

}

struct lc_vardefs *

vardef_new(long typ, char *name)

{

struct lc_vardefs *f = New(struct lc_vardefs);

if (!f) {

lc_error("Could not alloc variable definition for '%s'.", name);

return NULL;

}

f->next = NULL;

f->var_type = typ;

f->name = strdup(name);

f->n_used = 0;

return f;

}

void

vardef_free_all(struct lc_vardefs *fchain)

{

struct lc_vardefs *tmp = fchain;

struct lc_vardefs *nxt;

while (tmp) {

if (be_verbose && (tmp->n_used == 0))

lc_warning("Unused variable '%s'", tmp->name);

nxt = tmp->next;

Free(tmp->name);

Free(tmp);

tmp = nxt;

}

}

struct lc_vardefs *

vardef_defined(struct lc_vardefs *f, char *name, int casesense)

{

while (f) {

if (casesense) {

if (!strcmp(name, f->name)) return f;

} else {

if (!strcasecmp(name, f->name)) return f;

}

f = f->next;

}

return NULL;

}

const char *

spovar2str(long spovar)

{

static int togl = 0;

static char buf[2][128];

const char *n = NULL;

int is_array = (spovar & SPOVAR_ARRAY);

spovar &= ~SPOVAR_ARRAY;

switch (spovar) {

default: lc_error("spovar2str(%li)", spovar); break;

case SPOVAR_INT: n = "integer"; break;

case SPOVAR_STRING: n = "string"; break;

case SPOVAR_VARIABLE: n = "variable"; break;

case SPOVAR_COORD: n = "coordinate"; break;

case SPOVAR_REGION: n = "region"; break;

case SPOVAR_MAPCHAR: n = "mapchar"; break;

case SPOVAR_MONST: n = "monster"; break;

case SPOVAR_OBJ: n = "object"; break;

}

togl = ((togl + 1) % 2);

snprintf(buf[togl], 127, "%s%s", n, (is_array ? " array" : ""));

return buf[togl];

}

void

vardef_used(struct lc_vardefs *vd, char *varname)

{

struct lc_vardefs *tmp;

if ((tmp = vardef_defined(vd, varname, 1))) tmp->n_used++;

}

void

check_vardef_type(struct lc_vardefs *vd, char *varname, long vartype)

{

struct lc_vardefs *tmp;

if ((tmp = vardef_defined(vd, varname, 1))) {

if (tmp->var_type != vartype)

lc_error("Trying to use variable '%s' as %s, when it is %s.",

varname, spovar2str(vartype), spovar2str(tmp->var_type));

} else lc_error("Variable '%s' not defined.", varname);

}

struct lc_vardefs *

add_vardef_type(struct lc_vardefs *vd, char *varname, long vartype)

{

struct lc_vardefs *tmp;

if ((tmp = vardef_defined(vd, varname, 1))) {

if (tmp->var_type != vartype)

lc_error("Trying to redefine variable '%s' as %s, when it is %s.",

varname, spovar2str(vartype), spovar2str(tmp->var_type));

} else {

tmp = vardef_new(vartype, varname);

tmp->next = vd;

return tmp;

}

return vd;

}

int

reverse_jmp_opcode(int opcode)

{

switch (opcode) {

case SPO_JE: return SPO_JNE;

case SPO_JNE: return SPO_JE;

case SPO_JL: return SPO_JGE;

case SPO_JG: return SPO_JLE;

case SPO_JLE: return SPO_JG;

case SPO_JGE: return SPO_JL;

default: lc_error("Cannot reverse comparison jmp opcode %i.", opcode); return SPO_NULL;

}

}

/* basically copied from src/sp_lev.c */

struct opvar *

opvar_clone(struct opvar *ov)

{

if (ov) {

struct opvar *tmpov = (struct opvar *)alloc(sizeof(struct opvar));

if (!tmpov) panic("could not alloc opvar struct");

switch (ov->spovartyp) {

case SPOVAR_COORD:

case SPOVAR_REGION:

case SPOVAR_MAPCHAR:

case SPOVAR_MONST:

case SPOVAR_OBJ:

case SPOVAR_INT:

{

tmpov->spovartyp = ov->spovartyp;

tmpov->vardata.l = ov->vardata.l;

}

break;

case SPOVAR_VARIABLE:

case SPOVAR_STRING:

{

int len = strlen(ov->vardata.str);

tmpov->spovartyp = ov->spovartyp;

tmpov->vardata.str = (char *)alloc(len+1);

(void)memcpy((genericptr_t)tmpov->vardata.str,

(genericptr_t)ov->vardata.str, len);

tmpov->vardata.str[len] = '\0';

}

break;

default:

{

lc_error("Unknown opvar_clone value type (%i)!", ov->spovartyp);

}

}

return tmpov;

}

return NULL;

}

void

splev_add_from(sp_lev *splev, sp_lev *from_splev)

{

int i;

if (splev && from_splev) {

for (i = 0; i < from_splev->n_opcodes; i++) {

add_opcode(splev, from_splev->opcodes[i].opcode, opvar_clone(from_splev->opcodes[i].opdat));

}

}

}

/*

* Find the type of floor, knowing its char representation.