ViewVC Help

View File | Revision Log | Show Annotations | Download File

/cvs/deliantra/server/common/loader.c

Comparing deliantra/server/common/loader.c (file contents):
Revision 1.1.1.3 by elmex, Wed Mar 15 14:04:37 2006 UTC vs.
Revision 1.7 by root, Mon Jun 26 21:46:21 2006 UTC

…		…
6	/* A lexical scanner generated by flex */	6	/* A lexical scanner generated by flex */
7		7
8	#define FLEX_SCANNER	8	#define FLEX_SCANNER
9	#define YY_FLEX_MAJOR_VERSION 2	9	#define YY_FLEX_MAJOR_VERSION 2
10	#define YY_FLEX_MINOR_VERSION 5	10	#define YY_FLEX_MINOR_VERSION 5
11	#define YY_FLEX_SUBMINOR_VERSION 31	11	#define YY_FLEX_SUBMINOR_VERSION 33
12	#if YY_FLEX_SUBMINOR_VERSION > 0	12	#if YY_FLEX_SUBMINOR_VERSION > 0
13	#define FLEX_BETA	13	#define FLEX_BETA
14	#endif	14	#endif
15		15
16	/* First, we deal with platform-specific or compiler-specific issues. */	16	/* First, we deal with platform-specific or compiler-specific issues. */
…		…
28	#ifndef FLEXINT_H	28	#ifndef FLEXINT_H
29	#define FLEXINT_H	29	#define FLEXINT_H
30		30
31	/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */	31	/* C99 systems have <inttypes.h>. Non-C99 systems may or may not. */
32		32
33	#if defined __STDC_VERSION__ && __STDC_VERSION__ >= 199901L	33	#if __STDC_VERSION__ >= 199901L
		34
		35	/* C99 says to define __STDC_LIMIT_MACROS before including stdint.h,
		36	* if you want the limit (max/min) macros for int types.
		37	*/
		38	#ifndef __STDC_LIMIT_MACROS
		39	#define __STDC_LIMIT_MACROS 1
		40	#endif
		41
34	#include <inttypes.h>	42	#include <inttypes.h>
35	typedef int8_t flex_int8_t;	43	typedef int8_t flex_int8_t;
36	typedef uint8_t flex_uint8_t;	44	typedef uint8_t flex_uint8_t;
37	typedef int16_t flex_int16_t;	45	typedef int16_t flex_int16_t;
38	typedef uint16_t flex_uint16_t;	46	typedef uint16_t flex_uint16_t;
…		…
132	/* Size of default input buffer. */	140	/* Size of default input buffer. */
133	#ifndef YY_BUF_SIZE	141	#ifndef YY_BUF_SIZE
134	#define YY_BUF_SIZE 16384	142	#define YY_BUF_SIZE 16384
135	#endif	143	#endif
136		144
		145	/* The state buf must be large enough to hold one state per character in the main buffer.
		146	*/
		147	#define YY_STATE_BUF_SIZE ((YY_BUF_SIZE + 2) * sizeof(yy_state_type))
		148
137	#ifndef YY_TYPEDEF_YY_BUFFER_STATE	149	#ifndef YY_TYPEDEF_YY_BUFFER_STATE
138	#define YY_TYPEDEF_YY_BUFFER_STATE	150	#define YY_TYPEDEF_YY_BUFFER_STATE
139	typedef struct yy_buffer_state *YY_BUFFER_STATE;	151	typedef struct yy_buffer_state *YY_BUFFER_STATE;
140	#endif	152	#endif
141		153
…		…
265	static int yy_n_chars; /* number of characters read into yy_ch_buf */	277	static int yy_n_chars; /* number of characters read into yy_ch_buf */
266	int yyleng;	278	int yyleng;
267		279
268	/* Points to current character in buffer. */	280	/* Points to current character in buffer. */
269	static char *yy_c_buf_p = (char *) 0;	281	static char *yy_c_buf_p = (char *) 0;
270	static int yy_init = 1; /* whether we need to initialize */	282	static int yy_init = 0; /* whether we need to initialize */
271	static int yy_start = 0; /* start state number */	283	static int yy_start = 0; /* start state number */
272		284
273	/* Flag which is used to allow yywrap()'s to do buffer switches	285	/* Flag which is used to allow yywrap()'s to do buffer switches
274	* instead of setting up a fresh yyin. A bit of a hack ...	286	* instead of setting up a fresh yyin. A bit of a hack ...
275	*/	287	*/
…		…
321		333
322	#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)	334	#define YY_AT_BOL() (YY_CURRENT_BUFFER_LVALUE->yy_at_bol)
323		335
324	/* Begin user sect3 */	336	/* Begin user sect3 */
325		337
326	#define yywrap(n) 1	338	#define yywrap() 1
327	#define YY_SKIP_YYWRAP	339	#define YY_SKIP_YYWRAP
328		340
329	typedef unsigned char YY_CHAR;	341	typedef unsigned char YY_CHAR;
330		342
331	FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;	343	FILE *yyin = (FILE *) 0, *yyout = (FILE *) 0;
…		…
1945	char *yytext;	1957	char *yytext;
1946	#line 1 "loader.l"	1958	#line 1 "loader.l"
1947	#line 2 "loader.l"	1959	#line 2 "loader.l"
1948	/*	1960	/*
1949	* static char *rcsid_object_c =	1961	* static char *rcsid_object_c =
1950	* "$Id: loader.c,v 1.1.1.3 2006/03/15 14:04:37 elmex Exp $";	1962	* "$Id: loader.c,v 1.7 2006/06/26 21:46:21 root dead $";
1951	*/	1963	*/
1952		1964
1953	/*	1965	/*
1954	CrossFire, A Multiplayer game for X-windows	1966	CrossFire, A Multiplayer game for X-windows
1955		1967
…		…
2271	}	2283	}
2272	}	2284	}
2273	LOG(llevError,"set_body_info called with bogus params: %s\n", params);	2285	LOG(llevError,"set_body_info called with bogus params: %s\n", params);
2274	}	2286	}
2275		2287
		2288	// return a suitable strign describign an objetc in enough detail to find it
		2289	// used only in check_loaded_object: TODO remove static, move it elsewhere and
		2290	// use it in more log messages.
		2291	static char *op_debug_info_ (object *op, char *info)
		2292	{
		2293	char info2[256 * 3];
		2294	char *p = info;
		2295
		2296	p += snprintf (p, 256, "%d=\"%s%s%s\"",
		2297	op->count,
		2298	op->name ? op->name : "(anon)",
		2299	op->title ? " " : "",
		2300	op->title ? op->title : "");
		2301
		2302	if (op->env)
		2303	p += snprintf (p, 256, "(in %s)", op_debug_info_ (op->env, info2));
		2304
		2305	if (op->map)
		2306	p += snprintf (p, 256, "(on %s@%d+%d)", op->map->path, op->x, op->y);
		2307
		2308	return info;
		2309	}
		2310
		2311	static char *op_debug_info (object *op)
		2312	{
		2313	static char info[256 * 3];
		2314
		2315	return op_debug_info_ (op, info);
		2316	}
2276		2317
2277	/* This function checks the object after it has been loaded (when we	2318	/* This function checks the object after it has been loaded (when we
2278	* get the 'end' in the input stream). This function can be used to	2319	* get the 'end' in the input stream). This function can be used to
2279	* deal with legacy objects where fields may have changed. It can also be used	2320	* deal with legacy objects where fields may have changed. It can also be used
2280	* to check for objects to make sure there are no common errors.	2321	* to check for objects to make sure there are no common errors.
…		…
2309	* really just to catch any errors - program will still run, but	2350	* really just to catch any errors - program will still run, but
2310	* not in the ideal fashion.	2351	* not in the ideal fashion.
2311	*/	2352	*/
2312	if ((op->type == WEAPON || op->type==BOW) && arch_init) {	2353	if ((op->type == WEAPON || op->type==BOW) && arch_init) {
2313	if (!op->skill) {	2354	if (!op->skill) {
2314	LOG(llevError,"Weapon %s lacks a skill.\n", op->name);	2355	LOG(llevError,"Weapon %s lacks a skill.\n", op_debug_info (op));
2315	} else if ((!strcmp(op->skill,"one handed weapons") && op->body_info[1] != -1) ||	2356	} else if ((!strcmp(op->skill,"one handed weapons") && op->body_info[1] != -1) ||
2316	(!strcmp(op->skill,"two handed weapons") && op->body_info[1] != -2)) {	2357	(!strcmp(op->skill,"two handed weapons") && op->body_info[1] != -2)) {
2317	LOG(llevError,"weapon %s arm usage does not match skill: %d, %s\n",	2358	LOG(llevError,"weapon %s arm usage does not match skill: %d, %s\n",
2318	op->name, op->body_info[1], op->skill);	2359	op_debug_info (op), op->body_info[1], op->skill);
2319	}	2360	}
2320	}	2361	}
2321		2362
2322	/* We changed last_heal to gen_sp_armour, which is what it	2363	/* We changed last_heal to gen_sp_armour, which is what it
2323	* really does for many objects. Need to catch any in maps	2364	* really does for many objects. Need to catch any in maps
…		…
2328	(op->type == SHIELD) || (op->type == RING) ||	2369	(op->type == SHIELD) || (op->type == RING) ||
2329	(op->type == BOOTS) || (op->type == GLOVES) ||	2370	(op->type == BOOTS) || (op->type == GLOVES) ||
2330	(op->type == AMULET ) || (op->type == GIRDLE) ||	2371	(op->type == AMULET ) || (op->type == GIRDLE) ||
2331	(op->type == BRACERS ) || (op->type == CLOAK)) {	2372	(op->type == BRACERS ) || (op->type == CLOAK)) {
2332	if (op->last_heal) {	2373	if (op->last_heal) {
2333	LOG(llevDebug,"Object %s still has last_heal set, not gen_sp_armour\n",	2374	LOG(llevDebug,"Object %s still has last_heal set, not gen_sp_armour\n", op_debug_info (op));
2334	op->name?op->name:"NULL");
2335	op->gen_sp_armour = op->last_heal;	2375	op->gen_sp_armour = op->last_heal;
2336	op->last_heal = 0;	2376	op->last_heal = 0;
2337	}	2377	}
2338	if (editor) ip =0;	2378	if (editor) ip =0;
2339	else ip = calc_item_power(op, 0);	2379	else ip = calc_item_power(op, 0);
2340	/* Legacy objects from before item power was in the game */	2380	/* Legacy objects from before item power was in the game */
2341	if (!op->item_power && ip) {	2381	if (!op->item_power && ip) {
2342	if (ip > 3) {	2382	if (ip > 3) {
2343	LOG(llevDebug,"Object %s had no item power, using %d\n",	2383	LOG(llevDebug,"Object %s had no item power, using %d\n", op_debug_info (op), ip);
2344	op->name?op->name:"NULL", ip);
2345	}	2384	}
2346	op->item_power = ip;	2385	op->item_power = ip;
2347	}	2386	}
2348	/* Check for possibly bogus values. Has to meet both these criteria -	2387	/* Check for possibly bogus values. Has to meet both these criteria -
2349	* something that has item_power 1 is probably just fine if our calculated	2388	* something that has item_power 1 is probably just fine if our calculated
…		…
2351	* similarly, it item_power is 0, the first check will always pass,	2390	* similarly, it item_power is 0, the first check will always pass,
2352	* but not the second one.	2391	* but not the second one.
2353	*/	2392	*/
2354	if (ip > 2 *op->item_power && ip > (op->item_power + 3)) {	2393	if (ip > 2 *op->item_power && ip > (op->item_power + 3)) {
2355	LOG(llevDebug,"Object %s seems to have too low item power? %d > %d\n",	2394	LOG(llevDebug,"Object %s seems to have too low item power? %d > %d\n",
2356	op->name?op->name:"NULL", ip, op->item_power);	2395	op_debug_info (op), ip, op->item_power);
2357	}	2396	}
2358		2397
2359	}	2398	}
2360	/* Old spellcasting object - need to load in the appropiate object */	2399	/* Old spellcasting object - need to load in the appropiate object */
2361	if ((op->type == ROD || op->type == WAND || op->type == SCROLL || op->type == HORN	2400	if ((op->type == ROD || op->type == WAND || op->type == SCROLL || op->type == HORN
…		…
2384	}	2423	}
2385		2424
2386	if (QUERY_FLAG(op, FLAG_MONSTER)) {	2425	if (QUERY_FLAG(op, FLAG_MONSTER)) {
2387	if (op->stats.hp > op->stats.maxhp)	2426	if (op->stats.hp > op->stats.maxhp)
2388	LOG(llevDebug,"Monster %s has hp set higher than maxhp (%d>%d)\n",	2427	LOG(llevDebug,"Monster %s has hp set higher than maxhp (%d>%d)\n",
2389	op->name,	2428	op_debug_info (op),
2390	op->stats.hp, op->stats.maxhp);	2429	op->stats.hp, op->stats.maxhp);
2391		2430
2392	/* The archs just need to be updated for this */	2431	/* The archs just need to be updated for this */
2393	if (op->move_type ==0) op->move_type = MOVE_WALK;	2432	if (op->move_type ==0) op->move_type = MOVE_WALK;
2394	}	2433	}
…		…
2537		2576
2538		2577
2539		2578
2540	/* Don't have to link with -lfl with this */	2579	/* Don't have to link with -lfl with this */
2541	/* need yy_push_state, yy_pop_state */	2580	/* need yy_push_state, yy_pop_state */
2542	#line 2543 "loader.c"	2581	#line 2582 "loader.c"
2543		2582
2544	#define INITIAL 0	2583	#define INITIAL 0
2545	#define MESSAGE 1	2584	#define MESSAGE 1
2546	#define LORE 2	2585	#define LORE 2
2547	#define SCRIPT 3	2586	#define SCRIPT 3
…		…
2556		2595
2557	#ifndef YY_EXTRA_TYPE	2596	#ifndef YY_EXTRA_TYPE
2558	#define YY_EXTRA_TYPE void *	2597	#define YY_EXTRA_TYPE void *
2559	#endif	2598	#endif
2560		2599
		2600	static int yy_init_globals (void );
		2601
2561	/* Macros after this point can all be overridden by user definitions in	2602	/* Macros after this point can all be overridden by user definitions in
2562	* section 1.	2603	* section 1.
2563	*/	2604	*/
2564		2605
2565	#ifndef YY_SKIP_YYWRAP	2606	#ifndef YY_SKIP_YYWRAP
…		…
2590		2631
2591	#endif	2632	#endif
2592		2633
2593	static int yy_start_stack_ptr = 0;	2634	static int yy_start_stack_ptr = 0;
2594	static int yy_start_stack_depth = 0;	2635	static int yy_start_stack_depth = 0;
2595	static int *yy_start_stack = 0;	2636	static int *yy_start_stack = NULL;
2596		2637
2597	static void yy_push_state (int new_state );	2638	static void yy_push_state (int new_state );
2598		2639
2599	static void yy_pop_state (void );	2640	static void yy_pop_state (void );
2600		2641
…		…
2704	{	2745	{
2705	register yy_state_type yy_current_state;	2746	register yy_state_type yy_current_state;
2706	register char *yy_cp, *yy_bp;	2747	register char *yy_cp, *yy_bp;
2707	register int yy_act;	2748	register int yy_act;
2708		2749
2709	#line 609 "loader.l"	2750	#line 636 "loader.l"
2710		2751
2711		2752
2712		2753
2713	/* Declare some local variables */	2754	/* Declare some local variables */
2714	int ismore=0;	2755	int ismore=0;
2715		2756
2716	lex_error=0;	2757	lex_error=0;
2717		2758
2718		2759
2719		2760
2720	#line 2721 "loader.c"	2761	#line 2762 "loader.c"
2721		2762
2722	if ( (yy_init) )	2763	if ( !(yy_init) )
2723	{	2764	{
2724	(yy_init) = 0;	2765	(yy_init) = 1;
2725		2766
2726	#ifdef YY_USER_INIT	2767	#ifdef YY_USER_INIT
2727	YY_USER_INIT;	2768	YY_USER_INIT;
2728	#endif	2769	#endif
2729		2770
…		…
2804	case 1:	2845	case 1:
2805	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */	2846	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2806	(yy_c_buf_p) = yy_cp -= 1;	2847	(yy_c_buf_p) = yy_cp -= 1;
2807	YY_DO_BEFORE_ACTION; /* set up yytext again */	2848	YY_DO_BEFORE_ACTION; /* set up yytext again */
2808	YY_RULE_SETUP	2849	YY_RULE_SETUP
2809	#line 619 "loader.l"	2850	#line 646 "loader.l"
2810	{ BEGIN( MESSAGE ); msgbuf[0]='\0'; }	2851	{ BEGIN( MESSAGE ); msgbuf[0]='\0'; }
2811	YY_BREAK	2852	YY_BREAK
2812	case 2:	2853	case 2:
2813	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */	2854	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2814	(yy_c_buf_p) = yy_cp -= 1;	2855	(yy_c_buf_p) = yy_cp -= 1;
2815	YY_DO_BEFORE_ACTION; /* set up yytext again */	2856	YY_DO_BEFORE_ACTION; /* set up yytext again */
2816	YY_RULE_SETUP	2857	YY_RULE_SETUP
2817	#line 620 "loader.l"	2858	#line 647 "loader.l"
2818	{ BEGIN( INITIAL );	2859	{ BEGIN( INITIAL );
2819	op->msg=add_string(msgbuf);	2860	op->msg=add_string(msgbuf);
2820	/* Just print a warning so we can be reasonably safe	2861	/* Just print a warning so we can be reasonably safe
2821	* about not overflowing the buffer.	2862	* about not overflowing the buffer.
2822	*/	2863	*/
…		…
2825	HUGE_BUF/2, HUGE_BUF, strlen(op->msg),op->msg);	2866	HUGE_BUF/2, HUGE_BUF, strlen(op->msg),op->msg);
2826	}	2867	}
2827	YY_BREAK	2868	YY_BREAK
2828	case 3:	2869	case 3:
2829	YY_RULE_SETUP	2870	YY_RULE_SETUP
2830	#line 629 "loader.l"	2871	#line 656 "loader.l"
2831	{strcat(msgbuf, yytext); strcat(msgbuf,"\n"); }	2872	{strcat(msgbuf, yytext); strcat(msgbuf,"\n"); }
2832	YY_BREAK	2873	YY_BREAK
2833	case 4:	2874	case 4:
2834	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */	2875	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2835	(yy_c_buf_p) = yy_cp -= 1;	2876	(yy_c_buf_p) = yy_cp -= 1;
2836	YY_DO_BEFORE_ACTION; /* set up yytext again */	2877	YY_DO_BEFORE_ACTION; /* set up yytext again */
2837	YY_RULE_SETUP	2878	YY_RULE_SETUP
2838	#line 631 "loader.l"	2879	#line 658 "loader.l"
2839	{ BEGIN( LORE ); lorebuf[0]='\0'; }	2880	{ BEGIN( LORE ); lorebuf[0]='\0'; }
2840	YY_BREAK	2881	YY_BREAK
2841	case 5:	2882	case 5:
2842	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */	2883	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2843	(yy_c_buf_p) = yy_cp -= 1;	2884	(yy_c_buf_p) = yy_cp -= 1;
2844	YY_DO_BEFORE_ACTION; /* set up yytext again */	2885	YY_DO_BEFORE_ACTION; /* set up yytext again */
2845	YY_RULE_SETUP	2886	YY_RULE_SETUP
2846	#line 632 "loader.l"	2887	#line 659 "loader.l"
2847	{ BEGIN( INITIAL );	2888	{ BEGIN( INITIAL );
2848	op->lore=add_string(lorebuf);	2889	op->lore=add_string(lorebuf);
2849	/* Just print a warning so we can be reasonably safe	2890	/* Just print a warning so we can be reasonably safe
2850	* about not overflowing the buffer.	2891	* about not overflowing the buffer.
2851	*/	2892	*/
…		…
2854	HUGE_BUF/2, HUGE_BUF, strlen(op->lore),op->lore);	2895	HUGE_BUF/2, HUGE_BUF, strlen(op->lore),op->lore);
2855	}	2896	}
2856	YY_BREAK	2897	YY_BREAK
2857	case 6:	2898	case 6:
2858	YY_RULE_SETUP	2899	YY_RULE_SETUP
2859	#line 641 "loader.l"	2900	#line 668 "loader.l"
2860	{strcat(lorebuf, yytext); strcat(lorebuf,"\n"); }	2901	{strcat(lorebuf, yytext); strcat(lorebuf,"\n"); }
2861	YY_BREAK	2902	YY_BREAK
2862	case 7:	2903	case 7:
2863	YY_RULE_SETUP	2904	YY_RULE_SETUP
2864	#line 643 "loader.l"	2905	#line 670 "loader.l"
2865	{ char *yv=yval();	2906	{ char *yv=yval();
2866		2907
2867	if (*yv=='\0') {	2908	if (*yv=='\0') {
2868	LOG(llevError,"Object lacks name.\n");	2909	LOG(llevError,"Object lacks name.\n");
2869	return LL_IGNORED;	2910	return LL_IGNORED;
…		…
2876	}	2917	}
2877	}	2918	}
2878	YY_BREAK	2919	YY_BREAK
2879	case 8:	2920	case 8:
2880	YY_RULE_SETUP	2921	YY_RULE_SETUP
2881	#line 657 "loader.l"	2922	#line 684 "loader.l"
2882	{ char *yv=yval();	2923	{ char *yv=yval();
2883		2924
2884	if (*yv=='\0') LOG(llevError,"Name without val\n");	2925	if (*yv=='\0') LOG(llevError,"Name without val\n");
2885	else FREE_AND_COPY(op->name, yv);	2926	else FREE_AND_COPY(op->name, yv);
2886	}	2927	}
2887	YY_BREAK	2928	YY_BREAK
2888	case 9:	2929	case 9:
2889	YY_RULE_SETUP	2930	YY_RULE_SETUP
2890	#line 662 "loader.l"	2931	#line 689 "loader.l"
2891	{ char *yv=yval();	2932	{ char *yv=yval();
2892		2933
2893	if (*yv=='\0') LOG(llevError,"Name without val\n");	2934	if (*yv=='\0') LOG(llevError,"Name without val\n");
2894	else FREE_AND_COPY(op->name_pl, yv);	2935	else FREE_AND_COPY(op->name_pl, yv);
2895	}	2936	}
2896	YY_BREAK	2937	YY_BREAK
2897	case 10:	2938	case 10:
2898	YY_RULE_SETUP	2939	YY_RULE_SETUP
2899	#line 667 "loader.l"	2940	#line 694 "loader.l"
2900	FREE_AND_COPY(op->skill,yval());	2941	FREE_AND_COPY(op->skill,yval());
2901	YY_BREAK	2942	YY_BREAK
2902	case 11:	2943	case 11:
2903	YY_RULE_SETUP	2944	YY_RULE_SETUP
2904	#line 668 "loader.l"	2945	#line 695 "loader.l"
2905	{ char *yv=yval();	2946	{ char *yv=yval();
2906		2947
2907	if (*yv=='\0') LOG(llevError,"Custom name without val\n");	2948	if (*yv=='\0') LOG(llevError,"Custom name without val\n");
2908	else FREE_AND_COPY(op->custom_name, yv);	2949	else FREE_AND_COPY(op->custom_name, yv);
2909	}	2950	}
2910	YY_BREAK	2951	YY_BREAK
2911	case 12:	2952	case 12:
2912	YY_RULE_SETUP	2953	YY_RULE_SETUP
2913	#line 673 "loader.l"	2954	#line 700 "loader.l"
2914	FREE_AND_COPY(op->race,yval());	2955	FREE_AND_COPY(op->race,yval());
2915	YY_BREAK	2956	YY_BREAK
2916	case 13:	2957	case 13:
2917	YY_RULE_SETUP	2958	YY_RULE_SETUP
2918	#line 674 "loader.l"	2959	#line 701 "loader.l"
2919	FREE_AND_COPY(op->slaying, yval());	2960	FREE_AND_COPY(op->slaying, yval());
2920	YY_BREAK	2961	YY_BREAK
2921	case 14:	2962	case 14:
2922	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */	2963	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2923	(yy_c_buf_p) = yy_cp -= 1;	2964	(yy_c_buf_p) = yy_cp -= 1;
2924	YY_DO_BEFORE_ACTION; /* set up yytext again */	2965	YY_DO_BEFORE_ACTION; /* set up yytext again */
2925	YY_RULE_SETUP	2966	YY_RULE_SETUP
2926	#line 675 "loader.l"	2967	#line 702 "loader.l"
2927	LOG(llevError,"Got depreciated Inventory command?\n");	2968	LOG(llevError,"Got depreciated Inventory command?\n");
2928	YY_BREAK	2969	YY_BREAK
2929	case 15:	2970	case 15:
2930	YY_RULE_SETUP	2971	YY_RULE_SETUP
2931	#line 678 "loader.l"	2972	#line 705 "loader.l"
2932	{ /* If op->arch has been set, then this new object	2973	{ /* If op->arch has been set, then this new object
2933	* must be part of the inventory. So process	2974	* must be part of the inventory. So process
2934	* appropriately.	2975	* appropriately.
2935	*/	2976	*/
2936	if (op->arch) {	2977	if (op->arch) {
…		…
2971	}	3012	}
2972	}	3013	}
2973	YY_BREAK	3014	YY_BREAK
2974	case 16:	3015	case 16:
2975	YY_RULE_SETUP	3016	YY_RULE_SETUP
2976	#line 720 "loader.l"	3017	#line 747 "loader.l"
2977	op->other_arch=find_archetype(yval());	3018	op->other_arch=find_archetype(yval());
2978	YY_BREAK	3019	YY_BREAK
2979	case 17:	3020	case 17:
2980	YY_RULE_SETUP	3021	YY_RULE_SETUP
2981	#line 721 "loader.l"	3022	#line 748 "loader.l"
2982	{	3023	{
2983	if (strcmp (yval(), "NONE") == 0) {	3024	if (strcmp (yval(), "NONE") == 0) {
2984	op->animation_id = 0;	3025	op->animation_id = 0;
2985	CLEAR_FLAG (op, FLAG_ANIMATE);	3026	CLEAR_FLAG (op, FLAG_ANIMATE);
2986	} else {	3027	} else {
…		…
2992	case 18:	3033	case 18:
2993	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */	3034	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
2994	(yy_c_buf_p) = yy_cp -= 1;	3035	(yy_c_buf_p) = yy_cp -= 1;
2995	YY_DO_BEFORE_ACTION; /* set up yytext again */	3036	YY_DO_BEFORE_ACTION; /* set up yytext again */
2996	YY_RULE_SETUP	3037	YY_RULE_SETUP
2997	#line 731 "loader.l"	3038	#line 758 "loader.l"
2998	{ /* We need to record that this is a multipart object,	3039	{ /* We need to record that this is a multipart object,
2999	* so the calling function can glue things back together	3040	* so the calling function can glue things back together
3000	*/	3041	*/
3001	ismore=1;	3042	ismore=1;
3002	}	3043	}
…		…
3004	case 19:	3045	case 19:
3005	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */	3046	*yy_cp = (yy_hold_char); /* undo effects of setting up yytext */
3006	(yy_c_buf_p) = yy_cp -= 1;	3047	(yy_c_buf_p) = yy_cp -= 1;
3007	YY_DO_BEFORE_ACTION; /* set up yytext again */	3048	YY_DO_BEFORE_ACTION; /* set up yytext again */
3008	YY_RULE_SETUP	3049	YY_RULE_SETUP
3009	#line 737 "loader.l"	3050	#line 764 "loader.l"
3010	{ check_loaded_object(op);	3051	{ check_loaded_object(op);
3011	if (ismore) return LL_MORE;	3052	if (ismore) return LL_MORE;
3012	else return LL_NORMAL;	3053	else return LL_NORMAL;
3013	}	3054	}
3014	YY_BREAK	3055	YY_BREAK
3015	case 20:	3056	case 20:
3016	YY_RULE_SETUP	3057	YY_RULE_SETUP
3017	#line 741 "loader.l"	3058	#line 768 "loader.l"
3018	op->last_heal = IVAL;	3059	op->last_heal = IVAL;
3019	YY_BREAK	3060	YY_BREAK
3020	case 21:	3061	case 21:
3021	YY_RULE_SETUP	3062	YY_RULE_SETUP
3022	#line 742 "loader.l"	3063	#line 769 "loader.l"
3023	op->last_sp = IVAL;	3064	op->last_sp = IVAL;
3024	YY_BREAK	3065	YY_BREAK
3025	case 22:	3066	case 22:
3026	YY_RULE_SETUP	3067	YY_RULE_SETUP
3027	#line 743 "loader.l"	3068	#line 770 "loader.l"
3028	op->last_grace = IVAL;	3069	op->last_grace = IVAL;
3029	YY_BREAK	3070	YY_BREAK
3030	case 23:	3071	case 23:
3031	YY_RULE_SETUP	3072	YY_RULE_SETUP
3032	#line 744 "loader.l"	3073	#line 771 "loader.l"
3033	op->last_eat = IVAL;	3074	op->last_eat = IVAL;
3034	YY_BREAK	3075	YY_BREAK
3035	case 24:	3076	case 24:
3036	YY_RULE_SETUP	3077	YY_RULE_SETUP
3037	#line 745 "loader.l"	3078	#line 772 "loader.l"
3038	{ op->speed = FVAL;	3079	{ op->speed = FVAL;
3039	if (!(map_flags & MAP_STYLE)) {	3080	if (!(map_flags & MAP_STYLE)) {
3040	if (op->speed<0) op->speed_left = op->speed_left-RANDOM()%100/100.0;	3081	if (op->speed<0) op->speed_left = op->speed_left-RANDOM()%100/100.0;
3041	update_ob_speed(op);	3082	update_ob_speed(op);
3042	}	3083	}
3043	}	3084	}
3044	YY_BREAK	3085	YY_BREAK
3045	case 25:	3086	case 25:
3046	YY_RULE_SETUP	3087	YY_RULE_SETUP
3047	#line 751 "loader.l"	3088	#line 778 "loader.l"
3048	op->speed_left = FVAL;	3089	op->speed_left = FVAL;
3049	YY_BREAK	3090	YY_BREAK
3050	case 26:	3091	case 26:
3051	YY_RULE_SETUP	3092	YY_RULE_SETUP
3052	#line 752 "loader.l"	3093	#line 779 "loader.l"
3053	{ op->move_slow |= MOVE_WALK;	3094	{ op->move_slow |= MOVE_WALK;
3054	op->move_slow_penalty = FVAL;	3095	op->move_slow_penalty = FVAL;
3055	}	3096	}
3056	YY_BREAK	3097	YY_BREAK
3057	case 27:	3098	case 27:
3058	YY_RULE_SETUP	3099	YY_RULE_SETUP
3059	#line 755 "loader.l"	3100	#line 782 "loader.l"
3060	{ char *y=yval();	3101	{ char *y=yval();
3061	if (*y=='\0') LOG(llevError,"Title without value.\n");	3102	if (*y=='\0') LOG(llevError,"Title without value.\n");
3062	else FREE_AND_COPY(op->title, y);	3103	else FREE_AND_COPY(op->title, y);
3063	}	3104	}
3064	YY_BREAK	3105	YY_BREAK
3065	case 28:	3106	case 28:
3066	YY_RULE_SETUP	3107	YY_RULE_SETUP
3067	#line 760 "loader.l"	3108	#line 787 "loader.l"
3068	op->face = &new_faces[FindFace(yval(), 0)];	3109	op->face = &new_faces[FindFace(yval(), 0)];
3069	YY_BREAK	3110	YY_BREAK
3070	case 29:	3111	case 29:
3071	YY_RULE_SETUP	3112	YY_RULE_SETUP
3072	#line 761 "loader.l"	3113	#line 788 "loader.l"
3073	op->stats.Str = IVAL;	3114	op->stats.Str = IVAL;
3074	YY_BREAK	3115	YY_BREAK
3075	case 30:	3116	case 30:
3076	YY_RULE_SETUP	3117	YY_RULE_SETUP
3077	#line 762 "loader.l"	3118	#line 789 "loader.l"
3078	op->stats.Dex = IVAL;	3119	op->stats.Dex = IVAL;
3079	YY_BREAK	3120	YY_BREAK
3080	case 31:	3121	case 31:
3081	YY_RULE_SETUP	3122	YY_RULE_SETUP
3082	#line 763 "loader.l"	3123	#line 790 "loader.l"
3083	op->stats.Con = IVAL;	3124	op->stats.Con = IVAL;
3084	YY_BREAK	3125	YY_BREAK
3085	case 32:	3126	case 32:
3086	YY_RULE_SETUP	3127	YY_RULE_SETUP
3087	#line 764 "loader.l"	3128	#line 791 "loader.l"
3088	op->stats.Wis = IVAL;	3129	op->stats.Wis = IVAL;
3089	YY_BREAK	3130	YY_BREAK
3090	case 33:	3131	case 33:
3091	YY_RULE_SETUP	3132	YY_RULE_SETUP
3092	#line 765 "loader.l"	3133	#line 792 "loader.l"
3093	op->stats.Cha = IVAL;	3134	op->stats.Cha = IVAL;
3094	YY_BREAK	3135	YY_BREAK
3095	case 34:	3136	case 34:
3096	YY_RULE_SETUP	3137	YY_RULE_SETUP
3097	#line 766 "loader.l"	3138	#line 793 "loader.l"
3098	op->stats.Int = IVAL;	3139	op->stats.Int = IVAL;
3099	YY_BREAK	3140	YY_BREAK
3100	case 35:	3141	case 35:
3101	YY_RULE_SETUP	3142	YY_RULE_SETUP
3102	#line 767 "loader.l"	3143	#line 794 "loader.l"
3103	op->stats.Pow = IVAL;	3144	op->stats.Pow = IVAL;
3104	YY_BREAK	3145	YY_BREAK
3105	case 36:	3146	case 36:
3106	YY_RULE_SETUP	3147	YY_RULE_SETUP
3107	#line 768 "loader.l"	3148	#line 795 "loader.l"
3108	op->stats.hp = IVAL;	3149	op->stats.hp = IVAL;
3109	YY_BREAK	3150	YY_BREAK
3110	case 37:	3151	case 37:
3111	YY_RULE_SETUP	3152	YY_RULE_SETUP
3112	#line 769 "loader.l"	3153	#line 796 "loader.l"
3113	op->stats.maxhp = IVAL;	3154	op->stats.maxhp = IVAL;
3114	YY_BREAK	3155	YY_BREAK
3115	case 38:	3156	case 38:
3116	YY_RULE_SETUP	3157	YY_RULE_SETUP
3117	#line 770 "loader.l"	3158	#line 797 "loader.l"
3118	op->stats.sp = IVAL;	3159	op->stats.sp = IVAL;
3119	YY_BREAK	3160	YY_BREAK
3120	case 39:	3161	case 39:
3121	YY_RULE_SETUP	3162	YY_RULE_SETUP
3122	#line 771 "loader.l"	3163	#line 798 "loader.l"
3123	op->stats.maxsp = IVAL;	3164	op->stats.maxsp = IVAL;
3124	YY_BREAK	3165	YY_BREAK
3125	case 40:	3166	case 40:
3126	YY_RULE_SETUP	3167	YY_RULE_SETUP
3127	#line 772 "loader.l"	3168	#line 799 "loader.l"
3128	op->stats.grace = IVAL;	3169	op->stats.grace = IVAL;
3129	YY_BREAK	3170	YY_BREAK
3130	case 41:	3171	case 41:
3131	YY_RULE_SETUP	3172	YY_RULE_SETUP
3132	#line 773 "loader.l"	3173	#line 800 "loader.l"
3133	op->stats.maxgrace = IVAL;	3174	op->stats.maxgrace = IVAL;
3134	YY_BREAK	3175	YY_BREAK
3135	case 42:	3176	case 42:
3136	YY_RULE_SETUP	3177	YY_RULE_SETUP
3137	#line 774 "loader.l"	3178	#line 801 "loader.l"
3138	op->stats.exp = atoll(yval());	3179	op->stats.exp = atoll(yval());
3139	YY_BREAK	3180	YY_BREAK
3140	case 43:	3181	case 43:
3141	YY_RULE_SETUP	3182	YY_RULE_SETUP
3142	#line 775 "loader.l"	3183	#line 802 "loader.l"
3143	op->perm_exp = atoll(yval());	3184	op->perm_exp = atoll(yval());
3144	YY_BREAK	3185	YY_BREAK
3145	case 44:	3186	case 44:
3146	YY_RULE_SETUP	3187	YY_RULE_SETUP
3147	#line 776 "loader.l"	3188	#line 803 "loader.l"
3148	op->stats.food = IVAL;	3189	op->stats.food = IVAL;
3149	YY_BREAK	3190	YY_BREAK
3150	case 45:	3191	case 45:
3151	YY_RULE_SETUP	3192	YY_RULE_SETUP
3152	#line 777 "loader.l"	3193	#line 804 "loader.l"
3153	op->stats.dam = IVAL;	3194	op->stats.dam = IVAL;
3154	YY_BREAK	3195	YY_BREAK
3155	case 46:	3196	case 46:
3156	YY_RULE_SETUP	3197	YY_RULE_SETUP
3157	#line 778 "loader.l"	3198	#line 805 "loader.l"
3158	op->stats.wc = IVAL;	3199	op->stats.wc = IVAL;
3159	YY_BREAK	3200	YY_BREAK
3160	case 47:	3201	case 47:
3161	YY_RULE_SETUP	3202	YY_RULE_SETUP
3162	#line 779 "loader.l"	3203	#line 806 "loader.l"
3163	op->stats.ac = IVAL;	3204	op->stats.ac = IVAL;
3164	YY_BREAK	3205	YY_BREAK
3165	case 48:	3206	case 48:
3166	YY_RULE_SETUP	3207	YY_RULE_SETUP
3167	#line 780 "loader.l"	3208	#line 807 "loader.l"
3168	{op->x = IVAL; op->ox= op->x; }	3209	{op->x = IVAL; op->ox= op->x; }
3169	YY_BREAK	3210	YY_BREAK
3170	case 49:	3211	case 49:
3171	YY_RULE_SETUP	3212	YY_RULE_SETUP
3172	#line 781 "loader.l"	3213	#line 808 "loader.l"
3173	{op->y = IVAL; op->oy= op->y; }	3214	{op->y = IVAL; op->oy= op->y; }
3174	YY_BREAK	3215	YY_BREAK
3175	case 50:	3216	case 50:
3176	YY_RULE_SETUP	3217	YY_RULE_SETUP
3177	#line 782 "loader.l"	3218	#line 809 "loader.l"
3178	op->nrof= atol(yval());	3219	op->nrof= atol(yval());
3179	YY_BREAK	3220	YY_BREAK
3180	case 51:	3221	case 51:
3181	YY_RULE_SETUP	3222	YY_RULE_SETUP
3182	#line 783 "loader.l"	3223	#line 810 "loader.l"
3183	op->level = IVAL;	3224	op->level = IVAL;
3184	YY_BREAK	3225	YY_BREAK
3185	case 52:	3226	case 52:
3186	YY_RULE_SETUP	3227	YY_RULE_SETUP
3187	#line 784 "loader.l"	3228	#line 811 "loader.l"
3188	op->direction = IVAL;	3229	op->direction = IVAL;
3189	YY_BREAK	3230	YY_BREAK
3190	case 53:	3231	case 53:
3191	YY_RULE_SETUP	3232	YY_RULE_SETUP
3192	#line 785 "loader.l"	3233	#line 812 "loader.l"
3193	op->type = IVAL;	3234	op->type = IVAL;
3194	YY_BREAK	3235	YY_BREAK
3195	case 54:	3236	case 54:
3196	YY_RULE_SETUP	3237	YY_RULE_SETUP
3197	#line 786 "loader.l"	3238	#line 813 "loader.l"
3198	op->subtype = IVAL;	3239	op->subtype = IVAL;
3199	YY_BREAK	3240	YY_BREAK
3200	case 55:	3241	case 55:
3201	YY_RULE_SETUP	3242	YY_RULE_SETUP
3202	#line 787 "loader.l"	3243	#line 814 "loader.l"
3203	op->material = IVAL;	3244	op->material = IVAL;
3204	YY_BREAK	3245	YY_BREAK
3205	case 56:	3246	case 56:
3206	YY_RULE_SETUP	3247	YY_RULE_SETUP
3207	#line 788 "loader.l"	3248	#line 815 "loader.l"
3208	{ char *yv=yval();	3249	{ char *yv=yval();
3209	if (*yv=='\0')	3250	if (*yv=='\0')
3210	LOG(llevError,"Materialname without val\n");	3251	LOG(llevError,"Materialname without val\n");
3211	else	3252	else
3212	FREE_AND_COPY(op->materialname, yv);	3253	FREE_AND_COPY(op->materialname, yv);
3213	}	3254	}
3214	YY_BREAK	3255	YY_BREAK
3215	case 57:	3256	case 57:
3216	YY_RULE_SETUP	3257	YY_RULE_SETUP
3217	#line 795 "loader.l"	3258	#line 822 "loader.l"
3218	op->value = IVAL;	3259	op->value = IVAL;
3219	YY_BREAK	3260	YY_BREAK
3220	case 58:	3261	case 58:
3221	YY_RULE_SETUP	3262	YY_RULE_SETUP
3222	#line 796 "loader.l"	3263	#line 823 "loader.l"
3223	op->weight = atol(yval());	3264	op->weight = atol(yval());
3224	YY_BREAK	3265	YY_BREAK
3225	case 59:	3266	case 59:
3226	YY_RULE_SETUP	3267	YY_RULE_SETUP
3227	#line 797 "loader.l"	3268	#line 824 "loader.l"
3228	op->carrying = atol(yval());	3269	op->carrying = atol(yval());
3229	YY_BREAK	3270	YY_BREAK
3230	case 60:	3271	case 60:
3231	YY_RULE_SETUP	3272	YY_RULE_SETUP
3232	#line 798 "loader.l"	3273	#line 825 "loader.l"
3233	op->attacktype = IVAL;	3274	op->attacktype = IVAL;
3234	YY_BREAK	3275	YY_BREAK
3235	case 61:	3276	case 61:
3236	YY_RULE_SETUP	3277	YY_RULE_SETUP
3237	#line 799 "loader.l"	3278	#line 826 "loader.l"
3238	op->path_attuned = IVAL;	3279	op->path_attuned = IVAL;
3239	YY_BREAK	3280	YY_BREAK
3240	case 62:	3281	case 62:
3241	YY_RULE_SETUP	3282	YY_RULE_SETUP
3242	#line 800 "loader.l"	3283	#line 827 "loader.l"
3243	op->path_repelled = IVAL;	3284	op->path_repelled = IVAL;
3244	YY_BREAK	3285	YY_BREAK
3245	case 63:	3286	case 63:
3246	YY_RULE_SETUP	3287	YY_RULE_SETUP
3247	#line 801 "loader.l"	3288	#line 828 "loader.l"
3248	op->path_denied = IVAL;	3289	op->path_denied = IVAL;
3249	YY_BREAK	3290	YY_BREAK
3250	case 64:	3291	case 64:
3251	YY_RULE_SETUP	3292	YY_RULE_SETUP
3252	#line 802 "loader.l"	3293	#line 829 "loader.l"
3253	op->invisible = IVAL;	3294	op->invisible = IVAL;
3254	YY_BREAK	3295	YY_BREAK
3255	case 65:	3296	case 65:
3256	YY_RULE_SETUP	3297	YY_RULE_SETUP
3257	#line 803 "loader.l"	3298	#line 830 "loader.l"
3258	op->magic = IVAL;	3299	op->magic = IVAL;
3259	YY_BREAK	3300	YY_BREAK
3260	case 66:	3301	case 66:
3261	YY_RULE_SETUP	3302	YY_RULE_SETUP
3262	#line 804 "loader.l"	3303	#line 831 "loader.l"
3263	op->state = IVAL;	3304	op->state = IVAL;
3264	YY_BREAK	3305	YY_BREAK
3265	case 67:	3306	case 67:
3266	YY_RULE_SETUP	3307	YY_RULE_SETUP
3267	#line 805 "loader.l"	3308	#line 832 "loader.l"
3268	SET_OR_CLEAR_FLAG(op, FLAG_ALIVE, IVAL);	3309	SET_OR_CLEAR_FLAG(op, FLAG_ALIVE, IVAL);
3269	YY_BREAK	3310	YY_BREAK
3270	case 68:	3311	case 68:
3271	YY_RULE_SETUP	3312	YY_RULE_SETUP
3272	#line 806 "loader.l"	3313	#line 833 "loader.l"
3273	SET_OR_CLEAR_FLAG(op, FLAG_APPLIED, IVAL);	3314	SET_OR_CLEAR_FLAG(op, FLAG_APPLIED, IVAL);
3274	YY_BREAK	3315	YY_BREAK
3275	case 69:	3316	case 69:
3276	YY_RULE_SETUP	3317	YY_RULE_SETUP
3277	#line 807 "loader.l"	3318	#line 834 "loader.l"
3278	SET_OR_CLEAR_FLAG(op, FLAG_UNPAID, IVAL);	3319	SET_OR_CLEAR_FLAG(op, FLAG_UNPAID, IVAL);
3279	YY_BREAK	3320	YY_BREAK
3280	case 70:	3321	case 70:
3281	YY_RULE_SETUP	3322	YY_RULE_SETUP
3282	#line 808 "loader.l"	3323	#line 835 "loader.l"
3283	{ /* not used - just ignore */ }	3324	{ /* not used - just ignore */ }
3284	YY_BREAK	3325	YY_BREAK
3285	case 71:	3326	case 71:
3286	YY_RULE_SETUP	3327	YY_RULE_SETUP
3287	#line 809 "loader.l"	3328	#line 836 "loader.l"
3288	{ /* not used - jsut ignore */ }	3329	{ /* not used - jsut ignore */ }
3289	YY_BREAK	3330	YY_BREAK
3290	case 72:	3331	case 72:
3291	YY_RULE_SETUP	3332	YY_RULE_SETUP
3292	#line 810 "loader.l"	3333	#line 837 "loader.l"
3293	SET_OR_CLEAR_FLAG(op, FLAG_ANIMATE, IVAL);	3334	SET_OR_CLEAR_FLAG(op, FLAG_ANIMATE, IVAL);
3294	YY_BREAK	3335	YY_BREAK
3295	case 73:	3336	case 73:
3296	YY_RULE_SETUP	3337	YY_RULE_SETUP
3297	#line 811 "loader.l"	3338	#line 838 "loader.l"
3298	SET_OR_CLEAR_FLAG(op, FLAG_NO_PICK, IVAL);	3339	SET_OR_CLEAR_FLAG(op, FLAG_NO_PICK, IVAL);
3299	YY_BREAK	3340	YY_BREAK
3300	/* These are all legacy - any new objects should use the move_ .. values */	3341	/* These are all legacy - any new objects should use the move_ .. values */
3301		3342
3302	case 74:	3343	case 74:
3303	YY_RULE_SETUP	3344	YY_RULE_SETUP
3304	#line 815 "loader.l"	3345	#line 842 "loader.l"
3305	{ if (IVAL) op->move_block = MOVE_ALL; else op->move_block=0; }	3346	{ if (IVAL) op->move_block = MOVE_ALL; else op->move_block=0; }
3306	YY_BREAK	3347	YY_BREAK
3307	case 75:	3348	case 75:
3308	YY_RULE_SETUP	3349	YY_RULE_SETUP
3309	#line 816 "loader.l"	3350	#line 843 "loader.l"
3310	{ if (IVAL) op->move_on |= MOVE_WALK; else op->move_on &= ~MOVE_WALK; }	3351	{ if (IVAL) op->move_on |= MOVE_WALK; else op->move_on &= ~MOVE_WALK; }
3311	YY_BREAK	3352	YY_BREAK
3312	case 76:	3353	case 76:
3313	YY_RULE_SETUP	3354	YY_RULE_SETUP
3314	#line 817 "loader.l"	3355	#line 844 "loader.l"
3315	{ if (IVAL) op->move_off |= MOVE_WALK; else op->move_off &= ~MOVE_WALK; }	3356	{ if (IVAL) op->move_off |= MOVE_WALK; else op->move_off &= ~MOVE_WALK; }
3316	YY_BREAK	3357	YY_BREAK
3317	case 77:	3358	case 77:
3318	YY_RULE_SETUP	3359	YY_RULE_SETUP
3319	#line 818 "loader.l"	3360	#line 845 "loader.l"
3320	{ if (IVAL) op->move_on |= MOVE_FLY_LOW; else op->move_on &= ~MOVE_FLY_LOW; }	3361	{ if (IVAL) op->move_on |= MOVE_FLY_LOW; else op->move_on &= ~MOVE_FLY_LOW; }
3321	YY_BREAK	3362	YY_BREAK
3322	case 78:	3363	case 78:
3323	YY_RULE_SETUP	3364	YY_RULE_SETUP
3324	#line 819 "loader.l"	3365	#line 846 "loader.l"
3325	{ if (IVAL) op->move_off |= MOVE_FLY_LOW; else op->move_off &= ~MOVE_FLY_LOW; }	3366	{ if (IVAL) op->move_off |= MOVE_FLY_LOW; else op->move_off &= ~MOVE_FLY_LOW; }
3326	YY_BREAK	3367	YY_BREAK
3327	case 79:	3368	case 79:
3328	YY_RULE_SETUP	3369	YY_RULE_SETUP
3329	#line 820 "loader.l"	3370	#line 847 "loader.l"
3330	{ if (IVAL) op->move_type |= MOVE_FLY_LOW; else op->move_type &= ~MOVE_FLY_LOW; }	3371	{ if (IVAL) op->move_type |= MOVE_FLY_LOW; else op->move_type &= ~MOVE_FLY_LOW; }
3331	YY_BREAK	3372	YY_BREAK
3332	/* These are the new values */	3373	/* These are the new values */
3333		3374
3334	case 80:	3375	case 80:
3335	YY_RULE_SETUP	3376	YY_RULE_SETUP
3336	#line 824 "loader.l"	3377	#line 851 "loader.l"
3337	set_move(&op->move_block, yval());	3378	set_move(&op->move_block, yval());
3338	YY_BREAK	3379	YY_BREAK
3339	case 81:	3380	case 81:
3340	YY_RULE_SETUP	3381	YY_RULE_SETUP
3341	#line 825 "loader.l"	3382	#line 852 "loader.l"
3342	set_move(&op->move_allow, yval());	3383	set_move(&op->move_allow, yval());
3343	YY_BREAK	3384	YY_BREAK
3344	case 82:	3385	case 82:
3345	YY_RULE_SETUP	3386	YY_RULE_SETUP
3346	#line 826 "loader.l"	3387	#line 853 "loader.l"
3347	set_move(&op->move_type, yval());	3388	set_move(&op->move_type, yval());
3348	YY_BREAK	3389	YY_BREAK
3349	case 83:	3390	case 83:
3350	YY_RULE_SETUP	3391	YY_RULE_SETUP
3351	#line 827 "loader.l"	3392	#line 854 "loader.l"
3352	set_move(&op->move_on, yval());	3393	set_move(&op->move_on, yval());
3353	YY_BREAK	3394	YY_BREAK
3354	case 84:	3395	case 84:
3355	YY_RULE_SETUP	3396	YY_RULE_SETUP
3356	#line 828 "loader.l"	3397	#line 855 "loader.l"
3357	set_move(&op->move_off, yval());	3398	set_move(&op->move_off, yval());
3358	YY_BREAK	3399	YY_BREAK
3359	case 85:	3400	case 85:
3360	YY_RULE_SETUP	3401	YY_RULE_SETUP
3361	#line 829 "loader.l"	3402	#line 856 "loader.l"
3362	set_move(&op->move_slow, yval());	3403	set_move(&op->move_slow, yval());
3363	YY_BREAK	3404	YY_BREAK
3364	case 86:	3405	case 86:
3365	YY_RULE_SETUP	3406	YY_RULE_SETUP
3366	#line 830 "loader.l"	3407	#line 857 "loader.l"
3367	op->move_slow_penalty = FVAL;	3408	op->move_slow_penalty = FVAL;
3368	YY_BREAK	3409	YY_BREAK
3369	case 87:	3410	case 87:
3370	YY_RULE_SETUP	3411	YY_RULE_SETUP
3371	#line 833 "loader.l"	3412	#line 860 "loader.l"
3372	SET_OR_CLEAR_FLAG(op, FLAG_MONSTER, IVAL);	3413	SET_OR_CLEAR_FLAG(op, FLAG_MONSTER, IVAL);
3373	YY_BREAK	3414	YY_BREAK
3374	case 88:	3415	case 88:
3375	YY_RULE_SETUP	3416	YY_RULE_SETUP
3376	#line 834 "loader.l"	3417	#line 861 "loader.l"
3377	SET_OR_CLEAR_FLAG(op, FLAG_NEUTRAL, IVAL);	3418	SET_OR_CLEAR_FLAG(op, FLAG_NEUTRAL, IVAL);
3378	YY_BREAK	3419	YY_BREAK
3379	case 89:	3420	case 89:
3380	YY_RULE_SETUP	3421	YY_RULE_SETUP
3381	#line 835 "loader.l"	3422	#line 862 "loader.l"
3382	SET_OR_CLEAR_FLAG(op, FLAG_NO_ATTACK, IVAL);	3423	SET_OR_CLEAR_FLAG(op, FLAG_NO_ATTACK, IVAL);
3383	YY_BREAK	3424	YY_BREAK
3384	case 90:	3425	case 90:
3385	YY_RULE_SETUP	3426	YY_RULE_SETUP
3386	#line 836 "loader.l"	3427	#line 863 "loader.l"
3387	SET_OR_CLEAR_FLAG(op, FLAG_NO_DAMAGE, IVAL);	3428	SET_OR_CLEAR_FLAG(op, FLAG_NO_DAMAGE, IVAL);
3388	YY_BREAK	3429	YY_BREAK
3389	case 91:	3430	case 91:
3390	YY_RULE_SETUP	3431	YY_RULE_SETUP
3391	#line 837 "loader.l"	3432	#line 864 "loader.l"
3392	{ if (IVAL) {	3433	{ if (IVAL) {
3393	SET_FLAG(op, FLAG_FRIENDLY);	3434	SET_FLAG(op, FLAG_FRIENDLY);
3394	if (op->type != PLAYER) {	3435	if (op->type != PLAYER)
3395	LOG(llevDebug," Adding friendly object %s.\n",op->name);
3396	add_friendly_object(op);	3436	add_friendly_object (op);
3397	}
3398	}	3437	}
3399	else CLEAR_FLAG(op, FLAG_FRIENDLY);	3438	else CLEAR_FLAG(op, FLAG_FRIENDLY);
3400	}	3439	}
3401	YY_BREAK	3440	YY_BREAK
3402	case 92:	3441	case 92:
3403	YY_RULE_SETUP	3442	YY_RULE_SETUP
3404	#line 846 "loader.l"	3443	#line 871 "loader.l"
3405	SET_OR_CLEAR_FLAG(op, FLAG_GENERATOR, IVAL);	3444	SET_OR_CLEAR_FLAG(op, FLAG_GENERATOR, IVAL);
3406	YY_BREAK	3445	YY_BREAK
3407	case 93:	3446	case 93:
3408	YY_RULE_SETUP	3447	YY_RULE_SETUP
3409	#line 847 "loader.l"	3448	#line 872 "loader.l"
3410	SET_OR_CLEAR_FLAG (op,FLAG_CONTENT_ON_GEN, IVAL);	3449	SET_OR_CLEAR_FLAG (op,FLAG_CONTENT_ON_GEN, IVAL);
3411	YY_BREAK	3450	YY_BREAK
3412	case 94:	3451	case 94:
3413	YY_RULE_SETUP	3452	YY_RULE_SETUP
3414	#line 848 "loader.l"	3453	#line 873 "loader.l"
3415	SET_OR_CLEAR_FLAG(op, FLAG_IS_THROWN, IVAL);	3454	SET_OR_CLEAR_FLAG(op, FLAG_IS_THROWN, IVAL);
3416	YY_BREAK	3455	YY_BREAK
3417	case 95:	3456	case 95:
3418	YY_RULE_SETUP	3457	YY_RULE_SETUP
3419	#line 849 "loader.l"	3458	#line 874 "loader.l"
3420	SET_OR_CLEAR_FLAG(op, FLAG_AUTO_APPLY, IVAL);	3459	SET_OR_CLEAR_FLAG(op, FLAG_AUTO_APPLY, IVAL);
3421	YY_BREAK	3460	YY_BREAK
3422	case 96:	3461	case 96:
3423	YY_RULE_SETUP	3462	YY_RULE_SETUP
3424	#line 850 "loader.l"	3463	#line 875 "loader.l"
3425	SET_OR_CLEAR_FLAG(op, FLAG_TREASURE, IVAL);	3464	SET_OR_CLEAR_FLAG(op, FLAG_TREASURE, IVAL);
3426	YY_BREAK	3465	YY_BREAK
3427	case 97:	3466	case 97:
3428	YY_RULE_SETUP	3467	YY_RULE_SETUP
3429	#line 851 "loader.l"	3468	#line 876 "loader.l"
3430	SET_OR_CLEAR_FLAG(op, FLAG_SEE_INVISIBLE, IVAL);	3469	SET_OR_CLEAR_FLAG(op, FLAG_SEE_INVISIBLE, IVAL);
3431	YY_BREAK	3470	YY_BREAK
3432	case 98:	3471	case 98:
3433	YY_RULE_SETUP	3472	YY_RULE_SETUP
3434	#line 852 "loader.l"	3473	#line 877 "loader.l"
3435	SET_OR_CLEAR_FLAG(op, FLAG_CAN_ROLL, IVAL);	3474	SET_OR_CLEAR_FLAG(op, FLAG_CAN_ROLL, IVAL);
3436	YY_BREAK	3475	YY_BREAK
3437	case 99:	3476	case 99:
3438	YY_RULE_SETUP	3477	YY_RULE_SETUP
3439	#line 853 "loader.l"	3478	#line 878 "loader.l"
3440	SET_OR_CLEAR_FLAG(op, FLAG_OVERLAY_FLOOR, IVAL);	3479	SET_OR_CLEAR_FLAG(op, FLAG_OVERLAY_FLOOR, IVAL);
3441	YY_BREAK	3480	YY_BREAK
3442	case 100:	3481	case 100:
3443	YY_RULE_SETUP	3482	YY_RULE_SETUP
3444	#line 854 "loader.l"	3483	#line 879 "loader.l"
3445	SET_OR_CLEAR_FLAG(op, FLAG_IS_TURNABLE, IVAL);	3484	SET_OR_CLEAR_FLAG(op, FLAG_IS_TURNABLE, IVAL);
3446	YY_BREAK	3485	YY_BREAK
3447	case 101:	3486	case 101:
3448	YY_RULE_SETUP	3487	YY_RULE_SETUP
3449	#line 855 "loader.l"	3488	#line 880 "loader.l"
3450	SET_OR_CLEAR_FLAG(op, FLAG_IS_USED_UP, IVAL);	3489	SET_OR_CLEAR_FLAG(op, FLAG_IS_USED_UP, IVAL);
3451	YY_BREAK	3490	YY_BREAK
3452	case 102:	3491	case 102:
3453	YY_RULE_SETUP	3492	YY_RULE_SETUP
3454	#line 856 "loader.l"	3493	#line 881 "loader.l"
3455	{ if (IVAL) {	3494	{ if (IVAL) {
3456	SET_FLAG(op, FLAG_IDENTIFIED);	3495	SET_FLAG(op, FLAG_IDENTIFIED);
3457	CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL);	3496	CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL);
3458	}	3497	}
3459	else CLEAR_FLAG(op, FLAG_IDENTIFIED);	3498	else CLEAR_FLAG(op, FLAG_IDENTIFIED);
3460	}	3499	}
3461	YY_BREAK	3500	YY_BREAK
3462	case 103:	3501	case 103:
3463	YY_RULE_SETUP	3502	YY_RULE_SETUP
3464	#line 862 "loader.l"	3503	#line 887 "loader.l"
3465	SET_OR_CLEAR_FLAG(op, FLAG_REFLECTING, IVAL);	3504	SET_OR_CLEAR_FLAG(op, FLAG_REFLECTING, IVAL);
3466	YY_BREAK	3505	YY_BREAK
3467	case 104:	3506	case 104:
3468	YY_RULE_SETUP	3507	YY_RULE_SETUP
3469	#line 863 "loader.l"	3508	#line 888 "loader.l"
3470	SET_OR_CLEAR_FLAG(op, FLAG_CHANGING, IVAL);	3509	SET_OR_CLEAR_FLAG(op, FLAG_CHANGING, IVAL);
3471	YY_BREAK	3510	YY_BREAK
3472	case 105:	3511	case 105:
3473	YY_RULE_SETUP	3512	YY_RULE_SETUP
3474	#line 864 "loader.l"	3513	#line 889 "loader.l"
3475	SET_OR_CLEAR_FLAG(op, FLAG_SPLITTING, IVAL);	3514	SET_OR_CLEAR_FLAG(op, FLAG_SPLITTING, IVAL);
3476	YY_BREAK	3515	YY_BREAK
3477	case 106:	3516	case 106:
3478	YY_RULE_SETUP	3517	YY_RULE_SETUP
3479	#line 865 "loader.l"	3518	#line 890 "loader.l"
3480	SET_OR_CLEAR_FLAG(op, FLAG_HITBACK, IVAL);	3519	SET_OR_CLEAR_FLAG(op, FLAG_HITBACK, IVAL);
3481	YY_BREAK	3520	YY_BREAK
3482	case 107:	3521	case 107:
3483	YY_RULE_SETUP	3522	YY_RULE_SETUP
3484	#line 866 "loader.l"	3523	#line 891 "loader.l"
3485	SET_OR_CLEAR_FLAG(op, FLAG_STARTEQUIP, IVAL);	3524	SET_OR_CLEAR_FLAG(op, FLAG_STARTEQUIP, IVAL);
3486	YY_BREAK	3525	YY_BREAK
3487	case 108:	3526	case 108:
3488	YY_RULE_SETUP	3527	YY_RULE_SETUP
3489	#line 867 "loader.l"	3528	#line 892 "loader.l"
3490	SET_OR_CLEAR_FLAG(op, FLAG_BLOCKSVIEW, IVAL);	3529	SET_OR_CLEAR_FLAG(op, FLAG_BLOCKSVIEW, IVAL);
3491	YY_BREAK	3530	YY_BREAK
3492	case 109:	3531	case 109:
3493	YY_RULE_SETUP	3532	YY_RULE_SETUP
3494	#line 868 "loader.l"	3533	#line 893 "loader.l"
3495	op->arch->editable = IVAL;	3534	op->arch->editable = IVAL;
3496	YY_BREAK	3535	YY_BREAK
3497	case 110:	3536	case 110:
3498	YY_RULE_SETUP	3537	YY_RULE_SETUP
3499	#line 869 "loader.l"	3538	#line 894 "loader.l"
3500	{ }	3539	{ }
3501	YY_BREAK	3540	YY_BREAK
3502	case 111:	3541	case 111:
3503	YY_RULE_SETUP	3542	YY_RULE_SETUP
3504	#line 870 "loader.l"	3543	#line 895 "loader.l"
3505	SET_OR_CLEAR_FLAG(op, FLAG_UNDEAD, IVAL);	3544	SET_OR_CLEAR_FLAG(op, FLAG_UNDEAD, IVAL);
3506	YY_BREAK	3545	YY_BREAK
3507	case 112:	3546	case 112:
3508	YY_RULE_SETUP	3547	YY_RULE_SETUP
3509	#line 871 "loader.l"	3548	#line 896 "loader.l"
3510	SET_OR_CLEAR_FLAG(op, FLAG_SCARED, IVAL);	3549	SET_OR_CLEAR_FLAG(op, FLAG_SCARED, IVAL);
3511	YY_BREAK	3550	YY_BREAK
3512	case 113:	3551	case 113:
3513	YY_RULE_SETUP	3552	YY_RULE_SETUP
3514	#line 872 "loader.l"	3553	#line 897 "loader.l"
3515	SET_OR_CLEAR_FLAG(op, FLAG_UNAGGRESSIVE, IVAL);	3554	SET_OR_CLEAR_FLAG(op, FLAG_UNAGGRESSIVE, IVAL);
3516	YY_BREAK	3555	YY_BREAK
3517	case 114:	3556	case 114:
3518	YY_RULE_SETUP	3557	YY_RULE_SETUP
3519	#line 873 "loader.l"	3558	#line 898 "loader.l"
3520	SET_OR_CLEAR_FLAG(op, FLAG_REFL_MISSILE, IVAL);	3559	SET_OR_CLEAR_FLAG(op, FLAG_REFL_MISSILE, IVAL);
3521	YY_BREAK	3560	YY_BREAK
3522	case 115:	3561	case 115:
3523	YY_RULE_SETUP	3562	YY_RULE_SETUP
3524	#line 874 "loader.l"	3563	#line 899 "loader.l"
3525	SET_OR_CLEAR_FLAG(op, FLAG_REFL_SPELL, IVAL);	3564	SET_OR_CLEAR_FLAG(op, FLAG_REFL_SPELL, IVAL);
3526	YY_BREAK	3565	YY_BREAK
3527	case 116:	3566	case 116:
3528	YY_RULE_SETUP	3567	YY_RULE_SETUP
3529	#line 875 "loader.l"	3568	#line 900 "loader.l"
3530	SET_OR_CLEAR_FLAG(op, FLAG_NO_MAGIC, IVAL);	3569	SET_OR_CLEAR_FLAG(op, FLAG_NO_MAGIC, IVAL);
3531	YY_BREAK	3570	YY_BREAK
3532	case 117:	3571	case 117:
3533	YY_RULE_SETUP	3572	YY_RULE_SETUP
3534	#line 876 "loader.l"	3573	#line 901 "loader.l"
3535	{ if (IVAL) {	3574	{ if (IVAL) {
3536	SET_FLAG(op, FLAG_WIZ);	3575	SET_FLAG(op, FLAG_WIZ);
3537	SET_FLAG(op, FLAG_WAS_WIZ);	3576	SET_FLAG(op, FLAG_WAS_WIZ);
3538	SET_FLAG(op, FLAG_WIZPASS);	3577	SET_FLAG(op, FLAG_WIZPASS);
3539	SET_FLAG(op, FLAG_WIZCAST);	3578	SET_FLAG(op, FLAG_WIZCAST);
…		…
3545	}	3584	}
3546	}	3585	}
3547	YY_BREAK	3586	YY_BREAK
3548	case 118:	3587	case 118:
3549	YY_RULE_SETUP	3588	YY_RULE_SETUP
3550	#line 888 "loader.l"	3589	#line 913 "loader.l"
3551	SET_OR_CLEAR_FLAG(op, FLAG_WAS_WIZ, IVAL);	3590	SET_OR_CLEAR_FLAG(op, FLAG_WAS_WIZ, IVAL);
3552	YY_BREAK	3591	YY_BREAK
3553	case 119:	3592	case 119:
3554	YY_RULE_SETUP	3593	YY_RULE_SETUP
3555	#line 889 "loader.l"	3594	#line 914 "loader.l"
3556	SET_OR_CLEAR_FLAG(op, FLAG_NO_FIX_PLAYER, IVAL);	3595	SET_OR_CLEAR_FLAG(op, FLAG_NO_FIX_PLAYER, IVAL);
3557	YY_BREAK	3596	YY_BREAK
3558	case 120:	3597	case 120:
3559	YY_RULE_SETUP	3598	YY_RULE_SETUP
3560	#line 890 "loader.l"	3599	#line 915 "loader.l"
3561	SET_OR_CLEAR_FLAG(op, FLAG_IS_LIGHTABLE, IVAL);	3600	SET_OR_CLEAR_FLAG(op, FLAG_IS_LIGHTABLE, IVAL);
3562	YY_BREAK	3601	YY_BREAK
3563	case 121:	3602	case 121:
3564	YY_RULE_SETUP	3603	YY_RULE_SETUP
3565	#line 891 "loader.l"	3604	#line 916 "loader.l"
3566	SET_OR_CLEAR_FLAG(op, FLAG_TEAR_DOWN, IVAL);	3605	SET_OR_CLEAR_FLAG(op, FLAG_TEAR_DOWN, IVAL);
3567	YY_BREAK	3606	YY_BREAK
3568	case 122:	3607	case 122:
3569	YY_RULE_SETUP	3608	YY_RULE_SETUP
3570	#line 892 "loader.l"	3609	#line 917 "loader.l"
3571	op->stats.luck = IVAL;	3610	op->stats.luck = IVAL;
3572	YY_BREAK	3611	YY_BREAK
3573	case 123:	3612	case 123:
3574	YY_RULE_SETUP	3613	YY_RULE_SETUP
3575	#line 893 "loader.l"	3614	#line 918 "loader.l"
3576	op->run_away = IVAL;	3615	op->run_away = IVAL;
3577	YY_BREAK	3616	YY_BREAK
3578	case 124:	3617	case 124:
3579	YY_RULE_SETUP	3618	YY_RULE_SETUP
3580	#line 894 "loader.l"	3619	#line 919 "loader.l"
3581	op->pick_up = IVAL;	3620	op->pick_up = IVAL;
3582	YY_BREAK	3621	YY_BREAK
3583	case 125:	3622	case 125:
3584	YY_RULE_SETUP	3623	YY_RULE_SETUP
3585	#line 895 "loader.l"	3624	#line 920 "loader.l"
3586	op->item_power = IVAL;	3625	op->item_power = IVAL;
3587	YY_BREAK	3626	YY_BREAK
3588	case 126:	3627	case 126:
3589	YY_RULE_SETUP	3628	YY_RULE_SETUP
3590	#line 896 "loader.l"	3629	#line 921 "loader.l"
3591	op->gen_sp_armour = IVAL;	3630	op->gen_sp_armour = IVAL;
3592	YY_BREAK	3631	YY_BREAK
3593	case 127:	3632	case 127:
3594	YY_RULE_SETUP	3633	YY_RULE_SETUP
3595	#line 897 "loader.l"	3634	#line 922 "loader.l"
3596	op->anim_speed = IVAL;	3635	op->anim_speed = IVAL;
3597	YY_BREAK	3636	YY_BREAK
3598	case 128:	3637	case 128:
3599	YY_RULE_SETUP	3638	YY_RULE_SETUP
3600	#line 898 "loader.l"	3639	#line 923 "loader.l"
3601	op->weight_limit = IVAL;	3640	op->weight_limit = IVAL;
3602	YY_BREAK	3641	YY_BREAK
3603	case 129:	3642	case 129:
3604	YY_RULE_SETUP	3643	YY_RULE_SETUP
3605	#line 899 "loader.l"	3644	#line 924 "loader.l"
3606	SET_OR_CLEAR_FLAG(op, FLAG_NO_DROP, IVAL);	3645	SET_OR_CLEAR_FLAG(op, FLAG_NO_DROP, IVAL);
3607	YY_BREAK	3646	YY_BREAK
3608	case 130:	3647	case 130:
3609	YY_RULE_SETUP	3648	YY_RULE_SETUP
3610	#line 900 "loader.l"	3649	#line 925 "loader.l"
3611	op->will_apply = IVAL;	3650	op->will_apply = IVAL;
3612	YY_BREAK	3651	YY_BREAK
3613	case 131:	3652	case 131:
3614	YY_RULE_SETUP	3653	YY_RULE_SETUP
3615	#line 901 "loader.l"	3654	#line 926 "loader.l"
3616	SET_OR_CLEAR_FLAG(op, FLAG_RANDOM_MOVE, IVAL);	3655	SET_OR_CLEAR_FLAG(op, FLAG_RANDOM_MOVE, IVAL);
3617	YY_BREAK	3656	YY_BREAK
3618	case 132:	3657	case 132:
3619	YY_RULE_SETUP	3658	YY_RULE_SETUP
3620	#line 902 "loader.l"	3659	#line 927 "loader.l"
3621	{ }	3660	{ }
3622	YY_BREAK	3661	YY_BREAK
3623	case 133:	3662	case 133:
3624	YY_RULE_SETUP	3663	YY_RULE_SETUP
3625	#line 903 "loader.l"	3664	#line 928 "loader.l"
3626	SET_OR_CLEAR_FLAG(op, FLAG_USE_SHIELD, IVAL);	3665	SET_OR_CLEAR_FLAG(op, FLAG_USE_SHIELD, IVAL);
3627	YY_BREAK	3666	YY_BREAK
3628	case 134:	3667	case 134:
3629	YY_RULE_SETUP	3668	YY_RULE_SETUP
3630	#line 904 "loader.l"	3669	#line 929 "loader.l"
3631	SET_OR_CLEAR_FLAG(op, FLAG_CAST_SPELL, IVAL);	3670	SET_OR_CLEAR_FLAG(op, FLAG_CAST_SPELL, IVAL);
3632	YY_BREAK	3671	YY_BREAK
3633	case 135:	3672	case 135:
3634	YY_RULE_SETUP	3673	YY_RULE_SETUP
3635	#line 905 "loader.l"	3674	#line 930 "loader.l"
3636	SET_OR_CLEAR_FLAG(op, FLAG_USE_SCROLL, IVAL);	3675	SET_OR_CLEAR_FLAG(op, FLAG_USE_SCROLL, IVAL);
3637	YY_BREAK	3676	YY_BREAK
3638	case 136:	3677	case 136:
3639	YY_RULE_SETUP	3678	YY_RULE_SETUP
3640	#line 906 "loader.l"	3679	#line 931 "loader.l"
3641	SET_OR_CLEAR_FLAG(op, FLAG_USE_RANGE, IVAL);	3680	SET_OR_CLEAR_FLAG(op, FLAG_USE_RANGE, IVAL);
3642	YY_BREAK	3681	YY_BREAK
3643	case 137:	3682	case 137:
3644	YY_RULE_SETUP	3683	YY_RULE_SETUP
3645	#line 907 "loader.l"	3684	#line 932 "loader.l"
3646	SET_OR_CLEAR_FLAG(op, FLAG_USE_BOW, IVAL);	3685	SET_OR_CLEAR_FLAG(op, FLAG_USE_BOW, IVAL);
3647	YY_BREAK	3686	YY_BREAK
3648	case 138:	3687	case 138:
3649	YY_RULE_SETUP	3688	YY_RULE_SETUP
3650	#line 908 "loader.l"	3689	#line 933 "loader.l"
3651	SET_OR_CLEAR_FLAG(op, FLAG_USE_ARMOUR, IVAL);	3690	SET_OR_CLEAR_FLAG(op, FLAG_USE_ARMOUR, IVAL);
3652	YY_BREAK	3691	YY_BREAK
3653	case 139:	3692	case 139:
3654	YY_RULE_SETUP	3693	YY_RULE_SETUP
3655	#line 909 "loader.l"	3694	#line 934 "loader.l"
3656	SET_OR_CLEAR_FLAG(op, FLAG_USE_WEAPON, IVAL);	3695	SET_OR_CLEAR_FLAG(op, FLAG_USE_WEAPON, IVAL);
3657	YY_BREAK	3696	YY_BREAK
3658	case 140:	3697	case 140:
3659	YY_RULE_SETUP	3698	YY_RULE_SETUP
3660	#line 910 "loader.l"	3699	#line 935 "loader.l"
3661	SET_OR_CLEAR_FLAG(op, FLAG_USE_RING, IVAL);	3700	SET_OR_CLEAR_FLAG(op, FLAG_USE_RING, IVAL);
3662	YY_BREAK	3701	YY_BREAK
3663	case 141:	3702	case 141:
3664	YY_RULE_SETUP	3703	YY_RULE_SETUP
3665	#line 911 "loader.l"	3704	#line 936 "loader.l"
3666	SET_OR_CLEAR_FLAG(op, FLAG_READY_BOW, IVAL);	3705	SET_OR_CLEAR_FLAG(op, FLAG_READY_BOW, IVAL);
3667	YY_BREAK	3706	YY_BREAK
3668	case 142:	3707	case 142:
3669	YY_RULE_SETUP	3708	YY_RULE_SETUP
3670	#line 912 "loader.l"	3709	#line 937 "loader.l"
3671	SET_OR_CLEAR_FLAG(op, FLAG_XRAYS, IVAL);	3710	SET_OR_CLEAR_FLAG(op, FLAG_XRAYS, IVAL);
3672	YY_BREAK	3711	YY_BREAK
3673	case 143:	3712	case 143:
3674	YY_RULE_SETUP	3713	YY_RULE_SETUP
3675	#line 913 "loader.l"	3714	#line 938 "loader.l"
3676	SET_OR_CLEAR_FLAG(op, FLAG_IS_FLOOR, IVAL);	3715	SET_OR_CLEAR_FLAG(op, FLAG_IS_FLOOR, IVAL);
3677	YY_BREAK	3716	YY_BREAK
3678	case 144:	3717	case 144:
3679	YY_RULE_SETUP	3718	YY_RULE_SETUP
3680	#line 914 "loader.l"	3719	#line 939 "loader.l"
3681	SET_OR_CLEAR_FLAG(op, FLAG_LIFESAVE, IVAL);	3720	SET_OR_CLEAR_FLAG(op, FLAG_LIFESAVE, IVAL);
3682	YY_BREAK	3721	YY_BREAK
3683	case 145:	3722	case 145:
3684	YY_RULE_SETUP	3723	YY_RULE_SETUP
3685	#line 915 "loader.l"	3724	#line 940 "loader.l"
3686	SET_OR_CLEAR_FLAG(op, FLAG_NO_STRENGTH, IVAL);	3725	SET_OR_CLEAR_FLAG(op, FLAG_NO_STRENGTH, IVAL);
3687	YY_BREAK	3726	YY_BREAK
3688	case 146:	3727	case 146:
3689	YY_RULE_SETUP	3728	YY_RULE_SETUP
3690	#line 916 "loader.l"	3729	#line 941 "loader.l"
3691	{	3730	{
3692	SET_OR_CLEAR_FLAG(op, FLAG_SLEEP, IVAL);	3731	SET_OR_CLEAR_FLAG(op, FLAG_SLEEP, IVAL);
3693	/*(LOG(llevDebug," Warning: Object %s has sleep set in arch.\n",op->name);*/	3732	/*(LOG(llevDebug," Warning: Object %s has sleep set in arch.\n",op->name);*/
3694	}	3733	}
3695	YY_BREAK	3734	YY_BREAK
3696	case 147:	3735	case 147:
3697	YY_RULE_SETUP	3736	YY_RULE_SETUP
3698	#line 920 "loader.l"	3737	#line 945 "loader.l"
3699	SET_OR_CLEAR_FLAG(op, FLAG_STAND_STILL, IVAL);	3738	SET_OR_CLEAR_FLAG(op, FLAG_STAND_STILL, IVAL);
3700	YY_BREAK	3739	YY_BREAK
3701	case 148:	3740	case 148:
3702	YY_RULE_SETUP	3741	YY_RULE_SETUP
3703	#line 921 "loader.l"	3742	#line 946 "loader.l"
3704	SET_OR_CLEAR_FLAG(op, FLAG_RANDOM_MOVE, IVAL);	3743	SET_OR_CLEAR_FLAG(op, FLAG_RANDOM_MOVE, IVAL);
3705	YY_BREAK	3744	YY_BREAK
3706	case 149:	3745	case 149:
3707	YY_RULE_SETUP	3746	YY_RULE_SETUP
3708	#line 922 "loader.l"	3747	#line 947 "loader.l"
3709	SET_OR_CLEAR_FLAG(op, FLAG_ONLY_ATTACK, IVAL);	3748	SET_OR_CLEAR_FLAG(op, FLAG_ONLY_ATTACK, IVAL);
3710	YY_BREAK	3749	YY_BREAK
3711	case 150:	3750	case 150:
3712	YY_RULE_SETUP	3751	YY_RULE_SETUP
3713	#line 924 "loader.l"	3752	#line 949 "loader.l"
3714	SET_OR_CLEAR_FLAG(op, FLAG_ACTIVATE_ON_PUSH, IVAL);	3753	SET_OR_CLEAR_FLAG(op, FLAG_ACTIVATE_ON_PUSH, IVAL);
3715	YY_BREAK	3754	YY_BREAK
3716	case 151:	3755	case 151:
3717	YY_RULE_SETUP	3756	YY_RULE_SETUP
3718	#line 925 "loader.l"	3757	#line 950 "loader.l"
3719	SET_OR_CLEAR_FLAG(op, FLAG_ACTIVATE_ON_RELEASE, IVAL);	3758	SET_OR_CLEAR_FLAG(op, FLAG_ACTIVATE_ON_RELEASE, IVAL);
3720	YY_BREAK	3759	YY_BREAK
3721	/* armour is loaded for compatiblity reasons */	3760	/* armour is loaded for compatiblity reasons */
3722	case 152:	3761	case 152:
3723	YY_RULE_SETUP	3762	YY_RULE_SETUP
3724	#line 928 "loader.l"	3763	#line 953 "loader.l"
3725	SET_RESIST(op, ATNR_PHYSICAL, IVAL);	3764	SET_RESIST(op, ATNR_PHYSICAL, IVAL);
3726	YY_BREAK	3765	YY_BREAK
3727	/* Start of various attacktypes */	3766	/* Start of various attacktypes */
3728	case 153:	3767	case 153:
3729	YY_RULE_SETUP	3768	YY_RULE_SETUP
3730	#line 930 "loader.l"	3769	#line 955 "loader.l"
3731	SET_RESIST(op, ATNR_PHYSICAL, IVAL);	3770	SET_RESIST(op, ATNR_PHYSICAL, IVAL);
3732	YY_BREAK	3771	YY_BREAK
3733	case 154:	3772	case 154:
3734	YY_RULE_SETUP	3773	YY_RULE_SETUP
3735	#line 931 "loader.l"	3774	#line 956 "loader.l"
3736	SET_RESIST(op, ATNR_MAGIC, IVAL);	3775	SET_RESIST(op, ATNR_MAGIC, IVAL);
3737	YY_BREAK	3776	YY_BREAK
3738	case 155:	3777	case 155:
3739	YY_RULE_SETUP	3778	YY_RULE_SETUP
3740	#line 932 "loader.l"	3779	#line 957 "loader.l"
3741	SET_RESIST(op, ATNR_FIRE, IVAL);	3780	SET_RESIST(op, ATNR_FIRE, IVAL);
3742	YY_BREAK	3781	YY_BREAK
3743	case 156:	3782	case 156:
3744	YY_RULE_SETUP	3783	YY_RULE_SETUP
3745	#line 933 "loader.l"	3784	#line 958 "loader.l"
3746	SET_RESIST(op, ATNR_ELECTRICITY, IVAL);	3785	SET_RESIST(op, ATNR_ELECTRICITY, IVAL);
3747	YY_BREAK	3786	YY_BREAK
3748	case 157:	3787	case 157:
3749	YY_RULE_SETUP	3788	YY_RULE_SETUP
3750	#line 934 "loader.l"	3789	#line 959 "loader.l"
3751	SET_RESIST(op, ATNR_COLD, IVAL);	3790	SET_RESIST(op, ATNR_COLD, IVAL);
3752	YY_BREAK	3791	YY_BREAK
3753	case 158:	3792	case 158:
3754	YY_RULE_SETUP	3793	YY_RULE_SETUP
3755	#line 935 "loader.l"	3794	#line 960 "loader.l"
3756	SET_RESIST(op, ATNR_CONFUSION, IVAL);	3795	SET_RESIST(op, ATNR_CONFUSION, IVAL);
3757	YY_BREAK	3796	YY_BREAK
3758	case 159:	3797	case 159:
3759	YY_RULE_SETUP	3798	YY_RULE_SETUP
3760	#line 936 "loader.l"	3799	#line 961 "loader.l"
3761	SET_RESIST(op, ATNR_ACID, IVAL);	3800	SET_RESIST(op, ATNR_ACID, IVAL);
3762	YY_BREAK	3801	YY_BREAK
3763	case 160:	3802	case 160:
3764	YY_RULE_SETUP	3803	YY_RULE_SETUP
3765	#line 937 "loader.l"	3804	#line 962 "loader.l"
3766	SET_RESIST(op, ATNR_DRAIN, IVAL);	3805	SET_RESIST(op, ATNR_DRAIN, IVAL);
3767	YY_BREAK	3806	YY_BREAK
3768	case 161:	3807	case 161:
3769	YY_RULE_SETUP	3808	YY_RULE_SETUP
3770	#line 938 "loader.l"	3809	#line 963 "loader.l"
3771	SET_RESIST(op, ATNR_WEAPONMAGIC, IVAL);	3810	SET_RESIST(op, ATNR_WEAPONMAGIC, IVAL);
3772	YY_BREAK	3811	YY_BREAK
3773	case 162:	3812	case 162:
3774	YY_RULE_SETUP	3813	YY_RULE_SETUP
3775	#line 939 "loader.l"	3814	#line 964 "loader.l"
3776	SET_RESIST(op, ATNR_GHOSTHIT, IVAL);	3815	SET_RESIST(op, ATNR_GHOSTHIT, IVAL);
3777	YY_BREAK	3816	YY_BREAK
3778	case 163:	3817	case 163:
3779	YY_RULE_SETUP	3818	YY_RULE_SETUP
3780	#line 940 "loader.l"	3819	#line 965 "loader.l"
3781	SET_RESIST(op, ATNR_POISON, IVAL);	3820	SET_RESIST(op, ATNR_POISON, IVAL);
3782	YY_BREAK	3821	YY_BREAK
3783	case 164:	3822	case 164:
3784	YY_RULE_SETUP	3823	YY_RULE_SETUP
3785	#line 941 "loader.l"	3824	#line 966 "loader.l"
3786	SET_RESIST(op, ATNR_SLOW, IVAL);	3825	SET_RESIST(op, ATNR_SLOW, IVAL);
3787	YY_BREAK	3826	YY_BREAK
3788	case 165:	3827	case 165:
3789	YY_RULE_SETUP	3828	YY_RULE_SETUP
3790	#line 942 "loader.l"	3829	#line 967 "loader.l"
3791	SET_RESIST(op, ATNR_PARALYZE, IVAL);	3830	SET_RESIST(op, ATNR_PARALYZE, IVAL);
3792	YY_BREAK	3831	YY_BREAK
3793	case 166:	3832	case 166:
3794	YY_RULE_SETUP	3833	YY_RULE_SETUP
3795	#line 943 "loader.l"	3834	#line 968 "loader.l"
3796	SET_RESIST(op, ATNR_TURN_UNDEAD, IVAL);	3835	SET_RESIST(op, ATNR_TURN_UNDEAD, IVAL);
3797	YY_BREAK	3836	YY_BREAK
3798	case 167:	3837	case 167:
3799	YY_RULE_SETUP	3838	YY_RULE_SETUP
3800	#line 944 "loader.l"	3839	#line 969 "loader.l"
3801	SET_RESIST(op, ATNR_FEAR, IVAL);	3840	SET_RESIST(op, ATNR_FEAR, IVAL);
3802	YY_BREAK	3841	YY_BREAK
3803	case 168:	3842	case 168:
3804	YY_RULE_SETUP	3843	YY_RULE_SETUP
3805	#line 945 "loader.l"	3844	#line 970 "loader.l"
3806	SET_RESIST(op, ATNR_CANCELLATION, IVAL);	3845	SET_RESIST(op, ATNR_CANCELLATION, IVAL);
3807	YY_BREAK	3846	YY_BREAK
3808	case 169:	3847	case 169:
3809	YY_RULE_SETUP	3848	YY_RULE_SETUP
3810	#line 946 "loader.l"	3849	#line 971 "loader.l"
3811	SET_RESIST(op, ATNR_DEPLETE, IVAL);	3850	SET_RESIST(op, ATNR_DEPLETE, IVAL);
3812	YY_BREAK	3851	YY_BREAK
3813	case 170:	3852	case 170:
3814	YY_RULE_SETUP	3853	YY_RULE_SETUP
3815	#line 947 "loader.l"	3854	#line 972 "loader.l"
3816	SET_RESIST(op, ATNR_DEATH, IVAL);	3855	SET_RESIST(op, ATNR_DEATH, IVAL);
3817	YY_BREAK	3856	YY_BREAK
3818	case 171:	3857	case 171:
3819	YY_RULE_SETUP	3858	YY_RULE_SETUP
3820	#line 948 "loader.l"	3859	#line 973 "loader.l"
3821	SET_RESIST(op, ATNR_CHAOS, IVAL);	3860	SET_RESIST(op, ATNR_CHAOS, IVAL);
3822	YY_BREAK	3861	YY_BREAK
3823	case 172:	3862	case 172:
3824	YY_RULE_SETUP	3863	YY_RULE_SETUP
3825	#line 949 "loader.l"	3864	#line 974 "loader.l"
3826	SET_RESIST(op, ATNR_COUNTERSPELL, IVAL);	3865	SET_RESIST(op, ATNR_COUNTERSPELL, IVAL);
3827	YY_BREAK	3866	YY_BREAK
3828	case 173:	3867	case 173:
3829	YY_RULE_SETUP	3868	YY_RULE_SETUP
3830	#line 950 "loader.l"	3869	#line 975 "loader.l"
3831	SET_RESIST(op, ATNR_GODPOWER, IVAL);	3870	SET_RESIST(op, ATNR_GODPOWER, IVAL);
3832	YY_BREAK	3871	YY_BREAK
3833	case 174:	3872	case 174:
3834	YY_RULE_SETUP	3873	YY_RULE_SETUP
3835	#line 951 "loader.l"	3874	#line 976 "loader.l"
3836	SET_RESIST(op, ATNR_HOLYWORD, IVAL);	3875	SET_RESIST(op, ATNR_HOLYWORD, IVAL);
3837	YY_BREAK	3876	YY_BREAK
3838	case 175:	3877	case 175:
3839	YY_RULE_SETUP	3878	YY_RULE_SETUP
3840	#line 952 "loader.l"	3879	#line 977 "loader.l"
3841	SET_RESIST(op, ATNR_BLIND, IVAL);	3880	SET_RESIST(op, ATNR_BLIND, IVAL);
3842	YY_BREAK	3881	YY_BREAK
3843	case 176:	3882	case 176:
3844	YY_RULE_SETUP	3883	YY_RULE_SETUP
3845	#line 953 "loader.l"	3884	#line 978 "loader.l"
3846	SET_RESIST(op, ATNR_INTERNAL, IVAL);	3885	SET_RESIST(op, ATNR_INTERNAL, IVAL);
3847	YY_BREAK	3886	YY_BREAK
3848	case 177:	3887	case 177:
3849	YY_RULE_SETUP	3888	YY_RULE_SETUP
3850	#line 954 "loader.l"	3889	#line 979 "loader.l"
3851	SET_RESIST(op, ATNR_LIFE_STEALING, IVAL);	3890	SET_RESIST(op, ATNR_LIFE_STEALING, IVAL);
3852	YY_BREAK	3891	YY_BREAK
3853	case 178:	3892	case 178:
3854	YY_RULE_SETUP	3893	YY_RULE_SETUP
3855	#line 955 "loader.l"	3894	#line 980 "loader.l"
3856	SET_RESIST(op, ATNR_DISEASE, IVAL);	3895	SET_RESIST(op, ATNR_DISEASE, IVAL);
3857	YY_BREAK	3896	YY_BREAK
3858	/* Old style resistances */	3897	/* Old style resistances */
3859	case 179:	3898	case 179:
3860	YY_RULE_SETUP	3899	YY_RULE_SETUP
3861	#line 958 "loader.l"	3900	#line 983 "loader.l"
3862	set_protection(op, IVAL, RESIST_IMMUNE);	3901	set_protection(op, IVAL, RESIST_IMMUNE);
3863	YY_BREAK	3902	YY_BREAK
3864	case 180:	3903	case 180:
3865	YY_RULE_SETUP	3904	YY_RULE_SETUP
3866	#line 959 "loader.l"	3905	#line 984 "loader.l"
3867	set_protection(op, IVAL, RESIST_PROT);	3906	set_protection(op, IVAL, RESIST_PROT);
3868	YY_BREAK	3907	YY_BREAK
3869	case 181:	3908	case 181:
3870	YY_RULE_SETUP	3909	YY_RULE_SETUP
3871	#line 960 "loader.l"	3910	#line 985 "loader.l"
3872	set_protection(op, IVAL, RESIST_VULN);	3911	set_protection(op, IVAL, RESIST_VULN);
3873	YY_BREAK	3912	YY_BREAK
3874	/* old values - keep them around for now, but they should be removed at some point */	3913	/* old values - keep them around for now, but they should be removed at some point */
3875	case 182:	3914	case 182:
3876	YY_RULE_SETUP	3915	YY_RULE_SETUP
3877	#line 963 "loader.l"	3916	#line 988 "loader.l"
3878	SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);	3917	SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);
3879	YY_BREAK	3918	YY_BREAK
3880	case 183:	3919	case 183:
3881	YY_RULE_SETUP	3920	YY_RULE_SETUP
3882	#line 964 "loader.l"	3921	#line 989 "loader.l"
3883	SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);	3922	SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);
3884	YY_BREAK	3923	YY_BREAK
3885	case 184:	3924	case 184:
3886	YY_RULE_SETUP	3925	YY_RULE_SETUP
3887	#line 965 "loader.l"	3926	#line 990 "loader.l"
3888	SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);	3927	SET_OR_CLEAR_FLAG(op, FLAG_READY_RANGE, IVAL);
3889	YY_BREAK	3928	YY_BREAK
3890	case 185:	3929	case 185:
3891	YY_RULE_SETUP	3930	YY_RULE_SETUP
3892	#line 966 "loader.l"	3931	#line 991 "loader.l"
3893	SET_OR_CLEAR_FLAG(op, FLAG_USE_RANGE, IVAL);	3932	SET_OR_CLEAR_FLAG(op, FLAG_USE_RANGE, IVAL);
3894	YY_BREAK	3933	YY_BREAK
3895	case 186:	3934	case 186:
3896	YY_RULE_SETUP	3935	YY_RULE_SETUP
3897	#line 968 "loader.l"	3936	#line 993 "loader.l"
3898	op->attack_movement = IVAL;	3937	op->attack_movement = IVAL;
3899	YY_BREAK	3938	YY_BREAK
3900	case 187:	3939	case 187:
3901	YY_RULE_SETUP	3940	YY_RULE_SETUP
3902	#line 969 "loader.l"	3941	#line 994 "loader.l"
3903	op->move_status = IVAL;	3942	op->move_status = IVAL;
3904	YY_BREAK	3943	YY_BREAK
3905	case 188:	3944	case 188:
3906	YY_RULE_SETUP	3945	YY_RULE_SETUP
3907	#line 970 "loader.l"	3946	#line 995 "loader.l"
3908	SET_OR_CLEAR_FLAG(op, FLAG_CONFUSED, IVAL);	3947	SET_OR_CLEAR_FLAG(op, FLAG_CONFUSED, IVAL);
3909	YY_BREAK	3948	YY_BREAK
3910	case 189:	3949	case 189:
3911	YY_RULE_SETUP	3950	YY_RULE_SETUP
3912	#line 971 "loader.l"	3951	#line 996 "loader.l"
3913	SET_OR_CLEAR_FLAG(op, FLAG_STEALTH, IVAL);	3952	SET_OR_CLEAR_FLAG(op, FLAG_STEALTH, IVAL);
3914	YY_BREAK	3953	YY_BREAK
3915	case 190:	3954	case 190:
3916	YY_RULE_SETUP	3955	YY_RULE_SETUP
3917	#line 972 "loader.l"	3956	#line 997 "loader.l"
3918	add_button_link(op, op->map, IVAL);	3957	add_button_link(op, op->map, IVAL);
3919	YY_BREAK	3958	YY_BREAK
3920	case 191:	3959	case 191:
3921	YY_RULE_SETUP	3960	YY_RULE_SETUP
3922	#line 973 "loader.l"	3961	#line 998 "loader.l"
3923	SET_OR_CLEAR_FLAG(op, FLAG_CURSED, IVAL);	3962	SET_OR_CLEAR_FLAG(op, FLAG_CURSED, IVAL);
3924	YY_BREAK	3963	YY_BREAK
3925	case 192:	3964	case 192:
3926	YY_RULE_SETUP	3965	YY_RULE_SETUP
3927	#line 974 "loader.l"	3966	#line 999 "loader.l"
3928	SET_OR_CLEAR_FLAG(op, FLAG_DAMNED, IVAL);	3967	SET_OR_CLEAR_FLAG(op, FLAG_DAMNED, IVAL);
3929	YY_BREAK	3968	YY_BREAK
3930	case 193:	3969	case 193:
3931	YY_RULE_SETUP	3970	YY_RULE_SETUP
3932	#line 975 "loader.l"	3971	#line 1000 "loader.l"
3933	SET_OR_CLEAR_FLAG(op, FLAG_SEE_ANYWHERE, IVAL);	3972	SET_OR_CLEAR_FLAG(op, FLAG_SEE_ANYWHERE, IVAL);
3934	YY_BREAK	3973	YY_BREAK
3935	case 194:	3974	case 194:
3936	YY_RULE_SETUP	3975	YY_RULE_SETUP
3937	#line 976 "loader.l"	3976	#line 1001 "loader.l"
3938	SET_OR_CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL, IVAL);	3977	SET_OR_CLEAR_FLAG(op, FLAG_KNOWN_MAGICAL, IVAL);
3939	YY_BREAK	3978	YY_BREAK
3940	case 195:	3979	case 195:
3941	YY_RULE_SETUP	3980	YY_RULE_SETUP
3942	#line 977 "loader.l"	3981	#line 1002 "loader.l"
3943	SET_OR_CLEAR_FLAG(op, FLAG_KNOWN_CURSED, IVAL);	3982	SET_OR_CLEAR_FLAG(op, FLAG_KNOWN_CURSED, IVAL);
3944	YY_BREAK	3983	YY_BREAK
3945	case 196:	3984	case 196:
3946	YY_RULE_SETUP	3985	YY_RULE_SETUP
3947	#line 978 "loader.l"	3986	#line 1003 "loader.l"
3948	SET_OR_CLEAR_FLAG(op, FLAG_CAN_USE_SKILL, IVAL);	3987	SET_OR_CLEAR_FLAG(op, FLAG_CAN_USE_SKILL, IVAL);
3949	YY_BREAK	3988	YY_BREAK
3950	case 197:	3989	case 197:
3951	YY_RULE_SETUP	3990	YY_RULE_SETUP
3952	#line 979 "loader.l"	3991	#line 1004 "loader.l"
3953	SET_OR_CLEAR_FLAG(op, FLAG_BEEN_APPLIED, IVAL);	3992	SET_OR_CLEAR_FLAG(op, FLAG_BEEN_APPLIED, IVAL);
3954	YY_BREAK	3993	YY_BREAK
3955	case 198:	3994	case 198:
3956	YY_RULE_SETUP	3995	YY_RULE_SETUP
3957	#line 980 "loader.l"	3996	#line 1005 "loader.l"
3958	SET_OR_CLEAR_FLAG(op, FLAG_READY_SCROLL, IVAL);	3997	SET_OR_CLEAR_FLAG(op, FLAG_READY_SCROLL, IVAL);
3959	YY_BREAK	3998	YY_BREAK
3960	case 199:	3999	case 199:
3961	YY_RULE_SETUP	4000	YY_RULE_SETUP
3962	#line 981 "loader.l"	4001	#line 1006 "loader.l"
3963	SET_OR_CLEAR_FLAG(op, FLAG_USE_ROD, IVAL);	4002	SET_OR_CLEAR_FLAG(op, FLAG_USE_ROD, IVAL);
3964	YY_BREAK	4003	YY_BREAK
3965	case 200:	4004	case 200:
3966	YY_RULE_SETUP	4005	YY_RULE_SETUP
3967	#line 982 "loader.l"	4006	#line 1007 "loader.l"
3968	SET_OR_CLEAR_FLAG(op, FLAG_USE_HORN, IVAL);	4007	SET_OR_CLEAR_FLAG(op, FLAG_USE_HORN, IVAL);
3969	YY_BREAK	4008	YY_BREAK
3970	case 201:	4009	case 201:
3971	YY_RULE_SETUP	4010	YY_RULE_SETUP
3972	#line 983 "loader.l"	4011	#line 1008 "loader.l"
3973	op->expmul = FVAL;	4012	op->expmul = FVAL;
3974	YY_BREAK	4013	YY_BREAK
3975	case 202:	4014	case 202:
3976	YY_RULE_SETUP	4015	YY_RULE_SETUP
3977	#line 984 "loader.l"	4016	#line 1009 "loader.l"
3978	SET_OR_CLEAR_FLAG(op, FLAG_UNIQUE, IVAL);	4017	SET_OR_CLEAR_FLAG(op, FLAG_UNIQUE, IVAL);
3979	YY_BREAK	4018	YY_BREAK
3980	case 203:	4019	case 203:
3981	YY_RULE_SETUP	4020	YY_RULE_SETUP
3982	#line 985 "loader.l"	4021	#line 1010 "loader.l"
3983	SET_OR_CLEAR_FLAG(op, FLAG_MAKE_INVIS, IVAL);	4022	SET_OR_CLEAR_FLAG(op, FLAG_MAKE_INVIS, IVAL);
3984	YY_BREAK	4023	YY_BREAK
3985	case 204:	4024	case 204:
3986	YY_RULE_SETUP	4025	YY_RULE_SETUP
3987	#line 986 "loader.l"	4026	#line 1011 "loader.l"
3988	SET_OR_CLEAR_FLAG(op, FLAG_INV_LOCKED, IVAL);	4027	SET_OR_CLEAR_FLAG(op, FLAG_INV_LOCKED, IVAL);
3989	YY_BREAK	4028	YY_BREAK
3990	case 205:	4029	case 205:
3991	YY_RULE_SETUP	4030	YY_RULE_SETUP
3992	#line 987 "loader.l"	4031	#line 1012 "loader.l"
3993	SET_OR_CLEAR_FLAG(op, FLAG_IS_WOODED, IVAL);	4032	SET_OR_CLEAR_FLAG(op, FLAG_IS_WOODED, IVAL);
3994	YY_BREAK	4033	YY_BREAK
3995	case 206:	4034	case 206:
3996	YY_RULE_SETUP	4035	YY_RULE_SETUP
3997	#line 988 "loader.l"	4036	#line 1013 "loader.l"
3998	SET_OR_CLEAR_FLAG(op, FLAG_IS_HILLY, IVAL);	4037	SET_OR_CLEAR_FLAG(op, FLAG_IS_HILLY, IVAL);
3999	YY_BREAK	4038	YY_BREAK
4000	case 207:	4039	case 207:
4001	YY_RULE_SETUP	4040	YY_RULE_SETUP
4002	#line 989 "loader.l"	4041	#line 1014 "loader.l"
4003	SET_OR_CLEAR_FLAG(op, FLAG_IS_WATER, IVAL);	4042	SET_OR_CLEAR_FLAG(op, FLAG_IS_WATER, IVAL);
4004	YY_BREAK	4043	YY_BREAK
4005	case 208:	4044	case 208:
4006	YY_RULE_SETUP	4045	YY_RULE_SETUP
4007	#line 990 "loader.l"	4046	#line 1015 "loader.l"
4008	SET_OR_CLEAR_FLAG(op, FLAG_READY_SKILL, IVAL);	4047	SET_OR_CLEAR_FLAG(op, FLAG_READY_SKILL, IVAL);
4009	YY_BREAK	4048	YY_BREAK
4010	case 209:	4049	case 209:
4011	YY_RULE_SETUP	4050	YY_RULE_SETUP
4012	#line 991 "loader.l"	4051	#line 1016 "loader.l"
4013	SET_OR_CLEAR_FLAG(op, FLAG_READY_WEAPON, IVAL);	4052	SET_OR_CLEAR_FLAG(op, FLAG_READY_WEAPON, IVAL);
4014	YY_BREAK	4053	YY_BREAK
4015	case 210:	4054	case 210:
4016	YY_RULE_SETUP	4055	YY_RULE_SETUP
4017	#line 992 "loader.l"	4056	#line 1017 "loader.l"
4018	SET_OR_CLEAR_FLAG(op, FLAG_NO_SKILL_IDENT, IVAL);	4057	SET_OR_CLEAR_FLAG(op, FLAG_NO_SKILL_IDENT, IVAL);
4019	YY_BREAK	4058	YY_BREAK
4020	case 211:	4059	case 211:
4021	YY_RULE_SETUP	4060	YY_RULE_SETUP
4022	#line 993 "loader.l"	4061	#line 1018 "loader.l"
4023	op->glow_radius = IVAL;	4062	op->glow_radius = IVAL;
4024	YY_BREAK	4063	YY_BREAK
4025	case 212:	4064	case 212:
4026	YY_RULE_SETUP	4065	YY_RULE_SETUP
4027	#line 994 "loader.l"	4066	#line 1019 "loader.l"
4028	SET_OR_CLEAR_FLAG(op, FLAG_BLIND, IVAL);	4067	SET_OR_CLEAR_FLAG(op, FLAG_BLIND, IVAL);
4029	YY_BREAK	4068	YY_BREAK
4030	case 213:	4069	case 213:
4031	YY_RULE_SETUP	4070	YY_RULE_SETUP
4032	#line 995 "loader.l"	4071	#line 1020 "loader.l"
4033	SET_OR_CLEAR_FLAG(op, FLAG_SEE_IN_DARK, IVAL);	4072	SET_OR_CLEAR_FLAG(op, FLAG_SEE_IN_DARK, IVAL);
4034	YY_BREAK	4073	YY_BREAK
4035	case 214:	4074	case 214:
4036	YY_RULE_SETUP	4075	YY_RULE_SETUP
4037	#line 996 "loader.l"	4076	#line 1021 "loader.l"
4038	SET_OR_CLEAR_FLAG(op, FLAG_IS_CAULDRON, IVAL);	4077	SET_OR_CLEAR_FLAG(op, FLAG_IS_CAULDRON, IVAL);
4039	YY_BREAK	4078	YY_BREAK
4040	case 215:	4079	case 215:
4041	YY_RULE_SETUP	4080	YY_RULE_SETUP
4042	#line 997 "loader.l"	4081	#line 1022 "loader.l"
4043	op->randomitems = find_treasurelist(yval());	4082	op->randomitems = find_treasurelist(yval());
4044	YY_BREAK	4083	YY_BREAK
4045	case 216:	4084	case 216:
4046	YY_RULE_SETUP	4085	YY_RULE_SETUP
4047	#line 998 "loader.l"	4086	#line 1023 "loader.l"
4048	SET_OR_CLEAR_FLAG(op, FLAG_NO_STEAL, IVAL);	4087	SET_OR_CLEAR_FLAG(op, FLAG_NO_STEAL, IVAL);
4049	YY_BREAK	4088	YY_BREAK
4050	case 217:	4089	case 217:
4051	YY_RULE_SETUP	4090	YY_RULE_SETUP
4052	#line 999 "loader.l"	4091	#line 1024 "loader.l"
4053	SET_OR_CLEAR_FLAG(op, FLAG_ONE_HIT, IVAL);	4092	SET_OR_CLEAR_FLAG(op, FLAG_ONE_HIT, IVAL);
4054	YY_BREAK	4093	YY_BREAK
4055	case 218:	4094	case 218:
4056	YY_RULE_SETUP	4095	YY_RULE_SETUP
4057	#line 1000 "loader.l"	4096	#line 1025 "loader.l"
4058	SET_OR_CLEAR_FLAG(op, FLAG_BERSERK, IVAL);	4097	SET_OR_CLEAR_FLAG(op, FLAG_BERSERK, IVAL);
4059	YY_BREAK	4098	YY_BREAK
4060	case 219:	4099	case 219:
4061	YY_RULE_SETUP	4100	YY_RULE_SETUP
4062	#line 1002 "loader.l"	4101	#line 1027 "loader.l"
4063	{ /* Some archetypes have these values in them */ }	4102	{ /* Some archetypes have these values in them */ }
4064	YY_BREAK	4103	YY_BREAK
4065	case 220:	4104	case 220:
4066	YY_RULE_SETUP	4105	YY_RULE_SETUP
4067	#line 1003 "loader.l"	4106	#line 1028 "loader.l"
4068	{ /* Probably the pupland archetypes - I imagined */ }	4107	{ /* Probably the pupland archetypes - I imagined */ }
4069	YY_BREAK	4108	YY_BREAK
4070	case 221:	4109	case 221:
4071	YY_RULE_SETUP	4110	YY_RULE_SETUP
4072	#line 1004 "loader.l"	4111	#line 1029 "loader.l"
4073	{ /* That these are for the new combat code */ }	4112	{ /* That these are for the new combat code */ }
4074	YY_BREAK	4113	YY_BREAK
4075	case 222:	4114	case 222:
4076	YY_RULE_SETUP	4115	YY_RULE_SETUP
4077	#line 1005 "loader.l"	4116	#line 1030 "loader.l"
4078	{ /* just ignore for now */ }	4117	{ /* just ignore for now */ }
4079	YY_BREAK	4118	YY_BREAK
4080	case 223:	4119	case 223:
4081	YY_RULE_SETUP	4120	YY_RULE_SETUP
4082	#line 1006 "loader.l"	4121	#line 1031 "loader.l"
4083	{ }	4122	{ }
4084	YY_BREAK	4123	YY_BREAK
4085	case 224:	4124	case 224:
4086	YY_RULE_SETUP	4125	YY_RULE_SETUP
4087	#line 1007 "loader.l"	4126	#line 1032 "loader.l"
4088	op->weapontype = IVAL;	4127	op->weapontype = IVAL;
4089	YY_BREAK	4128	YY_BREAK
4090	case 225:	4129	case 225:
4091	YY_RULE_SETUP	4130	YY_RULE_SETUP
4092	#line 1008 "loader.l"	4131	#line 1033 "loader.l"
4093	op->tooltype = IVAL;	4132	op->tooltype = IVAL;
4094	YY_BREAK	4133	YY_BREAK
4095	case 226:	4134	case 226:
4096	YY_RULE_SETUP	4135	YY_RULE_SETUP
4097	#line 1009 "loader.l"	4136	#line 1034 "loader.l"
4098	op->casting_time = FVAL;	4137	op->casting_time = FVAL;
4099	YY_BREAK	4138	YY_BREAK
4100	case 227:	4139	case 227:
4101	YY_RULE_SETUP	4140	YY_RULE_SETUP
4102	#line 1010 "loader.l"	4141	#line 1035 "loader.l"
4103	op->elevation = IVAL;	4142	op->elevation = IVAL;
4104	YY_BREAK	4143	YY_BREAK
4105	case 228:	4144	case 228:
4106	YY_RULE_SETUP	4145	YY_RULE_SETUP
4107	#line 1011 "loader.l"	4146	#line 1036 "loader.l"
4108	op->smoothlevel = IVAL;	4147	op->smoothlevel = IVAL;
4109	YY_BREAK	4148	YY_BREAK
4110	case 229:	4149	case 229:
4111	YY_RULE_SETUP	4150	YY_RULE_SETUP
4112	#line 1012 "loader.l"	4151	#line 1037 "loader.l"
4113	op->client_type = IVAL;	4152	op->client_type = IVAL;
4114	YY_BREAK	4153	YY_BREAK
4115	case 230:	4154	case 230:
4116	YY_RULE_SETUP	4155	YY_RULE_SETUP
4117	#line 1013 "loader.l"	4156	#line 1038 "loader.l"
4118	set_body_info(op, yytext);	4157	set_body_info(op, yytext);
4119	YY_BREAK	4158	YY_BREAK
4120	case 231:	4159	case 231:
4121	YY_RULE_SETUP	4160	YY_RULE_SETUP
4122	#line 1014 "loader.l"	4161	#line 1039 "loader.l"
4123	op->duration = IVAL;	4162	op->duration = IVAL;
4124	YY_BREAK	4163	YY_BREAK
4125	case 232:	4164	case 232:
4126	YY_RULE_SETUP	4165	YY_RULE_SETUP
4127	#line 1015 "loader.l"	4166	#line 1040 "loader.l"
4128	op->range = IVAL;	4167	op->range = IVAL;
4129	YY_BREAK	4168	YY_BREAK
4130	case 233:	4169	case 233:
4131	YY_RULE_SETUP	4170	YY_RULE_SETUP
4132	#line 1016 "loader.l"	4171	#line 1041 "loader.l"
4133	op->range_modifier = IVAL;	4172	op->range_modifier = IVAL;
4134	YY_BREAK	4173	YY_BREAK
4135	case 234:	4174	case 234:
4136	YY_RULE_SETUP	4175	YY_RULE_SETUP
4137	#line 1017 "loader.l"	4176	#line 1042 "loader.l"
4138	op->dam_modifier = IVAL;	4177	op->dam_modifier = IVAL;
4139	YY_BREAK	4178	YY_BREAK
4140	case 235:	4179	case 235:
4141	YY_RULE_SETUP	4180	YY_RULE_SETUP
4142	#line 1018 "loader.l"	4181	#line 1043 "loader.l"
4143	op->duration_modifier = IVAL;	4182	op->duration_modifier = IVAL;
4144	YY_BREAK	4183	YY_BREAK
4145	case 236:	4184	case 236:
4146	YY_RULE_SETUP	4185	YY_RULE_SETUP
4147	#line 1019 "loader.l"	4186	#line 1044 "loader.l"
4148	SET_OR_CLEAR_FLAG( op, FLAG_IS_BUILDABLE, IVAL );	4187	SET_OR_CLEAR_FLAG( op, FLAG_IS_BUILDABLE, IVAL );
4149	YY_BREAK	4188	YY_BREAK
4150	case 237:	4189	case 237:
4151	YY_RULE_SETUP	4190	YY_RULE_SETUP
4152	#line 1021 "loader.l"	4191	#line 1046 "loader.l"
4153	{	4192	{
4154	char *yv=yval();	4193	char *yv=yval();
4155	if (*yv=='\0')	4194	if (*yv=='\0')
4156	LOG(llevError,"Event (apply) without val\n");	4195	LOG(llevError,"Event (apply) without val\n");
4157	else	4196	else
4158	insert_event(op,EVENT_APPLY,yv,NULL,NULL);	4197	insert_event(op,EVENT_APPLY,yv,NULL,NULL);
4159	}	4198	}
4160	YY_BREAK	4199	YY_BREAK
4161	case 238:	4200	case 238:
4162	YY_RULE_SETUP	4201	YY_RULE_SETUP
4163	#line 1029 "loader.l"	4202	#line 1054 "loader.l"
4164	{	4203	{
4165	char *yv=yval();	4204	char *yv=yval();
4166	if (*yv=='\0')	4205	if (*yv=='\0')
4167	LOG(llevError,"Event (apply) without plugin\n");	4206	LOG(llevError,"Event (apply) without plugin\n");
4168	else	4207	else
4169	insert_event(op,EVENT_APPLY,NULL,yv,NULL);	4208	insert_event(op,EVENT_APPLY,NULL,yv,NULL);
4170	}	4209	}
4171	YY_BREAK	4210	YY_BREAK
4172	case 239:	4211	case 239:
4173	YY_RULE_SETUP	4212	YY_RULE_SETUP
4174	#line 1037 "loader.l"	4213	#line 1062 "loader.l"
4175	{	4214	{
4176	char *yv=yval();	4215	char *yv=yval();
4177	if (*yv=='\0')	4216	if (*yv=='\0')
4178	LOG(llevError,"Event (apply) without options\n");	4217	LOG(llevError,"Event (apply) without options\n");
4179	else	4218	else
4180	insert_event(op,EVENT_APPLY,NULL,NULL,yv);	4219	insert_event(op,EVENT_APPLY,NULL,NULL,yv);
4181	}	4220	}
4182	YY_BREAK	4221	YY_BREAK
4183	case 240:	4222	case 240:
4184	YY_RULE_SETUP	4223	YY_RULE_SETUP
4185	#line 1045 "loader.l"	4224	#line 1070 "loader.l"
4186	{	4225	{
4187	char *yv=yval();	4226	char *yv=yval();
4188	if (*yv=='\0')	4227	if (*yv=='\0')
4189	LOG(llevError,"Event (attack) without val\n");	4228	LOG(llevError,"Event (attack) without val\n");
4190	else	4229	else
4191	insert_event(op,EVENT_ATTACK,yv,NULL,NULL);	4230	insert_event(op,EVENT_ATTACK,yv,NULL,NULL);
4192	}	4231	}
4193	YY_BREAK	4232	YY_BREAK
4194	case 241:	4233	case 241:
4195	YY_RULE_SETUP	4234	YY_RULE_SETUP
4196	#line 1053 "loader.l"	4235	#line 1078 "loader.l"
4197	{	4236	{
4198	char *yv=yval();	4237	char *yv=yval();
4199	if (*yv=='\0')	4238	if (*yv=='\0')
4200	LOG(llevError,"Event (attack) without plugin\n");	4239	LOG(llevError,"Event (attack) without plugin\n");
4201	else	4240	else
4202	insert_event(op,EVENT_ATTACK,NULL,yv,NULL);	4241	insert_event(op,EVENT_ATTACK,NULL,yv,NULL);
4203	}	4242	}
4204	YY_BREAK	4243	YY_BREAK
4205	case 242:	4244	case 242:
4206	YY_RULE_SETUP	4245	YY_RULE_SETUP
4207	#line 1061 "loader.l"	4246	#line 1086 "loader.l"
4208	{	4247	{
4209	char *yv=yval();	4248	char *yv=yval();
4210	if (*yv=='\0')	4249	if (*yv=='\0')
4211	LOG(llevError,"Event (attack) without options\n");	4250	LOG(llevError,"Event (attack) without options\n");
4212	else	4251	else
4213	insert_event(op,EVENT_ATTACK,NULL,NULL,yv);	4252	insert_event(op,EVENT_ATTACK,NULL,NULL,yv);
4214	}	4253	}
4215	YY_BREAK	4254	YY_BREAK
4216	case 243:	4255	case 243:
4217	YY_RULE_SETUP	4256	YY_RULE_SETUP
4218	#line 1068 "loader.l"	4257	#line 1093 "loader.l"
4219	{	4258	{
4220	char *yv=yval();	4259	char *yv=yval();
4221	if (*yv=='\0')	4260	if (*yv=='\0')
4222	LOG(llevError,"Event (death) without val\n");	4261	LOG(llevError,"Event (death) without val\n");
4223	else	4262	else
4224	insert_event(op,EVENT_DEATH,yv,NULL,NULL);	4263	insert_event(op,EVENT_DEATH,yv,NULL,NULL);
4225	}	4264	}
4226	YY_BREAK	4265	YY_BREAK
4227	case 244:	4266	case 244:
4228	YY_RULE_SETUP	4267	YY_RULE_SETUP
4229	#line 1076 "loader.l"	4268	#line 1101 "loader.l"
4230	{	4269	{
4231	char *yv=yval();	4270	char *yv=yval();
4232	if (*yv=='\0')	4271	if (*yv=='\0')
4233	LOG(llevError,"Event (death) without plugin\n");	4272	LOG(llevError,"Event (death) without plugin\n");
4234	else	4273	else
4235	insert_event(op,EVENT_DEATH,NULL,yv,NULL);	4274	insert_event(op,EVENT_DEATH,NULL,yv,NULL);
4236	}	4275	}
4237	YY_BREAK	4276	YY_BREAK
4238	case 245:	4277	case 245:
4239	YY_RULE_SETUP	4278	YY_RULE_SETUP
4240	#line 1084 "loader.l"	4279	#line 1109 "loader.l"
4241	{	4280	{
4242	char *yv=yval();	4281	char *yv=yval();
4243	if (*yv=='\0')	4282	if (*yv=='\0')
4244	LOG(llevError,"Event (death) without options\n");	4283	LOG(llevError,"Event (death) without options\n");
4245	else	4284	else
4246	insert_event(op,EVENT_DEATH,NULL,NULL,yv);	4285	insert_event(op,EVENT_DEATH,NULL,NULL,yv);
4247	}	4286	}
4248	YY_BREAK	4287	YY_BREAK
4249	case 246:	4288	case 246:
4250	YY_RULE_SETUP	4289	YY_RULE_SETUP
4251	#line 1091 "loader.l"	4290	#line 1116 "loader.l"
4252	{	4291	{
4253	char *yv=yval();	4292	char *yv=yval();
4254	if (*yv=='\0')	4293	if (*yv=='\0')
4255	LOG(llevError,"Event (drop) without val\n");	4294	LOG(llevError,"Event (drop) without val\n");
4256	else	4295	else
4257	insert_event(op,EVENT_DROP,yv,NULL,NULL);	4296	insert_event(op,EVENT_DROP,yv,NULL,NULL);
4258	}	4297	}
4259	YY_BREAK	4298	YY_BREAK
4260	case 247:	4299	case 247:
4261	YY_RULE_SETUP	4300	YY_RULE_SETUP
4262	#line 1099 "loader.l"	4301	#line 1124 "loader.l"
4263	{	4302	{
4264	char *yv=yval();	4303	char *yv=yval();
4265	if (*yv=='\0')	4304	if (*yv=='\0')
4266	LOG(llevError,"Event (drop) without plugin\n");	4305	LOG(llevError,"Event (drop) without plugin\n");
4267	else	4306	else
4268	insert_event(op,EVENT_DROP,NULL,yv,NULL);	4307	insert_event(op,EVENT_DROP,NULL,yv,NULL);
4269	}	4308	}
4270	YY_BREAK	4309	YY_BREAK
4271	case 248:	4310	case 248:
4272	YY_RULE_SETUP	4311	YY_RULE_SETUP
4273	#line 1107 "loader.l"	4312	#line 1132 "loader.l"
4274	{	4313	{
4275	char *yv=yval();	4314	char *yv=yval();
4276	if (*yv=='\0')	4315	if (*yv=='\0')
4277	LOG(llevError,"Event (drop) without options\n");	4316	LOG(llevError,"Event (drop) without options\n");
4278	else	4317	else
4279	insert_event(op,EVENT_DROP,NULL,NULL,yv);	4318	insert_event(op,EVENT_DROP,NULL,NULL,yv);
4280	}	4319	}
4281	YY_BREAK	4320	YY_BREAK
4282	case 249:	4321	case 249:
4283	YY_RULE_SETUP	4322	YY_RULE_SETUP
4284	#line 1114 "loader.l"	4323	#line 1139 "loader.l"
4285	{	4324	{
4286	char *yv=yval();	4325	char *yv=yval();
4287	if (*yv=='\0')	4326	if (*yv=='\0')
4288	LOG(llevError,"Event (pickup) without val\n");	4327	LOG(llevError,"Event (pickup) without val\n");
4289	else	4328	else
4290	insert_event(op,EVENT_PICKUP,yv,NULL,NULL);	4329	insert_event(op,EVENT_PICKUP,yv,NULL,NULL);
4291	}	4330	}
4292	YY_BREAK	4331	YY_BREAK
4293	case 250:	4332	case 250:
4294	YY_RULE_SETUP	4333	YY_RULE_SETUP
4295	#line 1122 "loader.l"	4334	#line 1147 "loader.l"
4296	{	4335	{
4297	char *yv=yval();	4336	char *yv=yval();
4298	if (*yv=='\0')	4337	if (*yv=='\0')
4299	LOG(llevError,"Event (pickup) without plugin\n");	4338	LOG(llevError,"Event (pickup) without plugin\n");
4300	else	4339	else
4301	insert_event(op,EVENT_PICKUP,NULL,yv,NULL);	4340	insert_event(op,EVENT_PICKUP,NULL,yv,NULL);
4302	}	4341	}
4303	YY_BREAK	4342	YY_BREAK
4304	case 251:	4343	case 251:
4305	YY_RULE_SETUP	4344	YY_RULE_SETUP
4306	#line 1130 "loader.l"	4345	#line 1155 "loader.l"
4307	{	4346	{
4308	char *yv=yval();	4347	char *yv=yval();
4309	if (*yv=='\0')	4348	if (*yv=='\0')
4310	LOG(llevError,"Event (pickup) without options\n");	4349	LOG(llevError,"Event (pickup) without options\n");
4311	else	4350	else
4312	insert_event(op,EVENT_PICKUP,NULL,NULL,yv);	4351	insert_event(op,EVENT_PICKUP,NULL,NULL,yv);
4313	}	4352	}
4314	YY_BREAK	4353	YY_BREAK
4315	case 252:	4354	case 252:
4316	YY_RULE_SETUP	4355	YY_RULE_SETUP
4317	#line 1137 "loader.l"	4356	#line 1162 "loader.l"
4318	{	4357	{
4319	char *yv=yval();	4358	char *yv=yval();
4320	if (*yv=='\0')	4359	if (*yv=='\0')
4321	LOG(llevError,"Event (say) without val\n");	4360	LOG(llevError,"Event (say) without val\n");
4322	else	4361	else
4323	insert_event(op,EVENT_SAY,yv,NULL,NULL);	4362	insert_event(op,EVENT_SAY,yv,NULL,NULL);
4324	}	4363	}
4325	YY_BREAK	4364	YY_BREAK
4326	case 253:	4365	case 253:
4327	YY_RULE_SETUP	4366	YY_RULE_SETUP
4328	#line 1145 "loader.l"	4367	#line 1170 "loader.l"
4329	{	4368	{
4330	char *yv=yval();	4369	char *yv=yval();
4331	if (*yv=='\0')	4370	if (*yv=='\0')
4332	LOG(llevError,"Event (say) without plugin\n");	4371	LOG(llevError,"Event (say) without plugin\n");
4333	else	4372	else
4334	insert_event(op,EVENT_SAY,NULL,yv,NULL);	4373	insert_event(op,EVENT_SAY,NULL,yv,NULL);
4335	}	4374	}
4336	YY_BREAK	4375	YY_BREAK
4337	case 254:	4376	case 254:
4338	YY_RULE_SETUP	4377	YY_RULE_SETUP
4339	#line 1153 "loader.l"	4378	#line 1178 "loader.l"
4340	{	4379	{
4341	char *yv=yval();	4380	char *yv=yval();
4342	if (*yv=='\0')	4381	if (*yv=='\0')
4343	LOG(llevError,"Event (say) without options\n");	4382	LOG(llevError,"Event (say) without options\n");
4344	else	4383	else
4345	insert_event(op,EVENT_SAY,NULL,NULL,yv);	4384	insert_event(op,EVENT_SAY,NULL,NULL,yv);
4346	}	4385	}
4347	YY_BREAK	4386	YY_BREAK
4348	case 255:	4387	case 255:
4349	YY_RULE_SETUP	4388	YY_RULE_SETUP
4350	#line 1160 "loader.l"	4389	#line 1185 "loader.l"
4351	{	4390	{
4352	char *yv=yval();	4391	char *yv=yval();
4353	if (*yv=='\0')	4392	if (*yv=='\0')
4354	LOG(llevError,"Event (stop) without val\n");	4393	LOG(llevError,"Event (stop) without val\n");
4355	else	4394	else
4356	insert_event(op,EVENT_STOP,yv,NULL,NULL);	4395	insert_event(op,EVENT_STOP,yv,NULL,NULL);
4357	}	4396	}
4358	YY_BREAK	4397	YY_BREAK
4359	case 256:	4398	case 256:
4360	YY_RULE_SETUP	4399	YY_RULE_SETUP
4361	#line 1168 "loader.l"	4400	#line 1193 "loader.l"
4362	{	4401	{
4363	char *yv=yval();	4402	char *yv=yval();
4364	if (*yv=='\0')	4403	if (*yv=='\0')
4365	LOG(llevError,"Event (stop) without plugin\n");	4404	LOG(llevError,"Event (stop) without plugin\n");
4366	else	4405	else
4367	insert_event(op,EVENT_STOP,NULL,yv,NULL);	4406	insert_event(op,EVENT_STOP,NULL,yv,NULL);
4368	}	4407	}
4369	YY_BREAK	4408	YY_BREAK
4370	case 257:	4409	case 257:
4371	YY_RULE_SETUP	4410	YY_RULE_SETUP
4372	#line 1176 "loader.l"	4411	#line 1201 "loader.l"
4373	{	4412	{
4374	char *yv=yval();	4413	char *yv=yval();
4375	if (*yv=='\0')	4414	if (*yv=='\0')
4376	LOG(llevError,"Event (stop) without options\n");	4415	LOG(llevError,"Event (stop) without options\n");
4377	else	4416	else
4378	insert_event(op,EVENT_STOP,NULL,NULL,yv);	4417	insert_event(op,EVENT_STOP,NULL,NULL,yv);
4379	}	4418	}
4380	YY_BREAK	4419	YY_BREAK
4381	case 258:	4420	case 258:
4382	YY_RULE_SETUP	4421	YY_RULE_SETUP
4383	#line 1183 "loader.l"	4422	#line 1208 "loader.l"
4384	{	4423	{
4385	char *yv=yval();	4424	char *yv=yval();
4386	if (*yv=='\0')	4425	if (*yv=='\0')
4387	LOG(llevError,"Event (time) without val\n");	4426	LOG(llevError,"Event (time) without val\n");
4388	else	4427	else
4389	insert_event(op,EVENT_TIME,yv,NULL,NULL);	4428	insert_event(op,EVENT_TIME,yv,NULL,NULL);
4390	}	4429	}
4391	YY_BREAK	4430	YY_BREAK
4392	case 259:	4431	case 259:
4393	YY_RULE_SETUP	4432	YY_RULE_SETUP
4394	#line 1191 "loader.l"	4433	#line 1216 "loader.l"
4395	{	4434	{
4396	char *yv=yval();	4435	char *yv=yval();
4397	if (*yv=='\0')	4436	if (*yv=='\0')
4398	LOG(llevError,"Event (time) without plugin\n");	4437	LOG(llevError,"Event (time) without plugin\n");
4399	else	4438	else
4400	insert_event(op,EVENT_TIME,NULL,yv,NULL);	4439	insert_event(op,EVENT_TIME,NULL,yv,NULL);
4401	}	4440	}
4402	YY_BREAK	4441	YY_BREAK
4403	case 260:	4442	case 260:
4404	YY_RULE_SETUP	4443	YY_RULE_SETUP
4405	#line 1199 "loader.l"	4444	#line 1224 "loader.l"
4406	{	4445	{
4407	char *yv=yval();	4446	char *yv=yval();
4408	if (*yv=='\0')	4447	if (*yv=='\0')
4409	LOG(llevError,"Event (time) without options\n");	4448	LOG(llevError,"Event (time) without options\n");
4410	else	4449	else
4411	insert_event(op,EVENT_TIME,NULL,NULL,yv);	4450	insert_event(op,EVENT_TIME,NULL,NULL,yv);
4412	}	4451	}
4413	YY_BREAK	4452	YY_BREAK
4414	case 261:	4453	case 261:
4415	YY_RULE_SETUP	4454	YY_RULE_SETUP
4416	#line 1206 "loader.l"	4455	#line 1231 "loader.l"
4417	{	4456	{
4418	char *yv=yval();	4457	char *yv=yval();
4419	if (*yv=='\0')	4458	if (*yv=='\0')
4420	LOG(llevError,"Event (throw) without val\n");	4459	LOG(llevError,"Event (throw) without val\n");
4421	else	4460	else
4422	insert_event(op,EVENT_THROW,yv,NULL,NULL);	4461	insert_event(op,EVENT_THROW,yv,NULL,NULL);
4423	}	4462	}
4424	YY_BREAK	4463	YY_BREAK
4425	case 262:	4464	case 262:
4426	YY_RULE_SETUP	4465	YY_RULE_SETUP
4427	#line 1214 "loader.l"	4466	#line 1239 "loader.l"
4428	{	4467	{
4429	char *yv=yval();	4468	char *yv=yval();
4430	if (*yv=='\0')	4469	if (*yv=='\0')
4431	LOG(llevError,"Event (throw) without plugin\n");	4470	LOG(llevError,"Event (throw) without plugin\n");
4432	else	4471	else
4433	insert_event(op,EVENT_THROW,NULL,yv,NULL);	4472	insert_event(op,EVENT_THROW,NULL,yv,NULL);
4434	}	4473	}
4435	YY_BREAK	4474	YY_BREAK
4436	case 263:	4475	case 263:
4437	YY_RULE_SETUP	4476	YY_RULE_SETUP
4438	#line 1222 "loader.l"	4477	#line 1247 "loader.l"
4439	{	4478	{
4440	char *yv=yval();	4479	char *yv=yval();
4441	if (*yv=='\0')	4480	if (*yv=='\0')
4442	LOG(llevError,"Event (apply) without options\n");	4481	LOG(llevError,"Event (apply) without options\n");
4443	else	4482	else
4444	insert_event(op,EVENT_THROW,NULL,NULL,yv);	4483	insert_event(op,EVENT_THROW,NULL,NULL,yv);
4445	}	4484	}
4446	YY_BREAK	4485	YY_BREAK
4447	case 264:	4486	case 264:
4448	YY_RULE_SETUP	4487	YY_RULE_SETUP
4449	#line 1229 "loader.l"	4488	#line 1254 "loader.l"
4450	{	4489	{
4451	char *yv=yval();	4490	char *yv=yval();
4452	if (*yv=='\0')	4491	if (*yv=='\0')
4453	LOG(llevError,"Event (trigger) without val\n");	4492	LOG(llevError,"Event (trigger) without val\n");
4454	else	4493	else
4455	insert_event(op,EVENT_TRIGGER,yv,NULL,NULL);	4494	insert_event(op,EVENT_TRIGGER,yv,NULL,NULL);
4456	}	4495	}
4457	YY_BREAK	4496	YY_BREAK
4458	case 265:	4497	case 265:
4459	YY_RULE_SETUP	4498	YY_RULE_SETUP
4460	#line 1237 "loader.l"	4499	#line 1262 "loader.l"
4461	{	4500	{
4462	char *yv=yval();	4501	char *yv=yval();
4463	if (*yv=='\0')	4502	if (*yv=='\0')
4464	LOG(llevError,"Event (trigger) without plugin\n");	4503	LOG(llevError,"Event (trigger) without plugin\n");
4465	else	4504	else
4466	insert_event(op,EVENT_TRIGGER,NULL,yv,NULL);	4505	insert_event(op,EVENT_TRIGGER,NULL,yv,NULL);
4467	}	4506	}
4468	YY_BREAK	4507	YY_BREAK
4469	case 266:	4508	case 266:
4470	YY_RULE_SETUP	4509	YY_RULE_SETUP
4471	#line 1245 "loader.l"	4510	#line 1270 "loader.l"
4472	{	4511	{
4473	char *yv=yval();	4512	char *yv=yval();
4474	if (*yv=='\0')	4513	if (*yv=='\0')
4475	LOG(llevError,"Event (trigger) without options\n");	4514	LOG(llevError,"Event (trigger) without options\n");
4476	else	4515	else
4477	insert_event(op,EVENT_TRIGGER,NULL,NULL,yv);	4516	insert_event(op,EVENT_TRIGGER,NULL,NULL,yv);
4478	}	4517	}
4479	YY_BREAK	4518	YY_BREAK
4480	case 267:	4519	case 267:
4481	YY_RULE_SETUP	4520	YY_RULE_SETUP
4482	#line 1252 "loader.l"	4521	#line 1277 "loader.l"
4483	{	4522	{
4484	char *yv=yval();	4523	char *yv=yval();
4485	if (*yv=='\0')	4524	if (*yv=='\0')
4486	LOG(llevError,"Event (close) without val\n");	4525	LOG(llevError,"Event (close) without val\n");
4487	else	4526	else
4488	insert_event(op,EVENT_CLOSE,yv,NULL,NULL);	4527	insert_event(op,EVENT_CLOSE,yv,NULL,NULL);
4489	}	4528	}
4490	YY_BREAK	4529	YY_BREAK
4491	case 268:	4530	case 268:
4492	YY_RULE_SETUP	4531	YY_RULE_SETUP
4493	#line 1260 "loader.l"	4532	#line 1285 "loader.l"
4494	{	4533	{
4495	char *yv=yval();	4534	char *yv=yval();
4496	if (*yv=='\0')	4535	if (*yv=='\0')
4497	LOG(llevError,"Event (close) without plugin\n");	4536	LOG(llevError,"Event (close) without plugin\n");
4498	else	4537	else
4499	insert_event(op,EVENT_CLOSE,NULL,yv,NULL);	4538	insert_event(op,EVENT_CLOSE,NULL,yv,NULL);
4500	}	4539	}
4501	YY_BREAK	4540	YY_BREAK
4502	case 269:	4541	case 269:
4503	YY_RULE_SETUP	4542	YY_RULE_SETUP
4504	#line 1268 "loader.l"	4543	#line 1293 "loader.l"
4505	{	4544	{
4506	char *yv=yval();	4545	char *yv=yval();
4507	if (*yv=='\0')	4546	if (*yv=='\0')
4508	LOG(llevError,"Event (close) without options\n");	4547	LOG(llevError,"Event (close) without options\n");
4509	else	4548	else
4510	insert_event(op,EVENT_CLOSE,NULL,NULL,yv);	4549	insert_event(op,EVENT_CLOSE,NULL,NULL,yv);
4511	}	4550	}
4512	YY_BREAK	4551	YY_BREAK
4513	case 270:	4552	case 270:
4514	YY_RULE_SETUP	4553	YY_RULE_SETUP
4515	#line 1275 "loader.l"	4554	#line 1300 "loader.l"
4516	{	4555	{
4517	char *yv=yval();	4556	char *yv=yval();
4518	if (*yv=='\0')	4557	if (*yv=='\0')
4519	LOG(llevError,"Event (timer) without val\n");	4558	LOG(llevError,"Event (timer) without val\n");
4520	else	4559	else
4521	insert_event(op,EVENT_TIMER,yv,NULL,NULL);	4560	insert_event(op,EVENT_TIMER,yv,NULL,NULL);
4522	}	4561	}
4523	YY_BREAK	4562	YY_BREAK
4524	case 271:	4563	case 271:
4525	YY_RULE_SETUP	4564	YY_RULE_SETUP
4526	#line 1283 "loader.l"	4565	#line 1308 "loader.l"
4527	{	4566	{
4528	char *yv=yval();	4567	char *yv=yval();
4529	if (*yv=='\0')	4568	if (*yv=='\0')
4530	LOG(llevError,"Event (timer) without plugin\n");	4569	LOG(llevError,"Event (timer) without plugin\n");
4531	else	4570	else
4532	insert_event(op,EVENT_TIMER,NULL,yv,NULL);	4571	insert_event(op,EVENT_TIMER,NULL,yv,NULL);
4533	}	4572	}
4534	YY_BREAK	4573	YY_BREAK
4535	case 272:	4574	case 272:
4536	YY_RULE_SETUP	4575	YY_RULE_SETUP
4537	#line 1291 "loader.l"	4576	#line 1316 "loader.l"
4538	{	4577	{
4539	char *yv=yval();	4578	char *yv=yval();
4540	if (*yv=='\0')	4579	if (*yv=='\0')
4541	LOG(llevError,"Event (timer) without options\n");	4580	LOG(llevError,"Event (timer) without options\n");
4542	else	4581	else
4543	insert_event(op,EVENT_TIMER,NULL,NULL,yv);	4582	insert_event(op,EVENT_TIMER,NULL,NULL,yv);
4544	}	4583	}
4545	YY_BREAK	4584	YY_BREAK
4546	case 273:	4585	case 273:
4547	YY_RULE_SETUP	4586	YY_RULE_SETUP
4548	#line 1299 "loader.l"	4587	#line 1324 "loader.l"
4549	{ char *yv=yval();	4588	{ char *yv=yval();
4550		4589
4551	if (*yv=='\0') LOG(llevError,"Script (current weapon) without val\n");	4590	if (*yv=='\0') LOG(llevError,"Script (current weapon) without val\n");
4552	else	4591	else
4553	{	4592	{
…		…
4556	}	4595	}
4557	YY_BREAK	4596	YY_BREAK
4558	case 274:	4597	case 274:
4559	/* rule 274 can match eol */	4598	/* rule 274 can match eol */
4560	YY_RULE_SETUP	4599	YY_RULE_SETUP
4561	#line 1308 "loader.l"	4600	#line 1333 "loader.l"
4562	{/* ignore empty lines, newlines we don't do above */}	4601	{/* ignore empty lines, newlines we don't do above */}
4563	YY_BREAK	4602	YY_BREAK
4564	case 275:	4603	case 275:
4565	/* rule 275 can match eol */	4604	/* rule 275 can match eol */
4566	YY_RULE_SETUP	4605	YY_RULE_SETUP
4567	#line 1309 "loader.l"	4606	#line 1334 "loader.l"
4568	{}	4607	{}
4569	YY_BREAK	4608	YY_BREAK
4570	case YY_STATE_EOF(INITIAL):	4609	case YY_STATE_EOF(INITIAL):
4571	case YY_STATE_EOF(MESSAGE):	4610	case YY_STATE_EOF(MESSAGE):
4572	case YY_STATE_EOF(LORE):	4611	case YY_STATE_EOF(LORE):
4573	case YY_STATE_EOF(SCRIPT):	4612	case YY_STATE_EOF(SCRIPT):
4574	#line 1311 "loader.l"	4613	#line 1336 "loader.l"
4575	{/* If we got an error, return the error. Otherwise, return that we got EOF */	4614	{/* If we got an error, return the error. Otherwise, return that we got EOF */
4576	if (lex_error!=0) return lex_error; else return LL_EOF;}	4615	if (lex_error!=0) return lex_error; else return LL_EOF;}
4577	YY_BREAK	4616	YY_BREAK
4578	case 276:	4617	case 276:
4579	YY_RULE_SETUP	4618	YY_RULE_SETUP
4580	#line 1313 "loader.l"	4619	#line 1338 "loader.l"
4581	{ add_key_value(op); }	4620	{ add_key_value(op); }
4582	YY_BREAK	4621	YY_BREAK
4583	case 277:	4622	case 277:
4584	YY_RULE_SETUP	4623	YY_RULE_SETUP
4585	#line 1314 "loader.l"	4624	#line 1339 "loader.l"
4586	ECHO;	4625	ECHO;
4587	YY_BREAK	4626	YY_BREAK
4588	#line 4589 "loader.c"	4627	#line 4628 "loader.c"
4589		4628
4590	case YY_END_OF_BUFFER:	4629	case YY_END_OF_BUFFER:
4591	{	4630	{
4592	/* Amount of text matched not including the EOB char. */	4631	/* Amount of text matched not including the EOB char. */
4593	int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;	4632	int yy_amount_of_matched_text = (int) (yy_cp - (yytext_ptr)) - 1;
…		…
4767	*/	4806	*/
4768	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;	4807	YY_CURRENT_BUFFER_LVALUE->yy_n_chars = (yy_n_chars) = 0;
4769		4808
4770	else	4809	else
4771	{	4810	{
4772	size_t num_to_read =	4811	int num_to_read =
4773	YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;	4812	YY_CURRENT_BUFFER_LVALUE->yy_buf_size - number_to_move - 1;
4774		4813
4775	while ( num_to_read <= 0 )	4814	while ( num_to_read <= 0 )
4776	{ /* Not enough room in the buffer - grow it. */	4815	{ /* Not enough room in the buffer - grow it. */
4777		4816
…		…
5316	return b;	5355	return b;
5317	}	5356	}
5318		5357
5319	/** Setup the input buffer state to scan a string. The next call to yylex() will	5358	/** Setup the input buffer state to scan a string. The next call to yylex() will
5320	* scan from a @e copy of @a str.	5359	* scan from a @e copy of @a str.
5321	* @param str a NUL-terminated string to scan	5360	* @param yystr a NUL-terminated string to scan
5322	*	5361	*
5323	* @return the newly allocated buffer state object.	5362	* @return the newly allocated buffer state object.
5324	* @note If you want to scan bytes that may contain NUL values, then use	5363	* @note If you want to scan bytes that may contain NUL values, then use
5325	* yy_scan_bytes() instead.	5364	* yy_scan_bytes() instead.
5326	*/	5365	*/
5327	YY_BUFFER_STATE yy_scan_string (yyconst char * yy_str )	5366	YY_BUFFER_STATE yy_scan_string (yyconst char * yystr )
5328	{	5367	{
5329		5368
5330	return yy_scan_bytes(yy_str,strlen(yy_str) );	5369	return yy_scan_bytes(yystr,strlen(yystr) );
5331	}	5370	}
5332		5371
5333	/** Setup the input buffer state to scan the given bytes. The next call to yylex() will	5372	/** Setup the input buffer state to scan the given bytes. The next call to yylex() will
5334	* scan from a @e copy of @a bytes.	5373	* scan from a @e copy of @a bytes.
5335	* @param bytes the byte buffer to scan	5374	* @param bytes the byte buffer to scan
5336	* @param len the number of bytes in the buffer pointed to by @a bytes.	5375	* @param len the number of bytes in the buffer pointed to by @a bytes.
5337	*	5376	*
5338	* @return the newly allocated buffer state object.	5377	* @return the newly allocated buffer state object.
5339	*/	5378	*/
5340	YY_BUFFER_STATE yy_scan_bytes (yyconst char * bytes, int len )	5379	YY_BUFFER_STATE yy_scan_bytes (yyconst char * yybytes, int _yybytes_len )
5341	{	5380	{
5342	YY_BUFFER_STATE b;	5381	YY_BUFFER_STATE b;
5343	char *buf;	5382	char *buf;
5344	yy_size_t n;	5383	yy_size_t n;
5345	int i;	5384	int i;
5346		5385
5347	/* Get memory for full buffer, including space for trailing EOB's. */	5386	/* Get memory for full buffer, including space for trailing EOB's. */
5348	n = len + 2;	5387	n = _yybytes_len + 2;
5349	buf = (char *) yyalloc(n );	5388	buf = (char *) yyalloc(n );
5350	if ( ! buf )	5389	if ( ! buf )
5351	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );	5390	YY_FATAL_ERROR( "out of dynamic memory in yy_scan_bytes()" );
5352		5391
5353	for ( i = 0; i < len; ++i )	5392	for ( i = 0; i < _yybytes_len; ++i )
5354	buf[i] = bytes[i];	5393	buf[i] = yybytes[i];
5355		5394
5356	buf[len] = buf[len+1] = YY_END_OF_BUFFER_CHAR;	5395	buf[_yybytes_len] = buf[_yybytes_len+1] = YY_END_OF_BUFFER_CHAR;
5357		5396
5358	b = yy_scan_buffer(buf,n );	5397	b = yy_scan_buffer(buf,n );
5359	if ( ! b )	5398	if ( ! b )
5360	YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );	5399	YY_FATAL_ERROR( "bad buffer in yy_scan_bytes()" );
5361		5400
…		…
5510	void yyset_debug (int bdebug )	5549	void yyset_debug (int bdebug )
5511	{	5550	{
5512	yy_flex_debug = bdebug ;	5551	yy_flex_debug = bdebug ;
5513	}	5552	}
5514		5553
		5554	static int yy_init_globals (void)
		5555	{
		5556	/* Initialization is the same as for the non-reentrant scanner.
		5557	* This function is called from yylex_destroy(), so don't allocate here.
		5558	*/
		5559
		5560	(yy_buffer_stack) = 0;
		5561	(yy_buffer_stack_top) = 0;
		5562	(yy_buffer_stack_max) = 0;
		5563	(yy_c_buf_p) = (char *) 0;
		5564	(yy_init) = 0;
		5565	(yy_start) = 0;
		5566
		5567	(yy_start_stack_ptr) = 0;
		5568	(yy_start_stack_depth) = 0;
		5569	(yy_start_stack) = NULL;
		5570
		5571	/* Defined in main.c */
		5572	#ifdef YY_STDINIT
		5573	yyin = stdin;
		5574	yyout = stdout;
		5575	#else
		5576	yyin = (FILE *) 0;
		5577	yyout = (FILE *) 0;
		5578	#endif
		5579
		5580	/* For future reference: Set errno on error, since we are called by
		5581	* yylex_init()
		5582	*/
		5583	return 0;
		5584	}
		5585
5515	/* yylex_destroy is for both reentrant and non-reentrant scanners. */	5586	/* yylex_destroy is for both reentrant and non-reentrant scanners. */
5516	int yylex_destroy (void)	5587	int yylex_destroy (void)
5517	{	5588	{
5518		5589
5519	/* Pop the buffer stack, destroying each element. */	5590	/* Pop the buffer stack, destroying each element. */
…		…
5529		5600
5530	/* Destroy the start condition stack. */	5601	/* Destroy the start condition stack. */
5531	yyfree((yy_start_stack) );	5602	yyfree((yy_start_stack) );
5532	(yy_start_stack) = NULL;	5603	(yy_start_stack) = NULL;
5533		5604
		5605	/* Reset the globals. This is important in a non-reentrant scanner so the next time
		5606	* yylex() is called, initialization will occur. */
		5607	yy_init_globals( );
		5608
5534	return 0;	5609	return 0;
5535	}	5610	}
5536		5611
5537	/*	5612	/*
5538	* Internal utility routines.	5613	* Internal utility routines.
…		…
5540		5615
5541	#ifndef yytext_ptr	5616	#ifndef yytext_ptr
5542	static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )	5617	static void yy_flex_strncpy (char* s1, yyconst char * s2, int n )
5543	{	5618	{
5544	register int i;	5619	register int i;
5545	for ( i = 0; i < n; ++i )	5620	for ( i = 0; i < n; ++i )
5546	s1[i] = s2[i];	5621	s1[i] = s2[i];
5547	}	5622	}
5548	#endif	5623	#endif
5549		5624
5550	#ifdef YY_NEED_STRLEN	5625	#ifdef YY_NEED_STRLEN
5551	static int yy_flex_strlen (yyconst char * s )	5626	static int yy_flex_strlen (yyconst char * s )
5552	{	5627	{
5553	register int n;	5628	register int n;
5554	for ( n = 0; s[n]; ++n )	5629	for ( n = 0; s[n]; ++n )
5555	;	5630	;
5556		5631
5557	return n;	5632	return n;
5558	}	5633	}
5559	#endif	5634	#endif
…		…
5580	free( (char *) ptr ); /* see yyrealloc() for (char *) cast */	5655	free( (char *) ptr ); /* see yyrealloc() for (char *) cast */
5581	}	5656	}
5582		5657
5583	#define YYTABLES_NAME "yytables"	5658	#define YYTABLES_NAME "yytables"
5584		5659
5585	#undef YY_NEW_FILE
5586	#undef YY_FLUSH_BUFFER
5587	#undef yy_set_bol
5588	#undef yy_new_buffer
5589	#undef yy_set_interactive
5590	#undef yytext_ptr
5591	#undef YY_DO_BEFORE_ACTION
5592
5593	#ifdef YY_DECL_IS_OURS
5594	#undef YY_DECL_IS_OURS
5595	#undef YY_DECL
5596	#endif
5597	#line 1314 "loader.l"	5660	#line 1339 "loader.l"
5598		5661
5599		5662
5600		5663
5601		5664
5602	int yyerror(char *s)	5665	int yyerror(char *s)

Diff Legend

–	Removed lines
+	Added lines
<	Changed lines
>	Changed lines