Print done when done.

1 files changed, 544 insertions, 0 deletions

diff --git a/indra/lscript/lscript_byteformat.h b/indra/lscript/lscript_byteformat.h
new file mode 100644
index 0000000000..a79f2effae
--- /dev/null
+++ b/indra/lscript/lscript_byteformat.h
@@ -0,0 +1,544 @@
+/** 
+ * @file lscript_byteformat.h
+ * @brief Shared code between compiler and assembler and LSL
+ *
+ * Copyright (c) 2002-$CurrentYear$, Linden Research, Inc.
+ * $License$
+ */
+
+#ifndef LL_LSCRIPT_BYTEFORMAT_H
+#define LL_LSCRIPT_BYTEFORMAT_H
+
+// Data shared between compiler/assembler and lscript execution code
+
+#include "stdtypes.h"
+
+const S32 LSL2_VERSION_NUMBER = 0x0200;
+const S32 LSL2_VERSION1_END_NUMBER = 0x0101;
+const S32 LSL2_VERSION2_START_NUMBER = 0x0200;
+
+const S32 LSL2_MAJOR_VERSION_ONE = 1;
+const S32 LSL2_MAJOR_VERSION_TWO = 2;
+const S32 LSL2_CURRENT_MAJOR_VERSION = LSL2_MAJOR_VERSION_TWO;
+
+const S32 TOP_OF_MEMORY = 16384;
+
+typedef enum e_lscript_registers
+{
+	LREG_INVALID,
+	LREG_IP,		// instruction pointer
+	LREG_VN,		// version number
+	LREG_BP,		// base pointer - what local variables are referenced from
+	LREG_SP,		// stack pointer - where the top of the stack is
+	LREG_HR,		// heap register - where in memory does the heap start
+	LREG_HP,		// heap pointer - where is the top of the heap?
+	LREG_CS,		// current state - what state are we currently in?
+	LREG_NS,		// next state - what state are we currently in?
+	LREG_CE,		// current events - what events are waiting to be handled?
+	LREG_IE,		// in event - which event handler are we currently in?
+	LREG_ER,		// event register - what events do we have active handlers for?
+	LREG_FR,		// fault register - which errors are currently active?
+	LREG_SLR,		// sleep register - are we sleeping?
+	LREG_GVR,		// global variable register - where do global variables start
+	LREG_GFR,		// global function register - where do global functions start
+	LREG_SR,		// state register - where do states start
+	LREG_TM,		// top of memory - where is the top of memory
+	LREG_PR,		// parameter register - data passed to script from launcher
+	LREG_ESR,		// energy supply register - how much energy do we have on board?
+	LREG_NCE,		// 64 bit current envents - what events are waiting to be handled?
+	LREG_NIE,		// 64 bit in event - which event handler are we currently in?
+	LREG_NER,		// 64 bit event register - what events do we have active handlers for?
+	LREG_EOF
+} LSCRIPTRegisters;
+
+const S32 gLSCRIPTRegisterAddresses[LREG_EOF] =
+{
+	0,			// LREG_INVALID
+	4,			// LREG_IP
+	8,			// LREG_VN
+	12,			// LREG_BP
+	16,			// LREG_SP
+	20,			// LREG_HR
+	24,			// LREG_HP
+	28,			// LREG_CS
+	32,			// LREG_NS
+	36,			// LREG_CE
+	40,			// LREG_IE
+	44,			// LREG_ER
+	48,			// LREG_FR
+	52,			// LREG_SLR
+	56,			// LREG_GVR
+	60,			// LREG_GFR
+	72,			// LREG_SR
+	0,			// LREG_TM
+	64,			// LREG_PR
+	68,			// LREG_ESR
+	76,			// LREG_NCE
+	84,			// LREG_NIE
+	92,			// LREG_NER
+};
+
+const char * const gLSCRIPTRegisterNames[LREG_EOF] =
+{
+	"INVALID",		// LREG_INVALID
+	"IP",			// LREG_IP
+	"VN",			// LREG_VN
+	"BP",			// LREG_BP
+	"SP",			// LREG_SP
+	"HR",			// LREG_HR
+	"HP",			// LREG_HP
+	"CS",			// LREG_CS
+	"NS",			// LREG_NS
+	"CE",			// LREG_CE
+	"IE",			// LREG_IE
+	"ER",			// LREG_ER
+	"FR",			// LREG_FR
+	"SLR",			// LREG_SLR
+	"GVR",			// LREG_GVR
+	"GFR",			// LREG_GFR
+	"SR",			// LREG_SR
+	"TM",			// LREG_TM
+	"PR",			// LREG_PR
+	"ESR",			// LREG_ESR
+	"NCE",			// LREG_NCE
+	"NIE",			// LREG_NIE
+	"NER",			// LREG_NER
+};
+
+typedef enum e_lscript_op_codes
+{
+	LOPC_INVALID,
+	LOPC_NOOP,
+	LOPC_POP,
+	LOPC_POPS,
+	LOPC_POPL,
+	LOPC_POPV,
+	LOPC_POPQ,
+	LOPC_POPARG,
+	LOPC_POPIP,
+	LOPC_POPBP,
+	LOPC_POPSP,
+	LOPC_POPSLR,
+	LOPC_DUP,
+	LOPC_DUPS,
+	LOPC_DUPL,
+	LOPC_DUPV,
+	LOPC_DUPQ,
+	LOPC_STORE,
+	LOPC_STORES,
+	LOPC_STOREL,
+	LOPC_STOREV,
+	LOPC_STOREQ,
+	LOPC_STOREG,
+	LOPC_STOREGS,
+	LOPC_STOREGL,
+	LOPC_STOREGV,
+	LOPC_STOREGQ,
+	LOPC_LOADP,
+	LOPC_LOADSP,
+	LOPC_LOADLP,
+	LOPC_LOADVP,
+	LOPC_LOADQP,
+	LOPC_LOADGP,
+	LOPC_LOADGLP,
+	LOPC_LOADGSP,
+	LOPC_LOADGVP,
+	LOPC_LOADGQP,
+	LOPC_PUSH,
+	LOPC_PUSHS,
+	LOPC_PUSHL,
+	LOPC_PUSHV,
+	LOPC_PUSHQ,
+	LOPC_PUSHG,
+	LOPC_PUSHGS,
+	LOPC_PUSHGL,
+	LOPC_PUSHGV,
+	LOPC_PUSHGQ,
+	LOPC_PUSHIP,
+	LOPC_PUSHBP,
+	LOPC_PUSHSP,
+	LOPC_PUSHARGB,
+	LOPC_PUSHARGI,
+	LOPC_PUSHARGF,
+	LOPC_PUSHARGS,
+	LOPC_PUSHARGV,
+	LOPC_PUSHARGQ,
+	LOPC_PUSHE,
+	LOPC_PUSHEV,
+	LOPC_PUSHEQ,
+	LOPC_PUSHARGE,
+	LOPC_ADD,
+	LOPC_SUB,
+	LOPC_MUL,
+	LOPC_DIV,
+	LOPC_MOD,
+	LOPC_EQ,
+	LOPC_NEQ,
+	LOPC_LEQ,
+	LOPC_GEQ,
+	LOPC_LESS,
+	LOPC_GREATER,
+	LOPC_BITAND,
+	LOPC_BITOR,
+	LOPC_BITXOR,
+	LOPC_BOOLAND,
+	LOPC_BOOLOR,
+	LOPC_NEG,
+	LOPC_BITNOT,
+	LOPC_BOOLNOT,
+	LOPC_JUMP,
+	LOPC_JUMPIF,
+	LOPC_JUMPNIF,
+	LOPC_STATE,
+	LOPC_CALL,
+	LOPC_RETURN,
+	LOPC_CAST,
+	LOPC_STACKTOS,
+	LOPC_STACKTOL,
+	LOPC_PRINT,
+	LOPC_CALLLIB,
+	LOPC_CALLLIB_TWO_BYTE,
+	LOPC_SHL,
+	LOPC_SHR,
+	LOPC_EOF
+} LSCRIPTOpCodesEnum;
+
+const U8 LSCRIPTOpCodes[LOPC_EOF] =
+{
+	0x00,	// LOPC_INVALID
+	0x00,	// LOPC_NOOP
+	0x01,	// LOPC_POP
+	0x02,	// LOPC_POPS
+	0x03,	// LOPC_POPL
+	0x04,	// LOPC_POPV
+	0x05,	// LOPC_POPQ
+	0x06,	// LOPC_POPARG
+	0x07,	// LOPC_POPIP
+	0x08,	// LOPC_POPBP
+	0x09,	// LOPC_POPSP
+	0x0a,	// LOPC_POPSLR
+	0x20,	// LOPC_DUP
+	0x21,	// LOPC_DUPS
+	0x22,	// LOPC_DUPL
+	0x23,	// LOPC_DUPV
+	0x24,	// LOPC_DUPQ
+	0x30,	// LOPC_STORE
+	0x31,	// LOPC_STORES
+	0x32,	// LOPC_STOREL
+	0x33,	// LOPC_STOREV
+	0x34,	// LOPC_STOREQ
+	0x35,	// LOPC_STOREG
+	0x36,	// LOPC_STOREGS
+	0x37,	// LOPC_STOREGL
+	0x38,	// LOPC_STOREGV
+	0x39,	// LOPC_STOREGQ
+	0x3a,	// LOPC_LOADP
+	0x3b,	// LOPC_LOADSP
+	0x3c,	// LOPC_LOADLP
+	0x3d,	// LOPC_LOADVP
+	0x3e,	// LOPC_LOADQP
+	0x3f,	// LOPC_LOADGP
+	0x40,	// LOPC_LOADGSP
+	0x41,	// LOPC_LOADGLP
+	0x42,	// LOPC_LOADGVP
+	0x43,	// LOPC_LOADGQP
+	0x50,	// LOPC_PUSH
+	0x51,	// LOPC_PUSHS
+	0x52,	// LOPC_PUSHL
+	0x53,	// LOPC_PUSHV
+	0x54,	// LOPC_PUSHQ
+	0x55,	// LOPC_PUSHG
+	0x56,	// LOPC_PUSHGS
+	0x57,	// LOPC_PUSHGL
+	0x58,	// LOPC_PUSHGV
+	0x59,	// LOPC_PUSHGQ
+	0x5a,	// LOPC_PUSHIP
+	0x5b,	// LOPC_PUSHBP
+	0x5c,	// LOPC_PUSHSP
+	0x5d,	// LOPC_PUSHARGB
+	0x5e,	// LOPC_PUSHARGI
+	0x5f,	// LOPC_PUSHARGF
+	0x60,	// LOPC_PUSHARGS
+	0x61,	// LOPC_PUSHARGV
+	0x62,	// LOPC_PUSHARGQ
+	0x63,	// LOPC_PUSHE
+	0x64,	// LOPC_PUSHEV
+	0x65,	// LOPC_PUSHEQ
+	0x66,	// LOPC_PUSHARGE
+	0x70,	// LOPC_ADD
+	0x71,	// LOPC_SUB
+	0x72,	// LOPC_MUL
+	0x73,	// LOPC_DIV
+	0x74,	// LOPC_MOD
+	0x75,	// LOPC_EQ
+	0x76,	// LOPC_NEQ
+	0x77,	// LOPC_LEQ
+	0x78,	// LOPC_GEQ
+	0x79,	// LOPC_LESS
+	0x7a,	// LOPC_GREATER
+	0x7b,	// LOPC_BITAND
+	0x7c,	// LOPC_BITOR
+	0x7d,	// LOPC_BITXOR
+	0x7e,	// LOPC_BOOLAND
+	0x7f,	// LOPC_BOOLOR
+	0x80,	// LOPC_NEG
+	0x81,	// LOPC_BITNOT
+	0x82,	// LOPC_BOOLNOT
+	0x90,	// LOPC_JUMP
+	0x91,	// LOPC_JUMPIF
+	0x92,	// LOPC_JUMPNIF
+	0x93,	// LOPC_STATE
+	0x94,	// LOPC_CALL
+	0x95,	// LOPC_RETURN
+	0xa0,	// LOPC_CAST
+	0xb0,	// LOPC_STACKTOS
+	0xb1,	// LOPC_STACKTOL
+	0xc0,	// LOPC_PRINT
+	0xd0,	// LOPC_CALLLIB
+	0xd1,	// LOPC_CALLLIB_TWO_BYTE
+	0xe0,	// LOPC_SHL
+	0xe1	// LOPC_SHR
+};
+
+typedef enum e_lscript_state_event_type
+{
+	LSTT_NULL,
+	LSTT_STATE_ENTRY,
+	LSTT_STATE_EXIT,
+	LSTT_TOUCH_START,
+	LSTT_TOUCH,
+	LSTT_TOUCH_END,
+	LSTT_COLLISION_START,
+	LSTT_COLLISION,
+	LSTT_COLLISION_END,
+	LSTT_LAND_COLLISION_START,
+	LSTT_LAND_COLLISION,
+	LSTT_LAND_COLLISION_END,
+	LSTT_TIMER,
+	LSTT_CHAT,
+	LSTT_REZ,
+	LSTT_SENSOR,
+	LSTT_NO_SENSOR,
+	LSTT_CONTROL,
+	LSTT_MONEY,
+	LSTT_EMAIL,
+	LSTT_AT_TARGET,
+	LSTT_NOT_AT_TARGET,
+	LSTT_AT_ROT_TARGET,
+	LSTT_NOT_AT_ROT_TARGET,
+	LSTT_RTPERMISSIONS,
+	LSTT_INVENTORY,
+	LSTT_ATTACH,
+	LSTT_DATASERVER,
+	LSTT_LINK_MESSAGE,
+	LSTT_MOVING_START,
+	LSTT_MOVING_END,
+	LSTT_OBJECT_REZ,
+	LSTT_REMOTE_DATA,
+	LSTT_HTTP_RESPONSE,
+	LSTT_EOF,
+	
+	LSTT_STATE_BEGIN = LSTT_STATE_ENTRY,
+	LSTT_STATE_END = LSTT_EOF
+} LSCRIPTStateEventType;
+
+const U64 LSCRIPTStateBitField[LSTT_EOF] =
+{
+	0x0000000000000000,		//	LSTT_NULL
+	0x0000000000000001,		//	LSTT_STATE_ENTRY
+	0x0000000000000002,		//	LSTT_STATE_EXIT
+	0x0000000000000004,		//	LSTT_TOUCH_START
+	0x0000000000000008,		//	LSTT_TOUCH
+	0x0000000000000010,		//	LSTT_TOUCH_END
+	0x0000000000000020,		//	LSTT_COLLISION_START
+	0x0000000000000040,		//	LSTT_COLLISION
+	0x0000000000000080,		//	LSTT_COLLISION_END
+	0x0000000000000100,		//	LSTT_LAND_COLLISION_START
+	0x0000000000000200,		//	LSTT_LAND_COLLISION
+	0x0000000000000400,		//	LSTT_LAND_COLLISION_END
+	0x0000000000000800,		//	LSTT_TIMER
+	0x0000000000001000,		//	LSTT_CHAT
+	0x0000000000002000,		//	LSTT_REZ
+	0x0000000000004000,		//	LSTT_SENSOR
+	0x0000000000008000,		//	LSTT_NO_SENSOR
+	0x0000000000010000,		//	LSTT_CONTROL
+	0x0000000000020000,		//	LSTT_MONEY
+	0x0000000000040000,		//	LSTT_EMAIL
+	0x0000000000080000,		//	LSTT_AT_TARGET
+	0x0000000000100000,		//	LSTT_NOT_AT_TARGET
+	0x0000000000200000,		//	LSTT_AT_ROT_TARGET
+	0x0000000000400000,		//	LSTT_NOT_AT_ROT_TARGET
+	0x0000000000800000,		//	LSTT_RTPERMISSIONS
+	0x0000000001000000,		//	LSTT_INVENTORY
+	0x0000000002000000,		//	LSTT_ATTACH
+	0x0000000004000000,		//	LSTT_DATASERVER
+	0x0000000008000000,		//  LSTT_LINK_MESSAGE
+	0x0000000010000000,		//  LSTT_MOVING_START
+	0x0000000020000000,		//  LSTT_MOVING_END
+	0x0000000040000000,		//  LSTT_OBJECT_REZ
+	0x0000000080000000,		//  LSTT_REMOTE_DATA
+	0x0000000100000000LL     // LSTT_HTTP_RESPOSE
+};
+
+inline S32 get_event_handler_jump_position(U64 bit_field, LSCRIPTStateEventType type)
+{
+	S32 count = 0, position = LSTT_STATE_ENTRY;
+	while (position < type)
+	{
+		if (bit_field & 0x1)
+		{
+			count++;
+		}
+		bit_field >>= 1;
+		position++;
+	}
+	return count;
+}
+
+inline S32 get_number_of_event_handlers(U64 bit_field)
+{
+	S32 count = 0, position = 0;
+	while (position < LSTT_EOF)
+	{
+		if (bit_field & 0x1)
+		{
+			count++;
+		}
+		bit_field >>= 1;
+		position++;
+	}
+	return count;
+}
+
+typedef enum e_lscript_types
+{
+	LST_NULL,
+	LST_INTEGER,
+	LST_FLOATINGPOINT,
+	LST_STRING,
+	LST_KEY,
+	LST_VECTOR,
+	LST_QUATERNION,
+	LST_LIST,
+	LST_UNDEFINED,
+	LST_EOF
+} LSCRIPTType;
+
+const U8 LSCRIPTTypeByte[LST_EOF] =
+{
+	LST_NULL,
+	LST_INTEGER,
+	LST_FLOATINGPOINT,
+	LST_STRING,
+	LST_KEY,
+	LST_VECTOR,
+	LST_QUATERNION,
+	LST_LIST,
+	LST_NULL,
+};
+
+const U8 LSCRIPTTypeHi4Bits[LST_EOF] =
+{
+	LST_NULL,
+	LST_INTEGER << 4,
+	LST_FLOATINGPOINT << 4,
+	LST_STRING << 4,
+	LST_KEY << 4,
+	LST_VECTOR << 4,
+	LST_QUATERNION << 4,
+	LST_LIST << 4,
+};
+
+const char * const LSCRIPTTypeNames[LST_EOF] =
+{
+	"VOID",
+	"integer",
+	"float",
+	"string",
+	"key",
+	"vector",
+	"quaternion",
+	"list",
+	"invalid"
+};
+
+const S32 LSCRIPTDataSize[LST_EOF] =
+{
+	0,	// VOID
+	4,	// integer
+	4,	// float
+	4,	// string
+	4,	// key
+	12,	// vector
+	16,	// quaternion
+	4,	// list
+	0	// invalid
+};
+
+
+typedef enum e_lscript_runtime_faults
+{
+	LSRF_INVALID,
+	LSRF_MATH,
+	LSRF_STACK_HEAP_COLLISION,
+	LSRF_BOUND_CHECK_ERROR,
+	LSRF_HEAP_ERROR,
+	LSRF_VERSION_MISMATCH,
+	LSRF_MISSING_INVENTORY,
+	LSRF_SANDBOX,
+	LSRF_CHAT_OVERRUN,
+	LSRF_TOO_MANY_LISTENS,
+	LSRF_NESTING_LISTS,
+	LSRF_EOF
+} LSCRIPTRunTimeFaults;
+
+extern char *LSCRIPTRunTimeFaultStrings[LSRF_EOF];
+
+const S32 LSCRIPTRunTimeFaultBits[LSRF_EOF] =
+{
+	0,		//	LSRF_INVALID
+	1,		//	LSRF_MATH
+	2,		//	LSRF_STACK_HEAP_COLLISION
+	3,		//	LSREF_BOUND_CHECK_ERROR
+	4,		//	LSREF_HEAP_ERROR
+	5,		//	LSREF_VERSION_MISMATCH
+	6,		//	LSREF_MISSING_INVENTORY
+	7,		//	LSRF_SANDBOX
+	8,		//	LSRF_CHAT_OVERRUN
+	9,		//	LSRF_TOO_MANY_LISTENS
+	10,		//	LSRF_NESTING_LISTS
+};
+
+typedef enum e_lscript_runtime_permissions
+{
+	SCRIPT_PERMISSION_DEBIT,
+	SCRIPT_PERMISSION_TAKE_CONTROLS,
+	SCRIPT_PERMISSION_REMAP_CONTROLS,
+	SCRIPT_PERMISSION_TRIGGER_ANIMATION,
+	SCRIPT_PERMISSION_ATTACH,
+	SCRIPT_PERMISSION_RELEASE_OWNERSHIP,
+	SCRIPT_PERMISSION_CHANGE_LINKS,
+	SCRIPT_PERMISSION_CHANGE_JOINTS,
+	SCRIPT_PERMISSION_CHANGE_PERMISSIONS,
+	SCRIPT_PERMISSION_TRACK_CAMERA,
+	SCRIPT_PERMISSION_CONTROL_CAMERA,
+	SCRIPT_PERMISSION_EOF
+} LSCRIPTRunTimePermissions;
+
+const U32 LSCRIPTRunTimePermissionBits[SCRIPT_PERMISSION_EOF] =
+{
+	(0x1 << 1),	//	SCRIPT_PERMISSION_DEBIT,
+	(0x1 << 2),	//	SCRIPT_PERMISSION_TAKE_CONTROLS,
+	(0x1 << 3),	//	SCRIPT_PERMISSION_REMAP_CONTROLS,
+	(0x1 << 4),	//	SCRIPT_PERMISSION_TRIGGER_ANIMATION,
+	(0x1 << 5),	//	SCRIPT_PERMISSION_ATTACH,
+	(0x1 << 6),	//	SCRIPT_PERMISSION_RELEASE_OWNERSHIP,
+	(0x1 << 7),	//	SCRIPT_PERMISSION_CHANGE_LINKS,
+	(0x1 << 8),	//	SCRIPT_PERMISSION_CHANGE_JOINTS,
+	(0x1 << 9),	//	SCRIPT_PERMISSION_CHANGE_PERMISSIONS
+	(0x1 << 10),//	SCRIPT_PERMISSION_TRACK_CAMERA
+	(0x1 << 11),//	SCRIPT_PERMISSION_CONTROL_CAMERA
+};
+
+#endif
+