1 files changed, 329 insertions, 0 deletions
diff --git a/libraries/libLSL/lsl.cs b/libraries/libLSL/lsl.cs
new file mode 100644
index 0000000..37a6429
--- /dev/null
+++ b/libraries/libLSL/lsl.cs
@@ -0,0 +1,329 @@
+using System;
+using System.Collections.Generic;
+using System.Text;
+namespace libLSL
+{
+    
+    enum lslVarType : byte
+    {
+        VARTYPE_VOID = 0,
+        VARTYPE_INTEGER = 1,
+        VARTYPE_FLOAT = 2,
+        VARTYPE_STRING = 3,
+        VARTYPE_KEY = 4,
+        VARTYPE_VECTOR = 5,
+        VARTYPE_ROTATION = 6,
+        VARTYPE_LIST = 7
+    }
+    enum lslEventType : byte
+    {
+        EVENT_STATE_ENTRY = 0,
+        EVENT_STATE_EXIT = 1,
+        EVENT_TOUCH_START = 2,
+        EVENT_TOUCH = 3,
+        EVENT_TOUCH_END = 4,
+        EVENT_COLLISION_START = 5,
+        EVENT_COLLISION = 6,
+        EVENT_COLLISION_END = 7,
+        EVENT_LAND_COLLISION_START = 8,
+        EVENT_LAND_COLLISION = 9,
+        EVENT_LAND_COLLISION_END = 10,
+        EVENT_TIMER = 11,
+        EVENT_LISTEN = 12,
+        EVENT_ON_REZ = 13,
+        EVENT_SENSOR = 14,
+        EVENT_NO_SENSOR = 15,
+        EVENT_CONTROL = 16,
+        EVENT_MONEY = 17,
+        EVENT_EMAIL = 18,
+        EVENT_AT_TARGET = 19,
+        EVENT_NOT_AT_TARGET = 20,
+        EVENT_AT_ROT_TARGET = 21,
+        EVENT_NOT_AT_ROT_TARGET = 22,
+        EVENT_RUN_TIME_PERMISSIONS = 23,
+        EVENT_CHANGED = 24,
+        EVENT_ATTACH = 25,
+        EVENT_DATASERVER = 26,
+        EVENT_LINK_MESSAGE = 27,
+        EVENT_MOVING_START = 28,
+        EVENT_MOVING_END = 29,
+        EVENT_OBJECT_REZ = 30,
+        EVENT_REMOTE_DATA = 31,
+        EVENT_HTTP_RESPONSE = 32
+    }
+    enum lslOpcodes : byte
+    {
+        // No Operation
+        OP_NOOP = 0x00,
+        // Pops
+        OP_POP = 0x01,
+        OP_POPS = 0x02,
+        OP_POPL = 0x03,
+        OP_POPV = 0x04,
+        OP_POPQ = 0x05,
+        OP_POPARG = 0x06,
+        OP_POPIP = 0x07,
+        OP_POPBP = 0x08,
+        OP_POPSP = 0x09,
+        OP_POPSLR = 0x0A,
+        // Dupes
+        OP_DUP = 0x20,
+        OP_DUPS = 0x21,
+        OP_DUPL = 0x22,
+        OP_DUPV = 0x23,
+        OP_DUPQ = 0x24,
+        // Stores
+        OP_STORE = 0x30,
+        OP_STORES = 0x31,
+        OP_STOREL = 0x32,
+        OP_STOREV = 0x33,
+        OP_STOREQ = 0x34,
+        OP_STOREG = 0x35,
+        OP_STOREGS = 0x36,
+        OP_STOREGL = 0x37,
+        OP_STOREGV = 0x38,
+        OP_STOREGQ = 0x39,
+        // Loads
+        OP_LOADP = 0x3A,
+        OP_LOADSP = 0x3B,
+        OP_LOADLP = 0x3C,
+        OP_LOADVP = 0x3D,
+        OP_LOADQP = 0x3E,
+        OP_LOADGP = 0x3F,
+        OP_LOADGSP = 0x40,
+        OP_LOADGLP = 0x41,
+        OP_LOADGVP = 0x42,
+        OP_LOADGQP = 0x43,
+        // Pushes
+        OP_PUSH = 0x50,
+        OP_PUSHS = 0x51,
+        OP_PUSHL = 0x52,
+        OP_PUSHV = 0x53,
+        OP_PUSHQ = 0x54,
+        OP_PUSHG = 0x55,
+        OP_PUSHGS = 0x56,
+        OP_PUSHGL = 0x57,
+        OP_PUSHGV = 0x58,
+        OP_PUSHGQ = 0x59,
+        OP_PUSHIP = 0x5A,
+        OP_PUSHBP = 0x5B,
+        OP_PUSHSP = 0x5C,
+        OP_PUSHARGB = 0x5D,
+        OP_PUSHARGI = 0x5E,
+        OP_PUSHARGF = 0x5F,
+        OP_PUSHARGS = 0x60,
+        OP_PUSHARGV = 0x61,
+        OP_PUSHARGQ = 0x62,
+        OP_PUSHE = 0x63,
+        OP_PUSHEV = 0x64,
+        OP_PUSHEQ = 0x65,
+        OP_PUSHARGE = 0x66,
+        // Numerics
+        OP_ADD = 0x70,
+        OP_SUB = 0x71,
+        OP_MUL = 0x72,
+        OP_DIV = 0x73, 
+        OP_MOD = 0x74,
+        OP_EQ = 0x75,
+        OP_NEQ = 0x76,
+        OP_LEQ = 0x77,
+        OP_GEQ = 0x78,
+        OP_LESS = 0x79,
+        OP_GREATER = 0x7A,
+        OP_BITAND = 0x7B,
+        OP_BITOR = 0x7C,
+        OP_BITXOR = 0x7D,
+        OP_BOOLAND = 0x7E,
+        OP_BOOLOR = 0x7F,
+        OP_NEG = 0x80,
+        OP_BITNOT = 0x81,
+        OP_BOOLNOT = 0x82,
+        
+        // Sequence
+        OP_JUMP = 0x90,
+        OP_JUMPIF = 0x91,
+        OP_JUMPNIF = 0x92,
+        OP_STATE = 0x93,
+        OP_CALL = 0x94, 
+        OP_RETURN = 0x95,
+        // Cast
+        OP_CAST = 0xA0,
+        // Stack
+        OP_STACKTOS = 0xB0,
+        OP_STACKTOL = 0xB1,
+        // Debug
+        OP_PRINT = 0xC0,
+        // Library
+        OP_CALLLIB = 0xD0,
+        OP_CALLLIB_TWO_BYTE = 0xD1,
+        
+        // More Numerics
+        OP_SHL = 0xE0,
+        OP_SHR = 0xE1
+    }
+    class lslHeader
+    {
+        int TM;     // Top of memory
+        int IP;     // Instruction pointer
+        int VN;     // Version Number (0x00000200)
+        int BP;     // Base Pointer
+        int SP;     // Stack Pointer
+        int HR;     // Heap Register
+        int HP;     // Heap Pointer
+        int CS;     // Current State
+        int NS;     // Next State
+        int CE;     // Current Events (Which events need running still?)
+        int IE;     // In Event
+        int ER;     // Event Register
+        int FR;     // Fault Register
+        int SLR;    // Sleep Register
+        int GVR;    // Global Variable Register (Pointer)
+        int GFR;    // Global Function Register (Pointer)
+        int PR;     // Parameter Register - OnRez Int?
+        int ESR;    // Energy Supply Register
+        int SR;     // State Register
+        long NCE;   // Extended Current Events
+        long NIE;   // Extended In Event
+        long NER;   // Extended Event Register
+        public void readFromBytes(byte[] data)
+        {
+        }
+    }
+    class lslStaticBlock
+    {
+        int length;        // Length (bytes)
+        lslVarType varType;// Variable Type
+        byte unknown;       // Unknown
+        Object varObject;     // Variable Object
+        public void readFromBytes(byte[] data)
+        {
+        }
+    }
+    class lslHeapBlock
+    {
+        int length;
+        lslVarType varType;
+        short referenceCount;
+        Object varObject;
+        public void readFromBytes(byte[] data)
+        {
+        }
+    }
+    class lslStatePointer
+    {
+        int location;
+        long eventMask;
+        public void readFromBytes(byte[] data)
+        {
+        }
+    }
+    class lslStateFrameBlock
+    {
+        int number;
+        lslStatePointer[] pointers;
+        public void readFromBytes(byte[] data)
+        {
+        }
+    }
+    class lslStateBlockElement
+    {
+        int pointerToCode;
+        int callFrameSize;
+        public void readFromBytes(byte[] data)
+        {
+        }
+    }
+    class lslStateBlock
+    {
+        int length;
+        byte unknown;
+        lslStateBlockElement[] handlers; // ?
+        public void readFromBytes(byte[] data)
+        {
+        }
+    }
+    class lslFunctioBlock
+    {
+        int number;
+        int[] pointers; // Relative to this -> codechunk
+        public void readFromBytes(byte[] data)
+        {
+        }
+    }
+    class lslCodeArgument
+    {
+        lslVarType type;
+        byte empty;
+        public void readFromBytes(byte[] data)
+        {
+        }
+    }
+    class lslCodeChunkHeader
+    {
+        int length;
+        string comment;
+        lslVarType returnType;
+        lslCodeArgument[] arguments;
+        byte empty;
+        public void readFromBytes(byte[] data)
+        {
+        }
+    }
+    class lslCodeChunk
+    {
+        lslCodeChunkHeader header;
+        lslByteCode bytecode;
+        public void readFromBytes(byte[] data)
+        {
+        }
+    }
+}

diff --git a/libraries/libLSL/lsl.cs b/libraries/libLSL/lsl.cs new file mode 100644 index 0000000..37a6429 --- /dev/null +++ b/libraries/libLSL/lsl.cs
@@ -0,0 +1,329 @@
	1	using System;
	2	using System.Collections.Generic;
	3	using System.Text;
	4
	5	namespace libLSL
	6	{
	7
	8
	9	enum lslVarType : byte
	10	{
	11	VARTYPE_VOID = 0,
	12	VARTYPE_INTEGER = 1,
	13	VARTYPE_FLOAT = 2,
	14	VARTYPE_STRING = 3,
	15	VARTYPE_KEY = 4,
	16	VARTYPE_VECTOR = 5,
	17	VARTYPE_ROTATION = 6,
	18	VARTYPE_LIST = 7
	19	}
	20
	21	enum lslEventType : byte
	22	{
	23	EVENT_STATE_ENTRY = 0,
	24	EVENT_STATE_EXIT = 1,
	25	EVENT_TOUCH_START = 2,
	26	EVENT_TOUCH = 3,
	27	EVENT_TOUCH_END = 4,
	28	EVENT_COLLISION_START = 5,
	29	EVENT_COLLISION = 6,
	30	EVENT_COLLISION_END = 7,
	31	EVENT_LAND_COLLISION_START = 8,
	32	EVENT_LAND_COLLISION = 9,
	33	EVENT_LAND_COLLISION_END = 10,
	34	EVENT_TIMER = 11,
	35	EVENT_LISTEN = 12,
	36	EVENT_ON_REZ = 13,
	37	EVENT_SENSOR = 14,
	38	EVENT_NO_SENSOR = 15,
	39	EVENT_CONTROL = 16,
	40	EVENT_MONEY = 17,
	41	EVENT_EMAIL = 18,
	42	EVENT_AT_TARGET = 19,
	43	EVENT_NOT_AT_TARGET = 20,
	44	EVENT_AT_ROT_TARGET = 21,
	45	EVENT_NOT_AT_ROT_TARGET = 22,
	46	EVENT_RUN_TIME_PERMISSIONS = 23,
	47	EVENT_CHANGED = 24,
	48	EVENT_ATTACH = 25,
	49	EVENT_DATASERVER = 26,
	50	EVENT_LINK_MESSAGE = 27,
	51	EVENT_MOVING_START = 28,
	52	EVENT_MOVING_END = 29,
	53	EVENT_OBJECT_REZ = 30,
	54	EVENT_REMOTE_DATA = 31,
	55	EVENT_HTTP_RESPONSE = 32
	56	}
	57
	58	enum lslOpcodes : byte
	59	{
	60	// No Operation
	61	OP_NOOP = 0x00,
	62
	63	// Pops
	64	OP_POP = 0x01,
	65	OP_POPS = 0x02,
	66	OP_POPL = 0x03,
	67	OP_POPV = 0x04,
	68	OP_POPQ = 0x05,
	69	OP_POPARG = 0x06,
	70	OP_POPIP = 0x07,
	71	OP_POPBP = 0x08,
	72	OP_POPSP = 0x09,
	73	OP_POPSLR = 0x0A,
	74
	75	// Dupes
	76	OP_DUP = 0x20,
	77	OP_DUPS = 0x21,
	78	OP_DUPL = 0x22,
	79	OP_DUPV = 0x23,
	80	OP_DUPQ = 0x24,
	81
	82	// Stores
	83	OP_STORE = 0x30,
	84	OP_STORES = 0x31,
	85	OP_STOREL = 0x32,
	86	OP_STOREV = 0x33,
	87	OP_STOREQ = 0x34,
	88	OP_STOREG = 0x35,
	89	OP_STOREGS = 0x36,
	90	OP_STOREGL = 0x37,
	91	OP_STOREGV = 0x38,
	92	OP_STOREGQ = 0x39,
	93
	94	// Loads
	95	OP_LOADP = 0x3A,
	96	OP_LOADSP = 0x3B,
	97	OP_LOADLP = 0x3C,
	98	OP_LOADVP = 0x3D,
	99	OP_LOADQP = 0x3E,
	100	OP_LOADGP = 0x3F,
	101	OP_LOADGSP = 0x40,
	102	OP_LOADGLP = 0x41,
	103	OP_LOADGVP = 0x42,
	104	OP_LOADGQP = 0x43,
	105
	106	// Pushes
	107	OP_PUSH = 0x50,
	108	OP_PUSHS = 0x51,
	109	OP_PUSHL = 0x52,
	110	OP_PUSHV = 0x53,
	111	OP_PUSHQ = 0x54,
	112	OP_PUSHG = 0x55,
	113	OP_PUSHGS = 0x56,
	114	OP_PUSHGL = 0x57,
	115	OP_PUSHGV = 0x58,
	116	OP_PUSHGQ = 0x59,
	117	OP_PUSHIP = 0x5A,
	118	OP_PUSHBP = 0x5B,
	119	OP_PUSHSP = 0x5C,
	120	OP_PUSHARGB = 0x5D,
	121	OP_PUSHARGI = 0x5E,
	122	OP_PUSHARGF = 0x5F,
	123	OP_PUSHARGS = 0x60,
	124	OP_PUSHARGV = 0x61,
	125	OP_PUSHARGQ = 0x62,
	126	OP_PUSHE = 0x63,
	127	OP_PUSHEV = 0x64,
	128	OP_PUSHEQ = 0x65,
	129	OP_PUSHARGE = 0x66,
	130
	131	// Numerics
	132	OP_ADD = 0x70,
	133	OP_SUB = 0x71,
	134	OP_MUL = 0x72,
	135	OP_DIV = 0x73,
	136	OP_MOD = 0x74,
	137	OP_EQ = 0x75,
	138	OP_NEQ = 0x76,
	139	OP_LEQ = 0x77,
	140	OP_GEQ = 0x78,
	141	OP_LESS = 0x79,
	142	OP_GREATER = 0x7A,
	143	OP_BITAND = 0x7B,
	144	OP_BITOR = 0x7C,
	145	OP_BITXOR = 0x7D,
	146	OP_BOOLAND = 0x7E,
	147	OP_BOOLOR = 0x7F,
	148	OP_NEG = 0x80,
	149	OP_BITNOT = 0x81,
	150	OP_BOOLNOT = 0x82,
	151
	152	// Sequence
	153	OP_JUMP = 0x90,
	154	OP_JUMPIF = 0x91,
	155	OP_JUMPNIF = 0x92,
	156	OP_STATE = 0x93,
	157	OP_CALL = 0x94,
	158	OP_RETURN = 0x95,
	159
	160	// Cast
	161	OP_CAST = 0xA0,
	162
	163	// Stack
	164	OP_STACKTOS = 0xB0,
	165	OP_STACKTOL = 0xB1,
	166
	167	// Debug
	168	OP_PRINT = 0xC0,
	169
	170	// Library
	171	OP_CALLLIB = 0xD0,
	172	OP_CALLLIB_TWO_BYTE = 0xD1,
	173
	174	// More Numerics
	175	OP_SHL = 0xE0,
	176	OP_SHR = 0xE1
	177	}
	178
	179	class lslHeader
	180	{
	181	int TM; // Top of memory
	182	int IP; // Instruction pointer
	183	int VN; // Version Number (0x00000200)
	184	int BP; // Base Pointer
	185	int SP; // Stack Pointer
	186	int HR; // Heap Register
	187	int HP; // Heap Pointer
	188	int CS; // Current State
	189	int NS; // Next State
	190	int CE; // Current Events (Which events need running still?)
	191	int IE; // In Event
	192	int ER; // Event Register
	193	int FR; // Fault Register
	194	int SLR; // Sleep Register
	195	int GVR; // Global Variable Register (Pointer)
	196	int GFR; // Global Function Register (Pointer)
	197	int PR; // Parameter Register - OnRez Int?
	198	int ESR; // Energy Supply Register
	199	int SR; // State Register
	200	long NCE; // Extended Current Events
	201	long NIE; // Extended In Event
	202	long NER; // Extended Event Register
	203
	204	public void readFromBytes(byte[] data)
	205	{
	206
	207	}
	208	}
	209
	210	class lslStaticBlock
	211	{
	212	int length; // Length (bytes)
	213	lslVarType varType;// Variable Type
	214	byte unknown; // Unknown
	215	Object varObject; // Variable Object
	216
	217	public void readFromBytes(byte[] data)
	218	{
	219
	220	}
	221
	222	}
	223
	224	class lslHeapBlock
	225	{
	226	int length;
	227	lslVarType varType;
	228	short referenceCount;
	229	Object varObject;
	230
	231	public void readFromBytes(byte[] data)
	232	{
	233
	234	}
	235	}
	236
	237	class lslStatePointer
	238	{
	239	int location;
	240	long eventMask;
	241
	242	public void readFromBytes(byte[] data)
	243	{
	244
	245	}
	246	}
	247
	248	class lslStateFrameBlock
	249	{
	250	int number;
	251	lslStatePointer[] pointers;
	252
	253	public void readFromBytes(byte[] data)
	254	{
	255
	256	}
	257	}
	258
	259	class lslStateBlockElement
	260	{
	261	int pointerToCode;
	262	int callFrameSize;
	263
	264	public void readFromBytes(byte[] data)
	265	{
	266
	267	}
	268	}
	269
	270	class lslStateBlock
	271	{
	272	int length;
	273	byte unknown;
	274
	275	lslStateBlockElement[] handlers; // ?
	276
	277	public void readFromBytes(byte[] data)
	278	{
	279
	280	}
	281	}
	282
	283	class lslFunctioBlock
	284	{
	285	int number;
	286	int[] pointers; // Relative to this -> codechunk
	287
	288	public void readFromBytes(byte[] data)
	289	{
	290
	291	}
	292	}
	293
	294	class lslCodeArgument
	295	{
	296	lslVarType type;
	297	byte empty;
	298
	299	public void readFromBytes(byte[] data)
	300	{
	301
	302	}
	303	}
	304
	305	class lslCodeChunkHeader
	306	{
	307	int length;
	308	string comment;
	309	lslVarType returnType;
	310	lslCodeArgument[] arguments;
	311	byte empty;
	312
	313	public void readFromBytes(byte[] data)
	314	{
	315
	316	}
	317	}
	318
	319	class lslCodeChunk
	320	{
	321	lslCodeChunkHeader header;
	322	lslByteCode bytecode;
	323
	324	public void readFromBytes(byte[] data)
	325	{
	326
	327	}
	328	}
	329	}