server/random_maps/reader.l

/*
    CrossFire, A Multiplayer game for X-windows

    Copyright (C) 1994 Mark Wedel
    Copyright (C) 1992 Frank Tore Johansen

    This program is free software; you can redistribute it and/or modify
    it under the terms of the GNU General Public License as published by
    the Free Software Foundation; either version 2 of the License, or
    (at your option) any later version.

    This program is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
    GNU General Public License for more details.

    You should have received a copy of the GNU General Public License
    along with this program; if not, write to the Free Software
    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.

    The author can be reached via e-mail to mark@pyramid.com
*/

%{

#include <global.h>
#include <loader.h>
#include <random_map.h>

#define LO_REPEAT   0
#define LO_LINEMODE 1
#define LO_NEWFILE  2
#define LO_NOREAD   3

int yyerror(char *s)
{
   LOG(llevError, "%s: %s\n", s, yytext);
   return -1;
}

#define YY_DECL int rmap_lex_read(RMParms *RP)

static char *rmap_yval();

static int rmap_lex_error;


#define IVAL    atoi(rmap_yval())
#define FVAL    atof(rmap_yval())

%}


S       [ \t]+.+
WS      [ \t]*

%x MESSAGE

/* Don't have to link with -lfl with this */
%option noyywrap

/* need yy_push_state, yy_pop_state */
%option stack

%%

%{
/* Declare some local variables */

    rmap_lex_error=0;

%}


^wallstyle{S}       strcpy(RP->wallstyle,rmap_yval());
^floorstyle{S}      strcpy(RP->floorstyle,rmap_yval());
^monsterstyle{S}    strcpy(RP->monsterstyle,rmap_yval());
^treasurestyle{S}   strcpy(RP->treasurestyle,rmap_yval());
^layoutstyle{S}     strcpy(RP->layoutstyle,rmap_yval());
^doorstyle{S}       strcpy(RP->doorstyle,rmap_yval());
^decorstyle{S}      strcpy(RP->decorstyle,rmap_yval());
^xsize{S}           RP->Xsize = IVAL;
^ysize{S}           RP->Ysize = IVAL;
^expand2x{S}        RP->expand2x = IVAL;
^layoutoptions1{S}  RP->layoutoptions1 = IVAL;
^layoutoptions2{S}  RP->layoutoptions2 = IVAL;
^layoutoptions3{S}  RP->layoutoptions3 = IVAL;
^symmetry{S}        RP->symmetry = IVAL;
^difficulty{S}        RP->difficulty = IVAL;
^difficulty_increase{S}        RP->difficulty_increase = FVAL;
^decoroptions{S}      RP->decoroptions = IVAL;
^exitstyle{S}       strcpy(RP->exitstyle,rmap_yval());
^dungeon_level{S}   RP->dungeon_level = IVAL;
^dungeon_depth{S}   RP->dungeon_depth = IVAL;
^final_map{S}       strcpy(RP->final_map,rmap_yval());
^orientation{S}    RP-> orientation = IVAL;
^origin_x{S}        RP->origin_x = IVAL;
^origin_y{S}       RP-> origin_y = IVAL;
^origin_map{S}       strcpy(RP->origin_map,rmap_yval());
^random_seed{S}        RP->random_seed = IVAL;
^treasureoptions{S}    RP->treasureoptions = IVAL;
^exit_on_final_map{S} strcpy(RP->exit_on_final_map,rmap_yval());

<*>(^{WS}$)|\n          {/* ignore empty lines, newlines we don't do above */}
#.*\n                   {}

<<EOF>>                 {/* If we got an error, return the error.  Otherwise, return that we got EOF */
                            if (rmap_lex_error!=0) return rmap_lex_error; else return LL_EOF;}
.*                      { yyerror( "Unrecognized string"); rmap_lex_error= -1; }
%%

/*int yyerror(char *s)
{
  return -1;
}
*/

/* Our save file syntax is very simple, so we can use a very simple
 * processing mechanism here instead using something like bison
 * This skips over the space and returns the value, or "" if no value
 * is found.
 */
static char *rmap_yval()
{
    static char *em="";
    char *cp;

    cp=strchr(yytext,' ');
    if (cp) return cp+1;
    else return em;
}


int load_parameters(FILE *fp, int bufstate,RMParms *RP) {
    int retval;
    char inbuf[MAX_BUF];

    if (bufstate==LO_NEWFILE || bufstate==LO_NOREAD) {
        yy_delete_buffer(YY_CURRENT_BUFFER);
        yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
        if (bufstate==LO_NOREAD) return LL_NORMAL;
    } 
    if (bufstate==LO_LINEMODE) {
        YY_BUFFER_STATE  yybufstate;
        while (fgets(inbuf, MAX_BUF-3, fp)) {
            yybufstate=yy_scan_string(inbuf);
            retval=rmap_lex_read(RP);
            yy_delete_buffer(yybufstate);
            if (retval==LL_NORMAL) return retval;
        }
        return LL_EOF;
    }

    retval=rmap_lex_read(RP);
/*    LOG(llevDebug," load completed, object=%s\n",op->name);*/
    return retval;
}


/* This takes a buffer, scans it for variables, and sets those variables
 * as appropriate in op.
 *
 * This function appears to be used in only 2 places - in crossedit to
 * override values and in c_wiz to mutate values.
 */
int set_random_map_variable(RMParms *rp,const char *buf) {
    YY_BUFFER_STATE  yybufstate;
    int retval;

    yybufstate=yy_scan_string(buf);
    retval=rmap_lex_read(rp);
    yy_delete_buffer(yybufstate);
    return retval;
}
Revision:	1.4
Committed:	Sat Dec 30 18:45:28 2006 UTC (19 years, 9 months ago) by root
Branch:	MAIN
CVS Tags:	HEAD
Changes since 1.3:	+0 -0 lines
State:	*FILE REMOVED*
Log Message:	random maps are nphard
#	User	Rev	Content
1	root	1.1	/*
2			CrossFire, A Multiplayer game for X-windows
3
4			Copyright (C) 1994 Mark Wedel
5			Copyright (C) 1992 Frank Tore Johansen
6
7			This program is free software; you can redistribute it and/or modify
8			it under the terms of the GNU General Public License as published by
9			the Free Software Foundation; either version 2 of the License, or
10			(at your option) any later version.
11
12			This program is distributed in the hope that it will be useful,
13			but WITHOUT ANY WARRANTY; without even the implied warranty of
14			MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15			GNU General Public License for more details.
16
17			You should have received a copy of the GNU General Public License
18			along with this program; if not, write to the Free Software
19			Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
21			The author can be reached via e-mail to mark@pyramid.com
22			*/
23
24	root	1.3	%{
25	root	1.1
26			#include <global.h>
27			#include <loader.h>
28			#include <random_map.h>
29
30	root	1.2	#define LO_REPEAT 0
31			#define LO_LINEMODE 1
32			#define LO_NEWFILE 2
33			#define LO_NOREAD 3
34
35			int yyerror(char *s)
36			{
37			LOG(llevError, "%s: %s\n", s, yytext);
38			return -1;
39			}
40	root	1.1
41			#define YY_DECL int rmap_lex_read(RMParms *RP)
42
43			static char *rmap_yval();
44
45			static int rmap_lex_error;
46
47
48			#define IVAL atoi(rmap_yval())
49			#define FVAL atof(rmap_yval())
50
51			%}
52
53
54
55			S [ \t]+.+
56			WS [ \t]*
57
58			%x MESSAGE
59
60			/* Don't have to link with -lfl with this */
61			%option noyywrap
62
63			/* need yy_push_state, yy_pop_state */
64			%option stack
65
66			%%
67
68			%{
69			/* Declare some local variables */
70
71			rmap_lex_error=0;
72
73			%}
74
75
76
77
78			^wallstyle{S} strcpy(RP->wallstyle,rmap_yval());
79			^floorstyle{S} strcpy(RP->floorstyle,rmap_yval());
80			^monsterstyle{S} strcpy(RP->monsterstyle,rmap_yval());
81			^treasurestyle{S} strcpy(RP->treasurestyle,rmap_yval());
82			^layoutstyle{S} strcpy(RP->layoutstyle,rmap_yval());
83			^doorstyle{S} strcpy(RP->doorstyle,rmap_yval());
84			^decorstyle{S} strcpy(RP->decorstyle,rmap_yval());
85			^xsize{S} RP->Xsize = IVAL;
86			^ysize{S} RP->Ysize = IVAL;
87			^expand2x{S} RP->expand2x = IVAL;
88			^layoutoptions1{S} RP->layoutoptions1 = IVAL;
89			^layoutoptions2{S} RP->layoutoptions2 = IVAL;
90			^layoutoptions3{S} RP->layoutoptions3 = IVAL;
91			^symmetry{S} RP->symmetry = IVAL;
92			^difficulty{S} RP->difficulty = IVAL;
93			^difficulty_increase{S} RP->difficulty_increase = FVAL;
94			^decoroptions{S} RP->decoroptions = IVAL;
95			^exitstyle{S} strcpy(RP->exitstyle,rmap_yval());
96			^dungeon_level{S} RP->dungeon_level = IVAL;
97			^dungeon_depth{S} RP->dungeon_depth = IVAL;
98			^final_map{S} strcpy(RP->final_map,rmap_yval());
99			^orientation{S} RP-> orientation = IVAL;
100			^origin_x{S} RP->origin_x = IVAL;
101			^origin_y{S} RP-> origin_y = IVAL;
102			^origin_map{S} strcpy(RP->origin_map,rmap_yval());
103			^random_seed{S} RP->random_seed = IVAL;
104			^treasureoptions{S} RP->treasureoptions = IVAL;
105			^exit_on_final_map{S} strcpy(RP->exit_on_final_map,rmap_yval());
106
107			<>(^{WS}$)\|\n {/ ignore empty lines, newlines we don't do above */}
108			#.*\n {}
109
110			<<EOF>> {/* If we got an error, return the error. Otherwise, return that we got EOF */
111			if (rmap_lex_error!=0) return rmap_lex_error; else return LL_EOF;}
112			.* { yyerror( "Unrecognized string"); rmap_lex_error= -1; }
113			%%
114
115			/int yyerror(char s)
116			{
117			return -1;
118			}
119			*/
120
121			/* Our save file syntax is very simple, so we can use a very simple
122			* processing mechanism here instead using something like bison
123			* This skips over the space and returns the value, or "" if no value
124			* is found.
125			*/
126			static char *rmap_yval()
127			{
128			static char *em="";
129			char *cp;
130
131			cp=strchr(yytext,' ');
132			if (cp) return cp+1;
133			else return em;
134			}
135
136
137
138
139			int load_parameters(FILE fp, int bufstate,RMParms RP) {
140			int retval;
141			char inbuf[MAX_BUF];
142
143			if (bufstate==LO_NEWFILE \|\| bufstate==LO_NOREAD) {
144			yy_delete_buffer(YY_CURRENT_BUFFER);
145			yy_switch_to_buffer(yy_create_buffer(fp, YY_BUF_SIZE));
146			if (bufstate==LO_NOREAD) return LL_NORMAL;
147			}
148			if (bufstate==LO_LINEMODE) {
149			YY_BUFFER_STATE yybufstate;
150			while (fgets(inbuf, MAX_BUF-3, fp)) {
151			yybufstate=yy_scan_string(inbuf);
152			retval=rmap_lex_read(RP);
153			yy_delete_buffer(yybufstate);
154			if (retval==LL_NORMAL) return retval;
155			}
156			return LL_EOF;
157			}
158
159			retval=rmap_lex_read(RP);
160			/* LOG(llevDebug," load completed, object=%s\n",op->name);*/
161			return retval;
162			}
163
164
165			/* This takes a buffer, scans it for variables, and sets those variables
166			* as appropriate in op.
167			*
168			* This function appears to be used in only 2 places - in crossedit to
169			* override values and in c_wiz to mutate values.
170			*/
171			int set_random_map_variable(RMParms rp,const char buf) {
172			YY_BUFFER_STATE yybufstate;
173			int retval;
174
175			yybufstate=yy_scan_string(buf);
176			retval=rmap_lex_read(rp);
177			yy_delete_buffer(yybufstate);
178			return retval;
179			}