/** 
 * @file lscript_tree.h
 * @brief provides the classes required to build lscript's abstract syntax tree and symbol table
 *
 * Copyright (c) 2002-2007, Linden Research, Inc.
 * 
 * The source code in this file ("Source Code") is provided by Linden Lab
 * to you under the terms of the GNU General Public License, version 2.0
 * ("GPL"), unless you have obtained a separate licensing agreement
 * ("Other License"), formally executed by you and Linden Lab.  Terms of
 * the GPL can be found in doc/GPL-license.txt in this distribution, or
 * online at http://secondlife.com/developers/opensource/gplv2
 * 
 * There are special exceptions to the terms and conditions of the GPL as
 * it is applied to this Source Code. View the full text of the exception
 * in the file doc/FLOSS-exception.txt in this software distribution, or
 * online at http://secondlife.com/developers/opensource/flossexception
 * 
 * By copying, modifying or distributing this software, you acknowledge
 * that you have read and understood your obligations described above,
 * and agree to abide by those obligations.
 * 
 * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
 * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
 * COMPLETENESS OR PERFORMANCE.
 */

#ifndef LL_LSCRIPT_TREE_H
#define LL_LSCRIPT_TREE_H

#include <stdio.h>
#include "stdtypes.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