aboutsummaryrefslogtreecommitdiffstatshomepage
path: root/OpenSim/Region/ScriptEngine/LSOEngine/LSO/LSO_Parser.cs
diff options
context:
space:
mode:
Diffstat (limited to 'OpenSim/Region/ScriptEngine/LSOEngine/LSO/LSO_Parser.cs')
-rw-r--r--OpenSim/Region/ScriptEngine/LSOEngine/LSO/LSO_Parser.cs729
1 files changed, 729 insertions, 0 deletions
diff --git a/OpenSim/Region/ScriptEngine/LSOEngine/LSO/LSO_Parser.cs b/OpenSim/Region/ScriptEngine/LSOEngine/LSO/LSO_Parser.cs
new file mode 100644
index 0000000..1d3992f
--- /dev/null
+++ b/OpenSim/Region/ScriptEngine/LSOEngine/LSO/LSO_Parser.cs
@@ -0,0 +1,729 @@
1/*
2* Copyright (c) Contributors, http://opensimulator.org/
3* See CONTRIBUTORS.TXT for a full list of copyright holders.
4*
5* Redistribution and use in source and binary forms, with or without
6* modification, are permitted provided that the following conditions are met:
7* * Redistributions of source code must retain the above copyright
8* notice, this list of conditions and the following disclaimer.
9* * Redistributions in binary form must reproduce the above copyright
10* notice, this list of conditions and the following disclaimer in the
11* documentation and/or other materials provided with the distribution.
12* * Neither the name of the OpenSim Project nor the
13* names of its contributors may be used to endorse or promote products
14* derived from this software without specific prior written permission.
15*
16* THIS SOFTWARE IS PROVIDED BY THE DEVELOPERS ``AS IS AND ANY
17* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
18* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
19* DISCLAIMED. IN NO EVENT SHALL THE CONTRIBUTORS BE LIABLE FOR ANY
20* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
21* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
22* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
23* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
24* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
25* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
26*
27*/
28/* Original code: Tedd Hansen */
29using System;
30using System.Collections;
31using System.Collections.Generic;
32using System.IO;
33using System.Reflection;
34using System.Reflection.Emit;
35using System.Text;
36using OpenSim.Region.ScriptEngine.LSOEngine.LSO;
37
38namespace OpenSim.Region.ScriptEngine.LSOEngine.LSO
39{
40 internal partial class LSO_Parser
41 {
42 private string FileName;
43 private FileStream fs;
44 private BinaryReader br;
45 internal LSO_Struct.Header myHeader;
46 internal Dictionary<long, LSO_Struct.StaticBlock> StaticBlocks = new Dictionary<long, LSO_Struct.StaticBlock>();
47 //private System.Collections.Hashtable StaticBlocks = new System.Collections.Hashtable();
48
49 private TypeBuilder typeBuilder;
50 private List<string> EventList = new List<string>();
51
52 public LSO_Parser(string _FileName, TypeBuilder _typeBuilder)
53 {
54 FileName = _FileName;
55 typeBuilder = _typeBuilder;
56 }
57
58 internal void OpenFile()
59 {
60 // Open
61 Common.SendToDebug("Opening filename: " + FileName);
62 fs = File.Open(FileName, FileMode.Open, FileAccess.Read, FileShare.Read);
63 br = new BinaryReader(fs, Encoding.BigEndianUnicode);
64 }
65
66 internal void CloseFile()
67 {
68 // Close
69 br.Close();
70 fs.Close();
71 }
72
73
74 /// <summary>
75 /// Parse LSO file.
76 /// </summary>
77 public void Parse()
78 {
79 // The LSO Format consist of 6 major blocks: header, statics, functions, states, heap, and stack.
80
81
82 // HEADER BLOCK
83 Common.SendToDebug("Reading HEADER BLOCK at: 0");
84 fs.Seek(0, SeekOrigin.Begin);
85 myHeader = new LSO_Struct.Header();
86 myHeader.TM = BitConverter.ToUInt32(br_read(4), 0);
87 myHeader.IP = BitConverter.ToUInt32(br_read(4), 0);
88 myHeader.VN = BitConverter.ToUInt32(br_read(4), 0);
89 myHeader.BP = BitConverter.ToUInt32(br_read(4), 0);
90 myHeader.SP = BitConverter.ToUInt32(br_read(4), 0);
91 myHeader.HR = BitConverter.ToUInt32(br_read(4), 0);
92 myHeader.HP = BitConverter.ToUInt32(br_read(4), 0);
93 myHeader.CS = BitConverter.ToUInt32(br_read(4), 0);
94 myHeader.NS = BitConverter.ToUInt32(br_read(4), 0);
95 myHeader.CE = BitConverter.ToUInt32(br_read(4), 0);
96 myHeader.IE = BitConverter.ToUInt32(br_read(4), 0);
97 myHeader.ER = BitConverter.ToUInt32(br_read(4), 0);
98 myHeader.FR = BitConverter.ToUInt32(br_read(4), 0);
99 myHeader.SLR = BitConverter.ToUInt32(br_read(4), 0);
100 myHeader.GVR = BitConverter.ToUInt32(br_read(4), 0);
101 myHeader.GFR = BitConverter.ToUInt32(br_read(4), 0);
102 myHeader.PR = BitConverter.ToUInt32(br_read(4), 0);
103 myHeader.ESR = BitConverter.ToUInt32(br_read(4), 0);
104 myHeader.SR = BitConverter.ToUInt32(br_read(4), 0);
105 myHeader.NCE = BitConverter.ToUInt64(br_read(8), 0);
106 myHeader.NIE = BitConverter.ToUInt64(br_read(8), 0);
107 myHeader.NER = BitConverter.ToUInt64(br_read(8), 0);
108
109 // Print Header Block to debug
110 Common.SendToDebug("TM - Top of memory (size): " + myHeader.TM);
111 Common.SendToDebug("IP - Instruction Pointer (0=not running): " + myHeader.IP);
112 Common.SendToDebug("VN - Version number: " + myHeader.VN);
113 Common.SendToDebug("BP - Local Frame Pointer: " + myHeader.BP);
114 Common.SendToDebug("SP - Stack Pointer: " + myHeader.SP);
115 Common.SendToDebug("HR - Heap Register: " + myHeader.HR);
116 Common.SendToDebug("HP - Heap Pointer: " + myHeader.HP);
117 Common.SendToDebug("CS - Current State: " + myHeader.CS);
118 Common.SendToDebug("NS - Next State: " + myHeader.NS);
119 Common.SendToDebug("CE - Current Events: " + myHeader.CE);
120 Common.SendToDebug("IE - In Event: " + myHeader.IE);
121 Common.SendToDebug("ER - Event Register: " + myHeader.ER);
122 Common.SendToDebug("FR - Fault Register: " + myHeader.FR);
123 Common.SendToDebug("SLR - Sleep Register: " + myHeader.SLR);
124 Common.SendToDebug("GVR - Global Variable Register: " + myHeader.GVR);
125 Common.SendToDebug("GFR - Global Function Register: " + myHeader.GFR);
126 Common.SendToDebug("PR - Parameter Register: " + myHeader.PR);
127 Common.SendToDebug("ESR - Energy Supply Register: " + myHeader.ESR);
128 Common.SendToDebug("SR - State Register: " + myHeader.SR);
129 Common.SendToDebug("NCE - 64-bit Current Events: " + myHeader.NCE);
130 Common.SendToDebug("NIE - 64-bit In Events: " + myHeader.NIE);
131 Common.SendToDebug("NER - 64-bit Event Register: " + myHeader.NER);
132 Common.SendToDebug("Read position when exiting HEADER BLOCK: " + fs.Position);
133
134 // STATIC BLOCK
135 Common.SendToDebug("Reading STATIC BLOCK at: " + myHeader.GVR);
136 fs.Seek(myHeader.GVR, SeekOrigin.Begin);
137 int StaticBlockCount = 0;
138 // Read function blocks until we hit GFR
139 while (fs.Position < myHeader.GFR)
140 {
141 StaticBlockCount++;
142 long startReadPos = fs.Position;
143 Common.SendToDebug("Reading Static Block " + StaticBlockCount + " at: " + startReadPos);
144
145 //fs.Seek(myHeader.GVR, SeekOrigin.Begin);
146 LSO_Struct.StaticBlock myStaticBlock = new LSO_Struct.StaticBlock();
147 myStaticBlock.Static_Chunk_Header_Size = BitConverter.ToUInt32(br_read(4), 0);
148 myStaticBlock.ObjectType = br_read(1)[0];
149 Common.SendToDebug("Static Block ObjectType: " +
150 ((LSO_Enums.Variable_Type_Codes) myStaticBlock.ObjectType).ToString());
151 myStaticBlock.Unknown = br_read(1)[0];
152 // Size of datatype varies -- what about strings?
153 if (myStaticBlock.ObjectType != 0)
154 myStaticBlock.BlockVariable = br_read(getObjectSize(myStaticBlock.ObjectType));
155
156 StaticBlocks.Add((UInt32) startReadPos, myStaticBlock);
157 }
158 Common.SendToDebug("Number of Static Blocks read: " + StaticBlockCount);
159
160
161 // FUNCTION BLOCK
162 // Always right after STATIC BLOCK
163 LSO_Struct.FunctionBlock myFunctionBlock = new LSO_Struct.FunctionBlock();
164 if (myHeader.GFR == myHeader.SR)
165 {
166 // If GFR and SR are at same position then there is no fuction block
167 Common.SendToDebug("No FUNCTION BLOCK found");
168 }
169 else
170 {
171 Common.SendToDebug("Reading FUNCTION BLOCK at: " + myHeader.GFR);
172 fs.Seek(myHeader.GFR, SeekOrigin.Begin);
173 myFunctionBlock.FunctionCount = BitConverter.ToUInt32(br_read(4), 0);
174 Common.SendToDebug("Number of functions in Fuction Block: " + myFunctionBlock.FunctionCount);
175 if (myFunctionBlock.FunctionCount > 0)
176 {
177 myFunctionBlock.CodeChunkPointer = new UInt32[myFunctionBlock.FunctionCount];
178 for (int i = 0; i < myFunctionBlock.FunctionCount; i++)
179 {
180 Common.SendToDebug("Reading function " + i + " at: " + fs.Position);
181 // TODO: ADD TO FUNCTION LIST (How do we identify it later?)
182 // Note! Absolute position
183 myFunctionBlock.CodeChunkPointer[i] = BitConverter.ToUInt32(br_read(4), 0) + myHeader.GFR;
184 Common.SendToDebug("Fuction " + i + " code chunk position: " +
185 myFunctionBlock.CodeChunkPointer[i]);
186 }
187 }
188 }
189
190
191 // STATE FRAME BLOCK
192 // Always right after FUNCTION BLOCK
193 Common.SendToDebug("Reading STATE BLOCK at: " + myHeader.SR);
194 fs.Seek(myHeader.SR, SeekOrigin.Begin);
195 LSO_Struct.StateFrameBlock myStateFrameBlock = new LSO_Struct.StateFrameBlock();
196 myStateFrameBlock.StateCount = BitConverter.ToUInt32(br_read(4), 0);
197 if (myStateFrameBlock.StateCount > 0)
198 {
199 // Initialize array
200 myStateFrameBlock.StatePointer = new LSO_Struct.StatePointerBlock[myStateFrameBlock.StateCount];
201 for (int i = 0; i < myStateFrameBlock.StateCount; i++)
202 {
203 Common.SendToDebug("Reading STATE POINTER BLOCK " + (i + 1) + " at: " + fs.Position);
204 // Position is relative to state frame
205 myStateFrameBlock.StatePointer[i].Location = myHeader.SR + BitConverter.ToUInt32(br_read(4), 0);
206 myStateFrameBlock.StatePointer[i].EventMask = new BitArray(br_read(8));
207 Common.SendToDebug("Pointer: " + myStateFrameBlock.StatePointer[i].Location);
208 Common.SendToDebug("Total potential EventMask bits: " +
209 myStateFrameBlock.StatePointer[i].EventMask.Count);
210
211 //// Read STATE BLOCK
212 //long CurPos = fs.Position;
213 //fs.Seek(CurPos, SeekOrigin.Begin);
214 }
215 }
216
217
218 // STATE BLOCK
219 // For each StateFrameBlock there is one StateBlock with multiple event handlers
220
221 if (myStateFrameBlock.StateCount > 0)
222 {
223 // Go through all State Frame Pointers found
224 for (int i = 0; i < myStateFrameBlock.StateCount; i++)
225 {
226 fs.Seek(myStateFrameBlock.StatePointer[i].Location, SeekOrigin.Begin);
227 Common.SendToDebug("Reading STATE BLOCK " + (i + 1) + " at: " + fs.Position);
228
229 // READ: STATE BLOCK HEADER
230 myStateFrameBlock.StatePointer[i].StateBlock = new LSO_Struct.StateBlock();
231 myStateFrameBlock.StatePointer[i].StateBlock.StartPos = (UInt32) fs.Position; // Note
232 myStateFrameBlock.StatePointer[i].StateBlock.HeaderSize = BitConverter.ToUInt32(br_read(4), 0);
233 myStateFrameBlock.StatePointer[i].StateBlock.Unknown = br_read(1)[0];
234 myStateFrameBlock.StatePointer[i].StateBlock.EndPos = (UInt32) fs.Position; // Note
235 Common.SendToDebug("State block Start Pos: " + myStateFrameBlock.StatePointer[i].StateBlock.StartPos);
236 Common.SendToDebug("State block Header Size: " +
237 myStateFrameBlock.StatePointer[i].StateBlock.HeaderSize);
238 Common.SendToDebug("State block Header End Pos: " +
239 myStateFrameBlock.StatePointer[i].StateBlock.EndPos);
240
241 // We need to count number of bits flagged in EventMask?
242
243
244 // for each bit in myStateFrameBlock.StatePointer[i].EventMask
245
246 // ADDING TO ALL RIGHT NOW, SHOULD LIMIT TO ONLY THE ONES IN USE
247 //TODO: Create event hooks
248 myStateFrameBlock.StatePointer[i].StateBlock.StateBlockHandlers =
249 new LSO_Struct.StateBlockHandler[myStateFrameBlock.StatePointer[i].EventMask.Count - 1];
250 for (int ii = 0; ii < myStateFrameBlock.StatePointer[i].EventMask.Count - 1; ii++)
251 {
252 if (myStateFrameBlock.StatePointer[i].EventMask.Get(ii) == true)
253 {
254 // We got an event
255 // READ: STATE BLOCK HANDLER
256 Common.SendToDebug("Reading STATE BLOCK " + (i + 1) + " HANDLER matching EVENT MASK " + ii +
257 " (" + ((LSO_Enums.Event_Mask_Values) ii).ToString() + ") at: " +
258 fs.Position);
259 myStateFrameBlock.StatePointer[i].StateBlock.StateBlockHandlers[ii].CodeChunkPointer =
260 myStateFrameBlock.StatePointer[i].StateBlock.EndPos +
261 BitConverter.ToUInt32(br_read(4), 0);
262 myStateFrameBlock.StatePointer[i].StateBlock.StateBlockHandlers[ii].CallFrameSize =
263 BitConverter.ToUInt32(br_read(4), 0);
264 Common.SendToDebug("Reading STATE BLOCK " + (i + 1) + " HANDLER EVENT MASK " + ii + " (" +
265 ((LSO_Enums.Event_Mask_Values) ii).ToString() + ") Code Chunk Pointer: " +
266 myStateFrameBlock.StatePointer[i].StateBlock.StateBlockHandlers[ii].
267 CodeChunkPointer);
268 Common.SendToDebug("Reading STATE BLOCK " + (i + 1) + " HANDLER EVENT MASK " + ii + " (" +
269 ((LSO_Enums.Event_Mask_Values) ii).ToString() + ") Call Frame Size: " +
270 myStateFrameBlock.StatePointer[i].StateBlock.StateBlockHandlers[ii].
271 CallFrameSize);
272 }
273 }
274 }
275 }
276
277
278 //// READ FUNCTION CODE CHUNKS
279 //// Functions + Function start pos (GFR)
280 //// TODO: Somehow be able to identify and reference this
281 //LSO_Struct.CodeChunk[] myFunctionCodeChunk;
282 //if (myFunctionBlock.FunctionCount > 0)
283 //{
284 // myFunctionCodeChunk = new LSO_Struct.CodeChunk[myFunctionBlock.FunctionCount];
285 // for (int i = 0; i < myFunctionBlock.FunctionCount; i++)
286 // {
287 // Common.SendToDebug("Reading Function Code Chunk " + i);
288 // myFunctionCodeChunk[i] = GetCodeChunk((UInt32)myFunctionBlock.CodeChunkPointer[i]);
289 // }
290
291 //}
292 // READ EVENT CODE CHUNKS
293 LSO_Struct.CodeChunk[] myEventCodeChunk;
294 if (myStateFrameBlock.StateCount > 0)
295 {
296 myEventCodeChunk = new LSO_Struct.CodeChunk[myStateFrameBlock.StateCount];
297 for (int i = 0; i < myStateFrameBlock.StateCount; i++)
298 {
299 // TODO: Somehow organize events and functions so they can be found again,
300 // two level search ain't no good
301 for (int ii = 0; ii < myStateFrameBlock.StatePointer[i].EventMask.Count - 1; ii++)
302 {
303 if (myStateFrameBlock.StatePointer[i].StateBlock.StateBlockHandlers[ii].CodeChunkPointer > 0)
304 {
305 Common.SendToDebug("Reading Event Code Chunk state " + i + ", event " +
306 (LSO_Enums.Event_Mask_Values) ii);
307
308
309 // Override a Method / Function
310 string eventname = i + "_event_" + (LSO_Enums.Event_Mask_Values) ii;
311 Common.SendToDebug("Event Name: " + eventname);
312 if (Common.IL_ProcessCodeChunks)
313 {
314 EventList.Add(eventname);
315
316 // JUMP TO CODE PROCESSOR
317 ProcessCodeChunk(
318 myStateFrameBlock.StatePointer[i].StateBlock.StateBlockHandlers[ii].CodeChunkPointer,
319 typeBuilder, eventname);
320 }
321 }
322 }
323 }
324 }
325
326
327 if (Common.IL_CreateFunctionList)
328 IL_INSERT_FUNCTIONLIST();
329 }
330
331 internal LSO_Struct.HeapBlock GetHeap(UInt32 pos)
332 {
333 // HEAP BLOCK
334 // TODO:? Special read for strings/keys (null terminated) and lists (pointers to other HEAP entries)
335 Common.SendToDebug("Reading HEAP BLOCK at: " + pos);
336 fs.Seek(pos, SeekOrigin.Begin);
337
338 LSO_Struct.HeapBlock myHeapBlock = new LSO_Struct.HeapBlock();
339 myHeapBlock.DataBlockSize = BitConverter.ToInt32(br_read(4), 0);
340 myHeapBlock.ObjectType = br_read(1)[0];
341 myHeapBlock.ReferenceCount = BitConverter.ToUInt16(br_read(2), 0);
342 //myHeapBlock.Data = br_read(getObjectSize(myHeapBlock.ObjectType));
343 // Don't read it reversed
344 myHeapBlock.Data = new byte[myHeapBlock.DataBlockSize - 1];
345 br.Read(myHeapBlock.Data, 0, myHeapBlock.DataBlockSize - 1);
346
347
348 Common.SendToDebug("Heap Block Data Block Size: " + myHeapBlock.DataBlockSize);
349 Common.SendToDebug("Heap Block ObjectType: " +
350 ((LSO_Enums.Variable_Type_Codes) myHeapBlock.ObjectType).ToString());
351 Common.SendToDebug("Heap Block Reference Count: " + myHeapBlock.ReferenceCount);
352
353 return myHeapBlock;
354 }
355
356 private byte[] br_read(int len)
357 {
358 if (len <= 0)
359 return null;
360
361 try
362 {
363 byte[] bytes = new byte[len];
364 for (int i = len - 1; i > -1; i--)
365 bytes[i] = br.ReadByte();
366 return bytes;
367 }
368 catch (Exception e)
369 {
370 Common.SendToDebug("Exception: " + e.ToString());
371 throw (e);
372 }
373 }
374
375 //private byte[] br_read_smallendian(int len)
376 //{
377 // byte[] bytes = new byte[len];
378 // br.Read(bytes,0, len);
379 // return bytes;
380 //}
381 private Type getLLObjectType(byte objectCode)
382 {
383 switch ((LSO_Enums.Variable_Type_Codes) objectCode)
384 {
385 case LSO_Enums.Variable_Type_Codes.Void:
386 return typeof (void);
387 case LSO_Enums.Variable_Type_Codes.Integer:
388 return typeof (UInt32);
389 case LSO_Enums.Variable_Type_Codes.Float:
390 return typeof (float);
391 case LSO_Enums.Variable_Type_Codes.String:
392 return typeof (string);
393 case LSO_Enums.Variable_Type_Codes.Key:
394 return typeof (string);
395 case LSO_Enums.Variable_Type_Codes.Vector:
396 return typeof (LSO_Enums.Vector);
397 case LSO_Enums.Variable_Type_Codes.Rotation:
398 return typeof (LSO_Enums.Rotation);
399 case LSO_Enums.Variable_Type_Codes.List:
400 Common.SendToDebug("TODO: List datatype not implemented yet!");
401 return typeof (ArrayList);
402 case LSO_Enums.Variable_Type_Codes.Null:
403 Common.SendToDebug("TODO: Datatype null is not implemented, using string instead.!");
404 return typeof (string);
405 default:
406 Common.SendToDebug("Lookup of LSL datatype " + objectCode +
407 " to .Net datatype failed: Unknown LSL datatype. Defaulting to object.");
408 return typeof (object);
409 }
410 }
411
412 private int getObjectSize(byte ObjectType)
413 {
414 switch ((LSO_Enums.Variable_Type_Codes) ObjectType)
415 {
416 case LSO_Enums.Variable_Type_Codes.Integer:
417 case LSO_Enums.Variable_Type_Codes.Float:
418 case LSO_Enums.Variable_Type_Codes.String:
419 case LSO_Enums.Variable_Type_Codes.Key:
420 case LSO_Enums.Variable_Type_Codes.List:
421 return 4;
422 case LSO_Enums.Variable_Type_Codes.Vector:
423 return 12;
424 case LSO_Enums.Variable_Type_Codes.Rotation:
425 return 16;
426 default:
427 return 0;
428 }
429 }
430
431 private string Read_String()
432 {
433 string ret = "";
434 byte reader = br_read(1)[0];
435 while (reader != 0x000)
436 {
437 ret += (char) reader;
438 reader = br_read(1)[0];
439 }
440 return ret;
441 }
442
443 /// <summary>
444 /// Reads a code chunk and creates IL
445 /// </summary>
446 /// <param name="pos">Absolute position in file. REMEMBER TO ADD myHeader.GFR!</param>
447 /// <param name="typeBuilder">TypeBuilder for assembly</param>
448 /// <param name="eventname">Name of event (function) to generate</param>
449 private void ProcessCodeChunk(UInt32 pos, TypeBuilder typeBuilder, string eventname)
450 {
451 LSO_Struct.CodeChunk myCodeChunk = new LSO_Struct.CodeChunk();
452
453 Common.SendToDebug("Reading Function Code Chunk at: " + pos);
454 fs.Seek(pos, SeekOrigin.Begin);
455 myCodeChunk.CodeChunkHeaderSize = BitConverter.ToUInt32(br_read(4), 0);
456 Common.SendToDebug("CodeChunk Header Size: " + myCodeChunk.CodeChunkHeaderSize);
457 // Read until null
458 myCodeChunk.Comment = Read_String();
459 Common.SendToDebug("Function comment: " + myCodeChunk.Comment);
460 myCodeChunk.ReturnTypePos = br_read(1)[0];
461 myCodeChunk.ReturnType = GetStaticBlock((long) myCodeChunk.ReturnTypePos + (long) myHeader.GVR);
462 Common.SendToDebug("Return type #" + myCodeChunk.ReturnType.ObjectType + ": " +
463 ((LSO_Enums.Variable_Type_Codes) myCodeChunk.ReturnType.ObjectType).ToString());
464
465
466 // TODO: How to determine number of codechunks -- does this method work?
467 myCodeChunk.CodeChunkArguments = new List<LSO_Struct.CodeChunkArgument>();
468 byte reader = br_read(1)[0];
469 reader = br_read(1)[0];
470
471 // NOTE ON CODE CHUNK ARGUMENTS
472 // This determins type definition
473 int ccount = 0;
474 while (reader != 0x000)
475 {
476 ccount++;
477 Common.SendToDebug("Reading Code Chunk Argument " + ccount);
478 LSO_Struct.CodeChunkArgument CCA = new LSO_Struct.CodeChunkArgument();
479 CCA.FunctionReturnTypePos = reader;
480 reader = br_read(1)[0];
481 CCA.NullString = reader;
482 CCA.FunctionReturnType = GetStaticBlock(CCA.FunctionReturnTypePos + myHeader.GVR);
483 myCodeChunk.CodeChunkArguments.Add(CCA);
484 Common.SendToDebug("Code Chunk Argument " + ccount + " type #" + CCA.FunctionReturnType.ObjectType +
485 ": " + (LSO_Enums.Variable_Type_Codes) CCA.FunctionReturnType.ObjectType);
486 }
487 // Create string array
488 Type[] MethodArgs = new Type[myCodeChunk.CodeChunkArguments.Count];
489 for (int _ic = 0; _ic < myCodeChunk.CodeChunkArguments.Count; _ic++)
490 {
491 MethodArgs[_ic] = getLLObjectType(myCodeChunk.CodeChunkArguments[_ic].FunctionReturnType.ObjectType);
492 Common.SendToDebug("Method argument " + _ic + ": " +
493 getLLObjectType(myCodeChunk.CodeChunkArguments[_ic].FunctionReturnType.ObjectType).
494 ToString());
495 }
496 // End marker is 0x000
497 myCodeChunk.EndMarker = reader;
498
499
500 //
501 // Emit: START OF METHOD (FUNCTION)
502 //
503
504 Common.SendToDebug("CLR:" + eventname + ":MethodBuilder methodBuilder = typeBuilder.DefineMethod...");
505 MethodBuilder methodBuilder = typeBuilder.DefineMethod(eventname,
506 MethodAttributes.Public,
507 typeof (void),
508 new Type[] {typeof (object)});
509 //MethodArgs);
510 //typeof(void), //getLLObjectType(myCodeChunk.ReturnType),
511 // new Type[] { typeof(object) }, //);
512
513 //Common.SendToDebug("CLR:" + eventname + ":typeBuilder.DefineMethodOverride(methodBuilder...");
514 //typeBuilder.DefineMethodOverride(methodBuilder,
515 // typeof(LSL_CLRInterface.LSLScript).GetMethod(eventname));
516
517 // Create the IL generator
518
519 Common.SendToDebug("CLR:" + eventname + ":ILGenerator il = methodBuilder.GetILGenerator();");
520 ILGenerator il = methodBuilder.GetILGenerator();
521
522
523 if (Common.IL_UseTryCatch)
524 IL_INSERT_TRY(il, eventname);
525
526
527 // Push Console.WriteLine command to stack ... Console.WriteLine("Hello World!");
528 //Common.SendToDebug("CLR:" + eventname + ":il.Emit(OpCodes.Call...");
529 //il.Emit(OpCodes.Call, typeof(Console).GetMethod
530 // ("WriteLine", new Type[] { typeof(string) }));
531
532 //Common.SendToDebug("STARTUP: il.Emit(OpCodes.Ldc_I4_S, 0);");
533
534 //il.Emit(OpCodes.Ldc_I4_S, 0);
535 for (int _ic = 0; _ic < myCodeChunk.CodeChunkArguments.Count; _ic++)
536 {
537 Common.SendToDebug("PARAMS: il.Emit(OpCodes.Ldarg, " + _ic + ");");
538 il.Emit(OpCodes.Ldarg, _ic);
539 }
540
541
542 //
543 // CALLING OPCODE PROCESSOR, one command at the time TO GENERATE IL
544 //
545 bool FoundRet = false;
546 while (FoundRet == false)
547 {
548 FoundRet = LSL_PROCESS_OPCODE(il);
549 }
550
551
552 if (Common.IL_UseTryCatch)
553 IL_INSERT_END_TRY(il, eventname);
554
555 // Emit: RETURN FROM METHOD
556 il.Emit(OpCodes.Ret);
557
558 return;
559 }
560
561 private void IL_INSERT_FUNCTIONLIST()
562 {
563 Common.SendToDebug("Creating function list");
564
565
566 string eventname = "GetFunctions";
567
568 Common.SendToDebug("Creating IL " + eventname);
569 // Define a private String field.
570 //FieldBuilder myField = myTypeBuilder.DefineField("EventList", typeof(String[]), FieldAttributes.Public);
571
572
573 //FieldBuilder mem = typeBuilder.DefineField("mem", typeof(Array), FieldAttributes.Private);
574
575
576 MethodBuilder methodBuilder = typeBuilder.DefineMethod(eventname,
577 MethodAttributes.Public,
578 typeof (string[]),
579 null);
580
581 //typeBuilder.DefineMethodOverride(methodBuilder,
582 // typeof(LSL_CLRInterface.LSLScript).GetMethod(eventname));
583
584 ILGenerator il = methodBuilder.GetILGenerator();
585
586
587 // IL_INSERT_TRY(il, eventname);
588
589 // // Push string to stack
590 // il.Emit(OpCodes.Ldstr, "Inside " + eventname);
591
592 //// Push Console.WriteLine command to stack ... Console.WriteLine("Hello World!");
593 //il.Emit(OpCodes.Call, typeof(Console).GetMethod
594 // ("WriteLine", new Type[] { typeof(string) }));
595
596 //initIL.Emit(OpCodes.Newobj, typeof(string[]));
597
598 //string[] MyArray = new string[2] { "TestItem1" , "TestItem2" };
599
600 ////il.Emit(OpCodes.Ldarg_0);
601
602 il.DeclareLocal(typeof (string[]));
603
604 ////il.Emit(OpCodes.Ldarg_0);
605 il.Emit(OpCodes.Ldc_I4, EventList.Count); // Specify array length
606 il.Emit(OpCodes.Newarr, typeof (String)); // create new string array
607 il.Emit(OpCodes.Stloc_0); // Store array as local variable 0 in stack
608 ////SetFunctionList
609
610 for (int lv = 0; lv < EventList.Count; lv++)
611 {
612 il.Emit(OpCodes.Ldloc_0); // Load local variable 0 onto stack
613 il.Emit(OpCodes.Ldc_I4, lv); // Push index position
614 il.Emit(OpCodes.Ldstr, EventList[lv]); // Push value
615 il.Emit(OpCodes.Stelem_Ref); // Perform array[index] = value
616
617 //il.Emit(OpCodes.Ldarg_0);
618 //il.Emit(OpCodes.Ldstr, EventList[lv]); // Push value
619 //il.Emit(OpCodes.Call, typeof(LSL_BaseClass).GetMethod("AddFunction", new Type[] { typeof(string) }));
620 }
621
622
623 // IL_INSERT_END_TRY(il, eventname);
624
625
626 il.Emit(OpCodes.Ldloc_0); // Load local variable 0 onto stack
627 // il.Emit(OpCodes.Call, typeof(LSL_BaseClass).GetMethod("SetFunctionList", new Type[] { typeof(Array) }));
628
629 il.Emit(OpCodes.Ret); // Return
630 }
631
632
633 private void IL_INSERT_TRY(ILGenerator il, string eventname)
634 {
635 /*
636 * CLR TRY
637 */
638 //Common.SendToDebug("CLR:" + eventname + ":il.BeginExceptionBlock()");
639 il.BeginExceptionBlock();
640
641 // Push "Hello World!" string to stack
642 //Common.SendToDebug("CLR:" + eventname + ":il.Emit(OpCodes.Ldstr...");
643 //il.Emit(OpCodes.Ldstr, "Starting CLR dynamic execution of: " + eventname);
644 }
645
646 private void IL_INSERT_END_TRY(ILGenerator il, string eventname)
647 {
648 /*
649 * CATCH
650 */
651 Common.SendToDebug("CLR:" + eventname + ":il.BeginCatchBlock(typeof(Exception));");
652 il.BeginCatchBlock(typeof (Exception));
653
654 // Push "Hello World!" string to stack
655 Common.SendToDebug("CLR:" + eventname + ":il.Emit(OpCodes.Ldstr...");
656 il.Emit(OpCodes.Ldstr, "Execption executing dynamic CLR function " + eventname + ": ");
657
658 //call void [mscorlib]System.Console::WriteLine(string)
659 Common.SendToDebug("CLR:" + eventname + ":il.Emit(OpCodes.Call...");
660 il.Emit(OpCodes.Call, typeof (Console).GetMethod
661 ("Write", new Type[] {typeof (string)}));
662
663 //callvirt instance string [mscorlib]System.Exception::get_Message()
664 Common.SendToDebug("CLR:" + eventname + ":il.Emit(OpCodes.Callvirt...");
665 il.Emit(OpCodes.Callvirt, typeof (Exception).GetMethod
666 ("get_Message"));
667
668 //call void [mscorlib]System.Console::WriteLine(string)
669 Common.SendToDebug("CLR:" + eventname + ":il.Emit(OpCodes.Call...");
670 il.Emit(OpCodes.Call, typeof (Console).GetMethod
671 ("WriteLine", new Type[] {typeof (string)}));
672
673 /*
674 * CLR END TRY
675 */
676 //Common.SendToDebug("CLR:" + eventname + ":il.EndExceptionBlock();");
677 il.EndExceptionBlock();
678 }
679
680 private LSO_Struct.StaticBlock GetStaticBlock(long pos)
681 {
682 long FirstPos = fs.Position;
683 try
684 {
685 UInt32 position = (UInt32) pos;
686 // STATIC BLOCK
687 Common.SendToDebug("Reading STATIC BLOCK at: " + position);
688 fs.Seek(position, SeekOrigin.Begin);
689
690 if (StaticBlocks.ContainsKey(position) == true)
691 {
692 Common.SendToDebug("Found cached STATIC BLOCK");
693
694
695 return StaticBlocks[pos];
696 }
697
698 //int StaticBlockCount = 0;
699 // Read function blocks until we hit GFR
700 //while (fs.Position < myHeader.GFR)
701 //{
702 //StaticBlockCount++;
703
704 //Common.SendToDebug("Reading Static Block at: " + position);
705
706 //fs.Seek(myHeader.GVR, SeekOrigin.Begin);
707 LSO_Struct.StaticBlock myStaticBlock = new LSO_Struct.StaticBlock();
708 myStaticBlock.Static_Chunk_Header_Size = BitConverter.ToUInt32(br_read(4), 0);
709 myStaticBlock.ObjectType = br_read(1)[0];
710 Common.SendToDebug("Static Block ObjectType: " +
711 ((LSO_Enums.Variable_Type_Codes) myStaticBlock.ObjectType).ToString());
712 myStaticBlock.Unknown = br_read(1)[0];
713 // Size of datatype varies
714 if (myStaticBlock.ObjectType != 0)
715 myStaticBlock.BlockVariable = br_read(getObjectSize(myStaticBlock.ObjectType));
716
717 StaticBlocks.Add(position, myStaticBlock);
718 //}
719 Common.SendToDebug("Done reading Static Block.");
720 return myStaticBlock;
721 }
722 finally
723 {
724 // Go back to original read pos
725 fs.Seek(FirstPos, SeekOrigin.Begin);
726 }
727 }
728 }
729} \ No newline at end of file
generated by cgit v1.1 at 2024-07-05 16:35:46 +0000