Second Life viewer sources 1.13.2.12

1 files changed, 563 insertions, 0 deletions

diff --git a/linden/indra/lscript/lscript_byteformat.h b/linden/indra/lscript/lscript_byteformat.h
new file mode 100644
index 0000000..a69f1fe
--- /dev/null
+++ b/linden/indra/lscript/lscript_byteformat.h
@@ -0,0 +1,563 @@
+/** 
+ * @file lscript_byteformat.h
+ * @brief Shared code between compiler and assembler and LSL
+ *
+ * Copyright (c) 2002-2007, Linden Research, Inc.
+ * 
+ * The source code in this file ("Source Code") is provided by Linden Lab
+ * to you under the terms of the GNU General Public License, version 2.0
+ * ("GPL"), unless you have obtained a separate licensing agreement
+ * ("Other License"), formally executed by you and Linden Lab.  Terms of
+ * the GPL can be found in doc/GPL-license.txt in this distribution, or
+ * online at http://secondlife.com/developers/opensource/gplv2
+ * 
+ * There are special exceptions to the terms and conditions of the GPL as
+ * it is applied to this Source Code. View the full text of the exception
+ * in the file doc/FLOSS-exception.txt in this software distribution, or
+ * online at http://secondlife.com/developers/opensource/flossexception
+ * 
+ * By copying, modifying or distributing this software, you acknowledge
+ * that you have read and understood your obligations described above,
+ * and agree to abide by those obligations.
+ * 
+ * ALL LINDEN LAB SOURCE CODE IS PROVIDED "AS IS." LINDEN LAB MAKES NO
+ * WARRANTIES, EXPRESS, IMPLIED OR OTHERWISE, REGARDING ITS ACCURACY,
+ * COMPLETENESS OR PERFORMANCE.
+ */
+
+#ifndef LL_LSCRIPT_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
+