aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/linden/indra/lscript/lscript_compile/lscript_tree.h
diff options
context:
space:
mode:
Diffstat (limited to 'linden/indra/lscript/lscript_compile/lscript_tree.h')
-rw-r--r--linden/indra/lscript/lscript_compile/lscript_tree.h2298
1 files changed, 2298 insertions, 0 deletions
diff --git a/linden/indra/lscript/lscript_compile/lscript_tree.h b/linden/indra/lscript/lscript_compile/lscript_tree.h
new file mode 100644
index 0000000..a535e76
--- /dev/null
+++ b/linden/indra/lscript/lscript_compile/lscript_tree.h
@@ -0,0 +1,2298 @@
1/**
2 * @file lscript_tree.h
3 * @brief provides the classes required to build lscript's abstract syntax tree and symbol table
4 *
5 * Copyright (c) 2002-2007, Linden Research, Inc.
6 *
7 * The source code in this file ("Source Code") is provided by Linden Lab
8 * to you under the terms of the GNU General Public License, version 2.0
9 * ("GPL"), unless you have obtained a separate licensing agreement
10 * ("Other License"), formally executed by you and Linden Lab. Terms of
11 * the GPL can be found in doc/GPL-license.txt in this distribution, or
12 * online at http://secondlife.com/developers/opensource/gplv2
13 *
14 * There are special exceptions to the terms and conditions of the GPL as
15 * it is applied to this Source Code. View the full text of the exception
16 * in the file doc/FLOSS-exception.txt in this software distribution, or
17 * online at http://secondlife.com/developers/opensource/flossexception
18 *
19 * By copying, modifying or distributing this software, you acknowledge
20 * that you have read and understood your obligations described above,
21 * and agree to abide by those obligations.
22 *
23 * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
24 * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
25 * COMPLETENESS OR PERFORMANCE.
26 */
27
28#ifndef LL_LSCRIPT_TREE_H
29#define LL_LSCRIPT_TREE_H
30
31#include <stdio.h>
32#include "stdtypes.h"
33#include "v3math.h"
34#include "llquaternion.h"
35#include "linked_lists.h"
36#include "lscript_error.h"
37#include "lscript_typecheck.h"
38#include "lscript_byteformat.h"
39
40
41// Nota Bene: Class destructors don't delete pointed to classes because it isn't guaranteed that lex/yacc will build
42// complete data structures. Instead various chunks that are allocated are stored and deleted by allocation lists
43
44class LLScriptType : public LLScriptFilePosition
45{
46public:
47 LLScriptType(S32 line, S32 col, LSCRIPTType type)
48 : LLScriptFilePosition(line, col), mType(type)
49 {
50 }
51
52 ~LLScriptType() {}
53
54 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
55 S32 getSize();
56
57 LSCRIPTType mType;
58};
59
60// contains a literal or constant value
61class LLScriptConstant : public LLScriptFilePosition
62{
63public:
64 LLScriptConstant(S32 line, S32 col, LSCRIPTType type)
65 : LLScriptFilePosition(line, col), mType(type)
66 {
67 }
68
69 virtual ~LLScriptConstant() {}
70
71 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
72 S32 getSize();
73
74 LSCRIPTType mType;
75};
76
77class LLScriptConstantInteger : public LLScriptConstant
78{
79public:
80 LLScriptConstantInteger(S32 line, S32 col, S32 value)
81 : LLScriptConstant(line, col, LST_INTEGER), mValue(value)
82 {
83 }
84
85 ~LLScriptConstantInteger() {}
86
87 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
88 S32 getSize();
89
90 S32 mValue;
91};
92
93class LLScriptConstantFloat : public LLScriptConstant
94{
95public:
96 LLScriptConstantFloat(S32 line, S32 col, F32 value)
97 : LLScriptConstant(line, col, LST_FLOATINGPOINT), mValue(value)
98 {
99 }
100
101 ~LLScriptConstantFloat() {}
102
103 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
104 S32 getSize();
105
106 F32 mValue;
107};
108
109class LLScriptConstantString : public LLScriptConstant
110{
111public:
112 LLScriptConstantString(S32 line, S32 col, char *value)
113 : LLScriptConstant(line, col, LST_STRING), mValue(value)
114 {
115 }
116
117 ~LLScriptConstantString()
118 {
119 delete [] mValue;
120 mValue = NULL;
121 }
122
123 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
124 S32 getSize();
125
126 char *mValue;
127};
128
129// container for individual identifiers
130class LLScriptIdentifier : public LLScriptFilePosition
131{
132public:
133 LLScriptIdentifier(S32 line, S32 col, char *name, LLScriptType *type = NULL)
134 : LLScriptFilePosition(line, col), mName(name), mScopeEntry(NULL), mType(type)
135 {
136 }
137
138 ~LLScriptIdentifier()
139 {
140 delete [] mName;
141 mName = NULL;
142 }
143
144 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
145 S32 getSize();
146
147 char *mName;
148 LLScriptScopeEntry *mScopeEntry;
149 LLScriptType *mType;
150};
151
152typedef enum e_lscript_simple_assignable_type
153{
154 LSSAT_NULL,
155 LSSAT_IDENTIFIER,
156 LSSAT_CONSTANT,
157 LSSAT_VECTOR_CONSTANT,
158 LSSAT_QUATERNION_CONSTANT,
159 LSSAT_LIST_CONSTANT,
160 LSSAT_EOF
161} LSCRIPTSimpleAssignableType;
162
163class LLScriptSimpleAssignable : public LLScriptFilePosition
164{
165public:
166 LLScriptSimpleAssignable(S32 line, S32 col, LSCRIPTSimpleAssignableType type)
167 : LLScriptFilePosition(line, col), mType(type), mNextp(NULL)
168 {
169 }
170
171 void addAssignable(LLScriptSimpleAssignable *assign);
172
173 virtual ~LLScriptSimpleAssignable()
174 {
175 // don't delete next pointer because we're going to store allocation lists and delete from those
176 }
177
178 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
179 S32 getSize();
180
181 LSCRIPTSimpleAssignableType mType;
182 LLScriptSimpleAssignable *mNextp;
183};
184
185class LLScriptSAIdentifier : public LLScriptSimpleAssignable
186{
187public:
188 LLScriptSAIdentifier(S32 line, S32 col, LLScriptIdentifier *identifier)
189 : LLScriptSimpleAssignable(line, col, LSSAT_IDENTIFIER), mIdentifier(identifier)
190 {
191 }
192
193 ~LLScriptSAIdentifier()
194 {
195 }
196
197 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
198 S32 getSize();
199
200 LLScriptIdentifier *mIdentifier;
201};
202
203class LLScriptSAConstant : public LLScriptSimpleAssignable
204{
205public:
206 LLScriptSAConstant(S32 line, S32 col, LLScriptConstant *constant)
207 : LLScriptSimpleAssignable(line, col, LSSAT_CONSTANT), mConstant(constant)
208 {
209 }
210
211 ~LLScriptSAConstant()
212 {
213 }
214
215 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
216 S32 getSize();
217
218 LLScriptConstant *mConstant;
219};
220
221class LLScriptSAVector : public LLScriptSimpleAssignable
222{
223public:
224 LLScriptSAVector(S32 line, S32 col, LLScriptSimpleAssignable *e1,
225 LLScriptSimpleAssignable *e2,
226 LLScriptSimpleAssignable *e3)
227 : LLScriptSimpleAssignable(line, col, LSSAT_VECTOR_CONSTANT),
228 mEntry1(e1), mEntry2(e2), mEntry3(e3)
229 {
230 }
231
232 ~LLScriptSAVector()
233 {
234 }
235
236 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
237 S32 getSize();
238
239 LLScriptSimpleAssignable *mEntry1;
240 LLScriptSimpleAssignable *mEntry2;
241 LLScriptSimpleAssignable *mEntry3;
242};
243
244class LLScriptSAQuaternion : public LLScriptSimpleAssignable
245{
246public:
247 LLScriptSAQuaternion(S32 line, S32 col, LLScriptSimpleAssignable *e1,
248 LLScriptSimpleAssignable *e2,
249 LLScriptSimpleAssignable *e3,
250 LLScriptSimpleAssignable *e4)
251 : LLScriptSimpleAssignable(line, col, LSSAT_QUATERNION_CONSTANT),
252 mEntry1(e1), mEntry2(e2), mEntry3(e3), mEntry4(e4)
253 {
254 }
255
256 ~LLScriptSAQuaternion()
257 {
258 }
259
260 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
261 S32 getSize();
262
263 LLScriptSimpleAssignable *mEntry1;
264 LLScriptSimpleAssignable *mEntry2;
265 LLScriptSimpleAssignable *mEntry3;
266 LLScriptSimpleAssignable *mEntry4;
267};
268
269class LLScriptSAList : public LLScriptSimpleAssignable
270{
271public:
272 LLScriptSAList(S32 line, S32 col, LLScriptSimpleAssignable *elist)
273 : LLScriptSimpleAssignable(line, col, LSSAT_QUATERNION_CONSTANT), mEntryList(elist)
274 {
275 }
276
277 ~LLScriptSAList()
278 {
279 }
280
281 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
282 S32 getSize();
283
284 LLScriptSimpleAssignable *mEntryList;
285};
286
287// global variables
288class LLScriptGlobalVariable : public LLScriptFilePosition
289{
290public:
291 LLScriptGlobalVariable(S32 line, S32 col, LLScriptType *type,
292 LLScriptIdentifier *identifier,
293 LLScriptSimpleAssignable *assignable)
294 : LLScriptFilePosition(line, col), mType(type), mIdentifier(identifier), mAssignable(assignable), mNextp(NULL), mAssignableType(LST_NULL)
295 {
296 }
297
298 void addGlobal(LLScriptGlobalVariable *global);
299
300 ~LLScriptGlobalVariable()
301 {
302 }
303
304 void gonext(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
305
306 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
307 S32 getSize();
308
309 LLScriptType *mType;
310 LLScriptIdentifier *mIdentifier;
311 LLScriptSimpleAssignable *mAssignable;
312 LLScriptGlobalVariable *mNextp;
313 LSCRIPTType mAssignableType;
314};
315
316// events
317
318class LLScriptEvent : public LLScriptFilePosition
319{
320public:
321 LLScriptEvent(S32 line, S32 col, LSCRIPTStateEventType type)
322 : LLScriptFilePosition(line, col), mType(type)
323 {
324 }
325
326 virtual ~LLScriptEvent()
327 {
328 // don't delete next pointer because we're going to store allocation lists and delete from those
329 }
330
331 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
332 S32 getSize();
333
334 LSCRIPTStateEventType mType;
335};
336
337class LLScriptStateEntryEvent : public LLScriptEvent
338{
339public:
340 LLScriptStateEntryEvent(S32 line, S32 col)
341 : LLScriptEvent(line, col, LSTT_STATE_ENTRY)
342 {
343 }
344
345 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
346 S32 getSize();
347
348 ~LLScriptStateEntryEvent() {}
349};
350
351class LLScriptStateExitEvent : public LLScriptEvent
352{
353public:
354 LLScriptStateExitEvent(S32 line, S32 col)
355 : LLScriptEvent(line, col, LSTT_STATE_EXIT)
356 {
357 }
358
359 ~LLScriptStateExitEvent() {}
360
361 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
362 S32 getSize();
363};
364
365class LLScriptTouchStartEvent : public LLScriptEvent
366{
367public:
368 LLScriptTouchStartEvent(S32 line, S32 col, LLScriptIdentifier *count)
369 : LLScriptEvent(line, col, LSTT_TOUCH_START), mCount(count)
370 {
371 }
372
373 ~LLScriptTouchStartEvent()
374 {
375 }
376
377 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
378 S32 getSize();
379
380 LLScriptIdentifier *mCount;
381};
382
383class LLScriptTouchEvent : public LLScriptEvent
384{
385public:
386 LLScriptTouchEvent(S32 line, S32 col, LLScriptIdentifier *count)
387 : LLScriptEvent(line, col, LSTT_TOUCH), mCount(count)
388 {
389 }
390
391 ~LLScriptTouchEvent()
392 {
393 }
394
395 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
396 S32 getSize();
397
398 LLScriptIdentifier *mCount;
399};
400
401class LLScriptTouchEndEvent : public LLScriptEvent
402{
403public:
404 LLScriptTouchEndEvent(S32 line, S32 col, LLScriptIdentifier *count)
405 : LLScriptEvent(line, col, LSTT_TOUCH_END), mCount(count)
406 {
407 }
408
409 ~LLScriptTouchEndEvent()
410 {
411 }
412
413 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
414 S32 getSize();
415
416 LLScriptIdentifier *mCount;
417};
418
419class LLScriptCollisionStartEvent : public LLScriptEvent
420{
421public:
422 LLScriptCollisionStartEvent(S32 line, S32 col, LLScriptIdentifier *count)
423 : LLScriptEvent(line, col, LSTT_COLLISION_START), mCount(count)
424 {
425 }
426
427 ~LLScriptCollisionStartEvent()
428 {
429 }
430
431 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
432 S32 getSize();
433
434 LLScriptIdentifier *mCount;
435};
436
437class LLScriptCollisionEvent : public LLScriptEvent
438{
439public:
440 LLScriptCollisionEvent(S32 line, S32 col, LLScriptIdentifier *count)
441 : LLScriptEvent(line, col, LSTT_COLLISION), mCount(count)
442 {
443 }
444
445 ~LLScriptCollisionEvent()
446 {
447 }
448
449 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
450 S32 getSize();
451
452 LLScriptIdentifier *mCount;
453};
454
455class LLScriptCollisionEndEvent : public LLScriptEvent
456{
457public:
458 LLScriptCollisionEndEvent(S32 line, S32 col, LLScriptIdentifier *count)
459 : LLScriptEvent(line, col, LSTT_COLLISION_END), mCount(count)
460 {
461 }
462
463 ~LLScriptCollisionEndEvent()
464 {
465 }
466
467 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
468 S32 getSize();
469
470 LLScriptIdentifier *mCount;
471};
472
473class LLScriptLandCollisionStartEvent : public LLScriptEvent
474{
475public:
476 LLScriptLandCollisionStartEvent(S32 line, S32 col, LLScriptIdentifier *pos)
477 : LLScriptEvent(line, col, LSTT_LAND_COLLISION_START), mPosition(pos)
478 {
479 }
480
481 ~LLScriptLandCollisionStartEvent()
482 {
483 }
484
485 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
486 S32 getSize();
487
488 LLScriptIdentifier *mPosition;
489};
490
491class LLScriptLandCollisionEvent : public LLScriptEvent
492{
493public:
494 LLScriptLandCollisionEvent(S32 line, S32 col, LLScriptIdentifier *pos)
495 : LLScriptEvent(line, col, LSTT_LAND_COLLISION), mPosition(pos)
496 {
497 }
498
499 ~LLScriptLandCollisionEvent()
500 {
501 }
502
503 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
504 S32 getSize();
505
506 LLScriptIdentifier *mPosition;
507};
508
509class LLScriptLandCollisionEndEvent : public LLScriptEvent
510{
511public:
512 LLScriptLandCollisionEndEvent(S32 line, S32 col, LLScriptIdentifier *pos)
513 : LLScriptEvent(line, col, LSTT_LAND_COLLISION_END), mPosition(pos)
514 {
515 }
516
517 ~LLScriptLandCollisionEndEvent()
518 {
519 }
520
521 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
522 S32 getSize();
523
524 LLScriptIdentifier *mPosition;
525};
526
527class LLScriptInventoryEvent : public LLScriptEvent
528{
529public:
530 LLScriptInventoryEvent(S32 line, S32 col, LLScriptIdentifier *change)
531 : LLScriptEvent(line, col, LSTT_INVENTORY), mChange(change)
532 {
533 }
534
535 ~LLScriptInventoryEvent() {}
536
537 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
538 S32 getSize();
539
540 LLScriptIdentifier *mChange;
541};
542
543class LLScriptAttachEvent : public LLScriptEvent
544{
545public:
546 LLScriptAttachEvent(S32 line, S32 col, LLScriptIdentifier *attach)
547 : LLScriptEvent(line, col, LSTT_ATTACH), mAttach(attach)
548 {
549 }
550
551 ~LLScriptAttachEvent() {}
552
553 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
554 S32 getSize();
555
556 LLScriptIdentifier *mAttach;
557};
558
559class LLScriptDataserverEvent : public LLScriptEvent
560{
561public:
562 LLScriptDataserverEvent(S32 line, S32 col, LLScriptIdentifier *id, LLScriptIdentifier *data)
563 : LLScriptEvent(line, col, LSTT_DATASERVER), mID(id), mData(data)
564 {
565 }
566
567 ~LLScriptDataserverEvent() {}
568
569 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
570 S32 getSize();
571
572 LLScriptIdentifier *mID;
573 LLScriptIdentifier *mData;
574};
575
576class LLScriptTimerEvent : public LLScriptEvent
577{
578public:
579 LLScriptTimerEvent(S32 line, S32 col)
580 : LLScriptEvent(line, col, LSTT_TIMER)
581 {
582 }
583
584 ~LLScriptTimerEvent() {}
585
586 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
587 S32 getSize();
588};
589
590class LLScriptMovingStartEvent : public LLScriptEvent
591{
592public:
593 LLScriptMovingStartEvent(S32 line, S32 col)
594 : LLScriptEvent(line, col, LSTT_MOVING_START)
595 {
596 }
597
598 ~LLScriptMovingStartEvent() {}
599
600 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
601 S32 getSize();
602};
603
604class LLScriptMovingEndEvent : public LLScriptEvent
605{
606public:
607 LLScriptMovingEndEvent(S32 line, S32 col)
608 : LLScriptEvent(line, col, LSTT_MOVING_END)
609 {
610 }
611
612 ~LLScriptMovingEndEvent() {}
613
614 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
615 S32 getSize();
616};
617
618class LLScriptRTPEvent : public LLScriptEvent
619{
620public:
621 LLScriptRTPEvent(S32 line, S32 col, LLScriptIdentifier *rtperm)
622 : LLScriptEvent(line, col, LSTT_RTPERMISSIONS), mRTPermissions(rtperm)
623 {
624 }
625
626 ~LLScriptRTPEvent() {}
627
628 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
629 S32 getSize();
630
631 LLScriptIdentifier *mRTPermissions;
632};
633
634class LLScriptChatEvent : public LLScriptEvent
635{
636public:
637 LLScriptChatEvent(S32 line, S32 col, LLScriptIdentifier *channel, LLScriptIdentifier *name, LLScriptIdentifier *id, LLScriptIdentifier *message)
638 : LLScriptEvent(line, col, LSTT_CHAT), mChannel(channel), mName(name), mID(id), mMessage(message)
639 {
640 }
641
642 ~LLScriptChatEvent()
643 {
644 }
645
646 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
647 S32 getSize();
648
649 LLScriptIdentifier *mChannel;
650 LLScriptIdentifier *mName;
651 LLScriptIdentifier *mID;
652 LLScriptIdentifier *mMessage;
653};
654
655class LLScriptObjectRezEvent : public LLScriptEvent
656{
657public:
658 LLScriptObjectRezEvent(S32 line, S32 col, LLScriptIdentifier *id)
659 : LLScriptEvent(line, col, LSTT_OBJECT_REZ), mID(id)
660 {
661 }
662
663 ~LLScriptObjectRezEvent()
664 {
665 }
666
667 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
668 S32 getSize();
669
670 LLScriptIdentifier *mID;
671};
672
673class LLScriptSensorEvent : public LLScriptEvent
674{
675public:
676 LLScriptSensorEvent(S32 line, S32 col, LLScriptIdentifier *number)
677 : LLScriptEvent(line, col, LSTT_SENSOR), mNumber(number)
678 {
679 }
680
681 ~LLScriptSensorEvent()
682 {
683 }
684
685 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
686 S32 getSize();
687
688 LLScriptIdentifier *mNumber;
689};
690
691class LLScriptControlEvent : public LLScriptEvent
692{
693public:
694 LLScriptControlEvent(S32 line, S32 col, LLScriptIdentifier *name, LLScriptIdentifier *levels, LLScriptIdentifier *edges)
695 : LLScriptEvent(line, col, LSTT_CONTROL), mName(name), mLevels(levels), mEdges(edges)
696 {
697 }
698
699 ~LLScriptControlEvent()
700 {
701 }
702
703 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
704 S32 getSize();
705
706 LLScriptIdentifier *mName;
707 LLScriptIdentifier *mLevels;
708 LLScriptIdentifier *mEdges;
709};
710
711class LLScriptLinkMessageEvent : public LLScriptEvent
712{
713public:
714 LLScriptLinkMessageEvent(S32 line, S32 col, LLScriptIdentifier *sender, LLScriptIdentifier *num, LLScriptIdentifier *str, LLScriptIdentifier *id)
715 : LLScriptEvent(line, col, LSTT_LINK_MESSAGE), mSender(sender), mNum(num), mStr(str), mID(id)
716 {
717 }
718
719 ~LLScriptLinkMessageEvent()
720 {
721 }
722
723 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
724 S32 getSize();
725
726 LLScriptIdentifier *mSender;
727 LLScriptIdentifier *mNum;
728 LLScriptIdentifier *mStr;
729 LLScriptIdentifier *mID;
730};
731
732class LLScriptRemoteEvent : public LLScriptEvent
733{
734public:
735 LLScriptRemoteEvent(S32 line, S32 col, LLScriptIdentifier *type, LLScriptIdentifier *channel, LLScriptIdentifier *message_id, LLScriptIdentifier *sender, LLScriptIdentifier *int_val, LLScriptIdentifier *str_val)
736 : LLScriptEvent(line, col, LSTT_REMOTE_DATA), mType(type), mChannel(channel), mMessageID(message_id), mSender(sender), mIntVal(int_val), mStrVal(str_val)
737 {
738 }
739
740 ~LLScriptRemoteEvent()
741 {
742 }
743
744 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
745 S32 getSize();
746
747 LLScriptIdentifier *mType;
748 LLScriptIdentifier *mChannel;
749 LLScriptIdentifier *mMessageID;
750 LLScriptIdentifier *mSender;
751 LLScriptIdentifier *mIntVal;
752 LLScriptIdentifier *mStrVal;
753};
754
755class LLScriptHTTPResponseEvent : public LLScriptEvent
756{
757public:
758 LLScriptHTTPResponseEvent(S32 line, S32 col,
759 LLScriptIdentifier *reqeust_id,
760 LLScriptIdentifier *status,
761 LLScriptIdentifier *metadata,
762 LLScriptIdentifier *body)
763 : LLScriptEvent(line, col, LSTT_HTTP_RESPONSE),
764 mRequestId(reqeust_id), mStatus(status), mMetadata(metadata), mBody(body)
765 {
766 }
767
768 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass,
769 LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope,
770 LSCRIPTType &type, LSCRIPTType basetype, U64 &count,
771 LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap,
772 S32 stacksize, LLScriptScopeEntry *entry,
773 S32 entrycount, LLScriptLibData **ldata);
774
775 S32 getSize();
776
777 LLScriptIdentifier *mRequestId;
778 LLScriptIdentifier *mStatus;
779 LLScriptIdentifier *mMetadata;
780 LLScriptIdentifier *mBody;
781};
782
783class LLScriptRezEvent : public LLScriptEvent
784{
785public:
786 LLScriptRezEvent(S32 line, S32 col, LLScriptIdentifier *start_param)
787 : LLScriptEvent(line, col, LSTT_REZ), mStartParam(start_param)
788 {
789 }
790 ~LLScriptRezEvent() {}
791
792 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
793 S32 getSize();
794
795 LLScriptIdentifier *mStartParam;
796};
797
798class LLScriptNoSensorEvent : public LLScriptEvent
799{
800public:
801 LLScriptNoSensorEvent(S32 line, S32 col)
802 : LLScriptEvent(line, col, LSTT_NO_SENSOR)
803 {
804 }
805
806 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
807 S32 getSize();
808
809 ~LLScriptNoSensorEvent() {}
810};
811
812class LLScriptAtTarget : public LLScriptEvent
813{
814public:
815 LLScriptAtTarget(S32 line, S32 col, LLScriptIdentifier *tnumber, LLScriptIdentifier *tpos, LLScriptIdentifier *ourpos)
816 : LLScriptEvent(line, col, LSTT_AT_TARGET), mTargetNumber(tnumber), mTargetPosition(tpos), mOurPosition(ourpos)
817 {
818 }
819
820 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
821 S32 getSize();
822
823 ~LLScriptAtTarget() {}
824
825 LLScriptIdentifier *mTargetNumber;
826 LLScriptIdentifier *mTargetPosition;
827 LLScriptIdentifier *mOurPosition;
828};
829
830class LLScriptNotAtTarget : public LLScriptEvent
831{
832public:
833 LLScriptNotAtTarget(S32 line, S32 col)
834 : LLScriptEvent(line, col, LSTT_NOT_AT_TARGET)
835 {
836 }
837
838 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
839 S32 getSize();
840
841 ~LLScriptNotAtTarget() {}
842};
843
844class LLScriptAtRotTarget : public LLScriptEvent
845{
846public:
847 LLScriptAtRotTarget(S32 line, S32 col, LLScriptIdentifier *tnumber, LLScriptIdentifier *trot, LLScriptIdentifier *ourrot)
848 : LLScriptEvent(line, col, LSTT_AT_ROT_TARGET), mTargetNumber(tnumber), mTargetRotation(trot), mOurRotation(ourrot)
849 {
850 }
851
852 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
853 S32 getSize();
854
855 ~LLScriptAtRotTarget() {}
856
857 LLScriptIdentifier *mTargetNumber;
858 LLScriptIdentifier *mTargetRotation;
859 LLScriptIdentifier *mOurRotation;
860};
861
862class LLScriptNotAtRotTarget : public LLScriptEvent
863{
864public:
865 LLScriptNotAtRotTarget(S32 line, S32 col)
866 : LLScriptEvent(line, col, LSTT_NOT_AT_ROT_TARGET)
867 {
868 }
869
870 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
871 S32 getSize();
872
873 ~LLScriptNotAtRotTarget() {}
874};
875
876class LLScriptMoneyEvent : public LLScriptEvent
877{
878public:
879 LLScriptMoneyEvent(S32 line, S32 col, LLScriptIdentifier *name, LLScriptIdentifier *amount)
880 : LLScriptEvent(line, col, LSTT_MONEY), mName(name), mAmount(amount)
881 {
882 }
883
884 ~LLScriptMoneyEvent()
885 {
886 }
887
888 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
889 S32 getSize();
890
891 LLScriptIdentifier *mName;
892 LLScriptIdentifier *mAmount;
893};
894
895class LLScriptEmailEvent : public LLScriptEvent
896{
897public:
898 LLScriptEmailEvent(S32 line, S32 col, LLScriptIdentifier *time, LLScriptIdentifier *address, LLScriptIdentifier *subject, LLScriptIdentifier *body, LLScriptIdentifier *number)
899 : LLScriptEvent(line, col, LSTT_EMAIL), mTime(time), mAddress(address), mSubject(subject), mBody(body), mNumber(number)
900 {
901 }
902
903 ~LLScriptEmailEvent()
904 {
905 }
906
907 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
908 S32 getSize();
909
910 LLScriptIdentifier *mTime;
911 LLScriptIdentifier *mAddress;
912 LLScriptIdentifier *mSubject;
913 LLScriptIdentifier *mBody;
914 LLScriptIdentifier *mNumber;
915};
916
917
918class LLScriptExpression : public LLScriptFilePosition
919{
920public:
921 LLScriptExpression(S32 line, S32 col, LSCRIPTExpressionType type)
922 : LLScriptFilePosition(line, col), mType(type), mNextp(NULL), mLeftType(LST_NULL), mRightType(LST_NULL), mReturnType(LST_NULL)
923 {
924 }
925
926 void addExpression(LLScriptExpression *expression);
927
928 virtual ~LLScriptExpression()
929 {
930 // don't delete next pointer because we're going to store allocation lists and delete from those
931 }
932
933 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
934
935 void gonext(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
936 S32 getSize();
937
938 LSCRIPTExpressionType mType;
939 LLScriptExpression *mNextp;
940 LSCRIPTType mLeftType, mRightType, mReturnType;
941
942};
943
944class LLScriptForExpressionList : public LLScriptExpression
945{
946public:
947 LLScriptForExpressionList(S32 line, S32 col, LLScriptExpression *first, LLScriptExpression *second)
948 : LLScriptExpression(line, col, LET_FOR_EXPRESSION_LIST), mFirstp(first), mSecondp(second)
949 {
950 }
951
952 ~LLScriptForExpressionList()
953 {
954 }
955
956 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
957 S32 getSize();
958
959 LLScriptExpression *mFirstp;
960 LLScriptExpression *mSecondp;
961};
962
963class LLScriptFuncExpressionList : public LLScriptExpression
964{
965public:
966 LLScriptFuncExpressionList(S32 line, S32 col, LLScriptExpression *first, LLScriptExpression *second)
967 : LLScriptExpression(line, col, LET_FUNC_EXPRESSION_LIST), mFirstp(first), mSecondp(second)
968 {
969 }
970
971 ~LLScriptFuncExpressionList()
972 {
973 }
974
975 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
976 S32 getSize();
977
978 LLScriptExpression *mFirstp;
979 LLScriptExpression *mSecondp;
980};
981
982class LLScriptListExpressionList : public LLScriptExpression
983{
984public:
985 LLScriptListExpressionList(S32 line, S32 col, LLScriptExpression *first, LLScriptExpression *second)
986 : LLScriptExpression(line, col, LET_LIST_EXPRESSION_LIST), mFirstp(first), mSecondp(second)
987 {
988 }
989
990 ~LLScriptListExpressionList()
991 {
992 }
993
994 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
995 S32 getSize();
996
997 LLScriptExpression *mFirstp;
998 LLScriptExpression *mSecondp;
999};
1000
1001class LLScriptLValue : public LLScriptExpression
1002{
1003public:
1004 LLScriptLValue(S32 line, S32 col, LLScriptIdentifier *identifier, LLScriptIdentifier *accessor)
1005 : LLScriptExpression(line, col, LET_LVALUE), mOffset(0), mIdentifier(identifier), mAccessor(accessor)
1006 {
1007 }
1008
1009 ~LLScriptLValue()
1010 {
1011 }
1012
1013 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1014 S32 getSize();
1015
1016 S32 mOffset;
1017 LLScriptIdentifier *mIdentifier;
1018 LLScriptIdentifier *mAccessor;
1019};
1020
1021class LLScriptAssignment : public LLScriptExpression
1022{
1023public:
1024 LLScriptAssignment(S32 line, S32 col, LLScriptExpression *lvalue, LLScriptExpression *rightside)
1025 : LLScriptExpression(line, col, LET_ASSIGNMENT), mLValue(lvalue), mRightSide(rightside)
1026 {
1027 }
1028
1029 ~LLScriptAssignment()
1030 {
1031 }
1032
1033 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1034 S32 getSize();
1035
1036 LLScriptExpression *mLValue;
1037 LLScriptExpression *mRightSide;
1038};
1039
1040class LLScriptAddAssignment : public LLScriptExpression
1041{
1042public:
1043 LLScriptAddAssignment(S32 line, S32 col, LLScriptExpression *lvalue, LLScriptExpression *rightside)
1044 : LLScriptExpression(line, col, LET_ADD_ASSIGN), mLValue(lvalue), mRightSide(rightside)
1045 {
1046 }
1047
1048 ~LLScriptAddAssignment()
1049 {
1050 }
1051
1052 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1053 S32 getSize();
1054
1055 LLScriptExpression *mLValue;
1056 LLScriptExpression *mRightSide;
1057};
1058
1059class LLScriptSubAssignment : public LLScriptExpression
1060{
1061public:
1062 LLScriptSubAssignment(S32 line, S32 col, LLScriptExpression *lvalue, LLScriptExpression *rightside)
1063 : LLScriptExpression(line, col, LET_SUB_ASSIGN), mLValue(lvalue), mRightSide(rightside)
1064 {
1065 }
1066
1067 ~LLScriptSubAssignment()
1068 {
1069 }
1070
1071 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1072 S32 getSize();
1073
1074 LLScriptExpression *mLValue;
1075 LLScriptExpression *mRightSide;
1076};
1077
1078class LLScriptMulAssignment : public LLScriptExpression
1079{
1080public:
1081 LLScriptMulAssignment(S32 line, S32 col, LLScriptExpression *lvalue, LLScriptExpression *rightside)
1082 : LLScriptExpression(line, col, LET_MUL_ASSIGN), mLValue(lvalue), mRightSide(rightside)
1083 {
1084 }
1085
1086 ~LLScriptMulAssignment()
1087 {
1088 }
1089
1090 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1091 S32 getSize();
1092
1093 LLScriptExpression *mLValue;
1094 LLScriptExpression *mRightSide;
1095};
1096
1097class LLScriptDivAssignment : public LLScriptExpression
1098{
1099public:
1100 LLScriptDivAssignment(S32 line, S32 col, LLScriptExpression *lvalue, LLScriptExpression *rightside)
1101 : LLScriptExpression(line, col, LET_DIV_ASSIGN), mLValue(lvalue), mRightSide(rightside)
1102 {
1103 }
1104
1105 ~LLScriptDivAssignment()
1106 {
1107 }
1108
1109 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1110 S32 getSize();
1111
1112 LLScriptExpression *mLValue;
1113 LLScriptExpression *mRightSide;
1114};
1115
1116class LLScriptModAssignment : public LLScriptExpression
1117{
1118public:
1119 LLScriptModAssignment(S32 line, S32 col, LLScriptExpression *lvalue, LLScriptExpression *rightside)
1120 : LLScriptExpression(line, col, LET_MOD_ASSIGN), mLValue(lvalue), mRightSide(rightside)
1121 {
1122 }
1123
1124 ~LLScriptModAssignment()
1125 {
1126 }
1127
1128 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1129 S32 getSize();
1130
1131 LLScriptExpression *mLValue;
1132 LLScriptExpression *mRightSide;
1133};
1134
1135class LLScriptEquality : public LLScriptExpression
1136{
1137public:
1138 LLScriptEquality(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1139 : LLScriptExpression(line, col, LET_EQUALITY), mLeftSide(leftside), mRightSide(rightside)
1140 {
1141 }
1142
1143 ~LLScriptEquality()
1144 {
1145 }
1146
1147 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1148 S32 getSize();
1149
1150 LLScriptExpression *mLeftSide;
1151 LLScriptExpression *mRightSide;
1152};
1153
1154class LLScriptNotEquals : public LLScriptExpression
1155{
1156public:
1157 LLScriptNotEquals(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1158 : LLScriptExpression(line, col, LET_NOT_EQUALS), mLeftSide(leftside), mRightSide(rightside)
1159 {
1160 }
1161
1162 ~LLScriptNotEquals()
1163 {
1164 }
1165
1166 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1167 S32 getSize();
1168
1169 LLScriptExpression *mLeftSide;
1170 LLScriptExpression *mRightSide;
1171};
1172
1173class LLScriptLessEquals : public LLScriptExpression
1174{
1175public:
1176 LLScriptLessEquals(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1177 : LLScriptExpression(line, col, LET_LESS_EQUALS), mLeftSide(leftside), mRightSide(rightside)
1178 {
1179 }
1180
1181 ~LLScriptLessEquals()
1182 {
1183 }
1184
1185 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1186 S32 getSize();
1187
1188 LLScriptExpression *mLeftSide;
1189 LLScriptExpression *mRightSide;
1190};
1191
1192class LLScriptGreaterEquals : public LLScriptExpression
1193{
1194public:
1195 LLScriptGreaterEquals(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1196 : LLScriptExpression(line, col, LET_GREATER_EQUALS), mLeftSide(leftside), mRightSide(rightside)
1197 {
1198 }
1199
1200 ~LLScriptGreaterEquals()
1201 {
1202 }
1203
1204 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1205 S32 getSize();
1206
1207 LLScriptExpression *mLeftSide;
1208 LLScriptExpression *mRightSide;
1209};
1210
1211class LLScriptLessThan : public LLScriptExpression
1212{
1213public:
1214 LLScriptLessThan(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1215 : LLScriptExpression(line, col, LET_LESS_THAN), mLeftSide(leftside), mRightSide(rightside)
1216 {
1217 }
1218
1219 ~LLScriptLessThan()
1220 {
1221 }
1222
1223 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1224 S32 getSize();
1225
1226 LLScriptExpression *mLeftSide;
1227 LLScriptExpression *mRightSide;
1228};
1229
1230class LLScriptGreaterThan : public LLScriptExpression
1231{
1232public:
1233 LLScriptGreaterThan(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1234 : LLScriptExpression(line, col, LET_GREATER_THAN), mLeftSide(leftside), mRightSide(rightside)
1235 {
1236 }
1237
1238 ~LLScriptGreaterThan()
1239 {
1240 }
1241
1242 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1243 S32 getSize();
1244
1245 LLScriptExpression *mLeftSide;
1246 LLScriptExpression *mRightSide;
1247};
1248
1249class LLScriptPlus : public LLScriptExpression
1250{
1251public:
1252 LLScriptPlus(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1253 : LLScriptExpression(line, col, LET_PLUS), mLeftSide(leftside), mRightSide(rightside)
1254 {
1255 }
1256
1257 ~LLScriptPlus()
1258 {
1259 }
1260
1261 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1262 S32 getSize();
1263
1264 LLScriptExpression *mLeftSide;
1265 LLScriptExpression *mRightSide;
1266};
1267
1268class LLScriptMinus : public LLScriptExpression
1269{
1270public:
1271 LLScriptMinus(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1272 : LLScriptExpression(line, col, LET_MINUS), mLeftSide(leftside), mRightSide(rightside)
1273 {
1274 }
1275
1276 ~LLScriptMinus()
1277 {
1278 }
1279
1280 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1281 S32 getSize();
1282
1283 LLScriptExpression *mLeftSide;
1284 LLScriptExpression *mRightSide;
1285};
1286
1287class LLScriptTimes : public LLScriptExpression
1288{
1289public:
1290 LLScriptTimes(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1291 : LLScriptExpression(line, col, LET_TIMES), mLeftSide(leftside), mRightSide(rightside)
1292 {
1293 }
1294
1295 ~LLScriptTimes()
1296 {
1297 }
1298
1299 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1300 S32 getSize();
1301
1302 LLScriptExpression *mLeftSide;
1303 LLScriptExpression *mRightSide;
1304};
1305
1306class LLScriptDivide : public LLScriptExpression
1307{
1308public:
1309 LLScriptDivide(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1310 : LLScriptExpression(line, col, LET_DIVIDE), mLeftSide(leftside), mRightSide(rightside)
1311 {
1312 }
1313
1314 ~LLScriptDivide()
1315 {
1316 }
1317
1318 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1319 S32 getSize();
1320
1321 LLScriptExpression *mLeftSide;
1322 LLScriptExpression *mRightSide;
1323};
1324
1325class LLScriptMod : public LLScriptExpression
1326{
1327public:
1328 LLScriptMod(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1329 : LLScriptExpression(line, col, LET_MOD), mLeftSide(leftside), mRightSide(rightside)
1330 {
1331 }
1332
1333 ~LLScriptMod()
1334 {
1335 }
1336
1337 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1338 S32 getSize();
1339
1340 LLScriptExpression *mLeftSide;
1341 LLScriptExpression *mRightSide;
1342};
1343
1344class LLScriptBitAnd : public LLScriptExpression
1345{
1346public:
1347 LLScriptBitAnd(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1348 : LLScriptExpression(line, col, LET_BIT_AND), mLeftSide(leftside), mRightSide(rightside)
1349 {
1350 }
1351
1352 ~LLScriptBitAnd()
1353 {
1354 }
1355
1356 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1357 S32 getSize();
1358
1359 LLScriptExpression *mLeftSide;
1360 LLScriptExpression *mRightSide;
1361};
1362
1363class LLScriptBitOr : public LLScriptExpression
1364{
1365public:
1366 LLScriptBitOr(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1367 : LLScriptExpression(line, col, LET_BIT_OR), mLeftSide(leftside), mRightSide(rightside)
1368 {
1369 }
1370
1371 ~LLScriptBitOr()
1372 {
1373 }
1374
1375 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1376 S32 getSize();
1377
1378 LLScriptExpression *mLeftSide;
1379 LLScriptExpression *mRightSide;
1380};
1381
1382class LLScriptBitXor : public LLScriptExpression
1383{
1384public:
1385 LLScriptBitXor(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1386 : LLScriptExpression(line, col, LET_BIT_XOR), mLeftSide(leftside), mRightSide(rightside)
1387 {
1388 }
1389
1390 ~LLScriptBitXor()
1391 {
1392 }
1393
1394 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1395 S32 getSize();
1396
1397 LLScriptExpression *mLeftSide;
1398 LLScriptExpression *mRightSide;
1399};
1400
1401class LLScriptBooleanAnd : public LLScriptExpression
1402{
1403public:
1404 LLScriptBooleanAnd(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1405 : LLScriptExpression(line, col, LET_BOOLEAN_AND), mLeftSide(leftside), mRightSide(rightside)
1406 {
1407 }
1408
1409 ~LLScriptBooleanAnd()
1410 {
1411 }
1412
1413 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1414 S32 getSize();
1415
1416 LLScriptExpression *mLeftSide;
1417 LLScriptExpression *mRightSide;
1418};
1419
1420class LLScriptBooleanOr : public LLScriptExpression
1421{
1422public:
1423 LLScriptBooleanOr(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1424 : LLScriptExpression(line, col, LET_BOOLEAN_OR), mLeftSide(leftside), mRightSide(rightside)
1425 {
1426 }
1427
1428 ~LLScriptBooleanOr()
1429 {
1430 }
1431
1432 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1433 S32 getSize();
1434
1435 LLScriptExpression *mLeftSide;
1436 LLScriptExpression *mRightSide;
1437};
1438
1439class LLScriptShiftLeft : public LLScriptExpression
1440{
1441public:
1442 LLScriptShiftLeft(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1443 : LLScriptExpression(line, col, LET_SHIFT_LEFT), mLeftSide(leftside), mRightSide(rightside)
1444 {
1445 }
1446
1447 ~LLScriptShiftLeft()
1448 {
1449 }
1450
1451 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1452 S32 getSize();
1453
1454 LLScriptExpression *mLeftSide;
1455 LLScriptExpression *mRightSide;
1456};
1457
1458class LLScriptShiftRight : public LLScriptExpression
1459{
1460public:
1461 LLScriptShiftRight(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
1462 : LLScriptExpression(line, col, LET_SHIFT_RIGHT), mLeftSide(leftside), mRightSide(rightside)
1463 {
1464 }
1465
1466 ~LLScriptShiftRight()
1467 {
1468 }
1469
1470 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1471 S32 getSize();
1472
1473 LLScriptExpression *mLeftSide;
1474 LLScriptExpression *mRightSide;
1475};
1476
1477class LLScriptParenthesis : public LLScriptExpression
1478{
1479public:
1480 LLScriptParenthesis(S32 line, S32 col, LLScriptExpression *expression)
1481 : LLScriptExpression(line, col, LET_PARENTHESIS), mExpression(expression)
1482 {
1483 }
1484
1485 ~LLScriptParenthesis()
1486 {
1487 }
1488
1489 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1490 S32 getSize();
1491
1492 LLScriptExpression *mExpression;
1493};
1494
1495class LLScriptUnaryMinus : public LLScriptExpression
1496{
1497public:
1498 LLScriptUnaryMinus(S32 line, S32 col, LLScriptExpression *expression)
1499 : LLScriptExpression(line, col, LET_UNARY_MINUS), mExpression(expression)
1500 {
1501 }
1502
1503 ~LLScriptUnaryMinus()
1504 {
1505 }
1506
1507 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1508 S32 getSize();
1509
1510 LLScriptExpression *mExpression;
1511};
1512
1513class LLScriptBooleanNot : public LLScriptExpression
1514{
1515public:
1516 LLScriptBooleanNot(S32 line, S32 col, LLScriptExpression *expression)
1517 : LLScriptExpression(line, col, LET_BOOLEAN_NOT), mExpression(expression)
1518 {
1519 }
1520
1521 ~LLScriptBooleanNot()
1522 {
1523 }
1524
1525 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1526 S32 getSize();
1527
1528 LLScriptExpression *mExpression;
1529};
1530
1531class LLScriptBitNot : public LLScriptExpression
1532{
1533public:
1534 LLScriptBitNot(S32 line, S32 col, LLScriptExpression *expression)
1535 : LLScriptExpression(line, col, LET_BIT_NOT), mExpression(expression)
1536 {
1537 }
1538
1539 ~LLScriptBitNot()
1540 {
1541 }
1542
1543 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1544 S32 getSize();
1545
1546 LLScriptExpression *mExpression;
1547};
1548
1549class LLScriptPreIncrement : public LLScriptExpression
1550{
1551public:
1552 LLScriptPreIncrement(S32 line, S32 col, LLScriptExpression *expression)
1553 : LLScriptExpression(line, col, LET_PRE_INCREMENT), mExpression(expression)
1554 {
1555 }
1556
1557 ~LLScriptPreIncrement()
1558 {
1559 }
1560
1561 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1562 S32 getSize();
1563
1564 LLScriptExpression *mExpression;
1565};
1566
1567class LLScriptPreDecrement : public LLScriptExpression
1568{
1569public:
1570 LLScriptPreDecrement(S32 line, S32 col, LLScriptExpression *expression)
1571 : LLScriptExpression(line, col, LET_PRE_DECREMENT), mExpression(expression)
1572 {
1573 }
1574
1575 ~LLScriptPreDecrement()
1576 {
1577 }
1578
1579 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1580 S32 getSize();
1581
1582 LLScriptExpression *mExpression;
1583};
1584
1585class LLScriptTypeCast : public LLScriptExpression
1586{
1587public:
1588 LLScriptTypeCast(S32 line, S32 col, LLScriptType *type, LLScriptExpression *expression)
1589 : LLScriptExpression(line, col, LET_CAST), mType(type), mExpression(expression)
1590 {
1591 }
1592
1593 ~LLScriptTypeCast()
1594 {
1595 }
1596
1597 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1598 S32 getSize();
1599
1600 LLScriptType *mType;
1601 LLScriptExpression *mExpression;
1602};
1603
1604class LLScriptVectorInitializer : public LLScriptExpression
1605{
1606public:
1607 LLScriptVectorInitializer(S32 line, S32 col, LLScriptExpression *expression1,
1608 LLScriptExpression *expression2,
1609 LLScriptExpression *expression3)
1610 : LLScriptExpression(line, col, LET_VECTOR_INITIALIZER),
1611 mExpression1(expression1),
1612 mExpression2(expression2),
1613 mExpression3(expression3)
1614 {
1615 }
1616
1617 ~LLScriptVectorInitializer()
1618 {
1619 }
1620
1621 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1622 S32 getSize();
1623
1624 LLScriptExpression *mExpression1;
1625 LLScriptExpression *mExpression2;
1626 LLScriptExpression *mExpression3;
1627};
1628
1629class LLScriptQuaternionInitializer : public LLScriptExpression
1630{
1631public:
1632 LLScriptQuaternionInitializer(S32 line, S32 col, LLScriptExpression *expression1,
1633 LLScriptExpression *expression2,
1634 LLScriptExpression *expression3,
1635 LLScriptExpression *expression4)
1636 : LLScriptExpression(line, col, LET_VECTOR_INITIALIZER),
1637 mExpression1(expression1),
1638 mExpression2(expression2),
1639 mExpression3(expression3),
1640 mExpression4(expression4)
1641 {
1642 }
1643
1644 ~LLScriptQuaternionInitializer()
1645 {
1646 }
1647
1648 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1649 S32 getSize();
1650
1651 LLScriptExpression *mExpression1;
1652 LLScriptExpression *mExpression2;
1653 LLScriptExpression *mExpression3;
1654 LLScriptExpression *mExpression4;
1655};
1656
1657class LLScriptListInitializer : public LLScriptExpression
1658{
1659public:
1660 LLScriptListInitializer(S32 line, S32 col, LLScriptExpression *expressionlist)
1661 : LLScriptExpression(line, col, LET_LIST_INITIALIZER), mExpressionList(expressionlist)
1662 {
1663 }
1664
1665 ~LLScriptListInitializer()
1666 {
1667 }
1668
1669 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1670 S32 getSize();
1671
1672 LLScriptExpression *mExpressionList;
1673};
1674
1675class LLScriptPostIncrement : public LLScriptExpression
1676{
1677public:
1678 LLScriptPostIncrement(S32 line, S32 col, LLScriptExpression *expression)
1679 : LLScriptExpression(line, col, LET_POST_INCREMENT), mExpression(expression)
1680 {
1681 }
1682
1683 ~LLScriptPostIncrement()
1684 {
1685 }
1686
1687 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1688 S32 getSize();
1689
1690 LLScriptExpression *mExpression;
1691};
1692
1693class LLScriptPostDecrement : public LLScriptExpression
1694{
1695public:
1696 LLScriptPostDecrement(S32 line, S32 col, LLScriptExpression *expression)
1697 : LLScriptExpression(line, col, LET_POST_DECREMENT), mExpression(expression)
1698 {
1699 }
1700
1701 ~LLScriptPostDecrement()
1702 {
1703 }
1704
1705 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1706 S32 getSize();
1707
1708 LLScriptExpression *mExpression;
1709};
1710
1711class LLScriptFunctionCall : public LLScriptExpression
1712{
1713public:
1714 LLScriptFunctionCall(S32 line, S32 col, LLScriptIdentifier *identifier, LLScriptExpression *expressionlist)
1715 : LLScriptExpression(line, col, LET_FUNCTION_CALL), mIdentifier(identifier), mExpressionList(expressionlist)
1716 {
1717 }
1718
1719 ~LLScriptFunctionCall()
1720 {
1721 }
1722
1723 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1724 S32 getSize();
1725
1726 LLScriptIdentifier *mIdentifier;
1727 LLScriptExpression *mExpressionList;
1728};
1729
1730class LLScriptPrint : public LLScriptExpression
1731{
1732public:
1733 LLScriptPrint(S32 line, S32 col, LLScriptExpression *expression)
1734 : LLScriptExpression(line, col, LET_PRINT), mExpression(expression)
1735 {
1736 }
1737
1738 ~LLScriptPrint()
1739 {
1740 }
1741
1742 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1743 S32 getSize();
1744
1745 LLScriptExpression *mExpression;
1746};
1747
1748class LLScriptConstantExpression : public LLScriptExpression
1749{
1750public:
1751 LLScriptConstantExpression(S32 line, S32 col, LLScriptConstant *constant)
1752 : LLScriptExpression(line, col, LET_CONSTANT), mConstant(constant)
1753 {
1754 }
1755
1756 ~LLScriptConstantExpression()
1757 {
1758 }
1759
1760 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1761 S32 getSize();
1762
1763 LLScriptConstant *mConstant;
1764};
1765
1766// statement
1767typedef enum e_lscript_statement_types
1768{
1769 LSSMT_NULL,
1770 LSSMT_SEQUENCE,
1771 LSSMT_NOOP,
1772 LSSMT_STATE_CHANGE,
1773 LSSMT_JUMP,
1774 LSSMT_LABEL,
1775 LSSMT_RETURN,
1776 LSSMT_EXPRESSION,
1777 LSSMT_IF,
1778 LSSMT_IF_ELSE,
1779 LSSMT_FOR,
1780 LSSMT_DO_WHILE,
1781 LSSMT_WHILE,
1782 LSSMT_DECLARATION,
1783 LSSMT_COMPOUND_STATEMENT,
1784 LSSMT_EOF
1785} LSCRIPTStatementType;
1786
1787class LLScriptStatement : public LLScriptFilePosition
1788{
1789public:
1790 LLScriptStatement(S32 line, S32 col, LSCRIPTStatementType type)
1791 : LLScriptFilePosition(line, col), mType(type), mNextp(NULL), mStatementScope(NULL), mAllowDeclarations(TRUE)
1792 {
1793 }
1794
1795 virtual ~LLScriptStatement()
1796 {
1797 delete mStatementScope;
1798 }
1799
1800 void addStatement(LLScriptStatement *event);
1801
1802 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1803
1804 void gonext(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1805 S32 getSize();
1806
1807 LSCRIPTStatementType mType;
1808 LLScriptStatement *mNextp;
1809 LLScriptScope *mStatementScope;
1810 BOOL mAllowDeclarations;
1811};
1812
1813class LLScriptStatementSequence : public LLScriptStatement
1814{
1815public:
1816 LLScriptStatementSequence(S32 line, S32 col, LLScriptStatement *first, LLScriptStatement *second)
1817 : LLScriptStatement(line, col, LSSMT_SEQUENCE), mFirstp(first), mSecondp(second)
1818 {
1819 }
1820
1821 ~LLScriptStatementSequence()
1822 {
1823 }
1824
1825 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1826 S32 getSize();
1827
1828 LLScriptStatement *mFirstp;
1829 LLScriptStatement *mSecondp;
1830};
1831
1832class LLScriptNOOP : public LLScriptStatement
1833{
1834public:
1835 LLScriptNOOP(S32 line, S32 col)
1836 : LLScriptStatement(line, col, LSSMT_NOOP)
1837 {
1838 }
1839
1840 ~LLScriptNOOP() {}
1841
1842 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1843 S32 getSize();
1844};
1845
1846class LLScriptStateChange : public LLScriptStatement
1847{
1848public:
1849 LLScriptStateChange(S32 line, S32 col, LLScriptIdentifier *identifier)
1850 : LLScriptStatement(line, col, LSSMT_STATE_CHANGE), mIdentifier(identifier)
1851 {
1852 }
1853
1854 ~LLScriptStateChange()
1855 {
1856 }
1857
1858 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1859 S32 getSize();
1860
1861 LLScriptIdentifier *mIdentifier;
1862};
1863
1864class LLScriptJump : public LLScriptStatement
1865{
1866public:
1867 LLScriptJump(S32 line, S32 col, LLScriptIdentifier *identifier)
1868 : LLScriptStatement(line, col, LSSMT_JUMP), mIdentifier(identifier)
1869 {
1870 }
1871
1872 ~LLScriptJump()
1873 {
1874 }
1875
1876 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1877 S32 getSize();
1878
1879 LLScriptIdentifier *mIdentifier;
1880};
1881
1882class LLScriptLabel : public LLScriptStatement
1883{
1884public:
1885 LLScriptLabel(S32 line, S32 col, LLScriptIdentifier *identifier)
1886 : LLScriptStatement(line, col, LSSMT_LABEL), mIdentifier(identifier)
1887 {
1888 }
1889
1890 ~LLScriptLabel()
1891 {
1892 }
1893
1894 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1895 S32 getSize();
1896
1897 LLScriptIdentifier *mIdentifier;
1898};
1899
1900class LLScriptReturn : public LLScriptStatement
1901{
1902public:
1903 LLScriptReturn(S32 line, S32 col, LLScriptExpression *expression)
1904 : LLScriptStatement(line, col, LSSMT_RETURN), mExpression(expression), mType(LST_NULL)
1905 {
1906 }
1907
1908 ~LLScriptReturn()
1909 {
1910 }
1911
1912 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1913 S32 getSize();
1914
1915 LLScriptExpression *mExpression;
1916 LSCRIPTType mType;
1917};
1918
1919class LLScriptExpressionStatement : public LLScriptStatement
1920{
1921public:
1922 LLScriptExpressionStatement(S32 line, S32 col, LLScriptExpression *expression)
1923 : LLScriptStatement(line, col, LSSMT_EXPRESSION), mExpression(expression)
1924 {
1925 }
1926
1927 ~LLScriptExpressionStatement()
1928 {
1929 }
1930
1931 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1932 S32 getSize();
1933
1934 LLScriptExpression *mExpression;
1935};
1936
1937class LLScriptIf : public LLScriptStatement
1938{
1939public:
1940 LLScriptIf(S32 line, S32 col, LLScriptExpression *expression, LLScriptStatement *statement)
1941 : LLScriptStatement(line, col, LSSMT_IF), mType(LST_NULL), mExpression(expression), mStatement(statement)
1942 {
1943 }
1944
1945 ~LLScriptIf()
1946 {
1947 }
1948
1949 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1950 S32 getSize();
1951
1952 LSCRIPTType mType;
1953 LLScriptExpression *mExpression;
1954 LLScriptStatement *mStatement;
1955};
1956
1957class LLScriptIfElse : public LLScriptStatement
1958{
1959public:
1960 LLScriptIfElse(S32 line, S32 col, LLScriptExpression *expression, LLScriptStatement *statement1, LLScriptStatement *statement2)
1961 : LLScriptStatement(line, col, LSSMT_IF_ELSE), mExpression(expression), mStatement1(statement1), mStatement2(statement2), mType(LST_NULL)
1962 {
1963 }
1964
1965 ~LLScriptIfElse()
1966 {
1967 }
1968
1969 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1970 S32 getSize();
1971
1972 LLScriptExpression *mExpression;
1973 LLScriptStatement *mStatement1;
1974 LLScriptStatement *mStatement2;
1975 LSCRIPTType mType;
1976};
1977
1978class LLScriptFor : public LLScriptStatement
1979{
1980public:
1981 LLScriptFor(S32 line, S32 col, LLScriptExpression *sequence, LLScriptExpression *expression, LLScriptExpression *expressionlist, LLScriptStatement *statement)
1982 : LLScriptStatement(line, col, LSSMT_FOR), mSequence(sequence), mExpression(expression), mExpressionList(expressionlist), mStatement(statement), mType(LST_NULL)
1983 {
1984 }
1985
1986 ~LLScriptFor()
1987 {
1988 }
1989
1990 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
1991 S32 getSize();
1992
1993 LLScriptExpression *mSequence;
1994 LLScriptExpression *mExpression;
1995 LLScriptExpression *mExpressionList;
1996 LLScriptStatement *mStatement;
1997 LSCRIPTType mType;
1998};
1999
2000class LLScriptDoWhile : public LLScriptStatement
2001{
2002public:
2003 LLScriptDoWhile(S32 line, S32 col, LLScriptStatement *statement, LLScriptExpression *expression)
2004 : LLScriptStatement(line, col, LSSMT_DO_WHILE), mStatement(statement), mExpression(expression), mType(LST_NULL)
2005 {
2006 }
2007
2008 ~LLScriptDoWhile()
2009 {
2010 }
2011
2012 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2013 S32 getSize();
2014
2015 LLScriptStatement *mStatement;
2016 LLScriptExpression *mExpression;
2017 LSCRIPTType mType;
2018};
2019
2020class LLScriptWhile : public LLScriptStatement
2021{
2022public:
2023 LLScriptWhile(S32 line, S32 col, LLScriptExpression *expression, LLScriptStatement *statement)
2024 : LLScriptStatement(line, col, LSSMT_WHILE), mExpression(expression), mStatement(statement), mType(LST_NULL)
2025 {
2026 }
2027
2028 ~LLScriptWhile()
2029 {
2030 }
2031
2032 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2033 S32 getSize();
2034
2035 LLScriptExpression *mExpression;
2036 LLScriptStatement *mStatement;
2037 LSCRIPTType mType;
2038};
2039
2040// local variables
2041class LLScriptDeclaration : public LLScriptStatement
2042{
2043public:
2044 LLScriptDeclaration(S32 line, S32 col, LLScriptType *type, LLScriptIdentifier *identifier, LLScriptExpression *expression)
2045 : LLScriptStatement(line, col, LSSMT_DECLARATION), mType(type), mIdentifier(identifier), mExpression(expression)
2046 {
2047 }
2048
2049 ~LLScriptDeclaration()
2050 {
2051 }
2052
2053 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2054 S32 getSize();
2055
2056 LLScriptType *mType;
2057 LLScriptIdentifier *mIdentifier;
2058 LLScriptExpression *mExpression;
2059};
2060
2061class LLScriptCompoundStatement : public LLScriptStatement
2062{
2063public:
2064 LLScriptCompoundStatement(S32 line, S32 col, LLScriptStatement *statement)
2065 : LLScriptStatement(line, col, LSSMT_COMPOUND_STATEMENT), mStatement(statement)
2066 {
2067 }
2068
2069 ~LLScriptCompoundStatement()
2070 {
2071 }
2072
2073 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2074 S32 getSize();
2075
2076 LLScriptStatement *mStatement;
2077};
2078
2079class LLScriptEventHandler : public LLScriptFilePosition
2080{
2081public:
2082 LLScriptEventHandler(S32 line, S32 col, LLScriptEvent *event, LLScriptStatement *statement)
2083 : LLScriptFilePosition(line, col), mEventp(event), mStatement(statement), mNextp(NULL), mEventScope(NULL), mbNeedTrailingReturn(FALSE), mScopeEntry(NULL), mStackSpace(0)
2084 {
2085 }
2086
2087 ~LLScriptEventHandler()
2088 {
2089 delete mEventScope;
2090 delete mScopeEntry;
2091 }
2092
2093 void addEvent(LLScriptEventHandler *event);
2094
2095 void gonext(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2096
2097 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2098 S32 getSize();
2099
2100 LLScriptEvent *mEventp;
2101 LLScriptStatement *mStatement;
2102 LLScriptEventHandler *mNextp;
2103 LLScriptScope *mEventScope;
2104 BOOL mbNeedTrailingReturn;
2105 LLScriptScopeEntry *mScopeEntry;
2106
2107 S32 mStackSpace;
2108
2109};
2110
2111
2112// global functions
2113class LLScriptFunctionDec : public LLScriptFilePosition
2114{
2115public:
2116 LLScriptFunctionDec(S32 line, S32 col, LLScriptType *type, LLScriptIdentifier *identifier)
2117 : LLScriptFilePosition(line, col), mType(type), mIdentifier(identifier), mNextp(NULL)
2118 {
2119 }
2120
2121 ~LLScriptFunctionDec()
2122 {
2123 }
2124
2125 void addFunctionParameter(LLScriptFunctionDec *dec);
2126
2127 void gonext(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2128
2129 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2130 S32 getSize();
2131
2132 LLScriptType *mType;
2133 LLScriptIdentifier *mIdentifier;
2134 LLScriptFunctionDec *mNextp;
2135};
2136
2137class LLScriptGlobalFunctions : public LLScriptFilePosition
2138{
2139public:
2140 LLScriptGlobalFunctions(S32 line, S32 col, LLScriptType *type,
2141 LLScriptIdentifier *identifier,
2142 LLScriptFunctionDec *parameters,
2143 LLScriptStatement *statements)
2144 : LLScriptFilePosition(line, col), mType(type), mIdentifier(identifier), mParameters(parameters), mStatements(statements), mNextp(NULL), mFunctionScope(NULL), mbNeedTrailingReturn(FALSE)
2145 {
2146 }
2147
2148 void addGlobalFunction(LLScriptGlobalFunctions *global);
2149
2150 ~LLScriptGlobalFunctions()
2151 {
2152 delete mFunctionScope;
2153 }
2154
2155 void gonext(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2156
2157 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2158 S32 getSize();
2159
2160 LLScriptType *mType;
2161 LLScriptIdentifier *mIdentifier;
2162 LLScriptFunctionDec *mParameters;
2163 LLScriptStatement *mStatements;
2164 LLScriptGlobalFunctions *mNextp;
2165 LLScriptScope *mFunctionScope;
2166 BOOL mbNeedTrailingReturn;
2167
2168};
2169
2170typedef enum e_lscript_state_type
2171{
2172 LSSTYPE_NULL,
2173 LSSTYPE_DEFAULT,
2174 LSSTYPE_USER,
2175 LSSTYPE_EOF
2176} LSCRIPTStateType;
2177
2178// info on state
2179class LLScriptState : public LLScriptFilePosition
2180{
2181public:
2182 LLScriptState(S32 line, S32 col, LSCRIPTStateType type, LLScriptIdentifier *identifier, LLScriptEventHandler *event)
2183 : LLScriptFilePosition(line, col), mType(type), mIdentifier(identifier), mEvent(event), mNextp(NULL)
2184 {
2185 }
2186
2187 void addState(LLScriptState *state);
2188
2189 ~LLScriptState()
2190 {
2191 }
2192
2193 void gonext(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2194
2195 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2196 S32 getSize();
2197
2198 LSCRIPTStateType mType;
2199 LLScriptIdentifier *mIdentifier;
2200 LLScriptEventHandler *mEvent;
2201 LLScriptState *mNextp;
2202
2203};
2204
2205class LLScritpGlobalStorage : public LLScriptFilePosition
2206{
2207public:
2208
2209 LLScritpGlobalStorage(LLScriptGlobalVariable *var)
2210 : LLScriptFilePosition(0, 0), mGlobal(var), mbGlobalFunction(FALSE), mNextp(NULL)
2211 {
2212 }
2213
2214 LLScritpGlobalStorage(LLScriptGlobalFunctions *func)
2215 : LLScriptFilePosition(0, 0), mGlobal(func), mbGlobalFunction(TRUE), mNextp(NULL)
2216 {
2217 }
2218
2219 ~LLScritpGlobalStorage()
2220 {
2221 }
2222
2223 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
2224 {
2225 }
2226
2227 S32 getSize()
2228 {
2229 return 0;
2230 }
2231
2232 void addGlobal(LLScritpGlobalStorage *global)
2233 {
2234 if (mNextp)
2235 {
2236 global->mNextp = mNextp;
2237 }
2238 mNextp = global;
2239 }
2240
2241 LLScriptFilePosition *mGlobal;
2242 BOOL mbGlobalFunction;
2243 LLScritpGlobalStorage *mNextp;
2244};
2245
2246// top level container for entire script
2247class LLScriptScript : public LLScriptFilePosition
2248{
2249public:
2250 LLScriptScript(LLScritpGlobalStorage *globals,
2251 LLScriptState *states);
2252
2253 ~LLScriptScript()
2254 {
2255 delete mGlobalScope;
2256 }
2257
2258 void recurse(FILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata);
2259 S32 getSize();
2260
2261 void setBytecodeDest(const char* dst_filename);
2262
2263 LLScriptState *mStates;
2264 LLScriptScope *mGlobalScope;
2265 LLScriptGlobalVariable *mGlobals;
2266 LLScriptGlobalFunctions *mGlobalFunctions;
2267 BOOL mGodLike;
2268
2269private:
2270 char mBytecodeDest[MAX_STRING];
2271};
2272
2273class LLScriptAllocationManager
2274{
2275public:
2276 LLScriptAllocationManager() {}
2277 ~LLScriptAllocationManager()
2278 {
2279 mAllocationList.deleteAllData();
2280 }
2281
2282 void addAllocation(LLScriptFilePosition *ptr)
2283 {
2284 mAllocationList.addData(ptr);
2285 }
2286
2287 void deleteAllocations()
2288 {
2289 mAllocationList.deleteAllData();
2290 }
2291
2292 LLLinkedList<LLScriptFilePosition> mAllocationList;
2293};
2294
2295extern LLScriptAllocationManager *gAllocationManager;
2296extern LLScriptScript *gScriptp;
2297
2298#endif
generated by cgit v1.1 at 2025-04-26 14:49:48 +0000