Subversion Repositories eduke32

Rev

Rev 532 | Rev 547 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
5 Plagman 1
//-------------------------------------------------------------------------
2
/*
484 terminx 3
Copyright (C) 1996, 2003 - 3D Realms Entertainment
4
Copyright (C) 2000, 2003 - Matt Saettler (EDuke Enhancements)
5
Copyright (C) 2004, 2007 - EDuke32 developers
5 Plagman 6
 
7
This file is part of EDuke32
8
 
9
EDuke32 is free software; you can redistribute it and/or
10
modify it under the terms of the GNU General Public License version 2
11
as published by the Free Software Foundation.
12
 
13
This program is distributed in the hope that it will be useful,
14
but WITHOUT ANY WARRANTY; without even the implied warranty of
15
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
16
 
17
See the GNU General Public License for more details.
18
 
19
You should have received a copy of the GNU General Public License
20
along with this program; if not, write to the Free Software
21
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
22
*/
23
//-------------------------------------------------------------------------
24
 
25
#include "duke3d.h"
26
#include "gamedef.h"
27
 
28
#include "osd.h"
29
 
30
int conversion = 13;
31
 
398 terminx 32
char compilefile[BMAX_PATH] = "(none)";  // file we're currently compiling
5 Plagman 33
static char parsing_item_name[MAXVARLABEL] = "(none)", previous_item_name[MAXVARLABEL] = "NULL";
34
 
432 terminx 35
int total_lines,line_number;
36
static int checking_ifelse,parsing_state;
5 Plagman 37
char g_szBuf[1024];
38
 
39
long *casescriptptr=NULL;      // the pointer to the start of the case table in a switch statement
40
// first entry is 'default' code.
432 terminx 41
static int casecount = 0;
42
static int checking_switch = 0, current_event = -1;
43
static int labelsonly = 0, nokeywordcheck = 0, dynamicremap = 0;
44
static int num_braces = 0;    // init to some sensible defaults
5 Plagman 45
 
92 terminx 46
int redefined_quote_count = 0;
5 Plagman 47
 
48
long *aplWeaponClip[MAX_WEAPONS];       // number of items in magazine
49
long *aplWeaponReload[MAX_WEAPONS];     // delay to reload (include fire)
50
long *aplWeaponFireDelay[MAX_WEAPONS];      // delay to fire
51
long *aplWeaponHoldDelay[MAX_WEAPONS];      // delay after release fire button to fire (0 for none)
52
long *aplWeaponTotalTime[MAX_WEAPONS];      // The total time the weapon is cycling before next fire.
53
long *aplWeaponFlags[MAX_WEAPONS];      // Flags for weapon
54
long *aplWeaponShoots[MAX_WEAPONS];     // what the weapon shoots
55
long *aplWeaponSpawnTime[MAX_WEAPONS];      // the frame at which to spawn an item
56
long *aplWeaponSpawn[MAX_WEAPONS];      // the item to spawn
57
long *aplWeaponShotsPerBurst[MAX_WEAPONS];  // number of shots per 'burst' (one ammo per 'burst'
58
long *aplWeaponWorksLike[MAX_WEAPONS];      // What original the weapon works like
59
long *aplWeaponInitialSound[MAX_WEAPONS];   // Sound made when initialy firing. zero for no sound
60
long *aplWeaponFireSound[MAX_WEAPONS];      // Sound made when firing (each time for automatic)
61
long *aplWeaponSound2Time[MAX_WEAPONS];     // Alternate sound time
62
long *aplWeaponSound2Sound[MAX_WEAPONS];    // Alternate sound sound ID
63
long *aplWeaponReloadSound1[MAX_WEAPONS];    // Sound of magazine being removed
64
long *aplWeaponReloadSound2[MAX_WEAPONS];    // Sound of magazine being inserted
65
 
66
int g_iReturnVarID=-1;      // var ID of "RETURN"
67
int g_iWeaponVarID=-1;      // var ID of "WEAPON"
68
int g_iWorksLikeVarID=-1;   // var ID of "WORKSLIKE"
69
int g_iZRangeVarID=-1;      // var ID of "ZRANGE"
70
int g_iAngRangeVarID=-1;    // var ID of "ANGRANGE"
71
int g_iAimAngleVarID=-1;    // var ID of "AUTOAIMANGLE"
72
int g_iLoTagID=-1;          // var ID of "LOTAG"
73
int g_iHiTagID=-1;          // var ID of "HITAG"
74
int g_iTextureID=-1;        // var ID of "TEXTURE"
75
int g_iThisActorID=-1;      // var ID of "THISACTOR"
76
 
77
long *actorLoadEventScrptr[MAXTILES];
78
 
79
long *apScriptGameEvent[MAXGAMEEVENTS];
80
long *parsing_event=NULL;
81
 
82
MATTGAMEVAR aGameVars[MAXGAMEVARS];
83
int iGameVarCount=0;
84
 
85
MATTGAMEVAR aDefaultGameVars[MAXGAMEVARS];  // the 'original' values
86
 
87
extern long qsetmode;
88
 
432 terminx 89
char *textptr;
90
int error,warning;
91
 
335 terminx 92
enum labeltypes
93
{
255 terminx 94
    LABEL_ANY    = -1,
95
    LABEL_DEFINE = 1,
96
    LABEL_STATE  = 2,
97
    LABEL_ACTOR  = 4,
98
    LABEL_ACTION = 8,
99
    LABEL_AI     = 16,
100
    LABEL_MOVE   = 32,
5 Plagman 101
};
102
 
437 terminx 103
static const char *labeltypenames[] =
335 terminx 104
    {
105
        "define",
106
        "state",
107
        "actor",
108
        "action",
109
        "ai",
110
        "move"
111
    };
5 Plagman 112
 
437 terminx 113
static const char *translatelabeltype(long type)
5 Plagman 114
{
115
    int i;
116
    char x[64];
117
 
118
    x[0] = 0;
335 terminx 119
    for (i=0;i<6;i++)
120
    {
5 Plagman 121
        if (!(type & (1<<i))) continue;
122
        if (x[0]) Bstrcat(x, " or ");
123
        Bstrcat(x, labeltypenames[i]);
124
    }
125
    return strdup(x);
126
}
127
 
128
#define NUMKEYWORDS (signed int)(sizeof(keyw)/sizeof(keyw[0]))
129
 
484 terminx 130
static const char *keyw[] =
131
    {
132
        "definelevelname",          // 0  defines level name
133
        "actor",                    // 1  defines an actor
134
        "addammo",                  // 2  adds ammo to a weapon
135
        "ifrnd",                    // 3  checks against a randomizer
136
        "enda",                     // 4  ends an actor definition
137
        "ifcansee",                 // 5  checks if the player can see an object
138
        "ifhitweapon",              // 6  checks if an object was hit by a weapon
139
        "action",                   // 7  defines an action if used outside a state or actor, otherwise triggers actor to perform action
140
        "ifpdistl",                 // 8  checks if player distance is less than value
141
        "ifpdistg",                 // 9  checks if player distance is more than value
142
        "else",                     // 10 used with if checks
143
        "strength",                 // 11 sets health
144
        "break",                    // 12 stops processing
145
        "shoot",                    // 13 shoots a projectile
146
        "palfrom",                  // 14 used for player screen shading effect, sets p->pals_time and p->pals[0-2]
147
        "sound",                    // 15 plays a sound that was defined with definesound
148
        "fall",                     // 16 causes actor to fall to sector floor height
149
        "state",                    // 17 begins defining a state if used outside a state or actor, otherwise calls a state
150
        "ends",                     // 18 ends defining a state
151
        "define",                   // 19 defines a value
152
        "<null>",                   // 20 was previously used to define a comment
153
        "ifai",                     // 21 checks if actor is currently performing a specific ai function
154
        "killit",                   // 22 kills an actor
155
        "addweapon",                // 23 adds a weapon to the closest player
156
        "ai",                       // 24 sets an ai function to be used by an actor
157
        "addphealth",               // 25 adds health to the player
158
        "ifdead",                   // 26 checks if actor is dead
159
        "ifsquished",               // 27 checks if actor has been squished
160
        "sizeto",                   // 28 gradually increases actor size until it matches parameters given
161
        "{",                        // 29 used to indicate segments of code
162
        "}",                        // 30 used to indicate segments of code
163
        "spawn",                    // 31 spawns an actor
164
        "move",                     // 32
165
        "ifwasweapon",              // 33
166
        "ifaction",                 // 34
167
        "ifactioncount",            // 35
168
        "resetactioncount",         // 36
169
        "debris",                   // 37
170
        "pstomp",                   // 38
171
        "<null>",                   // 39 was previously used to define the start of a comment block
172
        "cstat",                    // 40
173
        "ifmove",                   // 41
174
        "resetplayer",              // 42
175
        "ifonwater",                // 43
176
        "ifinwater",                // 44
177
        "ifcanshoottarget",         // 45
178
        "ifcount",                  // 46
179
        "resetcount",               // 47
180
        "addinventory",             // 48
181
        "ifactornotstayput",        // 49
182
        "hitradius",                // 50
183
        "ifp",                      // 51
184
        "count",                    // 52
185
        "ifactor",                  // 53
186
        "music",                    // 54
187
        "include",                  // 55
188
        "ifstrength",               // 56
189
        "definesound",              // 57
190
        "guts",                     // 58
191
        "ifspawnedby",              // 59
192
        "gamestartup",              // 60
193
        "wackplayer",               // 61
194
        "ifgapzl",                  // 62
195
        "ifhitspace",               // 63
196
        "ifoutside",                // 64
197
        "ifmultiplayer",            // 65
198
        "operate",                  // 66
199
        "ifinspace",                // 67
200
        "debug",                    // 68
201
        "endofgame",                // 69
202
        "ifbulletnear",             // 70
203
        "ifrespawn",                // 71
204
        "iffloordistl",             // 72
205
        "ifceilingdistl",           // 73
206
        "spritepal",                // 74
207
        "ifpinventory",             // 75
208
        "betaname",                 // 76
209
        "cactor",                   // 77
210
        "ifphealthl",               // 78
211
        "definequote",              // 79
212
        "quote",                    // 80
213
        "ifinouterspace",           // 81
214
        "ifnotmoving",              // 82
215
        "respawnhitag",             // 83
216
        "tip",                      // 84
217
        "ifspritepal",              // 85
218
        "money",                    // 86
219
        "soundonce",                // 87
220
        "addkills",                 // 88
221
        "stopsound",                // 89
222
        "ifawayfromwall",           // 90
223
        "ifcanseetarget",           // 91
224
        "globalsound",              // 92
225
        "lotsofglass",              // 93
226
        "ifgotweaponce",            // 94
227
        "getlastpal",               // 95
228
        "pkick",                    // 96
229
        "mikesnd",                  // 97
230
        "useractor",                // 98
231
        "sizeat",                   // 99
232
        "addstrength",              // 100  [#]
233
        "cstator",                  // 101
234
        "mail",                     // 102
235
        "paper",                    // 103
236
        "tossweapon",               // 104
237
        "sleeptime",                // 105
238
        "nullop",                   // 106
239
        "definevolumename",         // 107
240
        "defineskillname",          // 108
241
        "ifnosounds",               // 109
242
        "clipdist",                 // 110
243
        "ifangdiffl",               // 111
244
        "gamevar",                  // 112
245
        "ifvarl",                   // 113
246
        "ifvarg",                   // 114
247
        "setvarvar",                // 115
248
        "setvar",                   // 116
249
        "addvarvar",                // 117
250
        "addvar",                   // 118
251
        "ifvarvarl",                // 119
252
        "ifvarvarg",                // 120
253
        "addlogvar",                // 121
254
        "addlog",                   // 122
255
        "onevent",                  // 123
256
        "endevent",                 // 124
257
        "ifvare",                   // 125
258
        "ifvarvare",                // 126
259
        "spgetlotag",               // 127
260
        "spgethitag",               // 128
261
        "sectgetlotag",             // 129
262
        "sectgethitag",             // 130
263
        "ifsound",                  // 131
264
        "gettexturefloor",          // 132
265
        "gettextureceiling",        // 133
266
        "inittimer",                // 134
267
        "starttrack",               // 135
268
        "randvar",                  // 136
269
        "enhanced",                 // 137
270
        "getangletotarget",         // 138
271
        "getactorangle",            // 139
272
        "setactorangle",            // 140
273
        "mulvar",                   // 141
274
        "mulvarvar",                // 142
275
        "divvar",                   // 143
276
        "divvarvar",                // 144
277
        "modvar",                   // 145
278
        "modvarvar",                // 146
279
        "andvar",                   // 147
280
        "andvarvar",                // 148
281
        "orvar",                    // 149
282
        "orvarvar",                 // 150
283
        "getplayerangle",           // 151
284
        "setplayerangle",           // 152
285
        "lockplayer",               // 153
286
        "setsector",                // 154
287
        "getsector",                // 155
288
        "setactor",                 // 156
289
        "getactor",                 // 157
290
        "setwall",                  // 158
291
        "getwall",                  // 159
292
        "findnearactor",            // 160
293
        "findnearactorvar",         // 161
294
        "setactorvar",              // 162
295
        "getactorvar",              // 163
296
        "espawn",                   // 164
297
        "getplayer",                // 165
298
        "setplayer",                // 166
299
        "sqrt",                     // 167
300
        "eventloadactor",           // 168
301
        "espawnvar",                // 169
302
        "getuserdef",               // 170
303
        "setuserdef",               // 171
304
        "subvarvar",                // 172
305
        "subvar",                   // 173
306
        "ifvarn",                   // 174
307
        "ifvarvarn",                // 175
308
        "ifvarand",                 // 176
309
        "ifvarvarand",              // 177
310
        "myos",                     // 178
311
        "myospal",                  // 179
312
        "displayrand",              // 180
313
        "sin",                      // 181
314
        "xorvarvar",                // 182
315
        "xorvar",                   // 183
316
        "randvarvar",               // 184
317
        "myosx",                    // 185
318
        "myospalx",                 // 186
319
        "gmaxammo",                 // 187
320
        "smaxammo",                 // 188
321
        "startlevel",               // 189
322
        "eshoot",                   // 190
323
        "qspawn",                   // 191
324
        "rotatesprite",             // 192
325
        "defineprojectile",         // 193
326
        "spriteshadow",             // 194
327
        "cos",                      // 195
328
        "eshootvar",                // 196
329
        "findnearactor3d",          // 197
330
        "findnearactor3dvar",       // 198
331
        "flash",                    // 199
332
        "qspawnvar",                // 200
333
        "eqspawn",                  // 201
334
        "eqspawnvar",               // 202
335
        "minitext",                 // 203
336
        "gametext",                 // 204
337
        "digitalnumber",            // 205
338
        "addweaponvar",             // 206
339
        "setprojectile",            // 207
340
        "angoff",                   // 208
341
        "updatesector",             // 209
342
        "insertspriteq",            // 210
343
        "angoffvar",                // 211
344
        "whilevarn",                // 212
345
        "switch",                   // 213
346
        "case",                     // 214
347
        "default",                  // 215
348
        "endswitch",                // 216
349
        "shootvar",                 // 217
350
        "soundvar",                 // 218
351
        "findplayer",               // 219
352
        "findotherplayer",          // 220
353
        "activatebysector",         // 221 sectnum, spriteid
354
        "operatesectors",           // 222 sectnum, spriteid
355
        "operaterespawns",          // 223 lotag
356
        "operateactivators",        // 224 lotag, player index
357
        "operatemasterswitches",    // 225 lotag
358
        "checkactivatormotion",     // 226 lotag
359
        "zshoot",                   // 227 zvar projnum
360
        "dist",                     // 228 sprite1 sprite2
361
        "ldist",                    // 229 sprite1 sprite2
362
        "shiftvarl",                // 230
363
        "shiftvarr",                // 231
364
        "spritenvg",                // 232
365
        "getangle",                 // 233
366
        "whilevarvarn",             // 234
367
        "hitscan",                  // 235
368
        "time",                     // 236
369
        "getplayervar",             // 237
370
        "setplayervar",             // 238
371
        "mulscale",                 // 239
372
        "setaspect",                // 240
373
        "ezshoot",                  // 241
374
        "spritenoshade",            // 242
375
        "movesprite",               // 243
376
        "checkavailweapon",         // 244
377
        "soundoncevar",             // 245
378
        "updatesectorz",            // 246
379
        "stopallsounds",            // 247
380
        "ssp",                      // 248
381
        "stopsoundvar",             // 249
382
        "displayrandvar",           // 250
383
        "displayrandvarvar",        // 251
384
        "checkavailinven",          // 252
385
        "globalsoundvar",           // 253
386
        "guniqhudid",               // 254
387
        "getprojectile",            // 255
388
        "getthisprojectile",        // 256
389
        "setthisprojectile",        // 257
390
        "definecheat",              // 258
391
        "cheatkeys",                // 259
392
        "userquote",                // 260
393
        "precache",                 // 261
394
        "definegamefuncname",       // 262
395
        "redefinequote",            // 263
396
        "qsprintf",                 // 264
397
        "getpname",                 // 265
398
        "qstrcat",                  // 266
399
        "qstrcpy",                  // 267
400
        "setsprite",                // 268
401
        "rotatepoint",              // 269
402
        "dragpoint",                // 270
403
        "getzrange",                // 271
404
        "changespritestat",         // 272
405
        "getceilzofslope",          // 273
406
        "getflorzofslope",          // 274
407
        "neartag",                  // 275
408
        "definegametype",           // 276
409
        "changespritesect",         // 277
410
        "spriteflags",              // 278
411
        "savegamevar",              // 279
412
        "readgamevar",              // 280
413
        "findnearsprite",           // 281
414
        "findnearspritevar",        // 282
415
        "findnearsprite3d",         // 283
416
        "findnearsprite3dvar",      // 284
417
        "dynamicremap",             // 285
418
        "setinput",                 // 286
419
        "getinput",                 // 287
420
        "save",                                    // 288
421
        "cansee",                   // 289
422
        "canseespr",                // 290
423
        "findnearactorz",           // 291
424
        "findnearactorzvar",        // 292
425
        "findnearspritez",          // 293
426
        "findnearspritezvar",       // 294
427
        "zshootvar",                               // 295
428
        "ezshootvar",                      // 296
429
        "getcurraddress",                  // 297
430
        "jump",                                    // 298
431
        "qstrlen",                                 // 299
432
        "getincangle",              // 300
433
        "quake",                    // 301
434
        "showview",                 // 302
435
        "<null>"
436
    };
5 Plagman 437
 
484 terminx 438
LABELS sectorlabels[]=
439
    {
440
        { "wallptr", SECTOR_WALLPTR, 0, 0 },
441
        { "wallnum", SECTOR_WALLNUM, 0, 0 },
442
        { "ceilingz", SECTOR_CEILINGZ, 0, 0 },
443
        { "floorz", SECTOR_FLOORZ, 0, 0 },
444
        { "ceilingstat", SECTOR_CEILINGSTAT, 0, 0 },
445
        { "floorstat", SECTOR_FLOORSTAT, 0, 0 },
446
        { "ceilingpicnum", SECTOR_CEILINGPICNUM, 0, 0 },
447
        { "ceilingslope", SECTOR_CEILINGSLOPE, 0, 0 },
448
        { "ceilingshade", SECTOR_CEILINGSHADE, 0, 0 },
449
        { "ceilingpal", SECTOR_CEILINGPAL, 0, 0 },
450
        { "ceilingxpanning", SECTOR_CEILINGXPANNING, 0, 0 },
451
        { "ceilingypanning", SECTOR_CEILINGYPANNING, 0, 0 },
452
        { "floorpicnum", SECTOR_FLOORPICNUM, 0, 0 },
453
        { "floorslope", SECTOR_FLOORSLOPE, 0, 0 },
454
        { "floorshade", SECTOR_FLOORSHADE, 0, 0 },
455
        { "floorpal", SECTOR_FLOORPAL, 0, 0 },
456
        { "floorxpanning", SECTOR_FLOORXPANNING, 0, 0 },
457
        { "floorypanning", SECTOR_FLOORYPANNING, 0, 0 },
458
        { "visibility", SECTOR_VISIBILITY, 0, 0 },
459
        { "alignto", SECTOR_ALIGNTO, 0, 0 },
460
        { "lotag", SECTOR_LOTAG, 0, 0 },
461
        { "hitag", SECTOR_HITAG, 0, 0 },
462
        { "extra", SECTOR_EXTRA, 0, 0 },
463
        { "", -1, 0, 0  }     // END OF LIST
464
    };
5 Plagman 465
 
484 terminx 466
LABELS walllabels[]=
467
    {
468
        { "x", WALL_X, 0, 0 },
469
        { "y", WALL_Y, 0, 0 },
470
        { "point2", WALL_POINT2, 0, 0 },
471
        { "nextwall", WALL_NEXTWALL, 0, 0 },
472
        { "nextsector", WALL_NEXTSECTOR, 0, 0 },
473
        { "cstat", WALL_CSTAT, 0, 0 },
474
        { "picnum", WALL_PICNUM, 0, 0 },
475
        { "overpicnum", WALL_OVERPICNUM, 0, 0 },
476
        { "shade", WALL_SHADE, 0, 0 },
477
        { "pal", WALL_PAL, 0, 0 },
478
        { "xrepeat", WALL_XREPEAT, 0, 0 },
479
        { "yrepeat", WALL_YREPEAT, 0, 0 },
480
        { "xpanning", WALL_XPANNING, 0, 0 },
481
        { "ypanning", WALL_YPANNING, 0, 0 },
482
        { "lotag", WALL_LOTAG, 0, 0 },
483
        { "hitag", WALL_HITAG, 0, 0 },
484
        { "extra", WALL_EXTRA, 0, 0 },
485
        { "", -1, 0, 0  }     // END OF LIST
486
    };
5 Plagman 487
 
484 terminx 488
LABELS actorlabels[]=
489
    {
490
        { "x", ACTOR_X, 0, 0 },
491
        { "y", ACTOR_Y, 0, 0 },
492
        { "z", ACTOR_Z, 0, 0 },
493
        { "cstat", ACTOR_CSTAT, 0, 0 },
494
        { "picnum", ACTOR_PICNUM, 0, 0 },
495
        { "shade", ACTOR_SHADE, 0, 0 },
496
        { "pal", ACTOR_PAL, 0, 0 },
497
        { "clipdist", ACTOR_CLIPDIST, 0, 0 },
498
        { "detail", ACTOR_DETAIL, 0, 0 },
499
        { "xrepeat", ACTOR_XREPEAT, 0, 0 },
500
        { "yrepeat", ACTOR_YREPEAT, 0, 0 },
501
        { "xoffset", ACTOR_XOFFSET, 0, 0 },
502
        { "yoffset", ACTOR_YOFFSET, 0, 0 },
503
        { "sectnum", ACTOR_SECTNUM, 0, 0 },
504
        { "statnum", ACTOR_STATNUM, 0, 0 },
505
        { "ang", ACTOR_ANG, 0, 0 },
506
        { "owner", ACTOR_OWNER, 0, 0 },
507
        { "xvel", ACTOR_XVEL, 0, 0 },
508
        { "yvel", ACTOR_YVEL, 0, 0 },
509
        { "zvel", ACTOR_ZVEL, 0, 0 },
510
        { "lotag", ACTOR_LOTAG, 0, 0 },
511
        { "hitag", ACTOR_HITAG, 0, 0 },
512
        { "extra", ACTOR_EXTRA, 0, 0 },
5 Plagman 513
 
484 terminx 514
        // hittype labels...
515
        { "htcgg", ACTOR_HTCGG, 0, 0 },
516
        { "htpicnum", ACTOR_HTPICNUM, 0, 0 },
517
        { "htang", ACTOR_HTANG, 0, 0 },
518
        { "htextra", ACTOR_HTEXTRA, 0, 0 },
519
        { "htowner", ACTOR_HTOWNER, 0, 0 },
520
        { "htmovflag", ACTOR_HTMOVFLAG, 0, 0 },
521
        { "httempang", ACTOR_HTTEMPANG, 0, 0 },
522
        { "htactorstayput", ACTOR_HTACTORSTAYPUT, 0, 0 },
523
        { "htdispicnum", ACTOR_HTDISPICNUM, 0, 0 },
524
        { "httimetosleep", ACTOR_HTTIMETOSLEEP, 0, 0 },
525
        { "htfloorz", ACTOR_HTFLOORZ, 0, 0 },
526
        { "htceilingz", ACTOR_HTCEILINGZ, 0, 0 },
527
        { "htlastvx", ACTOR_HTLASTVX, 0, 0 },
528
        { "htlastvy", ACTOR_HTLASTVY, 0, 0 },
529
        { "htbposx", ACTOR_HTBPOSX, 0, 0 },
530
        { "htbposy", ACTOR_HTBPOSY, 0, 0 },
531
        { "htbposz", ACTOR_HTBPOSZ, 0, 0 },
532
        { "htg_t", ACTOR_HTG_T, LABEL_HASPARM2, 8 },
5 Plagman 533
 
484 terminx 534
        // model flags
5 Plagman 535
 
484 terminx 536
        { "angoff", ACTOR_ANGOFF, 0, 0 },
537
        { "pitch", ACTOR_PITCH, 0, 0 },
538
        { "roll", ACTOR_ROLL, 0, 0 },
539
        { "mdxoff", ACTOR_MDXOFF, 0, 0 },
540
        { "mdyoff", ACTOR_MDYOFF, 0, 0 },
541
        { "mdzoff", ACTOR_MDZOFF, 0, 0 },
542
        { "", -1, 0, 0  }     // END OF LIST
543
    };
5 Plagman 544
 
484 terminx 545
LABELS playerlabels[]=
546
    {
547
        { "zoom", PLAYER_ZOOM, 0, 0 },
548
        { "exitx", PLAYER_EXITX, 0, 0 },
549
        { "exity", PLAYER_EXITY, 0, 0 },
550
        { "loogiex", PLAYER_LOOGIEX, LABEL_HASPARM2, 64 },
551
        { "loogiey", PLAYER_LOOGIEY, LABEL_HASPARM2, 64 },
552
        { "numloogs", PLAYER_NUMLOOGS, 0, 0 },
553
        { "loogcnt", PLAYER_LOOGCNT, 0, 0 },
554
        { "posx", PLAYER_POSX, 0, 0 },
555
        { "posy", PLAYER_POSY, 0, 0 },
556
        { "posz", PLAYER_POSZ, 0, 0 },
557
        { "horiz", PLAYER_HORIZ, 0, 0 },
558
        { "ohoriz", PLAYER_OHORIZ, 0, 0 },
559
        { "ohorizoff", PLAYER_OHORIZOFF, 0, 0 },
560
        { "invdisptime", PLAYER_INVDISPTIME, 0, 0 },
561
        { "bobposx", PLAYER_BOBPOSX, 0, 0 },
562
        { "bobposy", PLAYER_BOBPOSY, 0, 0 },
563
        { "oposx", PLAYER_OPOSX, 0, 0 },
564
        { "oposy", PLAYER_OPOSY, 0, 0 },
565
        { "oposz", PLAYER_OPOSZ, 0, 0 },
566
        { "pyoff", PLAYER_PYOFF, 0, 0 },
567
        { "opyoff", PLAYER_OPYOFF, 0, 0 },
568
        { "posxv", PLAYER_POSXV, 0, 0 },
569
        { "posyv", PLAYER_POSYV, 0, 0 },
570
        { "poszv", PLAYER_POSZV, 0, 0 },
571
        { "last_pissed_time", PLAYER_LAST_PISSED_TIME, 0, 0 },
572
        { "truefz", PLAYER_TRUEFZ, 0, 0 },
573
        { "truecz", PLAYER_TRUECZ, 0, 0 },
574
        { "player_par", PLAYER_PLAYER_PAR, 0, 0 },
575
        { "visibility", PLAYER_VISIBILITY, 0, 0 },
576
        { "bobcounter", PLAYER_BOBCOUNTER, 0, 0 },
577
        { "weapon_sway", PLAYER_WEAPON_SWAY, 0, 0 },
578
        { "pals_time", PLAYER_PALS_TIME, 0, 0 },
579
        { "randomflamex", PLAYER_RANDOMFLAMEX, 0, 0 },
580
        { "crack_time", PLAYER_CRACK_TIME, 0, 0 },
581
        { "aim_mode", PLAYER_AIM_MODE, 0, 0 },
582
        { "ang", PLAYER_ANG, 0, 0 },
583
        { "oang", PLAYER_OANG, 0, 0 },
584
        { "angvel", PLAYER_ANGVEL, 0, 0 },
585
        { "cursectnum", PLAYER_CURSECTNUM, 0, 0 },
586
        { "look_ang", PLAYER_LOOK_ANG, 0, 0 },
587
        { "last_extra", PLAYER_LAST_EXTRA, 0, 0 },
588
        { "subweapon", PLAYER_SUBWEAPON, 0, 0 },
589
        { "ammo_amount", PLAYER_AMMO_AMOUNT, LABEL_HASPARM2, MAX_WEAPONS },
590
        { "wackedbyactor", PLAYER_WACKEDBYACTOR, 0, 0 },
591
        { "frag", PLAYER_FRAG, 0, 0 },
592
        { "fraggedself", PLAYER_FRAGGEDSELF, 0, 0 },
593
        { "curr_weapon", PLAYER_CURR_WEAPON, 0, 0 },
594
        { "last_weapon", PLAYER_LAST_WEAPON, 0, 0 },
595
        { "tipincs", PLAYER_TIPINCS, 0, 0 },
596
        { "horizoff", PLAYER_HORIZOFF, 0, 0 },
597
        { "wantweaponfire", PLAYER_WANTWEAPONFIRE, 0, 0 },
598
        { "holoduke_amount", PLAYER_HOLODUKE_AMOUNT, 0, 0 },
599
        { "newowner", PLAYER_NEWOWNER, 0, 0 },
600
        { "hurt_delay", PLAYER_HURT_DELAY, 0, 0 },
601
        { "hbomb_hold_delay", PLAYER_HBOMB_HOLD_DELAY, 0, 0 },
602
        { "jumping_counter", PLAYER_JUMPING_COUNTER, 0, 0 },
603
        { "airleft", PLAYER_AIRLEFT, 0, 0 },
604
        { "knee_incs", PLAYER_KNEE_INCS, 0, 0 },
605
        { "access_incs", PLAYER_ACCESS_INCS, 0, 0 },
606
        { "fta", PLAYER_FTA, 0, 0 },
607
        { "ftq", PLAYER_FTQ, 0, 0 },
608
        { "access_wallnum", PLAYER_ACCESS_WALLNUM, 0, 0 },
609
        { "access_spritenum", PLAYER_ACCESS_SPRITENUM, 0, 0 },
610
        { "kickback_pic", PLAYER_KICKBACK_PIC, 0, 0 },
611
        { "got_access", PLAYER_GOT_ACCESS, 0, 0 },
612
        { "weapon_ang", PLAYER_WEAPON_ANG, 0, 0 },
613
        { "firstaid_amount", PLAYER_FIRSTAID_AMOUNT, 0, 0 },
614
        { "somethingonplayer", PLAYER_SOMETHINGONPLAYER, 0, 0 },
615
        { "on_crane", PLAYER_ON_CRANE, 0, 0 },
616
        { "i", PLAYER_I, 0, 0 },
617
        { "one_parallax_sectnum", PLAYER_ONE_PARALLAX_SECTNUM, 0, 0 },
618
        { "over_shoulder_on", PLAYER_OVER_SHOULDER_ON, 0, 0 },
619
        { "random_club_frame", PLAYER_RANDOM_CLUB_FRAME, 0, 0 },
620
        { "fist_incs", PLAYER_FIST_INCS, 0, 0 },
621
        { "one_eighty_count", PLAYER_ONE_EIGHTY_COUNT, 0, 0 },
622
        { "cheat_phase", PLAYER_CHEAT_PHASE, 0, 0 },
623
        { "dummyplayersprite", PLAYER_DUMMYPLAYERSPRITE, 0, 0 },
624
        { "extra_extra8", PLAYER_EXTRA_EXTRA8, 0, 0 },
625
        { "quick_kick", PLAYER_QUICK_KICK, 0, 0 },
626
        { "heat_amount", PLAYER_HEAT_AMOUNT, 0, 0 },
627
        { "actorsqu", PLAYER_ACTORSQU, 0, 0 },
628
        { "timebeforeexit", PLAYER_TIMEBEFOREEXIT, 0, 0 },
629
        { "customexitsound", PLAYER_CUSTOMEXITSOUND, 0, 0 },
630
        { "weaprecs[16]", PLAYER_WEAPRECS, 0, 0 },
631
        { "weapreccnt", PLAYER_WEAPRECCNT, 0, 0 },
632
        { "interface_toggle_flag", PLAYER_INTERFACE_TOGGLE_FLAG, 0, 0 },
633
        { "rotscrnang", PLAYER_ROTSCRNANG, 0, 0 },
634
        { "dead_flag", PLAYER_DEAD_FLAG, 0, 0 },
635
        { "show_empty_weapon", PLAYER_SHOW_EMPTY_WEAPON, 0, 0 },
636
        { "scuba_amount", PLAYER_SCUBA_AMOUNT, 0, 0 },
637
        { "jetpack_amount", PLAYER_JETPACK_AMOUNT, 0, 0 },
638
        { "steroids_amount", PLAYER_STEROIDS_AMOUNT, 0, 0 },
639
        { "shield_amount", PLAYER_SHIELD_AMOUNT, 0, 0 },
640
        { "holoduke_on", PLAYER_HOLODUKE_ON, 0, 0 },
641
        { "pycount", PLAYER_PYCOUNT, 0, 0 },
642
        { "weapon_pos", PLAYER_WEAPON_POS, 0, 0 },
643
        { "frag_ps", PLAYER_FRAG_PS, 0, 0 },
644
        { "transporter_hold", PLAYER_TRANSPORTER_HOLD, 0, 0 },
645
        { "last_full_weapon", PLAYER_LAST_FULL_WEAPON, 0, 0 },
646
        { "footprintshade", PLAYER_FOOTPRINTSHADE, 0, 0 },
647
        { "boot_amount", PLAYER_BOOT_AMOUNT, 0, 0 },
648
        { "scream_voice", PLAYER_SCREAM_VOICE, 0, 0 },
649
        { "gm", PLAYER_GM, 0, 0 },
650
        { "on_warping_sector", PLAYER_ON_WARPING_SECTOR, 0, 0 },
651
        { "footprintcount", PLAYER_FOOTPRINTCOUNT, 0, 0 },
652
        { "hbomb_on", PLAYER_HBOMB_ON, 0, 0 },
653
        { "jumping_toggle", PLAYER_JUMPING_TOGGLE, 0, 0 },
654
        { "rapid_fire_hold", PLAYER_RAPID_FIRE_HOLD, 0, 0 },
655
        { "on_ground", PLAYER_ON_GROUND, 0, 0 },
656
        { "name", PLAYER_NAME,  LABEL_ISSTRING, 32 },
657
        { "inven_icon", PLAYER_INVEN_ICON, 0, 0 },
658
        { "buttonpalette", PLAYER_BUTTONPALETTE, 0, 0 },
659
        { "jetpack_on", PLAYER_JETPACK_ON, 0, 0 },
660
        { "spritebridge", PLAYER_SPRITEBRIDGE, 0, 0 },
661
        { "lastrandomspot", PLAYER_LASTRANDOMSPOT, 0, 0 },
662
        { "scuba_on", PLAYER_SCUBA_ON, 0, 0 },
663
        { "footprintpal", PLAYER_FOOTPRINTPAL, 0, 0 },
664
        { "heat_on", PLAYER_HEAT_ON, 0, 0 },
665
        { "holster_weapon", PLAYER_HOLSTER_WEAPON, 0, 0 },
666
        { "falling_counter", PLAYER_FALLING_COUNTER, 0, 0 },
667
        { "gotweapon", PLAYER_GOTWEAPON, LABEL_HASPARM2, MAX_WEAPONS },
668
        { "refresh_inventory", PLAYER_REFRESH_INVENTORY, 0, 0 },
669
        { "palette", PLAYER_PALETTE, 0, 0 },
670
        { "toggle_key_flag", PLAYER_TOGGLE_KEY_FLAG, 0, 0 },
671
        { "knuckle_incs", PLAYER_KNUCKLE_INCS, 0, 0 },
672
        { "walking_snd_toggle", PLAYER_WALKING_SND_TOGGLE, 0, 0 },
673
        { "palookup", PLAYER_PALOOKUP, 0, 0 },
674
        { "hard_landing", PLAYER_HARD_LANDING, 0, 0 },
675
        { "max_+_rooms", PLAYER_MAX_SECRET_ROOMS, 0, 0 },
676
        { "secret_rooms", PLAYER_SECRET_ROOMS, 0, 0 },
677
        { "pals", PLAYER_PALS, LABEL_HASPARM2, 2 },
678
        { "max_actors_killed", PLAYER_MAX_ACTORS_KILLED, 0, 0 },
679
        { "actors_killed", PLAYER_ACTORS_KILLED, 0, 0 },
680
        { "return_to_center", PLAYER_RETURN_TO_CENTER, 0, 0 },
681
        { "runspeed", PLAYER_RUNSPEED, 0, 0 },
682
        { "sbs", PLAYER_SBS, 0, 0 },
683
        { "reloading", PLAYER_RELOADING, 0, 0 },
684
        { "auto_aim", PLAYER_AUTO_AIM, 0, 0 },
685
        { "movement_lock", PLAYER_MOVEMENT_LOCK, 0, 0 },
686
        { "sound_pitch", PLAYER_SOUND_PITCH, 0, 0 },
687
        { "weaponswitch", PLAYER_WEAPONSWITCH, 0, 0 },
688
        { "team", PLAYER_TEAM, 0, 0 },
689
        { "", -1, 0, 0  }     // END OF LIST
690
    };
5 Plagman 691
 
484 terminx 692
LABELS projectilelabels[]=
693
    {
694
        { "workslike", PROJ_WORKSLIKE, 0, 0 },
695
        { "spawns", PROJ_SPAWNS, 0, 0 },
696
        { "sxrepeat", PROJ_SXREPEAT, 0, 0 },
697
        { "syrepeat", PROJ_SYREPEAT, 0, 0 },
698
        { "sound", PROJ_SOUND, 0, 0 },
699
        { "isound", PROJ_ISOUND, 0, 0 },
700
        { "vel", PROJ_VEL, 0, 0 },
701
        { "extra", PROJ_EXTRA, 0, 0 },
702
        { "decal", PROJ_DECAL, 0, 0 },
703
        { "trail", PROJ_TRAIL, 0, 0 },
704
        { "txrepeat", PROJ_TXREPEAT, 0, 0 },
705
        { "tyrepeat", PROJ_TYREPEAT, 0, 0 },
706
        { "toffset", PROJ_TOFFSET, 0, 0 },
707
        { "tnum", PROJ_TNUM, 0, 0 },
708
        { "drop", PROJ_DROP, 0, 0 },
709
        { "cstat", PROJ_CSTAT, 0, 0 },
710
        { "clipdist", PROJ_CLIPDIST, 0, 0 },
711
        { "shade", PROJ_SHADE, 0, 0 },
712
        { "xrepeat", PROJ_XREPEAT, 0, 0 },
713
        { "yrepeat", PROJ_YREPEAT, 0, 0 },
714
        { "pal", PROJ_PAL, 0, 0 },
715
        { "extra_rand", PROJ_EXTRA_RAND, 0, 0 },
716
        { "hitradius", PROJ_HITRADIUS, 0, 0 },
717
        { "velmult", PROJ_VEL_MULT, 0, 0 },
718
        { "offset", PROJ_OFFSET, 0, 0 },
719
        { "bounces", PROJ_BOUNCES, 0, 0 },
720
        { "bsound", PROJ_BSOUND, 0, 0 },
721
        { "range", PROJ_RANGE, 0, 0 },
722
        { "", -1, 0, 0  }     // END OF LIST
723
    };
5 Plagman 724
 
484 terminx 725
LABELS userdefslabels[]=
726
    {
727
        //        { "<null>", 1, 0, 0 },
728
        { "god", USERDEFS_GOD, 0, 0 },
729
        { "warp_on", USERDEFS_WARP_ON, 0, 0 },
730
        { "cashman", USERDEFS_CASHMAN, 0, 0 },
731
        { "eog", USERDEFS_EOG, 0, 0 },
732
        { "showallmap", USERDEFS_SHOWALLMAP, 0, 0 },
733
        { "show_help", USERDEFS_SHOW_HELP, 0, 0 },
734
        { "scrollmode", USERDEFS_SCROLLMODE, 0, 0 },
735
        { "clipping", USERDEFS_CLIPPING, 0, 0 },
736
        { "user_name", USERDEFS_USER_NAME, LABEL_HASPARM2, MAXPLAYERS },
737
        { "ridecule", USERDEFS_RIDECULE, LABEL_HASPARM2 | LABEL_ISSTRING, 10 },
738
        { "savegame", USERDEFS_SAVEGAME, LABEL_HASPARM2 | LABEL_ISSTRING, 10 },
739
        { "pwlockout", USERDEFS_PWLOCKOUT, LABEL_ISSTRING, 128 },
740
        { "rtsname;", USERDEFS_RTSNAME,  LABEL_ISSTRING, 128 },
741
        { "overhead_on", USERDEFS_OVERHEAD_ON, 0, 0 },
742
        { "last_overhead", USERDEFS_LAST_OVERHEAD, 0, 0 },
743
        { "showweapons", USERDEFS_SHOWWEAPONS, 0, 0 },
5 Plagman 744
 
484 terminx 745
        { "pause_on", USERDEFS_PAUSE_ON, 0, 0 },
746
        { "from_bonus", USERDEFS_FROM_BONUS, 0, 0 },
747
        { "camerasprite", USERDEFS_CAMERASPRITE, 0, 0 },
748
        { "last_camsprite", USERDEFS_LAST_CAMSPRITE, 0, 0 },
749
        { "last_level", USERDEFS_LAST_LEVEL, 0, 0 },
750
        { "secretlevel", USERDEFS_SECRETLEVEL, 0, 0 },
5 Plagman 751
 
484 terminx 752
        { "const_visibility", USERDEFS_CONST_VISIBILITY, 0, 0 },
753
        { "uw_framerate", USERDEFS_UW_FRAMERATE, 0, 0 },
754
        { "camera_time", USERDEFS_CAMERA_TIME, 0, 0 },
755
        { "folfvel", USERDEFS_FOLFVEL, 0, 0 },
756
        { "folavel", USERDEFS_FOLAVEL, 0, 0 },
757
        { "folx", USERDEFS_FOLX, 0, 0 },
758
        { "foly", USERDEFS_FOLY, 0, 0 },
759
        { "fola", USERDEFS_FOLA, 0, 0 },
760
        { "reccnt", USERDEFS_RECCNT, 0, 0 },
5 Plagman 761
 
484 terminx 762
        { "entered_name", USERDEFS_ENTERED_NAME, 0, 0 },
763
        { "screen_tilting", USERDEFS_SCREEN_TILTING, 0, 0 },
764
        { "shadows", USERDEFS_SHADOWS, 0, 0 },
765
        { "fta_on", USERDEFS_FTA_ON, 0, 0 },
766
        { "executions", USERDEFS_EXECUTIONS, 0, 0 },
767
        { "auto_run", USERDEFS_AUTO_RUN, 0, 0 },
768
        { "coords", USERDEFS_COORDS, 0, 0 },
769
        { "tickrate", USERDEFS_TICKRATE, 0, 0 },
770
        { "m_coop", USERDEFS_M_COOP, 0, 0 },
771
        { "coop", USERDEFS_COOP, 0, 0 },
772
        { "screen_size", USERDEFS_SCREEN_SIZE, 0, 0 },
773
        { "lockout", USERDEFS_LOCKOUT, 0, 0 },
774
        { "crosshair", USERDEFS_CROSSHAIR, 0, 0 },
775
        { "wchoice[MAXPLAYERS][MAX_WEAPONS]", USERDEFS_WCHOICE, 0, 0 },
776
        { "playerai", USERDEFS_PLAYERAI, 0, 0 },
777
        { "respawn_monsters", USERDEFS_RESPAWN_MONSTERS, 0, 0 },
778
        { "respawn_items", USERDEFS_RESPAWN_ITEMS, 0, 0 },
779
        { "respawn_inventory", USERDEFS_RESPAWN_INVENTORY, 0, 0 },
780
        { "recstat", USERDEFS_RECSTAT, 0, 0 },
781
        { "monsters_off", USERDEFS_MONSTERS_OFF, 0, 0 },
782
        { "brightness", USERDEFS_BRIGHTNESS, 0, 0 },
783
        { "m_respawn_items", USERDEFS_M_RESPAWN_ITEMS, 0, 0 },
784
        { "m_respawn_monsters", USERDEFS_M_RESPAWN_MONSTERS, 0, 0 },
785
        { "m_respawn_inventory", USERDEFS_M_RESPAWN_INVENTORY, 0, 0 },
786
        { "m_recstat", USERDEFS_M_RECSTAT, 0, 0 },
787
        { "m_monsters_off", USERDEFS_M_MONSTERS_OFF, 0, 0 },
788
        { "detail", USERDEFS_DETAIL, 0, 0 },
789
        { "m_ffire", USERDEFS_M_FFIRE, 0, 0 },
790
        { "ffire", USERDEFS_FFIRE, 0, 0 },
791
        { "m_player_skill", USERDEFS_M_PLAYER_SKILL, 0, 0 },
792
        { "m_level_number", USERDEFS_M_LEVEL_NUMBER, 0, 0 },
793
        { "m_volume_number", USERDEFS_M_VOLUME_NUMBER, 0, 0 },
794
        { "multimode", USERDEFS_MULTIMODE, 0, 0 },
795
        { "player_skill", USERDEFS_PLAYER_SKILL, 0, 0 },
796
        { "level_number", USERDEFS_LEVEL_NUMBER, 0, 0 },
797
        { "volume_number", USERDEFS_VOLUME_NUMBER, 0, 0 },
798
        { "m_marker", USERDEFS_M_MARKER, 0, 0 },
799
        { "marker", USERDEFS_MARKER, 0, 0 },
800
        { "mouseflip", USERDEFS_MOUSEFLIP, 0, 0 },
801
        { "statusbarscale", USERDEFS_STATUSBARSCALE, 0, 0 },
802
        { "drawweapon", USERDEFS_DRAWWEAPON, 0, 0 },
803
        { "mouseaiming", USERDEFS_MOUSEAIMING, 0, 0 },
804
        { "weaponswitch", USERDEFS_WEAPONSWITCH, 0, 0 },
805
        { "democams", USERDEFS_DEMOCAMS, 0, 0 },
806
        { "color", USERDEFS_COLOR, 0, 0 },
807
        { "msgdisptime", USERDEFS_MSGDISPTIME, 0, 0 },
808
        { "statusbarmode", USERDEFS_STATUSBARMODE, 0, 0 },
809
        { "m_noexits", USERDEFS_M_NOEXITS, 0, 0 },
810
        { "noexits", USERDEFS_NOEXITS, 0, 0 },
811
        { "autovote", USERDEFS_AUTOVOTE, 0, 0 },
812
        { "automsg", USERDEFS_AUTOMSG, 0, 0 },
813
        { "idplayers", USERDEFS_IDPLAYERS, 0, 0 },
814
        { "team", USERDEFS_TEAM, 0, 0 },
507 terminx 815
        { "viewbob", USERDEFS_VIEWBOB, 0, 0 },
816
        { "weaponsway", USERDEFS_WEAPONSWAY, 0, 0 },
529 terminx 817
        { "angleinterpolation", USERDEFS_ANGLEINTERPOLATION, 0, 0 },
818
        { "deathmsgs", USERDEFS_DEATHMSGS, 0, 0 },
484 terminx 819
        { "", -1, 0, 0  }     // END OF LIST
820
    };
5 Plagman 821
 
484 terminx 822
LABELS inputlabels[]=
823
    {
824
        { "avel", INPUT_AVEL, 0, 0 },
825
        { "horz", INPUT_HORZ, 0, 0 },
826
        { "fvel", INPUT_FVEL, 0, 0 },
827
        { "svel", INPUT_SVEL, 0, 0 },
828
        { "bits", INPUT_BITS, 0, 0 },
829
        { "extbits", INPUT_EXTBITS, 0, 0 },
830
        { "", -1, 0, 0  }     // END OF LIST
831
    };
5 Plagman 832
 
398 terminx 833
static void skipcomments(void)
5 Plagman 834
{
835
    char c;
484 terminx 836
 
5 Plagman 837
    while ((c = *textptr))
838
    {
839
        if (c == ' ' || c == '\t' || c == '\r')
840
            textptr++;
335 terminx 841
        else if (c == '\n')
842
        {
5 Plagman 843
            line_number++;
844
            textptr++;
845
        }
846
        else if (c == '/' && textptr[1] == '/')
847
        {
848
            if (!(error || warning) && condebug > 1)
849
                initprintf("%s:%ld: debug: got comment.\n",compilefile,line_number);
333 terminx 850
            while (*textptr != 0x0a && *textptr != 0x0d && *textptr != 0)
5 Plagman 851
                textptr++;
852
        }
853
        else if (c == '/' && textptr[1] == '*')
854
        {
855
            if (!(error || warning) && condebug > 1)
856
                initprintf("%s:%ld: debug: got start of comment block.\n",compilefile,line_number);
857
            while (*textptr && !(textptr[0] == '*' && textptr[1] == '/'))
858
            {
859
                if (*textptr == '\n')
860
                    line_number++;
861
                textptr++;
862
            }
863
            if ((!(error || warning) && condebug > 1) && (textptr[0] == '*' && textptr[1] == '/'))
864
                initprintf("%s:%ld: debug: got end of comment block.\n",compilefile,line_number);
865
            if (!*textptr)
866
            {
331 terminx 867
                if (!(error || warning) && condebug)
5 Plagman 868
                    initprintf("%s:%ld: debug: EOF in comment!\n",compilefile,line_number);
869
                ReportError(-1);
870
                initprintf("%s:%ld: error: found `/*' with no `*/'.\n",compilefile,line_number);
871
                parsing_state = num_braces = 0;
872
                parsing_actor = 0;
873
                error++;
874
                break;
875
            }
876
            else textptr+=2;
877
        }
878
        else break;
879
    }
880
}
881
 
398 terminx 882
static void DefineProjectile(long lVar1, long lLabelID, long lVar2)
5 Plagman 883
{
331 terminx 884
    switch (lLabelID)
5 Plagman 885
    {
337 terminx 886
    case PROJ_WORKSLIKE:
887
        projectile[lVar1].workslike=lVar2;
888
        break;
5 Plagman 889
 
337 terminx 890
    case PROJ_SPAWNS:
891
        projectile[lVar1].spawns=lVar2;
892
        break;
5 Plagman 893
 
337 terminx 894
    case PROJ_SXREPEAT:
895
        projectile[lVar1].sxrepeat=lVar2;
896
        break;
5 Plagman 897
 
337 terminx 898
    case PROJ_SYREPEAT:
899
        projectile[lVar1].syrepeat=lVar2;
900
        break;
5 Plagman 901
 
337 terminx 902
    case PROJ_SOUND:
903
        projectile[lVar1].sound=lVar2;
904
        break;
5 Plagman 905
 
337 terminx 906
    case PROJ_ISOUND:
907
        projectile[lVar1].isound=lVar2;
908
        break;
5 Plagman 909
 
337 terminx 910
    case PROJ_VEL:
911
        projectile[lVar1].vel=lVar2;
912
        break;
5 Plagman 913
 
337 terminx 914
    case PROJ_EXTRA:
915
        projectile[lVar1].extra=lVar2;
916
        break;
5 Plagman 917
 
337 terminx 918
    case PROJ_DECAL:
919
        projectile[lVar1].decal=lVar2;
920
        break;
5 Plagman 921
 
337 terminx 922
    case PROJ_TRAIL:
923
        projectile[lVar1].trail=lVar2;
924
        break;
5 Plagman 925
 
337 terminx 926
    case PROJ_TXREPEAT:
927
        projectile[lVar1].txrepeat=lVar2;
928
        break;
5 Plagman 929
 
337 terminx 930
    case PROJ_TYREPEAT:
931
        projectile[lVar1].tyrepeat=lVar2;
932
        break;
5 Plagman 933
 
337 terminx 934
    case PROJ_TOFFSET:
935
        projectile[lVar1].toffset=lVar2;
936
        break;
5 Plagman 937
 
337 terminx 938
    case PROJ_TNUM:
939
        projectile[lVar1].tnum=lVar2;
940
        break;
5 Plagman 941
 
337 terminx 942
    case PROJ_DROP:
943
        projectile[lVar1].drop=lVar2;
944
        break;
5 Plagman 945
 
337 terminx 946
    case PROJ_CSTAT:
947
        projectile[lVar1].cstat=lVar2;
948
        break;
5 Plagman 949
 
337 terminx 950
    case PROJ_CLIPDIST:
951
        projectile[lVar1].clipdist=lVar2;
952
        break;
5 Plagman 953
 
337 terminx 954
    case PROJ_SHADE:
955
        projectile[lVar1].shade=lVar2;
956
        break;
5 Plagman 957
 
337 terminx 958
    case PROJ_XREPEAT:
959
        projectile[lVar1].xrepeat=lVar2;
960
        break;
5 Plagman 961
 
337 terminx 962
    case PROJ_YREPEAT:
963
        projectile[lVar1].yrepeat=lVar2;
964
        break;
5 Plagman 965
 
337 terminx 966
    case PROJ_PAL:
967
        projectile[lVar1].pal=lVar2;
968
        break;
5 Plagman 969
 
337 terminx 970
    case PROJ_EXTRA_RAND:
971
        projectile[lVar1].extra_rand=lVar2;
972
        break;
5 Plagman 973
 
337 terminx 974
    case PROJ_HITRADIUS:
975
        projectile[lVar1].hitradius=lVar2;
976
        break;
5 Plagman 977
 
337 terminx 978
    case PROJ_VEL_MULT:
979
        projectile[lVar1].velmult=lVar2;
980
        break;
5 Plagman 981
 
337 terminx 982
    case PROJ_OFFSET:
983
        projectile[lVar1].offset=lVar2;
984
        break;
5 Plagman 985
 
337 terminx 986
    case PROJ_BOUNCES:
987
        projectile[lVar1].bounces=lVar2;
988
        break;
5 Plagman 989
 
337 terminx 990
    case PROJ_BSOUND:
991
        projectile[lVar1].bsound=lVar2;
992
        break;
5 Plagman 993
 
337 terminx 994
    case PROJ_RANGE:
995
        projectile[lVar1].range=lVar2;
996
        break;
5 Plagman 997
 
337 terminx 998
    default:
999
        break;
5 Plagman 1000
    }
1001
 
1002
    //  defaultprojectile[lVar1] = projectile[lVar1];
1003
    Bmemcpy(&defaultprojectile[lVar1], &projectile[lVar1], sizeof(projectile[lVar1]));
1004
 
1005
    return;
1006
}
1007
 
546 terminx 1008
static int CheckEventSync(int iEventID)
5 Plagman 1009
{
331 terminx 1010
    if (parsing_event || parsing_actor)
5 Plagman 1011
    {
331 terminx 1012
        switch (iEventID)
5 Plagman 1013
        {
337 terminx 1014
        case EVENT_CHEATGETSTEROIDS:
1015
        case EVENT_CHEATGETHEAT:
1016
        case EVENT_CHEATGETBOOT:
1017
        case EVENT_CHEATGETSHIELD:
1018
        case EVENT_CHEATGETSCUBA:
1019
        case EVENT_CHEATGETHOLODUKE:
1020
        case EVENT_CHEATGETJETPACK:
1021
        case EVENT_CHEATGETFIRSTAID:
1022
        case EVENT_DISPLAYCROSSHAIR:
1023
        case EVENT_DISPLAYREST:
487 terminx 1024
        case EVENT_DISPLAYROOMS:
492 terminx 1025
        case EVENT_DISPLAYSBAR:
491 terminx 1026
        case EVENT_DISPLAYWEAPON:
1027
        case EVENT_DRAWWEAPON:
337 terminx 1028
        case EVENT_ENTERLEVEL:
1029
        case EVENT_FAKEDOMOVETHINGS:
1030
        case EVENT_GETLOADTILE:
1031
        case EVENT_GETMENUTILE:
1032
        case EVENT_INIT:
1033
        case EVENT_LOGO:
1034
            return 0;
1035
        default:
1036
            return 1;
5 Plagman 1037
        }
1038
    }
1039
    return 1;
1040
}
1041
 
484 terminx 1042
#if 0
1043
void AddLog(const char *psz, ...)
5 Plagman 1044
{
484 terminx 1045
    va_list va;
1046
 
1047
    va_start(va, psz);
1048
    Bvsnprintf(tempbuf, sizeof(tempbuf), psz, va);
1049
    va_end(va);
1050
 
1051
    if (tempbuf[Bstrlen(tempbuf)] != '\n')
5 Plagman 1052
        Bstrcat(tempbuf,"\n");
1053
    if (qsetmode == 200) OSD_Printf(tempbuf);
1054
    else initprintf(tempbuf);
1055
}
484 terminx 1056
#endif
5 Plagman 1057
 
437 terminx 1058
static long GetDefID(const char *szGameLabel)
5 Plagman 1059
{
1060
    int i;
331 terminx 1061
    for (i=0;i<iGameVarCount;i++)
5 Plagman 1062
    {
331 terminx 1063
        if (aGameVars[i].szLabel != NULL)
5 Plagman 1064
        {
333 terminx 1065
            if (Bstrcmp(szGameLabel, aGameVars[i].szLabel) == 0)
102 terminx 1066
            {
1067
                return i;
1068
            }
5 Plagman 1069
        }
1070
    }
1071
    return -1;
1072
}
1073
 
437 terminx 1074
static int ispecial(char c)
5 Plagman 1075
{
331 terminx 1076
    if (c == 0x0a)
5 Plagman 1077
    {
1078
        line_number++;
1079
        return 1;
1080
    }
1081
 
331 terminx 1082
    if (c == ' ' || c == 0x0d)
5 Plagman 1083
        return 1;
1084
 
1085
    return 0;
1086
}
1087
 
398 terminx 1088
static inline int isaltok(char c)
5 Plagman 1089
{
333 terminx 1090
    return (isalnum(c) || c == '{' || c == '}' || c == '/' || c == '*' || c == '-' || c == '_' || c == '.');
5 Plagman 1091
}
1092
 
437 terminx 1093
static long getlabelid(LABELS *pLabel, const char *psz)
5 Plagman 1094
{
1095
    // find the label psz in the table pLabel.
1096
    // returns the ID for the label, or -1
1097
 
1098
    long l=-1;
1099
    int i;
1100
 
331 terminx 1101
    for (i=0;pLabel[i].lId >=0 ; i++)
5 Plagman 1102
    {
331 terminx 1103
        if (!Bstrcasecmp(pLabel[i].name,psz))
5 Plagman 1104
        {
1105
            l= pLabel[i].lId;
1106
            break;  // stop for loop
1107
        }
1108
    }
1109
    return l;
1110
}
1111
 
437 terminx 1112
static long getlabeloffset(LABELS *pLabel, const char *psz)
5 Plagman 1113
{
1114
    // find the label psz in the table pLabel.
1115
    // returns the offset in the array for the label, or -1
1116
    int i;
1117
 
331 terminx 1118
    for (i=0;pLabel[i].lId >=0 ; i++)
5 Plagman 1119
    {
331 terminx 1120
        if (!Bstrcasecmp(pLabel[i].name,psz))
5 Plagman 1121
        {
1122
            //    printf("Label has flags of %02X\n",pLabel[i].flags);
1123
            return i;
1124
        }
1125
    }
1126
    return -1;
1127
}
1128
 
398 terminx 1129
static void getlabel(void)
5 Plagman 1130
{
1131
    long i;
1132
 
1133
    skipcomments();
1134
 
333 terminx 1135
    while (isalnum(*textptr) == 0)
5 Plagman 1136
    {
331 terminx 1137
        if (*textptr == 0x0a) line_number++;
5 Plagman 1138
        textptr++;
333 terminx 1139
        if (*textptr == 0)
5 Plagman 1140
            return;
1141
    }
1142
 
1143
    i = 0;
333 terminx 1144
    while (ispecial(*textptr) == 0 && *textptr!=']' && *textptr!='\t' && *textptr!='\n' && *textptr!='\r')
5 Plagman 1145
        label[(labelcnt<<6)+i++] = *(textptr++);
1146
 
1147
    label[(labelcnt<<6)+i] = 0;
1148
    if (!(error || warning) && condebug > 1)
1149
        initprintf("%s:%ld: debug: got label `%s'.\n",compilefile,line_number,label+(labelcnt<<6));
1150
}
1151
 
398 terminx 1152
static long keyword(void)
5 Plagman 1153
{
1154
    long i;
1155
    char *temptextptr;
1156
 
1157
    skipcomments();
1158
 
1159
    temptextptr = textptr;
1160
 
333 terminx 1161
    while (isaltok(*temptextptr) == 0)
5 Plagman 1162
    {
1163
        temptextptr++;
333 terminx 1164
        if (*temptextptr == 0)
5 Plagman 1165
            return 0;
1166
    }
1167
 
1168
    i = 0;
333 terminx 1169
    while (isaltok(*temptextptr))
5 Plagman 1170
    {
1171
        tempbuf[i] = *(temptextptr++);
1172
        i++;
1173
    }
1174
    tempbuf[i] = 0;
331 terminx 1175
    for (i=0;i<NUMKEYWORDS;i++)
333 terminx 1176
        if (Bstrcmp(tempbuf,keyw[i]) == 0)
5 Plagman 1177
            return i;
1178
 
1179
    return -1;
1180
}
1181
 
398 terminx 1182
static long transword(void) //Returns its code #
5 Plagman 1183
{
1184
    long i, l;
1185
 
1186
    skipcomments();
1187
 
333 terminx 1188
    while (isaltok(*textptr) == 0)
5 Plagman 1189
    {
331 terminx 1190
        if (*textptr == 0x0a) line_number++;
333 terminx 1191
        if (*textptr == 0)
5 Plagman 1192
            return -1;
1193
        textptr++;
1194
    }
1195
 
1196
    l = 0;
333 terminx 1197
    while (isaltok(*(textptr+l)) && !(*(textptr + l) == '.'))
5 Plagman 1198
    {
1199
        tempbuf[l] = textptr[l];
1200
        l++;
1201
    }
333 terminx 1202
    while (isaltok(*(textptr+l)))
5 Plagman 1203
    {
1204
        tempbuf[l] = textptr[l];
1205
        l++;
1206
    }
1207
    tempbuf[l] = 0;
1208
 
331 terminx 1209
    for (i=0;i<NUMKEYWORDS;i++)
5 Plagman 1210
    {
333 terminx 1211
        if (Bstrcmp(tempbuf,keyw[i]) == 0)
5 Plagman 1212
        {
1213
            *scriptptr = i;
1214
            textptr += l;
1215
            scriptptr++;
1216
            if (!(error || warning) && condebug)
1217
                initprintf("%s:%ld: debug: translating keyword `%s'.\n",compilefile,line_number,keyw[i]);
1218
            return i;
1219
        }
1220
    }
1221
 
1222
    textptr += l;
1223
 
333 terminx 1224
    if (tempbuf[0] == '{' && tempbuf[1] != 0)
5 Plagman 1225
    {
1226
        ReportError(-1);
1227
        initprintf("%s:%ld: error: expected a SPACE or CR between `{' and `%s'.\n",compilefile,line_number,tempbuf+1);
1228
    }
333 terminx 1229
    else if (tempbuf[0] == '}' && tempbuf[1] != 0)
5 Plagman 1230
    {
1231
        ReportError(-1);
1232
        initprintf("%s:%ld: error: expected a SPACE or CR between `}' and `%s'.\n",compilefile,line_number,tempbuf+1);
1233
    }
1234
    else ReportError(ERROR_EXPECTEDKEYWORD);
1235
    error++;
1236
    return -1;
1237
}
1238
 
398 terminx 1239
static void transvartype(int type)
5 Plagman 1240
{
91 terminx 1241
    int i=0,f=0;
5 Plagman 1242
 
1243
    skipcomments();
331 terminx 1244
    if (!type && !labelsonly && (isdigit(*textptr) || ((*textptr == '-') && (isdigit(*(textptr+1))))))
5 Plagman 1245
    {
1246
        if (!(error || warning) && condebug)
1247
            initprintf("%s:%ld: debug: accepted constant %ld in place of gamevar.\n",compilefile,line_number,atol(textptr));
1248
        *scriptptr++=MAXGAMEVARS;
1249
        *scriptptr++=atol(textptr);
1250
        getlabel();
1251
        return;
1252
    }
331 terminx 1253
    else if ((*textptr == '-') && !isdigit(*(textptr+1)))
5 Plagman 1254
    {
331 terminx 1255
        if (!type)
5 Plagman 1256
        {
1257
            if (!(error || warning) && condebug)
1258
                initprintf("%s:%ld: debug: flagging gamevar as negative.\n",compilefile,line_number,atol(textptr));
1259
            f = (MAXGAMEVARS<<1);
1260
        }
1261
        else
1262
        {
1263
            error++;
1264
            ReportError(ERROR_SYNTAXERROR);
1265
            getlabel();
1266
            return;
1267
        }
1268
    }
1269
    getlabel();
331 terminx 1270
    if (!nokeywordcheck)
1271
        for (i=0;i<NUMKEYWORDS;i++)
333 terminx 1272
            if (Bstrcmp(label+(labelcnt<<6),keyw[i]) == 0)
5 Plagman 1273
            {
1274
                error++;
1275
                ReportError(ERROR_ISAKEYWORD);
1276
                return;
1277
            }
1278
    i=GetDefID(label+(labelcnt<<6));
331 terminx 1279
    if (i<0)
5 Plagman 1280
    {
331 terminx 1281
        if (!type && !labelsonly)
5 Plagman 1282
        {
1283
            Bstrcpy(tempbuf,label+(labelcnt<<6));
331 terminx 1284
            for (i=0;i<labelcnt;i++)
5 Plagman 1285
            {
333 terminx 1286
                if (Bstrcmp(tempbuf,label+(i<<6)) == 0 && (labeltype[i] & LABEL_DEFINE))
5 Plagman 1287
                {
1288
                    if (!(error || warning) && condebug)
1289
                        initprintf("%s:%ld: debug: accepted defined label `%s' instead of gamevar.\n",compilefile,line_number,label+(i<<6));
1290
                    *scriptptr++=MAXGAMEVARS;
1291
                    *scriptptr++=labelcode[i];
1292
                    textptr++;
1293
                    return;
1294
                }
1295
            }
1296
            error++;
1297
            ReportError(ERROR_NOTAGAMEVAR);
1298
            textptr++;
1299
            return;
1300
        }
437 terminx 1301
        error++;
1302
        ReportError(ERROR_NOTAGAMEVAR);
1303
        textptr++;
1304
        return;
5 Plagman 1305
    }
331 terminx 1306
    if (type == GAMEVAR_FLAG_READONLY && aGameVars[i].dwFlags & GAMEVAR_FLAG_READONLY)
5 Plagman 1307
    {
1308
        error++;
1309
        ReportError(ERROR_VARREADONLY);
1310
        return;
1311
    }
331 terminx 1312
    else if (aGameVars[i].dwFlags & type)
5 Plagman 1313
    {
1314
        error++;
1315
        ReportError(ERROR_VARTYPEMISMATCH);
1316
        return;
1317
    }
331 terminx 1318
    if ((aGameVars[i].dwFlags & GAMEVAR_FLAG_SYNCCHECK) && parsing_actor && CheckEventSync(current_event))
5 Plagman 1319
    {
1320
        ReportError(-1);
1321
        initprintf("%s:%ld: warning: found local gamevar `%s' used within %s.\n",compilefile,line_number,label+(labelcnt<<6),parsing_event?"a synced event":"an actor");
1322
    }
1323
    if (!(error || warning) && condebug > 1)
1324
        initprintf("%s:%ld: debug: accepted gamevar `%s'.\n",compilefile,line_number,label+(labelcnt<<6));
1325
    i |= f;
1326
    *scriptptr++=i;
1327
}
1328
 
296 terminx 1329
static inline void transvar(void)
5 Plagman 1330
{
1331
    transvartype(0);
1332
}
1333
 
437 terminx 1334
static inline void transmultvarstype(int type, int num)
5 Plagman 1335
{
437 terminx 1336
    int i;
331 terminx 1337
    for (i=0;i<num;i++)
5 Plagman 1338
        transvartype(type);
1339
}
1340
 
437 terminx 1341
static inline void transmultvars(int num)
5 Plagman 1342
{
1343
    transmultvarstype(0,num);
1344
}
1345
 
398 terminx 1346
static long transnum(long type)
5 Plagman 1347
{
1348
    long i, l;
1349
 
1350
    skipcomments();
1351
 
333 terminx 1352
    while (isaltok(*textptr) == 0)
5 Plagman 1353
    {
331 terminx 1354
        if (*textptr == 0x0a) line_number++;
5 Plagman 1355
        textptr++;
333 terminx 1356
        if (*textptr == 0)
5 Plagman 1357
            return -1; // eof
1358
    }
1359
 
1360
    l = 0;
333 terminx 1361
    while (isaltok(*(textptr+l)))
5 Plagman 1362
    {
1363
        tempbuf[l] = textptr[l];
1364
        l++;
1365
    }
1366
    tempbuf[l] = 0;
1367
 
331 terminx 1368
    if (!nokeywordcheck)
1369
        for (i=0;i<NUMKEYWORDS;i++)
333 terminx 1370
            if (Bstrcmp(label+(labelcnt<<6),keyw[i]) == 0)
5 Plagman 1371
            {
1372
                error++;
1373
                ReportError(ERROR_ISAKEYWORD);
1374
                textptr+=l;
1375
            }
121 terminx 1376
 
331 terminx 1377
    for (i=0;i<labelcnt;i++)
5 Plagman 1378
    {
333 terminx 1379
        if (!Bstrcmp(tempbuf,label+(i<<6)))
5 Plagman 1380
        {
1381
            char *el,*gl;
1382
 
1383
            if (labeltype[i] & type)
1384
            {
1385
                if (!(error || warning) && condebug > 1)
1386
                {
437 terminx 1387
                    gl = (char *)translatelabeltype(labeltype[i]);
5 Plagman 1388
                    initprintf("%s:%ld: debug: accepted %s label `%s'.\n",compilefile,line_number,gl,label+(i<<6));
1389
                    Bfree(gl);
1390
                }
1391
                *(scriptptr++) = labelcode[i];
1392
                textptr += l;
1393
                return labeltype[i];
1394
            }
1395
            *(scriptptr++) = 0;
1396
            textptr += l;
437 terminx 1397
            el = (char *)translatelabeltype(type);
1398
            gl = (char *)translatelabeltype(labeltype[i]);
5 Plagman 1399
            ReportError(-1);
1400
            initprintf("%s:%ld: warning: expected a %s, found a %s.\n",compilefile,line_number,el,gl);
1401
            Bfree(el);
1402
            Bfree(gl);
1403
            return -1;  // valid label name, but wrong type
1404
        }
1405
    }
1406
 
333 terminx 1407
    if (isdigit(*textptr) == 0 && *textptr != '-')
5 Plagman 1408
    {
1409
        ReportError(ERROR_PARAMUNDEFINED);
1410
        error++;
1411
        textptr+=l;
1412
        return -1; // error!
1413
    }
1414
 
333 terminx 1415
    if (isdigit(*textptr) && labelsonly)
5 Plagman 1416
    {
1417
        ReportError(WARNING_LABELSONLY);
1418
        //         warning++;
1419
    }
1420
    if (!(error || warning) && condebug > 1)
1421
        initprintf("%s:%ld: debug: accepted constant %ld.\n",compilefile,line_number,atol(textptr));
1422
    *scriptptr = atol(textptr);
1423
    scriptptr++;
1424
 
1425
    textptr += l;
1426
 
1427
    return 0;   // literal value
1428
}
1429
 
437 terminx 1430
static int parsecommand(void);
398 terminx 1431
 
1432
static long CountCaseStatements()
5 Plagman 1433
{
1434
    long lCount;
437 terminx 1435
    char *temptextptr = textptr;
1436
    long *savescript = scriptptr;
1437
    long *savecase = casescriptptr;
1438
    int temp_line_number = line_number;
5 Plagman 1439
 
1440
    casecount=0;
1441
    casescriptptr=NULL;
1442
    //Bsprintf(g_szBuf,"CSS: %.12s",textptr);
1443
    //AddLog(g_szBuf);
331 terminx 1444
    while (parsecommand() == 0)
5 Plagman 1445
    {
1446
        //Bsprintf(g_szBuf,"CSSL: %.20s",textptr);
1447
        //AddLog(g_szBuf);
1448
        ;
1449
    }
1450
    // since we processed the endswitch, we need to re-increment checking_switch
1451
    checking_switch++;
1452
 
1453
    textptr=temptextptr;
1454
    scriptptr=savescript;
1455
 
1456
    line_number = temp_line_number;
1457
 
1458
    lCount=casecount;
1459
    casecount=0;
1460
    casescriptptr=savecase;
1461
    return lCount;
1462
}
1463
 
437 terminx 1464
static int parsecommand(void)
5 Plagman 1465
{
437 terminx 1466
    long i, j=0, k=0, *tempscrptr, done, tw;
1467
    char *temptextptr;
5 Plagman 1468
 
335 terminx 1469
    if (((unsigned)(scriptptr-script) > MAXSCRIPTSIZE) && error == 0)
1470
    {
5 Plagman 1471
        /* Bsprintf(tempbuf,"fatal error: Size of compiled CON code exceeds maximum size! (%ud, %d)\n",(unsigned)(scriptptr-script),MAXSCRIPTSIZE); */
1472
        ReportError(-1);
1473
        initprintf("%s:%ld: internal compiler error: Aborted (%ud)\n",compilefile,line_number,(unsigned)(scriptptr-script));
1474
        initprintf(tempbuf);
1475
        error++;
1476
    }
1477
 
333 terminx 1478
    if ((error+warning) > 63 || (*textptr == '\0') || (*(textptr+1) == '\0')) return 1;
5 Plagman 1479
 
331 terminx 1480
    if (condebug)
296 terminx 1481
        ReportError(-1);
1482
 
333 terminx 1483
    if (checking_switch > 0)
5 Plagman 1484
    {
1485
        //Bsprintf(g_szBuf,"PC(): '%.25s'",textptr);
1486
        //AddLog(g_szBuf);
1487
    }
1488
    tw = transword();
1489
    //    Bsprintf(tempbuf,"%s",keyw[tw]);
1490
    //    AddLog(tempbuf);
1491
 
1492
    skipcomments(); // yes?  no?
1493
 
331 terminx 1494
    switch (tw)
5 Plagman 1495
    {
337 terminx 1496
    default:
1497
    case -1:
1498
        return 0; //End
1499
    case CON_STATE:
1500
        if (parsing_actor == 0 && parsing_state == 0)
1501
        {
1502
            getlabel();
1503
            scriptptr--;
1504
            labelcode[labelcnt] = (long) scriptptr;
1505
            labeltype[labelcnt] = LABEL_STATE;
1506
 
1507
            parsing_state = 1;
1508
            Bsprintf(parsing_item_name,"%s",label+(labelcnt<<6));
1509
            labelcnt++;
1510
            return 0;
1511
        }
1512
 
1513
        getlabel();
1514
 
1515
        for (i=0;i<NUMKEYWORDS;i++)
1516
            if (Bstrcmp(label+(labelcnt<<6),keyw[i]) == 0)
335 terminx 1517
            {
337 terminx 1518
                error++;
1519
                ReportError(ERROR_ISAKEYWORD);
335 terminx 1520
                return 0;
1521
            }
337 terminx 1522
        for (j=0;j<labelcnt;j++)
1523
        {
1524
            if (Bstrcmp(label+(j<<6),label+(labelcnt<<6)) == 0)
1525
            {
1526
                if (labeltype[j] & LABEL_STATE)
5 Plagman 1527
                {
337 terminx 1528
                    if (!(error || warning) && condebug > 1)
1529
                        initprintf("%s:%ld: debug: accepted state label `%s'.\n",compilefile,line_number,label+(j<<6));
1530
                    *scriptptr = labelcode[j];
1531
                    break;
5 Plagman 1532
                }
337 terminx 1533
                else
5 Plagman 1534
                {
337 terminx 1535
                    char *gl;
437 terminx 1536
                    gl = (char *)translatelabeltype(labeltype[j]);
337 terminx 1537
                    ReportError(-1);
1538
                    initprintf("%s:%ld: warning: expected a state, found a %s.\n",compilefile,line_number,gl);
1539
                    Bfree(gl);
1540
                    *(scriptptr-1) = CON_NULLOP; // get rid of the state, leaving a nullop to satisfy if conditions
1541
                    return 0;  // valid label name, but wrong type
5 Plagman 1542
                }
1543
            }
337 terminx 1544
        }
1545
        if (j==labelcnt)
1546
        {
1547
            ReportError(-1);
1548
            initprintf("%s:%ld: error: state `%s' not found.\n",compilefile,line_number,label+(labelcnt<<6));
1549
            error++;
1550
        }
1551
        scriptptr++;
1552
        return 0;
1553
 
1554
    case CON_ENDS:
1555
        if (parsing_state == 0)
1556
        {
1557
            ReportError(-1);
1558
            initprintf("%s:%ld: error: found `ends' without open `state'.\n",compilefile,line_number);
1559
            error++;
1560
        }
1561
        //            else
1562
        {
1563
            if (num_braces > 0)
5 Plagman 1564
            {
337 terminx 1565
                ReportError(ERROR_OPENBRACKET);
5 Plagman 1566
                error++;
1567
            }
337 terminx 1568
            if (num_braces < 0)
5 Plagman 1569
            {
337 terminx 1570
                ReportError(ERROR_CLOSEBRACKET);
5 Plagman 1571
                error++;
1572
            }
337 terminx 1573
            if (checking_switch > 0)
5 Plagman 1574
            {
337 terminx 1575
                ReportError(ERROR_NOENDSWITCH);
1576
                error++;
5 Plagman 1577
 
337 terminx 1578
                checking_switch = 0; // can't be checking anymore...
1579
            }
335 terminx 1580
 
337 terminx 1581
            parsing_state = 0;
1582
            Bsprintf(parsing_item_name,"(none)");
1583
        }
1584
        return 0;
1585
 
1586
    case CON_SETTHISPROJECTILE:
1587
    case CON_SETPROJECTILE:
1588
        if (!CheckEventSync(current_event))
1589
            ReportError(WARNING_EVENTSYNC);
1590
    case CON_GETTHISPROJECTILE:
1591
    case CON_GETPROJECTILE:
1592
    {
1593
        long lLabelID;
1594
 
1595
        // syntax getwall[<var>].x <VAR>
1596
        // gets the value of wall[<var>].xxx into <VAR>
1597
 
1598
        // now get name of .xxx
1599
        while ((*textptr != '['))
1600
        {
1601
            textptr++;
1602
        }
1603
        if (*textptr == '[')
1604
            textptr++;
1605
 
1606
        // get the ID of the DEF
1607
        if (tw == CON_SETTHISPROJECTILE)
1608
            labelsonly = 1;
1609
        transvar();
1610
        labelsonly = 0;
1611
        // now get name of .xxx
1612
        while (*textptr != '.')
1613
        {
1614
            if (*textptr == 0xa)
1615
                break;
1616
            if (!*textptr)
1617
                break;
1618
 
1619
            textptr++;
1620
        }
1621
        if (*textptr!='.')
1622
        {
1623
            error++;
1624
            ReportError(ERROR_SYNTAXERROR);
331 terminx 1625
            return 0;
337 terminx 1626
        }
1627
        textptr++;
1628
        /// now pointing at 'xxx'
1629
        getlabel();
1630
        //printf("found xxx label of '%s'\n",   label+(labelcnt<<6));
5 Plagman 1631
 
337 terminx 1632
        lLabelID=getlabeloffset(projectilelabels,label+(labelcnt<<6));
1633
        //printf("LabelID is %ld\n",lLabelID);
1634
        if (lLabelID == -1)
331 terminx 1635
        {
337 terminx 1636
            error++;
1637
            ReportError(ERROR_SYMBOLNOTRECOGNIZED);
1638
            return 0;
1639
        }
5 Plagman 1640
 
337 terminx 1641
        *scriptptr++=projectilelabels[lLabelID].lId;
5 Plagman 1642
 
337 terminx 1643
        //printf("member's flags are: %02Xh\n",playerlabels[lLabelID].flags);
5 Plagman 1644
 
337 terminx 1645
        // now at target VAR...
1646
 
1647
        // get the ID of the DEF
1648
        switch (tw)
1649
        {
1650
        case CON_SETPROJECTILE:
1651
        case CON_SETTHISPROJECTILE:
331 terminx 1652
            transvar();
337 terminx 1653
            break;
1654
        default:
1655
            transvartype(GAMEVAR_FLAG_READONLY);
1656
            break;
1657
        }
1658
        break;
1659
    }
5 Plagman 1660
 
337 terminx 1661
    case CON_GAMEVAR:
1662
        // syntax: gamevar <var1> <initial value> <flags>
1663
        // defines var1 and sets initial value.
1664
        // flags are used to define usage
1665
        // (see top of this files for flags)
1666
        //printf("Got gamedef. Getting Label. '%.20s'\n",textptr);
1667
 
1668
        if (isdigit(*textptr) || (*textptr == '-'))
1669
        {
5 Plagman 1670
            getlabel();
337 terminx 1671
            error++;
1672
            ReportError(ERROR_SYNTAXERROR);
1673
            transnum(LABEL_DEFINE);
1674
            transnum(LABEL_DEFINE);
1675
            scriptptr -= 3; // we complete the process anyways just to skip past the fucked up section
1676
            return 0;
1677
        }
5 Plagman 1678
 
337 terminx 1679
        getlabel();
1680
        //printf("Got Label '%.20s'\n",textptr);
1681
        // Check to see it's already defined
1682
 
1683
        for (i=0;i<NUMKEYWORDS;i++)
1684
            if (Bstrcmp(label+(labelcnt<<6),keyw[i]) == 0)
5 Plagman 1685
            {
1686
                error++;
337 terminx 1687
                ReportError(ERROR_ISAKEYWORD);
5 Plagman 1688
                return 0;
1689
            }
337 terminx 1690
#if 0
1691
        for (i=0;i<iGameVarCount;i++)
1692
        {
1693
            if (aGameVars[i].szLabel != NULL)
5 Plagman 1694
            {
337 terminx 1695
                if (Bstrcmp(label+(labelcnt<<6),aGameVars[i].szLabel) == 0)
1696
                {
1697
                    warning++;
1698
                    initprintf("  * WARNING.(L%ld) duplicate Game definition `%s' ignored.\n",line_number,label+(labelcnt<<6));
102 terminx 1699
                    break;
337 terminx 1700
                }
5 Plagman 1701
            }
1702
        }
337 terminx 1703
#endif
5 Plagman 1704
 
337 terminx 1705
        //printf("Translating number  '%.20s'\n",textptr);
1706
        transnum(LABEL_DEFINE); // get initial value
1707
        //printf("Done Translating number.  '%.20s'\n",textptr);
5 Plagman 1708
 
337 terminx 1709
        transnum(LABEL_DEFINE); // get flags
1710
        //Bsprintf(g_szBuf,"Adding GameVar='%s', val=%l, flags=%lX",label+(labelcnt<<6),
1711
        //      *(scriptptr-2), *(scriptptr-1));
1712
        //AddLog(g_szBuf);
1713
 
1714
        AddGameVar(label+(labelcnt<<6),*(scriptptr-2),
1715
                   (*(scriptptr-1))
1716
                   // can't define default or secret
1717
                   & (~(GAMEVAR_FLAG_DEFAULT | GAMEVAR_FLAG_SECRET))
1718
                  );
1719
        //AddLog("Added gamevar");
1720
        scriptptr -= 3; // no need to save in script...
1721
        return 0;
1722
 
1723
    case CON_DEFINE:
1724
    {
1725
        //printf("Got definition. Getting Label. '%.20s'\n",textptr);
1726
        getlabel();
1727
        //printf("Got label. '%.20s'\n",textptr);
1728
        // Check to see it's already defined
1729
 
1730
        for (i=0;i<NUMKEYWORDS;i++)
1731
            if (Bstrcmp(label+(labelcnt<<6),keyw[i]) == 0)
331 terminx 1732
            {
1733
                error++;
337 terminx 1734
                ReportError(ERROR_ISAKEYWORD);
331 terminx 1735
                return 0;
1736
            }
5 Plagman 1737
 
337 terminx 1738
        for (i=0;i<labelcnt;i++)
1739
        {
546 terminx 1740
            if (Bstrcmp(label+(labelcnt<<6),label+(i<<6)) == 0 /* && (labeltype[i] & LABEL_DEFINE) */)
5 Plagman 1741
            {
337 terminx 1742
                if (i >= defaultlabelcnt)
5 Plagman 1743
                {
337 terminx 1744
                    warning++;
1745
                    ReportError(WARNING_DUPLICATEDEFINITION);
5 Plagman 1746
                }
337 terminx 1747
                break;
5 Plagman 1748
            }
337 terminx 1749
        }
1750
        //printf("Translating. '%.20s'\n",textptr);
1751
        transnum(LABEL_DEFINE);
1752
        //printf("Translated. '%.20s'\n",textptr);
1753
        if (i == labelcnt)
1754
        {
1755
            //              printf("Defining Definition '%s' to be '%d'\n",label+(labelcnt<<6),*(scriptptr-1));
1756
            labeltype[labelcnt] = LABEL_DEFINE;
1757
            labelcode[labelcnt++] = *(scriptptr-1);
1758
            if (*(scriptptr-1) >= 0 && *(scriptptr-1) < MAXTILES && dynamicremap)
1759
                processnames(label+(i<<6),*(scriptptr-1));
1760
        }
1761
        scriptptr -= 2;
1762
        return 0;
1763
    }
5 Plagman 1764
 
337 terminx 1765
    case CON_PALFROM:
1766
        for (j=0;j<4;j++)
1767
        {
1768
            if (keyword() == -1)
1769
                transnum(LABEL_DEFINE);
1770
            else break;
1771
        }
5 Plagman 1772
 
337 terminx 1773
        while (j<4)
1774
        {
1775
            *scriptptr = 0;
1776
            scriptptr++;
1777
            j++;
1778
        }
1779
        return 0;
5 Plagman 1780
 
337 terminx 1781
    case CON_MOVE:
1782
        if (parsing_actor || parsing_state)
1783
        {
1784
            if (!CheckEventSync(current_event))
1785
                ReportError(WARNING_EVENTSYNC);
5 Plagman 1786
 
337 terminx 1787
            if ((transnum(LABEL_MOVE|LABEL_DEFINE) == 0) && (*(scriptptr-1) != 0) && (*(scriptptr-1) != 1))
1788
            {
1789
                ReportError(-1);
1790
                *(scriptptr-1) = 0;
1791
                initprintf("%s:%ld: warning: expected a move, found a constant.\n",compilefile,line_number);
1792
            }
1793
 
1794
            j = 0;
1795
            while (keyword() == -1)
1796
            {
1797
                transnum(LABEL_DEFINE);
1798
                scriptptr--;
1799
                j |= *scriptptr;
1800
            }
1801
            *scriptptr = j;
1802
 
1803
            scriptptr++;
1804
        }
1805
        else
5 Plagman 1806
        {
337 terminx 1807
            scriptptr--;
5 Plagman 1808
            getlabel();
1809
            // Check to see it's already defined
1810
 
331 terminx 1811
            for (i=0;i<NUMKEYWORDS;i++)
333 terminx 1812
                if (Bstrcmp(label+(labelcnt<<6),keyw[i]) == 0)
5 Plagman 1813
                {
1814
                    error++;
1815
                    ReportError(ERROR_ISAKEYWORD);
1816
                    return 0;
1817
                }
1818
 
331 terminx 1819
            for (i=0;i<labelcnt;i++)
546 terminx 1820
                if (Bstrcmp(label+(labelcnt<<6),label+(i<<6)) == 0 /* && (labeltype[i] & LABEL_MOVE) */)
5 Plagman 1821
                {
337 terminx 1822
                    warning++;
1823
                    initprintf("%s:%ld: warning: duplicate move `%s' ignored.\n",compilefile,line_number,label+(labelcnt<<6));
5 Plagman 1824
                    break;
1825
                }
331 terminx 1826
            if (i == labelcnt)
5 Plagman 1827
            {
337 terminx 1828
                labeltype[labelcnt] = LABEL_MOVE;
1829
                labelcode[labelcnt++] = (long) scriptptr;
5 Plagman 1830
            }
337 terminx 1831
            for (j=0;j<2;j++)
5 Plagman 1832
            {
337 terminx 1833
                if (keyword() >= 0) break;
1834
                transnum(LABEL_DEFINE);
5 Plagman 1835
            }
337 terminx 1836
            for (k=j;k<2;k++)
5 Plagman 1837
            {
1838
                *scriptptr = 0;
1839
                scriptptr++;
1840
            }
337 terminx 1841
        }
1842
        return 0;
5 Plagman 1843
 
337 terminx 1844
    case CON_MUSIC:
1845
    {
1846
        // NOTE: this doesn't get stored in the PCode...
1847
 
1848
        // music 1 stalker.mid dethtoll.mid streets.mid watrwld1.mid snake1.mid
1849
        //    thecall.mid ahgeez.mid dethtoll.mid streets.mid watrwld1.mid snake1.mid
1850
        scriptptr--;
1851
        transnum(LABEL_DEFINE); // Volume Number (0/4)
1852
        scriptptr--;
1853
 
1854
        k = *scriptptr-1;
1855
 
1856
        if (k >= 0) // if it's background music
1857
        {
1858
            i = 0;
1859
            // get the file name...
1860
            while (keyword() == -1)
335 terminx 1861
            {
337 terminx 1862
                while (isaltok(*textptr) == 0)
5 Plagman 1863
                {
337 terminx 1864
                    if (*textptr == 0x0a) line_number++;
1865
                    textptr++;
1866
                    if (*textptr == 0) break;
5 Plagman 1867
                }
331 terminx 1868
                j = 0;
412 terminx 1869
                tempbuf[j] = '/';
337 terminx 1870
                while (isaltok(*(textptr+j)))
331 terminx 1871
                {
412 terminx 1872
                    tempbuf[j+1] = textptr[j];
337 terminx 1873
                    j++;
331 terminx 1874
                }
412 terminx 1875
                tempbuf[j+1] = '\0';
385 terminx 1876
 
1877
                if (music_fn[k][i] == NULL)
1878
                    music_fn[k][i] = Bcalloc(Bstrlen(tempbuf)+1,sizeof(char));
386 terminx 1879
                else if ((Bstrlen(tempbuf)+1) > sizeof(music_fn[k][i]))
1880
                    music_fn[k][i] = Brealloc(music_fn[k][i],(Bstrlen(tempbuf)+1));
385 terminx 1881
 
1882
                Bstrcpy(music_fn[k][i],tempbuf);
1883
 
337 terminx 1884
                textptr += j;
381 terminx 1885
                if (i > MAXLEVELS-1) break;
337 terminx 1886
                i++;
5 Plagman 1887
            }
337 terminx 1888
        }
1889
        else
1890
        {
1891
            i = 0;
1892
            while (keyword() == -1)
5 Plagman 1893
            {
337 terminx 1894
                while (isaltok(*textptr) == 0)
5 Plagman 1895
                {
337 terminx 1896
                    if (*textptr == 0x0a) line_number++;
1897
                    textptr++;
1898
                    if (*textptr == 0) break;
331 terminx 1899
                }
337 terminx 1900
                j = 0;
381 terminx 1901
 
337 terminx 1902
                while (isaltok(*(textptr+j)))
331 terminx 1903
                {
337 terminx 1904
                    env_music_fn[i][j] = textptr[j];
1905
                    j++;
331 terminx 1906
                }
337 terminx 1907
                env_music_fn[i][j] = '\0';
1908
 
1909
                textptr += j;
381 terminx 1910
                if (i > MAXVOLUMES-1) break;
337 terminx 1911
                i++;
5 Plagman 1912
            }
337 terminx 1913
        }
1914
    }
1915
    return 0;
5 Plagman 1916
 
337 terminx 1917
    case CON_INCLUDE:
1918
        scriptptr--;
1919
        while (isaltok(*textptr) == 0)
5 Plagman 1920
        {
337 terminx 1921
            if (*textptr == 0x0a) line_number++;
1922
            textptr++;
1923
            if (*textptr == 0) break;
1924
        }
1925
        j = 0;
1926
        while (isaltok(*textptr))
1927
        {
1928
            tempbuf[j] = *(textptr++);
1929
            j++;
1930
        }
1931
        tempbuf[j] = '\0';
5 Plagman 1932
 
337 terminx 1933
        {
437 terminx 1934
            int temp_line_number;
1935
            int  temp_ifelse_check;
337 terminx 1936
            char *origtptr, *mptr;
1937
            char parentcompilefile[255];
1938
            int fp;
5 Plagman 1939
 
337 terminx 1940
            fp = kopen4load(tempbuf,loadfromgrouponly);
1941
            if (fp < 0)
1942
            {
1943
                error++;
1944
                initprintf("%s:%ld: error: could not find file `%s'.\n",compilefile,line_number,tempbuf);
1945
                return 0;
1946
            }
335 terminx 1947
 
337 terminx 1948
            j = kfilelength(fp);
1949
 
1950
            mptr = (char *)Bmalloc(j+1);
1951
            if (!mptr)
5 Plagman 1952
            {
337 terminx 1953
                kclose(fp);
1954
                error++;
1955
                initprintf("%s:%ld: error: could not allocate %ld bytes to include `%s'.\n",
1956
                           line_number,compilefile,j,tempbuf);
1957
                return 0;
5 Plagman 1958
            }
1959
 
337 terminx 1960
            initprintf("Including: %s (%ld bytes)\n",tempbuf, j);
1961
            kread(fp, mptr, j);
1962
            kclose(fp);
1963
            mptr[j] = 0;
1964
 
1965
            if (*textptr == '"') // skip past the closing quote if it's there so we don't screw up the next line
1966
                textptr++;
1967
            origtptr = textptr;
1968
 
1969
            Bstrcpy(parentcompilefile, compilefile);
1970
            Bstrcpy(compilefile, tempbuf);
1971
            temp_line_number = line_number;
1972
            line_number = 1;
1973
            temp_ifelse_check = checking_ifelse;
1974
            checking_ifelse = 0;
1975
 
1976
            textptr = mptr;
1977
            do done = parsecommand();
1978
            while (!done);
1979
 
1980
            Bstrcpy(compilefile, parentcompilefile);
1981
            total_lines += line_number;
1982
            line_number = temp_line_number;
1983
            checking_ifelse = temp_ifelse_check;
1984
 
1985
            textptr = origtptr;
1986
 
1987
            Bfree(mptr);
5 Plagman 1988
        }
1989
        return 0;
1990
 
337 terminx 1991
    case CON_AI:
1992
        if (parsing_actor || parsing_state)
1993
        {
1994
            if (!CheckEventSync(current_event))
1995
                ReportError(WARNING_EVENTSYNC);
1996
            transnum(LABEL_AI);
1997
        }
1998
        else
1999
        {
5 Plagman 2000
            scriptptr--;
337 terminx 2001
            getlabel();
5 Plagman 2002
 
337 terminx 2003
            for (i=0;i<NUMKEYWORDS;i++)
2004
                if (Bstrcmp(label+(labelcnt<<6),keyw[i]) == 0)
5 Plagman 2005
                {
2006
                    error++;
337 terminx 2007
                    ReportError(ERROR_ISAKEYWORD);
5 Plagman 2008
                    return 0;
2009
                }
2010
 
337 terminx 2011
            for (i=0;i<labelcnt;i++)
546 terminx 2012
                if (Bstrcmp(label+(labelcnt<<6),label+(i<<6)) == 0 /* && (labeltype[i] & LABEL_AI) */)
5 Plagman 2013
                {
337 terminx 2014
                    warning++;
2015
                    initprintf("%s:%ld: warning: duplicate ai `%s' ignored.\n",compilefile,line_number,label+(labelcnt<<6));
2016
                    break;
5 Plagman 2017
                }
2018
 
337 terminx 2019
            if (i == labelcnt)
2020
            {
2021
                labeltype[labelcnt] = LABEL_AI;
2022
                labelcode[labelcnt++] = (long) scriptptr;
335 terminx 2023
            }
2024
 
337 terminx 2025
            for (j=0;j<3;j++)
5 Plagman 2026
            {
337 terminx 2027
                if (keyword() >= 0) break;
2028
                if (j == 1)
2029
                    transnum(LABEL_ACTION);
2030
                else if (j == 2)
2031
                {
2032
                    if ((transnum(LABEL_MOVE|LABEL_DEFINE) == 0) && (*(scriptptr-1) != 0) && (*(scriptptr-1) != 1))
254 terminx 2033
                    {
337 terminx 2034
                        ReportError(-1);
2035
                        *(scriptptr-1) = 0;
2036
                        initprintf("%s:%ld: warning: expected a move, found a constant.\n",compilefile,line_number);
254 terminx 2037
                    }
337 terminx 2038
                    k = 0;
2039
                    while (keyword() == -1)
5 Plagman 2040
                    {
337 terminx 2041
                        transnum(LABEL_DEFINE);
2042
                        scriptptr--;
2043
                        k |= *scriptptr;
5 Plagman 2044
                    }
337 terminx 2045
                    *scriptptr = k;
5 Plagman 2046
                    scriptptr++;
337 terminx 2047
                    return 0;
5 Plagman 2048
                }
2049
            }
337 terminx 2050
            for (k=j;k<3;k++)
5 Plagman 2051
            {
337 terminx 2052
                *scriptptr = 0;
2053
                scriptptr++;
5 Plagman 2054
            }
337 terminx 2055
        }
2056
        return 0;
5 Plagman 2057
 
337 terminx 2058
    case CON_ACTION:
2059
        if (parsing_actor || parsing_state)
2060
        {
2061
            if (!CheckEventSync(current_event))
2062
                ReportError(WARNING_EVENTSYNC);
2063
            transnum(LABEL_ACTION);
2064
        }
2065
        else
2066
        {
2067
            scriptptr--;
2068
            getlabel();
2069
            // Check to see it's already defined
5 Plagman 2070
 
337 terminx 2071
            for (i=0;i<NUMKEYWORDS;i++)
2072
                if (Bstrcmp(label+(labelcnt<<6),keyw[i]) == 0)
5 Plagman 2073
                {
337 terminx 2074
                    error++;
2075
                    ReportError(ERROR_ISAKEYWORD);
2076
                    return 0;
5 Plagman 2077
                }
337 terminx 2078
            for (i=0;i<labelcnt;i++)
546 terminx 2079
                if (Bstrcmp(label+(labelcnt<<6),label+(i<<6)) == 0 /* && (labeltype[i] & LABEL_ACTION) */)
5 Plagman 2080
                {
337 terminx 2081
                    warning++;
2082
                    initprintf("%s:%ld: warning: duplicate action `%s' ignored.\n",compilefile,line_number,label+(labelcnt<<6));
2083
                    break;
5 Plagman 2084
                }
337 terminx 2085
 
2086
            if (i == labelcnt)
2087
            {
2088
                labeltype[labelcnt] = LABEL_ACTION;
2089
                labelcode[labelcnt] = (long) scriptptr;
2090
                labelcnt++;
5 Plagman 2091
            }
2092
 
337 terminx 2093
            for (j=0;j<5;j++)
5 Plagman 2094
            {
337 terminx 2095
                if (keyword() >= 0) break;
2096
                transnum(LABEL_DEFINE);
5 Plagman 2097
            }
337 terminx 2098
            for (k=j;k<5;k++)
2099
            {
2100
                *scriptptr = 0;
2101
                scriptptr++;
2102
            }
2103
        }
2104
        return 0;
5 Plagman 2105
 
337 terminx 2106
    case CON_ACTOR:
2107
        if (parsing_state || parsing_actor)
2108
        {
2109
            ReportError(ERROR_FOUNDWITHIN);
2110
            error++;
2111
        }
5 Plagman 2112
 
337 terminx 2113
        num_braces = 0;
2114
        scriptptr--;
2115
        parsing_actor = scriptptr;
2116
 
2117
        skipcomments();
2118
        j = 0;
2119
        while (isaltok(*(textptr+j)))
2120
        {
2121
            parsing_item_name[j] = textptr[j];
2122
            j++;
2123
        }
2124
        parsing_item_name[j] = 0;
2125
        transnum(LABEL_DEFINE);
2126
        //         Bsprintf(parsing_item_name,"%s",label+(labelcnt<<6));
2127
        scriptptr--;
2128
        actorscrptr[*scriptptr] = parsing_actor;
2129
 
2130
        for (j=0;j<4;j++)
2131
        {
2132
            *(parsing_actor+j) = 0;
2133
            if (j == 3)
5 Plagman 2134
            {
337 terminx 2135
                j = 0;
2136
                while (keyword() == -1)
2137
                {
2138
                    transnum(LABEL_DEFINE);
2139
                    scriptptr--;
2140
                    j |= *scriptptr;
2141
                }
2142
                *scriptptr = j;
2143
                scriptptr++;
2144
                break;
5 Plagman 2145
            }
337 terminx 2146
            else
5 Plagman 2147
            {
337 terminx 2148
                if (keyword() >= 0)
5 Plagman 2149
                {
337 terminx 2150
                    for (i=4-j; i; i--) *(scriptptr++) = 0;
5 Plagman 2151
                    break;
2152
                }
337 terminx 2153
                switch (j)
5 Plagman 2154
                {
337 terminx 2155
                case 0:
2156
                    transnum(LABEL_DEFINE);
2157
                    break;
2158
                case 1:
2159
                    transnum(LABEL_ACTION);
2160
                    break;
2161
                case 2:
2162
                    if ((transnum(LABEL_MOVE|LABEL_DEFINE) == 0) && (*(scriptptr-1) != 0) && (*(scriptptr-1) != 1))
254 terminx 2163
                    {
337 terminx 2164
                        ReportError(-1);
2165
                        *(scriptptr-1) = 0;
2166
                        initprintf("%s:%ld: warning: expected a move, found a constant.\n",compilefile,line_number);
254 terminx 2167
                    }
337 terminx 2168
                    break;
5 Plagman 2169
                }
337 terminx 2170
                *(parsing_actor+j) = *(scriptptr-1);
5 Plagman 2171
            }
337 terminx 2172
        }
2173
        checking_ifelse = 0;
2174
        return 0;
2175
 
2176
    case CON_ONEVENT:
2177
        if (parsing_state || parsing_actor)
2178
        {
2179
            ReportError(ERROR_FOUNDWITHIN);
2180
            error++;
2181
        }
2182
 
2183
        num_braces = 0;
2184
        scriptptr--;
2185
        parsing_event = scriptptr;
2186
        parsing_actor = scriptptr;
2187
 
2188
        skipcomments();
2189
        j = 0;
2190
        while (isaltok(*(textptr+j)))
2191
        {
2192
            parsing_item_name[j] = textptr[j];
2193
            j++;
2194
        }
2195
        parsing_item_name[j] = 0;
2196
        labelsonly = 1;
2197
        transnum(LABEL_DEFINE);
2198
        labelsonly = 0;
2199
        scriptptr--;
2200
        j= *scriptptr;  // type of event
2201
        current_event = j;
2202
        //Bsprintf(g_szBuf,"Adding Event for %d at %lX",j, parsing_event);
2203
        //AddLog(g_szBuf);
2204
        if (j > MAXGAMEEVENTS-1 || j < 0)
2205
        {
2206
            initprintf("%s:%ld: error: invalid event ID.\n",compilefile,line_number);
2207
            error++;
335 terminx 2208
            return 0;
337 terminx 2209
        }
5 Plagman 2210
 
337 terminx 2211
        if (apScriptGameEvent[j])
2212
        {
2213
            tempscrptr = parsing_event;
2214
            parsing_event = parsing_actor = 0;
2215
            ReportError(-1);
2216
            parsing_event = parsing_actor = tempscrptr;
2217
            initprintf("%s:%ld: warning: duplicate event `%s'.\n",compilefile,line_number,parsing_item_name);
2218
        }
2219
        else apScriptGameEvent[j]=parsing_event;
5 Plagman 2220
 
337 terminx 2221
        checking_ifelse = 0;
5 Plagman 2222
 
337 terminx 2223
        return 0;
5 Plagman 2224
 
337 terminx 2225
    case CON_EVENTLOADACTOR:
2226
        if (parsing_state || parsing_actor)
2227
        {
2228
            ReportError(ERROR_FOUNDWITHIN);
2229
            error++;
2230
        }
5 Plagman 2231
 
337 terminx 2232
        num_braces = 0;
2233
        scriptptr--;
2234
        parsing_actor = scriptptr;
5 Plagman 2235
 
337 terminx 2236
        skipcomments();
2237
        j = 0;
2238
        while (isaltok(*(textptr+j)))
2239
        {
2240
            parsing_item_name[j] = textptr[j];
2241
            j++;
2242
        }
2243
        parsing_item_name[j] = 0;
2244
        transnum(LABEL_DEFINE);
2245
        scriptptr--;
2246
        actorLoadEventScrptr[*scriptptr] = parsing_actor;
5 Plagman 2247
 
337 terminx 2248
        checking_ifelse = 0;
2249
        return 0;
5 Plagman 2250
 
337 terminx 2251
    case CON_USERACTOR:
2252
        if (parsing_state || parsing_actor)
2253
        {
2254
            ReportError(ERROR_FOUNDWITHIN);
2255
            error++;
2256
        }
5 Plagman 2257
 
337 terminx 2258
        num_braces = 0;
2259
        scriptptr--;
2260
        parsing_actor = scriptptr;
5 Plagman 2261
 
337 terminx 2262
        transnum(LABEL_DEFINE);
2263
        scriptptr--;
5 Plagman 2264
 
337 terminx 2265
        skipcomments();
2266
        j = 0;
2267
        while (isaltok(*(textptr+j)))
2268
        {
2269
            parsing_item_name[j] = textptr[j];
2270
            j++;
2271
        }
2272
        parsing_item_name[j] = 0;
5 Plagman 2273
 
337 terminx 2274
        j = *scriptptr;
5 Plagman 2275
 
337 terminx 2276
        if (j > 2)
2277
        {
2278
            ReportError(-1);
2279
            initprintf("%s:%ld: warning: invalid useractor type.\n",compilefile,line_number);
296 terminx 2280
            j = 0;
337 terminx 2281
        }
267 terminx 2282
 
337 terminx 2283
        transnum(LABEL_DEFINE);
2284
        scriptptr--;
2285
        actorscrptr[*scriptptr] = parsing_actor;
2286
        actortype[*scriptptr] = j;
5 Plagman 2287
 
337 terminx 2288
        for (j=0;j<4;j++)
2289
        {
2290
            *(parsing_actor+j) = 0;
2291
            if (j == 3)
5 Plagman 2292
            {
2293
                j = 0;
337 terminx 2294
                while (keyword() == -1)
2295
                {
2296
                    transnum(LABEL_DEFINE);
2297
                    scriptptr--;
2298
                    j |= *scriptptr;
2299
                }
2300
                *scriptptr = j;
2301
                scriptptr++;
2302
                break;
5 Plagman 2303
            }
337 terminx 2304
            else
5 Plagman 2305
            {
337 terminx 2306
                if (keyword() >= 0)
5 Plagman 2307
                {
337 terminx 2308
                    for (i=4-j; i; i--) *(scriptptr++) = 0;
5 Plagman 2309
                    break;
2310
                }
337 terminx 2311
                switch (j)
5 Plagman 2312
                {
337 terminx 2313
                case 0:
2314
                    transnum(LABEL_DEFINE);
2315
                    break;
2316
                case 1:
2317
                    transnum(LABEL_ACTION);
2318
                    break;
2319
                case 2:
2320
                    if ((transnum(LABEL_MOVE|LABEL_DEFINE) == 0) && (*(scriptptr-1) != 0) && (*(scriptptr-1) != 1))
254 terminx 2321
                    {
337 terminx 2322
                        ReportError(-1);
2323
                        *(scriptptr-1) = 0;
2324
                        initprintf("%s:%ld: warning: expected a move, found a constant.\n",compilefile,line_number);
254 terminx 2325
                    }
337 terminx 2326
                    break;
5 Plagman 2327
                }
337 terminx 2328
                *(parsing_actor+j) = *(scriptptr-1);
5 Plagman 2329
            }
337 terminx 2330
        }
2331
        checking_ifelse = 0;
2332
        return 0;
5 Plagman 2333
 
337 terminx 2334
    case CON_INSERTSPRITEQ:
2335
        if (!CheckEventSync(current_event))
2336
            ReportError(WARNING_EVENTSYNC);
2337
        return 0;
5 Plagman 2338
 
337 terminx 2339
    case CON_QSPRINTF:
2340
        transnum(LABEL_DEFINE);
2341
        transnum(LABEL_DEFINE);
2342
        for (j = 0;j < 4;j++)
2343
        {
2344
            if (keyword() == -1)
2345
                transvar();
2346
            else break;
2347
        }
5 Plagman 2348
 
337 terminx 2349
        while (j < 4)
2350
        {
2351
            *scriptptr = 0;
2352
            scriptptr++;
2353
            j++;
2354
        }
2355
        return 0;
5 Plagman 2356
 
337 terminx 2357
    case CON_ESPAWN:
2358
    case CON_ESHOOT:
2359
    case CON_QSPAWN:
2360
    case CON_EQSPAWN:
2361
    case CON_STRENGTH:
2362
    case CON_SHOOT:
2363
    case CON_ADDPHEALTH:
2364
    case CON_SPAWN:
2365
    case CON_CSTAT:
2366
    case CON_COUNT:
2367
    case CON_ENDOFGAME:
2368
    case CON_SPRITEPAL:
2369
    case CON_CACTOR:
2370
    case CON_MONEY:
2371
    case CON_ADDKILLS:
2372
    case CON_DEBUG:
2373
    case CON_ADDSTRENGTH:
2374
    case CON_CSTATOR:
2375
    case CON_MAIL:
2376
    case CON_PAPER:
2377
    case CON_SLEEPTIME:
2378
    case CON_CLIPDIST:
2379
    case CON_LOTSOFGLASS:
2380
    case CON_SAVE:
2381
        if (!CheckEventSync(current_event))
2382
            ReportError(WARNING_EVENTSYNC);
2383
    case CON_ANGOFF:
2384
    case CON_USERQUOTE:
2385
    case CON_QUOTE:
2386
    case CON_SOUND:
2387
    case CON_GLOBALSOUND:
2388
    case CON_SOUNDONCE:
2389
    case CON_STOPSOUND:
2390
        transnum(LABEL_DEFINE);
2391
        if (tw == CON_CSTAT)
2392
        {
2393
            if (*(scriptptr-