nethack-gwaa-kiwi/nethack
1
0
Fork 0
Code Pull Requests Activity

New level compiler: code changes

Browse Source
This commit is contained in:
Pasi Kallinen
2015-02-18 20:14:40 +02:00
parent 7912a566e5
commit 47bb9abace
14 changed files with 7189 additions and 3776 deletions
Download Patch File Download Diff File Expand all files Collapse all files

5
include/extern.h
View File

@@ -275,7 +275,7 @@ E int FDECL(use_pick_axe2, (struct obj *));
E boolean FDECL(mdig_tunnel, (struct monst *));
E void FDECL(watch_dig, (struct monst *,XCHAR_P,XCHAR_P,BOOLEAN_P));
E void NDECL(zap_dig);
E struct obj *FDECL(bury_an_obj, (struct obj *));
E struct obj *FDECL(bury_an_obj, (struct obj *, boolean *));
E void FDECL(bury_objs, (int,int));
E void FDECL(unearth_objs, (int,int));
E void FDECL(rot_organic, (ANY_P *, long));
@@ -1132,6 +1132,7 @@ E void FDECL(dodoor, (int,int,struct mkroom *));
E void FDECL(mktrap, (int,int,struct mkroom *,coord*));
E void FDECL(mkstairs, (XCHAR_P,XCHAR_P,CHAR_P,struct mkroom *));
E void NDECL(mkinvokearea);
E void FDECL(mineralize, (int, int, int, int, boolean));
/* ### mkmap.c ### */
@@ -1141,7 +1142,7 @@ void FDECL(remove_rooms, (int,int,int,int));
/* ### mkmaze.c ### */
E void FDECL(wallification, (int,int,int,int));
E void FDECL(walkfrom, (int,int));
E void FDECL(walkfrom, (int,int,SCHAR_P));
E void FDECL(makemaz, (const char *));
E void FDECL(mazexy, (coord *));
E void NDECL(bound_digging);

2
include/mkroom.h
View File

@@ -13,6 +13,8 @@ struct mkroom {
schar rtype; /* type of room (zoo, throne, etc...) */
schar orig_rtype; /* same as rtype, but not zeroed later */
schar rlit; /* is the room lit ? */
schar needfill; /* sp_lev: does the room need filling? */
schar needjoining; /* sp_lev */
schar doorct; /* door count */
schar fdoor; /* index for the first door of the room */
schar nsubrooms; /* number of subrooms */

14
include/rm.h
View File

@@ -291,6 +291,7 @@ extern struct symsetentry symset[NUM_GRAPHICS]; /* from drawing.c */
#define D_CLOSED 4
#define D_LOCKED 8
#define D_TRAPPED 16
#define D_SECRET 32 /* only used by sp_lev.c, NOT in rm-struct */
/*
* Some altars are considered as shrines, so we need a flag.
@@ -393,6 +394,19 @@ struct rm {
Bitfield(candig,1); /* Exception to Can_dig_down; was a trapdoor */
};
#define SET_TYPLIT(x,y,ttyp,llit) \
{ \
if ((x) >= 0 && (y) >= 0 && (x) < COLNO && (y) < ROWNO) { \
if ((ttyp) < MAX_TYPE) levl[(x)][(y)].typ = (ttyp); \
if ((ttyp) == LAVAPOOL) levl[(x)][(y)].lit = 1; \
else if ((schar)(llit) != -2) { \
if ((schar)(llit) == -1) levl[(x)][(y)].lit = rn2(2); \
else levl[(x)][(y)].lit = (llit); \
} \
} \
}
/*
* Add wall angle viewing by defining "modes" for each wall type. Each
* mode describes which parts of a wall are finished (seen as as wall)

538
include/sp_lev.h
View File

@@ -19,26 +19,315 @@
#define MAP_Y_LIM 21
/* Per level flags */
#define NOTELEPORT 1
#define HARDFLOOR 2
#define NOMMAP 4
#define SHORTSIGHTED 8
#define ARBOREAL 16
#define NOTELEPORT 0x00000001L
#define HARDFLOOR 0x00000002L
#define NOMMAP 0x00000004L
#define SHORTSIGHTED 0x00000008L
#define ARBOREAL 0x00000010L
#define MAZELEVEL 0x00000020L
#define PREMAPPED 0x00000040L
#define SHROUD 0x00000080L
#define STORMY 0x00000100L
#define GRAVEYARD 0x00000200L
/* special level types */
#define SP_LEV_ROOMS 1
#define SP_LEV_MAZE 2
/* different level layout initializers */
#define LVLINIT_NONE 0
#define LVLINIT_SOLIDFILL 1
#define LVLINIT_MAZEGRID 2
#define LVLINIT_MINES 3
#define LVLINIT_ROGUE 4
/* max. layers of object containment */
#define MAX_CONTAINMENT 10
/* max. # of random registers */
#define MAX_REGISTERS 10
/* max. nested depth of subrooms */
#define MAX_NESTED_ROOMS 5
/* max. # of opcodes per special level */
#define SPCODER_MAX_RUNTIME 65536
/* Opcodes for creating the level
* If you change these, also change opcodestr[] in util/lev_main.c
*/
enum opcode_defs {
SPO_NULL = 0,
SPO_MESSAGE,
SPO_MONSTER,
SPO_OBJECT,
SPO_ENGRAVING,
SPO_ROOM,
SPO_SUBROOM,
SPO_DOOR,
SPO_STAIR,
SPO_LADDER,
SPO_ALTAR,
SPO_FOUNTAIN,
SPO_SINK,
SPO_POOL,
SPO_TRAP,
SPO_GOLD,
SPO_CORRIDOR,
SPO_LEVREGION,
SPO_DRAWBRIDGE,
SPO_MAZEWALK,
SPO_NON_DIGGABLE,
SPO_NON_PASSWALL,
SPO_WALLIFY,
SPO_MAP,
SPO_ROOM_DOOR,
SPO_REGION,
SPO_MINERALIZE,
SPO_CMP,
SPO_JMP,
SPO_JL,
SPO_JLE,
SPO_JG,
SPO_JGE,
SPO_JE,
SPO_JNE,
SPO_TERRAIN,
SPO_REPLACETERRAIN,
SPO_EXIT,
SPO_ENDROOM,
SPO_POP_CONTAINER,
SPO_PUSH,
SPO_POP,
SPO_RN2,
SPO_DEC,
SPO_INC,
SPO_MATH_ADD,
SPO_MATH_SUB,
SPO_MATH_MUL,
SPO_MATH_DIV,
SPO_MATH_MOD,
SPO_MATH_SIGN,
SPO_COPY,
SPO_END_MONINVENT,
SPO_GRAVE,
SPO_FRAME_PUSH,
SPO_FRAME_POP,
SPO_CALL,
SPO_RETURN,
SPO_INITLEVEL,
SPO_LEVEL_FLAGS,
SPO_VAR_INIT, /* variable_name data */
SPO_SHUFFLE_ARRAY,
SPO_DICE,
SPO_SEL_ADD,
SPO_SEL_POINT,
SPO_SEL_RECT,
SPO_SEL_FILLRECT,
SPO_SEL_LINE,
SPO_SEL_RNDLINE,
SPO_SEL_GROW,
SPO_SEL_FLOOD,
SPO_SEL_RNDCOORD,
SPO_SEL_ELLIPSE,
SPO_SEL_FILTER,
SPO_SEL_GRADIENT,
SPO_SEL_COMPLEMENT,
MAX_SP_OPCODES
};
/* MONSTER and OBJECT can take a variable number of parameters,
* they also pop different # of values from the stack. So,
* first we pop a value that tells what the _next_ value will
* mean.
*/
/* MONSTER */
#define SP_M_V_PEACEFUL 0
#define SP_M_V_ALIGN 1
#define SP_M_V_ASLEEP 2
#define SP_M_V_APPEAR 3
#define SP_M_V_NAME 4
#define SP_M_V_FEMALE 5
#define SP_M_V_INVIS 6
#define SP_M_V_CANCELLED 7
#define SP_M_V_REVIVED 8
#define SP_M_V_AVENGE 9
#define SP_M_V_FLEEING 10
#define SP_M_V_BLINDED 11
#define SP_M_V_PARALYZED 12
#define SP_M_V_STUNNED 13
#define SP_M_V_CONFUSED 14
#define SP_M_V_SEENTRAPS 15
#define SP_M_V_END 16 /* end of variable parameters */
/* OBJECT */
#define SP_O_V_SPE 0
#define SP_O_V_CURSE 1
#define SP_O_V_CORPSENM 2
#define SP_O_V_NAME 3
#define SP_O_V_QUAN 4
#define SP_O_V_BURIED 5
#define SP_O_V_LIT 6
#define SP_O_V_ERODED 7
#define SP_O_V_LOCKED 8
#define SP_O_V_TRAPPED 9
#define SP_O_V_RECHARGED 10
#define SP_O_V_INVIS 11
#define SP_O_V_GREASED 12
#define SP_O_V_BROKEN 13
#define SP_O_V_COORD 14
#define SP_O_V_END 15 /* end of variable parameters */
/* When creating objects, we need to know whether
* it's a container and/or contents.
*/
#define SP_OBJ_CONTENT 0x1
#define SP_OBJ_CONTAINER 0x2
/* SPO_FILTER types */
#define SPOFILTER_PERCENT 0
#define SPOFILTER_SELECTION 1
#define SPOFILTER_MAPCHAR 2
/* gradient filter types */
#define SEL_GRADIENT_RADIAL 0
#define SEL_GRADIENT_SQUARE 1
/* variable types */
#define SPOVAR_NULL 0x00
#define SPOVAR_INT 0x01 /* l */
#define SPOVAR_STRING 0x02 /* str */
#define SPOVAR_VARIABLE 0x03 /* str (contains the variable name) */
#define SPOVAR_COORD 0x04 /* coordinate, encoded in l; use SP_COORD_X() and SP_COORD_Y() */
#define SPOVAR_REGION 0x05 /* region, encoded in l; use SP_REGION_X1() etc */
#define SPOVAR_MAPCHAR 0x06 /* map char, in l */
#define SPOVAR_MONST 0x07 /* monster class & specific monster, encoded in l; use SP_MONST_... */
#define SPOVAR_OBJ 0x08 /* object class & specific object type, encoded in l; use SP_OBJ_... */
#define SPOVAR_SEL 0x09 /* selection. char[COLNO][ROWNO] in str */
#define SPOVAR_ARRAY 0x40 /* used in splev_var & lc_vardefs, not in opvar */
#define SP_COORD_IS_RANDOM 0x01000000
/* Humidity flags for get_location() and friends, used with SP_COORD_PACK_RANDOM() */
#define DRY 0x1
#define WET 0x2
#define HOT 0x4
#define SOLID 0x8
#define ANY_LOC 0x10 /* even outside the level */
#define NO_LOC_WARN 0x20 /* no complaints and set x & y to -1, if no loc */
#define SP_COORD_X(l) (l & 0xff)
#define SP_COORD_Y(l) ((l >> 16) & 0xff)
#define SP_COORD_PACK(x,y) ((( x ) & 0xff) + ((( y ) & 0xff) << 16))
#define SP_COORD_PACK_RANDOM(f) (SP_COORD_IS_RANDOM | (f))
#define SP_REGION_X1(l) (l & 0xff)
#define SP_REGION_Y1(l) ((l >> 8) & 0xff)
#define SP_REGION_X2(l) ((l >> 16) & 0xff)
#define SP_REGION_Y2(l) ((l >> 24) & 0xff)
#define SP_REGION_PACK(x1,y1,x2,y2) ((( x1 ) & 0xff) + ((( y1 ) & 0xff) << 8) + ((( x2 ) & 0xff) << 16) + ((( y2 ) & 0xff) << 24))
#define SP_MONST_CLASS(l) (l & 0xff)
#define SP_MONST_PM(l) ((l >> 8) & 0xffff)
#define SP_MONST_PACK(m,c) ((( m ) << 8) + ((char)( c )))
#define SP_OBJ_CLASS(l) (l & 0xff)
#define SP_OBJ_TYP(l) ((l >> 8) & 0xffff)
#define SP_OBJ_PACK(o,c) ((( o ) << 8) + ((char)( c )))
#define SP_MAPCHAR_TYP(l) (l & 0xff)
#define SP_MAPCHAR_LIT(l) ((l >> 8) & 0xff)
#define SP_MAPCHAR_PACK(typ,lit) ((( lit ) << 8) + ((char)( typ )))
struct opvar {
xchar spovartyp; /* one of SPOVAR_foo */
union {
char *str;
long l;
} vardata;
};
struct splev_var {
struct splev_var *next;
char *name;
xchar svtyp; /* SPOVAR_foo */
union {
struct opvar *value;
struct opvar **arrayvalues;
} data;
long array_len;
};
struct splevstack {
long depth;
long depth_alloc;
struct opvar **stackdata;
};
struct sp_frame {
struct sp_frame *next;
struct splevstack *stack;
struct splev_var *variables;
long n_opcode;
};
struct sp_coder {
struct splevstack *stack;
struct sp_frame *frame;
/*int allow_flips;*/
int premapped;
struct mkroom *croom;
struct mkroom *tmproomlist[MAX_NESTED_ROOMS+1];
boolean failed_room[MAX_NESTED_ROOMS+1];
int n_subroom;
boolean exit_script;
int lvl_is_joined;
int opcode; /* current opcode */
struct opvar *opdat; /* current push data (req. opcode == SPO_PUSH) */
};
/* special level coder CPU flags */
#define SP_CPUFLAG_LT 1
#define SP_CPUFLAG_GT 2
#define SP_CPUFLAG_EQ 4
#define SP_CPUFLAG_ZERO 8
/*
* Structures manipulated by the special levels loader & compiler
*/
#define packed_coord long
typedef struct {
xchar is_random;
long getloc_flags;
int x, y;
} unpacked_coord;
typedef struct {
int cmp_what;
int cmp_val;
} opcmp;
typedef struct {
long jmp_target;
} opjmp;
typedef union str_or_len {
char *str;
int len;
} Str_or_Len;
typedef struct {
xchar init_style; /* one of LVLINIT_foo */
long flags;
schar filling;
boolean init_present, padding;
char fg, bg;
boolean smoothed, joined;
@@ -46,65 +335,62 @@ typedef struct {
boolean icedpools; /* for ice locations: ICED_POOL vs ICED_MOAT */
} lev_init;
typedef struct {
xchar x, y, mask;
} door;
typedef struct {
xchar wall, pos, secret, mask;
} room_door;
typedef struct {
xchar x, y, chance, type;
packed_coord coord;
xchar x, y, type;
} trap;
typedef struct {
Str_or_Len name, appear_as;
short id;
aligntyp align;
xchar x, y, chance, class, appear;
packed_coord coord;
xchar x, y, class, appear;
schar peaceful, asleep;
short female, invis, cancelled, revived, avenge, fleeing, blinded, paralyzed, stunned, confused;
long seentraps;
short has_invent;
} monster;
typedef struct {
Str_or_Len name;
int corpsenm;
short id, spe;
xchar x, y, chance, class, containment;
packed_coord coord;
xchar x, y, class, containment;
schar curse_state;
int quan;
short buried;
short lit;
short eroded, locked, trapped, recharged, invis, greased, broken;
} object;
typedef struct {
packed_coord coord;
xchar x, y;
aligntyp align;
xchar shrine;
} altar;
typedef struct {
xchar x, y, dir, db_open;
} drawbridge;
typedef struct {
xchar x, y, dir;
} walk;
typedef struct {
xchar x1, y1, x2, y2;
} digpos;
typedef struct {
xchar x, y, up;
} lad;
typedef struct {
xchar x, y, up;
} stair;
typedef struct {
xchar x1, y1, x2, y2;
xchar rtype, rlit, rirreg;
} region;
typedef struct {
xchar ter, tlit;
} terrain;
typedef struct {
xchar chance;
xchar x1,y1,x2,y2;
xchar fromter, toter, tolit;
} replaceterrain;
/* values for rtype are defined in dungeon.h */
typedef struct {
struct { xchar x1, y1, x2, y2; } inarea;
@@ -114,116 +400,6 @@ typedef struct {
Str_or_Len rname;
} lev_region;
typedef struct {
xchar x, y;
int amount;
} gold;
typedef struct {
xchar x, y;
Str_or_Len engr;
xchar etype;
} engraving;
typedef struct {
xchar x, y;
} fountain;
typedef struct {
xchar x, y;
} sink;
typedef struct {
xchar x, y;
} pool;
typedef struct {
char halign, valign;
char xsize, ysize;
char **map;
char nrobjects;
char *robjects;
char nloc;
char *rloc_x;
char *rloc_y;
char nrmonst;
char *rmonst;
char nreg;
region **regions;
char nlreg;
lev_region **lregions;
char ndoor;
door **doors;
char ntrap;
trap **traps;
char nmonster;
monster **monsters;
char nobject;
object **objects;
char ndrawbridge;
drawbridge **drawbridges;
char nwalk;
walk **walks;
char ndig;
digpos **digs;
char npass;
digpos **passs;
char nlad;
lad **lads;
char nstair;
stair **stairs;
char naltar;
altar **altars;
char ngold;
gold **golds;
char nengraving;
engraving **engravings;
char nfountain;
fountain **fountains;
} mazepart;
typedef struct {
long flags;
lev_init init_lev;
schar filling;
char numpart;
mazepart **parts;
} specialmaze;
typedef struct _room {
char *name;
char *parent;
xchar x, y, w, h;
xchar xalign, yalign;
xchar rtype, chance, rlit, filled;
char ndoor;
room_door **doors;
char ntrap;
trap **traps;
char nmonster;
monster **monsters;
char nobject;
object **objects;
char naltar;
altar **altars;
char nstair;
stair **stairs;
char ngold;
gold **golds;
char nengraving;
engraving **engravings;
char nfountain;
fountain **fountains;
char nsink;
sink **sinks;
char npool;
pool **pools;
/* These three fields are only used when loading the level... */
int nsubroom;
struct _room *subrooms[MAX_SUBROOMS];
struct mkroom *mkr;
} room;
typedef struct {
struct {
xchar room;
@@ -232,18 +408,66 @@ typedef struct {
} src, dest;
} corridor;
/* used only by lev_comp */
typedef struct _room {
Str_or_Len name;
Str_or_Len parent;
xchar x, y, w, h;
xchar xalign, yalign;
xchar rtype, chance, rlit, filled, joined;
} room;
typedef struct {
long flags;
lev_init init_lev;
char nrobjects;
char *robjects;
char nrmonst;
char *rmonst;
xchar nroom;
room **rooms;
xchar ncorr;
corridor **corrs;
} splev;
schar zaligntyp;
schar keep_region;
schar halign, valign;
char xsize, ysize;
char **map;
} mazepart;
typedef struct {
int opcode;
struct opvar *opdat;
} _opcode;
typedef struct {
_opcode *opcodes;
long n_opcodes;
} sp_lev;
typedef struct {
xchar x, y, direction, count, lit;
char typ;
} spill;
/* only used by lev_comp */
struct lc_funcdefs_parm {
char *name;
char parmtype;
struct lc_funcdefs_parm *next;
};
struct lc_funcdefs {
struct lc_funcdefs *next;
char *name;
long addr;
sp_lev code;
long n_called;
struct lc_funcdefs_parm *params;
long n_params;
};
struct lc_vardefs {
struct lc_vardefs *next;
char *name;
long var_type; /* SPOVAR_foo */
long n_used;
};
struct lc_breakdef {
struct lc_breakdef *next;
struct opvar *breakpoint;
int break_depth;
};
#endif /* SP_LEV_H */

9
src/dig.c
View File

@@ -1683,13 +1683,15 @@ buried_ball_to_freedom()
/* move objects from fobj/nexthere lists to buriedobjlist, keeping position */
/* information */
struct obj *
bury_an_obj(otmp)
bury_an_obj(otmp, dealloced)
struct obj *otmp;
boolean *dealloced;
{
struct obj *otmp2;
boolean under_ice;
debugpline1("bury_an_obj: %s", xname(otmp));
if (dealloced) *dealloced = FALSE;
if (otmp == uball) {
unpunish();
u.utrap = rn1(50,20);
@@ -1720,6 +1722,7 @@ bury_an_obj(otmp)
under_ice = is_ice(otmp->ox, otmp->oy);
if (otmp->otyp == ROCK && !under_ice) {
/* merges into burying material */
if (dealloced) *dealloced = TRUE;
obfree(otmp, (struct obj *)0);
return(otmp2);
}
@@ -1754,7 +1757,7 @@ int x, y;
if(level.objects[x][y] != (struct obj *)0)
debugpline2("bury_objs: at <%d,%d>", x, y);
for (otmp = level.objects[x][y]; otmp; otmp = otmp2)
otmp2 = bury_an_obj(otmp);
otmp2 = bury_an_obj(otmp, NULL);
/* don't expect any engravings here, but just in case */
del_engr_at(x, y);
@@ -1814,7 +1817,7 @@ long timeout UNUSED;
/* Everything which can be held in a container can also be
buried, so bury_an_obj's use of obj_extract_self insures
that Has_contents(obj) will eventually become false. */
(void)bury_an_obj(obj->cobj);
(void)bury_an_obj(obj->cobj, NULL);
}
obj_extract_self(obj);
obfree(obj, (struct obj *) 0);

14
src/hacklib.c
View File

@@ -398,6 +398,20 @@ dist2(x0, y0, x1, y1) /* square of euclidean distance between pair of pts */
return dx * dx + dy * dy;
}
int
isqrt(val)
int val;
{
int rt = 0;
int odd = 1;
while(val >= odd) {
val = val-odd;
odd = odd+2;
rt = rt + 1;
}
return rt;
}
boolean
online2(x0, y0, x1, y1) /* are two points lined up (on a straight line)? */
int x0, y0, x1, y1;

42
src/mklev.c
View File

@@ -17,7 +17,6 @@ STATIC_DCL void FDECL(mkgrave,(struct mkroom *));
STATIC_DCL void NDECL(makevtele);
STATIC_DCL void NDECL(clear_level_structures);
STATIC_DCL void NDECL(makelevel);
STATIC_DCL void NDECL(mineralize);
STATIC_DCL boolean FDECL(bydoor,(XCHAR_P,XCHAR_P));
STATIC_DCL struct mkroom *FDECL(find_branch_room, (coord *));
STATIC_DCL struct mkroom *FDECL(pos_to_room, (XCHAR_P, XCHAR_P));
@@ -814,43 +813,50 @@ skip0:
* Place deposits of minerals (gold and misc gems) in the stone
* surrounding the rooms on the map.
* Also place kelp in water.
* mineralize(-1, -1, -1, -1, FALSE); => "default" behaviour
*/
STATIC_OVL void
mineralize()
void
mineralize(kelp_pool, kelp_moat, goldprob, gemprob, skip_lvl_checks)
int kelp_pool, kelp_moat, goldprob, gemprob;
boolean skip_lvl_checks;
{
s_level *sp;
struct obj *otmp;
int goldprob, gemprob, x, y, cnt;
int x, y, cnt;
if (kelp_pool < 0) kelp_pool = 10;
if (kelp_moat < 0) kelp_moat = 30;
/* Place kelp, except on the plane of water */
if (In_endgame(&u.uz)) return;
if (!skip_lvl_checks && In_endgame(&u.uz)) return;
for (x = 2; x < (COLNO - 2); x++)
for (y = 1; y < (ROWNO - 1); y++)
if ((levl[x][y].typ == POOL && !rn2(10)) ||
(levl[x][y].typ == MOAT && !rn2(30)))
if ((kelp_pool && levl[x][y].typ == POOL && !rn2(kelp_pool)) ||
(kelp_moat && levl[x][y].typ == MOAT && !rn2(kelp_moat)))
(void) mksobj_at(KELP_FROND, x, y, TRUE, FALSE);
/* determine if it is even allowed;
almost all special levels are excluded */
if (In_hell(&u.uz) || In_V_tower(&u.uz) ||
if (!skip_lvl_checks && (In_hell(&u.uz) || In_V_tower(&u.uz) ||
Is_rogue_level(&u.uz) ||
level.flags.arboreal ||
((sp = Is_special(&u.uz)) != 0 && !Is_oracle_level(&u.uz)
&& (!In_mines(&u.uz) || sp->flags.town)
)) return;
))) return;
/* basic level-related probabilities */
goldprob = 20 + depth(&u.uz) / 3;
gemprob = goldprob / 4;
if (goldprob < 0) goldprob = 20 + depth(&u.uz) / 3;
if (gemprob < 0) gemprob = goldprob / 4;
/* mines have ***MORE*** goodies - otherwise why mine? */
if (In_mines(&u.uz)) {
goldprob *= 2;
gemprob *= 3;
} else if (In_quest(&u.uz)) {
goldprob /= 4;
gemprob /= 6;
if (!skip_lvl_checks) {
if (In_mines(&u.uz)) {
goldprob *= 2;
gemprob *= 3;
} else if (In_quest(&u.uz)) {
goldprob /= 4;
gemprob /= 6;
}
}
/*
@@ -905,7 +911,7 @@ mklev()
in_mklev = TRUE;
makelevel();
bound_digging();
mineralize();
mineralize(-1, -1, -1, -1, FALSE);
in_mklev = FALSE;
/* has_morgue gets cleared once morgue is entered; graveyard stays
set (graveyard might already be set even when has_morgue is clear

46
src/mkmaze.c
View File

@@ -556,7 +556,7 @@ register const char *s;
#endif
maze0xy(&mm);
walkfrom((int) mm.x, (int) mm.y);
walkfrom((int) mm.x, (int) mm.y, 0);
/* put a boulder at the maze center */
(void) mksobj_at(BOULDER, (int) mm.x, (int) mm.y, TRUE, FALSE);
@@ -644,14 +644,21 @@ register const char *s;
* that is totally safe.
*/
void
walkfrom(x,y)
walkfrom(x,y,typ)
int x,y;
schar typ;
{
#define CELLS (ROWNO * COLNO) / 4 /* a maze cell is 4 squares */
char mazex[CELLS + 1], mazey[CELLS + 1]; /* char's are OK */
int q, a, dir, pos;
int dirs[4];
#ifndef WALLIFIED_MAZE
if (!typ) typ = CORR;
#else
if (!typ) typ = ROOM;
#endif
pos = 1;
mazex[pos] = (char) x;
mazey[pos] = (char) y;
@@ -660,11 +667,7 @@ int x,y;
y = (int) mazey[pos];
if(!IS_DOOR(levl[x][y].typ)) {
/* might still be on edge of MAP, so don't overwrite */
#ifndef WALLIFIED_MAZE
levl[x][y].typ = CORR;
#else
levl[x][y].typ = ROOM;
#endif
levl[x][y].typ = typ;
levl[x][y].flags = 0;
}
q = 0;
@@ -675,11 +678,7 @@ int x,y;
else {
dir = dirs[rn2(q)];
move(&x, &y, dir);
#ifndef WALLIFIED_MAZE
levl[x][y].typ = CORR;
#else
levl[x][y].typ = ROOM;
#endif
levl[x][y].typ = typ;
move(&x, &y, dir);
pos++;
if (pos > CELLS)
@@ -692,19 +691,22 @@ int x,y;
#else
void
walkfrom(x,y)
walkfrom(x,y,typ)
int x,y;
schar typ;
{
register int q,a,dir;
int dirs[4];
#ifndef WALLIFIED_MAZE
if (!typ) typ = CORR;
#else
if (!typ) typ = ROOM;
#endif
if(!IS_DOOR(levl[x][y].typ)) {
/* might still be on edge of MAP, so don't overwrite */
#ifndef WALLIFIED_MAZE
levl[x][y].typ = CORR;
#else
levl[x][y].typ = ROOM;
#endif
levl[x][y].typ = typ;
levl[x][y].flags = 0;
}
@@ -715,13 +717,9 @@ int x,y;
if(!q) return;
dir = dirs[rn2(q)];
move(&x,&y,dir);
#ifndef WALLIFIED_MAZE
levl[x][y].typ = CORR;
#else
levl[x][y].typ = ROOM;
#endif
levl[x][y].typ = typ;
move(&x,&y,dir);
walkfrom(x,y);
walkfrom(x,y,typ);
}
}
#endif /* MICRO */

5
src/mon.c
View File

@@ -278,9 +278,10 @@ unsigned corpseflags;
obj = mkcorpstat(CORPSE, KEEPTRAITS(mtmp) ? mtmp : 0,
mdat, x, y, corpstatflags);
if (burythem) {
(void) bury_an_obj(obj);
boolean dealloc;
(void) bury_an_obj(obj, &dealloc);
newsym(x, y);
return obj;
return (dealloc ? NULL : obj);
}
}
break;

4991
src/sp_lev.c
View File

File diff suppressed because it is too large Load Diff

2
src/trap.c
View File

@@ -3535,7 +3535,7 @@ boolean bury_it;
place_object(otmp, ttmp->tx, ttmp->ty);
if (bury_it) {
/* magical digging first disarms this trap, then will unearth it */
(void) bury_an_obj(otmp);
(void) bury_an_obj(otmp, NULL);
} else {
/* Sell your own traps only... */
if (ttmp->madeby_u) sellobj(otmp, ttmp->tx, ttmp->ty);

395
util/lev_comp.l
View File

@@ -66,16 +66,36 @@ int FDECL(yyoutput, (int));
void FDECL(init_yyin, (FILE *));
void FDECL(init_yyout, (FILE *));
long NDECL(handle_varstring_check);
long FDECL(corefunc_str_check, (char *, long));
extern struct lc_vardefs *FDECL(vardef_defined,(struct lc_vardefs *,char *, int));
extern struct lc_vardefs *variable_definitions;
extern long FDECL(method_defined, (char *, long, long *));
void FDECL(savetoken, (char *));
void NDECL(newline);
void FDECL(advancepos, (char *));
/*
* This doesn't always get put in lev_comp.h
* (esp. when using older versions of bison).
*/
extern YYSTYPE yylval;
int nh_line_number = 1, colon_line_number = 1;
int nh_line_number = 1;
int token_start_pos = 0;
char curr_token[512];
static char map[4096];
static int map_cnt = 0;
FILE *orig_yyin = NULL;
#define ST_RET(x) do { savetoken(yytext); return x; } while (0);
#define ST_RETF(y, x) do { savetoken(yytext); y; return x; } while (0);
%}
%e 1500
%p 5000
@@ -83,6 +103,7 @@ static int map_cnt = 0;
%s MAPC
%%
<MAPC>ENDMAP {
savetoken(yytext);
BEGIN(INITIAL);
yylval.map = (char *) alloc(map_cnt + 1);
(void) strncpy(yylval.map, map, map_cnt);
@@ -90,129 +111,229 @@ static int map_cnt = 0;
map_cnt = 0;
return MAP_ID;
}
<MAPC>[-|}{+ABCISHKPLWTF\\#. 0123456789]*\r?\n {
<MAPC>[-|}{+xABCISHKMPLWTtFYU\\#. 0123456789]*\r?\n {
int len = yyleng;
savetoken(yytext);
/* convert \r\n to \n */
if (len >= 2 && yytext[len - 2] == '\r') len -= 1;
nh_line_number++;
(void) strncpy(map + map_cnt, yytext, len);
map_cnt += len;
map[map_cnt - 1] = '\n';
map[map_cnt] = '\0';
newline();
}
^#.*\n { nh_line_number++; }
: { colon_line_number = nh_line_number; return ':'; }
MESSAGE return MESSAGE_ID;
MAZE return MAZE_ID;
NOMAP return NOMAP_ID;
LEVEL return LEVEL_ID;
INIT_MAP return LEV_INIT_ID;
FLAGS return FLAGS_ID;
GEOMETRY return GEOMETRY_ID;
^MAP\r?\n { BEGIN(MAPC); nh_line_number++; }
OBJECT return OBJECT_ID;
CONTAINER return COBJECT_ID;
MONSTER return MONSTER_ID;
TRAP return TRAP_ID;
DOOR return DOOR_ID;
DRAWBRIDGE return DRAWBRIDGE_ID;
MAZEWALK return MAZEWALK_ID;
WALLIFY return WALLIFY_ID;
REGION return REGION_ID;
RANDOM_OBJECTS return RANDOM_OBJECTS_ID;
RANDOM_MONSTERS return RANDOM_MONSTERS_ID;
RANDOM_PLACES return RANDOM_PLACES_ID;
ALTAR return ALTAR_ID;
LADDER return LADDER_ID;
STAIR return STAIR_ID;
PORTAL return PORTAL_ID;
TELEPORT_REGION return TELEPRT_ID;
BRANCH return BRANCH_ID;
FOUNTAIN return FOUNTAIN_ID;
SINK return SINK_ID;
POOL return POOL_ID;
NON_DIGGABLE return NON_DIGGABLE_ID;
NON_PASSWALL return NON_PASSWALL_ID;
ROOM return ROOM_ID;
SUBROOM return SUBROOM_ID;
RANDOM_CORRIDORS return RAND_CORRIDOR_ID;
CORRIDOR return CORRIDOR_ID;
GOLD return GOLD_ID;
ENGRAVING return ENGRAVING_ID;
NAME return NAME_ID;
CHANCE return CHANCE_ID;
levregion return LEV;
open { yylval.i=D_ISOPEN; return DOOR_STATE; }
closed { yylval.i=D_CLOSED; return DOOR_STATE; }
locked { yylval.i=D_LOCKED; return DOOR_STATE; }
nodoor { yylval.i=D_NODOOR; return DOOR_STATE; }
broken { yylval.i=D_BROKEN; return DOOR_STATE; }
north { yylval.i=W_NORTH; return DIRECTION; }
east { yylval.i=W_EAST; return DIRECTION; }
south { yylval.i=W_SOUTH; return DIRECTION; }
west { yylval.i=W_WEST; return DIRECTION; }
random { yylval.i = -1; return RANDOM_TYPE; }
none { yylval.i = -2; return NONE; }
object return O_REGISTER;
monster return M_REGISTER;
place return P_REGISTER;
align return A_REGISTER;
left { yylval.i=1; return LEFT_OR_RIGHT; }
half-left { yylval.i=2; return LEFT_OR_RIGHT; }
center { yylval.i=3; return CENTER; }
half-right { yylval.i=4; return LEFT_OR_RIGHT; }
right { yylval.i=5; return LEFT_OR_RIGHT; }
top { yylval.i=1; return TOP_OR_BOT; }
bottom { yylval.i=5; return TOP_OR_BOT; }
lit { yylval.i=1; return LIGHT_STATE; }
unlit { yylval.i=0; return LIGHT_STATE; }
filled { yylval.i=0; return FILLING; }
unfilled { yylval.i=1; return FILLING; }
noalign { yylval.i= AM_NONE; return ALIGNMENT; }
law { yylval.i= AM_LAWFUL; return ALIGNMENT; }
neutral { yylval.i= AM_NEUTRAL; return ALIGNMENT; }
chaos { yylval.i= AM_CHAOTIC; return ALIGNMENT; }
coaligned { yylval.i= AM_SPLEV_CO; return ALIGNMENT; }
noncoaligned { yylval.i= AM_SPLEV_NONCO; return ALIGNMENT; }
peaceful { yylval.i=1; return MON_ATTITUDE; }
hostile { yylval.i=0; return MON_ATTITUDE; }
asleep { yylval.i=1; return MON_ALERTNESS; }
awake { yylval.i=0; return MON_ALERTNESS; }
m_feature { yylval.i= M_AP_FURNITURE; return MON_APPEARANCE; }
m_monster { yylval.i= M_AP_MONSTER; return MON_APPEARANCE; }
m_object { yylval.i= M_AP_OBJECT; return MON_APPEARANCE; }
sanctum { yylval.i=2; return ALTAR_TYPE; }
shrine { yylval.i=1; return ALTAR_TYPE; }
altar { yylval.i=0; return ALTAR_TYPE; }
up { yylval.i=1; return UP_OR_DOWN; }
down { yylval.i=0; return UP_OR_DOWN; }
false { yylval.i=0; return BOOLEAN; }
true { yylval.i=1; return BOOLEAN; }
dust { yylval.i=DUST; return ENGRAVING_TYPE; }
engrave { yylval.i=ENGRAVE; return ENGRAVING_TYPE; }
burn { yylval.i=BURN; return ENGRAVING_TYPE; }
mark { yylval.i=MARK; return ENGRAVING_TYPE; }
blood { yylval.i=ENGR_BLOOD; return ENGRAVING_TYPE; }
blessed { yylval.i=1; return CURSE_TYPE; }
uncursed { yylval.i=2; return CURSE_TYPE; }
cursed { yylval.i=3; return CURSE_TYPE; }
contained { return CONTAINED; }
noteleport { yylval.i=NOTELEPORT; return FLAG_TYPE; }
hardfloor { yylval.i=HARDFLOOR; return FLAG_TYPE; }
nommap { yylval.i=NOMMAP; return FLAG_TYPE; }
arboreal { yylval.i=ARBOREAL; return FLAG_TYPE; } /* KMH */
shortsighted { yylval.i=SHORTSIGHTED; return FLAG_TYPE; }
\[\ *[0-9]+\%\ *\] { yylval.i = atoi(yytext + 1); return PERCENT; }
[+\-]?[0-9]+ { yylval.i=atoi(yytext); return INTEGER; }
\"[^"]*\" { yytext[yyleng-1] = 0; /* Discard the trailing \" */
^[ \t]*#.*\n { savetoken(yytext); newline(); }
MESSAGE ST_RET(MESSAGE_ID);
NOMAP ST_RET(NOMAP_ID);
MAZE ST_RET(MAZE_ID);
LEVEL ST_RET(LEVEL_ID);
INIT_MAP ST_RET(LEV_INIT_ID);
mazegrid ST_RET(MAZE_GRID_ID);
solidfill ST_RET(SOLID_FILL_ID);
mines ST_RET(MINES_ID);
rogue ST_RET(ROGUELEV_ID);
FLAGS ST_RET(FLAGS_ID);
GEOMETRY ST_RET(GEOMETRY_ID);
^MAP\r?\n { savetoken(yytext); BEGIN(MAPC); newline(); }
obj(ect)? ST_RET(object_ID);
OBJECT ST_RET(OBJECT_ID);
CONTAINER ST_RET(COBJECT_ID);
MONSTER ST_RET(MONSTER_ID);
monster ST_RET(monster_ID);
TRAP ST_RET(TRAP_ID);
DOOR ST_RET(DOOR_ID);
ROOMDOOR ST_RET(ROOMDOOR_ID);
DRAWBRIDGE ST_RET(DRAWBRIDGE_ID);
MAZEWALK ST_RET(MAZEWALK_ID);
WALLIFY ST_RET(WALLIFY_ID);
REGION ST_RET(REGION_ID);
ALTAR ST_RET(ALTAR_ID);
LADDER ST_RET(LADDER_ID);
STAIR ST_RET(STAIR_ID);
PORTAL ST_RET(PORTAL_ID);
TELEPORT_REGION ST_RET(TELEPRT_ID);
BRANCH ST_RET(BRANCH_ID);
FOUNTAIN ST_RET(FOUNTAIN_ID);
SINK ST_RET(SINK_ID);
POOL ST_RET(POOL_ID);
NON_DIGGABLE ST_RET(NON_DIGGABLE_ID);
NON_PASSWALL ST_RET(NON_PASSWALL_ID);
IF ST_RET(IF_ID);
ELSE ST_RET(ELSE_ID);
EXIT ST_RET(EXIT_ID);
ROOM ST_RET(ROOM_ID);
SUBROOM ST_RET(SUBROOM_ID);
RANDOM_CORRIDORS ST_RET(RAND_CORRIDOR_ID);
CORRIDOR ST_RET(CORRIDOR_ID);
TERRAIN ST_RET(TERRAIN_ID);
terrain ST_RET(terrain_ID);
REPLACE_TERRAIN ST_RET(REPLACE_TERRAIN_ID);
GOLD ST_RET(GOLD_ID);
GRAVE ST_RET(GRAVE_ID);
ENGRAVING ST_RET(ENGRAVING_ID);
MINERALIZE ST_RET(MINERALIZE_ID);
(NAME|name) ST_RET(NAME_ID);
FOR ST_RET(FOR_ID);
TO ST_RET(TO_ID);
LOOP ST_RET(LOOP_ID);
SWITCH ST_RET(SWITCH_ID);
CASE ST_RET(CASE_ID);
BREAK ST_RET(BREAK_ID);
DEFAULT ST_RET(DEFAULT_ID);
FUNCTION ST_RET(FUNCTION_ID);
SHUFFLE ST_RET(SHUFFLE_ID);
montype ST_RET(MONTYPE_ID);
selection ST_RET(selection_ID);
rect ST_RET(rect_ID);
fillrect ST_RET(fillrect_ID);
line ST_RET(line_ID);
randline ST_RET(randline_ID);
grow ST_RET(grow_ID);
floodfill ST_RET(flood_ID);
rndcoord ST_RET(rndcoord_ID);
circle ST_RET(circle_ID);
ellipse ST_RET(ellipse_ID);
filter ST_RET(filter_ID);
gradient ST_RET(gradient_ID);
complement ST_RET(complement_ID);
radial { savetoken(yytext); yylval.i=SEL_GRADIENT_RADIAL; return GRADIENT_TYPE; }
square { savetoken(yytext); yylval.i=SEL_GRADIENT_SQUARE; return GRADIENT_TYPE; }
dry { savetoken(yytext); yylval.i=DRY; return HUMIDITY_TYPE; }
wet { savetoken(yytext); yylval.i=WET; return HUMIDITY_TYPE; }
hot { savetoken(yytext); yylval.i=HOT; return HUMIDITY_TYPE; }
solid { savetoken(yytext); yylval.i=SOLID; return HUMIDITY_TYPE; }
any { savetoken(yytext); yylval.i=ANY_LOC; return HUMIDITY_TYPE; }
levregion ST_RET(LEV);
quantity ST_RET(QUANTITY_ID);
buried ST_RET(BURIED_ID);
eroded ST_RET(ERODED_ID);
erodeproof ST_RET(ERODEPROOF_ID);
trapped ST_RET(TRAPPED_ID);
recharged ST_RET(RECHARGED_ID);
invisible ST_RET(INVIS_ID);
greased ST_RET(GREASED_ID);
female ST_RET(FEMALE_ID);
cancelled ST_RET(CANCELLED_ID);
revived ST_RET(REVIVED_ID);
avenge ST_RET(AVENGE_ID);
fleeing ST_RET(FLEEING_ID);
blinded ST_RET(BLINDED_ID);
paralyzed ST_RET(PARALYZED_ID);
stunned ST_RET(STUNNED_ID);
confused ST_RET(CONFUSED_ID);
seen_traps ST_RET(SEENTRAPS_ID);
all ST_RET(ALL_ID);
horizontal ST_RETF((yylval.i=1), HORIZ_OR_VERT);
vertical { savetoken(yytext); yylval.i=2; return HORIZ_OR_VERT; }
open { savetoken(yytext); yylval.i=D_ISOPEN; return DOOR_STATE; }
closed { savetoken(yytext); yylval.i=D_CLOSED; return DOOR_STATE; }
locked { savetoken(yytext); yylval.i=D_LOCKED; return DOOR_STATE; }
nodoor { savetoken(yytext); yylval.i=D_NODOOR; return DOOR_STATE; }
broken { savetoken(yytext); yylval.i=D_BROKEN; return DOOR_STATE; }
secret { savetoken(yytext); yylval.i=D_SECRET; return DOOR_STATE; }
north { savetoken(yytext); yylval.i=W_NORTH; return DIRECTION; }
east { savetoken(yytext); yylval.i=W_EAST; return DIRECTION; }
south { savetoken(yytext); yylval.i=W_SOUTH; return DIRECTION; }
west { savetoken(yytext); yylval.i=W_WEST; return DIRECTION; }
random { savetoken(yytext); yylval.i = -1; return RANDOM_TYPE; }
random\[ { savetoken(yytext); yylval.i = -1; return RANDOM_TYPE_BRACKET; }
none { savetoken(yytext); yylval.i = -2; return NONE; }
align ST_RET(A_REGISTER);
left { savetoken(yytext); yylval.i=1; return LEFT_OR_RIGHT; }
half-left { savetoken(yytext); yylval.i=2; return LEFT_OR_RIGHT; }
center { savetoken(yytext); yylval.i=3; return CENTER; }
half-right { savetoken(yytext); yylval.i=4; return LEFT_OR_RIGHT; }
right { savetoken(yytext); yylval.i=5; return LEFT_OR_RIGHT; }
top { savetoken(yytext); yylval.i=1; return TOP_OR_BOT; }
bottom { savetoken(yytext); yylval.i=5; return TOP_OR_BOT; }
lit { savetoken(yytext); yylval.i=1; return LIGHT_STATE; }
unlit { savetoken(yytext); yylval.i=0; return LIGHT_STATE; }
filled { savetoken(yytext); yylval.i=1; return FILLING; }
unfilled { savetoken(yytext); yylval.i=0; return FILLING; }
regular { savetoken(yytext); yylval.i=0; return IRREGULAR; }
irregular { savetoken(yytext); yylval.i=1; return IRREGULAR; }
unjoined { savetoken(yytext); yylval.i=1; return JOINED; }
joined { savetoken(yytext); yylval.i=0; return JOINED; }
limited { savetoken(yytext); yylval.i=1; return LIMITED; }
unlimited { savetoken(yytext); yylval.i=0; return LIMITED; }
noalign { savetoken(yytext); yylval.i= AM_NONE; return ALIGNMENT; }
law { savetoken(yytext); yylval.i= AM_LAWFUL; return ALIGNMENT; }
neutral { savetoken(yytext); yylval.i= AM_NEUTRAL; return ALIGNMENT; }
chaos { savetoken(yytext); yylval.i= AM_CHAOTIC; return ALIGNMENT; }
coaligned { savetoken(yytext); yylval.i= AM_SPLEV_CO; return ALIGNMENT; }
noncoaligned { savetoken(yytext); yylval.i= AM_SPLEV_NONCO; return ALIGNMENT; }
peaceful { savetoken(yytext); yylval.i=1; return MON_ATTITUDE; }
hostile { savetoken(yytext); yylval.i=0; return MON_ATTITUDE; }
asleep { savetoken(yytext); yylval.i=1; return MON_ALERTNESS; }
awake { savetoken(yytext); yylval.i=0; return MON_ALERTNESS; }
m_feature { savetoken(yytext); yylval.i= M_AP_FURNITURE; return MON_APPEARANCE; }
m_monster { savetoken(yytext); yylval.i= M_AP_MONSTER; return MON_APPEARANCE; }
m_object { savetoken(yytext); yylval.i= M_AP_OBJECT; return MON_APPEARANCE; }
sanctum { savetoken(yytext); yylval.i=2; return ALTAR_TYPE; }
shrine { savetoken(yytext); yylval.i=1; return ALTAR_TYPE; }
altar { savetoken(yytext); yylval.i=0; return ALTAR_TYPE; }
up { savetoken(yytext); yylval.i=1; return UP_OR_DOWN; }
down { savetoken(yytext); yylval.i=0; return UP_OR_DOWN; }
false { savetoken(yytext); yylval.i=0; return BOOLEAN; }
true { savetoken(yytext); yylval.i=1; return BOOLEAN; }
dust { savetoken(yytext); yylval.i=DUST; return ENGRAVING_TYPE; }
engrave { savetoken(yytext); yylval.i=ENGRAVE; return ENGRAVING_TYPE; }
burn { savetoken(yytext); yylval.i=BURN; return ENGRAVING_TYPE; }
mark { savetoken(yytext); yylval.i=MARK; return ENGRAVING_TYPE; }
blood { savetoken(yytext); yylval.i=ENGR_BLOOD; return ENGRAVING_TYPE; }
blessed { savetoken(yytext); yylval.i=1; return CURSE_TYPE; }
uncursed { savetoken(yytext); yylval.i=2; return CURSE_TYPE; }
cursed { savetoken(yytext); yylval.i=3; return CURSE_TYPE; }
noteleport { savetoken(yytext); yylval.i=NOTELEPORT; return FLAG_TYPE; }
hardfloor { savetoken(yytext); yylval.i=HARDFLOOR; return FLAG_TYPE; }
nommap { savetoken(yytext); yylval.i=NOMMAP; return FLAG_TYPE; }
arboreal { savetoken(yytext); yylval.i=ARBOREAL; return FLAG_TYPE; } /* KMH */
shortsighted { savetoken(yytext); yylval.i=SHORTSIGHTED; return FLAG_TYPE; }
mazelevel { savetoken(yytext); yylval.i=MAZELEVEL; return FLAG_TYPE; }
premapped { savetoken(yytext); yylval.i=PREMAPPED; return FLAG_TYPE; }
shroud { savetoken(yytext); yylval.i=SHROUD; return FLAG_TYPE; }
stormy { savetoken(yytext); yylval.i=STORMY; return FLAG_TYPE; }
graveyard { savetoken(yytext); yylval.i=GRAVEYARD; return FLAG_TYPE; }
[0-9]+d[0-9]+ { char *p = strchr(yytext, 'd');
savetoken(yytext);
if (p) {
*p = '\0';
p++;
yylval.dice.num=atoi(yytext);
yylval.dice.die=atoi(p);
} else { yylval.dice.num = yylval.dice.die = 1; }
return DICE;
}
\[\ *[0-9]+\%\ *\] { savetoken(yytext); yylval.i = atoi(yytext + 1);
if (yylval.i < 0 || yylval.i > 100)
lc_error("Unexpected percentile '%li%%'", yylval.i);
return PERCENT; }
-[0-9]+ { savetoken(yytext); yylval.i=atoi(yytext); return MINUS_INTEGER; }
\+[0-9]+ { savetoken(yytext); yylval.i=atoi(yytext); return PLUS_INTEGER; }
[0-9]+\% { savetoken(yytext); yylval.i = atoi(yytext);
if (yylval.i < 0 || yylval.i > 100)
lc_error("Unexpected percentile '%li%%'", yylval.i);
return SPERCENT; }
[0-9]+ { savetoken(yytext); yylval.i=atoi(yytext); return INTEGER; }
\"[^"]*\" { savetoken(yytext);
yytext[yyleng-1] = 0; /* Discard the trailing \" */
yylval.map = (char *) alloc(strlen(yytext+1)+1);
Strcpy(yylval.map, yytext+1); /* Discard the first \" */
return STRING; }
\r?\n { nh_line_number++; }
[ \t]+ ;
'\\.' { yylval.i = yytext[2]; return CHAR; }
'.' { yylval.i = yytext[1]; return CHAR; }
. { return yytext[0]; }
\$[a-zA-Z_]+ { savetoken(yytext); return handle_varstring_check(); }
"==" { savetoken(yytext); yylval.i = SPO_JE; return COMPARE_TYPE; }
"!=" { savetoken(yytext); yylval.i = SPO_JNE; return COMPARE_TYPE; }
"<>" { savetoken(yytext); yylval.i = SPO_JNE; return COMPARE_TYPE; }
"<=" { savetoken(yytext); yylval.i = SPO_JLE; return COMPARE_TYPE; }
">=" { savetoken(yytext); yylval.i = SPO_JGE; return COMPARE_TYPE; }
"<" { savetoken(yytext); yylval.i = SPO_JL; return COMPARE_TYPE; }
">" { savetoken(yytext); yylval.i = SPO_JG; return COMPARE_TYPE; }
\r?\n { newline(); }
[ \t]+ { advancepos(yytext); }
'\\.' { savetoken(yytext); yylval.i = yytext[2]; return CHAR; }
'.' { savetoken(yytext); yylval.i = yytext[1]; return CHAR; }
[-_a-zA-Z0-9]+ ST_RET(UNKNOWN_TYPE);
. { savetoken(yytext); return yytext[0]; }
%%
#ifdef AMIGA
long *alloc(n)
@@ -232,6 +353,7 @@ FILE *input_f;
else
#endif
yyin = input_f;
if (!orig_yyin) orig_yyin = yyin;
}
/* analogous routine (for completeness) */
void init_yyout( output_f )
@@ -240,4 +362,51 @@ FILE *output_f;
yyout = output_f;
}
long
handle_varstring_check()
{
struct lc_vardefs *vd;
yylval.map = (char *) alloc(strlen(yytext)+1);
Strcpy(yylval.map, yytext);
if ((vd = vardef_defined(variable_definitions, yytext, 1))) {
long l = vd->var_type;
long a = ((l & SPOVAR_ARRAY) == SPOVAR_ARRAY);
l = (l & ~SPOVAR_ARRAY);
if (l == SPOVAR_INT) return (a ? VARSTRING_INT_ARRAY : VARSTRING_INT);
if (l == SPOVAR_STRING) return (a ? VARSTRING_STRING_ARRAY : VARSTRING_STRING);
if (l == SPOVAR_VARIABLE) return (a ? VARSTRING_VAR_ARRAY : VARSTRING_VAR);
if (l == SPOVAR_COORD) return (a ? VARSTRING_COORD_ARRAY : VARSTRING_COORD);
if (l == SPOVAR_REGION) return (a ? VARSTRING_REGION_ARRAY : VARSTRING_REGION);
if (l == SPOVAR_MAPCHAR) return (a ? VARSTRING_MAPCHAR_ARRAY : VARSTRING_MAPCHAR);
if (l == SPOVAR_MONST) return (a ? VARSTRING_MONST_ARRAY : VARSTRING_MONST);
if (l == SPOVAR_OBJ) return (a ? VARSTRING_OBJ_ARRAY : VARSTRING_OBJ);
if (l == SPOVAR_SEL) return (a ? VARSTRING_SEL_ARRAY : VARSTRING_SEL);
}
return VARSTRING;
}
void
newline()
{
nh_line_number++;
token_start_pos = 0;
memset(curr_token, 0, 512);
}
void
savetoken(s)
char *s;
{
sprintf(curr_token, "%s", s);
advancepos(s);
}
void
advancepos(s)
char *s;
{
token_start_pos += strlen(s);
}
/*lev_comp.l*/

3178
util/lev_comp.y
View File

File diff suppressed because it is too large Load Diff

1724
util/lev_main.c
View File

File diff suppressed because it is too large Load Diff