OPEN-292 - Remove lscript from project,

Remove legacy udp script upload methods,
Refactor script runtime perms from three arrays to one struct array so we don't have to juggle array order anymore.

20 files changed, 0 insertions, 18239 deletions

diff --git a/indra/lscript/lscript_compile/CMakeLists.txt b/indra/lscript/lscript_compile/CMakeLists.txt
deleted file mode 100755
index 07662005b9..0000000000
--- a/indra/lscript/lscript_compile/CMakeLists.txt
+++ /dev/null
@@ -1,157 +0,0 @@
-# -*- cmake -*-
-
-include(00-Common)
-include(LLCommon)
-include(LLMath)
-include(LLMessage)
-include(LLInventory)
-include(LLPrimitive)
-include(LScript)
-
-include(FindCygwin)
-
-find_program(FLEX flex
-             "C:/Program Files/GnuWin32/bin"
-             ${CYGWIN_INSTALL_PATH}/bin
-             /bin
-             /usr/bin
-             /usr/local/bin
-             )
-mark_as_advanced(FLEX)
-
-find_program(BISON bison
-             "C:/Program Files/GnuWin32/bin"
-             ${CYGWIN_INSTALL_PATH}/bin
-             /bin
-             /usr/bin
-             /usr/local/bin
-             )
-mark_as_advanced(BISON)
-
-find_program(M4 m4
-             "C:/Program Files/GnuWin32/bin"
-             ${CYGWIN_INSTALL_PATH}/bin
-             /bin
-             /usr/bin
-             /usr/local/bin
-             )
-mark_as_advanced(M4)
-
-include_directories(
-    ${LLCOMMON_INCLUDE_DIRS}
-    ${LLMATH_INCLUDE_DIRS}
-    ${LLMESSAGE_INCLUDE_DIRS}
-    ${LLINVENTORY_INCLUDE_DIRS}
-    ${LLPRIMITIVE_INCLUDE_DIRS}
-    ${LSCRIPT_INCLUDE_DIRS}
-    )
-include_directories(SYSTEM
-    ${LLCOMMON_SYSTEM_INCLUDE_DIRS}
-    )
-
-set(lscript_generated_SOURCE_FILES
-    indra.l.cpp
-    indra.y.cpp
-    )
-
-set(lscript_compile_SOURCE_FILES
-    lscript_alloc.cpp
-    lscript_bytecode.cpp
-    lscript_error.cpp
-    lscript_heap.cpp
-    lscript_resource.cpp
-    lscript_scope.cpp
-    lscript_tree.cpp
-    lscript_typecheck.cpp
-    )
-    
-set(lscript_compile_HEADER_FILES
-    CMakeLists.txt
-
-    indra.l
-    indra.y
-
-    ../lscript_alloc.h
-    ../lscript_byteformat.h
-    ../lscript_byteconvert.h
-    ../lscript_http.h
-
-    lscript_error.h
-    lscript_bytecode.h
-    lscript_heap.h
-    lscript_resource.h
-    lscript_scope.h
-    lscript_tree.h
-    lscript_typecheck.h
-    )
-
-set_source_files_properties(${lscript_compile_HEADER_FILES}
-                            PROPERTIES HEADER_FILE_ONLY TRUE)
-
-set_source_files_properties(${lscript_generated_SOURCE_FILES}
-                            PROPERTIES HEADER_FILE_ONLY FALSE GENERATED TRUE)
-
-list(APPEND lscript_compile_SOURCE_FILES ${lscript_generated_SOURCE_FILES} ${lscript_compile_HEADER_FILES})
-
-add_custom_command(
-    OUTPUT
-      ${CMAKE_CURRENT_BINARY_DIR}/indra.l.cpp
-    COMMAND ${FLEX}
-    ARGS
-      -P indra_
-      -o${CMAKE_CURRENT_BINARY_DIR}/indra.l.cpp
-      ${CMAKE_CURRENT_SOURCE_DIR}/indra.l
-    DEPENDS ${CMAKE_CURRENT_SOURCE_DIR}/indra.l
-    )
-
-if (WINDOWS)
-  set_source_files_properties(indra.l.cpp
-                              PROPERTIES COMPILE_FLAGS /DYY_NO_UNISTD_H)
-endif (WINDOWS)
-
-if (WINDOWS)
-  get_filename_component(M4_PATH ${M4} PATH)
-  add_custom_command(
-      OUTPUT
-        ${CMAKE_CURRENT_BINARY_DIR}/indra.y.cpp
-        ${CMAKE_CURRENT_BINARY_DIR}/indra.y.hpp
-      COMMAND ${CMAKE_CURRENT_SOURCE_DIR}/bison.bat
-      ARGS
-        ${BISON} ${M4_PATH}
-        -p indra_
-        -d -o ${CMAKE_CURRENT_BINARY_DIR}/indra.y.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/indra.y
-      DEPENDS
-        ${CMAKE_CURRENT_SOURCE_DIR}/bison.bat
-        ${CMAKE_CURRENT_SOURCE_DIR}/indra.y
-      )
-  include_directories(${CMAKE_CURRENT_SOURCE_DIR}/windows)
-else (WINDOWS)
-  add_custom_command(
-      OUTPUT
-        ${CMAKE_CURRENT_BINARY_DIR}/indra.y.cpp
-        ${CMAKE_CURRENT_BINARY_DIR}/indra.y.hpp
-      COMMAND
-        ${BISON}
-      ARGS
-        -p indra_
-        -d -o ${CMAKE_CURRENT_BINARY_DIR}/indra.y.cpp
-        ${CMAKE_CURRENT_SOURCE_DIR}/indra.y
-      DEPENDS
-        ${CMAKE_CURRENT_SOURCE_DIR}/indra.y
-      )
-endif (WINDOWS)
-
-if (DARWIN)
-  # Mac OS X 10.4 compatibility
-  add_custom_command(
-    OUTPUT
-      ${CMAKE_CURRENT_BINARY_DIR}/indra.y.hpp
-    COMMAND
-      mv
-      ${CMAKE_CURRENT_BINARY_DIR}/indra.y.cpp.h
-      ${CMAKE_CURRENT_BINARY_DIR}/indra.y.hpp
-    )
-endif (DARWIN)
-
-add_library (lscript_compile ${lscript_compile_SOURCE_FILES})
diff --git a/indra/lscript/lscript_compile/bison.bat b/indra/lscript/lscript_compile/bison.bat
deleted file mode 100644
index d40997225e..0000000000
--- a/indra/lscript/lscript_compile/bison.bat
+++ /dev/null
@@ -1,12 +0,0 @@
-@REM Run bison under Windows.  This script is needed so that bison can

-@REM find m4, even if neither program is present in PATH.

-

-@set bison=%1

-shift

-set M4PATH=%1

-shift

-set M4=

-

-set PATH=%M4PATH%;%PATH%

-@REM %* does not work with shift...

-%bison% %1 %2 %3 %4 %5 %6 %7 %8 %9

diff --git a/indra/lscript/lscript_compile/indra.l b/indra/lscript/lscript_compile/indra.l
deleted file mode 100755
index 7772c95609..0000000000
--- a/indra/lscript/lscript_compile/indra.l
+++ /dev/null
@@ -1,1013 +0,0 @@
-
-N			[0-9]
-L			[a-zA-Z_]
-H			[a-fA-F0-9]
-E			[Ee][+-]?{N}+
-FS			(f|F)
-%e 10000
-%n 4000
-%p 5000
-
-%top {
-	#include "linden_common.h"
-}
-
-%{
-// Deal with the fact that lex/yacc generates unreachable code
-#ifdef LL_WINDOWS
-#pragma warning (disable : 4018) // warning C4018: signed/unsigned mismatch
-#pragma warning (disable : 4702) // warning C4702: unreachable code
-#endif	//	LL_WINDOWS
-#include "llmath.h"
-#include "lscript_tree.h"
-#include "lscript_typecheck.h"
-#include "lscript_resource.h"
-#include "indra.y.hpp"
-#include "lltimer.h"
-#include "indra_constants.h"
-#include "lllslconstants.h"
-#include "lluuid.h"
-#include "llassetstorage.h"
-#include "llpartdata.h"
-#include "llvehicleparams.h"
-#include "llpermissionsflags.h"
-#include "llfollowcamparams.h"
-#include "llparcelflags.h"
-#include "llregionflags.h"
-#include "lscript_http.h"
-#include "llclickaction.h"
-#include "llmediaentry.h"
-
-void count();
-void line_comment();
-void block_comment();
-void parse_string();
-
-#define YYLMAX 16384
-#define YY_NEVER_INTERACTIVE 1 /* stops flex from calling isatty() */
-#ifdef LL_WINDOWS
-#define isatty(x) 0 /* hack for bug in cygwin flex 2.5.35 */
-#endif
-
-#ifdef ECHO
-#undef ECHO
-#endif
-
-#define ECHO do { } while (0)
-
-#define yyparse indra_parse
-#define yyerror indra_error
-#define yylval indra_lval
-#define yy_create_buffer indra__create_buffer
-#define yy_delete_buffer indra__delete_buffer
-#define yy_flex_debug indra__flex_debug
-#define yy_init_buffer indra__init_buffer
-#define yy_flush_buffer indra__flush_buffer
-#define yy_load_buffer_state indra__load_buffer_state
-#define yy_switch_to_buffer indra__switch_to_buffer
-#define yyin indra_in
-#define yyleng indra_leng
-#define yylex indra_lex
-#define yylineno indra_lineno
-#define yyout indra_out
-#define yyrestart indra_restart
-#define yytext indra_text
-#define yywrap indra_wrap
-#define yyalloc indra_alloc
-#define yyrealloc indra_realloc
-#define yyfree indra_free
-
-
-int yyparse( void );
-int yylex( void );
-int yyerror(const char *fmt, ...);
-
-%}
-
-%%
-"//"					{ gInternalLine++; gInternalColumn = 0; line_comment(); }
-"/*"					{ block_comment(); }
-
-"integer"			{ count(); return(INTEGER); }
-"float"				{ count(); return(FLOAT_TYPE); }
-"string"			{ count(); return(STRING); }
-"key"				{ count(); return(LLKEY); }
-"vector"			{ count(); return(VECTOR); }
-"quaternion"		{ count(); return(QUATERNION); }
-"rotation"			{ count(); return(QUATERNION); }
-"list"				{ count(); return(LIST); }
-
-"default"			{ count(); yylval.sval = new char[strlen(yytext) + 1]; strcpy(yylval.sval, yytext); return(STATE_DEFAULT); }
-"state"				{ count(); return(STATE); }
-"event"				{ count(); return(EVENT); }
-"jump"				{ count(); return(JUMP); }
-"return"			{ count(); return(RETURN); }
-"if"				{ count(); return(IF); }
-"else"				{ count(); return(ELSE); }
-"for"				{ count(); return(FOR); }
-"do"				{ count(); return(DO); }
-"while"				{ count(); return(WHILE); }
-
-"state_entry"			{ count(); return(STATE_ENTRY); }
-"state_exit"			{ count(); return(STATE_EXIT); }
-"touch_start"			{ count(); return(TOUCH_START); }
-"touch"					{ count(); return(TOUCH); }
-"touch_end"				{ count(); return(TOUCH_END); }
-"collision_start"		{ count(); return(COLLISION_START); }
-"collision"				{ count(); return(COLLISION); }
-"collision_end"			{ count(); return(COLLISION_END); }
-"land_collision_start"	{ count(); return(LAND_COLLISION_START); }
-"land_collision"		{ count(); return(LAND_COLLISION); }
-"land_collision_end"	{ count(); return(LAND_COLLISION_END); }
-"timer"					{ count(); return(TIMER); }
-"listen"				{ count(); return(CHAT); }
-"sensor"				{ count(); return(SENSOR); }
-"no_sensor"				{ count(); return(NO_SENSOR); }
-"control"				{ count(); return(CONTROL); }
-"print"					{ count(); return(PRINT); }
-"at_target"				{ count(); return(AT_TARGET); }
-"not_at_target"			{ count(); return(NOT_AT_TARGET); }
-"at_rot_target"			{ count(); return(AT_ROT_TARGET); }
-"not_at_rot_target"		{ count(); return(NOT_AT_ROT_TARGET); }
-"money"					{ count(); return(MONEY); }
-"email"					{ count(); return(EMAIL); }
-"run_time_permissions"	{ count(); return(RUN_TIME_PERMISSIONS); }
-"changed"				{ count(); return(INVENTORY); }
-"attach"				{ count(); return(ATTACH); }
-"dataserver"			{ count(); return(DATASERVER); }
-"moving_start"			{ count(); return(MOVING_START); }
-"moving_end"			{ count(); return(MOVING_END); }
-"link_message"			{ count(); return(LINK_MESSAGE); }
-"on_rez"				{ count(); return(REZ); }
-"object_rez"			{ count(); return(OBJECT_REZ); }
-"remote_data"			{ count(); return(REMOTE_DATA); }
-"http_response"			{ count(); return(HTTP_RESPONSE); }
-"http_request"			{ count(); return(HTTP_REQUEST); }
-"."						{ count(); return(PERIOD); }
-
-
-0[xX]{H}+			{ count(); yylval.ival = strtoul(yytext, NULL, 0);  return(INTEGER_CONSTANT); }
-{N}+				{ count(); yylval.ival = strtoul(yytext, NULL, 10); return(INTEGER_CONSTANT); }
-"TRUE"				{ count(); yylval.ival = 1; return(INTEGER_TRUE); }
-"FALSE"				{ count(); yylval.ival = 0; return(INTEGER_FALSE); }
-"STATUS_PHYSICS"		{ count(); yylval.ival = 0x1; return(INTEGER_CONSTANT); }
-"STATUS_ROTATE_X"		{ count(); yylval.ival = 0x2; return(INTEGER_CONSTANT); }
-"STATUS_ROTATE_Y"		{ count(); yylval.ival = 0x4; return(INTEGER_CONSTANT); }
-"STATUS_ROTATE_Z"		{ count(); yylval.ival = 0x8; return(INTEGER_CONSTANT); }
-"STATUS_PHANTOM"		{ count(); yylval.ival = 0x10; return(INTEGER_CONSTANT); }
-"STATUS_SANDBOX"		{ count(); yylval.ival = 0x20; return(INTEGER_CONSTANT); }
-"STATUS_BLOCK_GRAB"		{ count(); yylval.ival = 0x40; return(INTEGER_CONSTANT); }
-"STATUS_DIE_AT_EDGE"	{ count(); yylval.ival = 0x80; return(INTEGER_CONSTANT); }
-"STATUS_RETURN_AT_EDGE"	{ count(); yylval.ival = 0x100; return(INTEGER_CONSTANT); }
-"STATUS_CAST_SHADOWS"	{ count(); yylval.ival = 0x200; return(INTEGER_CONSTANT); }
-"STATUS_BLOCK_GRAB_OBJECT"	{ count(); yylval.ival = 0x400; return(INTEGER_CONSTANT); }
-
-"AGENT_FLYING"			{ count(); yylval.ival = AGENT_FLYING; return(INTEGER_CONSTANT); }
-"AGENT_ATTACHMENTS"		{ count(); yylval.ival = AGENT_ATTACHMENTS; return(INTEGER_CONSTANT); }
-"AGENT_SCRIPTED"		{ count(); yylval.ival = AGENT_SCRIPTED; return(INTEGER_CONSTANT); }
-"AGENT_MOUSELOOK"		{ count(); yylval.ival = AGENT_MOUSELOOK; return(INTEGER_CONSTANT); }
-"AGENT_SITTING"			{ count(); yylval.ival = AGENT_SITTING; return(INTEGER_CONSTANT); }
-"AGENT_ON_OBJECT"		{ count(); yylval.ival = AGENT_ON_OBJECT; return(INTEGER_CONSTANT); }
-"AGENT_AWAY"			{ count(); yylval.ival = AGENT_AWAY; return(INTEGER_CONSTANT); }
-"AGENT_WALKING"			{ count(); yylval.ival = AGENT_WALKING; return(INTEGER_CONSTANT); }
-"AGENT_IN_AIR"			{ count(); yylval.ival = AGENT_IN_AIR; return(INTEGER_CONSTANT); }
-"AGENT_TYPING"			{ count(); yylval.ival = AGENT_TYPING; return(INTEGER_CONSTANT); }
-"AGENT_CROUCHING"		{ count(); yylval.ival = AGENT_CROUCHING; return(INTEGER_CONSTANT); }
-"AGENT_BUSY"			{ count(); yylval.ival = AGENT_BUSY; return(INTEGER_CONSTANT); }
-"AGENT_ALWAYS_RUN"		{ count(); yylval.ival = AGENT_ALWAYS_RUN; return(INTEGER_CONSTANT); }
-"AGENT_AUTOPILOT"		{ count(); yylval.ival = AGENT_AUTOPILOT; return(INTEGER_CONSTANT); }
-
-"CAMERA_PITCH"				{ count(); yylval.ival = FOLLOWCAM_PITCH; return(INTEGER_CONSTANT); }
-"CAMERA_FOCUS_OFFSET"		{ count(); yylval.ival = FOLLOWCAM_FOCUS_OFFSET; return (INTEGER_CONSTANT); }
-"CAMERA_POSITION_LAG"		{ count(); yylval.ival = FOLLOWCAM_POSITION_LAG; return (INTEGER_CONSTANT); }
-"CAMERA_FOCUS_LAG"			{ count(); yylval.ival = FOLLOWCAM_FOCUS_LAG; return (INTEGER_CONSTANT); }
-"CAMERA_DISTANCE"			{ count(); yylval.ival = FOLLOWCAM_DISTANCE; return (INTEGER_CONSTANT); }
-"CAMERA_BEHINDNESS_ANGLE"	{ count(); yylval.ival = FOLLOWCAM_BEHINDNESS_ANGLE; return (INTEGER_CONSTANT); }
-"CAMERA_BEHINDNESS_LAG"		{ count(); yylval.ival = FOLLOWCAM_BEHINDNESS_LAG; return (INTEGER_CONSTANT); }
-"CAMERA_POSITION_THRESHOLD"	{ count(); yylval.ival = FOLLOWCAM_POSITION_THRESHOLD; return (INTEGER_CONSTANT); }
-"CAMERA_FOCUS_THRESHOLD"	{ count(); yylval.ival = FOLLOWCAM_FOCUS_THRESHOLD; return (INTEGER_CONSTANT); }
-"CAMERA_ACTIVE"				{ count(); yylval.ival = FOLLOWCAM_ACTIVE; return (INTEGER_CONSTANT); }
-"CAMERA_POSITION"			{ count(); yylval.ival = FOLLOWCAM_POSITION; return (INTEGER_CONSTANT); }
-"CAMERA_FOCUS"				{ count(); yylval.ival = FOLLOWCAM_FOCUS; return (INTEGER_CONSTANT); }
-"CAMERA_POSITION_LOCKED"	{ count(); yylval.ival = FOLLOWCAM_POSITION_LOCKED; return (INTEGER_CONSTANT); }
-"CAMERA_FOCUS_LOCKED"		{ count(); yylval.ival = FOLLOWCAM_FOCUS_LOCKED; return (INTEGER_CONSTANT); }
-
-"ANIM_ON"				{ count(); yylval.ival = 0x1; return(INTEGER_CONSTANT); }
-"LOOP"					{ count(); yylval.ival = 0x2; return(INTEGER_CONSTANT); }
-"REVERSE"				{ count(); yylval.ival = 0x4; return(INTEGER_CONSTANT); }
-"PING_PONG"				{ count(); yylval.ival = 0x8; return(INTEGER_CONSTANT); }
-"SMOOTH"				{ count(); yylval.ival = 0x10; return(INTEGER_CONSTANT); }
-"ROTATE"				{ count(); yylval.ival = 0x20; return(INTEGER_CONSTANT); }
-"SCALE"					{ count(); yylval.ival = 0x40; return(INTEGER_CONSTANT); }
-
-"ALL_SIDES"				{ count(); yylval.ival = LSL_ALL_SIDES; return(INTEGER_CONSTANT); }
-"LINK_ROOT"				{ count(); yylval.ival = LSL_LINK_ROOT; return(INTEGER_CONSTANT); }
-"LINK_SET"				{ count(); yylval.ival = LSL_LINK_SET; return(INTEGER_CONSTANT); }
-"LINK_ALL_OTHERS"		{ count(); yylval.ival = LSL_LINK_ALL_OTHERS; return(INTEGER_CONSTANT); }
-"LINK_ALL_CHILDREN"		{ count(); yylval.ival = LSL_LINK_ALL_CHILDREN; return(INTEGER_CONSTANT); }
-"LINK_THIS"				{ count(); yylval.ival = LSL_LINK_THIS; return(INTEGER_CONSTANT); }
-
-"AGENT"					{ count(); yylval.ival = 0x1; return(INTEGER_CONSTANT); }
-"ACTIVE"				{ count(); yylval.ival = 0x2; return(INTEGER_CONSTANT); }
-"PASSIVE"				{ count(); yylval.ival = 0x4; return(INTEGER_CONSTANT); }
-"SCRIPTED"				{ count(); yylval.ival = 0x8; return(INTEGER_CONSTANT); }
-
-"CONTROL_FWD"			{ count(); yylval.ival = AGENT_CONTROL_AT_POS; return(INTEGER_CONSTANT); }
-"CONTROL_BACK"			{ count(); yylval.ival = AGENT_CONTROL_AT_NEG; return(INTEGER_CONSTANT); }
-"CONTROL_LEFT"			{ count(); yylval.ival = AGENT_CONTROL_LEFT_POS; return(INTEGER_CONSTANT); }
-"CONTROL_RIGHT"			{ count(); yylval.ival = AGENT_CONTROL_LEFT_NEG; return(INTEGER_CONSTANT); }
-"CONTROL_ROT_LEFT"		{ count(); yylval.ival = AGENT_CONTROL_YAW_POS; return(INTEGER_CONSTANT); }
-"CONTROL_ROT_RIGHT"		{ count(); yylval.ival = AGENT_CONTROL_YAW_NEG; return(INTEGER_CONSTANT); }
-"CONTROL_UP"			{ count(); yylval.ival = AGENT_CONTROL_UP_POS; return(INTEGER_CONSTANT); }
-"CONTROL_DOWN"			{ count(); yylval.ival = AGENT_CONTROL_UP_NEG; return(INTEGER_CONSTANT); }
-"CONTROL_LBUTTON"		{ count(); yylval.ival = AGENT_CONTROL_LBUTTON_DOWN; return(INTEGER_CONSTANT); }
-"CONTROL_ML_LBUTTON"	{ count(); yylval.ival = AGENT_CONTROL_ML_LBUTTON_DOWN; return(INTEGER_CONSTANT); }
-
-"PERMISSION_DEBIT"				{ count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_DEBIT]; return(INTEGER_CONSTANT); }
-"PERMISSION_TAKE_CONTROLS"		{ count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_TAKE_CONTROLS]; return(INTEGER_CONSTANT); }
-"PERMISSION_REMAP_CONTROLS"		{ count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_REMAP_CONTROLS]; return(INTEGER_CONSTANT); }
-"PERMISSION_TRIGGER_ANIMATION"	{ count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_TRIGGER_ANIMATION]; return(INTEGER_CONSTANT); }
-"PERMISSION_ATTACH"				{ count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_ATTACH]; return(INTEGER_CONSTANT); }
-"PERMISSION_RELEASE_OWNERSHIP"	{ count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_RELEASE_OWNERSHIP]; return(INTEGER_CONSTANT); }
-"PERMISSION_CHANGE_LINKS"		{ count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_CHANGE_LINKS]; return(INTEGER_CONSTANT); }
-"PERMISSION_CHANGE_JOINTS"		{ count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_CHANGE_JOINTS]; return(INTEGER_CONSTANT); }
-"PERMISSION_CHANGE_PERMISSIONS"	{ count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_CHANGE_PERMISSIONS]; return(INTEGER_CONSTANT); }
-"PERMISSION_TRACK_CAMERA"		{ count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_TRACK_CAMERA]; return(INTEGER_CONSTANT); }
-"PERMISSION_CONTROL_CAMERA"		{ count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_CONTROL_CAMERA]; return(INTEGER_CONSTANT); }
-"PERMISSION_TELEPORT"			{ count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_TELEPORT]; return(INTEGER_CONSTANT); }
-"PERMISSION_SILENT_ESTATE_MANAGEMENT"   { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_SILENT_ESTATE_MANAGEMENT]; return(INTEGER_CONSTANT); }
-"PERMISSION_OVERRIDE_ANIMATIONS"    { count(); yylval.ival = LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_OVERRIDE_ANIMATIONS]; return(INTEGER_CONSTANT); }
-
-"INVENTORY_TEXTURE"					{ count(); yylval.ival = LLAssetType::AT_TEXTURE; return(INTEGER_CONSTANT); }
-"INVENTORY_SOUND"					{ count(); yylval.ival = LLAssetType::AT_SOUND; return(INTEGER_CONSTANT); }
-"INVENTORY_OBJECT"					{ count(); yylval.ival = LLAssetType::AT_OBJECT; return(INTEGER_CONSTANT); }
-"INVENTORY_SCRIPT"					{ count(); yylval.ival = LLAssetType::AT_LSL_TEXT; return(INTEGER_CONSTANT); }
-"INVENTORY_LANDMARK"				{ count(); yylval.ival = LLAssetType::AT_LANDMARK; return(INTEGER_CONSTANT); }
-"INVENTORY_CLOTHING"				{ count(); yylval.ival = LLAssetType::AT_CLOTHING; return(INTEGER_CONSTANT); }
-"INVENTORY_NOTECARD"				{ count(); yylval.ival = LLAssetType::AT_NOTECARD; return(INTEGER_CONSTANT); }
-"INVENTORY_BODYPART"				{ count(); yylval.ival = LLAssetType::AT_BODYPART; return(INTEGER_CONSTANT); }
-"INVENTORY_ANIMATION"				{ count(); yylval.ival = LLAssetType::AT_ANIMATION; return(INTEGER_CONSTANT); }
-"INVENTORY_GESTURE"					{ count(); yylval.ival = LLAssetType::AT_GESTURE; return(INTEGER_CONSTANT); }
-"INVENTORY_ALL"						{ count(); yylval.ival = LLAssetType::AT_NONE; return(INTEGER_CONSTANT); }
-"INVENTORY_NONE"					{ count(); yylval.ival = LLAssetType::AT_NONE; return(INTEGER_CONSTANT); }
-
-"CHANGED_INVENTORY"		{ count(); yylval.ival = CHANGED_INVENTORY; return(INTEGER_CONSTANT); }	
-"CHANGED_COLOR"			{ count(); yylval.ival = CHANGED_COLOR; return(INTEGER_CONSTANT); }	
-"CHANGED_SHAPE"			{ count(); yylval.ival = CHANGED_SHAPE; return(INTEGER_CONSTANT); }	
-"CHANGED_SCALE"			{ count(); yylval.ival = CHANGED_SCALE; return(INTEGER_CONSTANT); }	
-"CHANGED_TEXTURE"		{ count(); yylval.ival = CHANGED_TEXTURE; return(INTEGER_CONSTANT); }	
-"CHANGED_LINK"			{ count(); yylval.ival = CHANGED_LINK; return(INTEGER_CONSTANT); }	
-"CHANGED_ALLOWED_DROP"	{ count(); yylval.ival = CHANGED_ALLOWED_DROP; return(INTEGER_CONSTANT); }	
-"CHANGED_OWNER"			{ count(); yylval.ival = CHANGED_OWNER; return(INTEGER_CONSTANT); }	
-"CHANGED_REGION"		{ count(); yylval.ival = CHANGED_REGION; return(INTEGER_CONSTANT); }	
-"CHANGED_TELEPORT"		{ count(); yylval.ival = CHANGED_TELEPORT; return(INTEGER_CONSTANT); }	
-"CHANGED_REGION_START"	{ count(); yylval.ival = CHANGED_REGION_START; return(INTEGER_CONSTANT); }	
-"CHANGED_MEDIA"		    { count(); yylval.ival = CHANGED_MEDIA; return(INTEGER_CONSTANT); }	
-
-"OBJECT_UNKNOWN_DETAIL"	{ count(); yylval.ival = OBJECT_UNKNOWN_DETAIL; return(INTEGER_CONSTANT); }
-"OBJECT_NAME"			{ count(); yylval.ival = OBJECT_NAME; return(INTEGER_CONSTANT); }
-"OBJECT_DESC"			{ count(); yylval.ival = OBJECT_DESC; return(INTEGER_CONSTANT); }
-"OBJECT_POS"			{ count(); yylval.ival = OBJECT_POS; return(INTEGER_CONSTANT); }
-"OBJECT_ROT"			{ count(); yylval.ival = OBJECT_ROT; return(INTEGER_CONSTANT); }
-"OBJECT_VELOCITY"		{ count(); yylval.ival = OBJECT_VELOCITY; return(INTEGER_CONSTANT); }
-"OBJECT_OWNER"			{ count(); yylval.ival = OBJECT_OWNER; return(INTEGER_CONSTANT); }
-"OBJECT_GROUP"			{ count(); yylval.ival = OBJECT_GROUP; return(INTEGER_CONSTANT); }
-"OBJECT_CREATOR"		{ count(); yylval.ival = OBJECT_CREATOR; return(INTEGER_CONSTANT); }
-"OBJECT_RUNNING_SCRIPT_COUNT"	{ count(); yylval.ival = OBJECT_RUNNING_SCRIPT_COUNT; return(INTEGER_CONSTANT); }
-"OBJECT_TOTAL_SCRIPT_COUNT"		{ count(); yylval.ival = OBJECT_TOTAL_SCRIPT_COUNT; return(INTEGER_CONSTANT); }
-"OBJECT_SCRIPT_MEMORY"			{ count(); yylval.ival = OBJECT_SCRIPT_MEMORY; return(INTEGER_CONSTANT); }
-"OBJECT_SCRIPT_TIME"			{ count(); yylval.ival = OBJECT_SCRIPT_TIME; return(INTEGER_CONSTANT); }
-"OBJECT_PRIM_EQUIVALENCE"		{ count(); yylval.ival = OBJECT_PRIM_EQUIVALENCE; return(INTEGER_CONSTANT); }
-"OBJECT_SERVER_COST"			{ count(); yylval.ival = OBJECT_SERVER_COST; return(INTEGER_CONSTANT); }
-"OBJECT_STREAMING_COST"			{ count(); yylval.ival = OBJECT_STREAMING_COST; return(INTEGER_CONSTANT); }
-"OBJECT_PHYSICS_COST"			{ count(); yylval.ival = OBJECT_PHYSICS_COST; return(INTEGER_CONSTANT); }
-"OBJECT_CHARACTER_TIME"			{ count(); yylval.ival = OBJECT_CHARACTER_TIME; return(INTEGER_CONSTANT); }
-"OBJECT_ROOT"					{ count(); yylval.ival = OBJECT_ROOT; return(INTEGER_CONSTANT); }
-"OBJECT_ATTACHED_POINT"			{ count(); yylval.ival = OBJECT_ATTACHED_POINT; return(INTEGER_CONSTANT); }
-"OBJECT_PATHFINDING_TYPE"		{ count(); yylval.ival = OBJECT_PATHFINDING_TYPE; return(INTEGER_CONSTANT); }
-"OBJECT_PHYSICS"				{ count(); yylval.ival = OBJECT_PHYSICS; return(INTEGER_CONSTANT); }
-"OBJECT_PHANTOM"				{ count(); yylval.ival = OBJECT_PHANTOM; return(INTEGER_CONSTANT); }
-"OBJECT_TEMP_ON_REZ"			{ count(); yylval.ival = OBJECT_TEMP_ON_REZ; return(INTEGER_CONSTANT); }
-"OBJECT_RENDER_WEIGHT"			{ count(); yylval.ival = OBJECT_RENDER_WEIGHT; return(INTEGER_CONSTANT); }
-
-"TYPE_INTEGER"			{ count(); yylval.ival = LST_INTEGER; return(INTEGER_CONSTANT); }	
-"TYPE_FLOAT"			{ count(); yylval.ival = LST_FLOATINGPOINT; return(INTEGER_CONSTANT); }	
-"TYPE_STRING"			{ count(); yylval.ival = LST_STRING; return(INTEGER_CONSTANT); }	
-"TYPE_KEY"				{ count(); yylval.ival = LST_KEY; return(INTEGER_CONSTANT); }	
-"TYPE_VECTOR"			{ count(); yylval.ival = LST_VECTOR; return(INTEGER_CONSTANT); }	
-"TYPE_ROTATION"			{ count(); yylval.ival = LST_QUATERNION; return(INTEGER_CONSTANT); }	
-"TYPE_INVALID"			{ count(); yylval.ival = LST_NULL; return(INTEGER_CONSTANT); }	
-
-"NULL_KEY"				{ yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "00000000-0000-0000-0000-000000000000"); return(STRING_CONSTANT); }
-"EOF"					{ yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "\n\n\n"); return(STRING_CONSTANT); }
-"URL_REQUEST_GRANTED"	{ yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, URL_REQUEST_GRANTED); return(STRING_CONSTANT); }
-"URL_REQUEST_DENIED"	{ yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, URL_REQUEST_DENIED); return(STRING_CONSTANT); }
-
-"PI"					{ count(); yylval.fval = F_PI; return(FP_CONSTANT); }
-"TWO_PI"				{ count(); yylval.fval = F_TWO_PI; return(FP_CONSTANT); }
-"PI_BY_TWO"				{ count(); yylval.fval = F_PI_BY_TWO; return(FP_CONSTANT); }
-"DEG_TO_RAD"			{ count(); yylval.fval = DEG_TO_RAD; return(FP_CONSTANT); }
-"RAD_TO_DEG"			{ count(); yylval.fval = RAD_TO_DEG; return(FP_CONSTANT); }
-"SQRT2"					{ count(); yylval.fval = F_SQRT2; return(FP_CONSTANT); }
-
-"DEBUG_CHANNEL"			{ count(); yylval.ival = CHAT_CHANNEL_DEBUG; return(INTEGER_CONSTANT); }	
-"PUBLIC_CHANNEL"			{ count(); yylval.ival = 0; return(INTEGER_CONSTANT); }	
-
-"ZERO_VECTOR"			{ count(); return(ZERO_VECTOR); }
-"ZERO_ROTATION"			{ count(); return(ZERO_ROTATION); }
-
-"ATTACH_CHEST"		{ count(); yylval.ival = 1; return(INTEGER_CONSTANT); }
-"ATTACH_HEAD"		{ count(); yylval.ival = 2; return(INTEGER_CONSTANT); }
-"ATTACH_LSHOULDER"	{ count(); yylval.ival = 3; return(INTEGER_CONSTANT); }
-"ATTACH_RSHOULDER"	{ count(); yylval.ival = 4; return(INTEGER_CONSTANT); }
-"ATTACH_LHAND"		{ count(); yylval.ival = 5; return(INTEGER_CONSTANT); }
-"ATTACH_RHAND"		{ count(); yylval.ival = 6; return(INTEGER_CONSTANT); }
-"ATTACH_LFOOT"		{ count(); yylval.ival = 7; return(INTEGER_CONSTANT); }
-"ATTACH_RFOOT"		{ count(); yylval.ival = 8; return(INTEGER_CONSTANT); }
-"ATTACH_BACK"		{ count(); yylval.ival = 9; return(INTEGER_CONSTANT); }
-"ATTACH_PELVIS"		{ count(); yylval.ival = 10; return(INTEGER_CONSTANT); }
-"ATTACH_MOUTH"		{ count(); yylval.ival = 11; return(INTEGER_CONSTANT); }
-"ATTACH_CHIN"		{ count(); yylval.ival = 12; return(INTEGER_CONSTANT); }
-"ATTACH_LEAR"		{ count(); yylval.ival = 13; return(INTEGER_CONSTANT); }
-"ATTACH_REAR"		{ count(); yylval.ival = 14; return(INTEGER_CONSTANT); }
-"ATTACH_LEYE"		{ count(); yylval.ival = 15; return(INTEGER_CONSTANT); }
-"ATTACH_REYE"		{ count(); yylval.ival = 16; return(INTEGER_CONSTANT); }
-"ATTACH_NOSE"		{ count(); yylval.ival = 17; return(INTEGER_CONSTANT); }
-"ATTACH_RUARM"		{ count(); yylval.ival = 18; return(INTEGER_CONSTANT); }
-"ATTACH_RLARM"		{ count(); yylval.ival = 19; return(INTEGER_CONSTANT); }
-"ATTACH_LUARM"		{ count(); yylval.ival = 20; return(INTEGER_CONSTANT); }
-"ATTACH_LLARM"		{ count(); yylval.ival = 21; return(INTEGER_CONSTANT); }
-"ATTACH_RHIP"		{ count(); yylval.ival = 22; return(INTEGER_CONSTANT); }
-"ATTACH_RULEG"		{ count(); yylval.ival = 23; return(INTEGER_CONSTANT); }
-"ATTACH_RLLEG"		{ count(); yylval.ival = 24; return(INTEGER_CONSTANT); }
-"ATTACH_LHIP"		{ count(); yylval.ival = 25; return(INTEGER_CONSTANT); }
-"ATTACH_LULEG"		{ count(); yylval.ival = 26; return(INTEGER_CONSTANT); }
-"ATTACH_LLLEG"		{ count(); yylval.ival = 27; return(INTEGER_CONSTANT); }
-"ATTACH_BELLY"		{ count(); yylval.ival = 28; return(INTEGER_CONSTANT); }
-"ATTACH_RPEC"		{ count(); yylval.ival = 29; return(INTEGER_CONSTANT); }
-"ATTACH_LPEC"		{ count(); yylval.ival = 30; return(INTEGER_CONSTANT); }
-"ATTACH_HUD_CENTER_2"	{ count(); yylval.ival = 31; return(INTEGER_CONSTANT); }
-"ATTACH_HUD_TOP_RIGHT"	{ count(); yylval.ival = 32; return(INTEGER_CONSTANT); }
-"ATTACH_HUD_TOP_CENTER"	{ count(); yylval.ival = 33; return(INTEGER_CONSTANT); }
-"ATTACH_HUD_TOP_LEFT"	{ count(); yylval.ival = 34; return(INTEGER_CONSTANT); }
-"ATTACH_HUD_CENTER_1"	{ count(); yylval.ival = 35; return(INTEGER_CONSTANT); }
-"ATTACH_HUD_BOTTOM_LEFT" { count(); yylval.ival = 36; return(INTEGER_CONSTANT); }
-"ATTACH_HUD_BOTTOM"		{ count(); yylval.ival = 37; return(INTEGER_CONSTANT); }
-"ATTACH_HUD_BOTTOM_RIGHT"	{ count(); yylval.ival = 38; return(INTEGER_CONSTANT); }
-"ATTACH_NECK"   { count(); yylval.ival = 39; return(INTEGER_CONSTANT); }
-"ATTACH_AVATAR_CENTER"   { count(); yylval.ival = 40; return(INTEGER_CONSTANT); }
-
-"LAND_LEVEL"		{ count(); yylval.ival = E_LANDBRUSH_LEVEL; return(INTEGER_CONSTANT); }
-"LAND_RAISE"		{ count(); yylval.ival = E_LANDBRUSH_RAISE; return(INTEGER_CONSTANT); }
-"LAND_LOWER"		{ count(); yylval.ival = E_LANDBRUSH_LOWER; return(INTEGER_CONSTANT); }
-"LAND_SMOOTH"		{ count(); yylval.ival = E_LANDBRUSH_SMOOTH; return(INTEGER_CONSTANT); }
-"LAND_NOISE"		{ count(); yylval.ival = E_LANDBRUSH_NOISE; return(INTEGER_CONSTANT); }
-"LAND_REVERT"		{ count(); yylval.ival = E_LANDBRUSH_REVERT; return(INTEGER_CONSTANT); }
-	
-"LAND_SMALL_BRUSH"	{ count(); yylval.ival = 1; return(INTEGER_CONSTANT); }
-"LAND_MEDIUM_BRUSH"	{ count(); yylval.ival = 2; return(INTEGER_CONSTANT); }
-"LAND_LARGE_BRUSH"	{ count(); yylval.ival = 3; return(INTEGER_CONSTANT); }
-	
-"DATA_ONLINE"		{ count(); yylval.ival = 1; return(INTEGER_CONSTANT); }
-"DATA_NAME"			{ count(); yylval.ival = 2; return(INTEGER_CONSTANT); }
-"DATA_BORN"			{ count(); yylval.ival = 3; return(INTEGER_CONSTANT); }
-"DATA_RATING"		{ count(); yylval.ival = 4; return(INTEGER_CONSTANT); }
-"DATA_SIM_POS"		{ count(); yylval.ival = 5; return(INTEGER_CONSTANT); }
-"DATA_SIM_STATUS"	{ count(); yylval.ival = 6; return(INTEGER_CONSTANT); }
-"DATA_SIM_RATING"	{ count(); yylval.ival = 7; return(INTEGER_CONSTANT); }
-"DATA_PAYINFO"		{ count(); yylval.ival = 8; return(INTEGER_CONSTANT); }
-
-"PAYMENT_INFO_ON_FILE" { count(); yylval.ival = 1; return(INTEGER_CONSTANT); }
-"PAYMENT_INFO_USED"  { count(); yylval.ival = 2; return(INTEGER_CONSTANT); }
-
-"REMOTE_DATA_CHANNEL"	{ count(); yylval.ival = LSL_REMOTE_DATA_CHANNEL; return(INTEGER_CONSTANT); }
-"REMOTE_DATA_REQUEST"	{ count(); yylval.ival = LSL_REMOTE_DATA_REQUEST; return(INTEGER_CONSTANT); }
-"REMOTE_DATA_REPLY"		{ count(); yylval.ival = LSL_REMOTE_DATA_REPLY; return(INTEGER_CONSTANT); }
-
-
-"PSYS_PART_FLAGS"		{ count(); yylval.ival = LLPS_PART_FLAGS; return(INTEGER_CONSTANT); }
-"PSYS_PART_START_COLOR"	{ count(); yylval.ival = LLPS_PART_START_COLOR; return (INTEGER_CONSTANT); }
-"PSYS_PART_START_ALPHA"	{ count(); yylval.ival = LLPS_PART_START_ALPHA; return (INTEGER_CONSTANT); }
-"PSYS_PART_START_SCALE"	{ count(); yylval.ival = LLPS_PART_START_SCALE; return (INTEGER_CONSTANT); }
-"PSYS_PART_END_COLOR"	{ count(); yylval.ival = LLPS_PART_END_COLOR; return (INTEGER_CONSTANT); }
-"PSYS_PART_END_ALPHA"	{ count(); yylval.ival = LLPS_PART_END_ALPHA; return (INTEGER_CONSTANT); }
-"PSYS_PART_END_SCALE"	{ count(); yylval.ival = LLPS_PART_END_SCALE; return (INTEGER_CONSTANT); }
-"PSYS_PART_MAX_AGE"		{ count(); yylval.ival = LLPS_PART_MAX_AGE; return (INTEGER_CONSTANT); }
-
-"PSYS_PART_BLEND_FUNC_SOURCE"	{ count(); yylval.ival = LLPS_PART_BLEND_FUNC_SOURCE; return (INTEGER_CONSTANT); }
-"PSYS_PART_BLEND_FUNC_DEST"		{ count(); yylval.ival = LLPS_PART_BLEND_FUNC_DEST; return (INTEGER_CONSTANT); }
-"PSYS_PART_START_GLOW"	{ count(); yylval.ival = LLPS_PART_START_GLOW; return (INTEGER_CONSTANT); }
-"PSYS_PART_END_GLOW"	{ count(); yylval.ival = LLPS_PART_END_GLOW; return (INTEGER_CONSTANT); }
-
-"PSYS_PART_WIND_MASK"				{ count(); yylval.ival = LLPartData::LL_PART_WIND_MASK; return(INTEGER_CONSTANT); }
-"PSYS_PART_INTERP_COLOR_MASK"		{ count(); yylval.ival = LLPartData::LL_PART_INTERP_COLOR_MASK; return(INTEGER_CONSTANT); }
-"PSYS_PART_INTERP_SCALE_MASK"		{ count(); yylval.ival = LLPartData::LL_PART_INTERP_SCALE_MASK; return(INTEGER_CONSTANT); }
-"PSYS_PART_BOUNCE_MASK"				{ count(); yylval.ival = LLPartData::LL_PART_BOUNCE_MASK; return(INTEGER_CONSTANT); }
-"PSYS_PART_FOLLOW_SRC_MASK"			{ count(); yylval.ival = LLPartData::LL_PART_FOLLOW_SRC_MASK; return(INTEGER_CONSTANT); }
-"PSYS_PART_FOLLOW_VELOCITY_MASK"	{ count(); yylval.ival = LLPartData::LL_PART_FOLLOW_VELOCITY_MASK; return(INTEGER_CONSTANT); }
-"PSYS_PART_TARGET_POS_MASK"			{ count(); yylval.ival = LLPartData::LL_PART_TARGET_POS_MASK; return(INTEGER_CONSTANT); }
-"PSYS_PART_EMISSIVE_MASK"			{ count(); yylval.ival = LLPartData::LL_PART_EMISSIVE_MASK; return(INTEGER_CONSTANT); }
-"PSYS_PART_TARGET_LINEAR_MASK"		{ count(); yylval.ival = LLPartData::LL_PART_TARGET_LINEAR_MASK; return(INTEGER_CONSTANT); }
-"PSYS_PART_RIBBON_MASK"				{ count(); yylval.ival = LLPartData::LL_PART_RIBBON_MASK; return(INTEGER_CONSTANT); }
-
-"PSYS_PART_BF_ONE"						{ count(); yylval.ival = LLPartData::LL_PART_BF_ONE; return(INTEGER_CONSTANT); }
-"PSYS_PART_BF_ZERO"						{ count(); yylval.ival = LLPartData::LL_PART_BF_ZERO; return(INTEGER_CONSTANT); }
-"PSYS_PART_BF_DEST_COLOR"				{ count(); yylval.ival = LLPartData::LL_PART_BF_DEST_COLOR; return(INTEGER_CONSTANT); }
-"PSYS_PART_BF_SOURCE_COLOR"				{ count(); yylval.ival = LLPartData::LL_PART_BF_SOURCE_COLOR; return(INTEGER_CONSTANT); }
-"PSYS_PART_BF_ONE_MINUS_DEST_COLOR"		{ count(); yylval.ival = LLPartData::LL_PART_BF_ONE_MINUS_DEST_COLOR; return(INTEGER_CONSTANT); }
-"PSYS_PART_BF_ONE_MINUS_SOURCE_COLOR"	{ count(); yylval.ival = LLPartData::LL_PART_BF_ONE_MINUS_SOURCE_COLOR; return(INTEGER_CONSTANT); }
-"PSYS_PART_BF_SOURCE_ALPHA"				{ count(); yylval.ival = LLPartData::LL_PART_BF_SOURCE_ALPHA; return(INTEGER_CONSTANT); }
-"PSYS_PART_BF_ONE_MINUS_SOURCE_ALPHA"	{ count(); yylval.ival = LLPartData::LL_PART_BF_ONE_MINUS_SOURCE_ALPHA; return(INTEGER_CONSTANT); }
-
-
-"PSYS_SRC_MAX_AGE"					{ count(); yylval.ival = LLPS_SRC_MAX_AGE; return(INTEGER_CONSTANT); }
-"PSYS_SRC_PATTERN"					{ count(); yylval.ival = LLPS_SRC_PATTERN; return(INTEGER_CONSTANT); }
-"PSYS_SRC_INNERANGLE"				{ count(); yylval.ival = LLPS_SRC_INNERANGLE; return(INTEGER_CONSTANT); }
-"PSYS_SRC_OUTERANGLE"				{ count(); yylval.ival = LLPS_SRC_OUTERANGLE; return(INTEGER_CONSTANT); }
-"PSYS_SRC_ANGLE_BEGIN"				{ count(); yylval.ival = LLPS_SRC_ANGLE_BEGIN; return(INTEGER_CONSTANT); }
-"PSYS_SRC_ANGLE_END"				{ count(); yylval.ival = LLPS_SRC_ANGLE_END; return(INTEGER_CONSTANT); }
-"PSYS_SRC_BURST_RATE"				{ count(); yylval.ival = LLPS_SRC_BURST_RATE; return(INTEGER_CONSTANT); }
-"PSYS_SRC_BURST_PART_COUNT"			{ count(); yylval.ival = LLPS_SRC_BURST_PART_COUNT; return(INTEGER_CONSTANT); }
-"PSYS_SRC_BURST_RADIUS"				{ count(); yylval.ival = LLPS_SRC_BURST_RADIUS; return(INTEGER_CONSTANT); }
-"PSYS_SRC_BURST_SPEED_MIN"			{ count(); yylval.ival = LLPS_SRC_BURST_SPEED_MIN; return(INTEGER_CONSTANT); }
-"PSYS_SRC_BURST_SPEED_MAX"			{ count(); yylval.ival = LLPS_SRC_BURST_SPEED_MAX; return(INTEGER_CONSTANT); }
-"PSYS_SRC_ACCEL"					{ count(); yylval.ival = LLPS_SRC_ACCEL; return(INTEGER_CONSTANT); }
-"PSYS_SRC_TEXTURE"					{ count(); yylval.ival = LLPS_SRC_TEXTURE; return(INTEGER_CONSTANT); }
-"PSYS_SRC_TARGET_KEY"				{ count(); yylval.ival = LLPS_SRC_TARGET_UUID; return(INTEGER_CONSTANT); }
-"PSYS_SRC_OMEGA"					{ count(); yylval.ival = LLPS_SRC_OMEGA; return(INTEGER_CONSTANT); }
-
-"PSYS_SRC_OBJ_REL_MASK"				{ count(); yylval.ival = LLPartSysData::LL_PART_SRC_OBJ_REL_MASK; return(INTEGER_CONSTANT); }
-
-"PSYS_SRC_PATTERN_DROP"				{ count(); yylval.ival = LLPartSysData::LL_PART_SRC_PATTERN_DROP; return(INTEGER_CONSTANT); }
-"PSYS_SRC_PATTERN_EXPLODE"			{ count(); yylval.ival = LLPartSysData::LL_PART_SRC_PATTERN_EXPLODE; return(INTEGER_CONSTANT); }
-"PSYS_SRC_PATTERN_ANGLE"			{ count(); yylval.ival = LLPartSysData::LL_PART_SRC_PATTERN_ANGLE; return(INTEGER_CONSTANT); }
-"PSYS_SRC_PATTERN_ANGLE_CONE"		{ count(); yylval.ival = LLPartSysData::LL_PART_SRC_PATTERN_ANGLE_CONE; return(INTEGER_CONSTANT); }
-"PSYS_SRC_PATTERN_ANGLE_CONE_EMPTY"	{ count(); yylval.ival = LLPartSysData::LL_PART_SRC_PATTERN_ANGLE_CONE_EMPTY; return(INTEGER_CONSTANT); }
-
-
-"VEHICLE_TYPE_NONE"		{ count(); yylval.ival = VEHICLE_TYPE_NONE; return(INTEGER_CONSTANT); }
-"VEHICLE_TYPE_SLED"		{ count(); yylval.ival = VEHICLE_TYPE_SLED; return(INTEGER_CONSTANT); }
-"VEHICLE_TYPE_CAR"		{ count(); yylval.ival = VEHICLE_TYPE_CAR; return(INTEGER_CONSTANT); }
-"VEHICLE_TYPE_BOAT"		{ count(); yylval.ival = VEHICLE_TYPE_BOAT; return(INTEGER_CONSTANT); }
-"VEHICLE_TYPE_AIRPLANE"	{ count(); yylval.ival = VEHICLE_TYPE_AIRPLANE; return(INTEGER_CONSTANT); }
-"VEHICLE_TYPE_BALLOON"	{ count(); yylval.ival = VEHICLE_TYPE_BALLOON; return(INTEGER_CONSTANT); }
-
-"VEHICLE_REFERENCE_FRAME"			{ count(); yylval.ival = VEHICLE_REFERENCE_FRAME; return(INTEGER_CONSTANT); }
-"VEHICLE_LINEAR_FRICTION_TIMESCALE"	{ count(); yylval.ival = VEHICLE_LINEAR_FRICTION_TIMESCALE; return(INTEGER_CONSTANT); }
-"VEHICLE_ANGULAR_FRICTION_TIMESCALE" { count(); yylval.ival = VEHICLE_ANGULAR_FRICTION_TIMESCALE; return(INTEGER_CONSTANT); }
-"VEHICLE_LINEAR_MOTOR_DIRECTION"	{ count(); yylval.ival = VEHICLE_LINEAR_MOTOR_DIRECTION; return(INTEGER_CONSTANT); }
-"VEHICLE_ANGULAR_MOTOR_DIRECTION"	{ count(); yylval.ival = VEHICLE_ANGULAR_MOTOR_DIRECTION; return(INTEGER_CONSTANT); }
-"VEHICLE_LINEAR_MOTOR_OFFSET"	    { count(); yylval.ival = VEHICLE_LINEAR_MOTOR_OFFSET; return(INTEGER_CONSTANT); }
-
-
-
-"VEHICLE_HOVER_HEIGHT"		{ count(); yylval.ival = VEHICLE_HOVER_HEIGHT; return(INTEGER_CONSTANT); }
-"VEHICLE_HOVER_EFFICIENCY"	{ count(); yylval.ival = VEHICLE_HOVER_EFFICIENCY; return(INTEGER_CONSTANT); }
-"VEHICLE_HOVER_TIMESCALE"	{ count(); yylval.ival = VEHICLE_HOVER_TIMESCALE; return(INTEGER_CONSTANT); }
-"VEHICLE_BUOYANCY"			{ count(); yylval.ival = VEHICLE_BUOYANCY; return(INTEGER_CONSTANT); }
-
-"VEHICLE_LINEAR_DEFLECTION_EFFICIENCY"	{ count(); yylval.ival = VEHICLE_LINEAR_DEFLECTION_EFFICIENCY; return(INTEGER_CONSTANT); }
-"VEHICLE_LINEAR_DEFLECTION_TIMESCALE"	{ count(); yylval.ival = VEHICLE_LINEAR_DEFLECTION_TIMESCALE; return(INTEGER_CONSTANT); }
-"VEHICLE_LINEAR_MOTOR_TIMESCALE"		{ count(); yylval.ival = VEHICLE_LINEAR_MOTOR_TIMESCALE; return(INTEGER_CONSTANT); }
-"VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE"	{ count(); yylval.ival = VEHICLE_LINEAR_MOTOR_DECAY_TIMESCALE; return(INTEGER_CONSTANT); }
-
-"VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY" { count(); yylval.ival = VEHICLE_ANGULAR_DEFLECTION_EFFICIENCY; return(INTEGER_CONSTANT); }
-"VEHICLE_ANGULAR_DEFLECTION_TIMESCALE"	{ count(); yylval.ival = VEHICLE_ANGULAR_DEFLECTION_TIMESCALE; return(INTEGER_CONSTANT); }
-"VEHICLE_ANGULAR_MOTOR_TIMESCALE"		{ count(); yylval.ival = VEHICLE_ANGULAR_MOTOR_TIMESCALE; return(INTEGER_CONSTANT); }
-"VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE"	{ count(); yylval.ival = VEHICLE_ANGULAR_MOTOR_DECAY_TIMESCALE; return(INTEGER_CONSTANT); }
-
-"VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY"	{ count(); yylval.ival = VEHICLE_VERTICAL_ATTRACTION_EFFICIENCY; return(INTEGER_CONSTANT); }
-"VEHICLE_VERTICAL_ATTRACTION_TIMESCALE"		{ count(); yylval.ival = VEHICLE_VERTICAL_ATTRACTION_TIMESCALE; return(INTEGER_CONSTANT); }
-
-"VEHICLE_BANKING_EFFICIENCY"	{ count(); yylval.ival = VEHICLE_BANKING_EFFICIENCY; return(INTEGER_CONSTANT); }
-"VEHICLE_BANKING_MIX"			{ count(); yylval.ival = VEHICLE_BANKING_MIX; return(INTEGER_CONSTANT); }
-"VEHICLE_BANKING_TIMESCALE"		{ count(); yylval.ival = VEHICLE_BANKING_TIMESCALE; return(INTEGER_CONSTANT); }
-
-"VEHICLE_FLAG_NO_FLY_UP"			{ count(); yylval.ival = VEHICLE_FLAG_NO_DEFLECTION_UP; return(INTEGER_CONSTANT); }
-"VEHICLE_FLAG_NO_DEFLECTION_UP"			{ count(); yylval.ival = VEHICLE_FLAG_NO_DEFLECTION_UP; return(INTEGER_CONSTANT); }
-"VEHICLE_FLAG_LIMIT_ROLL_ONLY"		{ count(); yylval.ival = VEHICLE_FLAG_LIMIT_ROLL_ONLY; return(INTEGER_CONSTANT); }
-"VEHICLE_FLAG_HOVER_WATER_ONLY"		{ count(); yylval.ival = VEHICLE_FLAG_HOVER_WATER_ONLY; return(INTEGER_CONSTANT); }
-"VEHICLE_FLAG_HOVER_TERRAIN_ONLY"	{ count(); yylval.ival = VEHICLE_FLAG_HOVER_TERRAIN_ONLY; return(INTEGER_CONSTANT); }
-"VEHICLE_FLAG_HOVER_GLOBAL_HEIGHT"	{ count(); yylval.ival = VEHICLE_FLAG_HOVER_GLOBAL_HEIGHT; return(INTEGER_CONSTANT); }
-"VEHICLE_FLAG_HOVER_UP_ONLY"		{ count(); yylval.ival = VEHICLE_FLAG_HOVER_UP_ONLY; return(INTEGER_CONSTANT); }
-"VEHICLE_FLAG_LIMIT_MOTOR_UP"		{ count(); yylval.ival = VEHICLE_FLAG_LIMIT_MOTOR_UP; return(INTEGER_CONSTANT); }
-"VEHICLE_FLAG_MOUSELOOK_STEER"		{ count(); yylval.ival = VEHICLE_FLAG_MOUSELOOK_STEER; return(INTEGER_CONSTANT); }
-"VEHICLE_FLAG_MOUSELOOK_BANK"		{ count(); yylval.ival = VEHICLE_FLAG_MOUSELOOK_BANK; return(INTEGER_CONSTANT); }
-"VEHICLE_FLAG_CAMERA_DECOUPLED"		{ count(); yylval.ival = VEHICLE_FLAG_CAMERA_DECOUPLED; return(INTEGER_CONSTANT); }
-
-
-
-"PRIM_TYPE"				{ count(); yylval.ival = LSL_PRIM_TYPE; return(INTEGER_CONSTANT); }
-"PRIM_MATERIAL"			{ count(); yylval.ival = LSL_PRIM_MATERIAL; return(INTEGER_CONSTANT); }
-"PRIM_PHYSICS"			{ count(); yylval.ival = LSL_PRIM_PHYSICS; return(INTEGER_CONSTANT); }
-"PRIM_FLEXIBLE"			{ count(); yylval.ival = LSL_PRIM_FLEXIBLE; return(INTEGER_CONSTANT); }
-"PRIM_POINT_LIGHT"		{ count(); yylval.ival = LSL_PRIM_POINT_LIGHT; return(INTEGER_CONSTANT); }
-"PRIM_TEMP_ON_REZ"		{ count(); yylval.ival = LSL_PRIM_TEMP_ON_REZ; return(INTEGER_CONSTANT); }
-"PRIM_PHANTOM"			{ count(); yylval.ival = LSL_PRIM_PHANTOM; return(INTEGER_CONSTANT); }
-"PRIM_CAST_SHADOWS"		{ count(); yylval.ival = LSL_PRIM_CAST_SHADOWS; return(INTEGER_CONSTANT); }
-"PRIM_POSITION"			{ count(); yylval.ival = LSL_PRIM_POSITION; return(INTEGER_CONSTANT); }
-"PRIM_SIZE"				{ count(); yylval.ival = LSL_PRIM_SIZE; return(INTEGER_CONSTANT); }
-"PRIM_ROTATION"			{ count(); yylval.ival = LSL_PRIM_ROTATION; return(INTEGER_CONSTANT); }
-"PRIM_TEXTURE"			{ count(); yylval.ival = LSL_PRIM_TEXTURE; return(INTEGER_CONSTANT); }
-"PRIM_COLOR"			{ count(); yylval.ival = LSL_PRIM_COLOR; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_SHINY"		{ count(); yylval.ival = LSL_PRIM_BUMP_SHINY; return(INTEGER_CONSTANT); }
-"PRIM_FULLBRIGHT"		{ count(); yylval.ival = LSL_PRIM_FULLBRIGHT; return(INTEGER_CONSTANT); }
-"PRIM_TEXGEN"			{ count(); yylval.ival = LSL_PRIM_TEXGEN; return(INTEGER_CONSTANT); }
-"PRIM_GLOW"				{ count(); yylval.ival = LSL_PRIM_GLOW; return(INTEGER_CONSTANT); }
-"PRIM_TEXT"				{ count(); yylval.ival = LSL_PRIM_TEXT; return(INTEGER_CONSTANT); }
-"PRIM_NAME"				{ count(); yylval.ival = LSL_PRIM_NAME; return(INTEGER_CONSTANT); }
-"PRIM_DESC"				{ count(); yylval.ival = LSL_PRIM_DESC; return(INTEGER_CONSTANT); }
-"PRIM_OMEGA"			{ count(); yylval.ival = LSL_PRIM_OMEGA; return(INTEGER_CONSTANT); }
-"PRIM_LINK_TARGET"		{ count(); yylval.ival = LSL_PRIM_LINK_TARGET; return(INTEGER_CONSTANT); }
-"PRIM_SLICE"			{ count(); yylval.ival = LSL_PRIM_SLICE; return(INTEGER_CONSTANT); }
-
-"PRIM_PHYSICS_SHAPE_PRIM"	{ count(); yylval.ival = LSL_PRIM_PHYSICS_SHAPE_PRIM; return(INTEGER_CONSTANT); }
-"PRIM_PHYSICS_SHAPE_NONE"	{ count(); yylval.ival = LSL_PRIM_PHYSICS_SHAPE_NONE; return(INTEGER_CONSTANT); }
-"PRIM_PHYSICS_SHAPE_CONVEX"	{ count(); yylval.ival = LSL_PRIM_PHYSICS_SHAPE_CONVEX; return(INTEGER_CONSTANT); }
-
-"PRIM_TYPE_BOX"			{ count(); yylval.ival = LSL_PRIM_TYPE_BOX; return(INTEGER_CONSTANT); }
-"PRIM_TYPE_CYLINDER"	{ count(); yylval.ival = LSL_PRIM_TYPE_CYLINDER; return(INTEGER_CONSTANT); }
-"PRIM_TYPE_PRISM"		{ count(); yylval.ival = LSL_PRIM_TYPE_PRISM; return(INTEGER_CONSTANT); }
-"PRIM_TYPE_SPHERE"		{ count(); yylval.ival = LSL_PRIM_TYPE_SPHERE; return(INTEGER_CONSTANT); }
-"PRIM_TYPE_TORUS"		{ count(); yylval.ival = LSL_PRIM_TYPE_TORUS; return(INTEGER_CONSTANT); }
-"PRIM_TYPE_TUBE"		{ count(); yylval.ival = LSL_PRIM_TYPE_TUBE; return(INTEGER_CONSTANT); }
-"PRIM_TYPE_RING"		{ count(); yylval.ival = LSL_PRIM_TYPE_RING; return(INTEGER_CONSTANT); }
-"PRIM_TYPE_SCULPT"		{ count(); yylval.ival = LSL_PRIM_TYPE_SCULPT; return(INTEGER_CONSTANT); }
-
-"PRIM_HOLE_DEFAULT"		{ count(); yylval.ival = LSL_PRIM_HOLE_DEFAULT; return(INTEGER_CONSTANT); }
-"PRIM_HOLE_CIRCLE"		{ count(); yylval.ival = LSL_PRIM_HOLE_CIRCLE; return(INTEGER_CONSTANT); }
-"PRIM_HOLE_SQUARE"		{ count(); yylval.ival = LSL_PRIM_HOLE_SQUARE; return(INTEGER_CONSTANT); }
-"PRIM_HOLE_TRIANGLE"	{ count(); yylval.ival = LSL_PRIM_HOLE_TRIANGLE; return(INTEGER_CONSTANT); }
-
-"PRIM_MATERIAL_STONE"	{ count(); yylval.ival = LSL_PRIM_MATERIAL_STONE; return(INTEGER_CONSTANT); }
-"PRIM_MATERIAL_METAL"	{ count(); yylval.ival = LSL_PRIM_MATERIAL_METAL; return(INTEGER_CONSTANT); }
-"PRIM_MATERIAL_GLASS"	{ count(); yylval.ival = LSL_PRIM_MATERIAL_GLASS; return(INTEGER_CONSTANT); }
-"PRIM_MATERIAL_WOOD"	{ count(); yylval.ival = LSL_PRIM_MATERIAL_WOOD; return(INTEGER_CONSTANT); }
-"PRIM_MATERIAL_FLESH"	{ count(); yylval.ival = LSL_PRIM_MATERIAL_FLESH; return(INTEGER_CONSTANT); }
-"PRIM_MATERIAL_PLASTIC"	{ count(); yylval.ival = LSL_PRIM_MATERIAL_PLASTIC; return(INTEGER_CONSTANT); }
-"PRIM_MATERIAL_RUBBER"	{ count(); yylval.ival = LSL_PRIM_MATERIAL_RUBBER; return(INTEGER_CONSTANT); }
-"PRIM_MATERIAL_LIGHT"	{ count(); yylval.ival = LSL_PRIM_MATERIAL_LIGHT; return(INTEGER_CONSTANT); }
-
-"PRIM_SHINY_NONE"		{ count(); yylval.ival = LSL_PRIM_SHINY_NONE; return(INTEGER_CONSTANT); }
-"PRIM_SHINY_LOW"		{ count(); yylval.ival = LSL_PRIM_SHINY_LOW; return(INTEGER_CONSTANT); }
-"PRIM_SHINY_MEDIUM"		{ count(); yylval.ival = LSL_PRIM_SHINY_MEDIUM; return(INTEGER_CONSTANT); }
-"PRIM_SHINY_HIGH"		{ count(); yylval.ival = LSL_PRIM_SHINY_HIGH; return(INTEGER_CONSTANT); }
-
-"PRIM_BUMP_NONE"		{ count(); yylval.ival = LSL_PRIM_BUMP_NONE; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_BRIGHT"		{ count(); yylval.ival = LSL_PRIM_BUMP_BRIGHT; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_DARK"		{ count(); yylval.ival = LSL_PRIM_BUMP_DARK; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_WOOD"		{ count(); yylval.ival = LSL_PRIM_BUMP_WOOD; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_BARK"		{ count(); yylval.ival = LSL_PRIM_BUMP_BARK; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_BRICKS"		{ count(); yylval.ival = LSL_PRIM_BUMP_BRICKS; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_CHECKER"		{ count(); yylval.ival = LSL_PRIM_BUMP_CHECKER; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_CONCRETE"	{ count(); yylval.ival = LSL_PRIM_BUMP_CONCRETE; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_TILE"		{ count(); yylval.ival = LSL_PRIM_BUMP_TILE; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_STONE"		{ count(); yylval.ival = LSL_PRIM_BUMP_STONE; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_DISKS"		{ count(); yylval.ival = LSL_PRIM_BUMP_DISKS; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_GRAVEL"		{ count(); yylval.ival = LSL_PRIM_BUMP_GRAVEL; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_BLOBS"		{ count(); yylval.ival = LSL_PRIM_BUMP_BLOBS; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_SIDING"		{ count(); yylval.ival = LSL_PRIM_BUMP_SIDING; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_LARGETILE"	{ count(); yylval.ival = LSL_PRIM_BUMP_LARGETILE; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_STUCCO"		{ count(); yylval.ival = LSL_PRIM_BUMP_STUCCO; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_SUCTION"		{ count(); yylval.ival = LSL_PRIM_BUMP_SUCTION; return(INTEGER_CONSTANT); }
-"PRIM_BUMP_WEAVE"		{ count(); yylval.ival = LSL_PRIM_BUMP_WEAVE; return(INTEGER_CONSTANT); }
-
-"PRIM_TEXGEN_DEFAULT"	{ count(); yylval.ival = LSL_PRIM_TEXGEN_DEFAULT; return(INTEGER_CONSTANT); }
-"PRIM_TEXGEN_PLANAR"	{ count(); yylval.ival = LSL_PRIM_TEXGEN_PLANAR; return(INTEGER_CONSTANT); }
-
-"PRIM_SCULPT_TYPE_SPHERE"	{ count(); yylval.ival = LSL_PRIM_SCULPT_TYPE_SPHERE; return(INTEGER_CONSTANT); }
-"PRIM_SCULPT_TYPE_TORUS"	{ count(); yylval.ival = LSL_PRIM_SCULPT_TYPE_TORUS; return(INTEGER_CONSTANT); }
-"PRIM_SCULPT_TYPE_PLANE"	{ count(); yylval.ival = LSL_PRIM_SCULPT_TYPE_PLANE; return(INTEGER_CONSTANT); }
-"PRIM_SCULPT_TYPE_CYLINDER"	{ count(); yylval.ival = LSL_PRIM_SCULPT_TYPE_CYLINDER; return(INTEGER_CONSTANT); }
-"PRIM_SCULPT_TYPE_MASK" 	{ count(); yylval.ival = LSL_PRIM_SCULPT_TYPE_MASK; return(INTEGER_CONSTANT); }
-"PRIM_SCULPT_FLAG_MIRROR" 	{ count(); yylval.ival = LSL_PRIM_SCULPT_FLAG_MIRROR; return(INTEGER_CONSTANT); }
-"PRIM_SCULPT_FLAG_INVERT" 	{ count(); yylval.ival = LSL_PRIM_SCULPT_FLAG_INVERT; return(INTEGER_CONSTANT); }
-
-"MASK_BASE"				{ count(); yylval.ival = 0; return(INTEGER_CONSTANT); }
-"MASK_OWNER"			{ count(); yylval.ival = 1; return(INTEGER_CONSTANT); }
-"MASK_GROUP"			{ count(); yylval.ival = 2; return(INTEGER_CONSTANT); }
-"MASK_EVERYONE"			{ count(); yylval.ival = 3; return(INTEGER_CONSTANT); }
-"MASK_NEXT"				{ count(); yylval.ival = 4; return(INTEGER_CONSTANT); }
-
-"PERM_TRANSFER"			{ count(); yylval.ival = PERM_TRANSFER; return(INTEGER_CONSTANT); }
-"PERM_MODIFY"			{ count(); yylval.ival = PERM_MODIFY; return(INTEGER_CONSTANT); }
-"PERM_COPY"				{ count(); yylval.ival = PERM_COPY; return(INTEGER_CONSTANT); }
-"PERM_MOVE"				{ count(); yylval.ival = PERM_MOVE; return(INTEGER_CONSTANT); }
-"PERM_ALL"				{ count(); yylval.ival = PERM_ALL; return(INTEGER_CONSTANT); }
-
-"PARCEL_MEDIA_COMMAND_STOP"		{ count(); yylval.ival = PARCEL_MEDIA_COMMAND_STOP; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_PAUSE"	{ count(); yylval.ival = PARCEL_MEDIA_COMMAND_PAUSE; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_PLAY"		{ count(); yylval.ival = PARCEL_MEDIA_COMMAND_PLAY; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_LOOP"		{ count(); yylval.ival = PARCEL_MEDIA_COMMAND_LOOP; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_TEXTURE"	{ count(); yylval.ival = PARCEL_MEDIA_COMMAND_TEXTURE; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_URL"		{ count(); yylval.ival = PARCEL_MEDIA_COMMAND_URL; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_TIME"		{ count(); yylval.ival = PARCEL_MEDIA_COMMAND_TIME; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_AGENT"	{ count(); yylval.ival = PARCEL_MEDIA_COMMAND_AGENT; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_UNLOAD"	{ count(); yylval.ival = PARCEL_MEDIA_COMMAND_UNLOAD; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_AUTO_ALIGN"	{ count(); yylval.ival = PARCEL_MEDIA_COMMAND_AUTO_ALIGN; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_TYPE"     { count(); yylval.ival = PARCEL_MEDIA_COMMAND_TYPE; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_SIZE"     { count(); yylval.ival = PARCEL_MEDIA_COMMAND_SIZE; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_DESC"     { count(); yylval.ival = PARCEL_MEDIA_COMMAND_DESC; return(INTEGER_CONSTANT); }
-"PARCEL_MEDIA_COMMAND_LOOP_SET" { count(); yylval.ival = PARCEL_MEDIA_COMMAND_LOOP_SET; return(INTEGER_CONSTANT); }
-
-"LIST_STAT_MAX"			{ count(); yylval.ival = LIST_STAT_MAX; return(INTEGER_CONSTANT); }
-"LIST_STAT_MIN"			{ count(); yylval.ival = LIST_STAT_MIN; return(INTEGER_CONSTANT); }
-"LIST_STAT_MEAN"		{ count(); yylval.ival = LIST_STAT_MEAN; return(INTEGER_CONSTANT); }
-"LIST_STAT_MEDIAN"		{ count(); yylval.ival = LIST_STAT_MEDIAN; return(INTEGER_CONSTANT); }
-"LIST_STAT_STD_DEV"		{ count(); yylval.ival = LIST_STAT_STD_DEV; return(INTEGER_CONSTANT); }
-"LIST_STAT_SUM"		{ count(); yylval.ival = LIST_STAT_SUM; return(INTEGER_CONSTANT); }
-"LIST_STAT_SUM_SQUARES"		{ count(); yylval.ival = LIST_STAT_SUM_SQUARES; return(INTEGER_CONSTANT); }
-"LIST_STAT_NUM_COUNT"		{ count(); yylval.ival = LIST_STAT_NUM_COUNT; return(INTEGER_CONSTANT); }
-"LIST_STAT_GEOMETRIC_MEAN"		{ count(); yylval.ival = LIST_STAT_GEO_MEAN; return(INTEGER_CONSTANT); }
-"LIST_STAT_RANGE"		{ count(); yylval.ival = LIST_STAT_RANGE; return(INTEGER_CONSTANT); }
-
-"PAY_HIDE"		{ count(); yylval.ival = PAY_PRICE_HIDE; return(INTEGER_CONSTANT); }
-"PAY_DEFAULT"	{ count(); yylval.ival = PAY_PRICE_DEFAULT; return(INTEGER_CONSTANT); }
-
-"PARCEL_FLAG_ALLOW_FLY"		{ count(); yylval.ival = PF_ALLOW_FLY; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_ALLOW_GROUP_SCRIPTS"		{ count(); yylval.ival = PF_ALLOW_GROUP_SCRIPTS; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_ALLOW_SCRIPTS"		{ count(); yylval.ival = PF_ALLOW_OTHER_SCRIPTS; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_ALLOW_LANDMARK"		{ count(); yylval.ival = PF_ALLOW_LANDMARK; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_ALLOW_TERRAFORM"		{ count(); yylval.ival = PF_ALLOW_TERRAFORM; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_ALLOW_DAMAGE"		{ count(); yylval.ival = PF_ALLOW_DAMAGE; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_ALLOW_CREATE_OBJECTS"		{ count(); yylval.ival = PF_CREATE_OBJECTS; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_ALLOW_CREATE_GROUP_OBJECTS"		{ count(); yylval.ival = PF_CREATE_GROUP_OBJECTS; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_USE_ACCESS_GROUP"		{ count(); yylval.ival = PF_USE_ACCESS_GROUP; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_USE_ACCESS_LIST"		{ count(); yylval.ival = PF_USE_ACCESS_LIST; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_USE_BAN_LIST"		{ count(); yylval.ival = PF_USE_BAN_LIST; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_USE_LAND_PASS_LIST"		{ count(); yylval.ival = PF_USE_PASS_LIST; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_LOCAL_SOUND_ONLY"		{ count(); yylval.ival = PF_SOUND_LOCAL; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_RESTRICT_PUSHOBJECT"		{ count(); yylval.ival = PF_RESTRICT_PUSHOBJECT; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_ALLOW_GROUP_OBJECT_ENTRY"		{ count(); yylval.ival = PF_ALLOW_GROUP_OBJECT_ENTRY; return(INTEGER_CONSTANT); }
-"PARCEL_FLAG_ALLOW_ALL_OBJECT_ENTRY"		{ count(); yylval.ival = PF_ALLOW_ALL_OBJECT_ENTRY; return(INTEGER_CONSTANT); }
-
-"REGION_FLAG_ALLOW_DAMAGE"		{ count(); yylval.ival = REGION_FLAGS_ALLOW_DAMAGE; return(INTEGER_CONSTANT); }
-"REGION_FLAG_FIXED_SUN"		{ count(); yylval.ival = REGION_FLAGS_SUN_FIXED; return(INTEGER_CONSTANT); }
-"REGION_FLAG_BLOCK_TERRAFORM"		{ count(); yylval.ival = REGION_FLAGS_BLOCK_TERRAFORM; return(INTEGER_CONSTANT); }
-"REGION_FLAG_SANDBOX"		{ count(); yylval.ival = REGION_FLAGS_SANDBOX; return(INTEGER_CONSTANT); }
-"REGION_FLAG_DISABLE_COLLISIONS"		{ count(); yylval.ival = REGION_FLAGS_SKIP_COLLISIONS; return(INTEGER_CONSTANT); }
-"REGION_FLAG_DISABLE_PHYSICS"		{ count(); yylval.ival = REGION_FLAGS_SKIP_PHYSICS; return(INTEGER_CONSTANT); }
-"REGION_FLAG_BLOCK_FLY"			{ count(); yylval.ival = REGION_FLAGS_BLOCK_FLY; return(INTEGER_CONSTANT); }
-"REGION_FLAG_BLOCK_FLYOVER"		{ count(); yylval.ival = REGION_FLAGS_BLOCK_FLYOVER; return(INTEGER_CONSTANT); }
-"REGION_FLAG_ALLOW_DIRECT_TELEPORT"		{ count(); yylval.ival = REGION_FLAGS_ALLOW_DIRECT_TELEPORT; return(INTEGER_CONSTANT); }
-"REGION_FLAG_RESTRICT_PUSHOBJECT"		{ count(); yylval.ival = REGION_FLAGS_RESTRICT_PUSHOBJECT; return(INTEGER_CONSTANT); }
-
-"HTTP_METHOD" { count(); yylval.ival = HTTP_METHOD; return(INTEGER_CONSTANT); }
-"HTTP_MIMETYPE" { count(); yylval.ival = HTTP_MIMETYPE; return(INTEGER_CONSTANT); }
-"HTTP_BODY_MAXLENGTH" { count(); yylval.ival = HTTP_BODY_MAXLENGTH; return(INTEGER_CONSTANT); }
-"HTTP_BODY_TRUNCATED" { count(); yylval.ival = HTTP_BODY_TRUNCATED; return(INTEGER_CONSTANT); }
-"HTTP_VERIFY_CERT" { count(); yylval.ival = HTTP_VERIFY_CERT; return(INTEGER_CONSTANT); }
-
-"PARCEL_COUNT_TOTAL"		{ count(); yylval.ival = OC_TOTAL; return(INTEGER_CONSTANT); }
-"PARCEL_COUNT_OWNER"		{ count(); yylval.ival = OC_OWNER; return(INTEGER_CONSTANT); }
-"PARCEL_COUNT_GROUP"		{ count(); yylval.ival = OC_GROUP; return(INTEGER_CONSTANT); }
-"PARCEL_COUNT_OTHER"		{ count(); yylval.ival = OC_OTHER; return(INTEGER_CONSTANT); }
-"PARCEL_COUNT_SELECTED"	{ count(); yylval.ival = OC_SELECTED; return(INTEGER_CONSTANT); }
-"PARCEL_COUNT_TEMP"		{ count(); yylval.ival = OC_TEMP; return(INTEGER_CONSTANT); }
-
-"PARCEL_DETAILS_NAME"	{ count(); yylval.ival = PARCEL_DETAILS_NAME; return(INTEGER_CONSTANT); }
-"PARCEL_DETAILS_DESC"	{ count(); yylval.ival = PARCEL_DETAILS_DESC; return(INTEGER_CONSTANT); }
-"PARCEL_DETAILS_OWNER"	{ count(); yylval.ival = PARCEL_DETAILS_OWNER; return(INTEGER_CONSTANT); }
-"PARCEL_DETAILS_GROUP"	{ count(); yylval.ival = PARCEL_DETAILS_GROUP; return(INTEGER_CONSTANT); }
-"PARCEL_DETAILS_AREA"	{ count(); yylval.ival = PARCEL_DETAILS_AREA; return(INTEGER_CONSTANT); }
-"PARCEL_DETAILS_ID"		{ count(); yylval.ival = PARCEL_DETAILS_ID; return(INTEGER_CONSTANT); }
-"PARCEL_DETAILS_SEE_AVATARS"	{ count(); yylval.ival = PARCEL_DETAILS_SEE_AVATARS; return(INTEGER_CONSTANT); }
-
-"STRING_TRIM_HEAD"	{ count(); yylval.ival = STRING_TRIM_HEAD; return(INTEGER_CONSTANT); }
-"STRING_TRIM_TAIL"	{ count(); yylval.ival = STRING_TRIM_TAIL; return(INTEGER_CONSTANT); }
-"STRING_TRIM"	{ count(); yylval.ival = STRING_TRIM; return(INTEGER_CONSTANT); }
-
-"CLICK_ACTION_NONE"       { count(); yylval.ival = CLICK_ACTION_NONE; return(INTEGER_CONSTANT); }
-"CLICK_ACTION_TOUCH"      { count(); yylval.ival = CLICK_ACTION_TOUCH; return(INTEGER_CONSTANT); }
-"CLICK_ACTION_SIT"        { count(); yylval.ival = CLICK_ACTION_SIT; return(INTEGER_CONSTANT); }
-"CLICK_ACTION_BUY"        { count(); yylval.ival = CLICK_ACTION_BUY; return(INTEGER_CONSTANT); }
-"CLICK_ACTION_PAY"        { count(); yylval.ival = CLICK_ACTION_PAY; return(INTEGER_CONSTANT); }
-"CLICK_ACTION_OPEN"       { count(); yylval.ival = CLICK_ACTION_OPEN; return(INTEGER_CONSTANT); }
-"CLICK_ACTION_PLAY"       { count(); yylval.ival = CLICK_ACTION_PLAY; return(INTEGER_CONSTANT); }
-"CLICK_ACTION_OPEN_MEDIA" { count(); yylval.ival = CLICK_ACTION_OPEN_MEDIA; return(INTEGER_CONSTANT); }
-"CLICK_ACTION_ZOOM"       { count(); yylval.ival = CLICK_ACTION_ZOOM; return(INTEGER_CONSTANT); }
-
-"TEXTURE_BLANK"           { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "5748decc-f629-461c-9a36-a35a221fe21f"); return(STRING_CONSTANT); }
-"TEXTURE_DEFAULT"         { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "89556747-24cb-43ed-920b-47caed15465f"); return(STRING_CONSTANT); }
-"TEXTURE_MEDIA"           { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "8b5fec65-8d8d-9dc5-cda8-8fdf2716e361"); return(STRING_CONSTANT); }
-"TEXTURE_PLYWOOD"         { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "89556747-24cb-43ed-920b-47caed15465f"); return(STRING_CONSTANT); }
-"TEXTURE_TRANSPARENT"     { yylval.sval = new char[UUID_STR_LENGTH]; strcpy(yylval.sval, "8dcd4a48-2d37-4909-9f78-f7a9eb4ef903"); return(STRING_CONSTANT); }
-
-"TOUCH_INVALID_FACE"	  { count(); yylval.ival = -1; return(INTEGER_CONSTANT); }
-"TOUCH_INVALID_VECTOR"	  { count(); return(TOUCH_INVALID_VECTOR); }
-"TOUCH_INVALID_TEXCOORD"  { count(); return(TOUCH_INVALID_TEXCOORD); }
-
-"PRIM_MEDIA_ALT_IMAGE_ENABLE"        { count(); yylval.ival = LLMediaEntry::ALT_IMAGE_ENABLE_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_CONTROLS"                { count(); yylval.ival = LLMediaEntry::CONTROLS_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_CURRENT_URL"             { count(); yylval.ival = LLMediaEntry::CURRENT_URL_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_HOME_URL"                { count(); yylval.ival = LLMediaEntry::HOME_URL_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_AUTO_LOOP"               { count(); yylval.ival = LLMediaEntry::AUTO_LOOP_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_AUTO_PLAY"               { count(); yylval.ival = LLMediaEntry::AUTO_PLAY_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_AUTO_SCALE"              { count(); yylval.ival = LLMediaEntry::AUTO_SCALE_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_AUTO_ZOOM"               { count(); yylval.ival = LLMediaEntry::AUTO_ZOOM_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_FIRST_CLICK_INTERACT"    { count(); yylval.ival = LLMediaEntry::FIRST_CLICK_INTERACT_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_WIDTH_PIXELS"            { count(); yylval.ival = LLMediaEntry::WIDTH_PIXELS_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_HEIGHT_PIXELS"           { count(); yylval.ival = LLMediaEntry::HEIGHT_PIXELS_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_WHITELIST_ENABLE"        { count(); yylval.ival = LLMediaEntry::WHITELIST_ENABLE_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_WHITELIST"               { count(); yylval.ival = LLMediaEntry::WHITELIST_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_PERMS_INTERACT"          { count(); yylval.ival = LLMediaEntry::PERMS_INTERACT_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_PERMS_CONTROL"           { count(); yylval.ival = LLMediaEntry::PERMS_CONTROL_ID; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_PARAM_MAX"               { count(); yylval.ival = LLMediaEntry::PARAM_MAX_ID; return(INTEGER_CONSTANT); }
-
-"PRIM_MEDIA_CONTROLS_STANDARD"       { count(); yylval.ival = LLMediaEntry::STANDARD; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_CONTROLS_MINI"           { count(); yylval.ival = LLMediaEntry::MINI; return(INTEGER_CONSTANT); }
-
-"PRIM_MEDIA_PERM_NONE"               { count(); yylval.ival = LLMediaEntry::PERM_NONE; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_PERM_OWNER"              { count(); yylval.ival = LLMediaEntry::PERM_OWNER; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_PERM_GROUP"              { count(); yylval.ival = LLMediaEntry::PERM_GROUP; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_PERM_ANYONE"             { count(); yylval.ival = LLMediaEntry::PERM_ANYONE; return(INTEGER_CONSTANT); }
-
-"PRIM_MEDIA_MAX_URL_LENGTH"          { count(); yylval.ival = LLMediaEntry::MAX_URL_LENGTH; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_MAX_WHITELIST_SIZE"      { count(); yylval.ival = LLMediaEntry::MAX_WHITELIST_SIZE; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_MAX_WHITELIST_COUNT"     { count(); yylval.ival = LLMediaEntry::MAX_WHITELIST_COUNT; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_MAX_WIDTH_PIXELS"        { count(); yylval.ival = LLMediaEntry::MAX_WIDTH_PIXELS; return(INTEGER_CONSTANT); }
-"PRIM_MEDIA_MAX_HEIGHT_PIXELS"       { count(); yylval.ival = LLMediaEntry::MAX_HEIGHT_PIXELS; return(INTEGER_CONSTANT); }
-
-"STATUS_OK"                          { count(); yylval.ival = LSL_STATUS_OK; return(INTEGER_CONSTANT); }
-"STATUS_MALFORMED_PARAMS"            { count(); yylval.ival = LSL_STATUS_MALFORMED_PARAMS; return(INTEGER_CONSTANT); }
-"STATUS_TYPE_MISMATCH"               { count(); yylval.ival = LSL_STATUS_TYPE_MISMATCH; return(INTEGER_CONSTANT); }
-"STATUS_BOUNDS_ERROR"                { count(); yylval.ival = LSL_STATUS_BOUNDS_ERROR; return(INTEGER_CONSTANT); }
-"STATUS_NOT_FOUND"                   { count(); yylval.ival = LSL_STATUS_NOT_FOUND; return(INTEGER_CONSTANT); }
-"STATUS_NOT_SUPPORTED"               { count(); yylval.ival = LSL_STATUS_NOT_SUPPORTED; return(INTEGER_CONSTANT); }
-"STATUS_INTERNAL_ERROR"              { count(); yylval.ival = LSL_STATUS_INTERNAL_ERROR; return(INTEGER_CONSTANT); }
-"STATUS_WHITELIST_FAILED"            { count(); yylval.ival = LSL_STATUS_WHITELIST_FAILED; return(INTEGER_CONSTANT); }
-
-{L}({L}|{N})*		{ count(); yylval.sval = new char[strlen(yytext) + 1]; strcpy(yylval.sval, yytext); return(IDENTIFIER); }
-
-{N}+{E}					{ count(); yylval.fval = (F32)atof(yytext); return(FP_CONSTANT); }
-{N}*"."{N}+({E})?{FS}?	{ count(); yylval.fval = (F32)atof(yytext); return(FP_CONSTANT); }
-{N}+"."{N}*({E})?{FS}?	{ count(); yylval.fval = (F32)atof(yytext); return(FP_CONSTANT); }
-
-L?\"(\\.|[^\\"])*\"	{ parse_string(); count(); return(STRING_CONSTANT); }
-
-"++"				{ count(); return(INC_OP); }
-"--"				{ count(); return(DEC_OP); }
-"+="				{ count(); return(ADD_ASSIGN); }
-"-="				{ count(); return(SUB_ASSIGN); }
-"*="				{ count(); return(MUL_ASSIGN); }
-"/="				{ count(); return(DIV_ASSIGN); }
-"%="				{ count(); return(MOD_ASSIGN); }
-";"					{ count(); return(';'); }
-"{"					{ count(); return('{'); }
-"}"					{ count(); return('}'); }
-","					{ count(); return(','); }
-"="					{ count(); return('='); }
-"("					{ count(); return('('); }
-")"					{ count(); return(')'); }
-"-"					{ count(); return('-'); }
-"+"					{ count(); return('+'); }
-"*"					{ count(); return('*'); }
-"/"					{ count(); return('/'); }
-"%"					{ count(); return('%'); }
-"@"					{ count(); return('@'); }
-":"					{ count(); return(':'); }
-">"					{ count(); return('>'); }
-"<"					{ count(); return('<'); }
-"]"					{ count(); return(']'); }
-"["					{ count(); return('['); }
-"=="				{ count(); return(EQ);  }
-"!="				{ count(); return(NEQ);  }
-">="				{ count(); return(GEQ);  }
-"<="				{ count(); return(LEQ);  }
-"&"					{ count(); return('&');  }
-"|"					{ count(); return('|');  }
-"^"					{ count(); return('^');  }
-"~"					{ count(); return('~');  }
-"!"					{ count(); return('!');  }
-"&&"				{ count(); return(BOOLEAN_AND);	}
-"||"				{ count(); return(BOOLEAN_OR);	}
-"<<"				{ count(); return(SHIFT_LEFT);  }
-">>"				{ count(); return(SHIFT_RIGHT); }
-
-[ \t\v\n\f]			{ count(); }
-.					{ /* ignore bad characters */ }
-
-%%
-
-LLScriptAllocationManager	*gAllocationManager;
-LLScriptScript				*gScriptp;
-
-// Prototype for the yacc parser entry point
-int yyparse(void);
-
-int yyerror(const char *fmt, ...)
-{
-	gErrorToText.writeError(yyout, gLine, gColumn, LSERROR_SYNTAX_ERROR);
-	return 0;
-}
-
-//#define EMERGENCY_DEBUG_PRINTOUTS
-//#define EMIT_CIL_ASSEMBLER
-
-BOOL lscript_compile(const char* src_filename, const char* dst_filename,
-					 const char* err_filename, BOOL compile_to_mono, const char* class_name, BOOL is_god_like)
-{
-	BOOL			b_parse_ok = FALSE;
-	BOOL			b_dummy = FALSE;
-	U64				b_dummy_count = FALSE;
-	LSCRIPTType		type = LST_NULL;
-
-	gInternalColumn = 0;
-	gInternalLine = 0;
-	gScriptp = NULL;
-
-	gErrorToText.init();
-	init_supported_expressions();
-	init_temp_jumps();
-	gAllocationManager = new LLScriptAllocationManager();
-
-	yyin = LLFile::fopen(std::string(src_filename), "r");
-	if (yyin)
-	{
-		yyout = LLFile::fopen(std::string(err_filename), "w");
-
-		// Reset the lexer's internal buffering.
-
-	    yyrestart(yyin);
-
-		b_parse_ok = !yyparse();
-
-		if (b_parse_ok)
-		{
-#ifdef EMERGENCY_DEBUG_PRINTOUTS
-			char compiled[256];
-			sprintf(compiled, "%s.o", src_filename);
-			LLFILE* compfile;
-			compfile = LLFile::fopen(compiled, "w");
-#endif
-
-			if(dst_filename)
-			{
-				gScriptp->setBytecodeDest(dst_filename);
-			}
-
-			gScriptp->mGodLike = is_god_like;
-			
-			gScriptp->setClassName(class_name);
-
-			gScopeStringTable = new LLStringTable(16384);
-#ifdef EMERGENCY_DEBUG_PRINTOUTS
-			gScriptp->recurse(compfile, 0, 4, LSCP_PRETTY_PRINT, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
-#endif
-			gScriptp->recurse(yyout, 0, 0, LSCP_PRUNE,		 LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
-			gScriptp->recurse(yyout, 0, 0, LSCP_SCOPE_PASS1, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
-			gScriptp->recurse(yyout, 0, 0, LSCP_SCOPE_PASS2, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
-			gScriptp->recurse(yyout, 0, 0, LSCP_TYPE,		 LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
-			if (!gErrorToText.getErrors())
-			{
-				gScriptp->recurse(yyout, 0, 0, LSCP_RESOURCE, LSPRUNE_INVALID,		 b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
-#ifdef EMERGENCY_DEBUG_PRINTOUTS
-				gScriptp->recurse(yyout, 0, 0, LSCP_EMIT_ASSEMBLY, LSPRUNE_INVALID,  b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
-#endif
-				if(TRUE == compile_to_mono)
-				{
-					gScriptp->recurse(yyout, 0, 0, LSCP_EMIT_CIL_ASSEMBLY, LSPRUNE_INVALID,  b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
-				}
-				else
-				{
-					gScriptp->recurse(yyout, 0, 0, LSCP_EMIT_BYTE_CODE, LSPRUNE_INVALID, b_dummy, NULL, type, type, b_dummy_count, NULL, NULL, 0, NULL, 0, NULL);
-				}
-			}
-			delete gScopeStringTable;
-			gScopeStringTable = NULL;
-#ifdef EMERGENCY_DEBUG_PRINTOUTS
-			fclose(compfile);
-#endif
-		}
-		fclose(yyout);
-		fclose(yyin);
-	}
-
-	delete gAllocationManager;
-	delete gScopeStringTable;
-	
-	return b_parse_ok && !gErrorToText.getErrors();
-}
-
-
-BOOL lscript_compile(char *filename, BOOL compile_to_mono, BOOL is_god_like = FALSE)
-{
-	char src_filename[MAX_STRING];
-	sprintf(src_filename, "%s.lsl", filename);
-	char err_filename[MAX_STRING];
-	sprintf(err_filename, "%s.out", filename);
-	char class_name[MAX_STRING];
-	sprintf(class_name, "%s", filename);
-	return lscript_compile(src_filename, NULL, err_filename, compile_to_mono, class_name, is_god_like);
-}
-
-
-S32 yywrap()
-{
-#if defined(FLEX_SCANNER) && !defined(LL_WINDOWS)
-	// get gcc to stop complaining about lack of use of yyunput
-	(void) yyunput;
-#endif
-	return(1);
-}
-
-void line_comment()
-{
-	char c;
-
-	while ((c = yyinput()) != '\n' && c != 0 && c != EOF)
-		;
-}
-
-void block_comment()
-{
-	char c1 = 0;
-	char c2 = yyinput();
-	while (c2 != 0 && c2 != EOF && !(c1 == '*' && c2 == '/')) {
-		if (c2 == '\n')
-		{
-			gInternalLine++;
-			gInternalColumn = 0;
-		}
-		else if (c2 == '\t')
-			gInternalColumn += 4 - (gInternalColumn % 8);
-		else
-			gInternalColumn++;
-		c1 = c2;
-		c2 = yyinput();
-	}
-}
-
-void count()
-{
-	S32 i;
-
-	gColumn = gInternalColumn;
-	gLine = gInternalLine;
-
-	for (i = 0; yytext[i] != '\0'; i++)
-		if (yytext[i] == '\n')
-		{
-			gInternalLine++;
-			gInternalColumn = 0;
-		}
-		else if (yytext[i] == '\t')
-			gInternalColumn += 4 - (gInternalColumn % 8);
-		else
-			gInternalColumn++;
-}
-
-void parse_string()
-{
-	S32 length = (S32)strlen(yytext);
-	length = length - 2; 
-	char *temp = yytext + 1;
-
-	S32 i;
-	S32 escapes = 0;
-	S32 tabs = 0;
-	for (i = 0; i < length; i++)
-	{
-		if (temp[i] == '\\')
-		{
-			escapes++;
-			i++;
-			if (temp[i] == 't')
-				tabs++;
-		}
-	}
-
-	S32 newlength = length - escapes + tabs*3;
-	yylval.sval = new char[newlength + 1];
-
-	char *dest = yylval.sval;
-
-	for (i = 0; i < length; i++)
-	{
-		if (temp[i] == '\\')
-		{
-			i++;
-			// linefeed
-			if (temp[i] == 'n')
-			{
-				*dest++ = 10;
-			}
-			else if (temp[i] == 't')
-			{
-				*dest++ = ' ';
-				*dest++ = ' ';
-				*dest++ = ' ';
-				*dest++ = ' ';
-			}
-			else
-			{
-				*dest++ = temp[i];
-			}
-		}
-		else
-		{
-			*dest++ = temp[i];
-		}
-	}
-	yylval.sval[newlength] = 0;
-}
diff --git a/indra/lscript/lscript_compile/indra.y b/indra/lscript/lscript_compile/indra.y
deleted file mode 100755
index a0a034d21c..0000000000
--- a/indra/lscript/lscript_compile/indra.y
+++ /dev/null
@@ -1,1791 +0,0 @@
-%{
-	#include "linden_common.h"
-	#include "lscript_tree.h"
-
-	int yylex(void);
-	int yyparse( void );
-	int yyerror(const char *fmt, ...);
-
-    #if LL_LINUX
-    // broken yacc codegen...  --ryan.
-    #define getenv getenv_workaround
-    #endif
-
-    #ifdef LL_WINDOWS
-	#pragma warning (disable : 4702) // warning C4702: unreachable code
-	#pragma warning( disable : 4065 )	// warning: switch statement contains 'default' but no 'case' labels
-	#endif
-
-%}
-
-%union
-{
-	S32								ival;
-	F32								fval;
-	char							*sval;
-	class LLScriptType				*type;
-	class LLScriptConstant			*constant;
-	class LLScriptIdentifier		*identifier;
-	class LLScriptSimpleAssignable	*assignable;
-	class LLScriptGlobalVariable	*global;
-	class LLScriptEvent				*event;
-	class LLScriptEventHandler		*handler;
-	class LLScriptExpression		*expression;
-	class LLScriptStatement			*statement;
-	class LLScriptGlobalFunctions	*global_funcs;
-	class LLScriptFunctionDec		*global_decl;
-	class LLScriptState				*state;
-	class LLScritpGlobalStorage		*global_store;
-	class LLScriptScript			*script;
-};
-
-%token					INTEGER
-%token					FLOAT_TYPE
-%token					STRING
-%token					LLKEY
-%token					VECTOR
-%token					QUATERNION
-%token					LIST
-
-%token					STATE
-%token					EVENT
-%token					JUMP
-%token					RETURN
-
-%token					STATE_ENTRY
-%token					STATE_EXIT
-%token					TOUCH_START
-%token					TOUCH
-%token					TOUCH_END
-%token					COLLISION_START
-%token					COLLISION
-%token					COLLISION_END
-%token					LAND_COLLISION_START
-%token					LAND_COLLISION
-%token					LAND_COLLISION_END
-%token					TIMER
-%token					CHAT
-%token					SENSOR
-%token					NO_SENSOR
-%token					CONTROL
-%token					AT_TARGET
-%token					NOT_AT_TARGET
-%token					AT_ROT_TARGET
-%token					NOT_AT_ROT_TARGET
-%token					MONEY
-%token					EMAIL
-%token					RUN_TIME_PERMISSIONS
-%token					INVENTORY
-%token					ATTACH
-%token					DATASERVER
-%token					MOVING_START
-%token					MOVING_END
-%token					REZ
-%token					OBJECT_REZ
-%token					LINK_MESSAGE
-%token					REMOTE_DATA
-%token					HTTP_RESPONSE
-%token					HTTP_REQUEST
-
-%token <sval>			IDENTIFIER
-%token <sval>			STATE_DEFAULT
-
-%token <ival>			INTEGER_CONSTANT
-%token <ival>			INTEGER_TRUE
-%token <ival>			INTEGER_FALSE
-
-%token <fval>			FP_CONSTANT
-
-%token <sval>			STRING_CONSTANT
-
-%token					INC_OP
-%token					DEC_OP
-%token					ADD_ASSIGN
-%token					SUB_ASSIGN
-%token					MUL_ASSIGN
-%token					DIV_ASSIGN
-%token					MOD_ASSIGN
-
-%token					EQ
-%token					NEQ
-%token					GEQ
-%token					LEQ
-
-%token					BOOLEAN_AND
-%token					BOOLEAN_OR
-
-%token					SHIFT_LEFT
-%token					SHIFT_RIGHT
-
-%token					IF
-%token					ELSE
-%token					FOR
-%token					DO
-%token					WHILE
-
-%token					PRINT
-
-%token					PERIOD
-
-%token					ZERO_VECTOR
-%token					ZERO_ROTATION
-
-%token                  TOUCH_INVALID_VECTOR
-%token                  TOUCH_INVALID_TEXCOORD
-
-%nonassoc LOWER_THAN_ELSE
-%nonassoc ELSE
-
-
-%type <script>			lscript_program
-%type <global_store>	globals
-%type <global_store>	global
-%type <global>			global_variable
-%type <assignable>		simple_assignable
-%type <assignable>		simple_assignable_no_list
-%type <constant>		constant
-%type <ival>			integer_constant
-%type <fval>			fp_constant
-%type <assignable>		special_constant
-%type <assignable>		vector_constant
-%type <assignable>		quaternion_constant
-%type <assignable>		list_constant
-%type <assignable>		list_entries
-%type <assignable>		list_entry
-%type <type>			typename
-%type <global_funcs>	global_function
-%type <global_decl>		function_parameters
-%type <global_decl>		function_parameter
-%type <state>			states
-%type <state>			other_states
-%type <state>			default
-%type <state>			state
-%type <handler>			state_body
-%type <handler>			event
-%type <event>			state_entry
-%type <event>			state_exit
-%type <event>			touch_start
-%type <event>			touch
-%type <event>			touch_end
-%type <event>			collision_start
-%type <event>			collision
-%type <event>			collision_end
-%type <event>			land_collision_start
-%type <event>			land_collision
-%type <event>			land_collision_end
-%type <event>			at_target
-%type <event>			not_at_target
-%type <event>			at_rot_target
-%type <event>			not_at_rot_target
-%type <event>			money
-%type <event>			email
-%type <event>			run_time_permissions
-%type <event>			inventory
-%type <event>			attach
-%type <event>			dataserver
-%type <event>			moving_start
-%type <event>			moving_end
-%type <event>			rez
-%type <event>			object_rez
-%type <event>			remote_data
-%type <event>			http_response
-%type <event>			http_request
-%type <event>			link_message
-%type <event>			timer
-%type <event>			chat
-%type <event>			sensor
-%type <event>			no_sensor
-%type <event>			control
-%type <statement>		compound_statement
-%type <statement>		statement
-%type <statement>		statements
-%type <statement>		declaration
-%type <statement>		';'
-%type <statement>		'@'
-%type <expression>		nextforexpressionlist
-%type <expression>		forexpressionlist
-%type <expression>		nextfuncexpressionlist
-%type <expression>		funcexpressionlist
-%type <expression>		nextlistexpressionlist
-%type <expression>		listexpressionlist
-%type <expression>		unarypostfixexpression
-%type <expression>		vector_initializer
-%type <expression>		quaternion_initializer
-%type <expression>		list_initializer
-%type <expression>		lvalue
-%type <expression>		'-'
-%type <expression>		'!'
-%type <expression>		'~'
-%type <expression>		'='
-%type <expression>		'<'
-%type <expression>		'>'
-%type <expression>		'+'
-%type <expression>		'*'
-%type <expression>		'/'
-%type <expression>		'%'
-%type <expression>		'&'
-%type <expression>		'|'
-%type <expression>		'^'
-%type <expression>		ADD_ASSIGN
-%type <expression>		SUB_ASSIGN
-%type <expression>		MUL_ASSIGN
-%type <expression>		DIV_ASSIGN
-%type <expression>		MOD_ASSIGN
-%type <expression>		EQ
-%type <expression>		NEQ
-%type <expression>		LEQ
-%type <expression>		GEQ
-%type <expression>		BOOLEAN_AND
-%type <expression>		BOOLEAN_OR
-%type <expression>		SHIFT_LEFT
-%type <expression>		SHIFT_RIGHT
-%type <expression>		INC_OP
-%type <expression>		DEC_OP
-%type <expression>		'('
-%type <expression>		')'
-%type <expression>		PRINT
-%type <identifier>		name_type
-%type <expression>		expression
-%type <expression>		unaryexpression
-%type <expression>		typecast
-
-%right '=' MUL_ASSIGN DIV_ASSIGN MOD_ASSIGN ADD_ASSIGN SUB_ASSIGN
-%left 	BOOLEAN_AND BOOLEAN_OR
-%left	'|'
-%left	'^'
-%left	'&'
-%left	EQ NEQ
-%left	'<' LEQ '>' GEQ
-%left	SHIFT_LEFT SHIFT_RIGHT
-%left 	'+' '-'
-%left	'*' '/' '%'
-%right	'!' '~' INC_OP DEC_OP
-%nonassoc INITIALIZER
-
-%%
-
-lscript_program
-	: globals states		
-	{
-		$$ = new LLScriptScript($1, $2);
-		gAllocationManager->addAllocation($$);
-		gScriptp = $$;
-	}
-	| states		
-	{
-		$$ = new LLScriptScript(NULL, $1);
-		gAllocationManager->addAllocation($$);
-		gScriptp = $$;
-	}
-	;
-	
-globals
-	: global																
-	{
-		$$ = $1;
-	}
-	| global globals
-	{
-		$$ = $1;
-		$1->addGlobal($2);
-	}
-	;
-
-global
-	: global_variable
-	{
-		$$ = new LLScritpGlobalStorage($1);
-		gAllocationManager->addAllocation($$);
-	}
-	| global_function
-	{
-		$$ = new LLScritpGlobalStorage($1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-	
-name_type
-	: typename IDENTIFIER
-	{
-		$$ = new LLScriptIdentifier(gLine, gColumn, $2, $1);	
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-global_variable
-	: name_type ';'	
-	{
-		$$ = new LLScriptGlobalVariable(gLine, gColumn, $1->mType, $1, NULL);
-		gAllocationManager->addAllocation($$);
-	}
-	| name_type '=' simple_assignable ';'
-	{
-		$$ = new LLScriptGlobalVariable(gLine, gColumn, $1->mType, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-simple_assignable
-	: simple_assignable_no_list
-	{
-		$$ = $1;
-	}
-	| list_constant
-	{
-		$$ = $1;
-	}
-	;
-
-simple_assignable_no_list
-	: IDENTIFIER																	
-	{
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $1);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptSAIdentifier(gLine, gColumn, id);	
-		gAllocationManager->addAllocation($$);
-	}
-	| constant																		
-	{
-		$$ = new LLScriptSAConstant(gLine, gColumn, $1);
-		gAllocationManager->addAllocation($$);
-	}
-	| special_constant	
-	{
-		$$ = $1;
-	}
-	;
-
-constant
-	: integer_constant
-	{
-		$$ = new LLScriptConstantInteger(gLine, gColumn, $1);
-		gAllocationManager->addAllocation($$);
-	}
-	| fp_constant
-	{
-		$$ = new LLScriptConstantFloat(gLine, gColumn, $1);
-		gAllocationManager->addAllocation($$);
-	}
-	| STRING_CONSTANT
-	{
-		$$ = new LLScriptConstantString(gLine, gColumn, $1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-fp_constant
-	: FP_CONSTANT
-	{
-		$$ = $1;
-	}
-	| '-' FP_CONSTANT
-	{
-		$$ = -$2;
-	}
-	;
-
-integer_constant
-	: INTEGER_CONSTANT
-	{
-		$$ = $1;
-	}
-	| INTEGER_TRUE
-	{
-		$$ = $1;
-	}
-	| INTEGER_FALSE
-	{
-		$$ = $1;
-	}
-	| '-' INTEGER_CONSTANT
-	{
-		$$ = -$2;
-	}
-	;
-
-special_constant
-	: vector_constant
-	{
-		$$ = $1;
-	}
-	| quaternion_constant
-	{
-		$$ = $1;
-	}
-	;
-
-vector_constant
-	: '<' simple_assignable ',' simple_assignable ',' simple_assignable '>'
-	{
-		$$ = new LLScriptSAVector(gLine, gColumn, $2, $4, $6);
-		gAllocationManager->addAllocation($$);
-	}
-	| ZERO_VECTOR
-	{
-		LLScriptConstantFloat *cf0 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf0);
-		LLScriptSAConstant *sa0 = new LLScriptSAConstant(gLine, gColumn, cf0);
-		gAllocationManager->addAllocation(sa0);
-		LLScriptConstantFloat *cf1 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf1);
-		LLScriptSAConstant *sa1 = new LLScriptSAConstant(gLine, gColumn, cf1);
-		gAllocationManager->addAllocation(sa1);
-		LLScriptConstantFloat *cf2 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf2);
-		LLScriptSAConstant *sa2 = new LLScriptSAConstant(gLine, gColumn, cf2);
-		gAllocationManager->addAllocation(sa2);
-		$$ = new LLScriptSAVector(gLine, gColumn, sa0, sa1, sa2);
-		gAllocationManager->addAllocation($$);
-	}
-	| TOUCH_INVALID_VECTOR
-	{
-		LLScriptConstantFloat *cf0 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf0);
-		LLScriptSAConstant *sa0 = new LLScriptSAConstant(gLine, gColumn, cf0);
-		gAllocationManager->addAllocation(sa0);
-		LLScriptConstantFloat *cf1 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf1);
-		LLScriptSAConstant *sa1 = new LLScriptSAConstant(gLine, gColumn, cf1);
-		gAllocationManager->addAllocation(sa1);
-		LLScriptConstantFloat *cf2 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf2);
-		LLScriptSAConstant *sa2 = new LLScriptSAConstant(gLine, gColumn, cf2);
-		gAllocationManager->addAllocation(sa2);
-		$$ = new LLScriptSAVector(gLine, gColumn, sa0, sa1, sa2);
-		gAllocationManager->addAllocation($$);
-	}
-	| TOUCH_INVALID_TEXCOORD
-	{
-		LLScriptConstantFloat *cf0 = new LLScriptConstantFloat(gLine, gColumn, -1.f);
-		gAllocationManager->addAllocation(cf0);
-		LLScriptSAConstant *sa0 = new LLScriptSAConstant(gLine, gColumn, cf0);
-		gAllocationManager->addAllocation(sa0);
-		LLScriptConstantFloat *cf1 = new LLScriptConstantFloat(gLine, gColumn, -1.f);
-		gAllocationManager->addAllocation(cf1);
-		LLScriptSAConstant *sa1 = new LLScriptSAConstant(gLine, gColumn, cf1);
-		gAllocationManager->addAllocation(sa1);
-		LLScriptConstantFloat *cf2 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf2);
-		LLScriptSAConstant *sa2 = new LLScriptSAConstant(gLine, gColumn, cf2);
-		gAllocationManager->addAllocation(sa2);
-		$$ = new LLScriptSAVector(gLine, gColumn, sa0, sa1, sa2);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-	
-quaternion_constant
-	: '<' simple_assignable ',' simple_assignable ',' simple_assignable ',' simple_assignable '>'
-	{
-		$$ = new LLScriptSAQuaternion(gLine, gColumn, $2, $4, $6, $8);
-		gAllocationManager->addAllocation($$);
-	}
-	| ZERO_ROTATION
-	{
-		LLScriptConstantFloat *cf0 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf0);
-		LLScriptSAConstant *sa0 = new LLScriptSAConstant(gLine, gColumn, cf0);
-		gAllocationManager->addAllocation(sa0);
-		LLScriptConstantFloat *cf1 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf1);
-		LLScriptSAConstant *sa1 = new LLScriptSAConstant(gLine, gColumn, cf1);
-		gAllocationManager->addAllocation(sa1);
-		LLScriptConstantFloat *cf2 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf2);
-		LLScriptSAConstant *sa2 = new LLScriptSAConstant(gLine, gColumn, cf2);
-		gAllocationManager->addAllocation(sa2);
-		LLScriptConstantFloat *cf3 = new LLScriptConstantFloat(gLine, gColumn, 1.f);
-		gAllocationManager->addAllocation(cf3);
-		LLScriptSAConstant *sa3 = new LLScriptSAConstant(gLine, gColumn, cf3);
-		gAllocationManager->addAllocation(sa3);
-		$$ = new LLScriptSAQuaternion(gLine, gColumn, sa0, sa1, sa2, sa3);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-list_constant
-	: '[' list_entries ']'
-	{
-		$$ = new LLScriptSAList(gLine, gColumn, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| '[' ']'
-	{
-		$$ = new LLScriptSAList(gLine, gColumn, NULL);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-list_entries
-	: list_entry																	
-	{
-		$$ = $1;
-	}
-	| list_entry ',' list_entries
-	{
-		$$ = $1;
-		$1->addAssignable($3);
-	}
-	;
-
-list_entry
-	: simple_assignable_no_list
-	{
-		$$ = $1;
-	}
-	;	
-
-typename
-	: INTEGER																		
-	{  
-		$$ = new LLScriptType(gLine, gColumn, LST_INTEGER);
-		gAllocationManager->addAllocation($$);
-	}
-	| FLOAT_TYPE																			
-	{  
-		$$ = new LLScriptType(gLine, gColumn, LST_FLOATINGPOINT);
-		gAllocationManager->addAllocation($$);
-	}
-	| STRING																		
-	{  
-		$$ = new LLScriptType(gLine, gColumn, LST_STRING);
-		gAllocationManager->addAllocation($$);
-	}
-	| LLKEY																		
-	{  
-		$$ = new LLScriptType(gLine, gColumn, LST_KEY);
-		gAllocationManager->addAllocation($$);
-	}
-	| VECTOR																		
-	{  
-		$$ = new LLScriptType(gLine, gColumn, LST_VECTOR);
-		gAllocationManager->addAllocation($$);
-	}
-	| QUATERNION																	
-	{  
-		$$ = new LLScriptType(gLine, gColumn, LST_QUATERNION);
-		gAllocationManager->addAllocation($$);
-	}
-	| LIST																			
-	{
-		$$ = new LLScriptType(gLine, gColumn, LST_LIST);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-	
-global_function
-	: IDENTIFIER '(' ')' compound_statement
-	{  
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $1);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptGlobalFunctions(gLine, gColumn, NULL, id, NULL, $4);
-		gAllocationManager->addAllocation($$);
-	}
-	| name_type '(' ')' compound_statement
-	{
-		$$ = new LLScriptGlobalFunctions(gLine, gColumn, $1->mType, $1, NULL, $4);
-		gAllocationManager->addAllocation($$);
-	}
-	| IDENTIFIER '(' function_parameters ')' compound_statement
-	{
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $1);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptGlobalFunctions(gLine, gColumn, NULL, id, $3, $5);
-		gAllocationManager->addAllocation($$);
-	}
-	| name_type '(' function_parameters ')' compound_statement
-	{  
-		$$ = new LLScriptGlobalFunctions(gLine, gColumn, $1->mType, $1, $3, $5);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-	
-function_parameters
-	: function_parameter															
-	{  
-		$$ = $1;
-	}
-	| function_parameter ',' function_parameters									
-	{  
-		$$ = $1;
-		$1->addFunctionParameter($3);
-	}
-	;
-	
-function_parameter
-	: typename IDENTIFIER															
-	{  
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $2);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptFunctionDec(gLine, gColumn, $1, id);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-states
-	: default																		
-	{  
-		$$ = $1;
-	}
-	| default other_states
-	{  
-		$$ = $1;
-		$1->mNextp = $2;
-	}
-	;
-	
-other_states
-	: state																			
-	{  
-		$$ = $1;
-	}
-	| state other_states 															
-	{  
-		$$ = $1;
-		$1->addState($2);
-	}
-	;
-	
-default
-	: STATE_DEFAULT '{' state_body '}'													
-	{  
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $1);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptState(gLine, gColumn, LSSTYPE_DEFAULT, id, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-	
-state
-	: STATE IDENTIFIER '{' state_body '}'											
-	{  
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $2);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptState(gLine, gColumn, LSSTYPE_USER, id, $4);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-	
-state_body	
-	: event																			
-	{  
-		$$ = $1;
-	}
-	| event state_body															
-	{  
-		$$ = $1;
-		$1->addEvent($2);
-	}
-	;
-	
-event
-	: state_entry compound_statement												
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| state_exit compound_statement													
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| touch_start compound_statement												
-	{
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| touch compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| touch_end compound_statement													
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| collision_start compound_statement											
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| collision compound_statement													
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| collision_end compound_statement												
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| land_collision_start compound_statement											
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| land_collision compound_statement													
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| land_collision_end compound_statement												
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| timer compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| chat compound_statement														
-	{
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| sensor compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| no_sensor compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| at_target compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| not_at_target compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| at_rot_target compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| not_at_rot_target compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| money compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| email compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| run_time_permissions compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| inventory compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| attach compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| dataserver compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| control compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| moving_start compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| moving_end compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| rez compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| object_rez compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| link_message compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| remote_data compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| http_response compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| http_request compound_statement														
-	{  
-		$$ = new LLScriptEventHandler(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-	
-state_entry
-	: STATE_ENTRY '(' ')'															
-	{  
-		$$ = new LLScriptStateEntryEvent(gLine, gColumn);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-state_exit
-	: STATE_EXIT '(' ')'															
-	{  
-		$$ = new LLScriptStateExitEvent(gLine, gColumn);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-touch_start
-	: TOUCH_START '(' INTEGER IDENTIFIER ')'					
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptTouchStartEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-touch
-	: TOUCH '(' INTEGER IDENTIFIER ')'					
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptTouchEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-touch_end
-	: TOUCH_END '(' INTEGER IDENTIFIER ')'					
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptTouchEndEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-collision_start
-	: COLLISION_START '(' INTEGER IDENTIFIER ')'					
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptCollisionStartEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-collision
-	: COLLISION '(' INTEGER IDENTIFIER ')'					
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptCollisionEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-collision_end
-	: COLLISION_END '(' INTEGER IDENTIFIER ')'					
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptCollisionEndEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-land_collision_start
-	: LAND_COLLISION_START '(' VECTOR IDENTIFIER ')'	
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptLandCollisionStartEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-land_collision
-	: LAND_COLLISION '(' VECTOR IDENTIFIER ')'	
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptLandCollisionEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-land_collision_end
-	: LAND_COLLISION_END '(' VECTOR IDENTIFIER ')'	
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptLandCollisionEndEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-at_target
-	: AT_TARGET '(' INTEGER IDENTIFIER ',' VECTOR IDENTIFIER ',' VECTOR IDENTIFIER ')'	
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		LLScriptIdentifier	*id2 = new LLScriptIdentifier(gLine, gColumn, $7);	
-		gAllocationManager->addAllocation(id2);
-		LLScriptIdentifier	*id3 = new LLScriptIdentifier(gLine, gColumn, $10);	
-		gAllocationManager->addAllocation(id3);
-		$$ = new LLScriptAtTarget(gLine, gColumn, id1, id2, id3);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-not_at_target
-	: NOT_AT_TARGET '(' ')'															
-	{  
-		$$ = new LLScriptNotAtTarget(gLine, gColumn);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-at_rot_target
-	: AT_ROT_TARGET '(' INTEGER IDENTIFIER ',' QUATERNION IDENTIFIER ',' QUATERNION IDENTIFIER ')'	
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		LLScriptIdentifier	*id2 = new LLScriptIdentifier(gLine, gColumn, $7);	
-		gAllocationManager->addAllocation(id2);
-		LLScriptIdentifier	*id3 = new LLScriptIdentifier(gLine, gColumn, $10);	
-		gAllocationManager->addAllocation(id3);
-		$$ = new LLScriptAtRotTarget(gLine, gColumn, id1, id2, id3);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-not_at_rot_target
-	: NOT_AT_ROT_TARGET '(' ')'															
-	{  
-		$$ = new LLScriptNotAtRotTarget(gLine, gColumn);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-money
-	: MONEY '(' LLKEY IDENTIFIER ',' INTEGER IDENTIFIER ')'															
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		LLScriptIdentifier	*id2 = new LLScriptIdentifier(gLine, gColumn, $7);	
-		gAllocationManager->addAllocation(id2);
-		$$ = new LLScriptMoneyEvent(gLine, gColumn, id1, id2);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-email
-	: EMAIL '(' STRING IDENTIFIER ',' STRING IDENTIFIER ',' STRING IDENTIFIER ',' STRING IDENTIFIER ',' INTEGER IDENTIFIER ')'															
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		LLScriptIdentifier	*id2 = new LLScriptIdentifier(gLine, gColumn, $7);	
-		gAllocationManager->addAllocation(id2);
-		LLScriptIdentifier	*id3 = new LLScriptIdentifier(gLine, gColumn, $10);	
-		gAllocationManager->addAllocation(id3);
-		LLScriptIdentifier	*id4 = new LLScriptIdentifier(gLine, gColumn, $13);	
-		gAllocationManager->addAllocation(id4);
-		LLScriptIdentifier	*id5 = new LLScriptIdentifier(gLine, gColumn, $16);	
-		gAllocationManager->addAllocation(id5);
-		$$ = new LLScriptEmailEvent(gLine, gColumn, id1, id2, id3, id4, id5);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-run_time_permissions
-	: RUN_TIME_PERMISSIONS '(' INTEGER IDENTIFIER ')'															
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptRTPEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-inventory
-	: INVENTORY '(' INTEGER IDENTIFIER ')'																	
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptInventoryEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-attach
-	: ATTACH '(' LLKEY IDENTIFIER ')'																	
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptAttachEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-dataserver
-	: DATASERVER '(' LLKEY IDENTIFIER ',' STRING IDENTIFIER')'																	
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		LLScriptIdentifier	*id2 = new LLScriptIdentifier(gLine, gColumn, $7);	
-		gAllocationManager->addAllocation(id2);
-		$$ = new LLScriptDataserverEvent(gLine, gColumn, id1, id2);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-moving_start
-	: MOVING_START '(' ')'																	
-	{  
-		$$ = new LLScriptMovingStartEvent(gLine, gColumn);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-moving_end
-	: MOVING_END '(' ')'																	
-	{  
-		$$ = new LLScriptMovingEndEvent(gLine, gColumn);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-timer
-	: TIMER '(' ')'																	
-	{  
-		$$ = new LLScriptTimerEvent(gLine, gColumn);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-chat
-	: CHAT '(' INTEGER IDENTIFIER ',' STRING IDENTIFIER ',' LLKEY IDENTIFIER ',' STRING IDENTIFIER ')'							
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		LLScriptIdentifier	*id2 = new LLScriptIdentifier(gLine, gColumn, $7);	
-		gAllocationManager->addAllocation(id2);
-		LLScriptIdentifier	*id3 = new LLScriptIdentifier(gLine, gColumn, $10);	
-		gAllocationManager->addAllocation(id3);
-		LLScriptIdentifier	*id4 = new LLScriptIdentifier(gLine, gColumn, $13);	
-		gAllocationManager->addAllocation(id4);
-		$$ = new LLScriptChatEvent(gLine, gColumn, id1, id2, id3, id4);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-sensor
-	: SENSOR '(' INTEGER IDENTIFIER ')'	
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptSensorEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-no_sensor
-	: NO_SENSOR '(' ')'															
-	{  
-		$$ = new LLScriptNoSensorEvent(gLine, gColumn);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-control
-	: CONTROL '(' LLKEY IDENTIFIER ',' INTEGER IDENTIFIER ',' INTEGER IDENTIFIER ')'	
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		LLScriptIdentifier	*id2 = new LLScriptIdentifier(gLine, gColumn, $7);	
-		gAllocationManager->addAllocation(id2);
-		LLScriptIdentifier	*id3 = new LLScriptIdentifier(gLine, gColumn, $10);	
-		gAllocationManager->addAllocation(id3);
-		$$ = new LLScriptControlEvent(gLine, gColumn, id1, id2, id3);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-rez
-	: REZ '(' INTEGER IDENTIFIER ')'															
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptRezEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-object_rez
-	: OBJECT_REZ '(' LLKEY IDENTIFIER ')'															
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		$$ = new LLScriptObjectRezEvent(gLine, gColumn, id1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-link_message
-	: LINK_MESSAGE '(' INTEGER IDENTIFIER ','  INTEGER IDENTIFIER ',' STRING IDENTIFIER ',' LLKEY IDENTIFIER ')'															
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		LLScriptIdentifier	*id2 = new LLScriptIdentifier(gLine, gColumn, $7);	
-		gAllocationManager->addAllocation(id2);
-		LLScriptIdentifier	*id3 = new LLScriptIdentifier(gLine, gColumn, $10);	
-		gAllocationManager->addAllocation(id3);
-		LLScriptIdentifier	*id4 = new LLScriptIdentifier(gLine, gColumn, $13);	
-		gAllocationManager->addAllocation(id4);
-		$$ = new LLScriptLinkMessageEvent(gLine, gColumn, id1, id2, id3, id4);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-remote_data
-	: REMOTE_DATA '(' INTEGER IDENTIFIER ','  LLKEY IDENTIFIER ','  LLKEY IDENTIFIER ','  STRING IDENTIFIER ',' INTEGER IDENTIFIER ',' STRING IDENTIFIER ')'															
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		LLScriptIdentifier	*id2 = new LLScriptIdentifier(gLine, gColumn, $7);	
-		gAllocationManager->addAllocation(id2);
-		LLScriptIdentifier	*id3 = new LLScriptIdentifier(gLine, gColumn, $10);	
-		gAllocationManager->addAllocation(id3);
-		LLScriptIdentifier	*id4 = new LLScriptIdentifier(gLine, gColumn, $13);	
-		gAllocationManager->addAllocation(id4);
-		LLScriptIdentifier	*id5 = new LLScriptIdentifier(gLine, gColumn, $16);	
-		gAllocationManager->addAllocation(id4);
-		LLScriptIdentifier	*id6 = new LLScriptIdentifier(gLine, gColumn, $19);	
-		gAllocationManager->addAllocation(id4);
-		$$ = new LLScriptRemoteEvent(gLine, gColumn, id1, id2, id3, id4, id5, id6);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-http_response
-	: HTTP_RESPONSE '(' LLKEY IDENTIFIER ','  INTEGER IDENTIFIER ','  LIST IDENTIFIER ',' STRING IDENTIFIER ')'															
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		LLScriptIdentifier	*id2 = new LLScriptIdentifier(gLine, gColumn, $7);	
-		gAllocationManager->addAllocation(id2);
-		LLScriptIdentifier	*id3 = new LLScriptIdentifier(gLine, gColumn, $10);	
-		gAllocationManager->addAllocation(id3);
-		LLScriptIdentifier	*id4 = new LLScriptIdentifier(gLine, gColumn, $13);	
-		gAllocationManager->addAllocation(id4);
-		$$ = new LLScriptHTTPResponseEvent(gLine, gColumn, id1, id2, id3, id4);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-http_request
-	: HTTP_REQUEST '(' LLKEY IDENTIFIER ','  STRING IDENTIFIER ',' STRING IDENTIFIER ')'															
-	{  
-		LLScriptIdentifier	*id1 = new LLScriptIdentifier(gLine, gColumn, $4);	
-		gAllocationManager->addAllocation(id1);
-		LLScriptIdentifier	*id2 = new LLScriptIdentifier(gLine, gColumn, $7);	
-		gAllocationManager->addAllocation(id2);
-		LLScriptIdentifier	*id3 = new LLScriptIdentifier(gLine, gColumn, $10);	
-		gAllocationManager->addAllocation(id3);
-		$$ = new LLScriptHTTPRequestEvent(gLine, gColumn, id1, id2, id3);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-	
-compound_statement
-	: '{' '}'																		
-	{  
-		$$ = new LLScriptCompoundStatement(gLine, gColumn, NULL);
-		gAllocationManager->addAllocation($$);
-	}
-	| '{' statements '}'															
-	{  
-		$$ = new LLScriptCompoundStatement(gLine, gColumn, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-	
-statements
-	: statement																		
-	{  
-		$$ = $1;
-	}
-	| statements statement															
-	{  
-		$$ = new LLScriptStatementSequence(gLine, gColumn, $1, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-	
-statement
-	: ';'																			
-	{  
-		$$ = new LLScriptNOOP(gLine, gColumn);
-		gAllocationManager->addAllocation($$);
-	}
-	| STATE IDENTIFIER ';'						
-	{  
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $2);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptStateChange(gLine, gColumn, id);
-		gAllocationManager->addAllocation($$);
-	}
-	| STATE STATE_DEFAULT ';'						
-	{  
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $2);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptStateChange(gLine, gColumn, id);
-		gAllocationManager->addAllocation($$);
-	}
-	| JUMP IDENTIFIER ';'						
-	{  
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $2);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptJump(gLine, gColumn, id);
-		gAllocationManager->addAllocation($$);
-	}
-	| '@' IDENTIFIER ';'						
-	{  
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $2);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptLabel(gLine, gColumn, id);
-		gAllocationManager->addAllocation($$);
-	}
-	| RETURN expression ';'						
-	{  
-		$$ = new LLScriptReturn(gLine, gColumn, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| RETURN ';'								
-	{  
-		$$ = new LLScriptReturn(gLine, gColumn, NULL);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression ';'							
-	{  
-		$$ = new LLScriptExpressionStatement(gLine, gColumn, $1);
-		gAllocationManager->addAllocation($$);
-	}
-	| declaration ';'
-	{  
-		$$ = $1;
-	}
-	| compound_statement						
-	{ 
-		$$ = $1;
-	}
-	| IF '(' expression ')' statement	%prec LOWER_THAN_ELSE			
-	{  
-		$$ = new LLScriptIf(gLine, gColumn, $3, $5);
-		$5->mAllowDeclarations = FALSE;
-		gAllocationManager->addAllocation($$);
-	}
-	| IF '(' expression ')' statement ELSE statement					
-	{  
-		$$ = new LLScriptIfElse(gLine, gColumn, $3, $5, $7);
-		$5->mAllowDeclarations = FALSE;
-		$7->mAllowDeclarations = FALSE;
-		gAllocationManager->addAllocation($$);
-	}
-	| FOR '(' forexpressionlist ';' expression ';' forexpressionlist ')' statement	
-	{  
-		$$ = new LLScriptFor(gLine, gColumn, $3, $5, $7, $9);
-		$9->mAllowDeclarations = FALSE;
-		gAllocationManager->addAllocation($$);
-	}
-	| DO statement WHILE '(' expression ')' ';' 
-	{  
-		$$ = new LLScriptDoWhile(gLine, gColumn, $2, $5);
-		$2->mAllowDeclarations = FALSE;
-		gAllocationManager->addAllocation($$);
-	}
-	| WHILE '(' expression ')' statement		
-	{  
-		$$ = new LLScriptWhile(gLine, gColumn, $3, $5);
-		$5->mAllowDeclarations = FALSE;
-		gAllocationManager->addAllocation($$);
-	}
-	;
-	
-declaration
-	: typename IDENTIFIER						
-	{  
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $2);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptDeclaration(gLine, gColumn, $1, id, NULL);
-		gAllocationManager->addAllocation($$);
-	}
-	| typename IDENTIFIER '=' expression		
-	{  
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $2);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptDeclaration(gLine, gColumn, $1, id, $4);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-forexpressionlist
-	: /* empty */								
-	{  
-		$$ = NULL;
-	}
-	| nextforexpressionlist						
-	{
-		$$ = $1;
-	}
-	;
-
-nextforexpressionlist
-	: expression								
-	{  
-		$$ = new LLScriptForExpressionList(gLine, gColumn, $1, NULL);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression ',' nextforexpressionlist		
-	{
-		$$ = new LLScriptForExpressionList(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-funcexpressionlist
-	: /* empty */								
-	{  
-		$$ = NULL;
-	}
-	| nextfuncexpressionlist						
-	{
-		$$ = $1;
-	}
-	;
-
-nextfuncexpressionlist
-	: expression								
-	{  
-		$$ = new LLScriptFuncExpressionList(gLine, gColumn, $1, NULL);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression ',' nextfuncexpressionlist		
-	{
-		$$ = new LLScriptFuncExpressionList(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-listexpressionlist
-	: /* empty */								
-	{  
-		$$ = NULL;
-	}
-	| nextlistexpressionlist						
-	{
-		$$ = $1;
-	}
-	;
-
-nextlistexpressionlist
-	: expression								
-	{  
-		$$ = new LLScriptListExpressionList(gLine, gColumn, $1, NULL);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression ',' nextlistexpressionlist		
-	{
-		$$ = new LLScriptListExpressionList(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-expression
-	: unaryexpression							
-	{  
-		$$ = $1;
-	}
-	| lvalue '=' expression						
-	{  
-		$$ = new LLScriptAssignment(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| lvalue ADD_ASSIGN expression				
-	{  
-		$$ = new LLScriptAddAssignment(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| lvalue SUB_ASSIGN expression				
-	{  
-		$$ = new LLScriptSubAssignment(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| lvalue MUL_ASSIGN expression				
-	{  
-		$$ = new LLScriptMulAssignment(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| lvalue DIV_ASSIGN expression				
-	{  
-		$$ = new LLScriptDivAssignment(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| lvalue MOD_ASSIGN expression				
-	{  
-		$$ = new LLScriptModAssignment(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression EQ expression					
-	{  
-		$$ = new LLScriptEquality(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression NEQ expression					
-	{  
-		$$ = new LLScriptNotEquals(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression LEQ expression					
-	{  
-		$$ = new LLScriptLessEquals(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression GEQ expression					
-	{  
-		$$ = new LLScriptGreaterEquals(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression '<' expression					
-	{  
-		$$ = new LLScriptLessThan(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression '>' expression					
-	{  
-		$$ = new LLScriptGreaterThan(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression '+' expression					
-	{  
-		$$ = new LLScriptPlus(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression '-' expression					
-	{  
-		$$ = new LLScriptMinus(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression '*' expression					
-	{  
-		$$ = new LLScriptTimes(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression '/' expression					
-	{  
-		$$ = new LLScriptDivide(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression '%' expression					
-	{  
-		$$ = new LLScriptMod(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression '&' expression					
-	{  
-		$$ = new LLScriptBitAnd(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression '|' expression					
-	{  
-		$$ = new LLScriptBitOr(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression '^' expression					
-	{  
-		$$ = new LLScriptBitXor(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression BOOLEAN_AND expression			
-	{  
-		$$ = new LLScriptBooleanAnd(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression BOOLEAN_OR expression			
-	{  
-		$$ = new LLScriptBooleanOr(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression SHIFT_LEFT expression
-	{
-		$$ = new LLScriptShiftLeft(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| expression SHIFT_RIGHT expression
-	{
-		$$ = new LLScriptShiftRight(gLine, gColumn, $1, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-unaryexpression
-	: '-' expression						
-	{  
-		$$ = new LLScriptUnaryMinus(gLine, gColumn, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| '!' expression							
-	{  
-		$$ = new LLScriptBooleanNot(gLine, gColumn, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| '~' expression							
-	{  
-		$$ = new LLScriptBitNot(gLine, gColumn, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| INC_OP lvalue							
-	{  
-		$$ = new LLScriptPreIncrement(gLine, gColumn, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| DEC_OP lvalue							
-	{  
-		$$ = new LLScriptPreDecrement(gLine, gColumn, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	| typecast				
-	{
-		$$ = $1;
-	}
-	| unarypostfixexpression
-	{  
-		$$ = $1;
-	}
-	| '(' expression ')'						
-	{  
-		$$ = new LLScriptParenthesis(gLine, gColumn, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-typecast
-	: '(' typename ')' lvalue				
-	{
-		$$ = new LLScriptTypeCast(gLine, gColumn, $2, $4);
-		gAllocationManager->addAllocation($$);
-	}
-	| '(' typename ')' constant				
-	{
-		LLScriptConstantExpression *temp =  new LLScriptConstantExpression(gLine, gColumn, $4);
-		gAllocationManager->addAllocation(temp);
-		$$ = new LLScriptTypeCast(gLine, gColumn, $2, temp);
-		gAllocationManager->addAllocation($$);
-	}
-	| '(' typename ')' unarypostfixexpression				
-	{
-		$$ = new LLScriptTypeCast(gLine, gColumn, $2, $4);
-		gAllocationManager->addAllocation($$);
-	}
-	| '(' typename ')' '(' expression ')'				
-	{
-		$$ = new LLScriptTypeCast(gLine, gColumn, $2, $5);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-unarypostfixexpression
-	: vector_initializer 					
-	{  
-		$$ = $1;
-	}
-	| quaternion_initializer					
-	{
-		$$ = $1;
-	}
-	| list_initializer							
-	{  
-		$$ = $1;
-	}
-	| lvalue									
-	{  
-		$$ = $1;
-	}
-	| lvalue INC_OP							
-	{  
-		$$ = new LLScriptPostIncrement(gLine, gColumn, $1);
-		gAllocationManager->addAllocation($$);
-	}
-	| lvalue DEC_OP							
-	{  
-		$$ = new LLScriptPostDecrement(gLine, gColumn, $1);
-		gAllocationManager->addAllocation($$);
-	}
-	| IDENTIFIER '(' funcexpressionlist ')'			
-	{  
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $1);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptFunctionCall(gLine, gColumn, id, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| PRINT '(' expression ')'			
-	{  
-		$$ = new LLScriptPrint(gLine, gColumn, $3);
-		gAllocationManager->addAllocation($$);
-	}
-	| constant									
-	{  
-		$$ = new LLScriptConstantExpression(gLine, gColumn, $1);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-vector_initializer
-	: '<' expression ',' expression ',' expression '>'	%prec INITIALIZER
-	{
-		$$ = new LLScriptVectorInitializer(gLine, gColumn, $2, $4, $6);
-		gAllocationManager->addAllocation($$);
-	}
-	| ZERO_VECTOR
-	{
-		LLScriptConstantFloat *cf0 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf0);
-		LLScriptConstantExpression *sa0 = new LLScriptConstantExpression(gLine, gColumn, cf0);
-		gAllocationManager->addAllocation(sa0);
-		LLScriptConstantFloat *cf1 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf1);
-		LLScriptConstantExpression *sa1 = new LLScriptConstantExpression(gLine, gColumn, cf1);
-		gAllocationManager->addAllocation(sa1);
-		LLScriptConstantFloat *cf2 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf2);
-		LLScriptConstantExpression *sa2 = new LLScriptConstantExpression(gLine, gColumn, cf2);
-		gAllocationManager->addAllocation(sa2);
-		$$ = new LLScriptVectorInitializer(gLine, gColumn, sa0, sa1, sa2);
-		gAllocationManager->addAllocation($$);
-	}
-	| TOUCH_INVALID_VECTOR
-	{
-		LLScriptConstantFloat *cf0 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf0);
-		LLScriptConstantExpression *sa0 = new LLScriptConstantExpression(gLine, gColumn, cf0);
-		gAllocationManager->addAllocation(sa0);
-		LLScriptConstantFloat *cf1 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf1);
-		LLScriptConstantExpression *sa1 = new LLScriptConstantExpression(gLine, gColumn, cf1);
-		gAllocationManager->addAllocation(sa1);
-		LLScriptConstantFloat *cf2 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf2);
-		LLScriptConstantExpression *sa2 = new LLScriptConstantExpression(gLine, gColumn, cf2);
-		gAllocationManager->addAllocation(sa2);
-		$$ = new LLScriptVectorInitializer(gLine, gColumn, sa0, sa1, sa2);
-		gAllocationManager->addAllocation($$);
-	}
-	| TOUCH_INVALID_TEXCOORD
-	{
-		LLScriptConstantFloat *cf0 = new LLScriptConstantFloat(gLine, gColumn, -1.f);
-		gAllocationManager->addAllocation(cf0);
-		LLScriptConstantExpression *sa0 = new LLScriptConstantExpression(gLine, gColumn, cf0);
-		gAllocationManager->addAllocation(sa0);
-		LLScriptConstantFloat *cf1 = new LLScriptConstantFloat(gLine, gColumn, -1.f);
-		gAllocationManager->addAllocation(cf1);
-		LLScriptConstantExpression *sa1 = new LLScriptConstantExpression(gLine, gColumn, cf1);
-		gAllocationManager->addAllocation(sa1);
-		LLScriptConstantFloat *cf2 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf2);
-		LLScriptConstantExpression *sa2 = new LLScriptConstantExpression(gLine, gColumn, cf2);
-		gAllocationManager->addAllocation(sa2);
-		$$ = new LLScriptVectorInitializer(gLine, gColumn, sa0, sa1, sa2);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-quaternion_initializer
-	: '<' expression ',' expression ',' expression ',' expression '>' %prec INITIALIZER
-	{
-		$$ = new LLScriptQuaternionInitializer(gLine, gColumn, $2, $4, $6, $8);
-		gAllocationManager->addAllocation($$);
-	}
-	| ZERO_ROTATION
-	{
-		LLScriptConstantFloat *cf0 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf0);
-		LLScriptConstantExpression *sa0 = new LLScriptConstantExpression(gLine, gColumn, cf0);
-		gAllocationManager->addAllocation(sa0);
-		LLScriptConstantFloat *cf1 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf1);
-		LLScriptConstantExpression *sa1 = new LLScriptConstantExpression(gLine, gColumn, cf1);
-		gAllocationManager->addAllocation(sa1);
-		LLScriptConstantFloat *cf2 = new LLScriptConstantFloat(gLine, gColumn, 0.f);
-		gAllocationManager->addAllocation(cf2);
-		LLScriptConstantExpression *sa2 = new LLScriptConstantExpression(gLine, gColumn, cf2);
-		gAllocationManager->addAllocation(sa2);
-		LLScriptConstantFloat *cf3 = new LLScriptConstantFloat(gLine, gColumn, 1.f);
-		gAllocationManager->addAllocation(cf3);
-		LLScriptConstantExpression *sa3 = new LLScriptConstantExpression(gLine, gColumn, cf3);
-		gAllocationManager->addAllocation(sa3);
-		$$ = new LLScriptQuaternionInitializer(gLine, gColumn, sa0, sa1, sa2, sa3);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-list_initializer
-	: '[' listexpressionlist ']' %prec INITIALIZER
-	{  
-		$$ = new LLScriptListInitializer(gLine, gColumn, $2);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-
-lvalue 
-	: IDENTIFIER								
-	{  
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $1);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptLValue(gLine, gColumn, id, NULL);
-		gAllocationManager->addAllocation($$);
-	}
-	| IDENTIFIER PERIOD IDENTIFIER
-	{
-		LLScriptIdentifier	*id = new LLScriptIdentifier(gLine, gColumn, $1);	
-		gAllocationManager->addAllocation(id);
-		LLScriptIdentifier	*ac = new LLScriptIdentifier(gLine, gColumn, $3);	
-		gAllocationManager->addAllocation(id);
-		$$ = new LLScriptLValue(gLine, gColumn, id, ac);
-		gAllocationManager->addAllocation($$);
-	}
-	;
-		
-%%
diff --git a/indra/lscript/lscript_compile/lscript_alloc.cpp b/indra/lscript/lscript_compile/lscript_alloc.cpp
deleted file mode 100755
index 5856a94e48..0000000000
--- a/indra/lscript/lscript_compile/lscript_alloc.cpp
+++ /dev/null
@@ -1,26 +0,0 @@
-/** 
- * @file lscript_alloc.cpp
- * @brief Allocation tracking
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
diff --git a/indra/lscript/lscript_compile/lscript_bytecode.cpp b/indra/lscript/lscript_compile/lscript_bytecode.cpp
deleted file mode 100755
index 667e5dafc1..0000000000
--- a/indra/lscript/lscript_compile/lscript_bytecode.cpp
+++ /dev/null
@@ -1,317 +0,0 @@
-/** 
- * @file lscript_bytecode.cpp
- * @brief classes to build actual bytecode
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "lscript_bytecode.h"
-#include "lscript_error.h"
-
-#if defined(_MSC_VER)
-# pragma warning(disable: 4102) // 'yy_more' : unreferenced label
-# pragma warning(disable: 4702) // unreachable code
-#endif
-
-LLScriptJumpTable::LLScriptJumpTable()
-{
-}
-
-LLScriptJumpTable::~LLScriptJumpTable()
-{
-	delete_and_clear(mLabelMap);
-	delete_and_clear(mJumpMap);
-}
-
-void LLScriptJumpTable::addLabel(char *name, S32 offset)
-{
-	char *temp = gScopeStringTable->addString(name);
-	mLabelMap[temp] = new S32(offset);
-}
-
-void LLScriptJumpTable::addJump(char *name, S32 offset)
-{
-	char *temp = gScopeStringTable->addString(name);
-	mJumpMap[temp] = new S32(offset);
-}
-
-
-LLScriptByteCodeChunk::LLScriptByteCodeChunk(BOOL b_need_jumps)
-: mCodeChunk(NULL), mCurrentOffset(0), mJumpTable(NULL)
-{
-	if (b_need_jumps)
-	{
-		mJumpTable = new LLScriptJumpTable();
-	}
-}
-
-LLScriptByteCodeChunk::~LLScriptByteCodeChunk()
-{
-	delete [] mCodeChunk;
-	delete mJumpTable;
-}
-
-void LLScriptByteCodeChunk::addByte(U8 byte)
-{
-	if (mCodeChunk)
-	{
-		U8 *temp = new U8[mCurrentOffset + 1];
-		memcpy(temp, mCodeChunk, mCurrentOffset);	/* Flawfinder: ignore */
-		delete [] mCodeChunk;
-		mCodeChunk = temp;
-	}
-	else
-	{
-		mCodeChunk = new U8[1];
-	}
-	*(mCodeChunk + mCurrentOffset++) = byte;
-}
-
-void LLScriptByteCodeChunk::addU16(U16 data)
-{
-	U8 temp[2];
-	S32 offset = 0;
-	u162bytestream(temp, offset, data);
-	addBytes(temp, 2);
-}
-
-void LLScriptByteCodeChunk::addBytes(const U8 *bytes, S32 size)
-{
-	if (mCodeChunk)
-	{
-		U8 *temp = new U8[mCurrentOffset + size];
-		memcpy(temp, mCodeChunk, mCurrentOffset);	/* Flawfinder: ignore */
-		delete [] mCodeChunk;
-		mCodeChunk = temp;
-	}
-	else
-	{
-		mCodeChunk = new U8[size];
-	}
-	memcpy(mCodeChunk + mCurrentOffset, bytes, size);/* Flawfinder: ignore */
-	mCurrentOffset += size;
-}
-
-void LLScriptByteCodeChunk::addBytes(const char *bytes, S32 size)
-{
-	if (mCodeChunk)
-	{
-		U8 *temp = new U8[mCurrentOffset + size];
-		memcpy(temp, mCodeChunk, mCurrentOffset);	 	/*Flawfinder: ignore*/
-		delete [] mCodeChunk;
-		mCodeChunk = temp;
-	}
-	else
-	{
-		mCodeChunk = new U8[size];
-	}
-	memcpy(mCodeChunk + mCurrentOffset, bytes, size);	/*Flawfinder: ignore*/
-	mCurrentOffset += size;
-}
-
-void LLScriptByteCodeChunk::addBytes(S32 size)
-{
-	if (mCodeChunk)
-	{
-		U8 *temp = new U8[mCurrentOffset + size];
-		memcpy(temp, mCodeChunk, mCurrentOffset);	/*Flawfinder: ignore*/
-		delete [] mCodeChunk;
-		mCodeChunk = temp;
-	}
-	else
-	{
-		mCodeChunk = new U8[size];
-	}
-	memset(mCodeChunk + mCurrentOffset, 0, size);
-	mCurrentOffset += size;
-}
-
-void LLScriptByteCodeChunk::addBytesDontInc(S32 size)
-{
-	if (mCodeChunk)
-	{
-		U8 *temp = new U8[mCurrentOffset + size];
-		memcpy(temp, mCodeChunk, mCurrentOffset);	 	/*Flawfinder: ignore*/
-		delete [] mCodeChunk;
-		mCodeChunk = temp;
-	}
-	else
-	{
-		mCodeChunk = new U8[size];
-	}
-	memset(mCodeChunk + mCurrentOffset, 0, size);
-}
-
-void LLScriptByteCodeChunk::addInteger(S32 value)
-{
-	U8 temp[4];
-	S32 offset = 0;
-	integer2bytestream(temp, offset, value);
-	addBytes(temp, 4);
-}
-
-void LLScriptByteCodeChunk::addFloat(F32 value)
-{
-	U8 temp[4];
-	S32 offset = 0;
-	float2bytestream(temp, offset, value);
-	addBytes(temp, 4);
-}
-
-void LLScriptByteCodeChunk::addLabel(char *name)
-{
-	if (mJumpTable)
-	{
-		mJumpTable->addLabel(name, mCurrentOffset);
-	}
-}
-
-void LLScriptByteCodeChunk::addJump(char *name)
-{
-	if (mJumpTable)
-	{
-		mJumpTable->addJump(name, mCurrentOffset);
-	}
-}
-
-// format is Byte 0: jump op code Byte 1 - 4: offset
-// the jump position points to Byte 5, so we need to add the data at
-//  offset - 4, offset - 3, offset - 2, and offset - 1
-
-// offset is label - jump
-
-void LLScriptByteCodeChunk::connectJumps()
-{
-	if (mJumpTable)
-	{
-		for(std::map<char *, S32 *>::iterator it = mJumpTable->mJumpMap.begin(), end_it = mJumpTable->mJumpMap.end();
-			it != end_it;
-			++it)
-		{
-			S32 jumppos = *it->second;
-			S32 offset = *mJumpTable->mLabelMap[it->first] - jumppos;
-			jumppos = jumppos - 4;
-			integer2bytestream(mCodeChunk, jumppos, offset);
-		}
-	}
-}
-
-LLScriptScriptCodeChunk::LLScriptScriptCodeChunk(S32 total_size)
-: mTotalSize(total_size), mCompleteCode(NULL)
-{
-	mRegisters = new LLScriptByteCodeChunk(FALSE);
-	mGlobalVariables = new LLScriptByteCodeChunk(FALSE);
-	mGlobalFunctions = new LLScriptByteCodeChunk(FALSE);
-	mStates = new LLScriptByteCodeChunk(FALSE);
-	mHeap = new LLScriptByteCodeChunk(FALSE);
-}
-
-LLScriptScriptCodeChunk::~LLScriptScriptCodeChunk()
-{
-	delete mRegisters;
-	delete mGlobalVariables;
-	delete mGlobalFunctions;
-	delete mStates;
-	delete mHeap;
-	delete [] mCompleteCode;
-}
-
-void LLScriptScriptCodeChunk::build(LLFILE *efp, LLFILE *bcfp)
-{
-	S32 code_data_size = mRegisters->mCurrentOffset + 
-					 mGlobalVariables->mCurrentOffset +
-					 mGlobalFunctions->mCurrentOffset +
-					 mStates->mCurrentOffset +
-					 mHeap->mCurrentOffset;
-
-	S32 offset = 0;
-
-	if (code_data_size < mTotalSize)
-	{
-		mCompleteCode = new U8[mTotalSize];
-		memset(mCompleteCode, 0, mTotalSize);
-		
-		memcpy(mCompleteCode, mRegisters->mCodeChunk, mRegisters->mCurrentOffset);	
-		offset += mRegisters->mCurrentOffset;
-
-		set_register(mCompleteCode, LREG_IP, 0);
-		set_register(mCompleteCode, LREG_VN, LSL2_VERSION_NUMBER);
-		set_event_register(mCompleteCode, LREG_IE, 0, LSL2_CURRENT_MAJOR_VERSION);
-		set_register(mCompleteCode, LREG_BP, mTotalSize - 1);
-		set_register(mCompleteCode, LREG_SP, mTotalSize - 1);
-
-		set_register(mCompleteCode, LREG_GVR, offset);
-		
-		memcpy(mCompleteCode + offset, mGlobalVariables->mCodeChunk, mGlobalVariables->mCurrentOffset);	 	/*Flawfinder: ignore*/
-		offset += mGlobalVariables->mCurrentOffset;
-
-		set_register(mCompleteCode, LREG_GFR, offset);
-		
-		memcpy(mCompleteCode + offset, mGlobalFunctions->mCodeChunk, mGlobalFunctions->mCurrentOffset);	/*Flawfinder: ignore*/
-		offset += mGlobalFunctions->mCurrentOffset;
-
-		set_register(mCompleteCode, LREG_SR, offset);
-		// zero is, by definition the default state
-		set_register(mCompleteCode, LREG_CS, 0);
-		set_register(mCompleteCode, LREG_NS, 0);
-		set_event_register(mCompleteCode, LREG_CE, LSCRIPTStateBitField[LSTT_STATE_ENTRY], LSL2_CURRENT_MAJOR_VERSION);
-		S32 default_state_offset = 0;
-		if (LSL2_CURRENT_MAJOR_VERSION == LSL2_MAJOR_VERSION_TWO)
-		{
-			default_state_offset = 8;
-		}
-		else
-		{
-			default_state_offset = 4;
-		}
-		set_event_register(mCompleteCode, LREG_ER, bytestream2u64(mStates->mCodeChunk, default_state_offset), LSL2_CURRENT_MAJOR_VERSION);
-		
-		memcpy(mCompleteCode + offset, mStates->mCodeChunk, mStates->mCurrentOffset);	 	/*Flawfinder: ignore*/
-		offset += mStates->mCurrentOffset;
-
-		set_register(mCompleteCode, LREG_HR, offset);
-		
-		memcpy(mCompleteCode + offset, mHeap->mCodeChunk, mHeap->mCurrentOffset);	 	/*Flawfinder: ignore*/
-		offset += mHeap->mCurrentOffset;
-		
-		set_register(mCompleteCode, LREG_HP, offset);
-		set_register(mCompleteCode, LREG_FR, 0);
-		set_register(mCompleteCode, LREG_SLR, 0);
-		set_register(mCompleteCode, LREG_ESR, 0);
-		set_register(mCompleteCode, LREG_PR, 0);
-		set_register(mCompleteCode, LREG_TM, mTotalSize);
-
-
-		if (fwrite(mCompleteCode, 1, mTotalSize, bcfp) != (size_t)mTotalSize)
-		{
-			LL_WARNS() << "Short write" << LL_ENDL;
-		}
-	}
-	else
-	{
-		gErrorToText.writeError(efp, 0, 0, LSERROR_ASSEMBLE_OUT_OF_MEMORY);
-	}
-}
-
-LLScriptScriptCodeChunk	*gScriptCodeChunk;
diff --git a/indra/lscript/lscript_compile/lscript_bytecode.h b/indra/lscript/lscript_compile/lscript_bytecode.h
deleted file mode 100755
index 1908bebcb9..0000000000
--- a/indra/lscript/lscript_compile/lscript_bytecode.h
+++ /dev/null
@@ -1,90 +0,0 @@
-/** 
- * @file lscript_bytecode.h
- * @brief classes to build actual bytecode
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LSCRIPT_BYTECODE_H
-#define LL_LSCRIPT_BYTECODE_H
-
-#include "lscript_byteconvert.h"
-#include "lscript_scope.h"
-#include <map>
-
-class LLScriptJumpTable
-{
-public:
-	LLScriptJumpTable();
-	~LLScriptJumpTable();
-
-	void addLabel(char *name, S32 offset);
-	void addJump(char *name, S32 offset);
-
-	std::map<char *, S32 *> mLabelMap;
-	std::map<char *, S32 *> mJumpMap;
-};
-
-class LLScriptByteCodeChunk
-{
-public:
-	LLScriptByteCodeChunk(BOOL b_need_jumps);
-	~LLScriptByteCodeChunk();
-
-	void addByte(U8 byte);
-	void addU16(U16 data);
-	void addBytes(const U8 *bytes, S32 size);
-	void addBytes(const char *bytes, S32 size);
-	void addBytes(S32 size);
-	void addBytesDontInc(S32 size);
-	void addInteger(S32 value);
-	void addFloat(F32 value);
-	void addLabel(char *name);
-	void addJump(char *name);
-	void connectJumps();
-
-	U8					*mCodeChunk;
-	S32					mCurrentOffset;
-	LLScriptJumpTable	*mJumpTable;
-};
-
-class LLScriptScriptCodeChunk
-{
-public:
-	LLScriptScriptCodeChunk(S32 total_size);
-	~LLScriptScriptCodeChunk();
-
-	void build(LLFILE *efp, LLFILE *bcfp);
-
-	LLScriptByteCodeChunk				*mRegisters;	
-	LLScriptByteCodeChunk				*mGlobalVariables;	
-	LLScriptByteCodeChunk				*mGlobalFunctions;
-	LLScriptByteCodeChunk				*mStates;
-	LLScriptByteCodeChunk				*mHeap;
-	S32									mTotalSize;
-	U8									*mCompleteCode;
-};
-
-extern LLScriptScriptCodeChunk	*gScriptCodeChunk;
-
-#endif
-
diff --git a/indra/lscript/lscript_compile/lscript_error.cpp b/indra/lscript/lscript_compile/lscript_error.cpp
deleted file mode 100755
index a574981555..0000000000
--- a/indra/lscript/lscript_compile/lscript_error.cpp
+++ /dev/null
@@ -1,103 +0,0 @@
-/** 
- * @file lscript_error.cpp
- * @brief error reporting class and strings
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "lscript_error.h"
-
-S32 gColumn = 0;
-S32 gLine = 0;
-S32 gInternalColumn = 0;
-S32 gInternalLine = 0;
-
-LLScriptGenerateErrorText gErrorToText;
-
-void LLScriptFilePosition::fdotabs(LLFILE *fp, S32 tabs, S32 tabsize)
-{
-	S32 i;
-	for (i = 0; i < tabs * tabsize; i++)
-	{
-		fprintf(fp, " ");
-	}
-}
-
-const char* gWarningText[LSWARN_EOF] = 	 	/*Flawfinder: ignore*/
-{
-	"INVALID",
-	"Dead code found beyond return statement"
-};
-
-const char* gErrorText[LSERROR_EOF] = 	/*Flawfinder: ignore*/
-{
-	"INVALID",
-	"Syntax error",
-	"Not all code paths return a value",
-	"Function returns a value but return statement doesn't",
-	"Return statement type doesn't match function return type",
-	"Global functions can't change state",
-	"Name previously declared within scope",
-	"Name not defined within scope",
-	"Type mismatch",
-	"Expression must act on LValue",
-	"Byte code assembly failed -- out of memory",
-	"Function call mismatches type or number of arguments",
-	"Use of vector or quaternion method on incorrect type",
-	"Lists can't be included in lists",
-	"Unitialized variables can't be included in lists",
-	"Declaration requires a new scope -- use { and }",
-	"CIL assembler failed",
-	"Bytecode transformer failed",
-	"Bytecode verification failed"
-};
-
-void LLScriptGenerateErrorText::writeWarning(LLFILE *fp, LLScriptFilePosition *pos, LSCRIPTWarnings warning)
-{
-	fprintf(fp, "(%d, %d) : WARNING : %s\n", pos->mLineNumber, pos->mColumnNumber, gWarningText[warning]);
-	mTotalWarnings++;
-}
-
-void LLScriptGenerateErrorText::writeWarning(LLFILE *fp, S32 line, S32 col, LSCRIPTWarnings warning)
-{
-	fprintf(fp, "(%d, %d) : WARNING : %s\n", line, col, gWarningText[warning]);
-	mTotalWarnings++;
-}
-
-void LLScriptGenerateErrorText::writeError(LLFILE *fp, LLScriptFilePosition *pos, LSCRIPTErrors error)
-{
-	fprintf(fp, "(%d, %d) : ERROR : %s\n", pos->mLineNumber, pos->mColumnNumber, gErrorText[error]);
-	mTotalErrors++;
-}
-
-void LLScriptGenerateErrorText::writeError(LLFILE *fp, S32 line, S32 col, LSCRIPTErrors error)
-{
-	fprintf(fp, "(%d, %d) : ERROR : %s\n", line, col, gErrorText[error]);
-	mTotalErrors++;
-}
-
-std::string getLScriptErrorString(LSCRIPTErrors error)
-{
-	return gErrorText[error];
-}
diff --git a/indra/lscript/lscript_compile/lscript_error.h b/indra/lscript/lscript_compile/lscript_error.h
deleted file mode 100755
index 43fb968a40..0000000000
--- a/indra/lscript/lscript_compile/lscript_error.h
+++ /dev/null
@@ -1,152 +0,0 @@
-/** 
- * @file lscript_error.h
- * @brief error reporting class and strings
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LSCRIPT_ERROR_H
-#define LL_LSCRIPT_ERROR_H
-
-#include "lscript_scope.h"
-
-typedef enum e_lscript_compile_pass
-{
-	LSCP_INVALID,
-	LSCP_PRETTY_PRINT,
-	LSCP_PRUNE,
-	LSCP_SCOPE_PASS1,
-	LSCP_SCOPE_PASS2,
-	LSCP_TYPE,
-	LSCP_RESOURCE,
-	LSCP_EMIT_ASSEMBLY,
-	LSCP_EMIT_BYTE_CODE,
-	LSCP_DETERMINE_HANDLERS,
-	LSCP_LIST_BUILD_SIMPLE,
-	LSCP_TO_STACK,
-	LSCP_BUILD_FUNCTION_ARGS,
-	LSCP_EMIT_CIL_ASSEMBLY,
-	LSCP_EOF
-} LSCRIPTCompilePass;
-
-typedef enum e_lscript_prune_type
-{
-	LSPRUNE_INVALID,
-	LSPRUNE_GLOBAL_VOIDS,
-	LSPRUNE_GLOBAL_NON_VOIDS,
-	LSPRUNE_EVENTS,
-	LSPRUNE_DEAD_CODE,
-	LSPRUNE_EOF
-} LSCRIPTPruneType;
-
-extern S32 gColumn;
-extern S32 gLine;
-extern S32 gInternalColumn;
-extern S32 gInternalLine;
-
-
-// used to describe where in the file this piece is
-class LLScriptByteCodeChunk;
-
-class LLScriptLibData;
-
-class LLScriptFilePosition
-{
-public:
-	LLScriptFilePosition(S32 line, S32 col)
-		: mLineNumber(line), mColumnNumber(col), mByteOffset(0), mByteSize(0)
-	{
-	}
-
-	virtual ~LLScriptFilePosition() {}
-
-	virtual void recurse(LLFILE *fp, S32 tabs, S32 tabsize, 
-						LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, 
-						LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, 
-						LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata) = 0;
-	virtual S32 getSize() = 0;
-
-	void fdotabs(LLFILE *fp, S32 tabs, S32 tabsize);
-
-	S32 mLineNumber;
-	S32 mColumnNumber;
-
-	S32 mByteOffset;
-	S32 mByteSize;
-};
-
-typedef enum e_lscript_warnings
-{
-	LSWARN_INVALID,
-	LSWARN_DEAD_CODE,
-	LSWARN_EOF
-} LSCRIPTWarnings;
-
-typedef enum e_lscript_errors
-{
-	LSERROR_INVALID,
-	LSERROR_SYNTAX_ERROR,
-	LSERROR_NO_RETURN,
-	LSERROR_INVALID_VOID_RETURN,
-	LSERROR_INVALID_RETURN,
-	LSERROR_STATE_CHANGE_IN_GLOBAL,
-	LSERROR_DUPLICATE_NAME,
-	LSERROR_UNDEFINED_NAME,
-	LSERROR_TYPE_MISMATCH,
-	LSERROR_EXPRESSION_ON_LVALUE,
-	LSERROR_ASSEMBLE_OUT_OF_MEMORY,
-	LSERROR_FUNCTION_TYPE_ERROR,
-	LSERROR_VECTOR_METHOD_ERROR,
-	LSERROR_NO_LISTS_IN_LISTS,
-	LSERROR_NO_UNITIALIZED_VARIABLES_IN_LISTS,
-	LSERROR_NEED_NEW_SCOPE,
-	LSERROR_CIL_ASSEMBLER_FAILED = 16, // Mono build error.
-	LSERROR_BYTECODE_TRANSFORM_FAILED = 17, // Mono build error.
-	LSERROR_BYTECODE_VERIFICATION_FAILED, // Mono build error.
-	LSERROR_EOF
-} LSCRIPTErrors;
-
-class LLScriptGenerateErrorText
-{
-public:
-	LLScriptGenerateErrorText() { init(); }
-	~LLScriptGenerateErrorText() {}
-
-	void init() { mTotalErrors = 0; mTotalWarnings = 0; }
-
-	void writeWarning(LLFILE *fp, LLScriptFilePosition *pos, LSCRIPTWarnings warning);
-	void writeWarning(LLFILE *fp, S32 line, S32 col, LSCRIPTWarnings warning);
-	void writeError(LLFILE *fp, LLScriptFilePosition *pos, LSCRIPTErrors error);
-	void writeError(LLFILE *fp, S32 line, S32 col, LSCRIPTErrors error);
-
-	BOOL getErrors() { return mTotalErrors; }
-	BOOL getWarnings() { return mTotalWarnings; }
-
-	S32 mTotalErrors;
-	S32 mTotalWarnings;
-};
-
-std::string getLScriptErrorString(LSCRIPTErrors error);
-
-extern LLScriptGenerateErrorText gErrorToText;
-
-#endif
diff --git a/indra/lscript/lscript_compile/lscript_heap.cpp b/indra/lscript/lscript_compile/lscript_heap.cpp
deleted file mode 100755
index 476c1ac5a6..0000000000
--- a/indra/lscript/lscript_compile/lscript_heap.cpp
+++ /dev/null
@@ -1,67 +0,0 @@
-/** 
- * @file lscript_heap.cpp
- * @brief classes to manage script heap
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#if 0
-
-#include "linden_common.h"
-
-#include "lscript_heap.h"
-
-LLScriptHeapEntry::LLScriptHeapEntry(U8 *entry)
-: mEntry(entry)
-{
-	S32 offset = 0;
-	mNext = bytestream2integer(entry, offset);
-	mRefCount = bytestream2integer(entry, offset);
-	mType = *(entry + offset);
-	mData = entry + offset;
-	mListOffset = offset;
-}
-
-LLScriptHeapEntry::LLScriptHeapEntry(U8 *heap, S32 offset)
-: mNext(0x9), mType(0), mRefCount(0), mEntry(heap + offset), mData(heap + offset + 0x9), mListOffset(0x9)
-{
-}
-
-LLScriptHeapEntry::~LLScriptHeapEntry()
-{
-}
-
-void LLScriptHeapEntry::addString(char *string)
-{
-	S32 size = strlen(string) + 1;	 	/*Flawfinder: ignore*/
-	S32 offset = 0;
-	memcpy(mData, string, size);	 	/*Flawfinder: ignore*/
-	mNext += size;
-	integer2bytestream(mEntry, offset, mNext);
-	mRefCount++;
-	integer2bytestream(mEntry, offset, mRefCount);
-	*(mEntry + offset) = LSCRIPTTypeByte[LST_STRING];
-}
-
-
-
-#endif
diff --git a/indra/lscript/lscript_compile/lscript_heap.h b/indra/lscript/lscript_compile/lscript_heap.h
deleted file mode 100755
index 7762a367d6..0000000000
--- a/indra/lscript/lscript_compile/lscript_heap.h
+++ /dev/null
@@ -1,58 +0,0 @@
-/** 
- * @file lscript_heap.h
- * @brief classes to manage script heap
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#if 0
-
-#ifndef LL_LSCRIPT_HEAP_H
-#define LL_LSCRIPT_HEAP_H
-
-#include "lscript_byteconvert.h"
-//#include "vmath.h"
-#include "v3math.h"
-#include "llquaternion.h"
-
-class LLScriptHeapEntry
-{
-public:
-	LLScriptHeapEntry(U8 *entry);
-	LLScriptHeapEntry(U8 *heap, S32 offset);
-	~LLScriptHeapEntry();
-
-	void addString(char *string);
-
-	S32 mNext;
-	U8	mType;
-	S32 mRefCount;
-	S32 mListOffset;
-	U8  *mEntry;
-	U8  *mData;
-	U8  *mListEntry;
-};
-
-#endif
-
-#endif
-
diff --git a/indra/lscript/lscript_compile/lscript_resource.cpp b/indra/lscript/lscript_compile/lscript_resource.cpp
deleted file mode 100755
index 6cc3e3c5ee..0000000000
--- a/indra/lscript/lscript_compile/lscript_resource.cpp
+++ /dev/null
@@ -1,36 +0,0 @@
-/** 
- * @file lscript_resource.cpp
- * @brief resource determination prior to assembly
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "lscript_resource.h"
-
-void init_temp_jumps()
-{
-	gTempJumpCount = 0;
-}
-
-S32 gTempJumpCount = 0;
diff --git a/indra/lscript/lscript_compile/lscript_resource.h b/indra/lscript/lscript_compile/lscript_resource.h
deleted file mode 100755
index 82cece0a85..0000000000
--- a/indra/lscript/lscript_compile/lscript_resource.h
+++ /dev/null
@@ -1,37 +0,0 @@
-/** 
- * @file lscript_resource.h
- * @brief resource determination prior to assembly
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LSCRIPT_RESOURCE_H
-#define LL_LSCRIPT_RESOURCE_H
-
-#include "lscript_scope.h"
-
-void init_temp_jumps();
-
-extern S32 gTempJumpCount;
-
-#endif
-
diff --git a/indra/lscript/lscript_compile/lscript_scope.cpp b/indra/lscript/lscript_compile/lscript_scope.cpp
deleted file mode 100755
index e0fdf44d7a..0000000000
--- a/indra/lscript/lscript_compile/lscript_scope.cpp
+++ /dev/null
@@ -1,31 +0,0 @@
-/** 
- * @file lscript_scope.cpp
- * @brief builds nametable and checks scope
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "lscript_tree.h"
-
-LLStringTable *gScopeStringTable;
diff --git a/indra/lscript/lscript_compile/lscript_scope.h b/indra/lscript/lscript_compile/lscript_scope.h
deleted file mode 100755
index ffff91c81b..0000000000
--- a/indra/lscript/lscript_compile/lscript_scope.h
+++ /dev/null
@@ -1,401 +0,0 @@
-/** 
- * @file lscript_scope.h
- * @brief builds nametable and checks scope
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LSCRIPT_SCOPE_H
-#define LL_LSCRIPT_SCOPE_H
-
-#include <map>
-#include "llstringtable.h"
-#include "lscript_byteformat.h"
-
-typedef enum e_lscript_identifier_type
-{
-	LIT_INVALID,
-	LIT_GLOBAL,
-	LIT_VARIABLE,
-	LIT_FUNCTION,
-	LIT_LABEL,
-	LIT_STATE,
-	LIT_HANDLER,
-	LIT_LIBRARY_FUNCTION,
-	LIT_EOF
-} LSCRIPTIdentifierType;
-
-const char LSCRIPTFunctionTypeStrings[LST_EOF] =	 	/*Flawfinder: ignore*/
-{
-	'0',
-	'i',
-	'f',
-	's',
-	'k',
-	'v',
-	'q',
-	'l',
-	'0'
-};
-
-const char * const LSCRIPTListDescription[LST_EOF] =	/*Flawfinder: ignore*/
-{
-   "PUSHARGB 0",
-   "PUSHARGB 1",
-   "PUSHARGB 2",
-   "PUSHARGB 3",
-   "PUSHARGB 4",
-   "PUSHARGB 5",
-   "PUSHARGB 6",
-   "PUSHARGB 7",
-   "PUSHARGB 0"
-};
-
-const char * const LSCRIPTTypePush[LST_EOF] = 	/*Flawfinder: ignore*/
-{
-	"INVALID",
-	"PUSHE",
-	"PUSHE",
-	"PUSHE",
-	"PUSHE",
-	"PUSHEV",
-	"PUSHEQ",
-	"PUSHE",
-	"undefined"
-};
-
-const char * const LSCRIPTTypeReturn[LST_EOF] = 	/*Flawfinder: ignore*/
-{
-	"INVALID",
-	"LOADP -12",
-	"LOADP -12",
-	"STORES -12\nPOP",
-	"STORES -12\nPOP",
-	"LOADVP -20",
-	"LOADQP -24",
-	"LOADLP -12",
-	"undefined"
-};
-
-const char * const LSCRIPTTypePop[LST_EOF] = 	/*Flawfinder: ignore*/
-{
-	"INVALID",
-	"POP",
-	"POP",
-	"POPS",
-	"POPS",
-	"POPV",
-	"POPQ",
-	"POPL",
-	"undefined"
-};
-
-const char * const LSCRIPTTypeDuplicate[LST_EOF] = 	 	/*Flawfinder: ignore*/
-{
-	"INVALID",
-	"DUP",
-	"DUP",
-	"DUPS",
-	"DUPS",
-	"DUPV",
-	"DUPQ",
-	"DUPL",
-	"undefined"
-};
-
-const char * const LSCRIPTTypeLocalStore[LST_EOF] = 	/*Flawfinder: ignore*/
-{
-	"INVALID",
-	"STORE ",
-	"STORE ",
-	"STORES ",
-	"STORES ",
-	"STOREV ",
-	"STOREQ ",
-	"STOREL ",
-	"undefined"
-};
-
-const char * const LSCRIPTTypeLocalDeclaration[LST_EOF] = 	 	/*Flawfinder: ignore*/
-{
-	"INVALID",
-	"STOREP ",
-	"STOREP ",
-	"STORESP ",
-	"STORESP ",
-	"STOREVP ",
-	"STOREQP ",
-	"STORELP ",
-	"undefined"
-};
-
-const char * const LSCRIPTTypeGlobalStore[LST_EOF] = 	/*Flawfinder: ignore*/
-{
-	"INVALID",
-	"STOREG ",
-	"STOREG ",
-	"STORESG ",
-	"STORESG ",
-	"STOREGV ",
-	"STOREGQ ",
-	"STORELG ",
-	"undefined"
-};
-
-const char * const LSCRIPTTypeLocalPush[LST_EOF] = 	 	/*Flawfinder: ignore*/
-{
-	"INVALID",
-	"PUSH ",
-	"PUSH ",
-	"PUSHS ",
-	"PUSHS ",
-	"PUSHV ",
-	"PUSHQ ",
-	"PUSHL ",
-	"undefined"
-};
-
-const char * const LSCRIPTTypeLocalPush1[LST_EOF] = 	 	/*Flawfinder: ignore*/
-{
-	"INVALID",
-	"PUSHARGI 1",
-	"PUSHARGF 1",
-	"undefined",
-	"undefined",
-	"undefined",
-	"undefined",
-	"undefined",
-	"undefined"
-};
-
-const char * const LSCRIPTTypeGlobalPush[LST_EOF] = 	/*Flawfinder: ignore*/
-{
-	"INVALID",
-	"PUSHG ",
-	"PUSHG ",
-	"PUSHGS ",
-	"PUSHGS ",
-	"PUSHGV ",
-	"PUSHGQ ",
-	"PUSHGL ",
-	"undefined"
-};
-
-class LLScriptSimpleAssignable;
-
-class LLScriptArgString
-{
-public:
-	LLScriptArgString() : mString(NULL) {}
-	~LLScriptArgString() { delete [] mString; }
-
-	LSCRIPTType getType(S32 count)
-	{
-		if (!mString)
-			return LST_NULL;
-		S32 length = (S32)strlen(mString);	 	/*Flawfinder: ignore*/
-		if (count >= length)
-		{
-			return LST_NULL;
-		}
-		switch(mString[count])
-		{
-		case 'i':
-			return LST_INTEGER;
-		case 'f':
-			return LST_FLOATINGPOINT;
-		case 's':
-			return LST_STRING;
-		case 'k':
-			return LST_KEY;
-		case 'v':
-			return LST_VECTOR;
-		case 'q':
-			return LST_QUATERNION;
-		case 'l':
-			return LST_LIST;
-		default:
-			return LST_NULL;
-		}
-	}
-
-	void addType(LSCRIPTType type)
-	{
-		S32 count = 0;
-		if (mString)
-		{
-			count = (S32)strlen(mString);	 	/*Flawfinder: ignore*/
-			char *temp = new char[count + 2];
-			memcpy(temp, mString, count);	 	/*Flawfinder: ignore*/
-			delete [] mString;
-			mString = temp;
-			mString[count + 1] = 0;
-		}
-		else
-		{
-			mString = new char[count + 2];
-			mString[count + 1] = 0;
-		}
-		mString[count++] = LSCRIPTFunctionTypeStrings[type];
-	}
-
-	S32 getNumber()
-	{
-		if (mString)
-			return (S32)strlen(mString);	 	/*Flawfinder: ignore*/
-		else
-			return 0;
-	}
-
-	char *mString;
-};
-
-class LLScriptScopeEntry
-{
-public:
-	LLScriptScopeEntry(const char *identifier, LSCRIPTIdentifierType idtype, LSCRIPTType type, S32 count = 0)
-		: mIdentifier(identifier), mIDType(idtype), mType(type), mOffset(0), mSize(0), mAssignable(NULL), mCount(count), mLibraryNumber(0)
-	{
-	}
-
-	~LLScriptScopeEntry() {}
-
-	const char					*mIdentifier;
-	LSCRIPTIdentifierType		mIDType;
-	LSCRIPTType					mType;
-	S32							mOffset;
-	S32							mSize;
-	LLScriptSimpleAssignable	*mAssignable;
-	S32							mCount; // NOTE: Index for locals in CIL.
-	U16							mLibraryNumber;
-	LLScriptArgString			mFunctionArgs;
-	LLScriptArgString			mLocals;
-};
-
-class LLScriptScope
-{
-public:
-	LLScriptScope(LLStringTable *stable)
-		: mParentScope(NULL), mSTable(stable), mFunctionCount(0), mStateCount(0)
-	{ 
-	}
-
-	~LLScriptScope()	
-	{
-		delete_and_clear(mEntryMap);
-	}
-
-	LLScriptScopeEntry *addEntry(const char *identifier, LSCRIPTIdentifierType idtype, LSCRIPTType type)
-	{
-		const char *name = mSTable->addString(identifier);
-		if (mEntryMap.find(name) == mEntryMap.end())
-		{
-			if (idtype == LIT_FUNCTION)
-				mEntryMap[name] = new LLScriptScopeEntry(name, idtype, type, mFunctionCount++);
-			else if (idtype == LIT_STATE)
-				mEntryMap[name] = new LLScriptScopeEntry(name, idtype, type, mStateCount++);
-			else
-				mEntryMap[name] = new LLScriptScopeEntry(name, idtype, type);
-			return mEntryMap[name];
-		}
-		else
-		{
-			// identifier already exists at this scope
-			return NULL;
-		}
-	}
-
-	bool checkEntry(const char *identifier)
-	{
-		const char *name = mSTable->addString(identifier);
-		return mEntryMap.find(name) != mEntryMap.end();
-	}
-
-	LLScriptScopeEntry *findEntry(const char *identifier)
-	{
-		const char		*name = mSTable->addString(identifier);
-		LLScriptScope	*scope = this;
-
-		while (scope)
-		{
-			entry_map_t::iterator found_it = mEntryMap.find(name);
-			if (found_it != mEntryMap.end())
-			{
-				// cool, we found it at this scope
-				return found_it->second;
-			}
-			scope = scope->mParentScope;
-		}
-		return NULL;
-	}
-
-	LLScriptScopeEntry *findEntryTyped(const char *identifier, LSCRIPTIdentifierType idtype)
-	{
-		const char		*name = mSTable->addString(identifier);
-		LLScriptScope	*scope = this;
-
-		while (scope)
-		{
-			entry_map_t::iterator found_it = scope->mEntryMap.find(name);
-			if (found_it != scope->mEntryMap.end())
-			{
-				// need to check type, and if type is function we need to check both types
-				if (idtype == LIT_FUNCTION)
-				{
-					if (found_it->second->mIDType == LIT_FUNCTION)
-					{
-						return (found_it->second);
-					}
-					else if (found_it->second->mIDType == LIT_LIBRARY_FUNCTION)
-					{
-						return (found_it->second);
-					}
-				}
-				else if (found_it->second->mIDType == idtype)
-				{
-					// cool, we found it at this scope
-					return (found_it->second);
-				}
-			}
-			scope = scope->mParentScope;
-		}
-		return NULL;
-	}
-
-	void addParentScope(LLScriptScope *scope)
-	{
-		mParentScope = scope;
-	}
-
-	typedef std::map<const char *, LLScriptScopeEntry *> entry_map_t;
-	entry_map_t		mEntryMap;
-	LLScriptScope*	mParentScope;
-	LLStringTable*	mSTable;
-	S32				mFunctionCount;
-	S32				mStateCount;
-};
-
-extern LLStringTable *gScopeStringTable;
-
-
-
-#endif
diff --git a/indra/lscript/lscript_compile/lscript_tree.cpp b/indra/lscript/lscript_compile/lscript_tree.cpp
deleted file mode 100755
index 8a70dd9ac1..0000000000
--- a/indra/lscript/lscript_compile/lscript_tree.cpp
+++ /dev/null
@@ -1,10895 +0,0 @@
-/** 
- * @file lscript_tree.cpp
- * @brief implements methods for lscript_tree.h classes
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-// TO DO: Move print functionality from .h file to here
-
-#include "linden_common.h"
-
-#include "lscript_tree.h"
-#include "lscript_typecheck.h"
-#include "lscript_resource.h"
-#include "lscript_bytecode.h"
-#include "lscript_heap.h"
-#include "lscript_library.h"
-#include "lscript_alloc.h"
-
-//#define LSL_INCLUDE_DEBUG_INFO
-
-
-static void print_cil_box(LLFILE* fp, LSCRIPTType type)
-{
-	
-switch(type)
-	{
-	case LST_INTEGER:
-		fprintf(fp, "box [mscorlib]System.Int32\n");
-		break;
-	case LST_FLOATINGPOINT:
-		fprintf(fp, "box [mscorlib]System.Single\n");
-		break;
-	case LST_STRING:
-		// System.String is not a System.ValueType,
-		// so does not need to be boxed.
-		break;
-	case LST_KEY:
-		fprintf(fp, "box [ScriptTypes]LindenLab.SecondLife.Key\n");
-		break;
-	case LST_VECTOR:
-		fprintf(fp, "box [ScriptTypes]LindenLab.SecondLife.Vector\n");
-		break;
-	case LST_QUATERNION:
-		fprintf(fp, "box [ScriptTypes]LindenLab.SecondLife.Quaternion\n");
-		break;
-	default:
-		llassert(false);
-		break;
-	}
-}
-
-static void print_cil_type(LLFILE* fp, LSCRIPTType type)
-{
-	switch(type)
-	{
-	case LST_INTEGER:
-		fprintf(fp, "int32");
-		break;
-	case LST_FLOATINGPOINT:
-		fprintf(fp, "float32");
-		break;
-	case LST_STRING:
-		fprintf(fp, "string");
-		break;		
-	case LST_KEY:
-		fprintf(fp, "valuetype [ScriptTypes]LindenLab.SecondLife.Key");
-		break;
-	case LST_VECTOR:
-		fprintf(fp, "class [ScriptTypes]LindenLab.SecondLife.Vector");
-		break;
-	case LST_QUATERNION:
-		fprintf(fp, "class [ScriptTypes]LindenLab.SecondLife.Quaternion");
-		break;
-	case LST_LIST:
-		fprintf(fp, "class [mscorlib]System.Collections.ArrayList");
-		break;
-	case LST_NULL:
-		fprintf(fp, "void");
-		break;
-	default:
-		break;
-	}
-}
-
-void LLScriptType::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp,"%s",LSCRIPTTypeNames[mType]);
-		break;
-	case LSCP_TYPE:
-		type = mType;
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		print_cil_type(fp, mType);
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptType::getSize()
-{
-	return LSCRIPTDataSize[mType];
-}
-
-void LLScriptConstant::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp,"Script Constant Base class -- should never get here!\n");
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptConstant::getSize()
-{
-	printf("Script Constant Base class -- should never get here!\n");
-	return 0;
-}
-
-
-
-void LLScriptConstantInteger::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "%d", mValue);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "PUSHARGI %d\n", mValue);
-		break;
-	case LSCP_TYPE:
-		type = mType;
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			chunk->addInteger(mValue);
-			type = mType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGI]);
-			chunk->addInteger(mValue);
-			type = mType;
-		}
-		break;
-	case LSCP_LIST_BUILD_SIMPLE:
-		{
-			*ldata = new LLScriptLibData(mValue);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "ldc.i4 %d\n", mValue);
-		type = mType;
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptConstantInteger::getSize()
-{
-	return LSCRIPTDataSize[LST_INTEGER];
-}
-
-void LLScriptConstantFloat::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "%5.5f", mValue);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "PUSHARGF %5.5f\n", mValue);
-		break;
-	case LSCP_TYPE:
-		type = mType;
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			chunk->addFloat(mValue);
-			type = mType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGF]);
-			chunk->addFloat(mValue);
-			type = mType;
-		}
-		break;
-	case LSCP_LIST_BUILD_SIMPLE:
-		{
-			*ldata = new LLScriptLibData(mValue);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-	        {
-		        double v = (double)mValue;
-			U8 * p = (U8 *)&v; // See ECMA-335 Partition VI, Appendix C.4.6 Examples, line 4
-			fprintf(fp, "ldc.r8 (%02x %02x %02x %02x %02x %02x %02x %02x)\n", p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7]);
-			type = mType;
-		}
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptConstantFloat::getSize()
-{
-	return LSCRIPTDataSize[LST_FLOATINGPOINT];
-}
-
-void print_escaped(LLFILE* fp, const char* str)
-{
-  putc('"', fp);
-  for(const char* c = str; *c != '\0'; ++c)
-  {
-	  switch(*c)
-	  {
-	  case '"':
-		putc('\\', fp);
-		putc(*c, fp);
-		break;
-	  case '\n':
-		putc('\\', fp);
-		putc('n', fp);
-		break;
-	  case '\t':
-		putc(' ', fp);
-		putc(' ', fp);
-		putc(' ', fp);
-		putc(' ', fp);
-		break;
-	  case '\\':
-		putc('\\', fp);
-		putc('\\', fp);
-		break;
-	  default:
-		putc(*c, fp);
-	  }
-  }
-  putc('"', fp);
-}
-
-void LLScriptConstantString::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "\"%s\"", mValue);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "PUSHARGS \"%s\"\n", mValue);
-		break;
-	case LSCP_TYPE:
-		type = mType;
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			chunk->addInteger(heap->mCurrentOffset + 1);
-			LLScriptLibData *data = new LLScriptLibData(mValue);
-			U8 *temp;
-			S32 size = lsa_create_data_block(&temp, data, heap->mCurrentOffset);
-
-			heap->addBytes(temp, size);
-			delete [] temp;
-			delete data;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGS]);
-			chunk->addBytes(mValue, (S32)strlen(mValue) + 1);
-			type = mType;
-		}
-		break;
-	case LSCP_LIST_BUILD_SIMPLE:
-		{
-			*ldata = new LLScriptLibData(mValue);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "ldstr ");
-		print_escaped(fp, mValue);
-		fprintf(fp, "\n");
-	default:
-		break;
-	}
-}
-
-S32 LLScriptConstantString::getSize()
-{
-	return (S32)strlen(mValue) + 1;
-}
-
-void LLScriptIdentifier::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "%s", mName);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		if (mScopeEntry)
-		{
-			if (mScopeEntry->mIDType == LIT_VARIABLE)
-			{
-				fprintf(fp, "$BP + %d [%s]", mScopeEntry->mOffset, mName);
-			}
-			else if (mScopeEntry->mIDType == LIT_GLOBAL)
-			{
-				fprintf(fp, "$GVR + %d [%s]", mScopeEntry->mOffset, mName);
-			}
-			else
-			{
-				fprintf(fp, "%s", mName);
-			}
-		}
-		break;
-	case LSCP_TYPE:
-		if (mScopeEntry)
-			type = mScopeEntry->mType;
-		else
-			type = LST_NULL;
-		break;
-	case LSCP_RESOURCE:
-		if (mScopeEntry)
-		{
-			if (mScopeEntry->mIDType == LIT_VARIABLE)
-			{
-//				fprintf(fp, "LOCAL : %d : %d : %s\n", mScopeEntry->mOffset, mScopeEntry->mSize, mName);
-			}
-			else if (mScopeEntry->mIDType == LIT_GLOBAL)
-			{
-//				fprintf(fp, "GLOBAL: %d : %d : %s\n", mScopeEntry->mOffset, mScopeEntry->mSize, mName);
-			}
-		}
-		break;
-	case LSCP_LIST_BUILD_SIMPLE:
-		{
-			if (mScopeEntry)
-			{
-				if (mScopeEntry->mType == LST_LIST)
-				{
-					gErrorToText.writeError(fp, this, LSERROR_NO_LISTS_IN_LISTS);
-				}
-				else if (mScopeEntry->mAssignable)
-				{
-					mScopeEntry->mAssignable->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, ldata);
-				}
-				else
-				{
-					gErrorToText.writeError(fp, this, LSERROR_NO_UNITIALIZED_VARIABLES_IN_LISTS);
-				}
-			}
-			else
-			{
-				gErrorToText.writeError(fp, this, LSERROR_UNDEFINED_NAME);
-			}
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "'%s'", mName);
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptIdentifier::getSize()
-{
-	
-	return 0;
-}
-
-
-
-void LLScriptSimpleAssignable::addAssignable(LLScriptSimpleAssignable *assign)
-{
-	if (mNextp)
-	{
-		assign->mNextp = mNextp;
-	}
-	mNextp = assign;
-}
-
-void LLScriptSimpleAssignable::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	fprintf(fp, "Simple Assignable Base Class -- should never get here!\n");
-}
-
-S32 LLScriptSimpleAssignable::getSize()
-{
-	
-	printf("Simple Assignable Base Class -- should never get here!\n");
-	return 0;
-}
-
-static void print_cil_member(LLFILE* fp, LLScriptIdentifier *ident)
-{
-	print_cil_type(fp, ident->mScopeEntry->mType);
-	fprintf(fp, " %s::'%s'\n", gScriptp->getClassName(), ident->mScopeEntry->mIdentifier);
-}
-
-void LLScriptSAIdentifier::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mNextp)
-		{
-			fprintf(fp, ", ");
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_SCOPE_PASS1:
-		{ 
-			LLScriptScopeEntry *entry = scope->findEntry(mIdentifier->mName);
-			if (!entry)
-			{
-				gErrorToText.writeError(fp, this, LSERROR_UNDEFINED_NAME);
-			}
-			else
-			{
-				// if we did find it, make sure this identifier is associated with the correct scope entry
-				mIdentifier->mScopeEntry = entry;
-			}
-			if (mNextp)
-			{
-				mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			if (mIdentifier->mScopeEntry)
-			{
-				if(mIdentifier->mScopeEntry->mAssignable)
-				{
-					mIdentifier->mScopeEntry->mAssignable->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				}
-				else
-				{
-					// Babbage: 29/8/06: If the scope entry has no mAssignable,
-					// set the default type and add the default 0 value to the 
-					// chunk. Without this SAVectors and SAQuaternions will 
-					// assume the arbitrary current type is the assignable type 
-					// and may attempt to access a null chunk. (SL-20156)
-					type = mIdentifier->mScopeEntry->mType;
-					chunk->addBytes(LSCRIPTDataSize[type]);
-				}
-			}
-			if (mNextp)
-			{
-				mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			}
-		}
-		break;
-	case LSCP_LIST_BUILD_SIMPLE:
-		{
-			mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, ldata);
-			if (mNextp)
-			{
-				mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, &(*ldata)->mListp);
-			}
-		}
-		break;
-
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			fprintf(fp, "ldarg.0\n");
-			fprintf(fp, "ldfld ");
-			print_cil_member(fp, mIdentifier);
-			fprintf(fp, "\n");
-			if (mNextp)
-			{
-				mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			}
-			break;
-		}
-	default:
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-S32 LLScriptSAIdentifier::getSize()
-{
-	return mIdentifier->getSize();
-}
-
-void LLScriptSAConstant::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		mConstant->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mNextp)
-		{
-			fprintf(fp, ", ");
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_LIST_BUILD_SIMPLE:
-		{
-			mConstant->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, ldata);
-			if (mNextp)
-			{
-				mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, &(*ldata)->mListp);
-			}
-		}
-		break;
-	default:
-		mConstant->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-S32 LLScriptSAConstant::getSize()
-{
-	return mConstant->getSize();
-}
-
-
-static void print_cil_cast(LLFILE* fp, LSCRIPTType srcType, LSCRIPTType targetType)
-{
-	switch(srcType)
-	{
-	case LST_INTEGER:
-		switch(targetType)
-		{
-		case LST_FLOATINGPOINT:
-			fprintf(fp, "conv.r8\n");
-			break;
-		case LST_STRING:
-			fprintf(fp, "call string class [mscorlib]System.Convert::ToString(int32)\n");
-			break;
-		case LST_LIST:
-			print_cil_box(fp, LST_INTEGER);
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::CreateList(object)\n");
-			break;
-		default:
-			break;
-		}
-		break;
-	case LST_FLOATINGPOINT:
-		switch(targetType)
-		{
-		case LST_INTEGER:
-			fprintf(fp, "call int32 [LslLibrary]LindenLab.SecondLife.LslRunTime::ToInteger(float32)\n");
-			break;
-		case LST_STRING:
-			fprintf(fp, "call string [LslLibrary]LindenLab.SecondLife.LslRunTime::ToString(float32)\n");
-			break;
-		case LST_LIST:
-			print_cil_box(fp, LST_FLOATINGPOINT);
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::CreateList(object)\n");
-			break;
-		default:
-			break;
-		}
-		break;
-	case LST_STRING:
-		switch(targetType)
-		{
-		case LST_INTEGER:
-			fprintf(fp, "call int32 [LslLibrary]LindenLab.SecondLife.LslRunTime::StringToInt(string)\n");
-			break;
-		case LST_FLOATINGPOINT:
-			fprintf(fp, "call float32 [LslLibrary]LindenLab.SecondLife.LslRunTime::StringToFloat(string)\n");
-			break;
-		case LST_KEY:
-			fprintf(fp, "call valuetype [ScriptTypes]LindenLab.SecondLife.Key class [LslUserScript]LindenLab.SecondLife.LslUserScript::'CreateKey'(string)\n");
-			break;	
-		case LST_LIST:
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::CreateList(object)\n");
-			break;
-		case LST_VECTOR:
-			fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'ParseVector'(string)\n");
-			break;
-		case LST_QUATERNION:
-			fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'ParseQuaternion'(string)\n");
-			break;
-		default:
-			break;
-		}
-		break;
-	case LST_KEY:
-		switch(targetType)
-		{
-		case LST_KEY:
-			break;
-		case LST_STRING:
-			fprintf(fp, "call string [LslUserScript]LindenLab.SecondLife.LslUserScript::'ToString'(valuetype [ScriptTypes]LindenLab.SecondLife.Key)\n");
-			break;
-		case LST_LIST:
-			print_cil_box(fp, LST_KEY);
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::CreateList(object)\n");
-			break;
-		default:
-			break;
-		}
-		break;
-	case LST_VECTOR:
-		switch(targetType)
-		{
-		case LST_VECTOR:
-			break;
-		case LST_STRING:
-			fprintf(fp, "call string [LslUserScript]LindenLab.SecondLife.LslUserScript::'ToString'(valuetype [ScriptTypes]LindenLab.SecondLife.Vector)\n");
-			break;
-		case LST_LIST:
-			print_cil_box(fp, LST_VECTOR);
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::CreateList(object)\n");
-			break;
-		default:
-			break;
-		}
-		break;
-	case LST_QUATERNION:
-		switch(targetType)
-		{
-		case LST_QUATERNION:
-			break;
-		case LST_STRING:
-			fprintf(fp, "call string [LslUserScript]LindenLab.SecondLife.LslUserScript::'ToString'(valuetype [ScriptTypes]LindenLab.SecondLife.Quaternion)\n");
-			break;
-		case LST_LIST:
-			print_cil_box(fp, LST_QUATERNION);
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::CreateList(object)\n");
-			break;
-		default:
-			break;
-		}
-		break;
-	case LST_LIST:
-		switch(targetType)
-		{
-		case LST_LIST:
-			break;
-		case LST_STRING:
-			fprintf(fp, "call string [LslLibrary]LindenLab.SecondLife.LslRunTime::ListToString(class [mscorlib]System.Collections.ArrayList)\n");
-			break;
-		default:
-			break;
-		}
-		break;
-	default:
-		break;
-	}
-}
-
-static void print_cil_numeric_cast(LLFILE* fp, LSCRIPTType currentArg, LSCRIPTType otherArg)
-{
-	if((currentArg == LST_INTEGER) && ((otherArg == LST_FLOATINGPOINT) || (otherArg == LST_VECTOR)))
-	{
-		print_cil_cast(fp, LST_INTEGER, LST_FLOATINGPOINT);
-	}
-}
-
-static void print_cil_assignment_cast(LLFILE* fp, LSCRIPTType src,
-									  LSCRIPTType dest)
-{
-	if (LST_STRING == src && LST_KEY == dest)
-	{
-		print_cil_cast(fp, src, dest);
-	}
-	else if(LST_KEY == src && LST_STRING == dest)
-	{
-		print_cil_cast(fp, src, dest);
-	}
-	else
-	{
-		print_cil_numeric_cast(fp, src, dest);
-	}
-}
- 
-// HACK! Babbage: should be converted to virtual on LSCRIPTSimpleAssignableType to avoid downcasts.
-LSCRIPTType get_type(LLScriptSimpleAssignable* sa)
-{
-	LSCRIPTType result = LST_NULL;
-	switch(sa->mType)
-	{
-	case LSSAT_IDENTIFIER:
-		result = ((LLScriptSAIdentifier*) sa)->mIdentifier->mScopeEntry->mType;
-		break;
-	case LSSAT_CONSTANT:
-		result = ((LLScriptSAConstant*) sa)->mConstant->mType;
-		break;
-	case LSSAT_VECTOR_CONSTANT:
-		result = LST_VECTOR;
-		break;
-	case LSSAT_QUATERNION_CONSTANT:
-		result = LST_QUATERNION;
-		break;
-	case LSSAT_LIST_CONSTANT:
-		result = LST_LIST;
-		break;
-	default:
-		result = LST_UNDEFINED;
-		break;
-	}
-	return result;
-}
-
-void LLScriptSAVector::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "< ");
-		mEntry3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", ");
-		mEntry2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", ");
-		mEntry1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " >");
-		if (mNextp)
-		{
-			fprintf(fp, ", ");
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_TYPE:
-		// vector's take floats
-		mEntry3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		mEntry2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		mEntry1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		type = LST_VECTOR;
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		mEntry3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (type == LST_INTEGER)
-		{
-			S32 offset = chunk->mCurrentOffset - 4;
-			bytestream_int2float(chunk->mCodeChunk, offset);
-		}
-		mEntry2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (type == LST_INTEGER)
-		{
-			S32 offset = chunk->mCurrentOffset - 4;
-			bytestream_int2float(chunk->mCodeChunk, offset);
-		}
-		mEntry1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (type == LST_INTEGER)
-		{
-			S32 offset = chunk->mCurrentOffset - 4;
-			bytestream_int2float(chunk->mCodeChunk, offset);
-		}
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_LIST_BUILD_SIMPLE:
-		{
-			LLScriptByteCodeChunk	*list = new LLScriptByteCodeChunk(FALSE);
-			mEntry3->recurse(fp, tabs, tabsize, LSCP_EMIT_BYTE_CODE, ptype, prunearg, scope, type, basetype, count, list, heap, stacksize, entry, entrycount, NULL);
-			if (type == LST_INTEGER)
-			{
-				S32 offset = list->mCurrentOffset - 4;
-				bytestream_int2float(list->mCodeChunk, offset);
-			}
-			mEntry2->recurse(fp, tabs, tabsize, LSCP_EMIT_BYTE_CODE, ptype, prunearg, scope, type, basetype, count, list, heap, stacksize, entry, entrycount, NULL);
-			if (type == LST_INTEGER)
-			{
-				S32 offset = list->mCurrentOffset - 4;
-				bytestream_int2float(list->mCodeChunk, offset);
-			}
-			mEntry1->recurse(fp, tabs, tabsize, LSCP_EMIT_BYTE_CODE, ptype, prunearg, scope, type, basetype, count, list, heap, stacksize, entry, entrycount, NULL);
-			if (type == LST_INTEGER)
-			{
-				S32 offset = list->mCurrentOffset - 4;
-				bytestream_int2float(list->mCodeChunk, offset);
-			}
-			LLVector3 vec;
-			S32 offset = 0;
-			bytestream2vector(vec, list->mCodeChunk, offset);
-			*ldata = new LLScriptLibData(vec);
-			delete list;
-			if (mNextp)
-			{
-				mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, &(*ldata)->mListp);
-			}
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-
-		// Load arguments.
-		mEntry1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if(LST_INTEGER == get_type(mEntry1))
-		{
-			print_cil_cast(fp, LST_INTEGER, LST_FLOATINGPOINT);
-		}
-		mEntry2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if(LST_INTEGER == get_type(mEntry2))
-		{
-			print_cil_cast(fp, LST_INTEGER, LST_FLOATINGPOINT);
-		}
-		mEntry3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if(LST_INTEGER == get_type(mEntry3))
-		{
-			print_cil_cast(fp, LST_INTEGER, LST_FLOATINGPOINT);
-		}
-		
-		// Call named ctor, which leaves new Vector on stack, so it can be saved in to local or argument just like a primitive type.
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'CreateVector'(float32, float32, float32)\n");
-
-		// Next.
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	default:
-		mEntry3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mEntry2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mEntry1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-S32 LLScriptSAVector::getSize()
-{
-	return mEntry1->getSize() + mEntry2->getSize() + mEntry3->getSize();
-}
-
-void LLScriptSAQuaternion::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "< ");
-		mEntry4->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", ");
-		mEntry3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", ");
-		mEntry2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", ");
-		mEntry1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " >");
-		if (mNextp)
-		{
-			fprintf(fp, ", ");
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_TYPE:
-		// vector's take floats
-		mEntry4->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		mEntry3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		mEntry2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		mEntry1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		type = LST_QUATERNION;
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		mEntry4->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (type == LST_INTEGER)
-		{
-			S32 offset = chunk->mCurrentOffset - 4;
-			bytestream_int2float(chunk->mCodeChunk, offset);
-		}
-		mEntry3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (type == LST_INTEGER)
-		{
-			S32 offset = chunk->mCurrentOffset - 4;
-			bytestream_int2float(chunk->mCodeChunk, offset);
-		}
-		mEntry2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (type == LST_INTEGER)
-		{
-			S32 offset = chunk->mCurrentOffset - 4;
-			bytestream_int2float(chunk->mCodeChunk, offset);
-		}
-		mEntry1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (type == LST_INTEGER)
-		{
-			S32 offset = chunk->mCurrentOffset - 4;
-			bytestream_int2float(chunk->mCodeChunk, offset);
-		}
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_LIST_BUILD_SIMPLE:
-		{
-			LLScriptByteCodeChunk	*list = new LLScriptByteCodeChunk(FALSE);
-			mEntry4->recurse(fp, tabs, tabsize, LSCP_EMIT_BYTE_CODE, ptype, prunearg, scope, type, basetype, count, list, heap, stacksize, entry, entrycount, NULL);
-			if (type == LST_INTEGER)
-			{
-				S32 offset = list->mCurrentOffset - 4;
-				bytestream_int2float(list->mCodeChunk, offset);
-			}
-			mEntry3->recurse(fp, tabs, tabsize, LSCP_EMIT_BYTE_CODE, ptype, prunearg, scope, type, basetype, count, list, heap, stacksize, entry, entrycount, NULL);
-			if (type == LST_INTEGER)
-			{
-				S32 offset = list->mCurrentOffset - 4;
-				bytestream_int2float(list->mCodeChunk, offset);
-			}
-			mEntry2->recurse(fp, tabs, tabsize, LSCP_EMIT_BYTE_CODE, ptype, prunearg, scope, type, basetype, count, list, heap, stacksize, entry, entrycount, NULL);
-			if (type == LST_INTEGER)
-			{
-				S32 offset = list->mCurrentOffset - 4;
-				bytestream_int2float(list->mCodeChunk, offset);
-			}
-			mEntry1->recurse(fp, tabs, tabsize, LSCP_EMIT_BYTE_CODE, ptype, prunearg, scope, type, basetype, count, list, heap, stacksize, entry, entrycount, NULL);
-			if (type == LST_INTEGER)
-			{
-				S32 offset = list->mCurrentOffset - 4;
-				bytestream_int2float(list->mCodeChunk, offset);
-			}
-			LLQuaternion quat;
-			S32 offset = 0;
-			bytestream2quaternion(quat, list->mCodeChunk, offset);
-			*ldata = new LLScriptLibData(quat);
-			delete list;
-			if (mNextp)
-			{
-				mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, &(*ldata)->mListp);
-			}
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-
-		// Load arguments.
-		mEntry1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if(LST_INTEGER == get_type(mEntry1))
-		{
-			print_cil_cast(fp, LST_INTEGER, LST_FLOATINGPOINT);
-		}
-		mEntry2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if(LST_INTEGER == get_type(mEntry2))
-		{
-			print_cil_cast(fp, LST_INTEGER, LST_FLOATINGPOINT);
-		}
-		mEntry3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if(LST_INTEGER == get_type(mEntry3))
-		{
-			print_cil_cast(fp, LST_INTEGER, LST_FLOATINGPOINT);
-		}
-		mEntry4->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if(LST_INTEGER == get_type(mEntry4))
-		{
-			print_cil_cast(fp, LST_INTEGER, LST_FLOATINGPOINT);
-		}
-		
-		// Call named ctor, which leaves new Vector on stack, so it can be saved in to local or argument just like a primitive type.
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'CreateQuaternion'(float32, float32, float32, float32)\n");
-
-		// Next.
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	default:
-		mEntry4->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mEntry3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mEntry2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mEntry1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-S32 LLScriptSAQuaternion::getSize()
-{
-	return mEntry1->getSize() + mEntry2->getSize() + mEntry3->getSize() + mEntry4->getSize();
-}
-
-void LLScriptSAList::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "[ ");
-		if (mEntryList)
-			mEntryList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " ]");
-		if (mNextp)
-		{
-			fprintf(fp, ", ");
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_TYPE:
-		if (mEntryList)
-			mEntryList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		type = LST_LIST;
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			LLScriptLibData *list_data = new LLScriptLibData;
-
-			list_data->mType = LST_LIST;
-			if (mEntryList)
-				mEntryList->recurse(fp, tabs, tabsize, LSCP_LIST_BUILD_SIMPLE, ptype, prunearg, scope, type, basetype, count, chunk, NULL, stacksize, entry, entrycount, &(list_data->mListp));
-
-			U8 *temp;
-			chunk->addInteger(heap->mCurrentOffset + 1);
-			S32 size = lsa_create_data_block(&temp, list_data, heap->mCurrentOffset);
-			heap->addBytes(temp, size);
-			delete list_data;
-			delete [] temp;
-
-			if (mNextp)
-			{
-				mNextp->recurse(fp, tabs, tabsize, LSCP_EMIT_BYTE_CODE, ptype, prunearg, scope, type, basetype, count, chunk, NULL, stacksize, entry, entrycount, NULL);
-			}
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			// Create list.
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList [LslUserScript]LindenLab.SecondLife.LslUserScript::CreateList()\n");
-
-			// Add elements.
-			LLScriptSimpleAssignable* current_entry = mEntryList;
-			LLScriptSimpleAssignable* next_entry = NULL;
-			while(NULL != current_entry)
-			{
-				next_entry = current_entry->mNextp;
-
-				// Null mNextp pointer, so only current list element is processed.
-				current_entry->mNextp = NULL;
-				current_entry->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-
-				// Restore mNextp pointer.
-				current_entry->mNextp = next_entry;
-
-				// Box element and store in list.
-				print_cil_box(fp, get_type(current_entry));
-				fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(class [mscorlib]System.Collections.ArrayList, object)\n");
-
-				// Process next element.
-				current_entry = next_entry;
-			}
-
-			// Process next list.
-			if (mNextp)
-			{
-				mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			}
-		}
-		break;
-	default:
-		if (mEntryList)
-			mEntryList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, ldata);
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, ldata);
-		}
-		break;
-	}
-}
-
-S32 LLScriptSAList::getSize()
-{
-	return mEntryList->getSize();
-}
-
-void LLScriptGlobalVariable::addGlobal(LLScriptGlobalVariable *global)
-{
-	if (mNextp)
-	{
-		global->mNextp = mNextp;
-	}
-	mNextp = global;
-}
-
-void LLScriptGlobalVariable::gonext(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	default:
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-// Push initialised variable of type on to stack.
-static void print_cil_init_variable(LLFILE* fp, LSCRIPTType type)
-{
-	switch(type)
-	{
-	case LST_INTEGER:
-		fprintf(fp, "ldc.i4.0\n");
-		break;
-	case LST_FLOATINGPOINT:
-		fprintf(fp, "ldc.r8 0\n");
-		break;
-	case LST_STRING:
-		fprintf(fp, "ldstr \"\"\n");
-		break;
-	case LST_KEY:
-		fprintf(fp, "ldstr \"\"\n");
-		fprintf(fp, "call valuetype [ScriptTypes]LindenLab.SecondLife.Key class [LslUserScript]LindenLab.SecondLife.LslUserScript::'CreateKey'(string)\n");
-		break;
-	case LST_VECTOR:
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'CreateVector'(float32, float32, float32)\n");
-		break;
-	case LST_QUATERNION:
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "ldc.r8 1\n");
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'CreateQuaternion'(float32, float32, float32, float32)\n");
-		break;
-	case LST_LIST:
-		fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::CreateList()\n");
-		break;
-	default:
-		break;
-	}
-}
-
-void LLScriptGlobalVariable::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp,"\t");
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mAssignable)
-		{
-			fprintf(fp, " = ");
-			mAssignable->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		fprintf(fp, ";\n");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp,"\t");
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mAssignable)
-		{
-			fprintf(fp, " = ");
-			mAssignable->recurse(fp, tabs, tabsize, LSCP_PRETTY_PRINT, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "\n");
-			fprintf(fp, "Offset: %d Type: %d\n", mIdentifier->mScopeEntry->mOffset, (S32)LSCRIPTTypeByte[mType->mType]);
-		}
-		else
-		{
-			fprintf(fp, "\n");
-			fprintf(fp, "Offset: %d Type: %d\n", mIdentifier->mScopeEntry->mOffset, (S32)LSCRIPTTypeByte[mType->mType]);
-		}
-		break;
-	case LSCP_SCOPE_PASS1:
-		if (scope->checkEntry(mIdentifier->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			if (mAssignable)
-			{
-				mAssignable->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			}			
-			// this needs to go after expression decent to make sure that we don't add ourselves or something silly
-			mIdentifier->mScopeEntry = scope->addEntry(mIdentifier->mName, LIT_GLOBAL, mType->mType);
-			if (mIdentifier->mScopeEntry && mAssignable)
-					mIdentifier->mScopeEntry->mAssignable = mAssignable;
-		}
-		break;
-	case LSCP_TYPE:
-		// if the variable has an assignable, it must assignable to the variable's type
-		if (mAssignable)
-		{
-			mAssignable->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mAssignableType = type;
-			if (!legal_assignment(mType->mType, mAssignableType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			// it also includes the name of the variable as well as the type
-			// plus 4 bytes of offset from it's apparent address to the actual data
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			count += strlen(mIdentifier->mName) + 1 + 1 + 4;
-#else
-			count += 1 + 1 + 4;
-#endif
-			mIdentifier->mScopeEntry->mOffset = (S32)count;
-			mIdentifier->mScopeEntry->mSize = mType->getSize();
-			count += mIdentifier->mScopeEntry->mSize;
-			mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			// order for global variables
-			// 0 - 4: offset to actual data
-			S32 offsetoffset = chunk->mCurrentOffset;
-			S32 offsetdelta = 0;
-			chunk->addBytes(4);
-			// type
-			char vtype;
-			vtype = LSCRIPTTypeByte[mType->mType]; 
-			chunk->addBytes(&vtype, 1);
-			// null terminated name
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			chunk->addBytes(mIdentifier->mName, strlen(mIdentifier->mName) + 1);
-#else
-			chunk->addBytes(1);
-#endif
-			// put correct offset delta in
-			offsetdelta = chunk->mCurrentOffset - offsetoffset;
-			integer2bytestream(chunk->mCodeChunk, offsetoffset, offsetdelta);
-
-			// now we need space for the variable itself
-			LLScriptByteCodeChunk	*value = new LLScriptByteCodeChunk(FALSE);
-			if (mAssignable)
-			{
-				mAssignable->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, value, heap, stacksize, entry, entrycount, NULL);
-				// need to put sneaky type conversion here
-				if (mAssignableType != mType->mType)
-				{
-					// the only legal case that is a problem is int->float
-					if (mType->mType == LST_FLOATINGPOINT && mAssignableType == LST_INTEGER)
-					{
-						S32 offset = value->mCurrentOffset - 4;
-						bytestream_int2float(value->mCodeChunk, offset);
-					}
-				}
-			}
-			else
-			{
-				if (  (mType->mType == LST_STRING)
-					||(mType->mType == LST_KEY))
-				{
-					// string and keys (even empty ones) need heap entries
-					chunk->addInteger(heap->mCurrentOffset + 1);
-					LLScriptLibData *data = new LLScriptLibData("");
-					U8 *temp;
-					S32 size = lsa_create_data_block(&temp, data, heap->mCurrentOffset);
-
-					heap->addBytes(temp, size);
-					delete [] temp;
-					delete data;
-				}
-				else if (mType->mType == LST_LIST)
-				{
-					chunk->addInteger(heap->mCurrentOffset + 1);
-					LLScriptLibData *data = new LLScriptLibData;
-					data->mType = LST_LIST;
-					U8 *temp;
-					S32 size = lsa_create_data_block(&temp, data, heap->mCurrentOffset);
-
-					heap->addBytes(temp, size);
-					delete [] temp;
-					delete data;
-				}
-				else if (mType->mType == LST_QUATERNION)
-				{
-					chunk->addFloat(1.f);
-					chunk->addFloat(0.f);
-					chunk->addFloat(0.f);
-					chunk->addFloat(0.f);
-				}
-				else
-				{
-					value->addBytes(LSCRIPTDataSize[mType->mType]);
-				}
-			}
-			chunk->addBytes(value->mCodeChunk, value->mCurrentOffset);
-			delete value;
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-
-		// Initialisation inside ctor.
-		fprintf(fp, "ldarg.0\n");
-		if (mAssignable)
-		{
-			// Initialise to value.
-			mAssignable->recurse(fp, tabs, tabsize, LSCP_EMIT_CIL_ASSEMBLY,
-								 ptype, prunearg, scope, type, basetype,
-								 count, chunk, heap, stacksize, entry,
-								 entrycount, NULL);
-			print_cil_assignment_cast(fp, get_type(mAssignable), mType->mType);
-		}
-		else
-		{
-			// Initialise to zero.
-			print_cil_init_variable(fp, mType->mType);
-		}
-		// Store value.
-		fprintf(fp, "stfld ");
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp," %s::", gScriptp->getClassName());
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "\n");
-		break;
-	default:
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mAssignable)
-		{
-			mAssignable->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptGlobalVariable::getSize()
-{
-	S32 return_size;
-
-	return_size = mType->getSize();
-	return return_size;
-}
-
-void LLScriptEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	fprintf(fp, "Event Base Class -- should never get here!\n");
-}
-
-S32 LLScriptEvent::getSize()
-{
-	printf("Event Base Class -- should never get here!\n");
-	return 0;
-}
-static void checkForDuplicateHandler(LLFILE *fp, LLScriptFilePosition *pos, 
-				     LLScriptScope *scope,
-				     const char* name)
-{
-    LLScriptScope *parent = scope->mParentScope;
-    if (parent->checkEntry((char*)name))
-    {
-        gErrorToText.writeError(fp, pos, LSERROR_DUPLICATE_NAME);
-    }
-    else
-    {
-        parent->addEntry(((char*)name), LIT_HANDLER, LST_NULL);
-    }
-}
-
-void LLScriptStateEntryEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "state_entry()\n");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "state_entry()\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	        checkForDuplicateHandler(fp, this, scope, "state_entry");
-	        break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "state_entry";
-			chunk->addBytes(name, strlen(name) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "state_entry()");
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptStateEntryEvent::getSize()
-{
-	return 0;
-}
-
-void LLScriptStateExitEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "state_exit()\n");
-		break;
-        case LSCP_SCOPE_PASS1:
-                checkForDuplicateHandler(fp, this, scope, "state_exit");
-	        break;
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "state_exit()\n");
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "state_exit";
-			chunk->addBytes(name, strlen(name) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "state_exit()");
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptStateExitEvent::getSize()
-{
-	return 0;
-}
-
-void LLScriptTouchStartEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "touch_start( integer ");
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-		break;
-	case LSCP_SCOPE_PASS1:
-	        checkForDuplicateHandler(fp, this, scope, "touch_start");
-		if (scope->checkEntry(mCount->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mCount->mScopeEntry = scope->addEntry(mCount->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mCount->mScopeEntry)
-			{
-				mCount->mScopeEntry->mOffset = (S32)count;
-				mCount->mScopeEntry->mSize = 4;
-				count += mCount->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "touch_start";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mCount->mName, strlen(mCount->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "touch_start( int32 ");
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-		break;
-	default:
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptTouchStartEvent::getSize()
-{
-	// integer = 4
-	return 4;
-}
-
-void LLScriptTouchEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "touch( integer ");
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-		break;
-	case LSCP_SCOPE_PASS1:
-	        checkForDuplicateHandler(fp, this, scope, "touch");
-		if (scope->checkEntry(mCount->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mCount->mScopeEntry = scope->addEntry(mCount->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mCount->mScopeEntry)
-			{
-				mCount->mScopeEntry->mOffset = (S32)count;
-				mCount->mScopeEntry->mSize = 4;
-				count += mCount->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "touch";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mCount->mName, strlen(mCount->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "touch( int32 ");
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-		break;
-	default:
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptTouchEvent::getSize()
-{
-	// integer = 4
-	return 4;
-}
-
-void LLScriptTouchEndEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "touch_end( integer ");
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-		break;
-	case LSCP_SCOPE_PASS1:
-	        checkForDuplicateHandler(fp, this, scope, "touch_end");
-		if (scope->checkEntry(mCount->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mCount->mScopeEntry = scope->addEntry(mCount->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mCount->mScopeEntry)
-			{
-				mCount->mScopeEntry->mOffset = (S32)count;
-				mCount->mScopeEntry->mSize = 4;
-				count += mCount->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "touch_end";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mCount->mName, strlen(mCount->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "touch_end( int32 ");
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-		break;
-	default:
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptTouchEndEvent::getSize()
-{
-	// integer = 4
-	return 4;
-}
-
-void LLScriptCollisionStartEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "collision_start( integer ");
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-		break;
-	case LSCP_SCOPE_PASS1:
-	        checkForDuplicateHandler(fp, this, scope, "collision_start");
-		if (scope->checkEntry(mCount->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mCount->mScopeEntry = scope->addEntry(mCount->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mCount->mScopeEntry)
-			{
-				mCount->mScopeEntry->mOffset = (S32)count;
-				mCount->mScopeEntry->mSize = 4;
-				count += mCount->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "collision_start";
-			chunk->addBytes(name, (S32)strlen(name) + 1);
-			chunk->addBytes(mCount->mName, (S32)strlen(mCount->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "collision_start( int32 ");
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptCollisionStartEvent::getSize()
-{
-	// integer = 4
-	return 4;
-}
-
-void LLScriptCollisionEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "collision( integer ");
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-		break;
-	case LSCP_SCOPE_PASS1:
-	        checkForDuplicateHandler(fp, this, scope, "collision");
-		if (scope->checkEntry(mCount->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mCount->mScopeEntry = scope->addEntry(mCount->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mCount->mScopeEntry)
-			{
-				mCount->mScopeEntry->mOffset = (S32)count;
-				mCount->mScopeEntry->mSize = 4;
-				count += mCount->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "collision";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mCount->mName, strlen(mCount->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "collision( int32 ");
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptCollisionEvent::getSize()
-{
-	// integer = 4
-	return 4;
-}
-
-void LLScriptCollisionEndEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "collision_end( integer ");
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "collision_end");
-		if (scope->checkEntry(mCount->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mCount->mScopeEntry = scope->addEntry(mCount->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mCount->mScopeEntry)
-			{
-				mCount->mScopeEntry->mOffset = (S32)count;
-				mCount->mScopeEntry->mSize = 4;
-				count += mCount->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "collision_end";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mCount->mName, strlen(mCount->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "collision_end( int32 ");
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mCount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptCollisionEndEvent::getSize()
-{
-	// integer = 4
-	return 4;
-}
-
-void LLScriptLandCollisionStartEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "land_collision_start( vector ");
-		mPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "land_collision_start");
-		if (scope->checkEntry(mPosition->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mPosition->mScopeEntry = scope->addEntry(mPosition->mName, LIT_VARIABLE, LST_VECTOR);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mPosition->mScopeEntry)
-			{
-				mPosition->mScopeEntry->mOffset = (S32)count;
-				mPosition->mScopeEntry->mSize = 12;
-				count += mPosition->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "land_collision_start";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mPosition->mName, strlen(mPosition->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "land_collision_start( class [ScriptTypes]LindenLab.SecondLife.Vector ");
-		mPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptLandCollisionStartEvent::getSize()
-{
-	// vector = 12
-	return 12;
-}
-
-
-
-void LLScriptLandCollisionEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "land_collision( vector ");
-		mPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "land_collision");
-		if (scope->checkEntry(mPosition->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mPosition->mScopeEntry = scope->addEntry(mPosition->mName, LIT_VARIABLE, LST_VECTOR);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mPosition->mScopeEntry)
-			{
-				mPosition->mScopeEntry->mOffset = (S32)count;
-				mPosition->mScopeEntry->mSize = 12;
-				count += mPosition->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "land_collision";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mPosition->mName, strlen(mPosition->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "land_collision( class [ScriptTypes]LindenLab.SecondLife.Vector ");
-		mPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptLandCollisionEvent::getSize()
-{
-	// vector = 12
-	return 12;
-}
-
-
-void LLScriptLandCollisionEndEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "land_collision_end( vector ");
-		mPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "land_collision_end");
-		if (scope->checkEntry(mPosition->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mPosition->mScopeEntry = scope->addEntry(mPosition->mName, LIT_VARIABLE, LST_VECTOR);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mPosition->mScopeEntry)
-			{
-				mPosition->mScopeEntry->mOffset = (S32)count;
-				mPosition->mScopeEntry->mSize = 12;
-				count += mPosition->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "land_collision_end";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mPosition->mName, strlen(mPosition->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "land_collision_end( class [ScriptTypes]LindenLab.SecondLife.Vector ");
-		mPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptLandCollisionEndEvent::getSize()
-{
-	// vector = 12
-	return 12;
-}
-
-
-void LLScriptInventoryEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "changed( integer ");
-		mChange->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "changed");
-		if (scope->checkEntry(mChange->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mChange->mScopeEntry = scope->addEntry(mChange->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mChange->mScopeEntry)
-			{
-				mChange->mScopeEntry->mOffset = (S32)count;
-				mChange->mScopeEntry->mSize = 4;
-				count += mChange->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "changed";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mChange->mName, strlen(mChange->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "changed( int32 ");
-		mChange->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mChange->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptInventoryEvent::getSize()
-{
-	// integer = 4
-	return 4;
-}
-
-void LLScriptAttachEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "attach( key ");
-		mAttach->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "attach");
-		if (scope->checkEntry(mAttach->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mAttach->mScopeEntry = scope->addEntry(mAttach->mName, LIT_VARIABLE, LST_KEY);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mAttach->mScopeEntry)
-			{
-				mAttach->mScopeEntry->mOffset = (S32)count;
-				mAttach->mScopeEntry->mSize = 4;
-				count += mAttach->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "attach";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mAttach->mName, strlen(mAttach->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "attach( valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
-		mAttach->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	default:
-		mAttach->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptAttachEvent::getSize()
-{
-	// key = 4
-	return 4;
-}
-
-void LLScriptDataserverEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "dataserver( key ");
-		mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mData->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "dataserver");
-		if (scope->checkEntry(mID->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mID->mScopeEntry = scope->addEntry(mID->mName, LIT_VARIABLE, LST_KEY);
-		}
-		if (scope->checkEntry(mData->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mData->mScopeEntry = scope->addEntry(mData->mName, LIT_VARIABLE, LST_STRING);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mID->mScopeEntry)
-			{
-				mID->mScopeEntry->mOffset = (S32)count;
-				mID->mScopeEntry->mSize = 4;
-				count += mID->mScopeEntry->mSize;
-				mData->mScopeEntry->mOffset = (S32)count;
-				mData->mScopeEntry->mSize = 4;
-				count += mData->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "dataserver";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mID->mName, strlen(mID->mName) + 1);
-			chunk->addBytes(mData->mName, strlen(mData->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "dataserver( valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
-		mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mData->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mData->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptDataserverEvent::getSize()
-{
-	// key + string = 8
-	return 8;
-}
-
-void LLScriptTimerEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "timer()\n");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "timer()\n");
-		break;
-        case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "timer");
-	  break;
-
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "timer";
-			chunk->addBytes(name, strlen(name) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "timer()");
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptTimerEvent::getSize()
-{
-	return 0;
-}
-
-void LLScriptMovingStartEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "moving_start()\n");
-		break;
-        case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "moving_start");
-	  break;
-
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "moving_start";
-			chunk->addBytes(name, strlen(name) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "moving_start()");
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptMovingStartEvent::getSize()
-{
-	return 0;
-}
-
-void LLScriptMovingEndEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "moving_end()\n");
-		break;
-        case LSCP_SCOPE_PASS1:
-          checkForDuplicateHandler(fp, this, scope, "moving_end");
-          break;
-
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "moving_end";
-			chunk->addBytes(name, strlen(name) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "moving_end()");
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptMovingEndEvent::getSize()
-{
-	return 0;
-}
-
-void LLScriptRTPEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "chat( integer ");
-		mRTPermissions->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "run_time_perms");
-		if (scope->checkEntry(mRTPermissions->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mRTPermissions->mScopeEntry = scope->addEntry(mRTPermissions->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mRTPermissions->mScopeEntry)
-			{
-				mRTPermissions->mScopeEntry->mOffset = (S32)count;
-				mRTPermissions->mScopeEntry->mSize = 4;
-				count += mRTPermissions->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "chat";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mRTPermissions->mName, strlen(mRTPermissions->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		// NOTE: Not replicating LSL2 bug by calling RTP event hander "chat"
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "run_time_perms( int32 ");
-		mRTPermissions->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mRTPermissions->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptRTPEvent::getSize()
-{
-	// integer = 4
-	return 4;
-}
-
-void LLScriptChatEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "chat( integer ");
-		mChannel->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", key ");
-		mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mMessage->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-		checkForDuplicateHandler(fp, this, scope, "listen"); // note: this is actually listen in lsl source
-		if (scope->checkEntry(mChannel->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mChannel->mScopeEntry = scope->addEntry(mChannel->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		if (scope->checkEntry(mName->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mName->mScopeEntry = scope->addEntry(mName->mName, LIT_VARIABLE, LST_STRING);
-		}
-		if (scope->checkEntry(mID->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mID->mScopeEntry = scope->addEntry(mID->mName, LIT_VARIABLE, LST_KEY);
-		}
-		if (scope->checkEntry(mMessage->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mMessage->mScopeEntry = scope->addEntry(mMessage->mName, LIT_VARIABLE, LST_STRING);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mName->mScopeEntry)
-			{
-				mChannel->mScopeEntry->mOffset = (S32)count;
-				mChannel->mScopeEntry->mSize = 4;
-				count += mChannel->mScopeEntry->mSize;
-				mName->mScopeEntry->mOffset = (S32)count;
-				mName->mScopeEntry->mSize = 4;
-				count += mName->mScopeEntry->mSize;
-				mID->mScopeEntry->mOffset = (S32)count;
-				mID->mScopeEntry->mSize = 4;
-				count += mID->mScopeEntry->mSize;
-				mMessage->mScopeEntry->mOffset = (S32)count;
-				mMessage->mScopeEntry->mSize = 4;
-				count += mMessage->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "chat";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mChannel->mName, strlen(mChannel->mName) + 1);
-			chunk->addBytes(mName->mName, strlen(mName->mName) + 1);
-			chunk->addBytes(mID->mName, strlen(mID->mName) + 1);
-			chunk->addBytes(mMessage->mName, strlen(mMessage->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "chat( int32 ");
-		mChannel->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
-		mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mMessage->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mChannel->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mMessage->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptChatEvent::getSize()
-{
-	// integer + key + string + string = 16
-	return 16;
-}
-
-void LLScriptSensorEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "sensor( integer ");
-		mNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "sensor");
-		if (scope->checkEntry(mNumber->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mNumber->mScopeEntry = scope->addEntry(mNumber->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mNumber->mScopeEntry)
-			{
-				mNumber->mScopeEntry->mOffset = (S32)count;
-				mNumber->mScopeEntry->mSize = 4;
-				count += mNumber->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "sensor";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mNumber->mName, strlen(mNumber->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "sensor( int32 ");
-		mNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptSensorEvent::getSize()
-{
-	// integer = 4
-	return 4;
-}
-
-void LLScriptObjectRezEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "object_rez( key ");
-		mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "object_rez");
-		if (scope->checkEntry(mID->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mID->mScopeEntry = scope->addEntry(mID->mName, LIT_VARIABLE, LST_KEY);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mID->mScopeEntry)
-			{
-				mID->mScopeEntry->mOffset = (S32)count;
-				mID->mScopeEntry->mSize = 4;
-				count += mID->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "sensor";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mID->mName, strlen(mID->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "object_rez( valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
-		mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptObjectRezEvent::getSize()
-{
-	// key = 4
-	return 4;
-}
-
-void LLScriptControlEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "control( key ");
-		mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", integer ");
-		mLevels->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", integer ");
-		mEdges->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "control");
-		if (scope->checkEntry(mName->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mName->mScopeEntry = scope->addEntry(mName->mName, LIT_VARIABLE, LST_KEY);
-		}
-		if (scope->checkEntry(mLevels->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mLevels->mScopeEntry = scope->addEntry(mLevels->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		if (scope->checkEntry(mEdges->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mEdges->mScopeEntry = scope->addEntry(mEdges->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mName->mScopeEntry)
-			{
-				mName->mScopeEntry->mOffset = (S32)count;
-				mName->mScopeEntry->mSize = 4;
-				count += mName->mScopeEntry->mSize;
-				mLevels->mScopeEntry->mOffset = (S32)count;
-				mLevels->mScopeEntry->mSize = 4;
-				count += mLevels->mScopeEntry->mSize;
-				mEdges->mScopeEntry->mOffset = (S32)count;
-				mEdges->mScopeEntry->mSize = 4;
-				count += mEdges->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "control";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mName->mName, strlen(mName->mName) + 1);
-			chunk->addBytes(mLevels->mName, strlen(mLevels->mName) + 1);
-			chunk->addBytes(mEdges->mName, strlen(mEdges->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "control( valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
-		mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", int32 ");
-		mLevels->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", int32 ");
-		mEdges->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLevels->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mEdges->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptControlEvent::getSize()
-{
-	// key + integer + integer = 12
-	return 12;
-}
-
-void LLScriptLinkMessageEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "link_message( integer ");
-		mSender->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", integer ");
-		mNum->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mStr->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", key ");
-		mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "link_message");
-		if (scope->checkEntry(mSender->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mSender->mScopeEntry = scope->addEntry(mSender->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		if (scope->checkEntry(mNum->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mNum->mScopeEntry = scope->addEntry(mNum->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		if (scope->checkEntry(mStr->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mStr->mScopeEntry = scope->addEntry(mStr->mName, LIT_VARIABLE, LST_STRING);
-		}
-		if (scope->checkEntry(mID->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mID->mScopeEntry = scope->addEntry(mID->mName, LIT_VARIABLE, LST_KEY);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mSender->mScopeEntry)
-			{
-				mSender->mScopeEntry->mOffset = (S32)count;
-				mSender->mScopeEntry->mSize = 4;
-				count += mSender->mScopeEntry->mSize;
-				mNum->mScopeEntry->mOffset = (S32)count;
-				mNum->mScopeEntry->mSize = 4;
-				count += mNum->mScopeEntry->mSize;
-				mStr->mScopeEntry->mOffset = (S32)count;
-				mStr->mScopeEntry->mSize = 4;
-				count += mStr->mScopeEntry->mSize;
-				mID->mScopeEntry->mOffset = (S32)count;
-				mID->mScopeEntry->mSize = 4;
-				count += mID->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "link_message";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mSender->mName, strlen(mSender->mName) + 1);
-			chunk->addBytes(mNum->mName, strlen(mNum->mName) + 1);
-			chunk->addBytes(mStr->mName, strlen(mStr->mName) + 1);
-			chunk->addBytes(mID->mName, strlen(mID->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "link_message( int32 ");
-		mSender->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", int32 ");
-		mNum->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mStr->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
-		mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mSender->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mNum->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mStr->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptLinkMessageEvent::getSize()
-{
-	// integer + key + integer + string = 16
-	return 16;
-}
-
-void LLScriptRemoteEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "remote_event( integer ");
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", key ");
-		mChannel->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", key ");
-		mMessageID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mSender->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", integer ");
-		mIntVal->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mStrVal->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "remote_event");
-		if (scope->checkEntry(mType->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mType->mScopeEntry = scope->addEntry(mType->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		if (scope->checkEntry(mChannel->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mChannel->mScopeEntry = scope->addEntry(mChannel->mName, LIT_VARIABLE, LST_KEY);
-		}
-		if (scope->checkEntry(mMessageID->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mMessageID->mScopeEntry = scope->addEntry(mMessageID->mName, LIT_VARIABLE, LST_KEY);
-		}
-		if (scope->checkEntry(mSender->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mSender->mScopeEntry = scope->addEntry(mSender->mName, LIT_VARIABLE, LST_STRING);
-		}
-		if (scope->checkEntry(mIntVal->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mIntVal->mScopeEntry = scope->addEntry(mIntVal->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		if (scope->checkEntry(mStrVal->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mStrVal->mScopeEntry = scope->addEntry(mStrVal->mName, LIT_VARIABLE, LST_STRING);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mType->mScopeEntry)
-			{
-				mType->mScopeEntry->mOffset = (S32)count;
-				mType->mScopeEntry->mSize = 4;
-				count += mType->mScopeEntry->mSize;
-				mChannel->mScopeEntry->mOffset = (S32)count;
-				mChannel->mScopeEntry->mSize = 4;
-				count += mChannel->mScopeEntry->mSize;
-				mMessageID->mScopeEntry->mOffset = (S32)count;
-				mMessageID->mScopeEntry->mSize = 4;
-				count += mMessageID->mScopeEntry->mSize;
-				mSender->mScopeEntry->mOffset = (S32)count;
-				mSender->mScopeEntry->mSize = 4;
-				count += mSender->mScopeEntry->mSize;
-				mIntVal->mScopeEntry->mOffset = (S32)count;
-				mIntVal->mScopeEntry->mSize = 4;
-				count += mIntVal->mScopeEntry->mSize;
-				mStrVal->mScopeEntry->mOffset = (S32)count;
-				mStrVal->mScopeEntry->mSize = 4;
-				count += mStrVal->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "remote_event";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mType->mName, strlen(mType->mName) + 1);
-			chunk->addBytes(mChannel->mName, strlen(mChannel->mName) + 1);
-			chunk->addBytes(mMessageID->mName, strlen(mMessageID->mName) + 1);
-			chunk->addBytes(mSender->mName, strlen(mSender->mName) + 1);
-			chunk->addBytes(mIntVal->mName, strlen(mIntVal->mName) + 1);
-			chunk->addBytes(mStrVal->mName, strlen(mStrVal->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "remote_event( int32 ");
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
-		mChannel->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
-		mMessageID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mSender->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", int32 ");
-		mIntVal->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mStrVal->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mChannel->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mMessageID->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mSender->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mIntVal->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mStrVal->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptRemoteEvent::getSize()
-{
-	// integer + key + key + string + integer + string = 24
-	return 24;
-}
-
-void LLScriptHTTPResponseEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "http_response( key ");
-		mRequestId->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", integer ");
-		mStatus->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", class [mscorlib]System.Collections.ArrayList ");
-		mMetadata->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-		
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "http_response");
-		if (scope->checkEntry(mRequestId->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mRequestId->mScopeEntry = scope->addEntry(mRequestId->mName, LIT_VARIABLE, LST_KEY);
-		}
-		
-		if (scope->checkEntry(mStatus->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mStatus->mScopeEntry = scope->addEntry(mStatus->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		
-		if (scope->checkEntry(mMetadata->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mMetadata->mScopeEntry = scope->addEntry(mMetadata->mName, LIT_VARIABLE, LST_LIST);
-		}
-		
-		if (scope->checkEntry(mBody->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mBody->mScopeEntry = scope->addEntry(mBody->mName, LIT_VARIABLE, LST_STRING);
-		}
-		break;
-		
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mRequestId->mScopeEntry)
-			{
-				mRequestId->mScopeEntry->mOffset = (S32)count;
-				mRequestId->mScopeEntry->mSize = 4;
-				count += mRequestId->mScopeEntry->mSize;
-
-				mStatus->mScopeEntry->mOffset = (S32)count;
-				mStatus->mScopeEntry->mSize = 4;
-				count += mStatus->mScopeEntry->mSize;
-
-				mMetadata->mScopeEntry->mOffset = (S32)count;
-				mMetadata->mScopeEntry->mSize = 4;
-				count += mMetadata->mScopeEntry->mSize;
-
-				mBody->mScopeEntry->mOffset = (S32)count;
-				mBody->mScopeEntry->mSize = 4;
-				count += mBody->mScopeEntry->mSize;
-			}
-		}
-		break;
-		
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "http_response";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mRequestId->mName, strlen(mRequestId->mName) + 1);
-			chunk->addBytes(mStatus->mName, strlen(mStatus->mName) + 1);
-			chunk->addBytes(mMetadata->mName, strlen(mMetadata->mName) + 1);
-			chunk->addBytes(mBody->mName, strlen(mBody->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-	        fdotabs(fp, tabs, tabsize);
-   	        fprintf(fp, "http_response( valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
-		mRequestId->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", int32 ");
-		mStatus->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", class [mscorlib]System.Collections.ArrayList ");
-		mMetadata->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	default:
-		mRequestId->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mStatus->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mMetadata->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptHTTPResponseEvent::getSize()
-{
-	// key + integer + list + string = 16
-	return 16;
-}
-
-void LLScriptHTTPRequestEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "http_request( key ");
-		mRequestId->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mMethod->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-		
-	case LSCP_SCOPE_PASS1:
-		checkForDuplicateHandler(fp, this, scope, "http_request");
-		if (scope->checkEntry(mRequestId->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mRequestId->mScopeEntry = scope->addEntry(mRequestId->mName, LIT_VARIABLE, LST_KEY);
-		}
-
-		if (scope->checkEntry(mMethod->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mMethod->mScopeEntry = scope->addEntry(mMethod->mName, LIT_VARIABLE, LST_STRING);
-		}
-		
-		if (scope->checkEntry(mBody->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mBody->mScopeEntry = scope->addEntry(mBody->mName, LIT_VARIABLE, LST_STRING);
-		}
-		break;
-		
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mRequestId->mScopeEntry)
-			{
-				mRequestId->mScopeEntry->mOffset = (S32)count;
-				mRequestId->mScopeEntry->mSize = 4;
-				count += mRequestId->mScopeEntry->mSize;
-
-				mMethod->mScopeEntry->mOffset = (S32)count;
-				mMethod->mScopeEntry->mSize = 4;
-				count += mMethod->mScopeEntry->mSize;
-
-				mBody->mScopeEntry->mOffset = (S32)count;
-				mBody->mScopeEntry->mSize = 4;
-				count += mBody->mScopeEntry->mSize;
-			}
-		}
-		break;
-		
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "http_request";
-			chunk->addBytes(name, strlen(name) + 1); 		/*Flawfinder: ignore*/
-			chunk->addBytes(mRequestId->mName, strlen(mRequestId->mName) + 1); 		/*Flawfinder: ignore*/
-			chunk->addBytes(mMethod->mName, strlen(mMethod->mName) + 1); 		/*Flawfinder: ignore*/
-			chunk->addBytes(mBody->mName, strlen(mBody->mName) + 1); 		/*Flawfinder: ignore*/
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-	        fdotabs(fp, tabs, tabsize);
-   	        fprintf(fp, "http_request( valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
-		mRequestId->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mMethod->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	default:
-		mRequestId->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mMethod->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptHTTPRequestEvent::getSize()
-{
-	// key + string + string = 12
-	return 12;
-}
-
-void LLScriptMoneyEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "money( key ");
-		mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", integer ");
-		mAmount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "money");
-		if (scope->checkEntry(mName->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mName->mScopeEntry = scope->addEntry(mName->mName, LIT_VARIABLE, LST_KEY);
-		}
-		if (scope->checkEntry(mAmount->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mAmount->mScopeEntry = scope->addEntry(mAmount->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mName->mScopeEntry)
-			{
-				mName->mScopeEntry->mOffset = (S32)count;
-				mName->mScopeEntry->mSize = 4;
-				count += mName->mScopeEntry->mSize;
-				mAmount->mScopeEntry->mOffset = (S32)count;
-				mAmount->mScopeEntry->mSize = 4;
-				count += mAmount->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "money";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mName->mName, strlen(mName->mName) + 1);
-			chunk->addBytes(mAmount->mName, strlen(mAmount->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "money( valuetype [ScriptTypes]LindenLab.SecondLife.Key ");
-		mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", int32 ");
-		mAmount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mName->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mAmount->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptMoneyEvent::getSize()
-{
-	// key + integer = 8
-	return 8;
-}
-
-void LLScriptEmailEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "email( string ");
-		mTime->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mAddress->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mSubject->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", integer ");
-		mNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "email");
-		if (scope->checkEntry(mTime->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mTime->mScopeEntry = scope->addEntry(mTime->mName, LIT_VARIABLE, LST_STRING);
-		}
-		if (scope->checkEntry(mAddress->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mAddress->mScopeEntry = scope->addEntry(mAddress->mName, LIT_VARIABLE, LST_STRING);
-		}
-		if (scope->checkEntry(mSubject->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mSubject->mScopeEntry = scope->addEntry(mSubject->mName, LIT_VARIABLE, LST_STRING);
-		}
-		if (scope->checkEntry(mBody->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mBody->mScopeEntry = scope->addEntry(mBody->mName, LIT_VARIABLE, LST_STRING);
-		}
-		if (scope->checkEntry(mNumber->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mNumber->mScopeEntry = scope->addEntry(mNumber->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mAddress->mScopeEntry)
-			{
-				mTime->mScopeEntry->mOffset = (S32)count;
-				mTime->mScopeEntry->mSize = 4;
-				count += mTime->mScopeEntry->mSize;
-				mAddress->mScopeEntry->mOffset = (S32)count;
-				mAddress->mScopeEntry->mSize = 4;
-				count += mAddress->mScopeEntry->mSize;
-				mSubject->mScopeEntry->mOffset = (S32)count;
-				mSubject->mScopeEntry->mSize = 4;
-				count += mSubject->mScopeEntry->mSize;
-				mBody->mScopeEntry->mOffset = (S32)count;
-				mBody->mScopeEntry->mSize = 4;
-				count += mBody->mScopeEntry->mSize;
-				mNumber->mScopeEntry->mOffset = (S32)count;
-				mNumber->mScopeEntry->mSize = 4;
-				count += mNumber->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "email";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mTime->mName, strlen(mTime->mName) + 1);
-			chunk->addBytes(mAddress->mName, strlen(mAddress->mName) + 1);
-			chunk->addBytes(mSubject->mName, strlen(mSubject->mName) + 1);
-			chunk->addBytes(mBody->mName, strlen(mBody->mName) + 1);
-			chunk->addBytes(mNumber->mName, strlen(mNumber->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "email( string ");
-		mTime->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mAddress->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mSubject->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", string ");
-		mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", int32 ");
-		mNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mTime->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mAddress->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mSubject->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mBody->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptEmailEvent::getSize()
-{
-	// string + string + string + string + integer = 16
-	return 20;
-}
-
-void LLScriptRezEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "rez( integer ");
-		mStartParam->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-		checkForDuplicateHandler(fp, this, scope, "on_rez");
-		if (scope->checkEntry(mStartParam->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mStartParam->mScopeEntry = scope->addEntry(mStartParam->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mStartParam->mScopeEntry)
-			{
-				mStartParam->mScopeEntry->mOffset = (S32)count;
-				mStartParam->mScopeEntry->mSize = 4;
-				count += mStartParam->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "rez";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mStartParam->mName, strlen(mStartParam->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "rez( int32 ");
-		mStartParam->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mStartParam->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptRezEvent::getSize()
-{
-	// integer = 4
-	return 4;
-}
-
-void LLScriptNoSensorEvent::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "no_sensor()\n");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "no_sensor()\n");
-		break;
-        case LSCP_SCOPE_PASS1:
-     	        checkForDuplicateHandler(fp, this, scope, "no_sensor");
-	        break;
-  	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "no_sensor";
-			chunk->addBytes(name, strlen(name) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "no_sensor()");
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptNoSensorEvent::getSize()
-{
-	return 0;
-}
-
-void LLScriptAtTarget::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "at_target( integer ");
-		mTargetNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", vector ");
-		mTargetPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", vector ");
-		mOurPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-	        checkForDuplicateHandler(fp, this, scope, "at_target");
-		if (scope->checkEntry(mTargetNumber->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mTargetNumber->mScopeEntry = scope->addEntry(mTargetNumber->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		if (scope->checkEntry(mTargetPosition->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mTargetPosition->mScopeEntry = scope->addEntry(mTargetPosition->mName, LIT_VARIABLE, LST_VECTOR);
-		}
-		if (scope->checkEntry(mOurPosition->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mOurPosition->mScopeEntry = scope->addEntry(mOurPosition->mName, LIT_VARIABLE, LST_VECTOR);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mTargetNumber->mScopeEntry)
-			{
-				mTargetNumber->mScopeEntry->mOffset = (S32)count;
-				mTargetNumber->mScopeEntry->mSize = 4;
-				count += mTargetNumber->mScopeEntry->mSize;
-				mTargetPosition->mScopeEntry->mOffset = (S32)count;
-				mTargetPosition->mScopeEntry->mSize = 12;
-				count += mTargetPosition->mScopeEntry->mSize;
-				mOurPosition->mScopeEntry->mOffset = (S32)count;
-				mOurPosition->mScopeEntry->mSize = 12;
-				count += mOurPosition->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "at_target";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mTargetNumber->mName, strlen(mTargetNumber->mName) + 1);
-			chunk->addBytes(mTargetPosition->mName, strlen(mTargetPosition->mName) + 1);
-			chunk->addBytes(mOurPosition->mName, strlen(mOurPosition->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "at_target( int32 ");
-		mTargetNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", class [ScriptTypes]LindenLab.SecondLife.Vector ");
-		mTargetPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", class [ScriptTypes]LindenLab.SecondLife.Vector ");
-		mOurPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mTargetNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mTargetPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mOurPosition->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptAtTarget::getSize()
-{
-	// integer + vector + vector = 28
-	return 28;
-}
-
-
-
-void LLScriptNotAtTarget::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "not_at_target()\n");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "not_at_target()\n");
-		break;
-        case LSCP_SCOPE_PASS1:
-	        checkForDuplicateHandler(fp, this, scope, "not_at_target");
-	        break;
-
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "not_at_target";
-			chunk->addBytes(name, strlen(name) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "not_at_target()");
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptNotAtTarget::getSize()
-{
-	return 0;
-}
-
-void LLScriptAtRotTarget::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-	case LSCP_EMIT_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "at_rot_target( integer ");
-		mTargetNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", quaternion ");
-		mTargetRotation->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", quaternion ");
-		mOurRotation->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-		checkForDuplicateHandler(fp, this, scope, "at_rot_target");
-		if (scope->checkEntry(mTargetNumber->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mTargetNumber->mScopeEntry = scope->addEntry(mTargetNumber->mName, LIT_VARIABLE, LST_INTEGER);
-		}
-		if (scope->checkEntry(mTargetRotation->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mTargetRotation->mScopeEntry = scope->addEntry(mTargetRotation->mName, LIT_VARIABLE, LST_QUATERNION);
-		}
-		if (scope->checkEntry(mOurRotation->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mOurRotation->mScopeEntry = scope->addEntry(mOurRotation->mName, LIT_VARIABLE, LST_QUATERNION);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			if (mTargetNumber->mScopeEntry)
-			{
-				mTargetNumber->mScopeEntry->mOffset = (S32)count;
-				mTargetNumber->mScopeEntry->mSize = 4;
-				count += mTargetNumber->mScopeEntry->mSize;
-				mTargetRotation->mScopeEntry->mOffset = (S32)count;
-				mTargetRotation->mScopeEntry->mSize = 16;
-				count += mTargetRotation->mScopeEntry->mSize;
-				mOurRotation->mScopeEntry->mOffset = (S32)count;
-				mOurRotation->mScopeEntry->mSize = 16;
-				count += mOurRotation->mScopeEntry->mSize;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "at_rot_target";
-			chunk->addBytes(name, strlen(name) + 1);
-			chunk->addBytes(mTargetNumber->mName, strlen(mTargetNumber->mName) + 1);
-			chunk->addBytes(mTargetRotation->mName, strlen(mTargetRotation->mName) + 1);
-			chunk->addBytes(mOurRotation->mName, strlen(mOurRotation->mName) + 1);
-#endif
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "at_rot_target( int32 ");
-		mTargetNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", class [ScriptTypes]LindenLab.SecondLife.Quaternion ");
-		mTargetRotation->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", class [ScriptTypes]LindenLab.SecondLife.Quaternion ");
-		mOurRotation->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	default:
-		mTargetNumber->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mTargetRotation->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mOurRotation->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
-
-S32 LLScriptAtRotTarget::getSize()
-{
-	// integer + quaternion + quaternion = 36
-	return 36;
-}
-
-
-
-void LLScriptNotAtRotTarget::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "not_at_rot_target()\n");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "not_at_rot_target()\n");
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			char name[] = "not_at_rot_target";
-			chunk->addBytes(name, strlen(name) + 1);
-#endif
-		}
-		break;
-        case LSCP_SCOPE_PASS1:
-	  checkForDuplicateHandler(fp, this, scope, "not_at_rot_target");
-	  break;
-
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "not_at_rot_target()");
-		break;
-	default:
-		break;
-	}
-}
-
-S32 LLScriptNotAtRotTarget::getSize()
-{
-	return 0;
-}
-
-
-
-void LLScriptExpression::addExpression(LLScriptExpression *expression)
-{
-	if (mNextp)
-	{
-		expression->mNextp = mNextp;
-	}
-	mNextp = expression;
-}
-
-void LLScriptExpression::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	fprintf(fp, "Expression Base Class -- should never get here!\n");
-}
-
-S32 LLScriptExpression::getSize()
-{
-	printf("Expression Base Class -- should never get here!\n");
-	return 0;
-}
-
-void LLScriptExpression::gonext(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		if (mNextp)
-		{
-			fprintf(fp, ", ");
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	default:
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-void LLScriptForExpressionList::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mSecondp)
-		{
-			fprintf(fp, ", ");
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mFirstp->mReturnType)
-		{
-			fprintf(fp, "%s\n", LSCRIPTTypePop[mFirstp->mReturnType]);
-		}
-		if (mSecondp)
-		{
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mSecondp->mReturnType)
-			{
-				fprintf(fp, "%s\n", LSCRIPTTypePop[mSecondp->mReturnType]);
-			}
-		}
-		break;
-	case LSCP_TO_STACK:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		switch(mFirstp->mReturnType)
-		{
-		case LST_INTEGER:
-		case LST_FLOATINGPOINT:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
-			break;
-		case LST_STRING:
-		case LST_KEY:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_POPS]);
-			break;
-		case LST_LIST:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_POPL]);
-			break;
-		case LST_VECTOR:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_POPV]);
-			break;
-		case LST_QUATERNION:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_POPQ]);
-			break;
-		default:
-			break;
-		}
-		if (mSecondp)
-		{
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			switch(mSecondp->mReturnType)
-			{
-			case LST_INTEGER:
-			case LST_FLOATINGPOINT:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
-				break;
-			case LST_STRING:
-			case LST_KEY:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_POPS]);
-				break;
-			case LST_LIST:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPL]);
-				break;
-			case LST_VECTOR:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPV]);
-				break;
-			case LST_QUATERNION:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPQ]);
-				break;
-			default:
-				break;
-			}
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mFirstp->mReturnType)
-		{
-			fprintf(fp, "pop\n");
-		}
-		if (mSecondp)
-		{
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mSecondp->mReturnType)
-			{
-				fprintf(fp, "pop\n");
-			}
-		}
-		break;
-	default:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mSecondp)
-		{
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-S32 LLScriptForExpressionList::getSize()
-{
-	return 0;
-}
-
-// CIL code generation requires both caller and callee scope entries, so cannot use normal recurse signature.
-// TODO: Refactor general purpose recurse calls in to pass specific virtuals using visitor pattern to select method by pass and node type.
-static void print_cil_func_expression_list(LLScriptFuncExpressionList* self, LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata, LLScriptScopeEntry *callee_entry)
-{
-	self->mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-	LSCRIPTType argtype = callee_entry->mFunctionArgs.getType(entrycount);
-	if (argtype != self->mFirstp->mReturnType)
-	{
-		print_cil_cast(fp, self->mFirstp->mReturnType, argtype);
-	}
-	entrycount++;
-	if (self->mSecondp)
-	{
-		llassert(LET_FUNC_EXPRESSION_LIST == self->mSecondp->mType);
-		print_cil_func_expression_list((LLScriptFuncExpressionList*) self->mSecondp, fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL, callee_entry);
-
-	}
-}
-
-void LLScriptFuncExpressionList::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mSecondp)
-		{
-			fprintf(fp, ", ");
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_TYPE:
-		{
-			mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (!entry->mFunctionArgs.getType(entrycount))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_FUNCTION_TYPE_ERROR);
-			}
-			if (!legal_assignment(entry->mFunctionArgs.getType(entrycount), mFirstp->mReturnType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_FUNCTION_TYPE_ERROR);
-			}
-			count++;
-			entrycount++;
-			if (mSecondp)
-			{
-				mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				if (mSecondp->mReturnType)
-				{
-					count++;
-					if (!entry->mFunctionArgs.getType(entrycount))
-					{
-						gErrorToText.writeError(fp, this, LSERROR_FUNCTION_TYPE_ERROR);
-					}
-					if (!legal_assignment(entry->mFunctionArgs.getType(entrycount), mSecondp->mReturnType))
-					{
-						gErrorToText.writeError(fp, this, LSERROR_FUNCTION_TYPE_ERROR);
-					}
-				}
-			}
-		}
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			LSCRIPTType argtype = entry->mFunctionArgs.getType(entrycount);
-			if (argtype != mFirstp->mReturnType)
-			{
-				fprintf(fp, "CAST %s->%s\n", LSCRIPTTypeNames[mFirstp->mReturnType], LSCRIPTTypeNames[argtype]);
-			}
-			entrycount++;
-			if (mSecondp)
-			{
-				mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				if (mSecondp->mReturnType)
-				{
-					argtype = entry->mFunctionArgs.getType(entrycount);
-					if (argtype != mSecondp->mReturnType)
-					{
-						fprintf(fp, "CAST %s->%s\n", LSCRIPTTypeNames[mSecondp->mReturnType], LSCRIPTTypeNames[argtype]);
-					}
-				}
-			}
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			LSCRIPTType argtype = entry->mFunctionArgs.getType(entrycount);
-			if (argtype != mFirstp->mReturnType)
-			{
-				chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
-				U8 castbyte = LSCRIPTTypeByte[argtype] | LSCRIPTTypeHi4Bits[mFirstp->mReturnType];
-				chunk->addByte(castbyte);
-			}
-			entrycount++;
-			if (mSecondp)
-			{
-				mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				if (mSecondp->mReturnType)
-				{
-					argtype = entry->mFunctionArgs.getType(entrycount);
-					if (argtype != mSecondp->mReturnType)
-					{
-						chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
-						U8 castbyte = LSCRIPTTypeByte[argtype] | LSCRIPTTypeHi4Bits[mSecondp->mReturnType];
-						chunk->addByte(castbyte);
-					}
-				}
-			}
-		}
-		break;
-	default:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mSecondp)
-		{
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-S32 LLScriptFuncExpressionList::getSize()
-{
-	return 0;
-}
-
-void LLScriptListExpressionList::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mSecondp)
-		{
-			fprintf(fp, ", ");
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mFirstp->mType != LET_LIST_EXPRESSION_LIST)
-		{
-			fprintf(fp, "%s\n", LSCRIPTListDescription[mFirstp->mReturnType]);
-			count++;
-		}
-		if (mSecondp)
-		{
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mSecondp->mType != LET_LIST_EXPRESSION_LIST)
-			{
-				fprintf(fp, "%s\n", LSCRIPTListDescription[mSecondp->mReturnType]);
-				count++;
-			}
-		}
-		break;
-	case LSCP_TO_STACK:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mFirstp->mType != LET_LIST_EXPRESSION_LIST)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGB]);
-			chunk->addByte(LSCRIPTTypeByte[mFirstp->mReturnType]);
-			count++;
-		}
-		if (mSecondp)
-		{
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mSecondp->mType != LET_LIST_EXPRESSION_LIST)
-			{
-				chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGB]);
-				chunk->addByte(LSCRIPTTypeByte[mSecondp->mReturnType]);
-				count++;
-			}
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mFirstp->mType != LET_LIST_EXPRESSION_LIST)
-		{
-			// Box value.
-			print_cil_box(fp, mFirstp->mReturnType);
-			++count;
-		}
-		if (mSecondp)
-		{
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mSecondp->mType != LET_LIST_EXPRESSION_LIST)
-			{
-				// Box value.
-				print_cil_box(fp, mSecondp->mReturnType);
-				++count;
-			}
-		}
-		break;
-	default:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mSecondp)
-		{
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-S32 LLScriptListExpressionList::getSize()
-{
-	return 0;
-}
-
-// Returns true if identifier is a parameter and false if identifier is a local variable within function_scope.
-bool is_parameter(LLScriptIdentifier* identifier, LLScriptScopeEntry* function_scope)
-{
-	// Function stores offset of first local.
-	if(0 == function_scope->mOffset)
-	{
-		// Function offset 0 -> no parameters -> identifier is a local.
-		return false;
-	}
-	else
-	{
-		// Compare variable offset with function offset to
-		// determine whether variable is local or parameter.
-		return (identifier->mScopeEntry->mOffset < function_scope->mOffset);
-	}
-}
-
-// If assignment is to global variable, pushes this pointer on to stack.
-static void print_cil_load_address(LLFILE* fp, LLScriptExpression* exp, LLScriptScopeEntry* function_scope)
-{
-	LLScriptLValue *lvalue = (LLScriptLValue *) exp;
-	LLScriptIdentifier *ident = lvalue->mIdentifier;
-
-	// If global (member), load this pointer.
-	if(ident->mScopeEntry->mIDType == LIT_GLOBAL)
-	{
-		fprintf(fp, "ldarg.0\n");
-	}
-
-	// If accessor, load value type address, consumed by ldfld.
-	if(lvalue->mAccessor)
-	{
-		if(ident->mScopeEntry->mIDType == LIT_VARIABLE)
-		{
-			if(is_parameter(ident, function_scope))
-			{
-				// Parameter, load by name.
-				fprintf(fp, "ldarga.s '%s'\n", ident->mScopeEntry->mIdentifier);
-			}
-			else
-			{
-				// Local, load by index.
-				fprintf(fp, "ldloca.s %d\n", ident->mScopeEntry->mCount);
-			}
-		}
-		else if (ident->mScopeEntry->mIDType == LIT_GLOBAL)
-		{
-			fprintf(fp, "ldflda ");
-			print_cil_member(fp, ident);
-		}
-	}
-}
-
-static void print_cil_accessor(LLFILE* fp, LLScriptLValue *lvalue)
-
-{
-	LLScriptIdentifier *ident = lvalue->mIdentifier;
-	print_cil_type(fp, lvalue->mReturnType);
-	fprintf(fp, " ");
-	print_cil_type(fp, ident->mScopeEntry->mType);
-	fprintf(fp, "::%s\n", lvalue->mAccessor->mName);
-}
-
-void LLScriptLValue::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mAccessor)
-		{
-			fprintf(fp, ".");
-			mAccessor->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-		{
-			if (mAccessor)
-			{
-				fprintf(fp, "%s%d [%s.%s]\n", LSCRIPTTypeLocalPush[mReturnType], mIdentifier->mScopeEntry->mOffset + mOffset, mIdentifier->mName, mAccessor->mName);
-			}
-			else
-			{
-				fprintf(fp, "%s%d [%s]\n", LSCRIPTTypeLocalPush[mIdentifier->mScopeEntry->mType], mIdentifier->mScopeEntry->mOffset, mIdentifier->mName);
-			}
-		}
-		else if (mIdentifier->mScopeEntry->mIDType == LIT_GLOBAL)
-		{
-			if (mAccessor)
-			{
-				fprintf(fp, "%s%d [%s.%s]\n", LSCRIPTTypeGlobalPush[mReturnType], mIdentifier->mScopeEntry->mOffset + mOffset, mIdentifier->mName, mAccessor->mName);
-			}
-			else
-			{
-				fprintf(fp, "%s%d [%s]\n", LSCRIPTTypeGlobalPush[mIdentifier->mScopeEntry->mType], mIdentifier->mScopeEntry->mOffset, mIdentifier->mName);
-			}
-		}
-		else
-		{
-			fprintf(fp, "Unexpected LValue!\n");
-		}
-		break;
-	case LSCP_SCOPE_PASS1:
-		{
-			LLScriptScopeEntry *entry = scope->findEntry(mIdentifier->mName);
-			if (!entry || (  (entry->mIDType != LIT_GLOBAL) && (entry->mIDType != LIT_VARIABLE)))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_UNDEFINED_NAME);
-			}
-			else
-			{
-				// if we did find it, make sure this identifier is associated with the correct scope entry
-				mIdentifier->mScopeEntry = entry;
-			}
-		}
-		break;
-	case LSCP_TYPE:
-		// if we have an accessor, we need to change what type our identifier returns and set our offset value
-		if (mIdentifier->mScopeEntry)
-		{
-			if (mAccessor)
-			{
-				BOOL b_ok = FALSE;
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					if (mIdentifier->mScopeEntry->mType == LST_VECTOR)
-					{
-						if (!strcmp("x", mAccessor->mName))
-						{
-							mOffset = 0;
-							b_ok = TRUE;
-						}
-						else if (!strcmp("y", mAccessor->mName))
-						{
-							mOffset = 4;
-							b_ok = TRUE;
-						}
-						else if (!strcmp("z", mAccessor->mName))
-						{
-							mOffset = 8;
-							b_ok = TRUE;
-						}
-					}
-					else if (mIdentifier->mScopeEntry->mType == LST_QUATERNION)
-					{
-						if (!strcmp("x", mAccessor->mName))
-						{
-							mOffset = 0;
-							b_ok = TRUE;
-						}
-						else if (!strcmp("y", mAccessor->mName))
-						{
-							mOffset = 4;
-							b_ok = TRUE;
-						}
-						else if (!strcmp("z", mAccessor->mName))
-						{
-							mOffset = 8;
-							b_ok = TRUE;
-						}
-						else if (!strcmp("s", mAccessor->mName))
-						{
-							mOffset = 12;
-							b_ok = TRUE;
-						}
-					}
-				}
-				else
-				{
-					if (mIdentifier->mScopeEntry->mType == LST_VECTOR)
-					{
-						if (!strcmp("x", mAccessor->mName))
-						{
-							mOffset = 8;
-							b_ok = TRUE;
-						}
-						else if (!strcmp("y", mAccessor->mName))
-						{
-							mOffset = 4;
-							b_ok = TRUE;
-						}
-						else if (!strcmp("z", mAccessor->mName))
-						{
-							mOffset = 0;
-							b_ok = TRUE;
-						}
-					}
-					else if (mIdentifier->mScopeEntry->mType == LST_QUATERNION)
-					{
-						if (!strcmp("x", mAccessor->mName))
-						{
-							mOffset = 12;
-							b_ok = TRUE;
-						}
-						else if (!strcmp("y", mAccessor->mName))
-						{
-							mOffset = 8;
-							b_ok = TRUE;
-						}
-						else if (!strcmp("z", mAccessor->mName))
-						{
-							mOffset = 4;
-							b_ok = TRUE;
-						}
-						else if (!strcmp("s", mAccessor->mName))
-						{
-							mOffset = 0;
-							b_ok = TRUE;
-						}
-					}
-				}
-				if (b_ok)
-				{
-					mReturnType = type =  LST_FLOATINGPOINT;
-				}
-				else
-				{
-					gErrorToText.writeError(fp, this, LSERROR_VECTOR_METHOD_ERROR);
-				}
-			}
-			else
-			{
-				mReturnType = type = mIdentifier->mScopeEntry->mType;
-			}
-		}
-		else
-		{
-			mReturnType = type = LST_UNDEFINED;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			switch(mReturnType)
-			{
-			case LST_INTEGER:
-			case LST_FLOATINGPOINT:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSH]);
-				}
-				else
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHG]);
-				}
-				break;
-			case LST_KEY:
-			case LST_STRING:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHS]);
-				}
-				else
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHGS]);
-				}
-				break;
-			case LST_LIST:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHL]);
-				}
-				else
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHGL]);
-				}
-				break;
-			case LST_VECTOR:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHV]);
-				}
-				else
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHGV]);
-				}
-				break;
-			case LST_QUATERNION:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHQ]);
-				}
-				else
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHGQ]);
-				}
-				break;
-			default:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSH]);
-				}
-				else
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHG]);
-				}
-				break;
-			}
-			S32 address = mIdentifier->mScopeEntry->mOffset + mOffset;
-			chunk->addInteger(address);
-		}	
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		print_cil_load_address(fp, this, entry);
-		if(mAccessor)
-		{
-			fprintf(fp, "ldfld ");
-			print_cil_accessor(fp, this);
-		}
-		else if(mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-		{
-			if(is_parameter(mIdentifier, entry))
-			{
-				// Parameter, load by name.
-				fprintf(fp, "ldarg.s '%s'\n", mIdentifier->mScopeEntry->mIdentifier);
-			}
-			else
-			{
-				// Local, load by index.
-				fprintf(fp, "ldloc.s %d\n", mIdentifier->mScopeEntry->mCount);
-			}
-		}
-		else if (mIdentifier->mScopeEntry->mIDType == LIT_GLOBAL)
-		{
-			fprintf(fp, "ldfld ");
-			print_cil_member(fp, mIdentifier);
-		}
-		else
-		{
-			fprintf(fp, "Unexpected LValue!\n");
-		}
-		break;
-	default:
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptLValue::getSize()
-{
-	return 0;
-}
-
-static void print_assignment(LLFILE *fp, LLScriptExpression *exp)
-{
-	LLScriptLValue *lvalue = (LLScriptLValue *)exp;
-	LLScriptIdentifier *ident = lvalue->mIdentifier;
-	if (lvalue->mAccessor)
-	{
-		if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
-		{
-			fprintf(fp, "%s%d [%s.%s]\n", LSCRIPTTypeLocalStore[ident->mScopeEntry->mType], ident->mScopeEntry->mOffset + lvalue->mOffset, ident->mName, lvalue->mAccessor->mName);
-		}
-		else if (ident->mScopeEntry->mIDType == LIT_GLOBAL)
-		{
-			fprintf(fp, "%s%d [%s.%s]\n", LSCRIPTTypeGlobalStore[ident->mScopeEntry->mType], ident->mScopeEntry->mOffset + lvalue->mOffset, ident->mName, lvalue->mAccessor->mName);
-		}
-	}
-	else
-	{
-		if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
-		{
-			fprintf(fp, "%s%d [%s]\n", LSCRIPTTypeLocalStore[ident->mScopeEntry->mType], ident->mScopeEntry->mOffset, ident->mName);
-		}
-		else if (ident->mScopeEntry->mIDType == LIT_GLOBAL)
-		{
-			fprintf(fp, "%s%d [%s]\n", LSCRIPTTypeGlobalStore[ident->mScopeEntry->mType], ident->mScopeEntry->mOffset, ident->mName);
-		}
-	}
-}
-
-static void print_cil_assignment(LLFILE *fp, LLScriptExpression *exp, LLScriptScopeEntry* function_scope)
-{
-	LLScriptLValue *lvalue = (LLScriptLValue *) exp;
-	LLScriptIdentifier *ident = lvalue->mIdentifier;
-	if (lvalue->mAccessor)
-	{
-		// Object address loaded, store in to field.
-		fprintf(fp, "stfld ");
-		print_cil_accessor(fp, lvalue);
-
-		// Load object address.
-		print_cil_load_address(fp, exp, function_scope);
-
-		// Load field.
-		fprintf(fp, "ldfld ");
-		print_cil_accessor(fp, lvalue);
-	}
-	else
-	{
-		if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
-		{
-			// Language semantics require value of assignment to be left on stack. 
-			// TODO: Optimise away redundant dup/pop pairs.
-			fprintf(fp, "dup\n"); 
-			if(is_parameter(ident, function_scope))
-			{
-				// Parameter, store by name.
-				fprintf(fp, "starg.s '%s'\n", ident->mScopeEntry->mIdentifier);
-			}
-			else
-			{
-				// Local, store by index.
-				fprintf(fp, "stloc.s %d\n", ident->mScopeEntry->mCount);
-			}
-		}
-		else if (ident->mScopeEntry->mIDType == LIT_GLOBAL)
-		{
-			// Object address loaded, store in to field.
-			fprintf(fp, "stfld ");
-			print_cil_member(fp, ident);
-
-			// Load object address.
-			print_cil_load_address(fp, exp, function_scope);
-
-			// Load field.
-			fprintf(fp, "ldfld ");
-			print_cil_member(fp, ident);
-		}
-	}
-}
-
-void print_cast(LLFILE *fp, LSCRIPTType ret_type, LSCRIPTType right_type)
-{
-	if (right_type != ret_type)
-	{
-		fprintf(fp, "CAST %s->%s\n", LSCRIPTTypeNames[right_type], LSCRIPTTypeNames[ret_type]);
-	}
-}
-
-void cast2stack(LLScriptByteCodeChunk *chunk, LSCRIPTType ret_type, LSCRIPTType right_type)
-{
-	if (right_type != ret_type)
-	{
-		chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
-		U8 castbyte = LSCRIPTTypeByte[right_type] | LSCRIPTTypeHi4Bits[ret_type];
-		chunk->addByte(castbyte);
-	}
-}
-
-void operation2stack(LLScriptByteCodeChunk *chunk, LSCRIPTType ret_type, LSCRIPTType right_type)
-{
-	U8 typebyte = LSCRIPTTypeByte[right_type] | LSCRIPTTypeHi4Bits[ret_type];
-	chunk->addByte(typebyte);
-}
-
-void store2stack(LLScriptExpression *exp, LLScriptExpression *lv, LLScriptByteCodeChunk *chunk, LSCRIPTType right_type)
-{
-	LLScriptLValue *lvalue = (LLScriptLValue *)lv;
-	LLScriptIdentifier *ident = lvalue->mIdentifier;
-	LSCRIPTType rettype = exp->mReturnType;
-
-	if (exp->mRightType != LST_NULL)
-	{
-		if (legal_binary_expression(rettype, exp->mLeftType, exp->mRightType, exp->mType)) 
-			cast2stack(chunk, right_type, exp->mReturnType);
-	}
-	switch(exp->mReturnType)
-	{
-	case LST_INTEGER:
-	case LST_FLOATINGPOINT:
-		if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STORE]);
-		}
-		else
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STOREG]);
-		}
-		break;
-	case LST_KEY:
-	case LST_STRING:
-		if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STORES]);
-		}
-		else
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STOREGS]);
-		}
-		break;
-	case LST_LIST:
-		if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STOREL]);
-		}
-		else
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STOREGL]);
-		}
-		break;
-	case LST_VECTOR:
-		if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STOREV]);
-		}
-		else
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STOREGV]);
-		}
-		break;
-	case LST_QUATERNION:
-		if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STOREQ]);
-		}
-		else
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STOREGQ]);
-		}
-		break;
-	default:
-		if (ident->mScopeEntry->mIDType == LIT_VARIABLE)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STORE]);
-		}
-		else
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STOREG]);
-		}
-		break;
-	}
-	S32 address = ident->mScopeEntry->mOffset + lvalue->mOffset;
-	chunk->addInteger(address);
-}
-
-void LLScriptAssignment::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " = ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cast(fp, mReturnType, mRightType);
-			print_assignment(fp, mLValue);
-		}
-		break;
-	case LSCP_TYPE:
-		{
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_assignment(mLeftType, mRightType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType = mLeftType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			store2stack(this, mLValue, chunk, mRightType);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			print_cil_load_address(fp, mLValue, entry);
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_assignment_cast(fp, mRightType, mReturnType);
-			print_cil_assignment(fp, mLValue, entry);
-		}
-		break;
-	default:
-		mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptAssignment::getSize()
-{
-	return 0;
-}
-
-static void print_cil_add(LLFILE* fp, LSCRIPTType left_type, LSCRIPTType right_type)
-{
-	if(LST_LIST == right_type && LST_LIST != left_type)
-	{
-		print_cil_box(fp, left_type);
-		fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Prepend(class [mscorlib]System.Collections.ArrayList, object)\n");
-		return;
-	}
-
-	switch(left_type)
-	{
-	case LST_INTEGER:
-	case LST_FLOATINGPOINT:
-
-		// Numeric addition.
-		fprintf(fp, "add\n");
-		break;
-
-	case LST_STRING:
-	case LST_KEY:
-
-		// String concatenation.
-		fprintf(fp, "call string valuetype [LslUserScript]LindenLab.SecondLife.LslUserScript::Add(string, string)\n");
-		break;
-	
-	case LST_VECTOR:
-
-		// Vector addition.
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Add'(class [ScriptTypes]LindenLab.SecondLife.Vector, class [ScriptTypes]LindenLab.SecondLife.Vector)\n");
-		break;
-
-	case LST_QUATERNION:
-
-		// Rotation addition.
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Add'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Quaternion)\n");
-		break;
-
-	case LST_LIST:
-		switch(right_type)
-		{
-		case LST_LIST:
-			// Concatenate lists.
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(class [mscorlib]System.Collections.ArrayList, class [mscorlib]System.Collections.ArrayList)\n");
-			break;
-		case LST_INTEGER:
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(int32, class [mscorlib]System.Collections.ArrayList)\n");
-			break;
-		case LST_FLOATINGPOINT:
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(float32, class [mscorlib]System.Collections.ArrayList)\n");
-			break;
-		case LST_STRING:
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(string, class [mscorlib]System.Collections.ArrayList)\n");
-			break;
-		case LST_KEY:
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(valuetype [ScriptTypes]LindenLab.SecondLife.Key, class [mscorlib]System.Collections.ArrayList)\n");
-			break;			
-		case LST_VECTOR:
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(valuetype [ScriptTypes]LindenLab.SecondLife.Vector, class [mscorlib]System.Collections.ArrayList)\n");
-			break;
-		case LST_QUATERNION:
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Append(valuetype [ScriptTypes]LindenLab.SecondLife.Quaternion, class [mscorlib]System.Collections.ArrayList)\n");
-			break;
-		default:
-			break;
-		}
-
-	default:
-		break;
-	}
-}
-
-void LLScriptAddAssignment::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " += ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "ADD %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-			print_assignment(fp, mLValue);
-		}
-		break;
-	case LSCP_TYPE:
-		{
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_ADD]);
-			operation2stack(chunk, mReturnType, mRightType);
-			store2stack(this, mLValue, chunk, mReturnType);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			print_cil_load_address(fp, mLValue, entry);
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_numeric_cast(fp, mRightSide->mReturnType, mLValue->mReturnType);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_numeric_cast(fp, mLValue->mReturnType, mRightSide->mReturnType);
-			print_cil_add(fp, mLValue->mReturnType, mRightSide->mReturnType);
-			print_cil_assignment(fp, mLValue, entry);
-		}
-		break;
-	default:
-		mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptAddAssignment::getSize()
-{
-	return 0;
-}
-
-static void print_cil_sub(LLFILE* fp, LSCRIPTType left_type, LSCRIPTType right_type)
-{
-	switch(left_type)
-	{
-	case LST_INTEGER:
-		if(LST_INTEGER == right_type)
-		{	
-			fprintf(fp, "call int32 [LslUserScript]LindenLab.SecondLife.LslUserScript::Subtract(int32, int32)\n");
-			break;
-		}
-	case LST_FLOATINGPOINT:
-		// Numeric subtraction.
-		fprintf(fp, "call float64 [LslUserScript]LindenLab.SecondLife.LslUserScript::Subtract(float64, float64)\n");
-		break;
-	case LST_VECTOR:
-
-		// Vector subtraction.
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Subtract'(class [ScriptTypes]LindenLab.SecondLife.Vector, class [ScriptTypes]LindenLab.SecondLife.Vector)\n");
-		break;
-
-	case LST_QUATERNION:
-
-		// Rotation subtraction.
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Subtract'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Quaternion)\n");
-		break;
-
-	default:
-
-		// Error.
-		break;
-	}
-}
-
-void LLScriptSubAssignment::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " -= ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "SUB %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-			print_assignment(fp, mLValue);
-		}
-		break;
-	case LSCP_TYPE:
-		{
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_SUB]);
-			operation2stack(chunk, mReturnType, mRightType);
-			store2stack(this, mLValue, chunk, mReturnType);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			print_cil_load_address(fp, mLValue, entry);
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_numeric_cast(fp, mRightSide->mReturnType, mLValue->mReturnType);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_numeric_cast(fp, mLValue->mReturnType, mRightSide->mReturnType);
-			print_cil_sub(fp, mLValue->mReturnType, mRightSide->mReturnType);
-			print_cil_assignment(fp, mLValue, entry);
-		}
-		break;
-	default:
-		mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptSubAssignment::getSize()
-{
-	return 0;
-}
-
-static void print_cil_neg(LLFILE* fp, LSCRIPTType type)
-{
-        switch(type)
-	{
-	case LST_INTEGER:
-	case LST_FLOATINGPOINT:
-	  fprintf(fp, "neg\n");
-	  break;
-	case LST_VECTOR:
-	  fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Negate'(class [ScriptTypes]LindenLab.SecondLife.Vector)\n");	  
-	  break;
-	case LST_QUATERNION:
-	  fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Negate'(class [ScriptTypes]LindenLab.SecondLife.Quaternion)\n");	  
-	  break;
-	default:
-	  break;
-	}
-}
-
-static void print_cil_mul(LLFILE* fp, LSCRIPTType left_type, LSCRIPTType right_type)
-{
-	switch(left_type)
-	{
-	case LST_INTEGER:
-
-		switch(right_type)
-		{
-		case LST_INTEGER:
-		case LST_FLOATINGPOINT:
-
-			// Numeric multiplication.
-			fprintf(fp, "mul\n");
-			break;
-
-		case LST_VECTOR:
-
-			// Vector scaling.
-			fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Multiply'(class [ScriptTypes]LindenLab.SecondLife.Vector, float32)\n");
-			break;
-		default:
-			break;
-		}
-		break;
-
-	case LST_FLOATINGPOINT:
-
-		switch(right_type)
-		{
-		case LST_INTEGER:
-		case LST_FLOATINGPOINT:
-
-			// Numeric multiplication.
-			fprintf(fp, "mul\n");
-			break;
-
-		case LST_VECTOR:
-
-			// Vector scaling.
-			fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Multiply'(class [ScriptTypes]LindenLab.SecondLife.Vector, float32)\n");
-			break;
-
-		default:
-			break;
-		}
-		break;
-		
-	case LST_VECTOR:
-
-		switch(right_type)
-		{
-		case LST_INTEGER:
-		case LST_FLOATINGPOINT:
-
-			// Vector scaling.
-			fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Multiply'(float32, class [ScriptTypes]LindenLab.SecondLife.Vector)\n");
-			break;
-
-		case LST_VECTOR:
-
-			// Dot product.
-			fprintf(fp, "call float32 class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Multiply'(class [ScriptTypes]LindenLab.SecondLife.Vector, class [ScriptTypes]LindenLab.SecondLife.Vector)\n");
-			break;
-
-		case LST_QUATERNION:
-
-			// Vector rotation.
-			fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Multiply'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Vector)\n");
-			break;
-
-		default:
-			break;
-		}
-		break;
-
-	case LST_QUATERNION:
-
-		// Rotation multiplication.
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Multiply'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Quaternion)\n");
-		break;
-
-	default:
-
-		// Error.
-		break;
-	}
-}
-
-void LLScriptMulAssignment::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " *= ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "MUL %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-			print_assignment(fp, mLValue);
-		}
-		break;
-	case LSCP_TYPE:
-		{
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType) /*|| !legal_assignment(mLValue->mReturnType, mReturnType)*/)
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_MUL]);
-			operation2stack(chunk, mReturnType, mRightType);
-			store2stack(this, mLValue, chunk, mReturnType);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			print_cil_load_address(fp, mLValue, entry);
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_numeric_cast(fp, mRightSide->mReturnType, mLValue->mReturnType);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_numeric_cast(fp, mLValue->mReturnType, mRightSide->mReturnType);
-			print_cil_mul(fp, mLValue->mReturnType, mRightSide->mReturnType);
-			if((mLValue->mReturnType == LST_INTEGER) && 
-			   (mRightSide->mReturnType == LST_FLOATINGPOINT))
-			{
-			    print_cil_cast(fp, LST_FLOATINGPOINT, LST_INTEGER);
-			} 
-			print_cil_assignment(fp, mLValue, entry);
-		}
-		break;
-	default:
-		mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptMulAssignment::getSize()
-{
-	return 0;
-}
-
-static void print_cil_div(LLFILE* fp, LSCRIPTType left_type, LSCRIPTType right_type)
-{
-	switch(left_type)
-	{
-	case LST_INTEGER:
-		if(LST_INTEGER == right_type)
-		{
-			fprintf(fp, "call int32 [LslUserScript]LindenLab.SecondLife.LslUserScript::Divide(int32, int32)\n");
-			break;
-		}
-	case LST_FLOATINGPOINT:
-
-		// Numeric division.
-		fprintf(fp, "call float64 [LslUserScript]LindenLab.SecondLife.LslUserScript::Divide(float64, float64)\n");
-		break;
-	
-	case LST_VECTOR:
-
-		switch(right_type)
-		{
-		case LST_INTEGER:
-		case LST_FLOATINGPOINT:
-
-			// Scale.
-			fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Divide'(float32, class [ScriptTypes]LindenLab.SecondLife.Vector)\n");
-			break;
-
-		case LST_QUATERNION:
-
-			// Inverse rotation.
-			fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Divide'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Vector)\n");
-			break;
-
-		default:
-			break;
-		}
-		break;
-
-	case LST_QUATERNION:
-
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Divide'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Quaternion)\n");		
-		break;
-
-	default:
-
-		// Error.
-		break;
-	}
-}
-
-void LLScriptDivAssignment::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " /= ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "DIV %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-			print_assignment(fp, mLValue);
-		}
-		break;
-	case LSCP_TYPE:
-		{
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_DIV]);
-			operation2stack(chunk, mReturnType, mRightType);
-			store2stack(this, mLValue, chunk, mReturnType);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			print_cil_load_address(fp, mLValue, entry);
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_numeric_cast(fp, mRightSide->mReturnType, mLValue->mReturnType);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_numeric_cast(fp, mLValue->mReturnType, mRightSide->mReturnType);
-			print_cil_div(fp, mLValue->mReturnType, mRightSide->mReturnType);
-			print_cil_assignment(fp, mLValue, entry);
-		}
-		break;
-	default:
-		mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptDivAssignment::getSize()
-{
-	return 0;
-}
-
-static void print_cil_mod(LLFILE* fp, LSCRIPTType left_type, LSCRIPTType right_type)
-{
-	switch(left_type)
-	{
-	case LST_INTEGER:
-
-		// Numeric remainder.
-		fprintf(fp, "call int32 [LslUserScript]LindenLab.SecondLife.LslUserScript::Modulo(int32, int32)\n");
-		break;
-	
-	case LST_VECTOR:
-
-		// Vector cross product.
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'Modulo'(class [ScriptTypes]LindenLab.SecondLife.Vector, class [ScriptTypes]LindenLab.SecondLife.Vector)\n");
-		break;
-
-	default:
-
-		// Error.
-		break;
-	}
-}
-
-void LLScriptModAssignment::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " %%= ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "MOD %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-			print_assignment(fp, mLValue);
-		}
-		break;
-	case LSCP_TYPE:
-		{
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_MOD]);
-			operation2stack(chunk, mReturnType, mRightType);
-			store2stack(this, mLValue, chunk, mReturnType);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			print_cil_load_address(fp, mLValue, entry);
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_mod(fp, mLValue->mReturnType, mRightSide->mReturnType);
-			print_cil_assignment(fp, mLValue, entry);
-		}
-		break;
-	default:
-		mLValue->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptModAssignment::getSize()
-{
-	return 0;
-}
-
-static void print_cil_eq(LLFILE* fp, LSCRIPTType left_type, LSCRIPTType right_type)
-{
-	
-	switch(right_type)
-	{
-	case LST_INTEGER:
-	case LST_FLOATINGPOINT:
-
-		// Numeric equality.
-		fprintf(fp, "ceq\n");
-		break;
-
-	case LST_STRING:
-	        // NOTE: babbage: strings and keys can be compared, so a cast
-	        // may be required
-	        print_cil_cast(fp, left_type, right_type);
-		// String equality.
-		fprintf(fp, "call bool valuetype [mscorlib]System.String::op_Equality(string, string)\n");
-		break;
-		
-	case LST_KEY:
-	        // NOTE: babbage: strings and keys can be compared, so a cast 
-	        // may be required
-	        print_cil_cast(fp, left_type, right_type);
-
-		// Key equality.
-		fprintf(fp, "call int32 [LslUserScript]LindenLab.SecondLife.LslUserScript::'Equals'(valuetype [ScriptTypes]LindenLab.SecondLife.Key, valuetype [ScriptTypes]LindenLab.SecondLife.Key)\n");
-		break;
-	
-	case LST_VECTOR:
-
-		// Vector equality.
-		fprintf(fp, "call int32 [LslUserScript]LindenLab.SecondLife.LslUserScript::'Equals'(class [ScriptTypes]LindenLab.SecondLife.Vector, class [ScriptTypes]LindenLab.SecondLife.Vector)\n");
-		break;
-
-	case LST_QUATERNION:
-
-		// Rotation equality.
-		fprintf(fp, "call int32 [LslUserScript]LindenLab.SecondLife.LslUserScript::'Equals'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Quaternion)\n");
-		break;
-
-	case LST_LIST:
-		fprintf(fp, "call int32 [LslUserScript]LindenLab.SecondLife.LslUserScript::Equals(class [mscorlib]System.Collections.ArrayList, class [mscorlib]System.Collections.ArrayList)\n");
-		break;
-
-	default:
-
-		// Error.
-		break;
-	}
-}
-
-void LLScriptEquality::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " == ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "EQ %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			U8 typebyte = LSCRIPTTypeByte[mRightType] | LSCRIPTTypeHi4Bits[mLeftType];
-			chunk->addByte(LSCRIPTOpCodes[LOPC_EQ]);
-			chunk->addByte(typebyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mRightSide->mReturnType, mLeftSide->mReturnType);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		print_cil_eq(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptEquality::getSize()
-{
-	return 0;
-}
-
-void LLScriptNotEquals::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " != ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "NEQ %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			U8 typebyte = LSCRIPTTypeByte[mRightType] | LSCRIPTTypeHi4Bits[mLeftType];
-			chunk->addByte(LSCRIPTOpCodes[LOPC_NEQ]);
-			chunk->addByte(typebyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mRightSide->mReturnType, mLeftSide->mReturnType);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		if (LST_LIST == mLeftSide->mReturnType)
-		{
-		    fprintf(fp, "call int32 [LslUserScript]LindenLab.SecondLife.LslUserScript::NotEquals(class [mscorlib]System.Collections.ArrayList, class [mscorlib]System.Collections.ArrayList)\n");
-		}
-		else
-		{  
-		    print_cil_eq(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		    fprintf(fp, "ldc.i4.0\n");
-		    fprintf(fp, "ceq\n"); // Compare result of first compare equal with 0 to get compare not equal.
-		}    
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptNotEquals::getSize()
-{
-	return 0;
-}
-
-static void print_cil_lte(LLFILE* fp)
-{
-	// NOTE: LSL pushes operands backwards, so <= becomes >=
-	fprintf(fp, "clt\n");
-	fprintf(fp, "ldc.i4.0\n");
-	fprintf(fp, "ceq\n");
-}
-
-void LLScriptLessEquals::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " <= ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "LEQ %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			U8 typebyte = LSCRIPTTypeByte[mRightType] | LSCRIPTTypeHi4Bits[mLeftType];
-			chunk->addByte(LSCRIPTOpCodes[LOPC_LEQ]);
-			chunk->addByte(typebyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mRightSide->mReturnType, mLeftSide->mReturnType);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		print_cil_lte(fp);
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptLessEquals::getSize()
-{
-	return 0;
-}
-
-static void print_cil_gte(LLFILE* fp)
-{   
-	// NOTE: LSL pushes operands backwards, so >= becomes <=
-	fprintf(fp, "cgt\n");
-	fprintf(fp, "ldc.i4.0\n");
-	fprintf(fp, "ceq\n");
-}
-
-void LLScriptGreaterEquals::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " >= ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "GEQ %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			U8 typebyte = LSCRIPTTypeByte[mRightType] | LSCRIPTTypeHi4Bits[mLeftType];
-			chunk->addByte(LSCRIPTOpCodes[LOPC_GEQ]);
-			chunk->addByte(typebyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mRightSide->mReturnType, mLeftSide->mReturnType);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		print_cil_gte(fp);
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptGreaterEquals::getSize()
-{
-	return 0;
-}
-
-static void print_cil_lt(LLFILE* fp)
-{
-	// NOTE: LSL pushes operands backwards, so < becomes >
-	fprintf(fp, "cgt\n");
-}
-
-void LLScriptLessThan::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " < ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "LESS %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			U8 typebyte = LSCRIPTTypeByte[mRightType] | LSCRIPTTypeHi4Bits[mLeftType];
-			chunk->addByte(LSCRIPTOpCodes[LOPC_LESS]);
-			chunk->addByte(typebyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mRightSide->mReturnType, mLeftSide->mReturnType);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		print_cil_lt(fp);
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptLessThan::getSize()
-{
-	return 0;
-}
-
-static void print_cil_gt(LLFILE* fp)
-{   
-    // NOTE: LSL pushes operands backwards, so > becomes <
-	fprintf(fp, "clt\n");
-}
-
-void LLScriptGreaterThan::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " > ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "GREATER %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			U8 typebyte = LSCRIPTTypeByte[mRightType] | LSCRIPTTypeHi4Bits[mLeftType];
-			chunk->addByte(LSCRIPTOpCodes[LOPC_GREATER]);
-			chunk->addByte(typebyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mRightSide->mReturnType, mLeftSide->mReturnType);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		print_cil_gt(fp);
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptGreaterThan::getSize()
-{
-	return 0;
-}
-
-void LLScriptPlus::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " + ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "ADD %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			U8 typebyte = LSCRIPTTypeByte[mRightType] | LSCRIPTTypeHi4Bits[mLeftType];
-			chunk->addByte(LSCRIPTOpCodes[LOPC_ADD]);
-			chunk->addByte(typebyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mRightSide->mReturnType, mLeftSide->mReturnType);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		print_cil_add(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptPlus::getSize()
-{
-	return 0;
-}
-
-void LLScriptMinus::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " - ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "SUB %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			U8 typebyte = LSCRIPTTypeByte[mRightType] | LSCRIPTTypeHi4Bits[mLeftType];
-			chunk->addByte(LSCRIPTOpCodes[LOPC_SUB]);
-			chunk->addByte(typebyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mRightSide->mReturnType, mLeftSide->mReturnType);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		print_cil_sub(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptMinus::getSize()
-{
-	return 0;
-}
-
-void LLScriptTimes::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " * ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "MUL %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			U8 typebyte = LSCRIPTTypeByte[mRightType] | LSCRIPTTypeHi4Bits[mLeftType];
-			chunk->addByte(LSCRIPTOpCodes[LOPC_MUL]);
-			chunk->addByte(typebyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mRightSide->mReturnType, mLeftSide->mReturnType);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		print_cil_mul(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptTimes::getSize()
-{
-	return 0;
-}
-
-void LLScriptDivide::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " / ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "DIV %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			U8 typebyte = LSCRIPTTypeByte[mRightType] | LSCRIPTTypeHi4Bits[mLeftType];
-			chunk->addByte(LSCRIPTOpCodes[LOPC_DIV]);
-			chunk->addByte(typebyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mRightSide->mReturnType, mLeftSide->mReturnType);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_numeric_cast(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		print_cil_div(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptDivide::getSize()
-{
-	return 0;
-}
-
-void LLScriptMod::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " %% ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "MOD %s, %s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			U8 typebyte = LSCRIPTTypeByte[mRightType] | LSCRIPTTypeHi4Bits[mLeftType];
-			chunk->addByte(LSCRIPTOpCodes[LOPC_MOD]);
-			chunk->addByte(typebyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_mod(fp, mLeftSide->mReturnType, mRightSide->mReturnType);
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptMod::getSize()
-{
-	return 0;
-}
-
-void LLScriptBitAnd::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " & ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "BITAND\n");
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_BITAND]);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "and\n");
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptBitAnd::getSize()
-{
-	return 0;
-}
-
-void LLScriptBitOr::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " | ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "BITOR\n");
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_BITOR]);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "or\n");
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptBitOr::getSize()
-{
-	return 0;
-}
-
-void LLScriptBitXor::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " ^ ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "BITXOR\n");
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_BITXOR]);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "xor\n");
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptBitXor::getSize()
-{
-	return 0;
-}
-
-void LLScriptBooleanAnd::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " && ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "BOOLAND\n");
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_BOOLAND]);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "ldc.i4.0\n");
-		fprintf(fp, "ceq\n");
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "ldc.i4.0\n");
-		fprintf(fp, "ceq\n");
-		fprintf(fp, "or\n");
-                fprintf(fp, "ldc.i4.0\n");
-                fprintf(fp, "ceq\n");
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptBooleanAnd::getSize()
-{
-	return 0;
-}
-
-void LLScriptBooleanOr::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " || ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "BOOLOR\n");
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_BOOLOR]);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "or\n");
-                fprintf(fp, "ldc.i4.0\n");
-                fprintf(fp, "ceq\n");
-		fprintf(fp, "ldc.i4.0\n");
-		fprintf(fp, "ceq\n");
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptBooleanOr::getSize()
-{
-	return 0;
-}
-
-void LLScriptShiftLeft::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " << ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "SHL\n");
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_SHL]);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "call int32 [LslUserScript]LindenLab.SecondLife.LslUserScript::ShiftLeft(int32, int32)\n");
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptShiftLeft::getSize()
-{
-	return 0;
-}
-
-
-void LLScriptShiftRight::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " >> ");
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "SHR\n");
-		break;
-	case LSCP_TYPE:
-		{
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftType = type;
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mRightType = type;
-			if (!legal_binary_expression(mReturnType, mLeftType, mRightType, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			type = mReturnType;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_SHR]);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "call int32 [LslUserScript]LindenLab.SecondLife.LslUserScript::ShiftRight(int32, int32)\n");
-		break;
-	default:
-		mLeftSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightSide->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptShiftRight::getSize()
-{
-	return 0;
-}
-
-void LLScriptParenthesis::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "( ");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	case LSCP_TYPE:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mReturnType = mLeftType = type;
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mReturnType = mLeftType = type;
-		break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptParenthesis::getSize()
-{
-	return 0;
-}
-
-void LLScriptUnaryMinus::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "-");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "NEG %s\n", LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_unary_expression(type, type, mType))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		else
-		{
-			mReturnType = mLeftType = type;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			U8 typebyte = LSCRIPTTypeByte[mLeftType];
-			chunk->addByte(LSCRIPTOpCodes[LOPC_NEG]);
-			chunk->addByte(typebyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-	    {
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_neg(fp, mLeftType);
-	    }
-	    break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptUnaryMinus::getSize()
-{
-	return 0;
-}
-
-void LLScriptBooleanNot::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "!");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "BOOLNOT\n");
-		break;
-	case LSCP_TYPE:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_unary_expression(type, type, mType))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		else
-		{
-			mReturnType = mLeftType = type;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_BOOLNOT]);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "ldc.i4.0\n");
-		fprintf(fp, "ceq\n"); // If f(e) is (e == 0), f(e) returns 1 if e is 0 and 0 otherwise, therefore f(e) implements boolean not.
-		break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptBooleanNot::getSize()
-{
-	return 0;
-}
-
-void LLScriptBitNot::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "~");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "BITNOT\n");
-		break;
-	case LSCP_TYPE:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_unary_expression(type, type, mType))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		else
-		{
-			mReturnType = mLeftType = type;
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_BITNOT]);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "not\n");
-		break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptBitNot::getSize()
-{
-	return 0;
-}
-
-void LLScriptPreIncrement::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "++");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			if (mReturnType == LST_INTEGER)
-			{
-				fprintf(fp, "PUSHARGI 1\n");
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, "\n");
-				fprintf(fp, "ADD integer, integer\n");
-			}
-			else if (mReturnType == LST_FLOATINGPOINT)
-			{
-				fprintf(fp, "PUSHARGF 1\n");
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, "\n");
-				fprintf(fp, "ADD float, float\n");
-			}
-			else
-			{
-				fprintf(fp, "Unexpected Type\n");
-			}
-			print_assignment(fp, mExpression);
-		}
-		break;
-	case LSCP_TYPE:
-		if (mExpression->mType != LET_LVALUE)
-		{
-			gErrorToText.writeError(fp, this, LSERROR_EXPRESSION_ON_LVALUE);
-		}
-		else
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (!legal_unary_expression(type, type, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			else
-			{
-				mReturnType = mLeftType = type;
-			}
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			if (mReturnType == LST_INTEGER)
-			{
-				chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGI]);
-				chunk->addInteger(1);
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				chunk->addByte(LSCRIPTOpCodes[LOPC_ADD]);
-				chunk->addByte(LSCRIPTTypeByte[LST_INTEGER] | LSCRIPTTypeHi4Bits[LST_INTEGER]);
-			}
-			else if (mReturnType == LST_FLOATINGPOINT)
-			{
-				chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGF]);
-				chunk->addFloat(1.f);
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				chunk->addByte(LSCRIPTOpCodes[LOPC_ADD]);
-				chunk->addByte(LSCRIPTTypeByte[LST_FLOATINGPOINT] | LSCRIPTTypeHi4Bits[LST_FLOATINGPOINT]);
-			}
-			store2stack(this, mExpression, chunk, mReturnType);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			print_cil_load_address(fp, mExpression, entry);
-			if (mReturnType == LST_INTEGER)
-			{
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, "ldc.i4.1\n");
-				fprintf(fp, "add\n");
-			}
-			else if (mReturnType == LST_FLOATINGPOINT)
-			{
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, "ldc.r8 1\n");
-				fprintf(fp, "add\n");
-			}
-			else
-			{
-				fprintf(fp, "Unexpected Type\n");
-			}
-			print_cil_assignment(fp, mExpression, entry);
-		}
-		break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptPreIncrement::getSize()
-{
-	return 0;
-}
-
-void LLScriptPreDecrement::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "--");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			if (mReturnType == LST_INTEGER)
-			{
-				fprintf(fp, "PUSHARGI 1\n");
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, "\n");
-				fprintf(fp, "SUB integer, integer\n");
-			}
-			else if (mReturnType == LST_FLOATINGPOINT)
-			{
-				fprintf(fp, "PUSHARGF 1\n");
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, "\n");
-				fprintf(fp, "SUB float, float\n");
-			}
-			else
-			{
-				fprintf(fp, "Unexpected Type\n");
-			}
-			print_assignment(fp, mExpression);
-		}
-		break;
-	case LSCP_TYPE:
-		if (mExpression->mType != LET_LVALUE)
-		{
-			gErrorToText.writeError(fp, this, LSERROR_EXPRESSION_ON_LVALUE);
-		}
-		else
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (!legal_unary_expression(type, type, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			else
-			{
-				mReturnType = mLeftType = type;
-			}
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			if (mReturnType == LST_INTEGER)
-			{
-				chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGI]);
-				chunk->addInteger(1);
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				chunk->addByte(LSCRIPTOpCodes[LOPC_SUB]);
-				chunk->addByte(LSCRIPTTypeByte[LST_INTEGER] | LSCRIPTTypeHi4Bits[LST_INTEGER]);
-			}
-			else if (mReturnType == LST_FLOATINGPOINT)
-			{
-				chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGF]);
-				chunk->addFloat(1.f);
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				chunk->addByte(LSCRIPTOpCodes[LOPC_SUB]);
-				chunk->addByte(LSCRIPTTypeByte[LST_FLOATINGPOINT] | LSCRIPTTypeHi4Bits[LST_FLOATINGPOINT]);
-			}
-			store2stack(this, mExpression, chunk, mReturnType);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			print_cil_load_address(fp, mExpression, entry);
-			if (mReturnType == LST_INTEGER)
-			{
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, "ldc.i4.1\n");
-				fprintf(fp, "sub\n");
-			}
-			else if (mReturnType == LST_FLOATINGPOINT)
-			{
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, "ldc.r8 1\n");
-				fprintf(fp, "sub\n");
-			}
-			else
-			{
-				fprintf(fp, "Unexpected Type\n");
-			}
-			print_cil_assignment(fp, mExpression, entry);
-		}
-		break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptPreDecrement::getSize()
-{
-	return 0;
-}
-
-void LLScriptTypeCast::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "( ");
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ") ");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "CAST %s->%s\n", LSCRIPTTypeNames[mRightType], LSCRIPTTypeNames[mType->mType]);
-		break;
-	case LSCP_TYPE:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mRightType = type;
-		if (!legal_casts(mType->mType, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		type = mType->mType;
-		mReturnType = mLeftType = type;
-		break;
-	case LSCP_TO_STACK:
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
-			U8 castbyte = LSCRIPTTypeByte[mType->mType] | LSCRIPTTypeHi4Bits[mRightType];
-			chunk->addByte(castbyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_cast(fp, mRightType, mType->mType);
-		break;
-	default:
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptTypeCast::getSize()
-{
-	return 0;
-}
-
-void LLScriptVectorInitializer::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "< ");
-		mExpression1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", ");
-		mExpression2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", ");
-		mExpression3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " >");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mExpression1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression1->mReturnType != LST_FLOATINGPOINT)
-		{
-			fprintf(fp, "CAST %s->%s\n", LSCRIPTTypeNames[mExpression1->mReturnType], LSCRIPTTypeNames[LST_FLOATINGPOINT]);
-		}
-		mExpression2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression2->mReturnType != LST_FLOATINGPOINT)
-		{
-			fprintf(fp, "CAST %s->%s\n", LSCRIPTTypeNames[mExpression2->mReturnType], LSCRIPTTypeNames[LST_FLOATINGPOINT]);
-		}
-		mExpression3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression3->mReturnType != LST_FLOATINGPOINT)
-		{
-			fprintf(fp, "CAST %s->%s\n", LSCRIPTTypeNames[mExpression3->mReturnType], LSCRIPTTypeNames[LST_FLOATINGPOINT]);
-		}
-		break;
-	case LSCP_TYPE:
-		// vector's take floats
-		mExpression1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		mExpression2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		mExpression3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		mReturnType = type = LST_VECTOR;
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_TO_STACK:
-		pass = LSCP_TO_STACK;
-		mExpression1->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression1->mReturnType != LST_FLOATINGPOINT)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
-			U8 castbyte = LSCRIPTTypeByte[LST_FLOATINGPOINT] | LSCRIPTTypeHi4Bits[mExpression1->mReturnType];
-			chunk->addByte(castbyte);
-		}
-		mExpression2->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression2->mReturnType != LST_FLOATINGPOINT)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
-			U8 castbyte = LSCRIPTTypeByte[LST_FLOATINGPOINT] | LSCRIPTTypeHi4Bits[mExpression2->mReturnType];
-			chunk->addByte(castbyte);
-		}
-		mExpression3->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression3->mReturnType != LST_FLOATINGPOINT)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
-			U8 castbyte = LSCRIPTTypeByte[LST_FLOATINGPOINT] | LSCRIPTTypeHi4Bits[mExpression3->mReturnType];
-			chunk->addByte(castbyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-
-		// Load arguments.
-		mExpression1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression1->mReturnType != LST_FLOATINGPOINT)
-		{
-			print_cil_cast(fp, mExpression1->mReturnType, LST_FLOATINGPOINT);
-		}
-		mExpression2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression2->mReturnType != LST_FLOATINGPOINT)
-		{
-			print_cil_cast(fp, mExpression2->mReturnType, LST_FLOATINGPOINT);
-		}
-		mExpression3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression3->mReturnType != LST_FLOATINGPOINT)
-		{
-			print_cil_cast(fp, mExpression3->mReturnType, LST_FLOATINGPOINT);
-		}
-		// Call named ctor, which leaves new Vector on stack, so it can be saved in to local or argument just like a primitive type.
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'CreateVector'(float32, float32, float32)\n");
-		break;
-	default:
-		mExpression1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mExpression2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mExpression3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptVectorInitializer::getSize()
-{
-	return 0;
-}
-
-void LLScriptQuaternionInitializer::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "< ");
-		mExpression1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", ");
-		mExpression2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", ");
-		mExpression3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ", ");
-		mExpression4->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " >");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mExpression1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression1->mReturnType != LST_FLOATINGPOINT)
-		{
-			fprintf(fp, "CAST %s->%s\n", LSCRIPTTypeNames[mExpression1->mReturnType], LSCRIPTTypeNames[LST_FLOATINGPOINT]);
-		}
-		mExpression2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression2->mReturnType != LST_FLOATINGPOINT)
-		{
-			fprintf(fp, "CAST %s->%s\n", LSCRIPTTypeNames[mExpression2->mReturnType], LSCRIPTTypeNames[LST_FLOATINGPOINT]);
-		}
-		mExpression3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression3->mReturnType != LST_FLOATINGPOINT)
-		{
-			fprintf(fp, "CAST %s->%s\n", LSCRIPTTypeNames[mExpression3->mReturnType], LSCRIPTTypeNames[LST_FLOATINGPOINT]);
-		}
-		mExpression4->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression4->mReturnType != LST_FLOATINGPOINT)
-		{
-			fprintf(fp, "CAST %s->%s\n", LSCRIPTTypeNames[mExpression4->mReturnType], LSCRIPTTypeNames[LST_FLOATINGPOINT]);
-		}
-		break;
-	case LSCP_TYPE:
-		// vector's take floats
-		mExpression1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		mExpression2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		mExpression3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		mExpression4->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!legal_assignment(LST_FLOATINGPOINT, type))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		mReturnType = type = LST_QUATERNION;
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_TO_STACK:
-		pass = LSCP_TO_STACK;
-		mExpression1->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression1->mReturnType != LST_FLOATINGPOINT)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
-			U8 castbyte = LSCRIPTTypeByte[LST_FLOATINGPOINT] | LSCRIPTTypeHi4Bits[mExpression1->mReturnType];
-			chunk->addByte(castbyte);
-		}
-		mExpression2->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression2->mReturnType != LST_FLOATINGPOINT)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
-			U8 castbyte = LSCRIPTTypeByte[LST_FLOATINGPOINT] | LSCRIPTTypeHi4Bits[mExpression2->mReturnType];
-			chunk->addByte(castbyte);
-		}
-		mExpression3->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression3->mReturnType != LST_FLOATINGPOINT)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
-			U8 castbyte = LSCRIPTTypeByte[LST_FLOATINGPOINT] | LSCRIPTTypeHi4Bits[mExpression3->mReturnType];
-			chunk->addByte(castbyte);
-		}
-		mExpression4->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression4->mReturnType != LST_FLOATINGPOINT)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_CAST]);
-			U8 castbyte = LSCRIPTTypeByte[LST_FLOATINGPOINT] | LSCRIPTTypeHi4Bits[mExpression4->mReturnType];
-			chunk->addByte(castbyte);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-
-		// Load arguments.
-		mExpression1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression1->mReturnType != LST_FLOATINGPOINT)
-		{
-			print_cil_cast(fp, mExpression1->mReturnType, LST_FLOATINGPOINT);
-		}
-		mExpression2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression2->mReturnType != LST_FLOATINGPOINT)
-		{
-			print_cil_cast(fp, mExpression2->mReturnType, LST_FLOATINGPOINT);
-		}
-		mExpression3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression3->mReturnType != LST_FLOATINGPOINT)
-		{
-			print_cil_cast(fp, mExpression3->mReturnType, LST_FLOATINGPOINT);
-		}
-		mExpression4->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression4->mReturnType != LST_FLOATINGPOINT)
-		{
-			print_cil_cast(fp, mExpression4->mReturnType, LST_FLOATINGPOINT);
-		}
-
-		// Call named ctor, which leaves new Vector on stack, so it can be saved in to local or argument just like a primitive type.
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'CreateQuaternion'(float32, float32, float32, float32)\n");
-		break;
-	default:
-		mExpression1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mExpression2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mExpression3->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mExpression4->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptQuaternionInitializer::getSize()
-{
-	return 0;
-}
-
-void LLScriptListInitializer::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, "[ ");
-		mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " ]");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		count = 0;
-		if (mExpressionList)
-		{
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "STACKTOL %llu\n", count);
-		}
-		break;
-	case LSCP_TYPE:
-		if (mExpressionList)
-		{
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mReturnType = type = LST_LIST;
-		}
-		mReturnType = type = LST_LIST;
-		break;
-	case LSCP_TO_STACK:
-	{
-		if (mExpressionList)
-		{
-			pass = LSCP_TO_STACK;
-			U64 list_element_count = 0;
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, list_element_count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STACKTOL]);
-			chunk->addInteger((S32)list_element_count);
-			
-		}
-		else
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STACKTOL]);
-			chunk->addInteger(0);
-		}
-		break;
-	}
-	case LSCP_EMIT_CIL_ASSEMBLY:
-	{
-		// Push boxed elements on stack.
-		U64 list_element_count = 0;
-		if (mExpressionList)
-		{
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, list_element_count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-
-		// Create list on stack.
-		fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::CreateList()\n");
-
-		// Call Prepend to add remaining boxed expressions.
-		for(U64 i = 0; i < list_element_count; i++)
-		{
-			fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::Prepend(object, class [mscorlib]System.Collections.ArrayList)\n");
-		}
-		break;
-	}
-	default:
-		if (mExpressionList)
-		{
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptListInitializer::getSize()
-{
-	return 0;
-}
-
-void LLScriptPostIncrement::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "++");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mReturnType == LST_INTEGER)
-			{
-				fprintf(fp, "PUSHARGI 1\n");
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, "ADD integer, integer\n");
-			}
-			else if (mReturnType == LST_FLOATINGPOINT)
-			{
-				fprintf(fp, "PUSHARGF 1\n");
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, "ADD float, float\n");
-			}
-			else
-			{
-				fprintf(fp, "Unexpected Type\n");
-			}
-			print_assignment(fp, mExpression);
-			fprintf(fp, "%s\n", LSCRIPTTypePop[mReturnType]);
-		}
-		break;
-	case LSCP_TYPE:
-		if (mExpression->mType != LET_LVALUE)
-		{
-			gErrorToText.writeError(fp, this, LSERROR_EXPRESSION_ON_LVALUE);
-		}
-		else
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (!legal_unary_expression(type, type, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			else
-			{
-				mReturnType = mLeftType = type;
-			}
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mReturnType == LST_INTEGER)
-			{
-				chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGI]);
-				chunk->addInteger(1);
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				chunk->addByte(LSCRIPTOpCodes[LOPC_ADD]);
-				chunk->addByte(LSCRIPTTypeByte[LST_INTEGER] | LSCRIPTTypeHi4Bits[LST_INTEGER]);
-			}
-			else if (mReturnType == LST_FLOATINGPOINT)
-			{
-				chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGF]);
-				chunk->addFloat(1.f);
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				chunk->addByte(LSCRIPTOpCodes[LOPC_ADD]);
-				chunk->addByte(LSCRIPTTypeByte[LST_FLOATINGPOINT] | LSCRIPTTypeHi4Bits[LST_FLOATINGPOINT]);
-			}
-			store2stack(this, mExpression, chunk, mReturnType);
-			switch(mReturnType)
-			{
-			case LST_INTEGER:
-			case LST_FLOATINGPOINT:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
-				break;
-			case LST_KEY:
-			case LST_STRING:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPS]);
-				break;
-			case LST_LIST:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPL]);
-				break;
-			case LST_VECTOR:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPV]);
-				break;
-			case LST_QUATERNION:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPQ]);
-				break;
-			default:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
-				break;
-			}
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			// Push original value on to stack.
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-
-			// Load address if needed for store.
-			print_cil_load_address(fp, mExpression, entry);
-
-			// Load value again.
-			// TODO: Work out if sideeffects can result in 2 evaluations of expression giving different values.
-			// Original LSL2 uses this method, so any bugs due to side effects will probably be identical ;-)
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mReturnType == LST_INTEGER)
-			{
-				fprintf(fp, "ldc.i4.1\n");
-			}
-			else if (mReturnType == LST_FLOATINGPOINT)
-			{
-				fprintf(fp, "ldc.r8 1\n");
-			}
-			else
-			{
-				fprintf(fp, "Unexpected Type\n");
-			}
-			fprintf(fp, "add\n");
-			print_cil_assignment(fp, mExpression, entry);
-
-			// Pop assignment result to leave original expression result on stack. 
-			// TODO: Optimise away redundant pop/dup pairs.
-			fprintf(fp, "pop\n"); 
-		}
-		break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptPostIncrement::getSize()
-{
-	return 0;
-}
-
-void LLScriptPostDecrement::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "--");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mReturnType == LST_INTEGER)
-			{
-				fprintf(fp, "PUSHARGI 1\n");
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, "SUB integer, integer\n");
-			}
-			else if (mReturnType == LST_FLOATINGPOINT)
-			{
-				fprintf(fp, "PUSHARGF 1\n");
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, "SUB float, float\n");
-			}
-			else
-			{
-				fprintf(fp, "Unexpected Type\n");
-			}
-			print_assignment(fp, mExpression);
-			fprintf(fp, "%s\n", LSCRIPTTypePop[mReturnType]);
-		}
-		break;
-	case LSCP_TYPE:
-		if (mExpression->mType != LET_LVALUE)
-		{
-			gErrorToText.writeError(fp, this, LSERROR_EXPRESSION_ON_LVALUE);
-		}
-		else
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (!legal_unary_expression(type, type, mType))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			else
-			{
-				mReturnType = mLeftType = type;
-			}
-		}
-		break;
-	case LSCP_TO_STACK:
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mReturnType == LST_INTEGER)
-			{
-				chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGI]);
-				chunk->addInteger(1);
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				chunk->addByte(LSCRIPTOpCodes[LOPC_SUB]);
-				chunk->addByte(LSCRIPTTypeByte[LST_INTEGER] | LSCRIPTTypeHi4Bits[LST_INTEGER]);
-			}
-			else if (mReturnType == LST_FLOATINGPOINT)
-			{
-				chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGF]);
-				chunk->addFloat(1.f);
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				chunk->addByte(LSCRIPTOpCodes[LOPC_SUB]);
-				chunk->addByte(LSCRIPTTypeByte[LST_FLOATINGPOINT] | LSCRIPTTypeHi4Bits[LST_FLOATINGPOINT]);
-			}
-			store2stack(this, mExpression, chunk, mReturnType);
-			switch(mReturnType)
-			{
-			case LST_INTEGER:
-			case LST_FLOATINGPOINT:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
-				break;
-			case LST_KEY:
-			case LST_STRING:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPS]);
-				break;
-			case LST_LIST:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPL]);
-				break;
-			case LST_VECTOR:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPV]);
-				break;
-			case LST_QUATERNION:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPQ]);
-				break;
-			default:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
-				break;
-			}
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			// Push original value on to stack.
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-
-			// Load address if needed for store.
-			print_cil_load_address(fp, mExpression, entry);
-
-			// Load value again.
-			// TODO: Work out if sideeffects can result in 2 evaluations of expression giving different values.
-			// Original LSL2 uses this method, so any bugs due to side effects will probably be identical ;-)
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mReturnType == LST_INTEGER)
-			{
-				fprintf(fp, "ldc.i4.1\n");
-			}
-			else if (mReturnType == LST_FLOATINGPOINT)
-			{
-				fprintf(fp, "ldc.r8 1\n");
-			}
-			else
-			{
-				fprintf(fp, "Unexpected Type\n");
-			}
-			fprintf(fp, "sub\n");
-			print_cil_assignment(fp, mExpression, entry);
-
-			// Pop assignment result to leave original expression result on stack. 
-			// TODO: Optimise away redundant pop/dup pairs.
-			fprintf(fp, "pop\n"); 
-		}
-		break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptPostDecrement::getSize()
-{
-	return 0;
-}
-
-// Generate arg list.
-static void print_cil_arg_list(LLFILE *fp, LLScriptArgString& args)
-{
-	int i = 0;
-	bool finished = (i >= args.getNumber());
-	while(! finished)
-	{
-		print_cil_type(fp, args.getType(i));
-		++i;
-		finished = (i >= args.getNumber());
-		if(! finished)
-		{
-			fprintf(fp, ", ");
-		}
-	}
-}
-
-void LLScriptFunctionCall::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "( ");
-		if (mExpressionList)
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		if (mIdentifier->mScopeEntry->mType)
-			fprintf(fp, "%s\n", LSCRIPTTypePush[mIdentifier->mScopeEntry->mType]);
-		fprintf(fp,"PUSHE\n");
-		fprintf(fp, "PUSHBP\n");
-		if (mExpressionList)
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, mIdentifier->mScopeEntry, 0, NULL);
-		fprintf(fp, "PUSHARGE %d\n", mIdentifier->mScopeEntry->mSize - mIdentifier->mScopeEntry->mOffset);
-		fprintf(fp, "PUSHSP\n");
-		fprintf(fp, "PUSHARGI %d\n", mIdentifier->mScopeEntry->mSize);
-		fprintf(fp, "ADD integer, integer\n");
-		fprintf(fp, "POPBP\n");
-		if (mIdentifier->mScopeEntry->mIDType != LIT_LIBRARY_FUNCTION)
-		{
-			fprintf(fp, "CALL ");
-			mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		else
-		{
-			fprintf(fp, "CALLLID ");
-			mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, ", %d", (U32)mIdentifier->mScopeEntry->mLibraryNumber);
-		}
-		fprintf(fp, "\n");
-		fprintf(fp, "POPBP\n");
-		break;
-	case LSCP_SCOPE_PASS1:
-		if (mExpressionList)
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_SCOPE_PASS2:
-		{
-			LLScriptScopeEntry *entry = scope->findEntryTyped(mIdentifier->mName, LIT_FUNCTION);
-			if (!entry)
-			{
-				gErrorToText.writeError(fp, this, LSERROR_UNDEFINED_NAME);
-			}
-			else
-			{
-				// if we did find it, make sure this identifier is associated with the correct scope entry
-				mIdentifier->mScopeEntry = entry;
-			}
-			if (mExpressionList)
-				mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_TYPE:
-		if (mIdentifier->mScopeEntry)
-		{
-			U64 argcount = 0;
-			if (mExpressionList)
-				mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, argcount, chunk, heap, stacksize, mIdentifier->mScopeEntry, 0, NULL);
-
-			if (!mIdentifier->mScopeEntry->mFunctionArgs.mString)
-			{
-				if (argcount)
-				{
-					gErrorToText.writeError(fp, this, LSERROR_FUNCTION_TYPE_ERROR);
-				}
-			}
-			else if (argcount != strlen(mIdentifier->mScopeEntry->mFunctionArgs.mString))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_FUNCTION_TYPE_ERROR);
-			}
-		}
-
-		if (mIdentifier->mScopeEntry)
-			type = mIdentifier->mScopeEntry->mType;
-		else
-			type = LST_NULL;
-		mReturnType = type;
-		break;
-	case LSCP_TO_STACK:
-		switch(mIdentifier->mScopeEntry->mType)
-		{
-		case LST_INTEGER:
-		case LST_FLOATINGPOINT:
-		case LST_STRING:
-		case LST_KEY:
-		case LST_LIST:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHE]);
-			break;
-		case LST_VECTOR:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHEV]);
-			break;
-		case LST_QUATERNION:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHEQ]);
-			break;
-		default:
-			break;
-		}
-		chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHE]);
-		chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHBP]);
-		if (mExpressionList)
-		{
-			// Don't let this change the count.
-			U64 dummy_count = 0;
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, dummy_count, chunk, heap, stacksize, mIdentifier->mScopeEntry, 0, NULL);
-			//mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, mIdentifier->mScopeEntry, 0, NULL);
-		}
-		chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGE]);
-		chunk->addInteger(mIdentifier->mScopeEntry->mSize - mIdentifier->mScopeEntry->mOffset);
-		chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHSP]);
-		chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGI]);
-		chunk->addInteger(mIdentifier->mScopeEntry->mSize);
-		chunk->addByte(LSCRIPTOpCodes[LOPC_ADD]);
-		chunk->addByte(LSCRIPTTypeByte[LST_INTEGER] | LSCRIPTTypeHi4Bits[LST_INTEGER]);
-		chunk->addByte(LSCRIPTOpCodes[LOPC_POPBP]);
-		if (mIdentifier->mScopeEntry->mIDType != LIT_LIBRARY_FUNCTION)
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_CALL]);
-			chunk->addInteger(mIdentifier->mScopeEntry->mCount);
-		}
-		else
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_CALLLIB_TWO_BYTE]);
-			chunk->addU16(mIdentifier->mScopeEntry->mLibraryNumber);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			bool library_call = (mIdentifier->mScopeEntry->mIDType == LIT_LIBRARY_FUNCTION);
-			if(! library_call)
-			{
-				// Load this pointer.
-				fprintf(fp, "ldarg.0\n");
-			}
-
-			// Load args on to stack.
-			if (mExpressionList)
-			{
-				//mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry /* Needed for is_parameter calls */, 0, NULL);
-				llassert(LET_FUNC_EXPRESSION_LIST == mExpressionList->mType);
-				print_cil_func_expression_list((LLScriptFuncExpressionList*) mExpressionList, fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry /* Caller entry needed for is_parameter calls */, 0, NULL, mIdentifier->mScopeEntry /* Callee entry needed for argument casting */);
-			}
-
-			// Make call.
-			if (! library_call)
-			{
-				fprintf(fp, "call instance ");
-			}
-			else
-			{
-				fprintf(fp, "call ");
-			}
-			print_cil_type(fp, mIdentifier->mScopeEntry->mType);
-			fprintf(fp, " class ");
-			if (library_call)
-			{
-				fprintf(fp, "[LslLibrary]LindenLab.SecondLife.Library::'");
-			}
-			else
-			{
-				// Prefix function name with g to distinguish from
-				// event handlers.
-				fprintf(fp, "%s", gScriptp->getClassName());
-				fprintf(fp, "::'g");
-			}
-			fprintf(fp, "%s", mIdentifier->mName);
-			fprintf(fp, "'(");
-			print_cil_arg_list(fp, mIdentifier->mScopeEntry->mFunctionArgs);
-			fprintf(fp, ")\n");
-		}
-		break;
-	default:
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpressionList)
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptFunctionCall::getSize()
-{
-	return 0;
-}
-
-void LLScriptPrint::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fprintf(fp, " PRINT ( ");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "PRINT %s\n", LSCRIPTTypeNames[mLeftType]);
-		break;
-	case LSCP_TYPE:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mLeftType = type;
-		mReturnType = LST_NULL;
-		break;
-	case LSCP_TO_STACK:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		chunk->addByte(LSCRIPTOpCodes[LOPC_PRINT]);
-		chunk->addByte(LSCRIPTTypeByte[mLeftType]);
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-	        mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		print_cil_cast(fp, mLeftType, LST_STRING);
- 	        fprintf(fp, "call void class [LslLibrary]LindenLab.SecondLife.Library::Print(string)");
-	        break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptPrint::getSize()
-{
-	return 0;
-}
-
-void LLScriptConstantExpression::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mConstant->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_TYPE:
-		mConstant->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mReturnType = type;
-		break;
-	case LSCP_TO_STACK:
-		mConstant->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	default:
-		mConstant->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptConstantExpression::getSize()
-{
-	return 0;
-}
-
-void LLScriptStatement::addStatement(LLScriptStatement *event)
-{
-	if (mNextp)
-	{
-		event->mNextp = mNextp;
-	}
-	mNextp = event;
-}
-
-void LLScriptStatement::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	fprintf(fp, "Statement Base Class -- should never get here!\n");
-}
-
-S32 LLScriptStatement::getSize()
-{
-	printf("Statement Base Class -- should never get here!\n");
-	return 0;
-}
-
-void LLScriptStatement::gonext(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		if (mNextp)
-		{
-			fprintf(fp, ", ");
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	default:
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-S32 LLScriptStatementSequence::getSize()
-{
-	return 0;
-}
-
-void LLScriptStatementSequence::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_PRUNE:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (prunearg)
-		{
-			// babbage: only warn on first dead code block found.
-			if(ptype != LSPRUNE_DEAD_CODE)
-			{
-				gErrorToText.writeWarning(fp, this, LSWARN_DEAD_CODE);
-			}
-			
-			// babbage: set prune type to LSPRUNE_DEAD_CODE to mask other
-			// prune errors.
-			ptype = LSPRUNE_DEAD_CODE;
-			
-			// babbage: reset prunearg, to track whether return needed at
-			// end of dead code path as CIL always needs a return/throw.
-			prunearg = FALSE;
-		}
-		mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_TYPE:
-		// pass the return type into all statements so we can check returns
-		{
-			LSCRIPTType	return_type = type;
-			mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, return_type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			return_type = type;
-			mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, return_type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	default:
-		mFirstp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mSecondp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptNOOP::getSize()
-{
-	return 0;
-}
-
-void LLScriptNOOP::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, ";\n");
-		break;
-	case LSCP_PRUNE:
-		prunearg = FALSE;
-		break;
-	default:
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-void add_exit_pops(LLScriptByteCodeChunk *chunk, LLScriptScopeEntry *entry)
-{
-	// remember that we need to pop in reverse order
-	S32 number, i;
-
-	if (entry->mLocals.mString)
-	{
-		number = (S32)strlen(entry->mLocals.mString);
-		for (i = number - 1; i >= 0; i--)
-		{
-			switch(entry->mLocals.getType(i))
-			{
-			case LST_INTEGER:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
-				break;
-			case LST_FLOATINGPOINT:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
-				break;
-			case LST_STRING:
-			case LST_KEY:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPS]);
-				break;
-			case LST_VECTOR:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPV]);
-				break;
-			case LST_QUATERNION:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPQ]);
-				break;
-			case LST_LIST:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPL]);
-				break;
-
-			default:
-				break;
-			}
-		}
-	}
-
-	if (entry->mFunctionArgs.mString)
-	{
-		number = (S32)strlen(entry->mFunctionArgs.mString);
-		for (i = number - 1; i >= 0; i--)
-		{
-			switch(entry->mFunctionArgs.getType(i))
-			{
-			case LST_INTEGER:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
-				break;
-			case LST_FLOATINGPOINT:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
-				break;
-			case LST_STRING:
-			case LST_KEY:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPS]);
-				break;
-			case LST_VECTOR:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPV]);
-				break;
-			case LST_QUATERNION:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPQ]);
-				break;
-			case LST_LIST:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_POPL]);
-				break;
-
-			default:
-				break;
-			}
-		}
-	}
-}
-
-void print_exit_pops(LLFILE *fp, LLScriptScopeEntry *entry)
-{
-	// remember that we need to pop in reverse order
-	S32 number, i;
-
-	if (entry->mLocals.mString)
-	{
-		number = (S32)strlen(entry->mLocals.mString);
-		for (i = number - 1; i >= 0; i--)
-		{
-			fprintf(fp, "%s", LSCRIPTTypePop[entry->mLocals.getType(i)]);
-		}
-	}
-
-	if (entry->mFunctionArgs.mString)
-	{
-		number = (S32)strlen(entry->mFunctionArgs.mString);
-		for (i = number - 1; i >= 0; i--)
-		{
-			fprintf(fp, "%s", LSCRIPTTypePop[entry->mFunctionArgs.getType(i)]);
-		}
-	}
-}
-
-
-S32 LLScriptStateChange::getSize()
-{
-	return 0;
-}
-
-void LLScriptStateChange::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "state ");
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ";\n");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		print_exit_pops(fp, entry);
-		fprintf(fp, "STATE ");
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "\n");
-		break;
-	case LSCP_PRUNE:
-		if (  (ptype == LSPRUNE_GLOBAL_VOIDS)
-			||(ptype == LSPRUNE_GLOBAL_NON_VOIDS))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_STATE_CHANGE_IN_GLOBAL);
-		}
-		prunearg = FALSE;
-		break;
-	case LSCP_SCOPE_PASS2:
-		{
-			LLScriptScopeEntry *entry = scope->findEntryTyped(mIdentifier->mName, LIT_STATE);
-			if (!entry)
-			{
-				gErrorToText.writeError(fp, this, LSERROR_UNDEFINED_NAME);
-			}
-			else
-			{
-				// if we did find it, make sure this identifier is associated with the correct scope entry
-				mIdentifier->mScopeEntry = entry;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			add_exit_pops(chunk, entry);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_STATE]);
-			chunk->addInteger(mIdentifier->mScopeEntry->mCount);
-		}
-		break;
-	case LSCP_TYPE:
-		mReturnType = basetype;
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "ldarg.0\n");
-		fprintf(fp, "ldstr \"%s\"\n", mIdentifier->mName);
-		fprintf(fp, "call instance void class [LslUserScript]LindenLab.SecondLife.LslUserScript::ChangeState(string)\n");
-		// We are doing a state change. In the LSL interpreter, this is basically a longjmp. We emulate it
-		// here using a call to the ChangeState followed by a short cut return of the current method. To
-		// maintain type safety we need to push an arbitrary variable of the current method's return type
-		// onto the stack before returning. This will be ignored and discarded.
-		print_cil_init_variable(fp, mReturnType);
-		fprintf(fp, "ret\n");
-		break;
-	default:
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptJump::getSize()
-{
-	return 0;
-}
-
-void LLScriptJump::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "jump ");
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ";\n");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "JUMP ");
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "\n");
-		break;
-	case LSCP_PRUNE:
-		prunearg = FALSE;
-		break;
-	case LSCP_SCOPE_PASS2:
-		{
-			LLScriptScopeEntry *entry = scope->findEntryTyped(mIdentifier->mName, LIT_LABEL);
-			if (!entry)
-			{
-				gErrorToText.writeError(fp, this, LSERROR_UNDEFINED_NAME);
-			}
-			else
-			{
-				// if we did find it, make sure this identifier is associated with the correct scope entry
-				mIdentifier->mScopeEntry = entry;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			chunk->addByte(LSCRIPTOpCodes[LOPC_JUMP]);
-			chunk->addBytes(LSCRIPTDataSize[LST_INTEGER]);
-			chunk->addJump(mIdentifier->mName);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		fprintf(fp, "br ");
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "\n");
-		break;
-	default:
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptLabel::getSize()
-{
-	return 0;
-}
-
-void LLScriptLabel::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "@");
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ";\n");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		fprintf(fp, "LABEL ");
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "\n");
-		break;
-	case LSCP_PRUNE:
-		// Always clear this flag, to stop pruning after return statements.  A jump
-		// might start up code at this label, so we need to stop pruning.
-		prunearg = FALSE;
-		break;
-	case LSCP_SCOPE_PASS1:
-		// add labels to scope
-		if (scope->checkEntry(mIdentifier->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mIdentifier->mScopeEntry = scope->addEntry(mIdentifier->mName, LIT_LABEL, LST_NULL);
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			chunk->addLabel(mIdentifier->mName);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ":\n");
-		break;
-	default:
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-void add_return(LLScriptByteCodeChunk *chunk, LLScriptScopeEntry *entry)
-{
-	add_exit_pops(chunk, entry);
-	chunk->addByte(LSCRIPTOpCodes[LOPC_RETURN]);
-}
-
-void print_return(LLFILE *fp, LLScriptScopeEntry *entry)
-{
-	print_exit_pops(fp, entry);
-	fprintf(fp, "RETURN\n");
-}
-
-
-S32 LLScriptReturn::getSize()
-{
-	return 0;
-}
-
-void LLScriptReturn::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		if (mExpression)
-		{
-			fdotabs(fp, tabs, tabsize);
-			fprintf(fp, "return ");
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, ";\n");
-		}
-		else
-		{
-			fdotabs(fp, tabs, tabsize);
-			fprintf(fp, "return;\n");
-		}
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		if (mExpression)
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "%s\n", LSCRIPTTypeReturn[mType]);
-		}
-		print_return(fp, entry);
-		break;
-	case LSCP_PRUNE:
-		if (  (ptype == LSPRUNE_GLOBAL_VOIDS)
-			||(ptype == LSPRUNE_EVENTS))
-		{
-			if (mExpression)
-			{
-				gErrorToText.writeError(fp, this, LSERROR_INVALID_RETURN);
-			}
-		}
-		else if (ptype == LSPRUNE_GLOBAL_NON_VOIDS)
-		{
-			if (!mExpression)
-			{
-				gErrorToText.writeError(fp, this, LSERROR_INVALID_VOID_RETURN);
-			}
-		}
-		prunearg = TRUE;
-	case LSCP_TYPE:
-		// if there is a return expression, it must be promotable to the return type of the function
-		if (mExpression)
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (!legal_assignment(basetype, type))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-			else
-			{
-				mType = basetype;
-			}
-		}
-		else if (basetype != LST_NULL)
-		{
-		        gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		if (mExpression)
-		{
-			mExpression->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			switch(mType)
-			{
-			case LST_INTEGER:
-			case LST_FLOATINGPOINT:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_LOADP]);
-				chunk->addInteger(-12);
-				break;
-			case LST_STRING:
-			case LST_KEY:
-				// use normal store for reference counted types
-				chunk->addByte(LSCRIPTOpCodes[LOPC_LOADSP]);
-				chunk->addInteger(-12);
-				break;
-			case LST_LIST:
-				// use normal store for reference counted types
-				chunk->addByte(LSCRIPTOpCodes[LOPC_LOADLP]);
-				chunk->addInteger(-12);
-				break;
-			case LST_VECTOR:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_LOADVP]);
-				chunk->addInteger(-20);
-				break;
-			case LST_QUATERNION:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_LOADQP]);
-				chunk->addInteger(-24);
-				break;
-			default:
-				chunk->addByte(LSCRIPTOpCodes[LOPC_LOADP]);
-				chunk->addInteger(-12);
-				break;
-			}
-		}
-		add_return(chunk, entry);
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		if (mExpression)
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_cast(fp, mExpression->mReturnType, mType);
-		}
-		fprintf(fp, "ret\n");
-		break;
-	default:
-		if (mExpression)
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptExpressionStatement::getSize()
-{
-	return 0;
-}
-
-void LLScriptExpressionStatement::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ";\n");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mExpression->mReturnType)
-		{
-			fprintf(fp, "%s\n", LSCRIPTTypePop[mExpression->mReturnType]);
-		}
-		break;
-	case LSCP_PRUNE:
-		prunearg = FALSE;
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		mExpression->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		switch(mExpression->mReturnType)
-		{
-		case LST_INTEGER:
-		case LST_FLOATINGPOINT:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_POP]);
-			break;
-		case LST_STRING:
-		case LST_KEY:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_POPS]);
-			break;
-		case LST_LIST:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_POPL]);
-			break;
-		case LST_VECTOR:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_POPV]);
-			break;
-		case LST_QUATERNION:
-			chunk->addByte(LSCRIPTOpCodes[LOPC_POPQ]);
-			break;
-		default:
-			break;
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if(mExpression->mReturnType)
-		{
-			fprintf(fp, "pop\n");
-		}
-		break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptIf::getSize()
-{
-	return 0;
-}
-
-static void print_cil_if_test(LLFILE* fp, LSCRIPTType type)
-{
-	switch(type)
-	{
-	case LST_INTEGER:
-		break;
-	case LST_FLOATINGPOINT:
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "ceq\n");
-		fprintf(fp, "ldc.i4.0\n");
-		fprintf(fp, "ceq\n");
-		break;
-	case LST_VECTOR:
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Vector class [LslUserScript]LindenLab.SecondLife.LslUserScript::'CreateVector'(float32, float32, float32)\n");
-		fprintf(fp, "call bool [LslUserScript]LindenLab.SecondLife.LslUserScript::'Equals'(class [ScriptTypes]LindenLab.SecondLife.Vector, class [ScriptTypes]LindenLab.SecondLife.Vector)\n");
-		fprintf(fp, "ldc.i4.0\n");
-		fprintf(fp, "ceq\n");
-		break;
-	case LST_QUATERNION:
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "ldc.r8 0\n");
-		fprintf(fp, "ldc.r8 1\n");
-		fprintf(fp, "call class [ScriptTypes]LindenLab.SecondLife.Quaternion class [LslUserScript]LindenLab.SecondLife.LslUserScript::'CreateQuaternion'(float32, float32, float32, float32)\n");
-		fprintf(fp, "call bool [LslUserScript]LindenLab.SecondLife.LslUserScript::'Equals'(class [ScriptTypes]LindenLab.SecondLife.Quaternion, class [ScriptTypes]LindenLab.SecondLife.Quaternion)\n");
-		fprintf(fp, "ldc.i4.0\n");
-		fprintf(fp, "ceq\n");
-		break;
-	case LST_KEY:
-		fprintf(fp, "call bool [LslUserScript]LindenLab.SecondLife.LslUserScript::'IsNonNullUuid'(valuetype [ScriptTypes]LindenLab.SecondLife.Key)\n");
-		break;		
-	case LST_STRING:
-		fprintf(fp, "ldstr \"\"\n");
-		fprintf(fp, "call bool string::op_Equality(string, string)\n");
-		fprintf(fp, "ldc.i4.0\n");
-		fprintf(fp, "ceq\n");
-		break;
-	case LST_LIST:
-		fprintf(fp, "call class [mscorlib]System.Collections.ArrayList class [LslUserScript]LindenLab.SecondLife.LslUserScript::CreateList()\n");
-		fprintf(fp, "call bool [LslUserScript]LindenLab.SecondLife.LslUserScript::Equals(class [mscorlib]System.Collections.ArrayList, class [mscorlib]System.Collections.ArrayList)\n");
-		fprintf(fp, "ldc.i4.0\n");
-		fprintf(fp, "ceq\n");
-		break;		
-	default:
-		break;
-	}
-
-}
-
-void LLScriptIf::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "if ( ");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			S32 tjump =  gTempJumpCount++;
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "JUMPNIF ##Temp Jump %d##\n", tjump);
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "LABEL ##Temp Jump %d##\n", tjump);
-		}
-		break;
-	case LSCP_PRUNE:
-		prunearg = FALSE;
-		break;
-	case LSCP_TYPE:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (type == LST_NULL)
-		{
-			gErrorToText.writeError(fp, mExpression, LSERROR_TYPE_MISMATCH);
-		}
-		mType = type;
-		mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);		
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			char jumpname[32];	 	/*Flawfinder: ignore*/
-			snprintf(jumpname, sizeof(jumpname),"##Temp Jump %d##", gTempJumpCount++); 	/* Flawfinder: ignore */
-
-			mExpression->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_JUMPNIF]);
-			chunk->addByte(LSCRIPTTypeByte[mType]);
-			chunk->addBytes(LSCRIPTDataSize[LST_INTEGER]);
-			chunk->addJump(jumpname);
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addLabel(jumpname);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			S32 tjump = gTempJumpCount++;
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_if_test(fp, mExpression->mReturnType);
-			fprintf(fp, "brfalse LabelTempJump%d\n", tjump);
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "LabelTempJump%d:\n", tjump);
-		}
-		break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptIfElse::getSize()
-{
-	return 0;
-}
-
-void LLScriptIfElse::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "if ( ");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		mStatement1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "else\n");
-		mStatement2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			S32 tjump1 =  gTempJumpCount++;
-			S32 tjump2 =  gTempJumpCount++;
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "JUMPNIF ##Temp Jump %d##\n", tjump1);
-			mStatement1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "JUMP ##Temp Jump %d##\n", tjump2);
-			fprintf(fp, "LABEL ##Temp Jump %d##\n", tjump1);
-			mStatement2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "LABEL ##Temp Jump %d##\n", tjump2);
-		}
-		break;
-	case LSCP_PRUNE:
-		{
-			BOOL arg1 = TRUE, arg2 = TRUE;
-			mStatement1->recurse(fp, tabs, tabsize, pass, ptype, arg1, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mStatement2->recurse(fp, tabs, tabsize, pass, ptype, arg2, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			prunearg = arg1 && arg2;
-		}
-		break;
-	case LSCP_TYPE:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (type == LST_NULL)
-		{
-			gErrorToText.writeError(fp, mExpression, LSERROR_TYPE_MISMATCH);
-		}
-		mType = type;
-		mStatement1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mStatement2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			char jumpname1[32]; 				/*Flawfinder: ignore*/
-			snprintf(jumpname1, sizeof(jumpname1), "##Temp Jump %d##", gTempJumpCount++); 	/* Flawfinder: ignore */
-			char jumpname2[32];			 	/*Flawfinder: ignore*/
-			snprintf(jumpname2, sizeof(jumpname2), "##Temp Jump %d##", gTempJumpCount++);	 /* Flawfinder: ignore */
-
-			mExpression->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_JUMPNIF]);
-			chunk->addByte(LSCRIPTTypeByte[mType]);
-			chunk->addBytes(LSCRIPTDataSize[LST_INTEGER]);
-			chunk->addJump(jumpname1);
-			mStatement1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_JUMP]);
-			chunk->addBytes(LSCRIPTDataSize[LST_INTEGER]);
-			chunk->addJump(jumpname2);
-			chunk->addLabel(jumpname1);
-			mStatement2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addLabel(jumpname2);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			S32 tjump1 =  gTempJumpCount++;
-			S32 tjump2 =  gTempJumpCount++;
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_if_test(fp, mExpression->mReturnType);
-			fprintf(fp, "brfalse LabelTempJump%d\n", tjump1);
-			mStatement1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "br LabelTempJump%d\n", tjump2);
-			fprintf(fp, "LabelTempJump%d:\n", tjump1);
-			mStatement2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "LabelTempJump%d:\n", tjump2);
-		}
-		break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mStatement1->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mStatement2->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	};
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptFor::getSize()
-{
-	return 0;
-}
-
-void LLScriptFor::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "for ( ");
-		if(mSequence)
-			mSequence->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " ; ");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " ; ");
-		if(mExpressionList)
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		if(mStatement)
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			S32 tjump1 =  gTempJumpCount++;
-			S32 tjump2 =  gTempJumpCount++;
-			if(mSequence)
-				mSequence->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "LABEL ##Temp Jump %d##\n", tjump1);
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "JUMPNIF ##Temp Jump %d##\n", tjump2);
-			if(mStatement)
-				mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if(mExpressionList)
-				mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "JUMP ##Temp Jump %d##\n", tjump1);
-			fprintf(fp, "LABEL ##Temp Jump %d##\n", tjump2);
-		}
-		break;
-	case LSCP_PRUNE:
-		prunearg = FALSE;
-		break;
-	case LSCP_TYPE:
-		if(mSequence)
-			mSequence->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (type == LST_NULL)
-		{
-			gErrorToText.writeError(fp, mExpression, LSERROR_TYPE_MISMATCH);
-		}
-		mType = type;
-		if(mExpressionList)
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if(mStatement)
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			char jumpname1[32];		 	/*Flawfinder: ignore*/
-			snprintf(jumpname1, sizeof(jumpname1), "##Temp Jump %d##", gTempJumpCount++); 	/* Flawfinder: ignore */
-			char jumpname2[32];			 	/*Flawfinder: ignore*/
-			snprintf(jumpname2, sizeof(jumpname2), "##Temp Jump %d##", gTempJumpCount++);	 	/* Flawfinder: ignore */
-
-			if(mSequence)
-				mSequence->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addLabel(jumpname1);
-			mExpression->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_JUMPNIF]);
-			chunk->addByte(LSCRIPTTypeByte[mType]);
-			chunk->addBytes(LSCRIPTDataSize[LST_INTEGER]);
-			chunk->addJump(jumpname2);
-			if(mStatement)
-				mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if(mExpressionList)
-				mExpressionList->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_JUMP]);
-			chunk->addBytes(LSCRIPTDataSize[LST_INTEGER]);
-			chunk->addJump(jumpname1);
-			chunk->addLabel(jumpname2);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			S32 tjump1 =  gTempJumpCount++;
-			S32 tjump2 =  gTempJumpCount++;
-			if(mSequence)
-				mSequence->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "LabelTempJump%d:\n", tjump1);
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_if_test(fp, mExpression->mReturnType);
-			fprintf(fp, "brfalse LabelTempJump%d\n", tjump2);
-			if(mStatement)
-				mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if(mExpressionList)
-				mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "br LabelTempJump%d\n", tjump1);
-			fprintf(fp, "LabelTempJump%d:\n", tjump2);
-		}
-		break;
-	default:
-		if(mSequence)
-			mSequence->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if(mExpressionList)
-			mExpressionList->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if(mStatement)
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptDoWhile::getSize()
-{
-	return 0;
-}
-
-void LLScriptDoWhile::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "do\n");
-		mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "while( ");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " );\n");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			S32 tjump1 =  gTempJumpCount++;
-			fprintf(fp, "LABEL ##Temp Jump %d##\n", tjump1);
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "JUMPIF ##Temp Jump %d##\n", tjump1);
-		}
-		break;
-	case LSCP_PRUNE:
-		prunearg = FALSE;
-		break;
-	case LSCP_TYPE:
-		mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (type == LST_NULL)
-		{
-			gErrorToText.writeError(fp, mExpression, LSERROR_TYPE_MISMATCH);
-		}
-		mType = type;
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			char jumpname1[32];	 	/*Flawfinder: ignore*/
-			snprintf(jumpname1, sizeof(jumpname1), "##Temp Jump %d##", gTempJumpCount++);	 	/* Flawfinder: ignore */
-
-			chunk->addLabel(jumpname1);
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mExpression->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_JUMPIF]);
-			chunk->addByte(LSCRIPTTypeByte[mType]);
-			chunk->addBytes(LSCRIPTDataSize[LST_INTEGER]);
-			chunk->addJump(jumpname1);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			S32 tjump1 =  gTempJumpCount++;
-			fprintf(fp, "LabelTempJump%d:\n", tjump1);
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_if_test(fp, mExpression->mReturnType);
-			fprintf(fp, "brtrue LabelTempJump%d\n", tjump1);
-		}
-		break;
-	default:
-		mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptWhile::getSize()
-{
-	return 0;
-}
-
-void LLScriptWhile::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "while( ");
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " )\n");
-		mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		{
-			S32 tjump1 =  gTempJumpCount++;
-			S32 tjump2 =  gTempJumpCount++;
-			fprintf(fp, "LABEL ##Temp Jump %d##\n", tjump1);
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "JUMPNIF ##Temp Jump %d##\n", tjump2);
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "JUMP ##Temp Jump %d##\n", tjump1);
-			fprintf(fp, "LABEL ##Temp Jump %d##\n", tjump2);
-		}
-		break;
-	case LSCP_PRUNE:
-		prunearg = FALSE;
-		break;
-	case LSCP_TYPE:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (type == LST_NULL)
-		{
-			gErrorToText.writeError(fp, mExpression, LSERROR_TYPE_MISMATCH);
-		}
-		mType = type;
-		mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			char jumpname1[32]; 	/*Flawfinder: ignore*/
-			snprintf(jumpname1, sizeof(jumpname1), "##Temp Jump %d##", gTempJumpCount++); 	/* Flawfinder: ignore */
-			char jumpname2[32]; 	/*Flawfinder: ignore*/
-			snprintf(jumpname2, sizeof(jumpname2), "##Temp Jump %d##", gTempJumpCount++); 	/* Flawfinder: ignore */
-
-			chunk->addLabel(jumpname1);
-			mExpression->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_JUMPNIF]);
-			chunk->addByte(LSCRIPTTypeByte[mType]);
-			chunk->addBytes(LSCRIPTDataSize[LST_INTEGER]);
-			chunk->addJump(jumpname2);
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			chunk->addByte(LSCRIPTOpCodes[LOPC_JUMP]);
-			chunk->addBytes(LSCRIPTDataSize[LST_INTEGER]);
-			chunk->addJump(jumpname1);
-			chunk->addLabel(jumpname2);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			S32 tjump1 =  gTempJumpCount++;
-			S32 tjump2 =  gTempJumpCount++;
-			fprintf(fp, "LabelTempJump%d:\n", tjump1);
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_if_test(fp, mExpression->mReturnType);
-			fprintf(fp, "brfalse LabelTempJump%d\n", tjump2);
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "br LabelTempJump%d\n", tjump1);
-			fprintf(fp, "LabelTempJump%d:\n", tjump2);
-		}
-		break;
-	default:
-		mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptDeclaration::getSize()
-{
-	return mType->getSize();
-}
-
-void LLScriptDeclaration::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		if (mExpression)
-		{
-			fdotabs(fp, tabs, tabsize);
-			mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "\t");
-			mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, " = ");
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, ";\n");
-		}
-		else
-		{
-			fdotabs(fp, tabs, tabsize);
-			mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "\t");
-			mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, ";\n");
-		}
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		if (mExpression)
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-			{
-				fprintf(fp, "%s%d [%s]\n", LSCRIPTTypeLocalDeclaration[mIdentifier->mScopeEntry->mType], mIdentifier->mScopeEntry->mOffset, mIdentifier->mName);
-			}
-			else if (mIdentifier->mScopeEntry->mIDType == LIT_GLOBAL)
-			{
-				gErrorToText.writeError(fp, this, LSERROR_UNDEFINED_NAME);
-			}
-		}
-		break;
-	case LSCP_PRUNE:
-		prunearg = FALSE;
-		break;
-	case LSCP_SCOPE_PASS1:
-		// Check to see if a declaration is valid here.
-		if (!mAllowDeclarations)
-		{
-			gErrorToText.writeError(fp, this, LSERROR_NEED_NEW_SCOPE);
-		}
-		// add labels to scope
-		else if (scope->checkEntry(mIdentifier->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			if (mExpression)
-			{
-				mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			}
-			// this needs to go after expression decent to make sure that we don't add ourselves or something silly
-			// check expression if it exists
-			mIdentifier->mScopeEntry = scope->addEntry(mIdentifier->mName, LIT_VARIABLE, mType->mType);
-		}
-		break;
-	case LSCP_TYPE:
-		// if there is an expression, it must be promotable to variable type
-		if (mExpression && mIdentifier->mScopeEntry)
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (!legal_assignment(mIdentifier->mScopeEntry->mType, type))
-			{
-				gErrorToText.writeError(fp, this, LSERROR_TYPE_MISMATCH);
-			}
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			mIdentifier->mScopeEntry->mOffset = (S32)count;
-			mIdentifier->mScopeEntry->mSize = mType->getSize();
-			count += mIdentifier->mScopeEntry->mSize;
-			// Index into locals is current number of locals. Stored in mCount member of mScopeEntry.
-			mIdentifier->mScopeEntry->mCount = entry->mLocals.getNumber();
-			entry->mLocals.addType(mType->mType);
-			mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		if (mExpression)
-		{
-			mExpression->recurse(fp, tabs, tabsize, LSCP_TO_STACK, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (mExpression->mReturnType != mIdentifier->mScopeEntry->mType)
-			{
-				cast2stack(chunk, mExpression->mReturnType, mIdentifier->mScopeEntry->mType);
-			}
-			switch(mExpression->mReturnType)
-			{
-			case LST_INTEGER:
-			case LST_FLOATINGPOINT:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_LOADP]);
-				}
-				break;
-			case LST_STRING:
-			case LST_KEY:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_LOADSP]);
-				}
-				break;
-			case LST_LIST:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_LOADLP]);
-				}
-				break;
-			case LST_VECTOR:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_LOADVP]);
-				}
-				break;
-			case LST_QUATERNION:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_LOADQP]);
-				}
-				break;
-			default:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_LOADP]);
-				}
-				break;
-			}
-			if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-			{
-				S32 address = mIdentifier->mScopeEntry->mOffset;
-				chunk->addInteger(address);
-			}
-		}
-		else
-		{
-			switch(mIdentifier->mScopeEntry->mType)
-			{
-			case LST_INTEGER:
-			case LST_FLOATINGPOINT:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGI]);
-					chunk->addInteger(0);
-					chunk->addByte(LSCRIPTOpCodes[LOPC_LOADP]);
-				}
-				break;
-			case LST_STRING:
-			case LST_KEY:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGS]);
-					chunk->addBytes("", 1);
-					chunk->addByte(LSCRIPTOpCodes[LOPC_LOADSP]);
-				}
-				break;
-			case LST_LIST:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_STACKTOL]);
-					chunk->addInteger(0);
-					chunk->addByte(LSCRIPTOpCodes[LOPC_LOADLP]);
-				}
-				break;
-			case LST_VECTOR:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGV]);
-					chunk->addFloat(0);
-					chunk->addFloat(0);
-					chunk->addFloat(0);
-					chunk->addByte(LSCRIPTOpCodes[LOPC_LOADVP]);
-				}
-				break;
-			case LST_QUATERNION:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGQ]);
-					chunk->addFloat(1);
-					chunk->addFloat(0);
-					chunk->addFloat(0);
-					chunk->addFloat(0);
-					chunk->addByte(LSCRIPTOpCodes[LOPC_LOADQP]);
-				}
-				break;
-			default:
-				if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-				{
-					chunk->addByte(LSCRIPTOpCodes[LOPC_PUSHARGI]);
-					chunk->addInteger(0);
-					chunk->addByte(LSCRIPTOpCodes[LOPC_LOADP]);
-				}
-				break;
-			}
-			if (mIdentifier->mScopeEntry->mIDType == LIT_VARIABLE)
-			{
-				S32 address = mIdentifier->mScopeEntry->mOffset;
-				chunk->addInteger(address);
-			}
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		if (mExpression)
-		{
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			print_cil_cast(fp, mExpression->mReturnType, mIdentifier->mScopeEntry->mType);
-		}
-		else
-		{
-			print_cil_init_variable(fp, mIdentifier->mScopeEntry->mType);
-		}
-		fprintf(fp, "stloc.s %d\n", mIdentifier->mScopeEntry->mCount);
-		break;
-	default:
-		if (mExpression)
-		{
-			mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mExpression->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		else
-		{
-			mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-S32 LLScriptCompoundStatement::getSize()
-{
-	return 0;
-}
-
-void LLScriptCompoundStatement::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		if (mStatement)
-		{
-			fdotabs(fp, tabs, tabsize);
-			fprintf(fp, "{\n");
-			mStatement->recurse(fp, tabs + 1, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fdotabs(fp, tabs, tabsize);
-			fprintf(fp, "}\n");
-		}
-		else
-		{
-			fdotabs(fp, tabs, tabsize);
-			fprintf(fp, "{\n");
-			fdotabs(fp, tabs, tabsize);
-			fprintf(fp, "}\n");
-		}
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		if (mStatement)
-		{
-			mStatement->recurse(fp, tabs + 1, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_PRUNE:
-		if (mStatement)
-		{
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		else
-		{
-			prunearg = FALSE;
-		}
-		break;
-	case LSCP_SCOPE_PASS1:
-		// compound statements create a new scope
-		if (mStatement)
-		{
-			mStatementScope = new LLScriptScope(gScopeStringTable);
-			mStatementScope->addParentScope(scope);
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mStatementScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_SCOPE_PASS2:
-		// compound statements create a new scope
-		if (mStatement)
-		{
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mStatementScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	default:
-		if (mStatement)
-		{
-			mStatement->recurse(fp, tabs + 1, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-void LLScriptEventHandler::addEvent(LLScriptEventHandler *event)
-{
-	if (mNextp)
-	{
-		event->mNextp = mNextp;
-	}
-	mNextp = event;
-}
-
-void LLScriptEventHandler::gonext(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	default:
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-S32 LLScriptEventHandler::getSize()
-{
-	return mStackSpace;
-}
-
-U64 gCurrentHandler = 0;
-
-static void print_cil_local_init(LLFILE* fp, LLScriptScopeEntry* scopeEntry)
-{
-	if(scopeEntry->mLocals.getNumber() > 0)
-	{
-		fprintf(fp, ".locals init (");
-		for(int local = 0; local < scopeEntry->mLocals.getNumber(); ++local)
-		{
-			if(local > 0)
-			{
-				fprintf(fp, ", ");
-			}
-			print_cil_type(fp, scopeEntry->mLocals.getType(local));
-		}
-		fprintf(fp, ")\n");
-	}
-}
-
-void LLScriptEventHandler::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		mEventp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mStatement)
-		{
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		else
-		{
-			fdotabs(fp, tabs, tabsize);
-			fprintf(fp, "{\n");
-			fdotabs(fp, tabs, tabsize);
-			fprintf(fp, "}\n");
-		}
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mEventp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mStatement)
-		{
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, getSize(), mScopeEntry, entrycount, NULL);
-		}
-		if (mbNeedTrailingReturn)
-		{
-			print_return(fp, mScopeEntry);
-		}
-		fprintf(fp, "\n");
-		break;
-	case LSCP_PRUNE:
-		mbNeedTrailingReturn = FALSE;
-		prunearg = TRUE;
-		mStatement->recurse(fp, tabs, tabsize, pass, LSPRUNE_EVENTS, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (!prunearg)
-		{
-			// this means that we didn't end with a return statement, need to add one
-			mbNeedTrailingReturn = TRUE;
-		}
-		break;
-	case LSCP_SCOPE_PASS1:
-		// create event level scope
-		mEventScope = new LLScriptScope(gScopeStringTable);
-		mEventScope->addParentScope(scope);
-
-		// add event parameters
-		mEventp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mEventScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-
-		mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mEventScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_SCOPE_PASS2:
-		mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mEventScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_TYPE:
-		mScopeEntry = new LLScriptScopeEntry("Event", LIT_HANDLER, LST_NULL);
-		switch(mEventp->mType)
-		{
-		case LSTT_STATE_ENTRY:
-			break;
-		case LSTT_STATE_EXIT:
-			break;
-		case LSTT_TOUCH_START:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_TOUCH:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_TOUCH_END:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_COLLISION_START:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_COLLISION:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_COLLISION_END:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_LAND_COLLISION_START:
-			mScopeEntry->mFunctionArgs.addType(LST_VECTOR);
-			break;
-		case LSTT_LAND_COLLISION:
-			mScopeEntry->mFunctionArgs.addType(LST_VECTOR);
-			break;
-		case LSTT_LAND_COLLISION_END:
-			mScopeEntry->mFunctionArgs.addType(LST_VECTOR);
-			break;
-		case LSTT_INVENTORY:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_ATTACH:
-			mScopeEntry->mFunctionArgs.addType(LST_KEY);
-			break;
-		case LSTT_DATASERVER:
-			mScopeEntry->mFunctionArgs.addType(LST_KEY);
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			break;
-		case LSTT_TIMER:
-			break;
-		case LSTT_MOVING_START:
-			break;
-		case LSTT_MOVING_END:
-			break;
-		case LSTT_OBJECT_REZ:
-			mScopeEntry->mFunctionArgs.addType(LST_KEY);
-			break;
-		case LSTT_REMOTE_DATA:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			mScopeEntry->mFunctionArgs.addType(LST_KEY);
-			mScopeEntry->mFunctionArgs.addType(LST_KEY);
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			break;
-		case LSTT_CHAT:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			mScopeEntry->mFunctionArgs.addType(LST_KEY);
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			break;
-		case LSTT_SENSOR:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_CONTROL:
-			mScopeEntry->mFunctionArgs.addType(LST_KEY);
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_LINK_MESSAGE:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			mScopeEntry->mFunctionArgs.addType(LST_KEY);
-			break;
-		case LSTT_MONEY:
-			mScopeEntry->mFunctionArgs.addType(LST_KEY);
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_EMAIL:
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_REZ:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_NO_SENSOR:
-			break;
-		case LSTT_AT_TARGET:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			mScopeEntry->mFunctionArgs.addType(LST_VECTOR);
-			mScopeEntry->mFunctionArgs.addType(LST_VECTOR);
-			break;
-		case LSTT_NOT_AT_TARGET:
-			break;
-		case LSTT_AT_ROT_TARGET:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			mScopeEntry->mFunctionArgs.addType(LST_QUATERNION);
-			mScopeEntry->mFunctionArgs.addType(LST_QUATERNION);
-			break;
-		case LSTT_NOT_AT_ROT_TARGET:
-			break;
-		case LSTT_RTPERMISSIONS:
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			break;
-		case LSTT_HTTP_RESPONSE:
-			mScopeEntry->mFunctionArgs.addType(LST_KEY);
-			mScopeEntry->mFunctionArgs.addType(LST_INTEGER);
-			mScopeEntry->mFunctionArgs.addType(LST_LIST);
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			break;
-		case LSTT_HTTP_REQUEST:
-			mScopeEntry->mFunctionArgs.addType(LST_KEY);
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			mScopeEntry->mFunctionArgs.addType(LST_STRING);
-			break;
-
-		default:
-			break;
-		}
-		mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_RESOURCE:
-		// first determine resource counts for globals
-		count = 0;
-		mEventp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-
-		// Store offset of first local as with global functions, so locals and arguments can be distinguished with is_parameter when compiling to CIL.
-		mScopeEntry->mOffset = (S32) count;
-
-		if (mStatement)
-		{
-			entrycount = 0;
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, mScopeEntry, entrycount, NULL);
-
-			const char *function_args = mScopeEntry->mFunctionArgs.mString;
-			fprintf(fp, "Function Args: %s\n", function_args?function_args:"");
-
-			const char *local_list = mScopeEntry->mLocals.mString;
-			fprintf(fp, "Local List: %s\n", local_list?local_list:"");
-		}
-		mStackSpace = (S32)count;
-		break;
-	case LSCP_DETERMINE_HANDLERS:
-		count |= LSCRIPTStateBitField[mEventp->mType];
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			llassert(mEventp);
-			if (!mEventp) return;
-
-			// order for event handler
-			// set jump table value
-			S32 jumpoffset;
-			jumpoffset = LSCRIPTDataSize[LST_INTEGER]*get_event_handler_jump_position(gCurrentHandler, mEventp->mType)*2;
-
-			integer2bytestream(chunk->mCodeChunk, jumpoffset, chunk->mCurrentOffset);
-
-			// 0 - 3: offset to actual data
-			S32 offsetoffset = chunk->mCurrentOffset;
-			S32 offsetdelta = 0;
-			chunk->addBytes(4);
-
-			// null terminated event name and null terminated parameters
-			LLScriptByteCodeChunk	*event = new LLScriptByteCodeChunk(FALSE);
-			mEventp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, event, heap, stacksize, entry, entrycount, NULL);
-			chunk->addBytes(event->mCodeChunk, event->mCurrentOffset);
-			delete event;
-		
-			chunk->addBytes(1);
-
-			// now we're at the first opcode
-			offsetdelta = chunk->mCurrentOffset - offsetoffset;
-			integer2bytestream(chunk->mCodeChunk, offsetoffset, offsetdelta);
-
-			// get ready to compute the number of bytes of opcode
-			offsetdelta = chunk->mCurrentOffset;
-
-			if (mStatement)
-			{
-				LLScriptByteCodeChunk	*statements = new LLScriptByteCodeChunk(TRUE);
-				mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, statements, heap, getSize(), mScopeEntry, entrycount, NULL);
-				statements->connectJumps();
-				chunk->addBytes(statements->mCodeChunk, statements->mCurrentOffset);
-				delete statements;
-			}
-			if (mbNeedTrailingReturn)
-			{
-				add_return(chunk, mScopeEntry);
-			}
-			// now stuff in the number of bytes of stack space that this routine needs
-			integer2bytestream(chunk->mCodeChunk, jumpoffset, getSize());
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-
-		// Method signature prefix.
-		fprintf(fp, ".method public hidebysig instance default void ");
-
-		// Mangle event handler name by prefixing it with state name.
-		// Allows state changing by finding handlers prefixed with new
-		// state name. Prefix disambiguates functions and event handlers.
-		fprintf(fp, "e");
-		fprintf(fp, "%s", entry->mIdentifier);
-
-		// Handler name and arguments.
-		mEventp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-
-		// Method signature postfix.
-		fprintf(fp, " cil managed\n");
-
-		// Function header.
-		fprintf(fp,"{\n");
-		fprintf(fp, ".maxstack 500\n"); // TODO: Calculated stack size...
-
-		// Allocate space for locals.
-		print_cil_local_init(fp, mScopeEntry);
-
-		if (mStatement)
-		{
-			// Pass scope so identifiers can determine parameter or local.
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, mScopeEntry, entrycount, NULL);
-		}
-
-		// Function footer.
-		if (mbNeedTrailingReturn)
-		{
-			// TODO: throw exception?
-			fprintf(fp, "ret\n");
-		}
-		fprintf(fp, "}\n");
-
-		break;
-	default:
-		mEventp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mStatement)
-		{
-			mStatement->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-void LLScriptFunctionDec::addFunctionParameter(LLScriptFunctionDec *dec)
-{
-	if (mNextp)
-	{
-		dec->mNextp = mNextp;
-	}
-	mNextp = dec;
-}
-
-void LLScriptFunctionDec::gonext(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		if (mNextp)
-		{
-			fprintf(fp, ", ");
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		if (mNextp)
-		{
-			fprintf(fp, ", ");
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	default:
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-
-}
-
-S32 LLScriptFunctionDec::getSize()
-{
-	return 0;
-}
-
-void LLScriptFunctionDec::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " ");
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " ");
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_SCOPE_PASS1:
-		// add function names into global scope
-		if (scope->checkEntry(mIdentifier->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mIdentifier->mScopeEntry = scope->addEntry(mIdentifier->mName, LIT_VARIABLE, mType->mType);
-		}
-		break;
-	case LSCP_RESOURCE:
-		{
-			// we're just tryng to determine how much space the variable needs
-			mIdentifier->mScopeEntry->mOffset = (S32)count;
-			mIdentifier->mScopeEntry->mSize = mType->getSize();
-			count += mIdentifier->mScopeEntry->mSize;
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			// return type
-			char typereturn;
-			if (mType)
-			{
-				typereturn = LSCRIPTTypeByte[mType->mType];
-			}
-			else
-			{
-				typereturn = LSCRIPTTypeByte[LST_NULL]; 
-			}
-			chunk->addBytes(&typereturn, 1);
-			// name
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			chunk->addBytes(mIdentifier->mName, strlen(mIdentifier->mName) + 1);
-#else
-			chunk->addBytes(1);
-#endif
-		}
-		break;
-	case LSCP_BUILD_FUNCTION_ARGS:
-		{
-			entry->mFunctionArgs.addType(mType->mType);
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, " ");
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if(NULL != mNextp)
-		{
-			fprintf(fp, ",");
-		}
-		break;
-	default:
-		mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-void LLScriptGlobalFunctions::addGlobalFunction(LLScriptGlobalFunctions *global)
-{
-	if (mNextp)
-	{
-		global->mNextp = mNextp;
-	}
-	mNextp = global;
-}
-
-void LLScriptGlobalFunctions::gonext(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	default:
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-S32 LLScriptGlobalFunctions::getSize()
-{
-	return 0;
-}
-
-void LLScriptGlobalFunctions::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		if (mType)
-		{
-			mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "\t");
-		}
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mParameters)
-		{
-			fprintf(fp, "( ");
-			mParameters->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, " )\n");
-		}
-		else
-		{
-			fprintf(fp, "()\n");
-		}
-		if (mStatements)
-		{
-			fdotabs(fp, tabs, tabsize);
-			mStatements->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, mIdentifier->mScopeEntry, entrycount, NULL);
-		}
-		else
-		{
-			fdotabs(fp, tabs, tabsize);
-			fprintf(fp, "{\n");
-			fdotabs(fp, tabs, tabsize);
-			fprintf(fp, "}\n");
-		}
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mParameters)
-		{
-			fprintf(fp, "( ");
-			mParameters->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, " )\n");
-		}
-		else
-		{
-			fprintf(fp, "()\n");
-		}
-		if (mStatements)
-		{
-			mStatements->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, mIdentifier->mScopeEntry->mSize, mIdentifier->mScopeEntry, entrycount, NULL);
-		}
-		if (mbNeedTrailingReturn)
-		{
-			print_return(fp, mIdentifier->mScopeEntry);
-		}
-		fprintf(fp, "\n");
-		break;
-	case LSCP_PRUNE:
-		mbNeedTrailingReturn = FALSE;
-		if (mType)
-		{
-			prunearg = TRUE;
-			mStatements->recurse(fp, tabs, tabsize, pass, LSPRUNE_GLOBAL_NON_VOIDS, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (!prunearg)
-			{
-				gErrorToText.writeError(fp, this, LSERROR_NO_RETURN);
-			}
-		}
-		else
-		{
-			prunearg = TRUE;
-			mStatements->recurse(fp, tabs, tabsize, pass, LSPRUNE_GLOBAL_VOIDS, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			if (!prunearg)
-			{
-				// this means that we didn't end with a return statement, need to add one
-				mbNeedTrailingReturn = TRUE;
-			}
-		}
-		break;
-	case LSCP_SCOPE_PASS1:
-		// add function names into global scope
-		if (scope->checkEntry(mIdentifier->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			if (mType)
-			{
-				mIdentifier->mScopeEntry = scope->addEntry(mIdentifier->mName, LIT_FUNCTION, mType->mType);
-			}
-			else
-			{
-				mIdentifier->mScopeEntry = scope->addEntry(mIdentifier->mName, LIT_FUNCTION, LST_NULL);
-			}
-		}
-
-		// create function level scope
-		mFunctionScope = new LLScriptScope(gScopeStringTable);
-		mFunctionScope->addParentScope(scope);
-
-		// function parameters
-		if (mParameters)
-		{
-			mParameters->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mFunctionScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-
-		mStatements->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mFunctionScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_SCOPE_PASS2:
-		mStatements->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mFunctionScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		
-		if (mParameters)
-		{
-			if (mIdentifier->mScopeEntry)
-			{
-				mParameters->recurse(fp, tabs, tabsize, LSCP_BUILD_FUNCTION_ARGS, ptype, prunearg, mFunctionScope, type, basetype, count, chunk, heap, stacksize, mIdentifier->mScopeEntry, 0, NULL);
-			}
-		}
-		break;
-	case LSCP_TYPE:
-		if (mType)
-		{
-			mStatements->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, mType->mType, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		else
-		{
-			type = LST_NULL;
-			mStatements->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_RESOURCE:
-		// first determine resource counts for globals
-		count = 0;
-
-		if (mParameters)
-		{
-			mParameters->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-
-		if (mIdentifier->mScopeEntry)
-		{
-			// this isn't a bug . . . Offset is used to determine how much is params vs locals
-			mIdentifier->mScopeEntry->mOffset = (S32)count;
-		}
-
-		if (mStatements)
-		{
-			entrycount = 0;
-			mStatements->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, mIdentifier->mScopeEntry, entrycount, NULL);
-			fprintf(fp, "Function Args: %s\n", mIdentifier->mScopeEntry->mFunctionArgs.mString);
-			fprintf(fp, "Local List: %s\n", mIdentifier->mScopeEntry->mLocals.mString);
-			if (mIdentifier->mScopeEntry)
-			{
-				mIdentifier->mScopeEntry->mSize = (S32)count;
-			}
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			// order for global functions
-			// set jump table value
-			S32 jumpoffset = LSCRIPTDataSize[LST_INTEGER]*mIdentifier->mScopeEntry->mCount + LSCRIPTDataSize[LST_INTEGER];
-			integer2bytestream(chunk->mCodeChunk, jumpoffset, chunk->mCurrentOffset);
-
-			// 0 - 3: offset to actual data
-			S32 offsetoffset = chunk->mCurrentOffset;
-			S32 offsetdelta = 0;
-			chunk->addBytes(4);
-
-			// null terminated function name
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			chunk->addBytes(mIdentifier->mName, strlen(mIdentifier->mName) + 1);
-#else
-			chunk->addBytes(1);
-#endif
-			// return type
-			char typereturn;
-			if (mType)
-			{
-				typereturn = LSCRIPTTypeByte[mType->mType];
-			}
-			else
-			{
-				typereturn = LSCRIPTTypeByte[LST_NULL]; 
-			}
-			chunk->addBytes(&typereturn, 1);
-
-			// null terminated parameters, followed by type
-			if (mParameters)
-			{
-				LLScriptByteCodeChunk	*params = new LLScriptByteCodeChunk(FALSE);
-				mParameters->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, params, heap, stacksize, entry, entrycount, NULL);
-				chunk->addBytes(params->mCodeChunk, params->mCurrentOffset);
-				delete params;
-			}
-			chunk->addBytes(1);
-
-			// now we're at the first opcode
-			offsetdelta = chunk->mCurrentOffset - offsetoffset;
-			integer2bytestream(chunk->mCodeChunk, offsetoffset, offsetdelta);
-
-			if (mStatements)
-			{
-				LLScriptByteCodeChunk	*statements = new LLScriptByteCodeChunk(TRUE);
-				mStatements->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, statements, heap, mIdentifier->mScopeEntry->mSize, mIdentifier->mScopeEntry, entrycount, NULL);
-				statements->connectJumps();
-				chunk->addBytes(statements->mCodeChunk, statements->mCurrentOffset);
-				delete statements;
-			}
-			if (mbNeedTrailingReturn)
-			{
-				add_return(chunk, mIdentifier->mScopeEntry);
-			}
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			// Function header. Prefix function name with g to distinguish
-			// from event handlers.
-			fprintf(fp, ".method public hidebysig instance default ");
-			print_cil_type(fp, mType ? mType->mType : LST_NULL);
-			fprintf(fp, " 'g");
-			fprintf(fp, "%s", mIdentifier->mName);
-			fprintf(fp, "'");
-			if (mParameters)
-			{
-				fprintf(fp, "( ");
-				mParameters->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(fp, " )");
-			}
-			else
-			{
-				fprintf(fp, "()");
-			}
-			fprintf(fp, " cil managed\n{\n");
-			fprintf(fp, ".maxstack 500\n"); // TODO: Calculated stack size...
-
-			// Allocate space for locals.
-			print_cil_local_init(fp, mIdentifier->mScopeEntry);
-
-			if (mStatements)
-			{
-				mStatements->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, mIdentifier->mScopeEntry->mSize, mIdentifier->mScopeEntry, entrycount, NULL);
-			}
-
-			// Function footer.
-			if (mbNeedTrailingReturn)
-			{
-				// TODO: throw exception?
-				fprintf(fp, "ret\n");
-			}
-			fprintf(fp, "}\n");
-			fprintf(fp, "\n");
-		}
-		break;
-	default:
-		if (mType)
-		{
-			mType->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mParameters)
-		{
-			mParameters->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		if (mStatements)
-		{
-			mStatements->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-void LLScriptState::addState(LLScriptState *state)
-{
-	if (mNextp)
-	{
-		state->mNextp = mNextp;
-	}
-	mNextp = state;
-}
-
-void LLScriptState::gonext(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	default:
-		if (mNextp)
-		{
-			mNextp->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-}
-
-S32 LLScriptState::getSize()
-{
-	return 0;
-}
-
-void LLScriptState::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		fdotabs(fp, tabs, tabsize);
-		if (mType == LSSTYPE_DEFAULT)
-		{
-			mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "\n");
-			fdotabs(fp, tabs, tabsize);
-			fprintf(fp, "{\n");
-		}
-		else
-		{
-			fprintf(fp, "state ");
-			mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "\n");
-			fdotabs(fp, tabs, tabsize);
-			fprintf(fp, "{\n");
-		}
-		if (mEvent)
-		{
-			mEvent->recurse(fp, tabs + 1, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		fdotabs(fp, tabs, tabsize);
-		fprintf(fp, "}\n");
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-		mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, ":\n");
-		if (mEvent)
-		{
-			fprintf(fp, "EVENTS\n");
-			mEvent->recurse(fp, tabs + 1, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "\n");
-		}
-		break;
-	case LSCP_SCOPE_PASS1:
-		// add state name
-		if (scope->checkEntry(mIdentifier->mName))
-		{
-			gErrorToText.writeError(fp, this, LSERROR_DUPLICATE_NAME);
-		}
-		else
-		{
-			mIdentifier->mScopeEntry = scope->addEntry(mIdentifier->mName, LIT_STATE, LST_NULL);
-		}
-		mStateScope = new LLScriptScope(gScopeStringTable);
-		mStateScope->addParentScope(scope);
-		// now do the events
-		if (mEvent)
-		{
-			mEvent->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mStateScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_SCOPE_PASS2:
-		if (mEvent)
-		{
-			mEvent->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_TYPE:
-		if (mEvent)
-		{
-			mEvent->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			// order for states
-			// set jump table value
-			
-			S32 jumpoffset;
-			if (LSL2_CURRENT_MAJOR_VERSION == LSL2_MAJOR_VERSION_TWO)
-			{
-				jumpoffset = LSCRIPTDataSize[LST_INTEGER]*3*mIdentifier->mScopeEntry->mCount + LSCRIPTDataSize[LST_INTEGER];
-			}
-			else
-			{
-				jumpoffset = LSCRIPTDataSize[LST_INTEGER]*2*mIdentifier->mScopeEntry->mCount + LSCRIPTDataSize[LST_INTEGER];
-			}
-			integer2bytestream(chunk->mCodeChunk, jumpoffset, chunk->mCurrentOffset);
-
-			// need to figure out what handlers this state has registered
-			// we'll use to count to find it
-			count = 0;
-
-			if (mEvent)
-			{
-				mEvent->recurse(fp, tabs, tabsize, LSCP_DETERMINE_HANDLERS, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				gCurrentHandler = count;
-			}
-
-			// add description word into chunk
-			if (LSL2_CURRENT_MAJOR_VERSION == LSL2_MAJOR_VERSION_TWO)
-			{
-				u642bytestream(chunk->mCodeChunk, jumpoffset, gCurrentHandler);
-			}
-			else
-			{
-				integer2bytestream(chunk->mCodeChunk, jumpoffset, (S32)gCurrentHandler);
-			}
-
-
-			// 0 - 3: offset to event jump table
-			S32 offsetoffset = chunk->mCurrentOffset;
-			S32 offsetdelta = 0;
-			chunk->addBytes(4);
-
-			// null terminated state name
-#ifdef LSL_INCLUDE_DEBUG_INFO
-			chunk->addBytes(mIdentifier->mName, strlen(mIdentifier->mName) + 1);
-#else
-			chunk->addBytes(1);
-#endif
-			// now we're at the jump table
-			offsetdelta = chunk->mCurrentOffset - offsetoffset;
-			integer2bytestream(chunk->mCodeChunk, offsetoffset, offsetdelta);
-
-			// add the events themselves
-			if (mEvent)
-			{
-				LLScriptByteCodeChunk	*events = new LLScriptByteCodeChunk(FALSE);
-				// make space for event jump table
-				events->addBytes(LSCRIPTDataSize[LST_INTEGER]*get_number_of_event_handlers(gCurrentHandler)*2);
-				mEvent->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, events, heap, stacksize, entry, entrycount, NULL);
-				chunk->addBytes(events->mCodeChunk, events->mCurrentOffset);
-				delete events;
-			}
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		if (mEvent)
-		{
-			// Entry not used at this level, so pass state scope as entry parameter, to allow event handlers to do name mangling.
-			mEvent->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, mIdentifier->mScopeEntry, entrycount, NULL);
-		}
-		break;
-	default:
-		if (mType == LSSTYPE_DEFAULT)
-		{
-		}
-		else
-		{
-			mIdentifier->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		if (mEvent)
-		{
-			mEvent->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		break;
-	}
-	gonext(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-}
-
-// Converts string to a valid CIL class name and stores the result 
-// in the supplied buffer, which should be at least 32 chars long.
-// If the string starts with a UUID, all characters in the UUID are included
-// in the generated name.
-void to_class_name(char* buffer, const char* string)
-{
-	strcpy(buffer, "LSL-");
-	strcat(buffer, string);
-	char* current_char = buffer;
-	while((*current_char) != 0)
-	{
-		if(isalnum(*current_char))
-		{
-			++current_char;
-		}
-		else if((*current_char) == '-')
-		{
-			(*current_char) = '_';
-			++current_char;
-		}
-		else
-		{
-			(*current_char) = 0;
-		}
-	}
-}
-
-void LLScriptScript::setClassName(const char* class_name)
-{
-	to_class_name(mClassName, class_name);
-}
-
-S32 LLScriptScript::getSize()
-{
-	return 0;
-}
-
-LLScriptScript::LLScriptScript(LLScritpGlobalStorage *globals, 
-							   LLScriptState *states) :
-    LLScriptFilePosition(0, 0),
-	mStates(states), mGlobalScope(NULL), mGlobals(NULL), mGlobalFunctions(NULL), mGodLike(FALSE)
-{
-	const char DEFAULT_BYTECODE_FILENAME[] = "lscript.lso";
-
-	mBytecodeDest = DEFAULT_BYTECODE_FILENAME;
-	LLScriptGlobalVariable	*tvar;
-	LLScriptGlobalFunctions	*tfunc;
-	LLScritpGlobalStorage *temp;
-
-	temp = globals;
-	while(temp)
-	{
-		if (temp->mbGlobalFunction)
-		{
-			if (!mGlobalFunctions)
-			{
-				mGlobalFunctions = (LLScriptGlobalFunctions *)temp->mGlobal;
-			}
-			else
-			{
-				tfunc = mGlobalFunctions;
-				while(tfunc->mNextp)
-				{
-					tfunc = tfunc->mNextp;
-				}
-				tfunc->mNextp = (LLScriptGlobalFunctions *)temp->mGlobal;
-			}
-		}
-		else
-		{
-			if (!mGlobals)
-			{
-				mGlobals = (LLScriptGlobalVariable *)temp->mGlobal;
-			}
-			else
-			{
-				tvar = mGlobals;
-				while(tvar->mNextp)
-				{
-					tvar = tvar->mNextp;
-				}
-				tvar->mNextp = (LLScriptGlobalVariable *)temp->mGlobal;
-			}
-		}
-		temp = temp->mNextp;
-	}
-
-	mClassName[0] = '\0';
-}
-
-void LLScriptScript::setBytecodeDest(const char* dst_filename)
-{
-	mBytecodeDest = ll_safe_string(dst_filename);
-}
-
-static void print_cil_globals(LLFILE* fp, LLScriptGlobalVariable* global)
-{
-	fprintf(fp, ".field public ");
-	print_cil_type(fp, global->mType->mType);
-	fprintf(fp, " '%s'\n", global->mIdentifier->mName);
-	if(NULL != global->mNextp)
-	{
-		print_cil_globals(fp, global->mNextp);
-	}
-}
-
-void LLScriptScript::recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, LSCRIPTPruneType ptype, BOOL &prunearg, LLScriptScope *scope, LSCRIPTType &type, LSCRIPTType basetype, U64 &count, LLScriptByteCodeChunk *chunk, LLScriptByteCodeChunk *heap, S32 stacksize, LLScriptScopeEntry *entry, S32 entrycount, LLScriptLibData **ldata)
-{
-	if (gErrorToText.getErrors())
-	{
-		return;
-	}
-	switch(pass)
-	{
-	case LSCP_PRETTY_PRINT:
-		if (mGlobals)
-		{
-			fdotabs(fp, tabs, tabsize);
-			mGlobals->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-
-		if (mGlobalFunctions)
-		{
-			fdotabs(fp, tabs, tabsize);
-			mGlobalFunctions->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-
-		fdotabs(fp, tabs, tabsize);
-		mStates->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_PRUNE:
-		if (mGlobalFunctions)
-		{
-			mGlobalFunctions->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		}
-		mStates->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_SCOPE_PASS1:
-		{
-			mGlobalScope = new LLScriptScope(gScopeStringTable);
-			// zeroth, add library functions to global scope
-			U16 function_index = 0;
-			const char *arg;
-			LLScriptScopeEntry *sentry;
-			for (std::vector<LLScriptLibraryFunction>::const_iterator i = gScriptLibrary.mFunctions.begin();
-				 i != gScriptLibrary.mFunctions.end(); ++i)
-			{
-				// First, check to make sure this isn't a god only function, or that the viewer's agent is a god.
-				if (!i->mGodOnly || mGodLike)
-				{
-					if (i->mReturnType)
-						sentry = mGlobalScope->addEntry(i->mName, LIT_LIBRARY_FUNCTION, char2type(*i->mReturnType));
-					else
-						sentry = mGlobalScope->addEntry(i->mName, LIT_LIBRARY_FUNCTION, LST_NULL);
-					sentry->mLibraryNumber = function_index;
-					arg = i->mArgs;
-					if (arg)
-					{
-						while (*arg)
-						{
-							sentry->mFunctionArgs.addType(char2type(*arg));
-							sentry->mSize += LSCRIPTDataSize[char2type(*arg)];
-							sentry->mOffset += LSCRIPTDataSize[char2type(*arg)];
-							arg++;
-						}
-					}
-				}
-				function_index++;
-			}
-			// first go and collect all the global variables
-			if (mGlobals)
-				mGlobals->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mGlobalScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			// second, do the global functions
-			if (mGlobalFunctions)
-				mGlobalFunctions->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mGlobalScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			// now do states
-			mStates->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mGlobalScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			break;
-		}
-	case LSCP_SCOPE_PASS2:
-		// now we're checking jumps, function calls, and state transitions
-		if (mGlobalFunctions)
-			mGlobalFunctions->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mGlobalScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mStates->recurse(fp, tabs, tabsize, pass, ptype, prunearg, mGlobalScope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_TYPE:
-		// first we need to check global variables
-		if (mGlobals)
-			mGlobals->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		// now do global functions and states
-		if (mGlobalFunctions)
-			mGlobalFunctions->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mStates->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_RESOURCE:
-		// first determine resource counts for globals
-		count = 0;
-		if (mGlobals)
-			mGlobals->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		// now do locals
-		if (mGlobalFunctions)
-			mGlobalFunctions->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mStates->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	case LSCP_EMIT_ASSEMBLY:
-
-		if (mGlobals)
-		{
-			fprintf(fp, "GLOBALS\n");
-			fdotabs(fp, tabs, tabsize);
-			mGlobals->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "\n");
-		}
-
-		if (mGlobalFunctions)
-		{
-			fprintf(fp, "GLOBAL FUNCTIONS\n");
-			fdotabs(fp, tabs, tabsize);
-			mGlobalFunctions->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(fp, "\n");
-		}
-
-		fprintf(fp, "STATES\n");
-		fdotabs(fp, tabs, tabsize);
-		mStates->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		fprintf(fp, "\n");
-		break;
-	case LSCP_EMIT_BYTE_CODE:
-		{
-			// first, create data structure to hold the whole shebang
-			LLScriptScriptCodeChunk	*code = new LLScriptScriptCodeChunk(TOP_OF_MEMORY);
-
-			// ok, let's add the registers, all zeroes for now
-			S32 i;
-			S32 nooffset = 0;
-
-			for (i = LREG_IP; i < LREG_EOF; i++)
-			{
-				if (i < LREG_NCE)
-					code->mRegisters->addBytes(4);
-				else if (LSL2_CURRENT_MAJOR_VERSION == LSL2_MAJOR_VERSION_TWO)
-					code->mRegisters->addBytes(8);
-			}
-			// global variables
-			if (mGlobals)
-				mGlobals->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, code->mGlobalVariables, code->mHeap, stacksize, entry, entrycount, NULL);
-
-			// put the ending heap block onto the heap
-			U8 *temp;
-			S32 size = lsa_create_data_block(&temp, NULL, 0);
-			code->mHeap->addBytes(temp, size);
-			delete [] temp;
-
-			// global functions
-			// make space for global function jump table
-			if (mGlobalFunctions)
-			{
-				code->mGlobalFunctions->addBytes(LSCRIPTDataSize[LST_INTEGER]*mGlobalScope->mFunctionCount + LSCRIPTDataSize[LST_INTEGER]);
-				integer2bytestream(code->mGlobalFunctions->mCodeChunk, nooffset, mGlobalScope->mFunctionCount);
-				mGlobalFunctions->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, code->mGlobalFunctions, NULL, stacksize, entry, entrycount, NULL);
-			}
-
-
-			nooffset = 0;
-			// states
-			// make space for state jump/info table
-			if (LSL2_CURRENT_MAJOR_VERSION == LSL2_MAJOR_VERSION_TWO)
-			{
-				code->mStates->addBytes(LSCRIPTDataSize[LST_INTEGER]*3*mGlobalScope->mStateCount + LSCRIPTDataSize[LST_INTEGER]);
-			}
-			else
-			{
-				code->mStates->addBytes(LSCRIPTDataSize[LST_INTEGER]*2*mGlobalScope->mStateCount + LSCRIPTDataSize[LST_INTEGER]);
-			}
-			integer2bytestream(code->mStates->mCodeChunk, nooffset, mGlobalScope->mStateCount);
-			mStates->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, code->mStates, NULL, stacksize, entry, entrycount, NULL);
-
-			// now, put it all together and spit it out
-			// we need 
-			LLFILE* bcfp = LLFile::fopen(mBytecodeDest, "wb");		/*Flawfinder: ignore*/
-			
-			code->build(fp, bcfp);
-			fclose(bcfp);
-									   
-			delete code;
-		}
-		break;
-	case LSCP_EMIT_CIL_ASSEMBLY:
-		{
-			LLFILE *bcfp = LLFile::fopen(mBytecodeDest, "wb");
-
-			// Output dependencies.
-			fprintf(bcfp, ".assembly extern mscorlib {.ver 1:0:5000:0}\n");
-			fprintf(bcfp, ".assembly extern LslLibrary {.ver 0:1:0:0}\n");
-			fprintf(bcfp, ".assembly extern LslUserScript {.ver 0:1:0:0}\n");
-			fprintf(bcfp, ".assembly extern ScriptTypes {.ver 0:1:0:0}\n");
-
-			// Output assembly name.
-			fprintf(bcfp, ".assembly '%s' {.ver 0:0:0:0}\n", gScriptp->getClassName());
-
-			// Output class header.
-			fprintf(bcfp, ".class public auto ansi serializable beforefieldinit %s extends [LslUserScript]LindenLab.SecondLife.LslUserScript\n", gScriptp->getClassName());
-			fprintf(bcfp, "{\n");
-
-			// Output globals as members.
-			if(NULL != mGlobals)
-			{
-				print_cil_globals(bcfp, mGlobals);
-			}
-
-			// Output ctor header.
-			fprintf(bcfp, ".method public hidebysig  specialname  rtspecialname instance default void .ctor ()  cil managed\n");
-			fprintf(bcfp, "{\n");
-			fprintf(bcfp, ".maxstack 500\n");
-
-			// Initialise globals as members in ctor.
-			if (mGlobals)
-			{
-				fdotabs(bcfp, tabs, tabsize);
-				mGlobals->recurse(bcfp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(bcfp, "\n");
-			}
-
-			// Output ctor footer.
-			fprintf(bcfp, "ldarg.0\n");
-			fprintf(bcfp, "call instance void [LslUserScript]LindenLab.SecondLife.LslUserScript::.ctor()\n");
-			fprintf(bcfp, "ret\n");
-			fprintf(bcfp, "}\n");
-
-			// Output functions as methods.
-			if (mGlobalFunctions)
-			{
-				fdotabs(bcfp, tabs, tabsize);
-				mGlobalFunctions->recurse(bcfp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-				fprintf(bcfp, "\n");
-			}
-
-			// Output states as name mangled methods.
-			fdotabs(bcfp, tabs, tabsize);
-			mStates->recurse(bcfp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-			fprintf(bcfp, "\n");
-
-			// Output class footer.
-			fprintf(bcfp, "}\n");
-
-			// Close file.
-			fclose(bcfp);
-		}
-		break;
-	default:
-		if (mGlobals)
-			mGlobals->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		if (mGlobalFunctions)
-			mGlobalFunctions->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		mStates->recurse(fp, tabs, tabsize, pass, ptype, prunearg, scope, type, basetype, count, chunk, heap, stacksize, entry, entrycount, NULL);
-		break;
-	}
-}
diff --git a/indra/lscript/lscript_compile/lscript_tree.h b/indra/lscript/lscript_compile/lscript_tree.h
deleted file mode 100755
index 047c220b17..0000000000
--- a/indra/lscript/lscript_compile/lscript_tree.h
+++ /dev/null
@@ -1,2325 +0,0 @@
-/** 
- * @file lscript_tree.h
- * @brief provides the classes required to build lscript's abstract syntax tree and symbol table
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LSCRIPT_TREE_H
-#define LL_LSCRIPT_TREE_H
-
-#include "v3math.h"
-#include "llquaternion.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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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 *request_id,
-		LLScriptIdentifier *status,
-		LLScriptIdentifier *metadata,
-		LLScriptIdentifier *body)
-		: LLScriptEvent(line, col, LSTT_HTTP_RESPONSE),
-		 mRequestId(request_id), mStatus(status), mMetadata(metadata), mBody(body)
-	{
-	}
-
-	void recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass,
-		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 LLScriptHTTPRequestEvent : public LLScriptEvent
-{
-public:
-	LLScriptHTTPRequestEvent(S32 line, S32 col,
-		LLScriptIdentifier *request_id,
-		LLScriptIdentifier *method,
-		LLScriptIdentifier *body)
-		: LLScriptEvent(line, col, LSTT_HTTP_REQUEST),
-		 mRequestId(request_id), mMethod(method), mBody(body)
-	{
-	}
-
-	void recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass,
-		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	*mMethod;
-	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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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), mReturnType(LST_NULL)
-	{
-	}
-
-	~LLScriptStateChange() 
-	{
-	}
-
-	void recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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;
-	LSCRIPTType mReturnType;
-};
-
-class LLScriptJump : public LLScriptStatement
-{
-public:
-	LLScriptJump(S32 line, S32 col, LLScriptIdentifier *identifier)
-		: LLScriptStatement(line, col, LSSMT_JUMP), mIdentifier(identifier)
-	{
-	}
-
-	~LLScriptJump() 
-	{
-	}
-
-	void recurse(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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), mStateScope(NULL)
-	{
-	}
-
-	void addState(LLScriptState *state);
-
-	~LLScriptState() 
-	{
-	}
-
-	void gonext(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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;
-	LLScriptScope *mStateScope;
-};
-
-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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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(LLFILE *fp, S32 tabs, S32 tabsize, LSCRIPTCompilePass pass, 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);
-
-	void setClassName(const char* class_name);
-	const char* getClassName() {return mClassName;}
-
-	LLScriptState			*mStates;
-	LLScriptScope			*mGlobalScope;
-	LLScriptGlobalVariable	*mGlobals;
-	LLScriptGlobalFunctions	*mGlobalFunctions;
-	BOOL					mGodLike;
-
-private:
-	std::string mBytecodeDest;
-	char mClassName[MAX_STRING];
-};
-
-class LLScriptAllocationManager
-{
-public:
-	LLScriptAllocationManager() {}
-	~LLScriptAllocationManager() 
-	{
-		deleteAllocations();
-	}
-
-	void addAllocation(LLScriptFilePosition *ptr)
-	{
-		mAllocationList.push_front(ptr);
-	}
-
-	void deleteAllocations()
-	{
-		delete_and_clear(mAllocationList);
-	}
-
-	std::list<LLScriptFilePosition*> mAllocationList;
-};
-
-extern LLScriptAllocationManager *gAllocationManager;
-extern LLScriptScript			 *gScriptp;
-
-#endif
diff --git a/indra/lscript/lscript_compile/lscript_typecheck.cpp b/indra/lscript/lscript_compile/lscript_typecheck.cpp
deleted file mode 100755
index c685621538..0000000000
--- a/indra/lscript/lscript_compile/lscript_typecheck.cpp
+++ /dev/null
@@ -1,586 +0,0 @@
-/** 
- * @file lscript_typecheck.cpp
- * @brief typechecks script
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#include "linden_common.h"
-
-#include "lscript_tree.h"
-
-/*
-  LScript automatic type casting
-
-  LST_INTEGER			-> LST_INTEGER
-
-  LST_FLOATINGPOINT		-> LST_FLOATINGPOINT
-  LST_INTEGER			-> LST_FLOATINGPOINT
-
-  LST_FLOATINGPOINT		-> LST_STRING
-  LST_INTEGER			-> LST_STRING
-  LST_STRING			-> LST_STRING
-  LST_VECTOR			-> LST_STRING
-  LST_QUATERNION		-> LST_STRING
-  LST_LIST				-> LST_STRING
-
-  LST_VECTOR			-> LST_VECTOR
-  
-  LST_QUATERNION		-> LST_QUATERNION
-  
-  LST_FLOATINGPOINT		-> LST_LIST
-  LST_INTEGER			-> LST_LIST
-  LST_STRING			-> LST_LIST
-  LST_VECTOR			-> LST_LIST
-  LST_QUATERNION		-> LST_LIST
-  LST_LIST				-> LST_LIST
-*/
-
-LSCRIPTType implicit_casts(LSCRIPTType left_side, LSCRIPTType right_side)
-{
-	switch(left_side)
-	{
-		// shouldn't be doing an operation on void types
-	case LST_NULL:
-		switch(right_side)
-		{
-		case LST_NULL:
-			return LST_NULL;
-		default:
-			return LST_UNDEFINED;
-		}
-	// shouldn't be doing an operation on undefined types
-	case LST_UNDEFINED:
-		return LST_UNDEFINED;
-	// only integers can become integers
-	case LST_INTEGER:
-		switch(right_side)
-		{
-		case LST_INTEGER:
-			return LST_INTEGER;
-		default:
-			return LST_UNDEFINED;
-		}
-	// only integers and floats can become floats
-	case LST_FLOATINGPOINT:
-		switch(right_side)
-		{
-		case LST_INTEGER:
-		case LST_FLOATINGPOINT:
-			return LST_FLOATINGPOINT;
-		default:
-			return LST_UNDEFINED;
-		}
-	// only strings and keys can become strings
-	case LST_STRING:
-		switch(right_side)
-		{
-		case LST_STRING:
-		case LST_KEY:
-			return LST_STRING;
-		default:
-			return LST_UNDEFINED;
-		}
-	// only strings and keys can become keys
-	case LST_KEY:
-		switch(right_side)
-		{
-		case LST_STRING:
-		case LST_KEY:
-			return LST_KEY;
-		default:
-			return LST_UNDEFINED;
-		}
-	// only vectors can become vectors
-	case LST_VECTOR:
-		switch(right_side)
-		{
-		case LST_VECTOR:
-			return LST_VECTOR;
-		default:
-			return LST_UNDEFINED;
-		}
-	// only quaternions can become quaternions
-	case LST_QUATERNION:
-		switch(right_side)
-		{
-		case LST_QUATERNION:
-			return LST_QUATERNION;
-		default:
-			return LST_UNDEFINED;
-		}
-	// only lists can become lists
-	case LST_LIST:
-		switch(right_side)
-		{
-		case LST_LIST:
-			return LST_LIST;
-		default:
-			return LST_UNDEFINED;
-		}
-	default:
-		return LST_UNDEFINED;
-	}
-}
-
-LSCRIPTType promote(LSCRIPTType left_side, LSCRIPTType right_side)
-{
-	LSCRIPTType type;
-	type = implicit_casts(left_side, right_side);
-	if (type != LST_UNDEFINED)
-	{
-		return type;
-	}
-	type = implicit_casts(right_side, left_side);
-	if (type != LST_UNDEFINED)
-	{
-		return type;
-	}
-	return LST_UNDEFINED;
-}
-
-BOOL legal_assignment(LSCRIPTType left_side, LSCRIPTType right_side)
-{
-	// this is to prevent cascading errors
-	if (  (left_side == LST_UNDEFINED)
-		||(right_side == LST_UNDEFINED))
-	{
-		return TRUE;
-	}
-
-	if (implicit_casts(left_side, right_side) != LST_UNDEFINED)
-	{
-		return TRUE;
-	}
-	else
-	{
-		return FALSE;
-	}
-}
-
-BOOL legal_casts(LSCRIPTType cast, LSCRIPTType base)
-{
-	switch(base)
-	{
-	// shouldn't be doing an operation on void types
-	case LST_NULL:
-		return FALSE;
-	// shouldn't be doing an operation on undefined types
-	case LST_UNDEFINED:
-		return FALSE;
-	case LST_INTEGER:
-		switch(cast)
-		{
-		case LST_INTEGER:
-		case LST_FLOATINGPOINT:
-		case LST_STRING:
-		case LST_LIST:
-			return TRUE;
-			break;
-		default:
-			return FALSE;
-			break;
-		}
-		break;
-	case LST_FLOATINGPOINT:
-		switch(cast)
-		{
-		case LST_INTEGER:
-		case LST_FLOATINGPOINT:
-		case LST_STRING:
-		case LST_LIST:
-			return TRUE;
-			break;
-		default:
-			return FALSE;
-			break;
-		}
-		break;
-	case LST_STRING:
-		switch(cast)
-		{
-		case LST_INTEGER:
-		case LST_FLOATINGPOINT:
-		case LST_STRING:
-		case LST_KEY:
-		case LST_VECTOR:
-		case LST_QUATERNION:
-		case LST_LIST:
-			return TRUE;
-			break;
-		default:
-			return FALSE;
-			break;
-		}
-		break;
-	case LST_KEY:
-		switch(cast)
-		{
-		case LST_STRING:
-		case LST_KEY:
-		case LST_LIST:
-			return TRUE;
-			break;
-		default:
-			return FALSE;
-			break;
-		}
-		break;
-	case LST_VECTOR:
-		switch(cast)
-		{
-		case LST_VECTOR:
-		case LST_STRING:
-		case LST_LIST:
-			return TRUE;
-			break;
-		default:
-			return FALSE;
-			break;
-		}
-		break;
-	case LST_QUATERNION:
-		switch(cast)
-		{
-		case LST_QUATERNION:
-		case LST_STRING:
-		case LST_LIST:
-			return TRUE;
-			break;
-		default:
-			return FALSE;
-			break;
-		}
-		break;
-	// lists can only be cast to lists and strings
-	case LST_LIST:
-		switch(cast)
-		{
-		case LST_LIST:
-		case LST_STRING:
-			return TRUE;
-			break;
-		default:
-			return FALSE;
-			break;
-		}
-		break;
-	default:
-		return FALSE;
-		break;
-	}
-}
-
-LSCRIPTType gSupportedExpressionArray[LET_EOF][LST_EOF][LST_EOF];
-
-void init_supported_expressions(void)
-{
-	S32 i, j, k;
-	// zero out, then set the ones that matter
-	for (i = 0; i < LET_EOF; i++)
-	{
-		for (j = 0; j < LST_EOF; j++)
-		{
-			for (k = 0; k < LST_EOF; k++)
-			{
-				gSupportedExpressionArray[i][j][k] = LST_NULL;
-			}
-		}
-	}
-
-	// LET_ASSIGNMENT
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_INTEGER][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_STRING][LST_STRING] = LST_STRING;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_KEY][LST_KEY] = LST_KEY;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_INTEGER] = LST_LIST;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_FLOATINGPOINT] = LST_LIST;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_STRING] = LST_LIST;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_KEY] = LST_LIST;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_VECTOR] = LST_LIST;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_QUATERNION] = LST_LIST;
-	gSupportedExpressionArray[LET_ASSIGNMENT][LST_LIST][LST_LIST] = LST_LIST;
-
-	// LET_ADD_ASSIGN
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_STRING][LST_STRING] = LST_STRING;
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_INTEGER] = LST_LIST;
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_FLOATINGPOINT] = LST_LIST;
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_STRING] = LST_LIST;
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_KEY] = LST_LIST;
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_VECTOR] = LST_LIST;
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_QUATERNION] = LST_LIST;
-	gSupportedExpressionArray[LET_ADD_ASSIGN][LST_LIST][LST_LIST] = LST_LIST;
-
-	// LET_SUB_ASSIGN
-	gSupportedExpressionArray[LET_SUB_ASSIGN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_SUB_ASSIGN][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_SUB_ASSIGN][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_SUB_ASSIGN][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
-	gSupportedExpressionArray[LET_SUB_ASSIGN][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
-
-	// LET_MUL_ASSIGN
-	gSupportedExpressionArray[LET_MUL_ASSIGN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_MUL_ASSIGN][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_MUL_ASSIGN][LST_INTEGER][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_MUL_ASSIGN][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_MUL_ASSIGN][LST_VECTOR][LST_INTEGER] = LST_VECTOR;
-	//gSupportedExpressionArray[LET_MUL_ASSIGN][LST_INTEGER][LST_VECTOR] = LST_VECTOR;
-	gSupportedExpressionArray[LET_MUL_ASSIGN][LST_VECTOR][LST_FLOATINGPOINT] = LST_VECTOR;
-	//gSupportedExpressionArray[LET_MUL_ASSIGN][LST_FLOATINGPOINT][LST_VECTOR] = LST_VECTOR;
-	//gSupportedExpressionArray[LET_MUL_ASSIGN][LST_VECTOR][LST_VECTOR] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_MUL_ASSIGN][LST_VECTOR][LST_QUATERNION] = LST_VECTOR;
-	gSupportedExpressionArray[LET_MUL_ASSIGN][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
-
-	// LET_DIV_ASSIGN
-	gSupportedExpressionArray[LET_DIV_ASSIGN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_DIV_ASSIGN][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_DIV_ASSIGN][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_DIV_ASSIGN][LST_VECTOR][LST_INTEGER] = LST_VECTOR;
-	gSupportedExpressionArray[LET_DIV_ASSIGN][LST_VECTOR][LST_FLOATINGPOINT] = LST_VECTOR;
-	gSupportedExpressionArray[LET_DIV_ASSIGN][LST_VECTOR][LST_QUATERNION] = LST_VECTOR;
-	gSupportedExpressionArray[LET_DIV_ASSIGN][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
-
-	// LET_MOD_ASSIGN
-	gSupportedExpressionArray[LET_MOD_ASSIGN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_MOD_ASSIGN][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
-
-	// LET_EQUALITY
-	gSupportedExpressionArray[LET_EQUALITY][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_EQUALITY][LST_INTEGER][LST_FLOATINGPOINT] = LST_INTEGER;
-	gSupportedExpressionArray[LET_EQUALITY][LST_FLOATINGPOINT][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_EQUALITY][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_INTEGER;
-	gSupportedExpressionArray[LET_EQUALITY][LST_STRING][LST_STRING] = LST_INTEGER;
-	gSupportedExpressionArray[LET_EQUALITY][LST_STRING][LST_KEY] = LST_INTEGER;
-	gSupportedExpressionArray[LET_EQUALITY][LST_KEY][LST_STRING] = LST_INTEGER;
-	gSupportedExpressionArray[LET_EQUALITY][LST_KEY][LST_KEY] = LST_INTEGER;
-	gSupportedExpressionArray[LET_EQUALITY][LST_VECTOR][LST_VECTOR] = LST_INTEGER;
-	gSupportedExpressionArray[LET_EQUALITY][LST_QUATERNION][LST_QUATERNION] = LST_INTEGER;
-	gSupportedExpressionArray[LET_EQUALITY][LST_LIST][LST_LIST] = LST_INTEGER;
-
-	// LET_NOT_EQUALS
-	gSupportedExpressionArray[LET_NOT_EQUALS][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_NOT_EQUALS][LST_INTEGER][LST_FLOATINGPOINT] = LST_INTEGER;
-	gSupportedExpressionArray[LET_NOT_EQUALS][LST_FLOATINGPOINT][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_NOT_EQUALS][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_INTEGER;
-	gSupportedExpressionArray[LET_NOT_EQUALS][LST_STRING][LST_STRING] = LST_INTEGER;
-	gSupportedExpressionArray[LET_NOT_EQUALS][LST_STRING][LST_KEY] = LST_INTEGER;
-	gSupportedExpressionArray[LET_NOT_EQUALS][LST_KEY][LST_STRING] = LST_INTEGER;
-	gSupportedExpressionArray[LET_NOT_EQUALS][LST_KEY][LST_KEY] = LST_INTEGER;
-	gSupportedExpressionArray[LET_NOT_EQUALS][LST_VECTOR][LST_VECTOR] = LST_INTEGER;
-	gSupportedExpressionArray[LET_NOT_EQUALS][LST_QUATERNION][LST_QUATERNION] = LST_INTEGER;
-	gSupportedExpressionArray[LET_NOT_EQUALS][LST_LIST][LST_LIST] = LST_INTEGER;
-
-	// LET_LESS_EQUALS
-	gSupportedExpressionArray[LET_LESS_EQUALS][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_LESS_EQUALS][LST_INTEGER][LST_FLOATINGPOINT] = LST_INTEGER;
-	gSupportedExpressionArray[LET_LESS_EQUALS][LST_FLOATINGPOINT][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_LESS_EQUALS][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_INTEGER;
-
-	// LET_GREATER_EQUALS
-	gSupportedExpressionArray[LET_GREATER_EQUALS][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_GREATER_EQUALS][LST_INTEGER][LST_FLOATINGPOINT] = LST_INTEGER;
-	gSupportedExpressionArray[LET_GREATER_EQUALS][LST_FLOATINGPOINT][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_GREATER_EQUALS][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_INTEGER;
-
-	// LET_LESS_THAN
-	gSupportedExpressionArray[LET_LESS_THAN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_LESS_THAN][LST_INTEGER][LST_FLOATINGPOINT] = LST_INTEGER;
-	gSupportedExpressionArray[LET_LESS_THAN][LST_FLOATINGPOINT][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_LESS_THAN][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_INTEGER;
-
-	// LET_GREATER_THAN
-	gSupportedExpressionArray[LET_GREATER_THAN][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_GREATER_THAN][LST_INTEGER][LST_FLOATINGPOINT] = LST_INTEGER;
-	gSupportedExpressionArray[LET_GREATER_THAN][LST_FLOATINGPOINT][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_GREATER_THAN][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_INTEGER;
-
-	// LET_PLUS
-	gSupportedExpressionArray[LET_PLUS][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_PLUS][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_PLUS][LST_INTEGER][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_PLUS][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_PLUS][LST_STRING][LST_STRING] = LST_STRING;
-	gSupportedExpressionArray[LET_PLUS][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
-	gSupportedExpressionArray[LET_PLUS][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
-	gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_INTEGER] = LST_LIST;
-	gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_FLOATINGPOINT] = LST_LIST;
-	gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_STRING] = LST_LIST;
-	gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_KEY] = LST_LIST;
-	gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_VECTOR] = LST_LIST;
-	gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_QUATERNION] = LST_LIST;
-	gSupportedExpressionArray[LET_PLUS][LST_INTEGER][LST_LIST] = LST_LIST;
-	gSupportedExpressionArray[LET_PLUS][LST_FLOATINGPOINT][LST_LIST] = LST_LIST;
-	gSupportedExpressionArray[LET_PLUS][LST_STRING][LST_LIST] = LST_LIST;
-	gSupportedExpressionArray[LET_PLUS][LST_KEY][LST_LIST] = LST_LIST;
-	gSupportedExpressionArray[LET_PLUS][LST_VECTOR][LST_LIST] = LST_LIST;
-	gSupportedExpressionArray[LET_PLUS][LST_QUATERNION][LST_LIST] = LST_LIST;
-	gSupportedExpressionArray[LET_PLUS][LST_LIST][LST_LIST] = LST_LIST;
-
-	// LET_MINUS
-	gSupportedExpressionArray[LET_MINUS][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_MINUS][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_MINUS][LST_INTEGER][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_MINUS][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_MINUS][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
-	gSupportedExpressionArray[LET_MINUS][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
-
-	// LET_TIMES
-	gSupportedExpressionArray[LET_TIMES][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_TIMES][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_TIMES][LST_INTEGER][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_TIMES][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_TIMES][LST_VECTOR][LST_INTEGER] = LST_VECTOR;
-	gSupportedExpressionArray[LET_TIMES][LST_INTEGER][LST_VECTOR] = LST_VECTOR;
-	gSupportedExpressionArray[LET_TIMES][LST_VECTOR][LST_FLOATINGPOINT] = LST_VECTOR;
-	gSupportedExpressionArray[LET_TIMES][LST_FLOATINGPOINT][LST_VECTOR] = LST_VECTOR;
-	gSupportedExpressionArray[LET_TIMES][LST_VECTOR][LST_VECTOR] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_TIMES][LST_VECTOR][LST_QUATERNION] = LST_VECTOR;
-	gSupportedExpressionArray[LET_TIMES][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
-
-	// LET_DIVIDE
-	gSupportedExpressionArray[LET_DIVIDE][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_DIVIDE][LST_INTEGER][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_DIVIDE][LST_FLOATINGPOINT][LST_INTEGER] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_DIVIDE][LST_FLOATINGPOINT][LST_FLOATINGPOINT] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_DIVIDE][LST_VECTOR][LST_INTEGER] = LST_VECTOR;
-	gSupportedExpressionArray[LET_DIVIDE][LST_VECTOR][LST_FLOATINGPOINT] = LST_VECTOR;
-	gSupportedExpressionArray[LET_DIVIDE][LST_VECTOR][LST_QUATERNION] = LST_VECTOR;
-	gSupportedExpressionArray[LET_DIVIDE][LST_QUATERNION][LST_QUATERNION] = LST_QUATERNION;
-
-	// LET_MOD
-	gSupportedExpressionArray[LET_MOD][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-	gSupportedExpressionArray[LET_MOD][LST_VECTOR][LST_VECTOR] = LST_VECTOR;
-
-	// LET_BIT_AND
-	gSupportedExpressionArray[LET_BIT_AND][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-
-	// LET_BIT_OR
-	gSupportedExpressionArray[LET_BIT_OR][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-
-	// LET_BIT_XOR
-	gSupportedExpressionArray[LET_BIT_XOR][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-
-	// LET_BOOLEAN_AND
-	gSupportedExpressionArray[LET_BOOLEAN_AND][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-
-	// LET_BOOLEAN_OR
-	gSupportedExpressionArray[LET_BOOLEAN_OR][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-
-	// LET_SHIFT_LEFT
-	gSupportedExpressionArray[LET_SHIFT_LEFT][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-
-	// LET_SHIFT_RIGHT
-	gSupportedExpressionArray[LET_SHIFT_RIGHT][LST_INTEGER][LST_INTEGER] = LST_INTEGER;
-
-	// LET_PARENTHESIS
-	gSupportedExpressionArray[LET_PARENTHESIS][LST_INTEGER][LST_NULL] = LST_INTEGER;
-	gSupportedExpressionArray[LET_PARENTHESIS][LST_FLOATINGPOINT][LST_NULL] = LST_INTEGER;
-	gSupportedExpressionArray[LET_PARENTHESIS][LST_STRING][LST_NULL] = LST_INTEGER;
-	gSupportedExpressionArray[LET_PARENTHESIS][LST_LIST][LST_NULL] = LST_INTEGER;
-
-	// LET_UNARY_MINUS
-	gSupportedExpressionArray[LET_UNARY_MINUS][LST_INTEGER][LST_NULL] = LST_INTEGER;
-	gSupportedExpressionArray[LET_UNARY_MINUS][LST_FLOATINGPOINT][LST_NULL] = LST_FLOATINGPOINT;
-	gSupportedExpressionArray[LET_UNARY_MINUS][LST_VECTOR][LST_NULL] = LST_VECTOR;
-	gSupportedExpressionArray[LET_UNARY_MINUS][LST_QUATERNION][LST_NULL] = LST_QUATERNION;
-
-	// LET_BOOLEAN_NOT
-	gSupportedExpressionArray[LET_BOOLEAN_NOT][LST_INTEGER][LST_NULL] = LST_INTEGER;
-
-	// LET_BIT_NOT
-	gSupportedExpressionArray[LET_BIT_NOT][LST_INTEGER][LST_NULL] = LST_INTEGER;
-
-	// LET_PRE_INCREMENT
-	gSupportedExpressionArray[LET_PRE_INCREMENT][LST_INTEGER][LST_NULL] = LST_INTEGER;
-	gSupportedExpressionArray[LET_PRE_INCREMENT][LST_FLOATINGPOINT][LST_NULL] = LST_FLOATINGPOINT;
-
-	// LET_PRE_DECREMENT
-	gSupportedExpressionArray[LET_PRE_DECREMENT][LST_INTEGER][LST_NULL] = LST_INTEGER;
-	gSupportedExpressionArray[LET_PRE_DECREMENT][LST_FLOATINGPOINT][LST_NULL] = LST_FLOATINGPOINT;
-
-	// LET_POST_INCREMENT
-	gSupportedExpressionArray[LET_POST_INCREMENT][LST_INTEGER][LST_NULL] = LST_INTEGER;
-	gSupportedExpressionArray[LET_POST_INCREMENT][LST_FLOATINGPOINT][LST_NULL] = LST_FLOATINGPOINT;
-
-	// LET_POST_DECREMENT
-	gSupportedExpressionArray[LET_POST_DECREMENT][LST_INTEGER][LST_NULL] = LST_INTEGER;
-	gSupportedExpressionArray[LET_POST_DECREMENT][LST_FLOATINGPOINT][LST_NULL] = LST_FLOATINGPOINT;
-}
-
-BOOL legal_binary_expression(LSCRIPTType &result, LSCRIPTType left_side, LSCRIPTType right_side, LSCRIPTExpressionType expression)
-{
-	if (  (left_side == LST_UNDEFINED)
-		||(right_side == LST_UNDEFINED))
-	{
-		result = LST_UNDEFINED;
-		return TRUE;
-	}
-
-	if (  (left_side == LST_NULL)
-		||(right_side == LST_NULL))
-	{
-		result = LST_UNDEFINED;
-		return FALSE;
-	}
-
-	result = gSupportedExpressionArray[expression][left_side][right_side];
-	if (result)
-		return TRUE;
-	else
-	{
-		result = LST_UNDEFINED;
-		return FALSE;
-	}
-}
-
-BOOL legal_unary_expression(LSCRIPTType &result, LSCRIPTType left_side, LSCRIPTExpressionType expression)
-{
-	if (left_side == LST_UNDEFINED)
-	{
-		result = LST_UNDEFINED;
-		return TRUE;
-	}
-
-	if (left_side == LST_NULL)
-	{
-		result = LST_UNDEFINED;
-		return FALSE;
-	}
-
-	result = gSupportedExpressionArray[expression][left_side][LST_NULL];
-	if (result)
-		return TRUE;
-	else
-	{
-		result = LST_UNDEFINED;
-		return FALSE;
-	}
-}
diff --git a/indra/lscript/lscript_compile/lscript_typecheck.h b/indra/lscript/lscript_compile/lscript_typecheck.h
deleted file mode 100755
index 74f723506f..0000000000
--- a/indra/lscript/lscript_compile/lscript_typecheck.h
+++ /dev/null
@@ -1,118 +0,0 @@
-/** 
- * @file lscript_typecheck.h
- * @brief typechecks script
- *
- * $LicenseInfo:firstyear=2002&license=viewerlgpl$
- * Second Life Viewer Source Code
- * Copyright (C) 2010, Linden Research, Inc.
- * 
- * This library is free software; you can redistribute it and/or
- * modify it under the terms of the GNU Lesser General Public
- * License as published by the Free Software Foundation;
- * version 2.1 of the License only.
- * 
- * This library is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- * 
- * You should have received a copy of the GNU Lesser General Public
- * License along with this library; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- * 
- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA
- * $/LicenseInfo$
- */
-
-#ifndef LL_LSCRIPT_TYPECHECK_H
-#define LL_LSCRIPT_TYPECHECK_H
-
-#include "lscript_error.h"
-
-LSCRIPTType implicit_casts(LSCRIPTType left_side, LSCRIPTType right_side);
-BOOL legal_casts(LSCRIPTType cast, LSCRIPTType base);
-LSCRIPTType promote(LSCRIPTType left_side, LSCRIPTType right_side);
-BOOL legal_assignment(LSCRIPTType left_side, LSCRIPTType right_side);
-
-typedef enum e_lscript_expression_types
-{
-	LET_NULL,
-	LET_ASSIGNMENT,
-	LET_ADD_ASSIGN,
-	LET_SUB_ASSIGN,
-	LET_MUL_ASSIGN,
-	LET_DIV_ASSIGN,
-	LET_MOD_ASSIGN,
-	LET_EQUALITY,
-	LET_NOT_EQUALS,
-	LET_LESS_EQUALS,
-	LET_GREATER_EQUALS,
-	LET_LESS_THAN,
-	LET_GREATER_THAN,
-	LET_PLUS,
-	LET_MINUS,
-	LET_TIMES,
-	LET_DIVIDE,
-	LET_MOD,
-	LET_BIT_AND,
-	LET_BIT_OR,
-	LET_BIT_XOR,
-	LET_BOOLEAN_AND,
-	LET_BOOLEAN_OR,
-	LET_PARENTHESIS,
-	LET_UNARY_MINUS,
-	LET_BOOLEAN_NOT,
-	LET_BIT_NOT,
-	LET_PRE_INCREMENT,
-	LET_PRE_DECREMENT,
-	LET_CAST,
-	LET_VECTOR_INITIALIZER,
-	LET_QUATERNION_INITIALIZER,
-	LET_LIST_INITIALIZER,
-	LET_LVALUE,
-	LET_POST_INCREMENT,
-	LET_POST_DECREMENT,
-	LET_FUNCTION_CALL,
-	LET_CONSTANT,
-	LET_FOR_EXPRESSION_LIST,
-	LET_FUNC_EXPRESSION_LIST,
-	LET_LIST_EXPRESSION_LIST,
-	LET_PRINT,
-	LET_SHIFT_LEFT,
-	LET_SHIFT_RIGHT,
-	LET_EOF
-} LSCRIPTExpressionType;
-
-BOOL legal_binary_expression(LSCRIPTType &result, LSCRIPTType left_side, LSCRIPTType right_side, LSCRIPTExpressionType expression);
-BOOL legal_unary_expression(LSCRIPTType &result, LSCRIPTType left_side, LSCRIPTExpressionType expression);
-
-void init_supported_expressions(void);
-
-/*
-  LScript automatic type casting
-
-  LST_INTEGER			-> LST_INTEGER
-
-  LST_FLOATINGPOINT		-> LST_FLOATINGPOINT
-  LST_INTEGER			-> LST_FLOATINGPOINT
-
-  LST_FLOATINGPOINT		-> LST_STRING
-  LST_INTEGER			-> LST_STRING
-  LST_STRING			-> LST_STRING
-  LST_VECTOR			-> LST_STRING
-  LST_QUATERNION		-> LST_STRING
-  LST_LIST				-> LST_STRING
-
-  LST_VECTOR			-> LST_VECTOR
-  
-  LST_QUATERNION		-> LST_QUATERNION
-  
-  LST_FLOATINGPOINT		-> LST_LIST
-  LST_INTEGER			-> LST_LIST
-  LST_STRING			-> LST_LIST
-  LST_VECTOR			-> LST_LIST
-  LST_QUATERNION		-> LST_LIST
-  LST_LIST				-> LST_LIST
-*/
-
-#endif
diff --git a/indra/lscript/lscript_compile/windows/unistd.h b/indra/lscript/lscript_compile/windows/unistd.h
deleted file mode 100755
index 0b7e2581e3..0000000000
--- a/indra/lscript/lscript_compile/windows/unistd.h
+++ /dev/null
@@ -1,24 +0,0 @@
-/** 

- * $LicenseInfo:firstyear=2002&license=viewerlgpl$

- * Second Life Viewer Source Code

- * Copyright (C) 2010, Linden Research, Inc.

- * 

- * This library is free software; you can redistribute it and/or

- * modify it under the terms of the GNU Lesser General Public

- * License as published by the Free Software Foundation;

- * version 2.1 of the License only.

- * 

- * This library is distributed in the hope that it will be useful,

- * but WITHOUT ANY WARRANTY; without even the implied warranty of

- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

- * Lesser General Public License for more details.

- * 

- * You should have received a copy of the GNU Lesser General Public

- * License along with this library; if not, write to the Free Software

- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA

- * 

- * Linden Research, Inc., 945 Battery Street, San Francisco, CA  94111  USA

- * $/LicenseInfo$

- */

-

-/* After all that, this file is empty. */