lscript_tree.h

Go to the documentation of this file.

#ifndef LL_LSCRIPT_TREE_H
#define LL_LSCRIPT_TREE_H

#include "v3math.h"
#include "llquaternion.h"
#include "linked_lists.h"
#include "lscript_error.h"
#include "lscript_typecheck.h"
#include "lscript_byteformat.h"


// Nota Bene:  Class destructors don't delete pointed to classes because it isn't guaranteed that lex/yacc will build
//                              complete data structures.  Instead various chunks that are allocated are stored and deleted by allocation lists

class LLScriptType : public LLScriptFilePosition
{
public:
        LLScriptType(S32 line, S32 col, LSCRIPTType type)
                : LLScriptFilePosition(line, col), mType(type)
        {
        }

        ~LLScriptType() {}

        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);
        S32 getSize();

        LSCRIPTType     mType;
};

// contains a literal or constant value
class LLScriptConstant : public LLScriptFilePosition
{
public:
        LLScriptConstant(S32 line, S32 col, LSCRIPTType type)
                : LLScriptFilePosition(line, col), mType(type)
        {
        }

        virtual ~LLScriptConstant() {}

        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);
        S32 getSize();

        LSCRIPTType mType;
};

class LLScriptConstantInteger : public LLScriptConstant
{
public:
        LLScriptConstantInteger(S32 line, S32 col, S32 value)
                : LLScriptConstant(line, col, LST_INTEGER), mValue(value)
        {
        }

        ~LLScriptConstantInteger() {}

        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);
        S32 getSize();

        S32 mValue;
};

class LLScriptConstantFloat : public LLScriptConstant
{
public:
        LLScriptConstantFloat(S32 line, S32 col, F32 value)
                : LLScriptConstant(line, col, LST_FLOATINGPOINT), mValue(value)
        {
        }

        ~LLScriptConstantFloat() {}

        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);
        S32 getSize();

        F32 mValue;
};

class LLScriptConstantString : public LLScriptConstant
{
public:
        LLScriptConstantString(S32 line, S32 col, char *value)
                : LLScriptConstant(line, col, LST_STRING), mValue(value)
        {
        }

        ~LLScriptConstantString() 
        {
                delete [] mValue;
                mValue = NULL;
        }

        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);
        S32 getSize();

        char *mValue;
};

// container for individual identifiers
class LLScriptIdentifier : public LLScriptFilePosition
{
public:
        LLScriptIdentifier(S32 line, S32 col, char *name, LLScriptType *type = NULL)
                : LLScriptFilePosition(line, col), mName(name), mScopeEntry(NULL), mType(type)
        {
        }

        ~LLScriptIdentifier() 
        {
                delete [] mName;
                mName = NULL;
        }

        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);
        S32 getSize();

        char                                    *mName;
        LLScriptScopeEntry              *mScopeEntry;
        LLScriptType                    *mType;
};

typedef enum e_lscript_simple_assignable_type
{
        LSSAT_NULL,
        LSSAT_IDENTIFIER,
        LSSAT_CONSTANT,
        LSSAT_VECTOR_CONSTANT,
        LSSAT_QUATERNION_CONSTANT,
        LSSAT_LIST_CONSTANT,
        LSSAT_EOF
} LSCRIPTSimpleAssignableType;

class LLScriptSimpleAssignable : public LLScriptFilePosition
{
public:
        LLScriptSimpleAssignable(S32 line, S32 col, LSCRIPTSimpleAssignableType type)
                : LLScriptFilePosition(line, col), mType(type), mNextp(NULL)
        {
        }

        void addAssignable(LLScriptSimpleAssignable *assign);

        virtual ~LLScriptSimpleAssignable() 
        {
                // don't delete next pointer because we're going to store allocation lists and delete from those
        }

        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);
        S32 getSize();

        LSCRIPTSimpleAssignableType             mType;
        LLScriptSimpleAssignable                *mNextp;
};

class LLScriptSAIdentifier : public LLScriptSimpleAssignable
{
public:
        LLScriptSAIdentifier(S32 line, S32 col, LLScriptIdentifier *identifier)
                : LLScriptSimpleAssignable(line, col, LSSAT_IDENTIFIER), mIdentifier(identifier)
        {
        }

        ~LLScriptSAIdentifier() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier *mIdentifier;
};

class LLScriptSAConstant : public LLScriptSimpleAssignable
{
public:
        LLScriptSAConstant(S32 line, S32 col, LLScriptConstant *constant)
                : LLScriptSimpleAssignable(line, col, LSSAT_CONSTANT), mConstant(constant)
        {
        }

        ~LLScriptSAConstant() 
        {
        }

        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);
        S32 getSize();

        LLScriptConstant *mConstant;
};

class LLScriptSAVector : public LLScriptSimpleAssignable
{
public:
        LLScriptSAVector(S32 line, S32 col, LLScriptSimpleAssignable *e1, 
                                                                                LLScriptSimpleAssignable *e2, 
                                                                                LLScriptSimpleAssignable *e3)
                : LLScriptSimpleAssignable(line, col, LSSAT_VECTOR_CONSTANT), 
                        mEntry1(e1), mEntry2(e2), mEntry3(e3)
        {
        }

        ~LLScriptSAVector() 
        {
        }

        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);
        S32 getSize();

        LLScriptSimpleAssignable *mEntry1;
        LLScriptSimpleAssignable *mEntry2;
        LLScriptSimpleAssignable *mEntry3;
};

class LLScriptSAQuaternion : public LLScriptSimpleAssignable
{
public:
        LLScriptSAQuaternion(S32 line, S32 col, LLScriptSimpleAssignable *e1, 
                                                                                        LLScriptSimpleAssignable *e2, 
                                                                                        LLScriptSimpleAssignable *e3, 
                                                                                        LLScriptSimpleAssignable *e4)
                : LLScriptSimpleAssignable(line, col, LSSAT_QUATERNION_CONSTANT), 
                        mEntry1(e1), mEntry2(e2), mEntry3(e3), mEntry4(e4)
        {
        }

        ~LLScriptSAQuaternion() 
        {
        }

        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);
        S32 getSize();

        LLScriptSimpleAssignable *mEntry1;
        LLScriptSimpleAssignable *mEntry2;
        LLScriptSimpleAssignable *mEntry3;
        LLScriptSimpleAssignable *mEntry4;
};

class LLScriptSAList : public LLScriptSimpleAssignable
{
public:
        LLScriptSAList(S32 line, S32 col, LLScriptSimpleAssignable *elist)
                : LLScriptSimpleAssignable(line, col, LSSAT_QUATERNION_CONSTANT), mEntryList(elist)
        {
        }

        ~LLScriptSAList() 
        {
        }

        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);
        S32 getSize();

        LLScriptSimpleAssignable        *mEntryList;
};

// global variables
class LLScriptGlobalVariable : public LLScriptFilePosition
{
public:
        LLScriptGlobalVariable(S32 line, S32 col, LLScriptType *type,
                                                                                          LLScriptIdentifier *identifier,
                                                                                          LLScriptSimpleAssignable *assignable)
                : LLScriptFilePosition(line, col), mType(type), mIdentifier(identifier), mAssignable(assignable), mNextp(NULL), mAssignableType(LST_NULL)
        {
        }

        void addGlobal(LLScriptGlobalVariable *global);

        ~LLScriptGlobalVariable() 
        {
        }
        
        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);

        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);
        S32 getSize();

        LLScriptType                            *mType;
        LLScriptIdentifier                      *mIdentifier;
        LLScriptSimpleAssignable        *mAssignable;
        LLScriptGlobalVariable          *mNextp;
        LSCRIPTType                                     mAssignableType;
};

// events

class LLScriptEvent : public LLScriptFilePosition
{
public:
        LLScriptEvent(S32 line, S32 col, LSCRIPTStateEventType type)
                : LLScriptFilePosition(line, col), mType(type)
        {
        }

        virtual ~LLScriptEvent()
        {
                // don't delete next pointer because we're going to store allocation lists and delete from those
        }

        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);
        S32 getSize();

        LSCRIPTStateEventType   mType;
};

class LLScriptStateEntryEvent : public LLScriptEvent
{
public:
        LLScriptStateEntryEvent(S32 line, S32 col)
                : LLScriptEvent(line, col, LSTT_STATE_ENTRY)
        {
        }

        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);
        S32 getSize();

        ~LLScriptStateEntryEvent() {}
};

class LLScriptStateExitEvent : public LLScriptEvent
{
public:
        LLScriptStateExitEvent(S32 line, S32 col)
                : LLScriptEvent(line, col, LSTT_STATE_EXIT)
        {
        }

        ~LLScriptStateExitEvent() {}

        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);
        S32 getSize();
};

class LLScriptTouchStartEvent : public LLScriptEvent
{
public:
        LLScriptTouchStartEvent(S32 line, S32 col, LLScriptIdentifier *count)
                : LLScriptEvent(line, col, LSTT_TOUCH_START), mCount(count)
        {
        }

        ~LLScriptTouchStartEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mCount;
};

class LLScriptTouchEvent : public LLScriptEvent
{
public:
        LLScriptTouchEvent(S32 line, S32 col, LLScriptIdentifier *count)
                : LLScriptEvent(line, col, LSTT_TOUCH), mCount(count)
        {
        }

        ~LLScriptTouchEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mCount;
};

class LLScriptTouchEndEvent : public LLScriptEvent
{
public:
        LLScriptTouchEndEvent(S32 line, S32 col, LLScriptIdentifier *count)
                : LLScriptEvent(line, col, LSTT_TOUCH_END), mCount(count)
        {
        }

        ~LLScriptTouchEndEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mCount;
};

class LLScriptCollisionStartEvent : public LLScriptEvent
{
public:
        LLScriptCollisionStartEvent(S32 line, S32 col, LLScriptIdentifier *count)
                : LLScriptEvent(line, col, LSTT_COLLISION_START), mCount(count)
        {
        }

        ~LLScriptCollisionStartEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mCount;
};

class LLScriptCollisionEvent : public LLScriptEvent
{
public:
        LLScriptCollisionEvent(S32 line, S32 col, LLScriptIdentifier *count)
                : LLScriptEvent(line, col, LSTT_COLLISION), mCount(count)
        {
        }

        ~LLScriptCollisionEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mCount;
};

class LLScriptCollisionEndEvent : public LLScriptEvent
{
public:
        LLScriptCollisionEndEvent(S32 line, S32 col, LLScriptIdentifier *count)
                : LLScriptEvent(line, col, LSTT_COLLISION_END), mCount(count)
        {
        }

        ~LLScriptCollisionEndEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mCount;
};

class LLScriptLandCollisionStartEvent : public LLScriptEvent
{
public:
        LLScriptLandCollisionStartEvent(S32 line, S32 col, LLScriptIdentifier *pos)
                : LLScriptEvent(line, col, LSTT_LAND_COLLISION_START), mPosition(pos)
        {
        }

        ~LLScriptLandCollisionStartEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mPosition;
};

class LLScriptLandCollisionEvent : public LLScriptEvent
{
public:
        LLScriptLandCollisionEvent(S32 line, S32 col, LLScriptIdentifier *pos)
                : LLScriptEvent(line, col, LSTT_LAND_COLLISION), mPosition(pos)
        {
        }

        ~LLScriptLandCollisionEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mPosition;
};

class LLScriptLandCollisionEndEvent : public LLScriptEvent
{
public:
        LLScriptLandCollisionEndEvent(S32 line, S32 col, LLScriptIdentifier *pos)
                : LLScriptEvent(line, col, LSTT_LAND_COLLISION_END), mPosition(pos)
        {
        }

        ~LLScriptLandCollisionEndEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mPosition;
};

class LLScriptInventoryEvent : public LLScriptEvent
{
public:
        LLScriptInventoryEvent(S32 line, S32 col, LLScriptIdentifier *change)
                : LLScriptEvent(line, col, LSTT_INVENTORY), mChange(change)
        {
        }

        ~LLScriptInventoryEvent() {}

        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);
        S32 getSize();

        LLScriptIdentifier      *mChange;
};

class LLScriptAttachEvent : public LLScriptEvent
{
public:
        LLScriptAttachEvent(S32 line, S32 col, LLScriptIdentifier *attach)
                : LLScriptEvent(line, col, LSTT_ATTACH), mAttach(attach)
        {
        }

        ~LLScriptAttachEvent() {}

        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);
        S32 getSize();

        LLScriptIdentifier      *mAttach;
};

class LLScriptDataserverEvent : public LLScriptEvent
{
public:
        LLScriptDataserverEvent(S32 line, S32 col, LLScriptIdentifier *id, LLScriptIdentifier *data)
                : LLScriptEvent(line, col, LSTT_DATASERVER), mID(id), mData(data)
        {
        }

        ~LLScriptDataserverEvent() {}

        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);
        S32 getSize();

        LLScriptIdentifier      *mID;
        LLScriptIdentifier      *mData;
};

class LLScriptTimerEvent : public LLScriptEvent
{
public:
        LLScriptTimerEvent(S32 line, S32 col)
                : LLScriptEvent(line, col, LSTT_TIMER)
        {
        }

        ~LLScriptTimerEvent() {}

        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);
        S32 getSize();
};

class LLScriptMovingStartEvent : public LLScriptEvent
{
public:
        LLScriptMovingStartEvent(S32 line, S32 col)
                : LLScriptEvent(line, col, LSTT_MOVING_START)
        {
        }

        ~LLScriptMovingStartEvent() {}

        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);
        S32 getSize();
};

class LLScriptMovingEndEvent : public LLScriptEvent
{
public:
        LLScriptMovingEndEvent(S32 line, S32 col)
                : LLScriptEvent(line, col, LSTT_MOVING_END)
        {
        }

        ~LLScriptMovingEndEvent() {}

        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);
        S32 getSize();
};

class LLScriptRTPEvent : public LLScriptEvent
{
public:
        LLScriptRTPEvent(S32 line, S32 col, LLScriptIdentifier *rtperm)
                : LLScriptEvent(line, col, LSTT_RTPERMISSIONS), mRTPermissions(rtperm) 
        {
        }

        ~LLScriptRTPEvent() {}

        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);
        S32 getSize();

        LLScriptIdentifier      *mRTPermissions;
};

class LLScriptChatEvent : public LLScriptEvent
{
public:
        LLScriptChatEvent(S32 line, S32 col, LLScriptIdentifier *channel, LLScriptIdentifier *name, LLScriptIdentifier *id, LLScriptIdentifier *message)
                : LLScriptEvent(line, col, LSTT_CHAT), mChannel(channel), mName(name), mID(id), mMessage(message)
        {
        }

        ~LLScriptChatEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mChannel;
        LLScriptIdentifier      *mName;
        LLScriptIdentifier      *mID;
        LLScriptIdentifier      *mMessage;
};

class LLScriptObjectRezEvent : public LLScriptEvent
{
public:
        LLScriptObjectRezEvent(S32 line, S32 col, LLScriptIdentifier *id)
                : LLScriptEvent(line, col, LSTT_OBJECT_REZ), mID(id)
        {
        }

        ~LLScriptObjectRezEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mID;
};

class LLScriptSensorEvent : public LLScriptEvent
{
public:
        LLScriptSensorEvent(S32 line, S32 col, LLScriptIdentifier *number)
                : LLScriptEvent(line, col, LSTT_SENSOR), mNumber(number)
        {
        }

        ~LLScriptSensorEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mNumber;
};

class LLScriptControlEvent : public LLScriptEvent
{
public:
        LLScriptControlEvent(S32 line, S32 col, LLScriptIdentifier *name, LLScriptIdentifier *levels, LLScriptIdentifier *edges)
                : LLScriptEvent(line, col, LSTT_CONTROL), mName(name), mLevels(levels), mEdges(edges)
        {
        }

        ~LLScriptControlEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mName;
        LLScriptIdentifier      *mLevels;
        LLScriptIdentifier      *mEdges;
};

class LLScriptLinkMessageEvent : public LLScriptEvent
{
public:
        LLScriptLinkMessageEvent(S32 line, S32 col, LLScriptIdentifier *sender, LLScriptIdentifier *num, LLScriptIdentifier *str, LLScriptIdentifier *id)
                : LLScriptEvent(line, col, LSTT_LINK_MESSAGE), mSender(sender), mNum(num), mStr(str), mID(id)
        {
        }

        ~LLScriptLinkMessageEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mSender;
        LLScriptIdentifier      *mNum;
        LLScriptIdentifier      *mStr;
        LLScriptIdentifier      *mID;
};

class LLScriptRemoteEvent : public LLScriptEvent
{
public:
        LLScriptRemoteEvent(S32 line, S32 col, LLScriptIdentifier *type, LLScriptIdentifier *channel, LLScriptIdentifier *message_id, LLScriptIdentifier *sender, LLScriptIdentifier *int_val, LLScriptIdentifier *str_val)
                : LLScriptEvent(line, col, LSTT_REMOTE_DATA), mType(type), mChannel(channel), mMessageID(message_id), mSender(sender), mIntVal(int_val), mStrVal(str_val)
        {
        }

        ~LLScriptRemoteEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mType;
        LLScriptIdentifier      *mChannel;
        LLScriptIdentifier      *mMessageID;
        LLScriptIdentifier      *mSender;
        LLScriptIdentifier      *mIntVal;
        LLScriptIdentifier      *mStrVal;
};

class LLScriptHTTPResponseEvent : public LLScriptEvent
{
public:
        LLScriptHTTPResponseEvent(S32 line, S32 col,
                LLScriptIdentifier *reqeust_id,
                LLScriptIdentifier *status,
                LLScriptIdentifier *metadata,
                LLScriptIdentifier *body)
                : LLScriptEvent(line, col, LSTT_HTTP_RESPONSE),
                 mRequestId(reqeust_id), mStatus(status), mMetadata(metadata), mBody(body)
        {
        }

        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);
                
        S32 getSize();

        LLScriptIdentifier      *mRequestId;
        LLScriptIdentifier      *mStatus;
        LLScriptIdentifier      *mMetadata;
        LLScriptIdentifier      *mBody;
};

class LLScriptRezEvent : public LLScriptEvent
{
public:
        LLScriptRezEvent(S32 line, S32 col, LLScriptIdentifier *start_param)
                : LLScriptEvent(line, col, LSTT_REZ), mStartParam(start_param)
        {
        }
        ~LLScriptRezEvent() {}

        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);
        S32 getSize();

        LLScriptIdentifier      *mStartParam;
};

class LLScriptNoSensorEvent : public LLScriptEvent
{
public:
        LLScriptNoSensorEvent(S32 line, S32 col)
                : LLScriptEvent(line, col, LSTT_NO_SENSOR)
        {
        }

        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);
        S32 getSize();

        ~LLScriptNoSensorEvent() {}
};

class LLScriptAtTarget : public LLScriptEvent
{
public:
        LLScriptAtTarget(S32 line, S32 col, LLScriptIdentifier *tnumber, LLScriptIdentifier *tpos, LLScriptIdentifier *ourpos)
                : LLScriptEvent(line, col, LSTT_AT_TARGET), mTargetNumber(tnumber), mTargetPosition(tpos), mOurPosition(ourpos)
        {
        }

        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);
        S32 getSize();

        ~LLScriptAtTarget() {}

        LLScriptIdentifier      *mTargetNumber;
        LLScriptIdentifier      *mTargetPosition;
        LLScriptIdentifier      *mOurPosition;
};

class LLScriptNotAtTarget : public LLScriptEvent
{
public:
        LLScriptNotAtTarget(S32 line, S32 col)
                : LLScriptEvent(line, col, LSTT_NOT_AT_TARGET)
        {
        }

        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);
        S32 getSize();

        ~LLScriptNotAtTarget() {}
};

class LLScriptAtRotTarget : public LLScriptEvent
{
public:
        LLScriptAtRotTarget(S32 line, S32 col, LLScriptIdentifier *tnumber, LLScriptIdentifier *trot, LLScriptIdentifier *ourrot)
                : LLScriptEvent(line, col, LSTT_AT_ROT_TARGET), mTargetNumber(tnumber), mTargetRotation(trot), mOurRotation(ourrot)
        {
        }

        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);
        S32 getSize();

        ~LLScriptAtRotTarget() {}

        LLScriptIdentifier      *mTargetNumber;
        LLScriptIdentifier      *mTargetRotation;
        LLScriptIdentifier      *mOurRotation;
};

class LLScriptNotAtRotTarget : public LLScriptEvent
{
public:
        LLScriptNotAtRotTarget(S32 line, S32 col)
                : LLScriptEvent(line, col, LSTT_NOT_AT_ROT_TARGET)
        {
        }

        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);
        S32 getSize();

        ~LLScriptNotAtRotTarget() {}
};

class LLScriptMoneyEvent : public LLScriptEvent
{
public:
        LLScriptMoneyEvent(S32 line, S32 col, LLScriptIdentifier *name, LLScriptIdentifier *amount)
                : LLScriptEvent(line, col, LSTT_MONEY), mName(name), mAmount(amount)
        {
        }

        ~LLScriptMoneyEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mName;
        LLScriptIdentifier      *mAmount;
};

class LLScriptEmailEvent : public LLScriptEvent
{
public:
        LLScriptEmailEvent(S32 line, S32 col, LLScriptIdentifier *time, LLScriptIdentifier *address, LLScriptIdentifier *subject, LLScriptIdentifier *body, LLScriptIdentifier *number)
                : LLScriptEvent(line, col, LSTT_EMAIL), mTime(time), mAddress(address), mSubject(subject), mBody(body), mNumber(number)
        {
        }

        ~LLScriptEmailEvent() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mTime;
        LLScriptIdentifier      *mAddress;
        LLScriptIdentifier      *mSubject;
        LLScriptIdentifier      *mBody;
        LLScriptIdentifier      *mNumber;
};


class LLScriptExpression : public LLScriptFilePosition
{
public:
        LLScriptExpression(S32 line, S32 col, LSCRIPTExpressionType type)
                : LLScriptFilePosition(line, col), mType(type), mNextp(NULL), mLeftType(LST_NULL), mRightType(LST_NULL), mReturnType(LST_NULL)
        {
        }

        void addExpression(LLScriptExpression *expression);

        virtual ~LLScriptExpression() 
        {
                // don't delete next pointer because we're going to store allocation lists and delete from those
        }

        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);

        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);
        S32 getSize();

        LSCRIPTExpressionType   mType;
        LLScriptExpression              *mNextp;
        LSCRIPTType                             mLeftType, mRightType, mReturnType;

};

class LLScriptForExpressionList : public LLScriptExpression
{
public:
        LLScriptForExpressionList(S32 line, S32 col, LLScriptExpression *first, LLScriptExpression *second)
                : LLScriptExpression(line, col, LET_FOR_EXPRESSION_LIST), mFirstp(first), mSecondp(second)
        {
        }

        ~LLScriptForExpressionList() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mFirstp;
        LLScriptExpression      *mSecondp;
};

class LLScriptFuncExpressionList : public LLScriptExpression
{
public:
        LLScriptFuncExpressionList(S32 line, S32 col, LLScriptExpression *first, LLScriptExpression *second)
                : LLScriptExpression(line, col, LET_FUNC_EXPRESSION_LIST), mFirstp(first), mSecondp(second)
        {
        }

        ~LLScriptFuncExpressionList() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mFirstp;
        LLScriptExpression      *mSecondp;
};

class LLScriptListExpressionList : public LLScriptExpression
{
public:
        LLScriptListExpressionList(S32 line, S32 col, LLScriptExpression *first, LLScriptExpression *second)
                : LLScriptExpression(line, col, LET_LIST_EXPRESSION_LIST), mFirstp(first), mSecondp(second)
        {
        }

        ~LLScriptListExpressionList() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mFirstp;
        LLScriptExpression      *mSecondp;
};

class LLScriptLValue : public LLScriptExpression
{
public:
        LLScriptLValue(S32 line, S32 col, LLScriptIdentifier *identifier, LLScriptIdentifier *accessor)
                : LLScriptExpression(line, col, LET_LVALUE), mOffset(0), mIdentifier(identifier), mAccessor(accessor)
        {
        }

        ~LLScriptLValue() 
        {
        }

        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);
        S32 getSize();

        S32                                     mOffset;
        LLScriptIdentifier      *mIdentifier;
        LLScriptIdentifier      *mAccessor;
};

class LLScriptAssignment : public LLScriptExpression
{
public:
        LLScriptAssignment(S32 line, S32 col, LLScriptExpression *lvalue, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_ASSIGNMENT), mLValue(lvalue), mRightSide(rightside)
        {
        }

        ~LLScriptAssignment() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLValue;
        LLScriptExpression      *mRightSide;
};

class LLScriptAddAssignment : public LLScriptExpression
{
public:
        LLScriptAddAssignment(S32 line, S32 col, LLScriptExpression *lvalue, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_ADD_ASSIGN), mLValue(lvalue), mRightSide(rightside)
        {
        }

        ~LLScriptAddAssignment() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLValue;
        LLScriptExpression      *mRightSide;
};

class LLScriptSubAssignment : public LLScriptExpression
{
public:
        LLScriptSubAssignment(S32 line, S32 col, LLScriptExpression *lvalue, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_SUB_ASSIGN), mLValue(lvalue), mRightSide(rightside)
        {
        }

        ~LLScriptSubAssignment() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLValue;
        LLScriptExpression      *mRightSide;
};

class LLScriptMulAssignment : public LLScriptExpression
{
public:
        LLScriptMulAssignment(S32 line, S32 col, LLScriptExpression *lvalue, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_MUL_ASSIGN), mLValue(lvalue), mRightSide(rightside)
        {
        }

        ~LLScriptMulAssignment() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLValue;
        LLScriptExpression      *mRightSide;
};

class LLScriptDivAssignment : public LLScriptExpression
{
public:
        LLScriptDivAssignment(S32 line, S32 col, LLScriptExpression *lvalue, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_DIV_ASSIGN), mLValue(lvalue), mRightSide(rightside)
        {
        }

        ~LLScriptDivAssignment() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLValue;
        LLScriptExpression      *mRightSide;
};

class LLScriptModAssignment : public LLScriptExpression
{
public:
        LLScriptModAssignment(S32 line, S32 col, LLScriptExpression *lvalue, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_MOD_ASSIGN), mLValue(lvalue), mRightSide(rightside)
        {
        }

        ~LLScriptModAssignment() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLValue;
        LLScriptExpression      *mRightSide;
};

class LLScriptEquality : public LLScriptExpression
{
public:
        LLScriptEquality(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_EQUALITY), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptEquality() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptNotEquals : public LLScriptExpression
{
public:
        LLScriptNotEquals(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_NOT_EQUALS), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptNotEquals() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptLessEquals : public LLScriptExpression
{
public:
        LLScriptLessEquals(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_LESS_EQUALS), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptLessEquals() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptGreaterEquals : public LLScriptExpression
{
public:
        LLScriptGreaterEquals(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_GREATER_EQUALS), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptGreaterEquals() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptLessThan : public LLScriptExpression
{
public:
        LLScriptLessThan(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_LESS_THAN), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptLessThan() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptGreaterThan : public LLScriptExpression
{
public:
        LLScriptGreaterThan(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_GREATER_THAN), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptGreaterThan() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptPlus : public LLScriptExpression
{
public:
        LLScriptPlus(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_PLUS), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptPlus() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptMinus : public LLScriptExpression
{
public:
        LLScriptMinus(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_MINUS), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptMinus() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptTimes : public LLScriptExpression
{
public:
        LLScriptTimes(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_TIMES), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptTimes() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptDivide : public LLScriptExpression
{
public:
        LLScriptDivide(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_DIVIDE), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptDivide() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptMod : public LLScriptExpression
{
public:
        LLScriptMod(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_MOD), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptMod() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptBitAnd : public LLScriptExpression
{
public:
        LLScriptBitAnd(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_BIT_AND), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptBitAnd() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptBitOr : public LLScriptExpression
{
public:
        LLScriptBitOr(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_BIT_OR), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptBitOr() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptBitXor : public LLScriptExpression
{
public:
        LLScriptBitXor(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_BIT_XOR), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptBitXor() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptBooleanAnd : public LLScriptExpression
{
public:
        LLScriptBooleanAnd(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_BOOLEAN_AND), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptBooleanAnd() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptBooleanOr : public LLScriptExpression
{
public:
        LLScriptBooleanOr(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_BOOLEAN_OR), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptBooleanOr() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptShiftLeft : public LLScriptExpression
{
public:
        LLScriptShiftLeft(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_SHIFT_LEFT), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptShiftLeft() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptShiftRight : public LLScriptExpression
{
public:
        LLScriptShiftRight(S32 line, S32 col, LLScriptExpression *leftside, LLScriptExpression *rightside)
                : LLScriptExpression(line, col, LET_SHIFT_RIGHT), mLeftSide(leftside), mRightSide(rightside)
        {
        }

        ~LLScriptShiftRight() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mLeftSide;
        LLScriptExpression      *mRightSide;
};

class LLScriptParenthesis : public LLScriptExpression
{
public:
        LLScriptParenthesis(S32 line, S32 col, LLScriptExpression *expression)
                : LLScriptExpression(line, col, LET_PARENTHESIS), mExpression(expression)
        {
        }

        ~LLScriptParenthesis() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression;
};

class LLScriptUnaryMinus : public LLScriptExpression
{
public:
        LLScriptUnaryMinus(S32 line, S32 col, LLScriptExpression *expression)
                : LLScriptExpression(line, col, LET_UNARY_MINUS), mExpression(expression)
        {
        }

        ~LLScriptUnaryMinus() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression;
};

class LLScriptBooleanNot : public LLScriptExpression
{
public:
        LLScriptBooleanNot(S32 line, S32 col, LLScriptExpression *expression)
                : LLScriptExpression(line, col, LET_BOOLEAN_NOT), mExpression(expression)
        {
        }

        ~LLScriptBooleanNot() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression;
};

class LLScriptBitNot : public LLScriptExpression
{
public:
        LLScriptBitNot(S32 line, S32 col, LLScriptExpression *expression)
                : LLScriptExpression(line, col, LET_BIT_NOT), mExpression(expression)
        {
        }

        ~LLScriptBitNot() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression;
};

class LLScriptPreIncrement : public LLScriptExpression
{
public:
        LLScriptPreIncrement(S32 line, S32 col, LLScriptExpression *expression)
                : LLScriptExpression(line, col, LET_PRE_INCREMENT), mExpression(expression)
        {
        }

        ~LLScriptPreIncrement() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression;
};

class LLScriptPreDecrement : public LLScriptExpression
{
public:
        LLScriptPreDecrement(S32 line, S32 col, LLScriptExpression *expression)
                : LLScriptExpression(line, col, LET_PRE_DECREMENT), mExpression(expression)
        {
        }

        ~LLScriptPreDecrement() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression;
};

class LLScriptTypeCast : public LLScriptExpression
{
public:
        LLScriptTypeCast(S32 line, S32 col, LLScriptType *type, LLScriptExpression *expression)
                : LLScriptExpression(line, col, LET_CAST), mType(type), mExpression(expression)
        {
        }

        ~LLScriptTypeCast() 
        {
        }

        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);
        S32 getSize();

        LLScriptType            *mType;
        LLScriptExpression      *mExpression;
};

class LLScriptVectorInitializer : public LLScriptExpression
{
public:
        LLScriptVectorInitializer(S32 line, S32 col, LLScriptExpression *expression1, 
                                                                                                 LLScriptExpression *expression2, 
                                                                                                 LLScriptExpression *expression3)
                : LLScriptExpression(line, col, LET_VECTOR_INITIALIZER), 
                        mExpression1(expression1),
                        mExpression2(expression2),
                        mExpression3(expression3)
        {
        }

        ~LLScriptVectorInitializer() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression1;
        LLScriptExpression      *mExpression2;
        LLScriptExpression      *mExpression3;
};

class LLScriptQuaternionInitializer : public LLScriptExpression
{
public:
        LLScriptQuaternionInitializer(S32 line, S32 col, LLScriptExpression *expression1, 
                                                                                                         LLScriptExpression *expression2, 
                                                                                                         LLScriptExpression *expression3,
                                                                                                         LLScriptExpression *expression4)
                : LLScriptExpression(line, col, LET_VECTOR_INITIALIZER), 
                        mExpression1(expression1),
                        mExpression2(expression2),
                        mExpression3(expression3),
                        mExpression4(expression4)
        {
        }

        ~LLScriptQuaternionInitializer() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression1;
        LLScriptExpression      *mExpression2;
        LLScriptExpression      *mExpression3;
        LLScriptExpression      *mExpression4;
};

class LLScriptListInitializer : public LLScriptExpression
{
public:
        LLScriptListInitializer(S32 line, S32 col, LLScriptExpression *expressionlist)
                : LLScriptExpression(line, col, LET_LIST_INITIALIZER), mExpressionList(expressionlist)
        {
        }

        ~LLScriptListInitializer() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpressionList;
};

class LLScriptPostIncrement : public LLScriptExpression
{
public:
        LLScriptPostIncrement(S32 line, S32 col, LLScriptExpression *expression)
                : LLScriptExpression(line, col, LET_POST_INCREMENT), mExpression(expression)
        {
        }

        ~LLScriptPostIncrement() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression;
};

class LLScriptPostDecrement : public LLScriptExpression
{
public:
        LLScriptPostDecrement(S32 line, S32 col, LLScriptExpression *expression)
                : LLScriptExpression(line, col, LET_POST_DECREMENT), mExpression(expression)
        {
        }

        ~LLScriptPostDecrement() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression;
};

class LLScriptFunctionCall : public LLScriptExpression
{
public:
        LLScriptFunctionCall(S32 line, S32 col, LLScriptIdentifier *identifier, LLScriptExpression *expressionlist)
                : LLScriptExpression(line, col, LET_FUNCTION_CALL), mIdentifier(identifier), mExpressionList(expressionlist)
        {
        }

        ~LLScriptFunctionCall() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier      *mIdentifier;
        LLScriptExpression      *mExpressionList;
};

class LLScriptPrint : public LLScriptExpression
{
public:
        LLScriptPrint(S32 line, S32 col, LLScriptExpression *expression)
                : LLScriptExpression(line, col, LET_PRINT), mExpression(expression)
        {
        }

        ~LLScriptPrint() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression;
};

class LLScriptConstantExpression : public LLScriptExpression
{
public:
        LLScriptConstantExpression(S32 line, S32 col, LLScriptConstant *constant)
                : LLScriptExpression(line, col, LET_CONSTANT), mConstant(constant)
        {
        }

        ~LLScriptConstantExpression() 
        {
        }

        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);
        S32 getSize();

        LLScriptConstant        *mConstant;
};

// statement
typedef enum e_lscript_statement_types
{
        LSSMT_NULL,
        LSSMT_SEQUENCE,
        LSSMT_NOOP,
        LSSMT_STATE_CHANGE,
        LSSMT_JUMP,
        LSSMT_LABEL,
        LSSMT_RETURN,
        LSSMT_EXPRESSION,
        LSSMT_IF,
        LSSMT_IF_ELSE,
        LSSMT_FOR,
        LSSMT_DO_WHILE,
        LSSMT_WHILE,
        LSSMT_DECLARATION,
        LSSMT_COMPOUND_STATEMENT,
        LSSMT_EOF
} LSCRIPTStatementType;

class LLScriptStatement : public LLScriptFilePosition
{
public:
        LLScriptStatement(S32 line, S32 col, LSCRIPTStatementType type)
                : LLScriptFilePosition(line, col), mType(type), mNextp(NULL), mStatementScope(NULL), mAllowDeclarations(TRUE)
        {
        }

        virtual ~LLScriptStatement() 
        {
                delete mStatementScope;
        }

        void addStatement(LLScriptStatement *event);

        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);

        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);
        S32 getSize();

        LSCRIPTStatementType    mType;
        LLScriptStatement               *mNextp;
        LLScriptScope                   *mStatementScope;
        BOOL                                    mAllowDeclarations;
};

class LLScriptStatementSequence : public LLScriptStatement
{
public:
        LLScriptStatementSequence(S32 line, S32 col, LLScriptStatement *first, LLScriptStatement *second)
                : LLScriptStatement(line, col, LSSMT_SEQUENCE), mFirstp(first), mSecondp(second)
        {
        }

        ~LLScriptStatementSequence() 
        {
        }

        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);
        S32 getSize();

        LLScriptStatement *mFirstp;
        LLScriptStatement *mSecondp;
};

class LLScriptNOOP : public LLScriptStatement
{
public:
        LLScriptNOOP(S32 line, S32 col)
                : LLScriptStatement(line, col, LSSMT_NOOP)
        {
        }

        ~LLScriptNOOP() {}

        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);
        S32 getSize();
};

class LLScriptStateChange : public LLScriptStatement
{
public:
        LLScriptStateChange(S32 line, S32 col, LLScriptIdentifier *identifier)
                : LLScriptStatement(line, col, LSSMT_STATE_CHANGE), mIdentifier(identifier)
        {
        }

        ~LLScriptStateChange() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier *mIdentifier;
};

class LLScriptJump : public LLScriptStatement
{
public:
        LLScriptJump(S32 line, S32 col, LLScriptIdentifier *identifier)
                : LLScriptStatement(line, col, LSSMT_JUMP), mIdentifier(identifier)
        {
        }

        ~LLScriptJump() 
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier *mIdentifier;
};

class LLScriptLabel : public LLScriptStatement
{
public:
        LLScriptLabel(S32 line, S32 col, LLScriptIdentifier *identifier)
                : LLScriptStatement(line, col, LSSMT_LABEL), mIdentifier(identifier)
        {
        }

        ~LLScriptLabel()
        {
        }

        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);
        S32 getSize();

        LLScriptIdentifier *mIdentifier;
};

class LLScriptReturn : public LLScriptStatement
{
public:
        LLScriptReturn(S32 line, S32 col, LLScriptExpression *expression)
                : LLScriptStatement(line, col, LSSMT_RETURN), mExpression(expression), mType(LST_NULL)
        {
        }

        ~LLScriptReturn() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression;
        LSCRIPTType                     mType;
};

class LLScriptExpressionStatement : public LLScriptStatement
{
public:
        LLScriptExpressionStatement(S32 line, S32 col, LLScriptExpression *expression)
                : LLScriptStatement(line, col, LSSMT_EXPRESSION), mExpression(expression)
        {
        }

        ~LLScriptExpressionStatement() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression      *mExpression;
};

class LLScriptIf : public LLScriptStatement
{
public:
        LLScriptIf(S32 line, S32 col, LLScriptExpression *expression, LLScriptStatement *statement)
                : LLScriptStatement(line, col, LSSMT_IF), mType(LST_NULL), mExpression(expression), mStatement(statement)
        {
        }

        ~LLScriptIf() 
        {
        }

        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);
        S32 getSize();

        LSCRIPTType                             mType;
        LLScriptExpression              *mExpression;
        LLScriptStatement               *mStatement;
};

class LLScriptIfElse : public LLScriptStatement
{
public:
        LLScriptIfElse(S32 line, S32 col, LLScriptExpression *expression, LLScriptStatement *statement1, LLScriptStatement *statement2)
                : LLScriptStatement(line, col, LSSMT_IF_ELSE), mExpression(expression), mStatement1(statement1), mStatement2(statement2), mType(LST_NULL)
        {
        }

        ~LLScriptIfElse() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression              *mExpression;
        LLScriptStatement               *mStatement1;
        LLScriptStatement               *mStatement2;
        LSCRIPTType                             mType;
};

class LLScriptFor : public LLScriptStatement
{
public:
        LLScriptFor(S32 line, S32 col, LLScriptExpression *sequence, LLScriptExpression *expression, LLScriptExpression *expressionlist, LLScriptStatement *statement)
                : LLScriptStatement(line, col, LSSMT_FOR), mSequence(sequence), mExpression(expression), mExpressionList(expressionlist), mStatement(statement), mType(LST_NULL)
        {
        }

        ~LLScriptFor() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression              *mSequence;
        LLScriptExpression              *mExpression;
        LLScriptExpression              *mExpressionList;
        LLScriptStatement               *mStatement;
        LSCRIPTType                             mType;
};

class LLScriptDoWhile : public LLScriptStatement
{
public:
        LLScriptDoWhile(S32 line, S32 col, LLScriptStatement *statement, LLScriptExpression *expression)
                : LLScriptStatement(line, col, LSSMT_DO_WHILE), mStatement(statement), mExpression(expression), mType(LST_NULL)
        {
        }

        ~LLScriptDoWhile() 
        {
        }

        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);
        S32 getSize();

        LLScriptStatement               *mStatement;
        LLScriptExpression              *mExpression;
        LSCRIPTType                             mType;
};

class LLScriptWhile : public LLScriptStatement
{
public:
        LLScriptWhile(S32 line, S32 col, LLScriptExpression *expression, LLScriptStatement *statement)
                : LLScriptStatement(line, col, LSSMT_WHILE), mExpression(expression), mStatement(statement), mType(LST_NULL)
        {
        }

        ~LLScriptWhile() 
        {
        }

        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);
        S32 getSize();

        LLScriptExpression                      *mExpression;
        LLScriptStatement                       *mStatement;
        LSCRIPTType                                     mType;
};

// local variables
class LLScriptDeclaration : public LLScriptStatement
{
public:
        LLScriptDeclaration(S32 line, S32 col, LLScriptType *type, LLScriptIdentifier *identifier, LLScriptExpression *expression)
                : LLScriptStatement(line, col, LSSMT_DECLARATION), mType(type), mIdentifier(identifier), mExpression(expression)
        {
        }

        ~LLScriptDeclaration() 
        {
        }

        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);
        S32 getSize();

        LLScriptType            *mType;
        LLScriptIdentifier      *mIdentifier;
        LLScriptExpression      *mExpression;
};

class LLScriptCompoundStatement : public LLScriptStatement
{
public:
        LLScriptCompoundStatement(S32 line, S32 col, LLScriptStatement *statement)
                : LLScriptStatement(line, col, LSSMT_COMPOUND_STATEMENT),  mStatement(statement)
        {
        }

        ~LLScriptCompoundStatement() 
        {
        }

        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);
        S32 getSize();

        LLScriptStatement       *mStatement;
};

class LLScriptEventHandler : public LLScriptFilePosition
{
public:
        LLScriptEventHandler(S32 line, S32 col, LLScriptEvent *event, LLScriptStatement *statement)
                : LLScriptFilePosition(line, col), mEventp(event), mStatement(statement), mNextp(NULL), mEventScope(NULL), mbNeedTrailingReturn(FALSE), mScopeEntry(NULL), mStackSpace(0)
        {
        }

        ~LLScriptEventHandler()
        {
                delete mEventScope;
                delete mScopeEntry;
        }

        void addEvent(LLScriptEventHandler *event);

        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);

        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);
        S32 getSize();

        LLScriptEvent                   *mEventp;
        LLScriptStatement               *mStatement;
        LLScriptEventHandler    *mNextp;
        LLScriptScope                   *mEventScope;
        BOOL                                    mbNeedTrailingReturn;
        LLScriptScopeEntry              *mScopeEntry;

        S32                                             mStackSpace;

};


// global functions
class LLScriptFunctionDec : public LLScriptFilePosition
{
public:
        LLScriptFunctionDec(S32 line, S32 col, LLScriptType *type, LLScriptIdentifier *identifier)
                : LLScriptFilePosition(line, col), mType(type), mIdentifier(identifier), mNextp(NULL)
        {
        }

        ~LLScriptFunctionDec() 
        {
        }

        void addFunctionParameter(LLScriptFunctionDec *dec);

        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);

        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);
        S32 getSize();

        LLScriptType            *mType;
        LLScriptIdentifier      *mIdentifier;
        LLScriptFunctionDec     *mNextp;
};

class LLScriptGlobalFunctions : public LLScriptFilePosition
{
public:
        LLScriptGlobalFunctions(S32 line, S32 col, LLScriptType *type, 
                                                                                           LLScriptIdentifier *identifier, 
                                                                                           LLScriptFunctionDec *parameters, 
                                                                                           LLScriptStatement *statements)
                : LLScriptFilePosition(line, col), mType(type), mIdentifier(identifier), mParameters(parameters), mStatements(statements), mNextp(NULL), mFunctionScope(NULL), mbNeedTrailingReturn(FALSE)
        {
        }

        void addGlobalFunction(LLScriptGlobalFunctions *global);

        ~LLScriptGlobalFunctions()
        {
                delete mFunctionScope;
        }

        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);

        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);
        S32 getSize();

        LLScriptType                            *mType;
        LLScriptIdentifier                      *mIdentifier;
        LLScriptFunctionDec                     *mParameters;
        LLScriptStatement                       *mStatements;
        LLScriptGlobalFunctions         *mNextp;
        LLScriptScope                           *mFunctionScope;
        BOOL                                            mbNeedTrailingReturn;

};

typedef enum e_lscript_state_type
{
        LSSTYPE_NULL,
        LSSTYPE_DEFAULT,
        LSSTYPE_USER,
        LSSTYPE_EOF
} LSCRIPTStateType;

// info on state
class LLScriptState : public LLScriptFilePosition
{
public:
        LLScriptState(S32 line, S32 col, LSCRIPTStateType type, LLScriptIdentifier *identifier, LLScriptEventHandler *event)
                : LLScriptFilePosition(line, col), mType(type), mIdentifier(identifier), mEvent(event), mNextp(NULL)
        {
        }

        void addState(LLScriptState *state);

        ~LLScriptState() 
        {
        }

        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);

        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);
        S32 getSize();

        LSCRIPTStateType                mType;
        LLScriptIdentifier              *mIdentifier;
        LLScriptEventHandler    *mEvent;
        LLScriptState                   *mNextp;

};

class LLScritpGlobalStorage : public LLScriptFilePosition
{
public:

        LLScritpGlobalStorage(LLScriptGlobalVariable *var)
                : LLScriptFilePosition(0, 0), mGlobal(var), mbGlobalFunction(FALSE), mNextp(NULL)
        {
        }

        LLScritpGlobalStorage(LLScriptGlobalFunctions *func)
                : LLScriptFilePosition(0, 0), mGlobal(func), mbGlobalFunction(TRUE), mNextp(NULL)
        {
        }

        ~LLScritpGlobalStorage()
        {
        }

        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)
        {
        }
        
        S32 getSize()
        {
                return 0;
        }

        void addGlobal(LLScritpGlobalStorage *global)
        {
                if (mNextp)
                {
                        global->mNextp = mNextp;
                }
                mNextp = global;
        }

        LLScriptFilePosition    *mGlobal;
        BOOL                                    mbGlobalFunction;
        LLScritpGlobalStorage   *mNextp;
};

// top level container for entire script
class LLScriptScript : public LLScriptFilePosition
{
public:
        LLScriptScript(LLScritpGlobalStorage *globals, 
                                   LLScriptState *states);

        ~LLScriptScript()
        {
                delete mGlobalScope;
        }

        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);
        S32 getSize();

        void setBytecodeDest(const char* dst_filename);

        LLScriptState                   *mStates;
        LLScriptScope                   *mGlobalScope;
        LLScriptGlobalVariable  *mGlobals;
        LLScriptGlobalFunctions *mGlobalFunctions;
        BOOL                                    mGodLike;

private:
        char mBytecodeDest[MAX_STRING];         /*Flawfinder: ignore*/
};

class LLScriptAllocationManager
{
public:
        LLScriptAllocationManager() {}
        ~LLScriptAllocationManager() 
        {
                mAllocationList.deleteAllData();
        }

        void addAllocation(LLScriptFilePosition *ptr)
        {
                mAllocationList.addData(ptr);
        }

        void deleteAllocations()
        {
                mAllocationList.deleteAllData();
        }

        LLLinkedList<LLScriptFilePosition> mAllocationList;
};

extern LLScriptAllocationManager *gAllocationManager;
extern LLScriptScript                    *gScriptp;

#endif

---