diff options
author | UbitUmarov | 2018-02-23 14:52:34 +0000 |
---|---|---|
committer | UbitUmarov | 2018-02-23 14:52:34 +0000 |
commit | 2129d941acbc5f83aca4dc4c30a62d3226888136 (patch) | |
tree | e12f2391978c923ef780f558ee5a32d857ee9124 /OpenSim/Region/ScriptEngine/XMREngine/XMRObjectTokens.cs | |
parent | Merge branch 'master' into httptests (diff) | |
download | opensim-SC-2129d941acbc5f83aca4dc4c30a62d3226888136.zip opensim-SC-2129d941acbc5f83aca4dc4c30a62d3226888136.tar.gz opensim-SC-2129d941acbc5f83aca4dc4c30a62d3226888136.tar.bz2 opensim-SC-2129d941acbc5f83aca4dc4c30a62d3226888136.tar.xz |
rename XMREngine as Yengine (still not all done), big mess source formating changes, move state files to proper folder, fix a source file locking on errors, more changes for cross platform including from Mike,... yes yes i know a messy commit
Diffstat (limited to '')
-rw-r--r-- | OpenSim/Region/ScriptEngine/XMREngine/XMRObjectTokens.cs | 5476 |
1 files changed, 0 insertions, 5476 deletions
diff --git a/OpenSim/Region/ScriptEngine/XMREngine/XMRObjectTokens.cs b/OpenSim/Region/ScriptEngine/XMREngine/XMRObjectTokens.cs deleted file mode 100644 index f214f28..0000000 --- a/OpenSim/Region/ScriptEngine/XMREngine/XMRObjectTokens.cs +++ /dev/null | |||
@@ -1,5476 +0,0 @@ | |||
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 OpenSimulator 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 | using OpenSim.Region.ScriptEngine.Shared.ScriptBase; | ||
29 | using System; | ||
30 | using System.Collections.Generic; | ||
31 | using System.IO; | ||
32 | using System.Reflection; | ||
33 | using System.Reflection.Emit; | ||
34 | using System.Text; | ||
35 | |||
36 | using LSL_Float = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLFloat; | ||
37 | using LSL_Integer = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLInteger; | ||
38 | using LSL_Key = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString; | ||
39 | using LSL_List = OpenSim.Region.ScriptEngine.Shared.LSL_Types.list; | ||
40 | using LSL_Rotation = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Quaternion; | ||
41 | using LSL_String = OpenSim.Region.ScriptEngine.Shared.LSL_Types.LSLString; | ||
42 | using LSL_Vector = OpenSim.Region.ScriptEngine.Shared.LSL_Types.Vector3; | ||
43 | |||
44 | /** | ||
45 | * Contains classes that disassemble or decompile an xmrobj file. | ||
46 | * See xmrengcomp.cx utility program. | ||
47 | */ | ||
48 | |||
49 | namespace OpenSim.Region.ScriptEngine.XMREngine { | ||
50 | |||
51 | /* | ||
52 | * Encapsulate object code for a method. | ||
53 | */ | ||
54 | public abstract class ObjectTokens { | ||
55 | public ScriptObjCode scriptObjCode; | ||
56 | |||
57 | public ObjectTokens (ScriptObjCode scriptObjCode) | ||
58 | { | ||
59 | this.scriptObjCode = scriptObjCode; | ||
60 | } | ||
61 | |||
62 | public abstract void Close (); | ||
63 | public abstract void BegMethod (DynamicMethod method); | ||
64 | public abstract void EndMethod (); | ||
65 | public abstract void DefineLabel (int number, string name); | ||
66 | public abstract void DefineLocal (int number, string name, string type, Type syType); | ||
67 | public abstract void DefineMethod (string methName, Type retType, Type[] argTypes, string[] argNames); | ||
68 | public abstract void MarkLabel (int offset, int number); | ||
69 | public abstract void BegExcBlk (int offset); | ||
70 | public abstract void BegCatBlk (int offset, Type excType); | ||
71 | public abstract void BegFinBlk (int offset); | ||
72 | public abstract void EndExcBlk (int offset); | ||
73 | public abstract void EmitNull (int offset, OpCode opCode); | ||
74 | public abstract void EmitField (int offset, OpCode opCode, FieldInfo field); | ||
75 | public abstract void EmitLocal (int offset, OpCode opCode, int number); | ||
76 | public abstract void EmitType (int offset, OpCode opCode, Type type); | ||
77 | public abstract void EmitLabel (int offset, OpCode opCode, int number); | ||
78 | public abstract void EmitLabels (int offset, OpCode opCode, int[] numbers); | ||
79 | public abstract void EmitMethod (int offset, OpCode opCode, MethodInfo method); | ||
80 | public abstract void EmitCtor (int offset, OpCode opCode, ConstructorInfo ctor); | ||
81 | public abstract void EmitDouble (int offset, OpCode opCode, double value); | ||
82 | public abstract void EmitFloat (int offset, OpCode opCode, float value); | ||
83 | public abstract void EmitInteger (int offset, OpCode opCode, int value); | ||
84 | public abstract void EmitString (int offset, OpCode opCode, string value); | ||
85 | } | ||
86 | |||
87 | /******************\ | ||
88 | * DISASSEMBLER * | ||
89 | \******************/ | ||
90 | |||
91 | public class OTDisassemble : ObjectTokens { | ||
92 | private static readonly int OPCSTRWIDTH = 12; | ||
93 | |||
94 | private Dictionary<int,string> labelNames; | ||
95 | private Dictionary<int,string> localNames; | ||
96 | private StringBuilder lbuf = new StringBuilder (); | ||
97 | private TextWriter twout; | ||
98 | |||
99 | public OTDisassemble (ScriptObjCode scriptObjCode, TextWriter twout) : base (scriptObjCode) | ||
100 | { | ||
101 | this.twout = twout; | ||
102 | } | ||
103 | |||
104 | public override void Close () | ||
105 | { | ||
106 | twout.WriteLine ("TheEnd."); | ||
107 | } | ||
108 | |||
109 | /** | ||
110 | * About to generate object code for this method. | ||
111 | */ | ||
112 | public override void BegMethod (DynamicMethod method) | ||
113 | { | ||
114 | labelNames = new Dictionary<int,string> (); | ||
115 | localNames = new Dictionary<int,string> (); | ||
116 | |||
117 | twout.WriteLine (""); | ||
118 | |||
119 | lbuf.Append (method.ReturnType.Name); | ||
120 | lbuf.Append (' '); | ||
121 | lbuf.Append (method.Name); | ||
122 | |||
123 | ParameterInfo[] parms = method.GetParameters (); | ||
124 | int nArgs = parms.Length; | ||
125 | lbuf.Append (" ("); | ||
126 | for (int i = 0; i < nArgs; i ++) { | ||
127 | if (i > 0) lbuf.Append (", "); | ||
128 | lbuf.Append (parms[i].ParameterType.Name); | ||
129 | } | ||
130 | lbuf.Append (')'); | ||
131 | FlushLine (); | ||
132 | |||
133 | lbuf.Append ('{'); | ||
134 | FlushLine (); | ||
135 | } | ||
136 | |||
137 | /** | ||
138 | * Dump out reconstructed source for this method. | ||
139 | */ | ||
140 | public override void EndMethod () | ||
141 | { | ||
142 | lbuf.Append ('}'); | ||
143 | FlushLine (); | ||
144 | } | ||
145 | |||
146 | /** | ||
147 | * Add instructions to stream. | ||
148 | */ | ||
149 | public override void DefineLabel (int number, string name) | ||
150 | { | ||
151 | labelNames[number] = name + "$" + number; | ||
152 | } | ||
153 | |||
154 | public override void DefineLocal (int number, string name, string type, Type syType) | ||
155 | { | ||
156 | localNames[number] = name + "$" + number; | ||
157 | |||
158 | lbuf.Append (" "); | ||
159 | lbuf.Append (type.PadRight (OPCSTRWIDTH - 1)); | ||
160 | lbuf.Append (' '); | ||
161 | lbuf.Append (localNames[number]); | ||
162 | FlushLine (); | ||
163 | } | ||
164 | |||
165 | public override void DefineMethod (string methName, Type retType, Type[] argTypes, string[] argNames) | ||
166 | { } | ||
167 | |||
168 | public override void MarkLabel (int offset, int number) | ||
169 | { | ||
170 | LinePrefix (offset); | ||
171 | lbuf.Append (labelNames[number]); | ||
172 | lbuf.Append (":"); | ||
173 | FlushLine (); | ||
174 | } | ||
175 | |||
176 | public override void BegExcBlk (int offset) | ||
177 | { | ||
178 | LinePrefix (offset); | ||
179 | lbuf.Append (" BeginExceptionBlock"); | ||
180 | FlushLine (); | ||
181 | } | ||
182 | |||
183 | public override void BegCatBlk (int offset, Type excType) | ||
184 | { | ||
185 | LinePrefix (offset); | ||
186 | lbuf.Append (" BeginCatchBlock "); | ||
187 | lbuf.Append (excType.Name); | ||
188 | FlushLine (); | ||
189 | } | ||
190 | |||
191 | public override void BegFinBlk (int offset) | ||
192 | { | ||
193 | LinePrefix (offset); | ||
194 | lbuf.Append (" BeginFinallyBlock"); | ||
195 | FlushLine (); | ||
196 | } | ||
197 | |||
198 | public override void EndExcBlk (int offset) | ||
199 | { | ||
200 | LinePrefix (offset); | ||
201 | lbuf.Append (" EndExceptionBlock"); | ||
202 | FlushLine (); | ||
203 | } | ||
204 | |||
205 | public override void EmitNull (int offset, OpCode opCode) | ||
206 | { | ||
207 | LinePrefix (offset, opCode); | ||
208 | FlushLine (); | ||
209 | } | ||
210 | |||
211 | public override void EmitField (int offset, OpCode opCode, FieldInfo field) | ||
212 | { | ||
213 | LinePrefix (offset, opCode); | ||
214 | lbuf.Append (field.DeclaringType.Name); | ||
215 | lbuf.Append (':'); | ||
216 | lbuf.Append (field.Name); | ||
217 | lbuf.Append (" -> "); | ||
218 | lbuf.Append (field.FieldType.Name); | ||
219 | lbuf.Append (" (field)"); | ||
220 | FlushLine (); | ||
221 | } | ||
222 | |||
223 | public override void EmitLocal (int offset, OpCode opCode, int number) | ||
224 | { | ||
225 | LinePrefix (offset, opCode); | ||
226 | lbuf.Append (localNames[number]); | ||
227 | lbuf.Append (" (local)"); | ||
228 | FlushLine (); | ||
229 | } | ||
230 | |||
231 | public override void EmitType (int offset, OpCode opCode, Type type) | ||
232 | { | ||
233 | LinePrefix (offset, opCode); | ||
234 | lbuf.Append (type.Name); | ||
235 | lbuf.Append (" (type)"); | ||
236 | FlushLine (); | ||
237 | } | ||
238 | |||
239 | public override void EmitLabel (int offset, OpCode opCode, int number) | ||
240 | { | ||
241 | LinePrefix (offset, opCode); | ||
242 | lbuf.Append (labelNames[number]); | ||
243 | lbuf.Append (" (label)"); | ||
244 | FlushLine (); | ||
245 | } | ||
246 | |||
247 | public override void EmitLabels (int offset, OpCode opCode, int[] numbers) | ||
248 | { | ||
249 | LinePrefix (offset, opCode); | ||
250 | |||
251 | int lineLen = lbuf.Length; | ||
252 | int nLabels = numbers.Length; | ||
253 | for (int i = 0; i < nLabels; i ++) { | ||
254 | if (i > 0) { | ||
255 | lbuf.AppendLine (); | ||
256 | lbuf.Append (",".PadLeft (lineLen)); | ||
257 | } | ||
258 | lbuf.Append (labelNames[numbers[i]]); | ||
259 | } | ||
260 | |||
261 | FlushLine (); | ||
262 | } | ||
263 | |||
264 | public override void EmitMethod (int offset, OpCode opCode, MethodInfo method) | ||
265 | { | ||
266 | LinePrefix (offset, opCode); | ||
267 | |||
268 | ParameterInfo[] parms = method.GetParameters (); | ||
269 | int nArgs = parms.Length; | ||
270 | if (method.DeclaringType != null) { | ||
271 | lbuf.Append (method.DeclaringType.Name); | ||
272 | lbuf.Append (':'); | ||
273 | } | ||
274 | lbuf.Append (method.Name); | ||
275 | lbuf.Append ('('); | ||
276 | for (int i = 0; i < nArgs; i ++) { | ||
277 | if (i > 0) lbuf.Append (","); | ||
278 | lbuf.Append (parms[i].ParameterType.Name); | ||
279 | } | ||
280 | lbuf.Append (") -> "); | ||
281 | lbuf.Append (method.ReturnType.Name); | ||
282 | |||
283 | FlushLine (); | ||
284 | } | ||
285 | |||
286 | public override void EmitCtor (int offset, OpCode opCode, ConstructorInfo ctor) | ||
287 | { | ||
288 | LinePrefix (offset, opCode); | ||
289 | |||
290 | ParameterInfo[] parms = ctor.GetParameters (); | ||
291 | int nArgs = parms.Length; | ||
292 | lbuf.Append (ctor.DeclaringType.Name); | ||
293 | lbuf.Append (":("); | ||
294 | for (int i = 0; i < nArgs; i ++) { | ||
295 | if (i > 0) lbuf.Append (","); | ||
296 | lbuf.Append (parms[i].ParameterType.Name); | ||
297 | } | ||
298 | lbuf.Append (")"); | ||
299 | |||
300 | FlushLine (); | ||
301 | } | ||
302 | |||
303 | public override void EmitDouble (int offset, OpCode opCode, double value) | ||
304 | { | ||
305 | LinePrefix (offset, opCode); | ||
306 | lbuf.Append (value.ToString ()); | ||
307 | lbuf.Append (" (double)"); | ||
308 | FlushLine (); | ||
309 | } | ||
310 | |||
311 | public override void EmitFloat (int offset, OpCode opCode, float value) | ||
312 | { | ||
313 | LinePrefix (offset, opCode); | ||
314 | lbuf.Append (value.ToString ()); | ||
315 | lbuf.Append (" (float)"); | ||
316 | FlushLine (); | ||
317 | } | ||
318 | |||
319 | public override void EmitInteger (int offset, OpCode opCode, int value) | ||
320 | { | ||
321 | LinePrefix (offset, opCode); | ||
322 | lbuf.Append (value.ToString ()); | ||
323 | lbuf.Append (" (int)"); | ||
324 | FlushLine (); | ||
325 | } | ||
326 | |||
327 | public override void EmitString (int offset, OpCode opCode, string value) | ||
328 | { | ||
329 | LinePrefix (offset, opCode); | ||
330 | lbuf.Append ("\""); | ||
331 | lbuf.Append (value); | ||
332 | lbuf.Append ("\" (string)"); | ||
333 | FlushLine (); | ||
334 | } | ||
335 | |||
336 | /** | ||
337 | * Put offset and opcode at beginning of line. | ||
338 | */ | ||
339 | private void LinePrefix (int offset, OpCode opCode) | ||
340 | { | ||
341 | LinePrefix (offset); | ||
342 | lbuf.Append (" "); | ||
343 | lbuf.Append (opCode.ToString ().PadRight (OPCSTRWIDTH - 1)); | ||
344 | lbuf.Append (' '); | ||
345 | } | ||
346 | |||
347 | private void LinePrefix (int offset) | ||
348 | { | ||
349 | lbuf.Append (" "); | ||
350 | lbuf.Append (offset.ToString ("X4")); | ||
351 | lbuf.Append (" "); | ||
352 | } | ||
353 | |||
354 | /** | ||
355 | * Flush line buffer to output file. | ||
356 | */ | ||
357 | private void FlushLine () | ||
358 | { | ||
359 | if (lbuf.Length > 0) { | ||
360 | twout.WriteLine (lbuf.ToString ()); | ||
361 | lbuf.Remove (0, lbuf.Length); | ||
362 | } | ||
363 | } | ||
364 | } | ||
365 | |||
366 | /****************\ | ||
367 | * DECOMPILER * | ||
368 | \****************/ | ||
369 | |||
370 | /** | ||
371 | * Note: The decompiler does not handle any xmroption extensions | ||
372 | * such as &&&, |||, ? operators and switch statements, as | ||
373 | * they do branches with a non-empty stack, which is way | ||
374 | * beyond this code's ability to analyze. | ||
375 | */ | ||
376 | |||
377 | public class OTDecompile : ObjectTokens { | ||
378 | public const string _mainCallNo = "__mainCallNo$"; | ||
379 | public const string _callLabel = "__call_"; | ||
380 | public const string _callMode = "callMode"; | ||
381 | public const string _checkRunQuick = "CheckRunQuick"; | ||
382 | public const string _checkRunStack = "CheckRunStack"; | ||
383 | public const string _cmRestore = "__cmRestore"; | ||
384 | public const string _doBreak = "dobreak_"; | ||
385 | public const string _doCont = "docont_"; | ||
386 | public const string _doGblInit = "doGblInit"; | ||
387 | public const string _doLoop = "doloop_"; | ||
388 | public const string _ehArgs = "ehArgs"; | ||
389 | public const string _forBreak = "forbreak_"; | ||
390 | public const string _forCont = "forcont_"; | ||
391 | public const string _forLoop = "forloop_"; | ||
392 | public const string _globalvarinit = "$globalvarinit()"; | ||
393 | public const string _heapTrackerPop = "Pop"; | ||
394 | public const string _heapTrackerPush = "Push"; | ||
395 | public const string _ifDone = "ifdone_"; | ||
396 | public const string _ifElse = "ifelse_"; | ||
397 | public const string _llAbstemp = "llAbstemp"; | ||
398 | public const string _retlbl = "__retlbl"; | ||
399 | public const string _retval = "__retval$"; | ||
400 | public const string _whileBreak = "whilebreak_"; | ||
401 | public const string _whileCont = "whilecont_"; | ||
402 | public const string _whileLoop = "whileloop_"; | ||
403 | public const string _xmrinst = "__xmrinst"; | ||
404 | public const string _xmrinstlocal = "__xmrinst$"; | ||
405 | |||
406 | private const string INDENT = " "; | ||
407 | private const string LABELINDENT = " "; | ||
408 | |||
409 | private static Dictionary<string,string> typeTranslator = InitTypeTranslator (); | ||
410 | private static Dictionary<string,string> InitTypeTranslator () | ||
411 | { | ||
412 | Dictionary<string,string> d = new Dictionary<string,string> (); | ||
413 | d["Boolean"] = "integer"; | ||
414 | d["bool"] = "integer"; | ||
415 | d["Double"] = "float"; | ||
416 | d["double"] = "float"; | ||
417 | d["Int32"] = "integer"; | ||
418 | d["int"] = "integer"; | ||
419 | d["htlist"] = "list"; | ||
420 | d["htobject"] = "object"; | ||
421 | d["htstring"] = "string"; | ||
422 | d["lslfloat"] = "float"; | ||
423 | d["lslint"] = "integer"; | ||
424 | d["lsllist"] = "list"; | ||
425 | d["lslrot"] = "rotation"; | ||
426 | d["lslstr"] = "string"; | ||
427 | d["lslvec"] = "vector"; | ||
428 | d["Quaternion"] = "rotation"; | ||
429 | d["String"] = "string"; | ||
430 | d["Vector3"] = "vector"; | ||
431 | return d; | ||
432 | } | ||
433 | |||
434 | private Dictionary<int,OTLocal> eharglist; | ||
435 | private Dictionary<int,OTLabel> labels; | ||
436 | private Dictionary<int,OTLocal> locals; | ||
437 | private Dictionary<string,string[]> methargnames; | ||
438 | private LinkedList<OTCilInstr> cilinstrs; | ||
439 | private OTStmtBlock topBlock; | ||
440 | private Stack<OTOpnd> opstack; | ||
441 | private Stack<OTStmtBegExcBlk> trystack; | ||
442 | private Stack<OTStmtBlock> blockstack; | ||
443 | |||
444 | private int dupNo; | ||
445 | private DynamicMethod method; | ||
446 | private string laststate; | ||
447 | private TextWriter twout; | ||
448 | |||
449 | public OTDecompile (ScriptObjCode scriptObjCode, TextWriter twout) : base (scriptObjCode) | ||
450 | { | ||
451 | this.twout = twout; | ||
452 | twout.Write ("xmroption dollarsigns;"); | ||
453 | methargnames = new Dictionary<string,string[]> (); | ||
454 | } | ||
455 | |||
456 | public override void Close () | ||
457 | { | ||
458 | if (laststate != null) { | ||
459 | twout.Write ("\n}"); | ||
460 | laststate = null; | ||
461 | } | ||
462 | twout.Write ('\n'); | ||
463 | } | ||
464 | |||
465 | /** | ||
466 | * About to generate object code for this method. | ||
467 | */ | ||
468 | public override void BegMethod (DynamicMethod method) | ||
469 | { | ||
470 | this.method = method; | ||
471 | |||
472 | eharglist = new Dictionary<int,OTLocal> (); | ||
473 | labels = new Dictionary<int,OTLabel> (); | ||
474 | locals = new Dictionary<int,OTLocal> (); | ||
475 | cilinstrs = new LinkedList<OTCilInstr> (); | ||
476 | opstack = new Stack<OTOpnd> (); | ||
477 | trystack = new Stack<OTStmtBegExcBlk> (); | ||
478 | blockstack = new Stack<OTStmtBlock> (); | ||
479 | |||
480 | dupNo = 0; | ||
481 | } | ||
482 | |||
483 | /** | ||
484 | * Dump out reconstructed source for this method. | ||
485 | */ | ||
486 | public override void EndMethod () | ||
487 | { | ||
488 | /* | ||
489 | * Convert CIL code to primitive statements. | ||
490 | * There are a bunch of labels and internal code such as call stack save restore. | ||
491 | */ | ||
492 | topBlock = new OTStmtBlock (); | ||
493 | blockstack.Push (topBlock); | ||
494 | for (LinkedListNode<OTCilInstr> link = cilinstrs.First; link != null; link = link.Next) { | ||
495 | link.Value.BuildStatements (this, link); | ||
496 | } | ||
497 | |||
498 | /* | ||
499 | * Strip out stuff we don't want, such as references to callMode. | ||
500 | * This strips out stack frame capture and restore code. | ||
501 | */ | ||
502 | topBlock.StripStuff (null); | ||
503 | |||
504 | // including a possible final return statement | ||
505 | // - delete if void return value | ||
506 | // - delete if returning __retval cuz we converted all __retval assignments to return statements | ||
507 | if ((topBlock.blkstmts.Last != null) && (topBlock.blkstmts.Last.Value is OTStmtRet)) { | ||
508 | OTStmtRet finalret = (OTStmtRet) topBlock.blkstmts.Last.Value; | ||
509 | if ((finalret.value == null) || | ||
510 | ((finalret.value is OTOpndLocal) && | ||
511 | ((OTOpndLocal) finalret.value).local.name.StartsWith (_retval))) { | ||
512 | topBlock.blkstmts.RemoveLast (); | ||
513 | } | ||
514 | } | ||
515 | |||
516 | /** | ||
517 | * At this point, all behind-the-scenes references are removed except | ||
518 | * that the do/for/if/while blocks are represented by OTStmtCont-style | ||
519 | * if/jumps. So try to convert them to the higher-level structures. | ||
520 | */ | ||
521 | topBlock.DetectDoForIfWhile (null); | ||
522 | |||
523 | /* | ||
524 | * Final strip to get rid of unneeded @forbreak_<suffix>; labels and the like. | ||
525 | */ | ||
526 | topBlock.StripStuff (null); | ||
527 | |||
528 | /* | ||
529 | * Build reference counts so we don't output unneeded declarations, | ||
530 | * especially temps and internal variables. | ||
531 | */ | ||
532 | foreach (OTLocal local in locals.Values) { | ||
533 | local.nlclreads = 0; | ||
534 | local.nlclwrites = 0; | ||
535 | } | ||
536 | topBlock.CountRefs (); | ||
537 | for (IEnumerator<int> localenum = locals.Keys.GetEnumerator (); localenum.MoveNext ();) { | ||
538 | OTLocal local = locals[localenum.Current]; | ||
539 | if (((local.nlclreads | local.nlclwrites) == 0) || local.name.StartsWith (_xmrinstlocal)) { | ||
540 | locals.Remove (localenum.Current); | ||
541 | localenum = locals.Keys.GetEnumerator (); | ||
542 | } | ||
543 | } | ||
544 | |||
545 | /* | ||
546 | * Strip the $n off of local vars that are not ambiguous. | ||
547 | * Make sure they don't mask globals and arguments as well. | ||
548 | */ | ||
549 | Dictionary<string,int> namecounts = new Dictionary<string,int> (); | ||
550 | foreach (Dictionary<int,string> varnames in scriptObjCode.globalVarNames.Values) { | ||
551 | foreach (string varname in varnames.Values) { | ||
552 | int count; | ||
553 | if (!namecounts.TryGetValue (varname, out count)) count = 0; | ||
554 | namecounts[varname] = count + 1; | ||
555 | } | ||
556 | } | ||
557 | if (methargnames.ContainsKey (method.Name)) { | ||
558 | foreach (string argname in methargnames[method.Name]) { | ||
559 | int count; | ||
560 | if (!namecounts.TryGetValue (argname, out count)) count = 0; | ||
561 | namecounts[argname] = count + 1; | ||
562 | } | ||
563 | } | ||
564 | foreach (OTLocal local in locals.Values) { | ||
565 | int i = local.name.LastIndexOf ('$'); | ||
566 | string name = local.name.Substring (0, i); | ||
567 | int count; | ||
568 | if (!namecounts.TryGetValue (name, out count)) count = 0; | ||
569 | namecounts[name] = count + 1; | ||
570 | } | ||
571 | foreach (OTLocal local in locals.Values) { | ||
572 | int i = local.name.LastIndexOf ('$'); | ||
573 | string name = local.name.Substring (0, i); | ||
574 | int count = namecounts[name]; | ||
575 | if (count == 1) local.name = name; | ||
576 | } | ||
577 | |||
578 | /* | ||
579 | * Print out result. | ||
580 | */ | ||
581 | if (method.Name == _globalvarinit) { | ||
582 | GlobalsDump (); | ||
583 | } else { | ||
584 | MethodDump (); | ||
585 | } | ||
586 | } | ||
587 | |||
588 | /** | ||
589 | * Add instructions to stream. | ||
590 | */ | ||
591 | public override void DefineLabel (int number, string name) | ||
592 | { | ||
593 | labels.Add (number, new OTLabel (number, name)); | ||
594 | } | ||
595 | public override void DefineLocal (int number, string name, string type, Type syType) | ||
596 | { | ||
597 | locals.Add (number, new OTLocal (number, name, type)); | ||
598 | } | ||
599 | public override void DefineMethod (string methName, Type retType, Type[] argTypes, string[] argNames) | ||
600 | { | ||
601 | methargnames[methName] = argNames; | ||
602 | } | ||
603 | public override void MarkLabel (int offset, int number) | ||
604 | { | ||
605 | OTCilInstr label = labels[number]; | ||
606 | label.offset = offset; | ||
607 | cilinstrs.AddLast (label); | ||
608 | } | ||
609 | public override void BegExcBlk (int offset) | ||
610 | { | ||
611 | cilinstrs.AddLast (new OTCilBegExcBlk (offset)); | ||
612 | } | ||
613 | public override void BegCatBlk (int offset, Type excType) | ||
614 | { | ||
615 | cilinstrs.AddLast (new OTCilBegCatBlk (offset, excType)); | ||
616 | } | ||
617 | public override void BegFinBlk (int offset) | ||
618 | { | ||
619 | cilinstrs.AddLast (new OTCilBegFinBlk (offset)); | ||
620 | } | ||
621 | public override void EndExcBlk (int offset) | ||
622 | { | ||
623 | cilinstrs.AddLast (new OTCilEndExcBlk (offset)); | ||
624 | } | ||
625 | public override void EmitNull (int offset, OpCode opCode) | ||
626 | { | ||
627 | cilinstrs.AddLast (new OTCilNull (offset, opCode)); | ||
628 | } | ||
629 | public override void EmitField (int offset, OpCode opCode, FieldInfo field) | ||
630 | { | ||
631 | cilinstrs.AddLast (new OTCilField (offset, opCode, field)); | ||
632 | } | ||
633 | public override void EmitLocal (int offset, OpCode opCode, int number) | ||
634 | { | ||
635 | cilinstrs.AddLast (new OTCilLocal (offset, opCode, locals[number])); | ||
636 | } | ||
637 | public override void EmitType (int offset, OpCode opCode, Type type) | ||
638 | { | ||
639 | cilinstrs.AddLast (new OTCilType (offset, opCode, type)); | ||
640 | } | ||
641 | public override void EmitLabel (int offset, OpCode opCode, int number) | ||
642 | { | ||
643 | cilinstrs.AddLast (new OTCilLabel (offset, opCode, labels[number])); | ||
644 | } | ||
645 | public override void EmitLabels (int offset, OpCode opCode, int[] numbers) | ||
646 | { | ||
647 | OTLabel[] labelarray = new OTLabel[numbers.Length]; | ||
648 | for (int i = 0; i < numbers.Length; i ++) { | ||
649 | labelarray[i] = labels[numbers[i]]; | ||
650 | } | ||
651 | cilinstrs.AddLast (new OTCilLabels (offset, opCode, labelarray)); | ||
652 | } | ||
653 | public override void EmitMethod (int offset, OpCode opCode, MethodInfo method) | ||
654 | { | ||
655 | cilinstrs.AddLast (new OTCilMethod (offset, opCode, method)); | ||
656 | } | ||
657 | public override void EmitCtor (int offset, OpCode opCode, ConstructorInfo ctor) | ||
658 | { | ||
659 | cilinstrs.AddLast (new OTCilCtor (offset, opCode, ctor)); | ||
660 | } | ||
661 | public override void EmitDouble (int offset, OpCode opCode, double value) | ||
662 | { | ||
663 | cilinstrs.AddLast (new OTCilDouble (offset, opCode, value)); | ||
664 | } | ||
665 | public override void EmitFloat (int offset, OpCode opCode, float value) | ||
666 | { | ||
667 | cilinstrs.AddLast (new OTCilFloat (offset, opCode, value)); | ||
668 | } | ||
669 | public override void EmitInteger (int offset, OpCode opCode, int value) | ||
670 | { | ||
671 | cilinstrs.AddLast (new OTCilInteger (offset, opCode, value)); | ||
672 | } | ||
673 | public override void EmitString (int offset, OpCode opCode, string value) | ||
674 | { | ||
675 | cilinstrs.AddLast (new OTCilString (offset, opCode, value)); | ||
676 | } | ||
677 | |||
678 | /** | ||
679 | * Add the given statement to the end of the currently open block. | ||
680 | */ | ||
681 | public void AddLastStmt (OTStmt stmt) | ||
682 | { | ||
683 | blockstack.Peek ().blkstmts.AddLast (stmt); | ||
684 | } | ||
685 | |||
686 | /** | ||
687 | * Generate output for $globalvarinit() function. | ||
688 | * Also outputs declarations for global variables. | ||
689 | */ | ||
690 | private void GlobalsDump () | ||
691 | { | ||
692 | /* | ||
693 | * Scan $globalvarinit(). It should only have global var assignments in it. | ||
694 | * Also gather up list of variables it initializes. | ||
695 | */ | ||
696 | bool badinit = false; | ||
697 | Dictionary<string,string> inittypes = new Dictionary<string,string> (); | ||
698 | foreach (OTStmt stmt in topBlock.blkstmts) { | ||
699 | if (!(stmt is OTStmtStore)) { | ||
700 | badinit = true; | ||
701 | break; | ||
702 | } | ||
703 | OTStmtStore store = (OTStmtStore) stmt; | ||
704 | if (!(store.varwr is OTOpndGlobal)) { | ||
705 | badinit = true; | ||
706 | break; | ||
707 | } | ||
708 | OTOpndGlobal globalop = (OTOpndGlobal) store.varwr; | ||
709 | inittypes[globalop.PrintableString] = ""; | ||
710 | } | ||
711 | |||
712 | /* | ||
713 | * Scan through list of all global variables in the script. | ||
714 | * Output declarations for those what don't have any init statement for them. | ||
715 | * Save the type for those that do have init statements. | ||
716 | */ | ||
717 | bool first = true; | ||
718 | foreach (string iartypename in scriptObjCode.globalVarNames.Keys) { | ||
719 | Dictionary<int,string> varnames = scriptObjCode.globalVarNames[iartypename]; | ||
720 | string typename = iartypename.ToLowerInvariant (); | ||
721 | if (typename.StartsWith ("iar")) typename = typename.Substring (3); | ||
722 | if (typename.EndsWith ("s")) typename = typename.Substring (0, typename.Length - 1); | ||
723 | foreach (string varname in varnames.Values) { | ||
724 | if (!badinit && inittypes.ContainsKey (varname)) { | ||
725 | inittypes[varname] = typename; | ||
726 | } else { | ||
727 | if (first) twout.Write ('\n'); | ||
728 | twout.Write ('\n' + typename + ' ' + varname + ';'); | ||
729 | first = false; | ||
730 | } | ||
731 | } | ||
732 | } | ||
733 | |||
734 | /* | ||
735 | * If $globalvarinit() has anything bad in it, output it as a function. | ||
736 | * Otherwise, output it as a series of global declarations with init values. | ||
737 | */ | ||
738 | if (badinit) { | ||
739 | MethodDump (); | ||
740 | } else { | ||
741 | foreach (OTStmt stmt in topBlock.blkstmts) { | ||
742 | OTStmtStore store = (OTStmtStore) stmt; | ||
743 | OTOpndGlobal globalop = (OTOpndGlobal) store.varwr; | ||
744 | string name = globalop.PrintableString; | ||
745 | if (first) twout.Write ('\n'); | ||
746 | twout.Write ('\n' + inittypes[name] + ' '); | ||
747 | store.PrintStmt (twout, ""); | ||
748 | first = false; | ||
749 | } | ||
750 | } | ||
751 | } | ||
752 | |||
753 | /** | ||
754 | * Generate output for other functions. | ||
755 | */ | ||
756 | private void MethodDump () | ||
757 | { | ||
758 | string indent; | ||
759 | |||
760 | /* | ||
761 | * Event handlers don't have an argument list as such in the original | ||
762 | * code. Instead they have a series of assignments from ehargs[] to | ||
763 | * local variables. So make those local variables look like they are | ||
764 | * an argument list. | ||
765 | */ | ||
766 | int i = method.Name.IndexOf (' '); | ||
767 | if (i >= 0) { | ||
768 | |||
769 | /* | ||
770 | * Maybe we have to output the state name. | ||
771 | */ | ||
772 | string statename = method.Name.Substring (0, i); | ||
773 | string eventname = method.Name.Substring (++ i); | ||
774 | |||
775 | if (laststate != statename) { | ||
776 | if (laststate != null) twout.Write ("\n}"); | ||
777 | if (statename == "default") { | ||
778 | twout.Write ("\n\ndefault {"); | ||
779 | } else { | ||
780 | twout.Write ("\n\nstate " + statename + " {"); | ||
781 | } | ||
782 | laststate = statename; | ||
783 | } else { | ||
784 | twout.Write ('\n'); | ||
785 | } | ||
786 | |||
787 | /* | ||
788 | * Output event name and argument list. | ||
789 | * Remove from locals list so they don't print below. | ||
790 | */ | ||
791 | twout.Write ('\n' + INDENT + eventname + " ("); | ||
792 | MethodInfo meth = typeof (IEventHandlers).GetMethod (eventname); | ||
793 | i = 0; | ||
794 | foreach (ParameterInfo pi in meth.GetParameters ()) { | ||
795 | // skip the first param cuz it's the XMRInstance arg | ||
796 | if (i > 0) twout.Write (", "); | ||
797 | OTLocal local; | ||
798 | if (eharglist.TryGetValue (i, out local) && locals.ContainsKey (local.number)) { | ||
799 | twout.Write (local.DumpString ()); | ||
800 | locals.Remove (local.number); | ||
801 | } else { | ||
802 | // maybe the assignment was removed | ||
803 | // eg, because the local was write-only (not referenced) | ||
804 | // so substitute in placeholder that won't be referenced | ||
805 | twout.Write (AbbrType (pi.ParameterType) + " arg$" + (i + 1)); | ||
806 | } | ||
807 | i ++; | ||
808 | } | ||
809 | twout.Write (')'); | ||
810 | |||
811 | /* | ||
812 | * Indent method body by 4 spaces. | ||
813 | */ | ||
814 | indent = INDENT; | ||
815 | } else { | ||
816 | |||
817 | /* | ||
818 | * Maybe need to close out previous state. | ||
819 | */ | ||
820 | if (laststate != null) { | ||
821 | twout.Write ("\n}"); | ||
822 | laststate = null; | ||
823 | } | ||
824 | |||
825 | /* | ||
826 | * Output blank line and return type (if any). | ||
827 | */ | ||
828 | twout.Write ("\n\n"); | ||
829 | if (method.ReturnType != typeof (void)) { | ||
830 | twout.Write (AbbrType (method.ReturnType) + ' '); | ||
831 | } | ||
832 | |||
833 | /* | ||
834 | * Output method name and argument list. | ||
835 | */ | ||
836 | int j = method.Name.IndexOf ('('); | ||
837 | if (j < 0) { | ||
838 | twout.Write (method.Name); | ||
839 | } else { | ||
840 | twout.Write (method.Name.Substring (0, j) + " ("); | ||
841 | bool first = true; | ||
842 | j = 0; | ||
843 | foreach (ParameterInfo pi in method.GetParameters ()) { | ||
844 | if (j > 0) { // skip the XMRInstance arg$0 parameter | ||
845 | if (!first) twout.Write (", "); | ||
846 | twout.Write (AbbrType (pi.ParameterType) + ' ' + MethArgName (j)); | ||
847 | first = false; | ||
848 | } | ||
849 | j ++; | ||
850 | } | ||
851 | twout.Write (')'); | ||
852 | } | ||
853 | |||
854 | /* | ||
855 | * Don't indent method body at all. | ||
856 | */ | ||
857 | indent = ""; | ||
858 | } | ||
859 | |||
860 | /* | ||
861 | * Output local variable declarations. | ||
862 | */ | ||
863 | twout.Write ('\n' + indent + '{'); | ||
864 | bool didOne = false; | ||
865 | foreach (OTLocal local in locals.Values) { | ||
866 | twout.Write ('\n' + indent + INDENT + local.DumpString () + "; // r:" + local.nlclreads + " w:" + local.nlclwrites); | ||
867 | didOne = true; | ||
868 | } | ||
869 | if (didOne) twout.Write ('\n'); | ||
870 | |||
871 | /* | ||
872 | * Output statements. | ||
873 | */ | ||
874 | if (topBlock.blkstmts.Count == 0) { | ||
875 | twout.Write (" }"); | ||
876 | } else { | ||
877 | topBlock.PrintBodyAndEnd (twout, indent); | ||
878 | } | ||
879 | } | ||
880 | |||
881 | /** | ||
882 | * Get abbreviated type string. | ||
883 | */ | ||
884 | public static string AbbrType (Type type) | ||
885 | { | ||
886 | if (type == null) return "null"; | ||
887 | return AbbrType (type.Name); | ||
888 | } | ||
889 | public static string AbbrType (string type) | ||
890 | { | ||
891 | if (type.StartsWith ("OpenSim.Region.ScriptEngine.XMREngine.")) { | ||
892 | type = type.Substring (38); | ||
893 | int i = type.IndexOf (','); | ||
894 | if (i > 0) type = type.Substring (0, i); | ||
895 | } | ||
896 | if (typeTranslator.ContainsKey (type)) { | ||
897 | type = typeTranslator[type]; | ||
898 | } | ||
899 | return type; | ||
900 | } | ||
901 | |||
902 | /** | ||
903 | * Get current method's argument name. | ||
904 | */ | ||
905 | public string MethArgName (int index) | ||
906 | { | ||
907 | string[] argnames; | ||
908 | if (methargnames.TryGetValue (method.Name, out argnames) && (index < argnames.Length)) { | ||
909 | return argnames[index]; | ||
910 | } | ||
911 | return "arg$" + index; | ||
912 | } | ||
913 | |||
914 | /** | ||
915 | * Strip svperflvovs (float) cast from rotation/vector values. | ||
916 | */ | ||
917 | public static OTOpnd StripFloatCast (OTOpnd op) | ||
918 | { | ||
919 | if (op is OTOpndCast) { | ||
920 | OTOpndCast opcast = (OTOpndCast) op; | ||
921 | if ((opcast.type == typeof (double)) && (opcast.value is OTOpndInt)) { | ||
922 | return opcast.value; | ||
923 | } | ||
924 | } | ||
925 | return op; | ||
926 | } | ||
927 | |||
928 | /** | ||
929 | * Strip svperflvovs Brtrues so we don't end up with stuff like 'if (!! someint) ...'. | ||
930 | */ | ||
931 | public static OTOpnd StripBrtrue (OTOpnd op) | ||
932 | { | ||
933 | if (op is OTOpndUnOp) { | ||
934 | OTOpndUnOp opunop = (OTOpndUnOp) op; | ||
935 | if (opunop.opCode == MyOp.Brtrue) return opunop.value; | ||
936 | } | ||
937 | return op; | ||
938 | } | ||
939 | |||
940 | /* | ||
941 | * Local variable declaration. | ||
942 | */ | ||
943 | private class OTLocal { | ||
944 | public int number; | ||
945 | public string name; | ||
946 | public string type; | ||
947 | |||
948 | public int nlclreads; | ||
949 | public int nlclwrites; | ||
950 | |||
951 | public OTLocal (int number, string name, string type) | ||
952 | { | ||
953 | this.number = number; | ||
954 | this.name = name.StartsWith ("tmp$") ? name : name + "$" + number; | ||
955 | this.type = type; | ||
956 | } | ||
957 | |||
958 | public string DumpString () | ||
959 | { | ||
960 | return AbbrType (type) + ' ' + name; | ||
961 | } | ||
962 | } | ||
963 | |||
964 | /***********************************************\ | ||
965 | * Tokens that are one-for-one with CIL code * | ||
966 | \***********************************************/ | ||
967 | |||
968 | /* | ||
969 | * Part of instruction stream. | ||
970 | */ | ||
971 | public abstract class OTCilInstr { | ||
972 | public int offset; // cil offset | ||
973 | |||
974 | public OTCilInstr (int offset) | ||
975 | { | ||
976 | this.offset = offset; | ||
977 | } | ||
978 | |||
979 | public abstract string DumpString (); | ||
980 | public abstract void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link); | ||
981 | |||
982 | protected void CheckEmptyStack (OTDecompile decompile, string opMnemonic) | ||
983 | { | ||
984 | if (decompile.opstack.Count > 0) { | ||
985 | Console.Error.WriteLine ("CheckEmptyStack: " + decompile.method.Name + " 0x" + offset.ToString ("X") + ": " + | ||
986 | opMnemonic + " stack depth " + decompile.opstack.Count); | ||
987 | } | ||
988 | } | ||
989 | } | ||
990 | |||
991 | /* | ||
992 | * Label mark point. | ||
993 | */ | ||
994 | private class OTLabel : OTCilInstr { | ||
995 | public int number; | ||
996 | public string name; | ||
997 | |||
998 | public int lbljumps; | ||
999 | |||
1000 | public OTLabel (int number, string name) : base (-1) | ||
1001 | { | ||
1002 | this.number = number; | ||
1003 | this.name = name; | ||
1004 | } | ||
1005 | |||
1006 | public string PrintableName { | ||
1007 | get { | ||
1008 | if (name.StartsWith (_doBreak)) return _doBreak + "$" + number; | ||
1009 | if (name.StartsWith (_doCont)) return _doCont + "$" + number; | ||
1010 | if (name.StartsWith (_forBreak)) return _forBreak + "$" + number; | ||
1011 | if (name.StartsWith (_forCont)) return _forCont + "$" + number; | ||
1012 | if (name.StartsWith (_whileBreak)) return _whileBreak + "$" + number; | ||
1013 | if (name.StartsWith (_whileCont)) return _whileCont + "$" + number; | ||
1014 | return name; | ||
1015 | } | ||
1016 | } | ||
1017 | |||
1018 | public override string DumpString () | ||
1019 | { | ||
1020 | return name + ":"; | ||
1021 | } | ||
1022 | |||
1023 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1024 | { | ||
1025 | OTStmtLabel.AddLast (decompile, this); | ||
1026 | } | ||
1027 | } | ||
1028 | |||
1029 | /* | ||
1030 | * 'try {' | ||
1031 | */ | ||
1032 | private class OTCilBegExcBlk : OTCilInstr { | ||
1033 | public LinkedList<OTCilBegCatBlk> catches = new LinkedList<OTCilBegCatBlk> (); | ||
1034 | |||
1035 | public OTCilBegExcBlk (int offset) : base (offset) | ||
1036 | { } | ||
1037 | |||
1038 | public override string DumpString () | ||
1039 | { | ||
1040 | return "try {"; | ||
1041 | } | ||
1042 | |||
1043 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1044 | { | ||
1045 | CheckEmptyStack (decompile, "try"); | ||
1046 | |||
1047 | // link the try itself onto outer block | ||
1048 | OTStmtBegExcBlk trystmt = new OTStmtBegExcBlk (); | ||
1049 | decompile.AddLastStmt (trystmt); | ||
1050 | |||
1051 | // subsequent statements go to the try block | ||
1052 | trystmt.tryblock = new OTStmtBlock (); | ||
1053 | decompile.trystack.Push (trystmt); | ||
1054 | decompile.blockstack.Push (trystmt.tryblock); | ||
1055 | } | ||
1056 | } | ||
1057 | |||
1058 | /* | ||
1059 | * '} catch (...) {' | ||
1060 | */ | ||
1061 | private class OTCilBegCatBlk : OTCilInstr { | ||
1062 | public Type excType; | ||
1063 | |||
1064 | public OTCilBegCatBlk (int offset, Type excType) : base (offset) | ||
1065 | { | ||
1066 | this.excType = excType; | ||
1067 | } | ||
1068 | |||
1069 | public override string DumpString () | ||
1070 | { | ||
1071 | return "} catch (" + AbbrType (excType) + ") {"; | ||
1072 | } | ||
1073 | |||
1074 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1075 | { | ||
1076 | CheckEmptyStack (decompile, "catch"); | ||
1077 | |||
1078 | // link the catch itself onto the try statement | ||
1079 | OTStmtBegExcBlk trystmt = decompile.trystack.Peek (); | ||
1080 | OTStmtBegCatBlk catstmt = new OTStmtBegCatBlk (excType); | ||
1081 | trystmt.catches.AddLast (catstmt); | ||
1082 | |||
1083 | // start capturing statements into the catch block | ||
1084 | catstmt.tryblock = trystmt; | ||
1085 | catstmt.catchblock = new OTStmtBlock (); | ||
1086 | decompile.blockstack.Pop (); | ||
1087 | decompile.blockstack.Push (catstmt.catchblock); | ||
1088 | |||
1089 | // fill the stack slot with something for the exception argument | ||
1090 | OTOpndDup dup = new OTOpndDup (++ decompile.dupNo); | ||
1091 | decompile.opstack.Push (dup); | ||
1092 | } | ||
1093 | } | ||
1094 | |||
1095 | /* | ||
1096 | * '} finally {' | ||
1097 | */ | ||
1098 | private class OTCilBegFinBlk : OTCilInstr { | ||
1099 | public OTCilBegFinBlk (int offset) : base (offset) | ||
1100 | { } | ||
1101 | |||
1102 | public override string DumpString () | ||
1103 | { | ||
1104 | return "} finally {"; | ||
1105 | } | ||
1106 | |||
1107 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1108 | { | ||
1109 | CheckEmptyStack (decompile, "finally"); | ||
1110 | |||
1111 | // link the finally itself to the try statement | ||
1112 | OTStmtBegExcBlk trystmt = decompile.trystack.Peek (); | ||
1113 | OTStmtBegFinBlk finstmt = new OTStmtBegFinBlk (); | ||
1114 | trystmt.finblock = finstmt; | ||
1115 | |||
1116 | // start capturing statements into the finally block | ||
1117 | finstmt.tryblock = trystmt; | ||
1118 | finstmt.finblock = new OTStmtBlock (); | ||
1119 | decompile.blockstack.Pop (); | ||
1120 | decompile.blockstack.Push (finstmt.finblock); | ||
1121 | } | ||
1122 | } | ||
1123 | |||
1124 | /* | ||
1125 | * '}' end of try | ||
1126 | */ | ||
1127 | private class OTCilEndExcBlk : OTCilInstr { | ||
1128 | public OTCilEndExcBlk (int offset) : base (offset) | ||
1129 | { } | ||
1130 | |||
1131 | public override string DumpString () | ||
1132 | { | ||
1133 | return "} // end try"; | ||
1134 | } | ||
1135 | |||
1136 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1137 | { | ||
1138 | CheckEmptyStack (decompile, "endtry"); | ||
1139 | |||
1140 | // pop the try/catch/finally blocks from stacks | ||
1141 | decompile.blockstack.Pop (); | ||
1142 | decompile.trystack.Pop (); | ||
1143 | |||
1144 | // subsequent statements collect following the try | ||
1145 | } | ||
1146 | } | ||
1147 | |||
1148 | /* | ||
1149 | * Actual opcodes (instructions). | ||
1150 | */ | ||
1151 | private class OTCilNull : OTCilInstr { | ||
1152 | public MyOp opCode; | ||
1153 | |||
1154 | public OTCilNull (int offset, OpCode opCode) : base (offset) | ||
1155 | { | ||
1156 | this.opCode = MyOp.GetByName (opCode.Name); | ||
1157 | } | ||
1158 | |||
1159 | public override string DumpString () | ||
1160 | { | ||
1161 | return opCode.ToString (); | ||
1162 | } | ||
1163 | |||
1164 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1165 | { | ||
1166 | switch (opCode.ToString ()) { | ||
1167 | case "conv.i1": | ||
1168 | case "conv.i2": | ||
1169 | case "conv.i4": | ||
1170 | case "conv.i8": { | ||
1171 | OTOpnd value = decompile.opstack.Pop (); | ||
1172 | decompile.opstack.Push (new OTOpndCast (typeof (int), value)); | ||
1173 | break; | ||
1174 | } | ||
1175 | case "conv.r4": | ||
1176 | case "conv.r8": { | ||
1177 | OTOpnd value = decompile.opstack.Pop (); | ||
1178 | decompile.opstack.Push (new OTOpndCast (typeof (double), value)); | ||
1179 | break; | ||
1180 | } | ||
1181 | case "dup": { | ||
1182 | OTOpnd value = decompile.opstack.Pop (); | ||
1183 | if (!(value is OTOpndDup)) { | ||
1184 | OTOpndDup dup = new OTOpndDup (++ decompile.dupNo); | ||
1185 | OTStmtStore.AddLast (decompile, dup, value); | ||
1186 | value = dup; | ||
1187 | } | ||
1188 | decompile.opstack.Push (value); | ||
1189 | decompile.opstack.Push (value); | ||
1190 | break; | ||
1191 | } | ||
1192 | case "endfinally": break; | ||
1193 | case "ldarg.0": { decompile.opstack.Push (new OTOpndArg (0, false, decompile)); break; } | ||
1194 | case "ldarg.1": { decompile.opstack.Push (new OTOpndArg (1, false, decompile)); break; } | ||
1195 | case "ldarg.2": { decompile.opstack.Push (new OTOpndArg (2, false, decompile)); break; } | ||
1196 | case "ldarg.3": { decompile.opstack.Push (new OTOpndArg (3, false, decompile)); break; } | ||
1197 | case "ldc.i4.0": { decompile.opstack.Push (new OTOpndInt (0)); break; } | ||
1198 | case "ldc.i4.1": { decompile.opstack.Push (new OTOpndInt (1)); break; } | ||
1199 | case "ldc.i4.2": { decompile.opstack.Push (new OTOpndInt (2)); break; } | ||
1200 | case "ldc.i4.3": { decompile.opstack.Push (new OTOpndInt (3)); break; } | ||
1201 | case "ldc.i4.4": { decompile.opstack.Push (new OTOpndInt (4)); break; } | ||
1202 | case "ldc.i4.5": { decompile.opstack.Push (new OTOpndInt (5)); break; } | ||
1203 | case "ldc.i4.6": { decompile.opstack.Push (new OTOpndInt (6)); break; } | ||
1204 | case "ldc.i4.7": { decompile.opstack.Push (new OTOpndInt (7)); break; } | ||
1205 | case "ldc.i4.8": { decompile.opstack.Push (new OTOpndInt (8)); break; } | ||
1206 | case "ldc.i4.m1": { decompile.opstack.Push (new OTOpndInt (-1)); break; } | ||
1207 | case "ldelem.i4": | ||
1208 | case "ldelem.r4": | ||
1209 | case "ldelem.r8": | ||
1210 | case "ldelem.ref": { | ||
1211 | OTOpnd index = decompile.opstack.Pop (); | ||
1212 | OTOpnd array = decompile.opstack.Pop (); | ||
1213 | decompile.opstack.Push (OTOpndArrayElem.Make (array, index, false, decompile)); | ||
1214 | break; | ||
1215 | } | ||
1216 | case "ldnull": { | ||
1217 | decompile.opstack.Push (new OTOpndNull ()); | ||
1218 | break; | ||
1219 | } | ||
1220 | case "neg": | ||
1221 | case "not": { | ||
1222 | OTOpnd value = decompile.opstack.Pop (); | ||
1223 | decompile.opstack.Push (OTOpndUnOp.Make (opCode, value)); | ||
1224 | break; | ||
1225 | } | ||
1226 | case "pop": { | ||
1227 | OTStmtVoid.AddLast (decompile, decompile.opstack.Pop ()); | ||
1228 | break; | ||
1229 | } | ||
1230 | case "ret": { | ||
1231 | OTOpnd value = null; | ||
1232 | if (decompile.method.ReturnType != typeof (void)) { | ||
1233 | value = decompile.opstack.Pop (); | ||
1234 | } | ||
1235 | CheckEmptyStack (decompile); | ||
1236 | decompile.AddLastStmt (new OTStmtRet (value)); | ||
1237 | break; | ||
1238 | } | ||
1239 | case "stelem.i4": | ||
1240 | case "stelem.r8": | ||
1241 | case "stelem.ref": { | ||
1242 | OTOpnd value = decompile.opstack.Pop (); | ||
1243 | OTOpnd index = decompile.opstack.Pop (); | ||
1244 | OTOpnd array = decompile.opstack.Pop (); | ||
1245 | OTStmtStore.AddLast (decompile, OTOpndArrayElem.Make (array, index, false, decompile), value); | ||
1246 | break; | ||
1247 | } | ||
1248 | case "throw": { | ||
1249 | OTOpnd value = decompile.opstack.Pop (); | ||
1250 | CheckEmptyStack (decompile); | ||
1251 | decompile.AddLastStmt (new OTStmtThrow (value, decompile)); | ||
1252 | break; | ||
1253 | } | ||
1254 | case "add": | ||
1255 | case "and": | ||
1256 | case "ceq": | ||
1257 | case "cgt": | ||
1258 | case "cgt.un": | ||
1259 | case "clt": | ||
1260 | case "clt.un": | ||
1261 | case "div": | ||
1262 | case "div.un": | ||
1263 | case "mul": | ||
1264 | case "or": | ||
1265 | case "rem": | ||
1266 | case "rem.un": | ||
1267 | case "shl": | ||
1268 | case "shr": | ||
1269 | case "shr.un": | ||
1270 | case "sub": | ||
1271 | case "xor": { | ||
1272 | OTOpnd rite = decompile.opstack.Pop (); | ||
1273 | OTOpnd left = decompile.opstack.Pop (); | ||
1274 | decompile.opstack.Push (OTOpndBinOp.Make (left, opCode, rite)); | ||
1275 | break; | ||
1276 | } | ||
1277 | default: throw new Exception ("unknown opcode " + opCode.ToString ()); | ||
1278 | } | ||
1279 | } | ||
1280 | |||
1281 | protected void CheckEmptyStack (OTDecompile decompile) | ||
1282 | { | ||
1283 | CheckEmptyStack (decompile, opCode.ToString ()); | ||
1284 | } | ||
1285 | } | ||
1286 | |||
1287 | private class OTCilField : OTCilNull { | ||
1288 | public FieldInfo field; | ||
1289 | |||
1290 | public OTCilField (int offset, OpCode opCode, FieldInfo field) : base (offset, opCode) | ||
1291 | { | ||
1292 | this.field = field; | ||
1293 | } | ||
1294 | |||
1295 | public override string DumpString () | ||
1296 | { | ||
1297 | return opCode.ToString () + ' ' + field.Name; | ||
1298 | } | ||
1299 | |||
1300 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1301 | { | ||
1302 | switch (opCode.ToString ()) { | ||
1303 | case "ldfld": { | ||
1304 | OTOpnd obj = decompile.opstack.Pop (); | ||
1305 | decompile.opstack.Push (OTOpndField.Make (obj, field)); | ||
1306 | break; | ||
1307 | } | ||
1308 | case "ldsfld": { | ||
1309 | decompile.opstack.Push (new OTOpndSField (field)); | ||
1310 | break; | ||
1311 | } | ||
1312 | case "stfld": { | ||
1313 | OTOpnd val = decompile.opstack.Pop (); | ||
1314 | OTOpnd obj = decompile.opstack.Pop (); | ||
1315 | OTStmtStore.AddLast (decompile, OTOpndField.Make (obj, field), val); | ||
1316 | break; | ||
1317 | } | ||
1318 | case "stsfld": { | ||
1319 | OTOpnd val = decompile.opstack.Pop (); | ||
1320 | OTStmtStore.AddLast (decompile, new OTOpndSField (field), val); | ||
1321 | break; | ||
1322 | } | ||
1323 | default: throw new Exception ("unknown opcode " + opCode.ToString ()); | ||
1324 | } | ||
1325 | } | ||
1326 | } | ||
1327 | |||
1328 | private class OTCilLocal : OTCilNull { | ||
1329 | public OTLocal local; | ||
1330 | |||
1331 | public OTCilLocal (int offset, OpCode opCode, OTLocal local) : base (offset, opCode) | ||
1332 | { | ||
1333 | this.local = local; | ||
1334 | } | ||
1335 | |||
1336 | public override string DumpString () | ||
1337 | { | ||
1338 | return opCode.ToString () + ' ' + local.name; | ||
1339 | } | ||
1340 | |||
1341 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1342 | { | ||
1343 | switch (opCode.ToString ()) { | ||
1344 | case "ldloc": { | ||
1345 | decompile.opstack.Push (new OTOpndLocal (local)); | ||
1346 | break; | ||
1347 | } | ||
1348 | case "ldloca": { | ||
1349 | decompile.opstack.Push (new OTOpndLocalRef (local)); | ||
1350 | break; | ||
1351 | } | ||
1352 | case "stloc": { | ||
1353 | OTOpnd val = decompile.opstack.Pop (); | ||
1354 | OTStmtStore.AddLast (decompile, new OTOpndLocal (local), val); | ||
1355 | break; | ||
1356 | } | ||
1357 | default: throw new Exception ("unknown opcode " + opCode.ToString ()); | ||
1358 | } | ||
1359 | } | ||
1360 | } | ||
1361 | |||
1362 | private class OTCilType : OTCilNull { | ||
1363 | public Type type; | ||
1364 | |||
1365 | public OTCilType (int offset, OpCode opCode, Type type) : base (offset, opCode) | ||
1366 | { | ||
1367 | this.type = type; | ||
1368 | } | ||
1369 | |||
1370 | public override string DumpString () | ||
1371 | { | ||
1372 | return opCode.ToString () + ' ' + AbbrType (type); | ||
1373 | } | ||
1374 | |||
1375 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1376 | { | ||
1377 | switch (opCode.ToString ()) { | ||
1378 | case "box": { | ||
1379 | break; | ||
1380 | } | ||
1381 | case "castclass": | ||
1382 | case "unbox.any": { | ||
1383 | OTOpnd value = decompile.opstack.Pop (); | ||
1384 | decompile.opstack.Push (new OTOpndCast (type, value)); | ||
1385 | break; | ||
1386 | } | ||
1387 | case "ldelem": { | ||
1388 | OTOpnd index = decompile.opstack.Pop (); | ||
1389 | OTOpnd array = decompile.opstack.Pop (); | ||
1390 | decompile.opstack.Push (OTOpndArrayElem.Make (array, index, false, decompile)); | ||
1391 | break; | ||
1392 | } | ||
1393 | case "ldelema": { | ||
1394 | OTOpnd index = decompile.opstack.Pop (); | ||
1395 | OTOpnd array = decompile.opstack.Pop (); | ||
1396 | decompile.opstack.Push (OTOpndArrayElem.Make (array, index, true, decompile)); | ||
1397 | break; | ||
1398 | } | ||
1399 | case "newarr": { | ||
1400 | OTOpnd index = decompile.opstack.Pop (); | ||
1401 | decompile.opstack.Push (new OTOpndNewarr (type, index)); | ||
1402 | break; | ||
1403 | } | ||
1404 | case "stelem": { | ||
1405 | OTOpnd value = decompile.opstack.Pop (); | ||
1406 | OTOpnd index = decompile.opstack.Pop (); | ||
1407 | OTOpnd array = decompile.opstack.Pop (); | ||
1408 | OTStmtStore.AddLast (decompile, OTOpndArrayElem.Make (array, index, false, decompile), value); | ||
1409 | break; | ||
1410 | } | ||
1411 | default: throw new Exception ("unknown opcode " + opCode.ToString ()); | ||
1412 | } | ||
1413 | } | ||
1414 | } | ||
1415 | |||
1416 | private class OTCilLabel : OTCilNull { | ||
1417 | public OTLabel label; | ||
1418 | |||
1419 | public OTCilLabel (int offset, OpCode opCode, OTLabel label) : base (offset, opCode) | ||
1420 | { | ||
1421 | this.label = label; | ||
1422 | } | ||
1423 | |||
1424 | public override string DumpString () | ||
1425 | { | ||
1426 | return opCode.ToString () + ' ' + label.name; | ||
1427 | } | ||
1428 | |||
1429 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1430 | { | ||
1431 | switch (opCode.ToString ()) { | ||
1432 | |||
1433 | /* | ||
1434 | * We don't handle non-empty stack at branch points. | ||
1435 | * | ||
1436 | * So handle this case specially: | ||
1437 | * | ||
1438 | * dup | ||
1439 | * ldc.i4.0 | ||
1440 | * bge.s llAbstemp << we are here | ||
1441 | * neg | ||
1442 | * llAbstemp: | ||
1443 | * | ||
1444 | * becomes: | ||
1445 | * | ||
1446 | * call llAbs | ||
1447 | */ | ||
1448 | case "bge.s": { | ||
1449 | OTOpnd rite = decompile.opstack.Pop (); // alleged zero | ||
1450 | OTOpnd left = decompile.opstack.Pop (); // alleged dup | ||
1451 | |||
1452 | if ((label.name == _llAbstemp) && (decompile.opstack.Count > 0)) { | ||
1453 | LinkedListNode<OTCilInstr> linkneg = link.Next; | ||
1454 | if ((left is OTOpndDup) && (rite is OTOpndInt) && | ||
1455 | (linkneg != null) && (linkneg.Value is OTCilNull) && | ||
1456 | (((OTCilNull) linkneg.Value).opCode == MyOp.Neg)) { | ||
1457 | OTOpndInt riteint = (OTOpndInt) rite; | ||
1458 | LinkedListNode<OTCilInstr> linklbl = linkneg.Next; | ||
1459 | if ((riteint.value == 0) && (linklbl != null) && (linklbl.Value is OTLabel) && | ||
1460 | (((OTLabel) linklbl.Value) == label)) { | ||
1461 | linkneg.List.Remove (linkneg); | ||
1462 | linklbl.List.Remove (linklbl); | ||
1463 | MethodInfo method = typeof (ScriptBaseClass).GetMethod ("llAbs"); | ||
1464 | OTOpnd[] args = new OTOpnd[] { new OTOpndNull (), decompile.opstack.Pop () }; | ||
1465 | OTOpndCall.AddLast (decompile, method, args); | ||
1466 | break; | ||
1467 | } | ||
1468 | } | ||
1469 | } | ||
1470 | |||
1471 | CheckEmptyStack (decompile); | ||
1472 | OTOpnd valu = OTOpndBinOp.Make (left, opCode, rite); | ||
1473 | OTStmt jump = OTStmtJump.Make (label); | ||
1474 | decompile.AddLastStmt (new OTStmtCond (valu, jump)); | ||
1475 | break; | ||
1476 | } | ||
1477 | |||
1478 | case "beq": | ||
1479 | case "bge": | ||
1480 | case "bgt": | ||
1481 | case "ble": | ||
1482 | case "blt": | ||
1483 | case "bne.un": | ||
1484 | case "beq.s": | ||
1485 | case "bgt.s": | ||
1486 | case "ble.s": | ||
1487 | case "blt.s": | ||
1488 | case "bne.un.s": { | ||
1489 | OTOpnd rite = decompile.opstack.Pop (); | ||
1490 | OTOpnd left = decompile.opstack.Pop (); | ||
1491 | CheckEmptyStack (decompile); | ||
1492 | OTOpnd valu = OTOpndBinOp.Make (left, opCode, rite); | ||
1493 | OTStmt jump = OTStmtJump.Make (label); | ||
1494 | decompile.AddLastStmt (new OTStmtCond (valu, jump)); | ||
1495 | break; | ||
1496 | } | ||
1497 | case "brfalse": | ||
1498 | case "brfalse.s": | ||
1499 | case "brtrue": | ||
1500 | case "brtrue.s": { | ||
1501 | OTOpnd value = decompile.opstack.Pop (); | ||
1502 | CheckEmptyStack (decompile); | ||
1503 | OTOpnd valu = OTOpndUnOp.Make (opCode, value); | ||
1504 | OTStmt jump = OTStmtJump.Make (label); | ||
1505 | decompile.AddLastStmt (new OTStmtCond (valu, jump)); | ||
1506 | break; | ||
1507 | } | ||
1508 | case "br": | ||
1509 | case "br.s": | ||
1510 | case "leave": { | ||
1511 | CheckEmptyStack (decompile); | ||
1512 | OTStmt jump = OTStmtJump.Make (label); | ||
1513 | decompile.AddLastStmt (jump); | ||
1514 | break; | ||
1515 | } | ||
1516 | default: throw new Exception ("unknown opcode " + opCode.ToString ()); | ||
1517 | } | ||
1518 | } | ||
1519 | } | ||
1520 | |||
1521 | private class OTCilLabels : OTCilNull { | ||
1522 | public OTLabel[] labels; | ||
1523 | |||
1524 | public OTCilLabels (int offset, OpCode opCode, OTLabel[] labels) : base (offset, opCode) | ||
1525 | { | ||
1526 | this.labels = labels; | ||
1527 | } | ||
1528 | |||
1529 | public override string DumpString () | ||
1530 | { | ||
1531 | StringBuilder sb = new StringBuilder (); | ||
1532 | sb.Append (opCode.ToString ()); | ||
1533 | foreach (OTLabel label in labels) { | ||
1534 | sb.Append (' '); | ||
1535 | sb.Append (label.name); | ||
1536 | } | ||
1537 | return sb.ToString (); | ||
1538 | } | ||
1539 | |||
1540 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1541 | { | ||
1542 | switch (opCode.ToString ()) { | ||
1543 | case "switch": { | ||
1544 | OTOpnd value = decompile.opstack.Pop (); | ||
1545 | CheckEmptyStack (decompile); | ||
1546 | decompile.AddLastStmt (new OTStmtSwitch (value, labels)); | ||
1547 | break; | ||
1548 | } | ||
1549 | default: throw new Exception ("unknown opcode " + opCode.ToString ()); | ||
1550 | } | ||
1551 | } | ||
1552 | } | ||
1553 | |||
1554 | private class OTCilMethod : OTCilNull { | ||
1555 | public MethodInfo method; | ||
1556 | |||
1557 | public OTCilMethod (int offset, OpCode opCode, MethodInfo method) : base (offset, opCode) | ||
1558 | { | ||
1559 | this.method = method; | ||
1560 | } | ||
1561 | |||
1562 | public override string DumpString () | ||
1563 | { | ||
1564 | return opCode.ToString () + ' ' + method.Name; | ||
1565 | } | ||
1566 | |||
1567 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1568 | { | ||
1569 | switch (opCode.ToString ()) { | ||
1570 | case "call": | ||
1571 | case "callvirt": { | ||
1572 | int nargs = method.GetParameters ().Length; | ||
1573 | if (!method.IsStatic) nargs ++; | ||
1574 | OTOpnd[] args = new OTOpnd[nargs]; | ||
1575 | for (int i = nargs; -- i >= 0;) { | ||
1576 | args[i] = decompile.opstack.Pop (); | ||
1577 | } | ||
1578 | OTOpndCall.AddLast (decompile, method, args); | ||
1579 | break; | ||
1580 | } | ||
1581 | default: throw new Exception ("unknown opcode " + opCode.ToString ()); | ||
1582 | } | ||
1583 | } | ||
1584 | } | ||
1585 | |||
1586 | private class OTCilCtor : OTCilNull { | ||
1587 | public ConstructorInfo ctor; | ||
1588 | |||
1589 | public OTCilCtor (int offset, OpCode opCode, ConstructorInfo ctor) : base (offset, opCode) | ||
1590 | { | ||
1591 | this.ctor = ctor; | ||
1592 | } | ||
1593 | |||
1594 | public override string DumpString () | ||
1595 | { | ||
1596 | return opCode.ToString () + ' ' + AbbrType (ctor.DeclaringType); | ||
1597 | } | ||
1598 | |||
1599 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1600 | { | ||
1601 | switch (opCode.ToString ()) { | ||
1602 | case "newobj": { | ||
1603 | int nargs = ctor.GetParameters ().Length; | ||
1604 | OTOpnd[] args = new OTOpnd[nargs]; | ||
1605 | for (int i = nargs; -- i >= 0;) { | ||
1606 | args[i] = decompile.opstack.Pop (); | ||
1607 | } | ||
1608 | decompile.opstack.Push (OTOpndNewobj.Make (ctor, args)); | ||
1609 | break; | ||
1610 | } | ||
1611 | default: throw new Exception ("unknown opcode " + opCode.ToString ()); | ||
1612 | } | ||
1613 | } | ||
1614 | } | ||
1615 | |||
1616 | private class OTCilDouble : OTCilNull { | ||
1617 | public double value; | ||
1618 | |||
1619 | public OTCilDouble (int offset, OpCode opCode, double value) : base (offset, opCode) | ||
1620 | { | ||
1621 | this.value = value; | ||
1622 | } | ||
1623 | |||
1624 | public override string DumpString () | ||
1625 | { | ||
1626 | return opCode.ToString () + ' ' + value; | ||
1627 | } | ||
1628 | |||
1629 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1630 | { | ||
1631 | switch (opCode.ToString ()) { | ||
1632 | case "ldc.r8": { | ||
1633 | decompile.opstack.Push (new OTOpndDouble (value)); | ||
1634 | break; | ||
1635 | } | ||
1636 | default: throw new Exception ("unknown opcode " + opCode.ToString ()); | ||
1637 | } | ||
1638 | } | ||
1639 | } | ||
1640 | |||
1641 | private class OTCilFloat : OTCilNull { | ||
1642 | public float value; | ||
1643 | |||
1644 | public OTCilFloat (int offset, OpCode opCode, float value) : base (offset, opCode) | ||
1645 | { | ||
1646 | this.value = value; | ||
1647 | } | ||
1648 | |||
1649 | public override string DumpString () | ||
1650 | { | ||
1651 | return opCode.ToString () + ' ' + value; | ||
1652 | } | ||
1653 | |||
1654 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1655 | { | ||
1656 | switch (opCode.ToString ()) { | ||
1657 | case "ldc.r4": { | ||
1658 | decompile.opstack.Push (new OTOpndFloat (value)); | ||
1659 | break; | ||
1660 | } | ||
1661 | default: throw new Exception ("unknown opcode " + opCode.ToString ()); | ||
1662 | } | ||
1663 | } | ||
1664 | } | ||
1665 | |||
1666 | private class OTCilInteger : OTCilNull { | ||
1667 | public int value; | ||
1668 | |||
1669 | public OTCilInteger (int offset, OpCode opCode, int value) : base (offset, opCode) | ||
1670 | { | ||
1671 | this.value = value; | ||
1672 | } | ||
1673 | |||
1674 | public override string DumpString () | ||
1675 | { | ||
1676 | return opCode.ToString () + ' ' + value; | ||
1677 | } | ||
1678 | |||
1679 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1680 | { | ||
1681 | switch (opCode.ToString ()) { | ||
1682 | case "ldarg": | ||
1683 | case "ldarg.s": { | ||
1684 | decompile.opstack.Push (new OTOpndArg (value, false, decompile)); | ||
1685 | break; | ||
1686 | } | ||
1687 | case "ldarga": | ||
1688 | case "ldarga.s": { | ||
1689 | decompile.opstack.Push (new OTOpndArg (value, true, decompile)); | ||
1690 | break; | ||
1691 | } | ||
1692 | case "ldc.i4": | ||
1693 | case "ldc.i4.s": { | ||
1694 | decompile.opstack.Push (new OTOpndInt (value)); | ||
1695 | break; | ||
1696 | } | ||
1697 | case "starg": { | ||
1698 | OTOpnd val = decompile.opstack.Pop (); | ||
1699 | OTStmtStore.AddLast (decompile, new OTOpndArg (value, false, decompile), val); | ||
1700 | break; | ||
1701 | } | ||
1702 | default: throw new Exception ("unknown opcode " + opCode.ToString ()); | ||
1703 | } | ||
1704 | } | ||
1705 | } | ||
1706 | |||
1707 | private class OTCilString : OTCilNull { | ||
1708 | public string value; | ||
1709 | |||
1710 | public OTCilString (int offset, OpCode opCode, string value) : base (offset, opCode) | ||
1711 | { | ||
1712 | this.value = value; | ||
1713 | } | ||
1714 | |||
1715 | public override string DumpString () | ||
1716 | { | ||
1717 | StringBuilder sb = new StringBuilder (); | ||
1718 | sb.Append (opCode.ToString ()); | ||
1719 | sb.Append (' '); | ||
1720 | TokenDeclInline.PrintParamString (sb, value); | ||
1721 | return sb.ToString (); | ||
1722 | } | ||
1723 | |||
1724 | public override void BuildStatements (OTDecompile decompile, LinkedListNode<OTCilInstr> link) | ||
1725 | { | ||
1726 | switch (opCode.ToString ()) { | ||
1727 | case "ldstr": { | ||
1728 | decompile.opstack.Push (new OTOpndString (value)); | ||
1729 | break; | ||
1730 | } | ||
1731 | default: throw new Exception ("unknown opcode " + opCode.ToString ()); | ||
1732 | } | ||
1733 | } | ||
1734 | } | ||
1735 | |||
1736 | /***************************************\ | ||
1737 | * Tokens what are on operand stack. * | ||
1738 | \***************************************/ | ||
1739 | |||
1740 | public abstract class OTOpnd { | ||
1741 | |||
1742 | /** | ||
1743 | * See if it possibly has any side effects. | ||
1744 | */ | ||
1745 | public abstract bool HasSideEffects { get; } | ||
1746 | |||
1747 | /** | ||
1748 | * Increment reference counts. | ||
1749 | */ | ||
1750 | public virtual void CountRefs (bool writing) | ||
1751 | { } | ||
1752 | |||
1753 | /** | ||
1754 | * If this operand is a 'by reference' operand, | ||
1755 | * return the corresponding 'by value' operand. | ||
1756 | */ | ||
1757 | public virtual OTOpnd GetNonByRefOpnd () | ||
1758 | { | ||
1759 | return this; | ||
1760 | } | ||
1761 | |||
1762 | /** | ||
1763 | * If this operand is same as oldopnd, replace it with newopnd. | ||
1764 | * | ||
1765 | * This default just does a shallow search which is ok if this operand does not have any sub-operands. | ||
1766 | * But it must be overridden for a deep search if this operand has any sub-operands. | ||
1767 | */ | ||
1768 | public virtual OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
1769 | { | ||
1770 | if (SameAs (oldopnd)) { | ||
1771 | rc = true; | ||
1772 | return newopnd; | ||
1773 | } | ||
1774 | return this; | ||
1775 | } | ||
1776 | |||
1777 | /** | ||
1778 | * See if the two operands are the same value. | ||
1779 | * Note that calls might have side-effects so are never the same. | ||
1780 | */ | ||
1781 | public abstract bool SameAs (OTOpnd other); | ||
1782 | |||
1783 | /** | ||
1784 | * Get a printable string representation of the operand. | ||
1785 | */ | ||
1786 | public abstract string PrintableString { get; } | ||
1787 | } | ||
1788 | |||
1789 | /** | ||
1790 | * Argument variable. | ||
1791 | */ | ||
1792 | private class OTOpndArg : OTOpnd { | ||
1793 | public int index; | ||
1794 | public bool byref; | ||
1795 | |||
1796 | private OTDecompile decompile; | ||
1797 | |||
1798 | public OTOpndArg (int index, bool byref, OTDecompile decompile) | ||
1799 | { | ||
1800 | this.index = index; | ||
1801 | this.byref = byref; | ||
1802 | this.decompile = decompile; | ||
1803 | } | ||
1804 | |||
1805 | public override bool HasSideEffects { | ||
1806 | get { | ||
1807 | return false; | ||
1808 | } | ||
1809 | } | ||
1810 | |||
1811 | public override OTOpnd GetNonByRefOpnd () | ||
1812 | { | ||
1813 | if (!byref) return this; | ||
1814 | return new OTOpndArg (index, false, decompile); | ||
1815 | } | ||
1816 | |||
1817 | public override bool SameAs (OTOpnd other) | ||
1818 | { | ||
1819 | if (!(other is OTOpndArg)) return false; | ||
1820 | return (((OTOpndArg) other).byref == byref) && (((OTOpndArg) other).index == index); | ||
1821 | } | ||
1822 | |||
1823 | public override string PrintableString { | ||
1824 | get { | ||
1825 | string argname = decompile.MethArgName (index); | ||
1826 | return byref ? ("ref " + argname) : argname; | ||
1827 | } | ||
1828 | } | ||
1829 | } | ||
1830 | |||
1831 | /** | ||
1832 | * Element of an array. | ||
1833 | */ | ||
1834 | private class OTOpndArrayElem : OTOpnd { | ||
1835 | public bool byref; | ||
1836 | public OTOpnd array; | ||
1837 | public OTOpnd index; | ||
1838 | |||
1839 | public static OTOpnd Make (OTOpnd array, OTOpnd index, bool byref, OTDecompile decompile) | ||
1840 | { | ||
1841 | /* | ||
1842 | * arg$0.glblVars.iar<type>[<intconst>] is a reference to a global variable | ||
1843 | * likewise so is __xmrinst.glblVars.iar<type>[<intconst>] | ||
1844 | */ | ||
1845 | if ((array is OTOpndField) && (index is OTOpndInt)) { | ||
1846 | |||
1847 | /* | ||
1848 | * arrayfield = (arg$0.glblVars).iar<type> | ||
1849 | * arrayfieldobj = arg$0.glblVars | ||
1850 | * iartypename = iar<type> | ||
1851 | */ | ||
1852 | OTOpndField arrayfield = (OTOpndField) array; | ||
1853 | OTOpnd arrayfieldobj = arrayfield.obj; | ||
1854 | string iartypename = arrayfield.field.Name; | ||
1855 | |||
1856 | /* | ||
1857 | * See if they are what they are supposed to be. | ||
1858 | */ | ||
1859 | if ((arrayfieldobj is OTOpndField) && iartypename.StartsWith ("iar")) { | ||
1860 | |||
1861 | /* | ||
1862 | * arrayfieldobjfield = arg$0.glblVars | ||
1863 | */ | ||
1864 | OTOpndField arrayfieldobjfield = (OTOpndField) arrayfieldobj; | ||
1865 | |||
1866 | /* | ||
1867 | * See if the parts are what they are supposed to be. | ||
1868 | */ | ||
1869 | if (IsArg0OrXMRInst (arrayfieldobjfield.obj) && (arrayfieldobjfield.field.Name == "glblVars")) { | ||
1870 | |||
1871 | /* | ||
1872 | * Everything matches up, make a global variable instead of an array reference. | ||
1873 | */ | ||
1874 | return new OTOpndGlobal (iartypename, ((OTOpndInt) index).value, byref, decompile.scriptObjCode); | ||
1875 | } | ||
1876 | } | ||
1877 | } | ||
1878 | |||
1879 | /* | ||
1880 | * Other array reference. | ||
1881 | */ | ||
1882 | OTOpndArrayElem it = new OTOpndArrayElem (); | ||
1883 | it.array = array; | ||
1884 | it.index = index; | ||
1885 | it.byref = byref; | ||
1886 | return it; | ||
1887 | } | ||
1888 | |||
1889 | private OTOpndArrayElem () { } | ||
1890 | |||
1891 | public override bool HasSideEffects { | ||
1892 | get { | ||
1893 | return array.HasSideEffects || index.HasSideEffects; | ||
1894 | } | ||
1895 | } | ||
1896 | |||
1897 | public override void CountRefs (bool writing) | ||
1898 | { | ||
1899 | array.CountRefs (false); | ||
1900 | index.CountRefs (false); | ||
1901 | } | ||
1902 | |||
1903 | public override OTOpnd GetNonByRefOpnd () | ||
1904 | { | ||
1905 | if (!byref) return this; | ||
1906 | OTOpndArrayElem it = new OTOpndArrayElem (); | ||
1907 | it.array = array; | ||
1908 | it.index = index; | ||
1909 | return it; | ||
1910 | } | ||
1911 | |||
1912 | public override OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
1913 | { | ||
1914 | if (SameAs (oldopnd)) { | ||
1915 | rc = true; | ||
1916 | return newopnd; | ||
1917 | } | ||
1918 | array = array.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
1919 | index = index.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
1920 | return this; | ||
1921 | } | ||
1922 | |||
1923 | public override bool SameAs (OTOpnd other) | ||
1924 | { | ||
1925 | if (!(other is OTOpndArrayElem)) return false; | ||
1926 | OTOpndArrayElem otherae = (OTOpndArrayElem) other; | ||
1927 | return array.SameAs (otherae.array) && index.SameAs (otherae.index); | ||
1928 | } | ||
1929 | |||
1930 | public override string PrintableString { | ||
1931 | get { | ||
1932 | return (byref ? "ref " : "") + array.PrintableString + "[" + index.PrintableString + "]"; | ||
1933 | } | ||
1934 | } | ||
1935 | |||
1936 | /** | ||
1937 | * See if the argument is a reference to arg$0 or __xmrinst | ||
1938 | */ | ||
1939 | public static bool IsArg0OrXMRInst (OTOpnd obj) | ||
1940 | { | ||
1941 | if (obj is OTOpndArg) { | ||
1942 | OTOpndArg objarg = (OTOpndArg) obj; | ||
1943 | return objarg.index == 0; | ||
1944 | } | ||
1945 | if (obj is OTOpndLocal) { | ||
1946 | OTOpndLocal objlcl = (OTOpndLocal) obj; | ||
1947 | return objlcl.local.name.StartsWith (_xmrinstlocal); | ||
1948 | } | ||
1949 | return false; | ||
1950 | } | ||
1951 | } | ||
1952 | |||
1953 | /** | ||
1954 | * Binary operator. | ||
1955 | */ | ||
1956 | private class OTOpndBinOp : OTOpnd { | ||
1957 | public OTOpnd left; | ||
1958 | public MyOp opCode; | ||
1959 | public OTOpnd rite; | ||
1960 | |||
1961 | private static Dictionary<string,string> xor1ops = InitXor1Ops (); | ||
1962 | |||
1963 | private static Dictionary<string,string> InitXor1Ops () | ||
1964 | { | ||
1965 | Dictionary<string,string> d = new Dictionary<string,string> (); | ||
1966 | d["ceq"] = "cne"; | ||
1967 | d["cge"] = "clt"; | ||
1968 | d["cgt"] = "cle"; | ||
1969 | d["cle"] = "cgt"; | ||
1970 | d["clt"] = "cge"; | ||
1971 | d["cne"] = "ceq"; | ||
1972 | return d; | ||
1973 | } | ||
1974 | |||
1975 | public static OTOpnd Make (OTOpnd left, MyOp opCode, OTOpnd rite) | ||
1976 | { | ||
1977 | // ((x clt y) xor 1) => (x cge y) etc | ||
1978 | string xor1op; | ||
1979 | if ((left is OTOpndBinOp) && xor1ops.TryGetValue (((OTOpndBinOp) left).opCode.name, out xor1op) && | ||
1980 | (opCode == MyOp.Xor) && | ||
1981 | (rite is OTOpndInt) && (((OTOpndInt) rite).value == 1)) { | ||
1982 | opCode = MyOp.GetByName (xor1op); | ||
1983 | } | ||
1984 | |||
1985 | // handle strcmp() cases (see OTOpndStrCmp) | ||
1986 | if (left is OTOpndStrCmp) { | ||
1987 | OTOpnd strcmp = ((OTOpndStrCmp) left).MakeBinOp (opCode, rite); | ||
1988 | if (strcmp != null) return strcmp; | ||
1989 | } | ||
1990 | |||
1991 | // nothing special, make as is | ||
1992 | OTOpndBinOp it = new OTOpndBinOp (); | ||
1993 | it.left = left; | ||
1994 | it.opCode = opCode; | ||
1995 | it.rite = rite; | ||
1996 | return it; | ||
1997 | } | ||
1998 | |||
1999 | private OTOpndBinOp () { } | ||
2000 | |||
2001 | public override bool HasSideEffects { | ||
2002 | get { | ||
2003 | return left.HasSideEffects || rite.HasSideEffects; | ||
2004 | } | ||
2005 | } | ||
2006 | |||
2007 | public override void CountRefs (bool writing) | ||
2008 | { | ||
2009 | left.CountRefs (false); | ||
2010 | rite.CountRefs (false); | ||
2011 | } | ||
2012 | |||
2013 | public override OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
2014 | { | ||
2015 | if (SameAs (oldopnd)) { | ||
2016 | rc = true; | ||
2017 | return newopnd; | ||
2018 | } | ||
2019 | left = left.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
2020 | rite = rite.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
2021 | return this; | ||
2022 | } | ||
2023 | |||
2024 | public override bool SameAs (OTOpnd other) | ||
2025 | { | ||
2026 | if (!(other is OTOpndBinOp)) return false; | ||
2027 | OTOpndBinOp otherbo = (OTOpndBinOp) other; | ||
2028 | return left.SameAs (otherbo.left) && (opCode.ToString () == otherbo.opCode.ToString ()) && rite.SameAs (otherbo.rite); | ||
2029 | } | ||
2030 | |||
2031 | public override string PrintableString { | ||
2032 | get { | ||
2033 | StringBuilder sb = new StringBuilder (); | ||
2034 | |||
2035 | bool leftneedsparen = ItNeedsParentheses (left, true); | ||
2036 | if (leftneedsparen) sb.Append ('('); | ||
2037 | sb.Append (left.PrintableString); | ||
2038 | if (leftneedsparen) sb.Append (')'); | ||
2039 | |||
2040 | sb.Append (' '); | ||
2041 | sb.Append (opCode.source); | ||
2042 | sb.Append (' '); | ||
2043 | |||
2044 | bool riteneedsparen = ItNeedsParentheses (rite, false); | ||
2045 | if (riteneedsparen) sb.Append ('('); | ||
2046 | sb.Append (rite.PrintableString); | ||
2047 | if (riteneedsparen) sb.Append (')'); | ||
2048 | |||
2049 | return sb.ToString (); | ||
2050 | } | ||
2051 | } | ||
2052 | |||
2053 | /** | ||
2054 | * See if source code representation requires parentheses around the given operand. | ||
2055 | * @param it = the other operand to decide about | ||
2056 | * @param itleft = true: 'it' is on the left of this operand (A $ B) # C | ||
2057 | * false: 'it' is on the right of this operand A $ (B # C) | ||
2058 | */ | ||
2059 | private bool ItNeedsParentheses (OTOpnd it, bool itleft) | ||
2060 | { | ||
2061 | if (!(it is OTOpndBinOp)) return false; | ||
2062 | string itop = ((OTOpndBinOp) it).opCode.source; | ||
2063 | string myop = opCode.source; | ||
2064 | |||
2065 | // find them in table. higher number is for *, lower is for +. | ||
2066 | int itpi, mypi; | ||
2067 | if (!precedence.TryGetValue (itop, out itpi)) return true; | ||
2068 | if (!precedence.TryGetValue (myop, out mypi)) return true; | ||
2069 | int itpiabs = Math.Abs (itpi); | ||
2070 | int mypiabs = Math.Abs (mypi); | ||
2071 | |||
2072 | // if its precedence is lower (eg +) than my precedence (eg *), it needs parentheses | ||
2073 | if (itpiabs < mypiabs) return true; | ||
2074 | |||
2075 | // if its precedence is higher (eg *) than my precedence (eg +), it doesn't needs parentheses | ||
2076 | if (itpiabs > mypiabs) return false; | ||
2077 | |||
2078 | // if (A $ B) # C, we can safely go without the parentheses | ||
2079 | if (itleft) return false; | ||
2080 | |||
2081 | // my it | ||
2082 | // A $ (B # C) only works without parentheses for commutative $ | ||
2083 | // A - (B + C) and A - (B - C) require parentheses | ||
2084 | // A + (B - C) does not | ||
2085 | return mypi < 0; // neg: things like -, /, etc require parentheses | ||
2086 | // pos: things like +, *, etc do not need parens | ||
2087 | } | ||
2088 | |||
2089 | // see MMRScriptReduce.PrecedenceInit() | ||
2090 | private static Dictionary<string,int> precedence = InitPrecedence (); | ||
2091 | private static Dictionary<string,int> InitPrecedence () | ||
2092 | { | ||
2093 | Dictionary<string,int> d = new Dictionary<string,int> (); | ||
2094 | d["|"] = 140; | ||
2095 | d["^"] = 160; | ||
2096 | d["&"] = 180; | ||
2097 | d["<<"] = -260; | ||
2098 | d[">>"] = -260; | ||
2099 | d["+"] = 280; | ||
2100 | d["-"] = -280; | ||
2101 | d["*"] = 320; | ||
2102 | d["/"] = -320; | ||
2103 | d["%"] = -320; | ||
2104 | return d; | ||
2105 | } | ||
2106 | } | ||
2107 | |||
2108 | /** | ||
2109 | * Call with or without return value. | ||
2110 | */ | ||
2111 | private class OTOpndCall : OTOpnd { | ||
2112 | private static Dictionary<string,MethodInfo> mathmeths = InitMathMeths (); | ||
2113 | private static Dictionary<string,MethodInfo> InitMathMeths () | ||
2114 | { | ||
2115 | Dictionary<string,MethodInfo> d = new Dictionary<string,MethodInfo> (); | ||
2116 | d["Acos"] = typeof (ScriptBaseClass).GetMethod ("llAcos"); | ||
2117 | d["Asin"] = typeof (ScriptBaseClass).GetMethod ("llAsin"); | ||
2118 | d["Atan"] = typeof (ScriptBaseClass).GetMethod ("llAtan"); | ||
2119 | d["Cos"] = typeof (ScriptBaseClass).GetMethod ("llCos"); | ||
2120 | d["Abs"] = typeof (ScriptBaseClass).GetMethod ("llFabs"); | ||
2121 | d["Log"] = typeof (ScriptBaseClass).GetMethod ("llLog"); | ||
2122 | d["Log10"] = typeof (ScriptBaseClass).GetMethod ("llLog10"); | ||
2123 | d["Round"] = typeof (ScriptBaseClass).GetMethod ("llRound"); | ||
2124 | d["Sin"] = typeof (ScriptBaseClass).GetMethod ("llSin"); | ||
2125 | d["Sqrt"] = typeof (ScriptBaseClass).GetMethod ("llSqrt"); | ||
2126 | d["Tan"] = typeof (ScriptBaseClass).GetMethod ("llTan"); | ||
2127 | return d; | ||
2128 | } | ||
2129 | |||
2130 | public MethodInfo method; | ||
2131 | public OTOpnd[] args; | ||
2132 | |||
2133 | // pushes on stack for return-value functions | ||
2134 | // pushes to end of instruction stream for return-void functions | ||
2135 | public static void AddLast (OTDecompile decompile, MethodInfo method, OTOpnd[] args) | ||
2136 | { | ||
2137 | int nargs = args.Length; | ||
2138 | |||
2139 | // heap tracker push is just the single arg value as far as we're concerned | ||
2140 | if ((nargs == 1) && (method.Name == _heapTrackerPush) && method.DeclaringType.Name.StartsWith ("HeapTracker")) { | ||
2141 | decompile.opstack.Push (args[0]); | ||
2142 | return; | ||
2143 | } | ||
2144 | |||
2145 | // heap tracker pop is just a store as far as we're concerned | ||
2146 | if ((nargs == 2) && (method.Name == _heapTrackerPop) && method.DeclaringType.Name.StartsWith ("HeapTracker")) { | ||
2147 | OTStmtStore.AddLast (decompile, args[0], args[1]); | ||
2148 | return; | ||
2149 | } | ||
2150 | |||
2151 | // string.Compare() is its own thing cuz it has to decompile many ways | ||
2152 | if ((nargs == 2) && (method.DeclaringType == typeof (string)) && (method.Name == "Compare")) { | ||
2153 | decompile.opstack.Push (new OTOpndStrCmp (args[0], args[1])); | ||
2154 | return; | ||
2155 | } | ||
2156 | |||
2157 | // ObjectToString, etc, should appear as casts | ||
2158 | if ((nargs == 1) && (method.DeclaringType == typeof (TypeCast)) && method.Name.EndsWith ("ToBool")) { | ||
2159 | MethodInfo meth = typeof (XMRInstAbstract).GetMethod ("xmr" + method.Name); | ||
2160 | AddLast (decompile, meth, new OTOpnd[] { new OTOpndNull (), args[0] }); | ||
2161 | return; | ||
2162 | } | ||
2163 | if ((nargs == 1) && (method.DeclaringType == typeof (TypeCast)) && method.Name.EndsWith ("ToFloat")) { | ||
2164 | decompile.opstack.Push (new OTOpndCast (typeof (double), args[0])); | ||
2165 | return; | ||
2166 | } | ||
2167 | if ((nargs == 1) && (method.DeclaringType == typeof (TypeCast)) && method.Name.EndsWith ("ToInteger")) { | ||
2168 | decompile.opstack.Push (new OTOpndCast (typeof (int), args[0])); | ||
2169 | return; | ||
2170 | } | ||
2171 | if ((nargs == 1) && (method.DeclaringType == typeof (TypeCast)) && method.Name.EndsWith ("ToList")) { | ||
2172 | decompile.opstack.Push (new OTOpndCast (typeof (LSL_List), args[0])); | ||
2173 | return; | ||
2174 | } | ||
2175 | if ((nargs == 1) && (method.DeclaringType == typeof (TypeCast)) && method.Name.EndsWith ("ToRotation")) { | ||
2176 | decompile.opstack.Push (new OTOpndCast (typeof (LSL_Rotation), args[0])); | ||
2177 | return; | ||
2178 | } | ||
2179 | if ((nargs == 1) && (method.DeclaringType == typeof (TypeCast)) && method.Name.EndsWith ("ToString")) { | ||
2180 | decompile.opstack.Push (new OTOpndCast (typeof (string), args[0])); | ||
2181 | return; | ||
2182 | } | ||
2183 | if ((nargs == 1) && (method.DeclaringType == typeof (TypeCast)) && method.Name.EndsWith ("ToVector")) { | ||
2184 | decompile.opstack.Push (new OTOpndCast (typeof (LSL_Vector), args[0])); | ||
2185 | return; | ||
2186 | } | ||
2187 | |||
2188 | if ((method.DeclaringType == typeof (XMRInstAbstract)) && (method.Name == "xmrHeapLeft")) { | ||
2189 | AddLast (decompile, typeof (ScriptBaseClass).GetMethod ("llGetFreeMemory"), new OTOpnd[] { new OTOpndNull () }); | ||
2190 | return; | ||
2191 | } | ||
2192 | |||
2193 | // pop to entry in the list/object/string array | ||
2194 | if (PopToGlobalArray (decompile, method, args)) return; | ||
2195 | |||
2196 | // strip off event handler argument unwrapper calls | ||
2197 | if ((nargs == 1) && (method.DeclaringType == typeof (TypeCast)) && method.Name.StartsWith ("EHArgUnwrap")) { | ||
2198 | decompile.opstack.Push (args[0]); | ||
2199 | return; | ||
2200 | } | ||
2201 | |||
2202 | // translate Math method to ll method | ||
2203 | MethodInfo mathmeth; | ||
2204 | if ((method.DeclaringType == typeof (Math)) && mathmeths.TryGetValue (method.Name, out mathmeth)) { | ||
2205 | AddLast (decompile, mathmeth, new OTOpnd[] { new OTOpndNull (), args[0] }); | ||
2206 | return; | ||
2207 | } | ||
2208 | if ((method.DeclaringType == typeof (Math)) && (method.Name == "Atan2")) { | ||
2209 | AddLast (decompile, typeof (ScriptBaseClass).GetMethod ("llAtan2"), new OTOpnd[] { new OTOpndNull (), args[0], args[1] }); | ||
2210 | return; | ||
2211 | } | ||
2212 | if ((method.DeclaringType == typeof (Math)) && (method.Name == "Pow")) { | ||
2213 | AddLast (decompile, typeof (ScriptBaseClass).GetMethod ("llPow"), new OTOpnd[] { new OTOpndNull (), args[0], args[1] }); | ||
2214 | return; | ||
2215 | } | ||
2216 | |||
2217 | // string concat should be a bunch of adds | ||
2218 | if ((method.Name == "Concat") && (method.DeclaringType == typeof (string))) { | ||
2219 | int k = args.Length; | ||
2220 | while (k > 1) { | ||
2221 | int j = 0; | ||
2222 | int i; | ||
2223 | for (i = 0; i + 2 <= k; i += 2) { | ||
2224 | args[j++] = OTOpndBinOp.Make (args[i+0], MyOp.Add, args[i+1]); | ||
2225 | } | ||
2226 | while (i < k) args[j++] = args[i++]; | ||
2227 | k = j; | ||
2228 | } | ||
2229 | if (k > 0) decompile.opstack.Push (args[0]); | ||
2230 | return; | ||
2231 | } | ||
2232 | |||
2233 | // bunch of calls for rotation and vector arithmetic | ||
2234 | if ((method.DeclaringType == typeof (BinOpStr)) && BinOpStrCall (decompile, method, args)) return; | ||
2235 | if ((method.DeclaringType == typeof (ScriptCodeGen)) && (method.Name == "LSLRotationNegate")) { | ||
2236 | decompile.opstack.Push (OTOpndUnOp.Make (MyOp.Neg, args[0])); | ||
2237 | return; | ||
2238 | } | ||
2239 | if ((method.DeclaringType == typeof (ScriptCodeGen)) && (method.Name == "LSLVectorNegate")) { | ||
2240 | decompile.opstack.Push (OTOpndUnOp.Make (MyOp.Neg, args[0])); | ||
2241 | return; | ||
2242 | } | ||
2243 | |||
2244 | // otherwise process it as a call | ||
2245 | OTOpndCall call = new OTOpndCall (); | ||
2246 | call.method = method; | ||
2247 | call.args = args; | ||
2248 | if (method.ReturnType == typeof (void)) { | ||
2249 | OTStmtVoid.AddLast (decompile, call); | ||
2250 | } else { | ||
2251 | decompile.opstack.Push (call); | ||
2252 | } | ||
2253 | } | ||
2254 | |||
2255 | public override bool HasSideEffects { | ||
2256 | get { | ||
2257 | return true; | ||
2258 | } | ||
2259 | } | ||
2260 | |||
2261 | /** | ||
2262 | * Handle a call to XMRInstArrays.Pop<List,Object,String> | ||
2263 | * by converting it to a store directly into the array. | ||
2264 | */ | ||
2265 | private static bool PopToGlobalArray (OTDecompile decompile, MethodInfo method, OTOpnd[] args) | ||
2266 | { | ||
2267 | if (method.DeclaringType != typeof (XMRInstArrays)) return false; | ||
2268 | if (args.Length != 3) return false; | ||
2269 | |||
2270 | string array = null; | ||
2271 | if (method.Name == "PopList") array = "iarLists"; | ||
2272 | if (method.Name == "PopObject") array = "iarObjects"; | ||
2273 | if (method.Name == "PopString") array = "iarStrings"; | ||
2274 | if (array == null) return false; | ||
2275 | |||
2276 | // make token that points to the iar<whatever> array | ||
2277 | FieldInfo field = typeof (XMRInstArrays).GetField (array); | ||
2278 | OTOpnd arrayfield = OTOpndField.Make (args[0], field); | ||
2279 | |||
2280 | // make token that points to the element to be popped to | ||
2281 | OTOpnd element = OTOpndArrayElem.Make (arrayfield, args[1], false, decompile); | ||
2282 | |||
2283 | // make a statement to store value in that element | ||
2284 | OTStmtStore.AddLast (decompile, element, args[2]); | ||
2285 | |||
2286 | return true; | ||
2287 | } | ||
2288 | |||
2289 | /** | ||
2290 | * BinOpStr has a bunch of calls to do funky arithmetic. | ||
2291 | * Instead of generating a call, put back the original source. | ||
2292 | */ | ||
2293 | private static bool BinOpStrCall (OTDecompile decompile, MethodInfo method, OTOpnd[] args) | ||
2294 | { | ||
2295 | switch (method.Name) { | ||
2296 | case "MethFloatAddList": | ||
2297 | case "MethIntAddList": | ||
2298 | case "MethKeyAddList": | ||
2299 | case "MethListAddFloat": | ||
2300 | case "MethListAddInt": | ||
2301 | case "MethListAddKey": | ||
2302 | case "MethListAddList": | ||
2303 | case "MethListAddObj": | ||
2304 | case "MethListAddRot": | ||
2305 | case "MethListAddStr": | ||
2306 | case "MethListAddVec": | ||
2307 | case "MethObjAddList": | ||
2308 | case "MethRotAddList": | ||
2309 | case "MethRotAddRot": | ||
2310 | case "MethStrAddList": | ||
2311 | case "MethVecAddList": | ||
2312 | case "MethVecAddVec": { | ||
2313 | decompile.opstack.Push (OTOpndBinOp.Make (args[0], MyOp.Add, args[1])); | ||
2314 | return true; | ||
2315 | } | ||
2316 | |||
2317 | case "MethListEqList": | ||
2318 | case "MethRotEqRot": | ||
2319 | case "MethVecEqVec": { | ||
2320 | decompile.opstack.Push (OTOpndBinOp.Make (args[0], MyOp.Ceq, args[1])); | ||
2321 | return true; | ||
2322 | } | ||
2323 | |||
2324 | case "MethListNeList": | ||
2325 | case "MethRotNeRot": | ||
2326 | case "MethVecNeVec": { | ||
2327 | decompile.opstack.Push (OTOpndBinOp.Make (args[0], MyOp.Cne, args[1])); | ||
2328 | return true; | ||
2329 | } | ||
2330 | |||
2331 | case "MethRotSubRot": | ||
2332 | case "MethVecSubVec": { | ||
2333 | decompile.opstack.Push (OTOpndBinOp.Make (args[0], MyOp.Sub, args[1])); | ||
2334 | return true; | ||
2335 | } | ||
2336 | |||
2337 | case "MethFloatMulVec": | ||
2338 | case "MethIntMulVec": | ||
2339 | case "MethRotMulRot": | ||
2340 | case "MethVecMulFloat": | ||
2341 | case "MethVecMulInt": | ||
2342 | case "MethVecMulRot": | ||
2343 | case "MethVecMulVec": { | ||
2344 | decompile.opstack.Push (OTOpndBinOp.Make (args[0], MyOp.Mul, args[1])); | ||
2345 | return true; | ||
2346 | } | ||
2347 | |||
2348 | case "MethRotDivRot": | ||
2349 | case "MethVecDivFloat": | ||
2350 | case "MethVecDivInt": | ||
2351 | case "MethVecDivRot": { | ||
2352 | decompile.opstack.Push (OTOpndBinOp.Make (args[0], MyOp.Div, args[1])); | ||
2353 | return true; | ||
2354 | } | ||
2355 | |||
2356 | default: return false; | ||
2357 | } | ||
2358 | } | ||
2359 | |||
2360 | private OTOpndCall () { } | ||
2361 | |||
2362 | public override void CountRefs (bool writing) | ||
2363 | { | ||
2364 | foreach (OTOpnd arg in args) { | ||
2365 | arg.CountRefs (false); | ||
2366 | } | ||
2367 | } | ||
2368 | |||
2369 | public override OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
2370 | { | ||
2371 | for (int i = 0; i < args.Length; i ++) { | ||
2372 | args[i] = args[i].ReplaceOperand (oldopnd, newopnd, ref rc); | ||
2373 | } | ||
2374 | return this; | ||
2375 | } | ||
2376 | |||
2377 | public override bool SameAs (OTOpnd other) | ||
2378 | { | ||
2379 | return false; | ||
2380 | } | ||
2381 | |||
2382 | public override string PrintableString { | ||
2383 | get { | ||
2384 | StringBuilder sb = new StringBuilder (); | ||
2385 | |||
2386 | // GetByKey(a,i) => a[i] | ||
2387 | if ((method.DeclaringType == typeof (XMR_Array)) && (method.Name == "GetByKey") && (args.Length == 2)) { | ||
2388 | sb.Append (args[0].PrintableString); | ||
2389 | sb.Append ('['); | ||
2390 | sb.Append (args[1].PrintableString); | ||
2391 | sb.Append (']'); | ||
2392 | return sb.ToString (); | ||
2393 | } | ||
2394 | |||
2395 | // SetByKey(a,i,v) => a[i] = v | ||
2396 | if ((method.DeclaringType == typeof (XMR_Array)) && (method.Name == "SetByKey") && (args.Length == 3)) { | ||
2397 | sb.Append (args[0].PrintableString); | ||
2398 | sb.Append ('['); | ||
2399 | sb.Append (args[1].PrintableString); | ||
2400 | sb.Append ("] = "); | ||
2401 | sb.Append (args[2].PrintableString); | ||
2402 | return sb.ToString (); | ||
2403 | } | ||
2404 | |||
2405 | // CompValuListEl.GetElementFromList accesses list elements like an array. | ||
2406 | if ((method.DeclaringType == typeof (CompValuListEl)) && (method.Name == "GetElementFromList")) { | ||
2407 | sb.Append (args[0].PrintableString); | ||
2408 | sb.Append ('['); | ||
2409 | sb.Append (args[1].PrintableString); | ||
2410 | sb.Append (']'); | ||
2411 | return sb.ToString (); | ||
2412 | } | ||
2413 | |||
2414 | // methods that are part of ScriptBaseClass are LSL functions such as llSay() | ||
2415 | // so we want to skip outputting "arg$0," as it is the hidden "this" argument. | ||
2416 | // and there are also XMRInstAbstract functions such as xmrEventDequeue(). | ||
2417 | int starti = 0; | ||
2418 | if ((method.DeclaringType == typeof (ScriptBaseClass)) && !method.IsStatic) starti = 1; | ||
2419 | if ((method.DeclaringType == typeof (XMRInstAbstract)) && !method.IsStatic) starti = 1; | ||
2420 | |||
2421 | // likewise, method that have null as the declaring type are script-defined | ||
2422 | // dynamic methods which have a hidden "this" argument passed as "arg$0". | ||
2423 | if (method.DeclaringType == null) starti = 1; | ||
2424 | |||
2425 | // all others we want to show the type name (such as Math.Abs, String.Compare, etc) | ||
2426 | if (starti == 0) { | ||
2427 | sb.Append (AbbrType (method.DeclaringType)); | ||
2428 | sb.Append ('.'); | ||
2429 | } | ||
2430 | |||
2431 | // script-defined functions have the param types as part of their name | ||
2432 | // so strip them off here so they don't clutter things up | ||
2433 | int i = method.Name.IndexOf ('('); | ||
2434 | if (i < 0) sb.Append (method.Name); | ||
2435 | else sb.Append (method.Name.Substring (0, i)); | ||
2436 | |||
2437 | // now add the call arguments | ||
2438 | sb.Append (" ("); | ||
2439 | bool first = true; | ||
2440 | foreach (OTOpnd arg in args) { | ||
2441 | if (-- starti < 0) { | ||
2442 | if (!first) sb.Append (", "); | ||
2443 | sb.Append (arg.PrintableString); | ||
2444 | first = false; | ||
2445 | } | ||
2446 | } | ||
2447 | sb.Append (')'); | ||
2448 | return sb.ToString (); | ||
2449 | } | ||
2450 | } | ||
2451 | } | ||
2452 | |||
2453 | /** | ||
2454 | * Cast value to the given type. | ||
2455 | */ | ||
2456 | private class OTOpndCast : OTOpnd { | ||
2457 | public Type type; | ||
2458 | public OTOpnd value; | ||
2459 | |||
2460 | public OTOpndCast (Type type, OTOpnd value) | ||
2461 | { | ||
2462 | this.type = type; | ||
2463 | this.value = value; | ||
2464 | } | ||
2465 | |||
2466 | public override bool HasSideEffects { | ||
2467 | get { | ||
2468 | return value.HasSideEffects; | ||
2469 | } | ||
2470 | } | ||
2471 | |||
2472 | public override void CountRefs (bool writing) | ||
2473 | { | ||
2474 | value.CountRefs (false); | ||
2475 | } | ||
2476 | |||
2477 | public override OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
2478 | { | ||
2479 | if (SameAs (oldopnd)) { | ||
2480 | rc = true; | ||
2481 | return newopnd; | ||
2482 | } | ||
2483 | value = value.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
2484 | return this; | ||
2485 | } | ||
2486 | |||
2487 | public override bool SameAs (OTOpnd other) | ||
2488 | { | ||
2489 | if (!(other is OTOpndCast)) return false; | ||
2490 | OTOpndCast othercast = (OTOpndCast) other; | ||
2491 | return (type == othercast.type) && value.SameAs (othercast.value); | ||
2492 | } | ||
2493 | |||
2494 | public override string PrintableString { | ||
2495 | get { | ||
2496 | StringBuilder sb = new StringBuilder (); | ||
2497 | sb.Append ('('); | ||
2498 | sb.Append (AbbrType (type)); | ||
2499 | sb.Append (") "); | ||
2500 | if (value is OTOpndBinOp) sb.Append ('('); | ||
2501 | sb.Append (value.PrintableString); | ||
2502 | if (value is OTOpndBinOp) sb.Append (')'); | ||
2503 | return sb.ToString (); | ||
2504 | } | ||
2505 | } | ||
2506 | } | ||
2507 | |||
2508 | /** | ||
2509 | * Duplicate stack value without re-performing computation. | ||
2510 | * Semantics just like local var except it doesn't have a declaration. | ||
2511 | */ | ||
2512 | private class OTOpndDup : OTOpnd { | ||
2513 | public int index; | ||
2514 | public int ndupreads; | ||
2515 | |||
2516 | public OTOpndDup (int index) | ||
2517 | { | ||
2518 | this.index = index; | ||
2519 | } | ||
2520 | |||
2521 | public override bool HasSideEffects { | ||
2522 | get { | ||
2523 | return false; | ||
2524 | } | ||
2525 | } | ||
2526 | |||
2527 | public override void CountRefs (bool writing) | ||
2528 | { | ||
2529 | if (!writing) ndupreads ++; | ||
2530 | } | ||
2531 | |||
2532 | public override bool SameAs (OTOpnd other) | ||
2533 | { | ||
2534 | if (!(other is OTOpndDup)) return false; | ||
2535 | return ((OTOpndDup) other).index == index; | ||
2536 | } | ||
2537 | |||
2538 | public override string PrintableString { get { return "dup$" + index; } } | ||
2539 | } | ||
2540 | |||
2541 | /** | ||
2542 | * Field of an object. | ||
2543 | */ | ||
2544 | private class OTOpndField : OTOpnd { | ||
2545 | public OTOpnd obj; | ||
2546 | public FieldInfo field; | ||
2547 | |||
2548 | public static OTOpnd Make (OTOpnd obj, FieldInfo field) | ||
2549 | { | ||
2550 | // LSL_Float.value => the object itself | ||
2551 | if ((field.DeclaringType == typeof (LSL_Float)) && (field.Name == "value")) { | ||
2552 | return obj; | ||
2553 | } | ||
2554 | |||
2555 | // LSL_Integer.value => the object itself | ||
2556 | if ((field.DeclaringType == typeof (LSL_Integer)) && (field.Name == "value")) { | ||
2557 | return obj; | ||
2558 | } | ||
2559 | |||
2560 | // LSL_String.m_string => the object itself | ||
2561 | if ((field.DeclaringType == typeof (LSL_String)) && (field.Name == "m_string")) { | ||
2562 | return obj; | ||
2563 | } | ||
2564 | |||
2565 | // some other field, output code to access it | ||
2566 | // sometimes the object comes as by reference (value types), so we might need to deref it first | ||
2567 | OTOpndField it = new OTOpndField (); | ||
2568 | it.obj = obj.GetNonByRefOpnd (); | ||
2569 | it.field = field; | ||
2570 | return it; | ||
2571 | } | ||
2572 | |||
2573 | private OTOpndField () { } | ||
2574 | |||
2575 | public override bool HasSideEffects { | ||
2576 | get { | ||
2577 | return obj.HasSideEffects; | ||
2578 | } | ||
2579 | } | ||
2580 | |||
2581 | public override void CountRefs (bool writing) | ||
2582 | { | ||
2583 | // the field may be getting written to, but the object is being read | ||
2584 | obj.CountRefs (false); | ||
2585 | } | ||
2586 | |||
2587 | public override OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
2588 | { | ||
2589 | if (SameAs (oldopnd)) { | ||
2590 | rc = true; | ||
2591 | return newopnd; | ||
2592 | } | ||
2593 | obj = obj.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
2594 | return this; | ||
2595 | } | ||
2596 | |||
2597 | public override bool SameAs (OTOpnd other) | ||
2598 | { | ||
2599 | if (!(other is OTOpndField)) return false; | ||
2600 | OTOpndField otherfield = (OTOpndField) other; | ||
2601 | return (field.Name == otherfield.field.Name) && obj.SameAs (otherfield.obj); | ||
2602 | } | ||
2603 | |||
2604 | public override string PrintableString { | ||
2605 | get { | ||
2606 | StringBuilder sb = new StringBuilder (); | ||
2607 | if (obj is OTOpndBinOp) sb.Append ('('); | ||
2608 | sb.Append (obj.PrintableString); | ||
2609 | if (obj is OTOpndBinOp) sb.Append (')'); | ||
2610 | sb.Append ('.'); | ||
2611 | sb.Append (field.Name); | ||
2612 | return sb.ToString (); | ||
2613 | } | ||
2614 | } | ||
2615 | } | ||
2616 | |||
2617 | /** | ||
2618 | * Script-level global variable. | ||
2619 | */ | ||
2620 | private class OTOpndGlobal : OTOpnd { | ||
2621 | public string iartypename; | ||
2622 | public int iararrayidx; | ||
2623 | public bool byref; | ||
2624 | public ScriptObjCode scriptObjCode; | ||
2625 | |||
2626 | public OTOpndGlobal (string iartypename, int iararrayidx, bool byref, ScriptObjCode scriptObjCode) | ||
2627 | { | ||
2628 | this.iartypename = iartypename; | ||
2629 | this.iararrayidx = iararrayidx; | ||
2630 | this.byref = byref; | ||
2631 | this.scriptObjCode = scriptObjCode; | ||
2632 | } | ||
2633 | |||
2634 | public override bool HasSideEffects { | ||
2635 | get { | ||
2636 | return false; | ||
2637 | } | ||
2638 | } | ||
2639 | |||
2640 | public override OTOpnd GetNonByRefOpnd () | ||
2641 | { | ||
2642 | if (!byref) return this; | ||
2643 | return new OTOpndGlobal (iartypename, iararrayidx, false, scriptObjCode); | ||
2644 | } | ||
2645 | |||
2646 | public override bool SameAs (OTOpnd other) | ||
2647 | { | ||
2648 | if (!(other is OTOpndGlobal)) return false; | ||
2649 | OTOpndGlobal otherglobal = (OTOpndGlobal) other; | ||
2650 | return (iartypename == otherglobal.iartypename) && (iararrayidx == otherglobal.iararrayidx); | ||
2651 | } | ||
2652 | |||
2653 | public override string PrintableString { | ||
2654 | get { | ||
2655 | return (byref ? "ref " : "") + scriptObjCode.globalVarNames[iartypename][iararrayidx]; | ||
2656 | } | ||
2657 | } | ||
2658 | } | ||
2659 | |||
2660 | /** | ||
2661 | * List initialization. | ||
2662 | */ | ||
2663 | private class OTOpndListIni : OTOpnd { | ||
2664 | public OTOpnd[] values; | ||
2665 | |||
2666 | /** | ||
2667 | * Try to detect list initialization building idiom: | ||
2668 | * dup$<n> = newarr object[<m>] << link points here | ||
2669 | * dup$<n>[0] = bla | ||
2670 | * dup$<n>[1] = bla | ||
2671 | * ... | ||
2672 | * ... newobj list (dup$<n>) ... | ||
2673 | */ | ||
2674 | public static bool Detect (LinkedListNode<OTStmt> link) | ||
2675 | { | ||
2676 | if (link == null) return false; | ||
2677 | |||
2678 | /* | ||
2679 | * Check for 'dup$<n> = newarr object[<m>]' and get listsize from <m>. | ||
2680 | */ | ||
2681 | OTStmtStore store = (OTStmtStore) link.Value; | ||
2682 | if (!(store.varwr is OTOpndDup)) return false; | ||
2683 | if (!(store.value is OTOpndNewarr)) return false; | ||
2684 | OTOpndDup storevar = (OTOpndDup) store.varwr; | ||
2685 | OTOpndNewarr storeval = (OTOpndNewarr) store.value; | ||
2686 | if (storeval.type != typeof (object)) return false; | ||
2687 | if (!(storeval.index is OTOpndInt)) return false; | ||
2688 | int listsize = ((OTOpndInt) storeval.index).value; | ||
2689 | |||
2690 | /* | ||
2691 | * Good chance of having list initializer, malloc an object to hold it. | ||
2692 | */ | ||
2693 | OTOpndListIni it = new OTOpndListIni (); | ||
2694 | it.values = new OTOpnd[listsize]; | ||
2695 | |||
2696 | /* | ||
2697 | * There should be exactly listsize statements following that of the form: | ||
2698 | * dup$<n>[<i>] = bla | ||
2699 | * If so, save the bla values in the values[] array. | ||
2700 | */ | ||
2701 | LinkedListNode<OTStmt> vallink = link; | ||
2702 | for (int i = 0; i < listsize; i ++) { | ||
2703 | vallink = vallink.Next; | ||
2704 | if (vallink == null) return false; | ||
2705 | if (!(vallink.Value is OTStmtStore)) return false; | ||
2706 | OTStmtStore valstore = (OTStmtStore) vallink.Value; | ||
2707 | if (!(valstore.varwr is OTOpndArrayElem)) return false; | ||
2708 | OTOpndArrayElem varelem = (OTOpndArrayElem) valstore.varwr; | ||
2709 | if (varelem.array != storevar) return false; | ||
2710 | if (!(varelem.index is OTOpndInt)) return false; | ||
2711 | if (((OTOpndInt) varelem.index).value != i) return false; | ||
2712 | it.values[i] = valstore.value; | ||
2713 | } | ||
2714 | |||
2715 | /* | ||
2716 | * The next statement should have a 'newobj list (dup$<n>)' in it somewhere | ||
2717 | * that we want to replace with 'it'. | ||
2718 | */ | ||
2719 | ConstructorInfo protoctor = typeof (LSL_List).GetConstructor (new Type[] { typeof (object[]) }); | ||
2720 | OTOpnd[] protoargs = new OTOpnd[] { storevar }; | ||
2721 | OTOpnd proto = OTOpndNewobj.Make (protoctor, protoargs); | ||
2722 | |||
2723 | vallink = vallink.Next; | ||
2724 | bool rc = vallink.Value.ReplaceOperand (proto, it); | ||
2725 | |||
2726 | /* | ||
2727 | * If successful, delete 'dup$n =' and all 'dup$n[i] =' statements. | ||
2728 | */ | ||
2729 | if (rc) { | ||
2730 | do { | ||
2731 | LinkedListNode<OTStmt> nextlink = link.Next; | ||
2732 | link.List.Remove (link); | ||
2733 | link = nextlink; | ||
2734 | } while (link != vallink); | ||
2735 | } | ||
2736 | |||
2737 | return rc; | ||
2738 | } | ||
2739 | |||
2740 | public override bool HasSideEffects { | ||
2741 | get { | ||
2742 | foreach (OTOpnd value in values) { | ||
2743 | if (value.HasSideEffects) return true; | ||
2744 | } | ||
2745 | return false; | ||
2746 | } | ||
2747 | } | ||
2748 | |||
2749 | public override void CountRefs (bool writing) | ||
2750 | { | ||
2751 | foreach (OTOpnd value in values) { | ||
2752 | value.CountRefs (false); | ||
2753 | } | ||
2754 | } | ||
2755 | |||
2756 | public override OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
2757 | { | ||
2758 | if (SameAs (oldopnd)) { | ||
2759 | rc = true; | ||
2760 | return newopnd; | ||
2761 | } | ||
2762 | for (int i = 0; i < values.Length; i ++) { | ||
2763 | values[i] = values[i].ReplaceOperand (oldopnd, newopnd, ref rc); | ||
2764 | } | ||
2765 | return this; | ||
2766 | } | ||
2767 | |||
2768 | public override bool SameAs (OTOpnd other) | ||
2769 | { | ||
2770 | if (!(other is OTOpndListIni)) return false; | ||
2771 | OTOpndListIni otherli = (OTOpndListIni) other; | ||
2772 | if (otherli.values.Length != values.Length) return false; | ||
2773 | for (int i = 0; i < values.Length; i ++) { | ||
2774 | if (!values[i].SameAs (otherli.values[i])) return false; | ||
2775 | } | ||
2776 | return true; | ||
2777 | } | ||
2778 | |||
2779 | public override string PrintableString { | ||
2780 | get { | ||
2781 | StringBuilder sb = new StringBuilder (); | ||
2782 | sb.Append ('['); | ||
2783 | for (int i = 0; i < values.Length; i ++) { | ||
2784 | if (i > 0) sb.Append (','); | ||
2785 | sb.Append (' '); | ||
2786 | sb.Append (values[i].PrintableString); | ||
2787 | } | ||
2788 | sb.Append (" ]"); | ||
2789 | return sb.ToString (); | ||
2790 | } | ||
2791 | } | ||
2792 | } | ||
2793 | |||
2794 | /** | ||
2795 | * Local variable. | ||
2796 | */ | ||
2797 | private class OTOpndLocal : OTOpnd { | ||
2798 | public OTLocal local; | ||
2799 | |||
2800 | public OTOpndLocal (OTLocal local) | ||
2801 | { | ||
2802 | this.local = local; | ||
2803 | } | ||
2804 | |||
2805 | public override bool HasSideEffects { | ||
2806 | get { | ||
2807 | return false; | ||
2808 | } | ||
2809 | } | ||
2810 | |||
2811 | public override void CountRefs (bool writing) | ||
2812 | { | ||
2813 | if (writing) local.nlclwrites ++; | ||
2814 | else local.nlclreads ++; | ||
2815 | } | ||
2816 | |||
2817 | public override bool SameAs (OTOpnd other) | ||
2818 | { | ||
2819 | if (!(other is OTOpndLocal)) return false; | ||
2820 | OTOpndLocal otherlocal = (OTOpndLocal) other; | ||
2821 | return local == otherlocal.local; | ||
2822 | } | ||
2823 | |||
2824 | public override string PrintableString { | ||
2825 | get { | ||
2826 | return local.name; | ||
2827 | } | ||
2828 | } | ||
2829 | } | ||
2830 | private class OTOpndLocalRef : OTOpnd { | ||
2831 | public OTLocal local; | ||
2832 | |||
2833 | public OTOpndLocalRef (OTLocal local) | ||
2834 | { | ||
2835 | this.local = local; | ||
2836 | } | ||
2837 | |||
2838 | public override bool HasSideEffects { | ||
2839 | get { | ||
2840 | return true; | ||
2841 | } | ||
2842 | } | ||
2843 | |||
2844 | public override void CountRefs (bool writing) | ||
2845 | { | ||
2846 | local.nlclreads ++; | ||
2847 | local.nlclwrites ++; | ||
2848 | } | ||
2849 | |||
2850 | public override OTOpnd GetNonByRefOpnd () | ||
2851 | { | ||
2852 | return new OTOpndLocal (local); | ||
2853 | } | ||
2854 | |||
2855 | public override bool SameAs (OTOpnd other) | ||
2856 | { | ||
2857 | if (!(other is OTOpndLocal)) return false; | ||
2858 | OTOpndLocal otherlocal = (OTOpndLocal) other; | ||
2859 | return local == otherlocal.local; | ||
2860 | } | ||
2861 | |||
2862 | public override string PrintableString { get { return "ref " + local.name; } } | ||
2863 | } | ||
2864 | |||
2865 | /** | ||
2866 | * New C#-level array. | ||
2867 | */ | ||
2868 | private class OTOpndNewarr : OTOpnd { | ||
2869 | public Type type; | ||
2870 | public OTOpnd index; | ||
2871 | |||
2872 | public OTOpndNewarr (Type type, OTOpnd index) | ||
2873 | { | ||
2874 | this.type = type; | ||
2875 | this.index = index; | ||
2876 | } | ||
2877 | |||
2878 | public override bool HasSideEffects { | ||
2879 | get { | ||
2880 | return index.HasSideEffects; | ||
2881 | } | ||
2882 | } | ||
2883 | |||
2884 | public override void CountRefs (bool writing) | ||
2885 | { | ||
2886 | index.CountRefs (false); | ||
2887 | } | ||
2888 | |||
2889 | public override OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
2890 | { | ||
2891 | if (SameAs (oldopnd)) { | ||
2892 | rc = true; | ||
2893 | return newopnd; | ||
2894 | } | ||
2895 | index = index.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
2896 | return this; | ||
2897 | } | ||
2898 | |||
2899 | public override bool SameAs (OTOpnd other) | ||
2900 | { | ||
2901 | return false; | ||
2902 | } | ||
2903 | |||
2904 | public override string PrintableString { get { return "newarr " + type.Name + "[" + index.PrintableString + "]"; } } | ||
2905 | } | ||
2906 | |||
2907 | /** | ||
2908 | * New C#-level object. | ||
2909 | */ | ||
2910 | private class OTOpndNewobj : OTOpnd { | ||
2911 | public ConstructorInfo ctor; | ||
2912 | public OTOpnd[] args; | ||
2913 | |||
2914 | public static OTOpnd Make (ConstructorInfo ctor, OTOpnd[] args) | ||
2915 | { | ||
2916 | // newobj LSL_Float (x) => x | ||
2917 | if ((ctor.DeclaringType == typeof (LSL_Float)) && (args.Length == 1)) { | ||
2918 | Type ptype = ctor.GetParameters ()[0].ParameterType; | ||
2919 | if (ptype == typeof (string)) { | ||
2920 | return new OTOpndCast (typeof (double), args[0]); | ||
2921 | } | ||
2922 | return args[0]; | ||
2923 | } | ||
2924 | |||
2925 | // newobj LSL_Integer (x) => x | ||
2926 | if ((ctor.DeclaringType == typeof (LSL_Integer)) && (args.Length == 1)) { | ||
2927 | Type ptype = ctor.GetParameters ()[0].ParameterType; | ||
2928 | if (ptype == typeof (string)) { | ||
2929 | return new OTOpndCast (typeof (int), args[0]); | ||
2930 | } | ||
2931 | return args[0]; | ||
2932 | } | ||
2933 | |||
2934 | // newobj LSL_String (x) => x | ||
2935 | if ((ctor.DeclaringType == typeof (LSL_String)) && (args.Length == 1)) { | ||
2936 | return args[0]; | ||
2937 | } | ||
2938 | |||
2939 | // newobj LSL_Rotation (x, y, z, w) => <x, y, z, w> | ||
2940 | if ((ctor.DeclaringType == typeof (LSL_Rotation)) && (args.Length == 4)) { | ||
2941 | return new OTOpndRot (args[0], args[1], args[2], args[3]); | ||
2942 | } | ||
2943 | |||
2944 | // newobj LSL_Vector (x, y, z) => <x, y, z> | ||
2945 | if ((ctor.DeclaringType == typeof (LSL_Vector)) && (args.Length == 3)) { | ||
2946 | return new OTOpndVec (args[0], args[1], args[2]); | ||
2947 | } | ||
2948 | |||
2949 | // newobj LSL_Rotation (string) => (rotation) string | ||
2950 | if ((ctor.DeclaringType == typeof (LSL_Rotation)) && (args.Length == 1)) { | ||
2951 | return new OTOpndCast (typeof (LSL_Rotation), args[0]); | ||
2952 | } | ||
2953 | |||
2954 | // newobj LSL_Vector (string) => (rotation) string | ||
2955 | if ((ctor.DeclaringType == typeof (LSL_Vector)) && (args.Length == 1)) { | ||
2956 | return new OTOpndCast (typeof (LSL_Vector), args[0]); | ||
2957 | } | ||
2958 | |||
2959 | // newobj LSL_List (newarr object[0]) => [ ] | ||
2960 | if ((ctor.DeclaringType == typeof (LSL_List)) && (args.Length == 1) && (args[0] is OTOpndNewarr)) { | ||
2961 | OTOpndNewarr arg0 = (OTOpndNewarr) args[0]; | ||
2962 | if ((arg0.type == typeof (object)) && (arg0.index is OTOpndInt) && (((OTOpndInt) arg0.index).value == 0)) { | ||
2963 | OTOpndListIni listini = new OTOpndListIni (); | ||
2964 | listini.values = new OTOpnd[0]; | ||
2965 | return listini; | ||
2966 | } | ||
2967 | } | ||
2968 | |||
2969 | // something else, output as is | ||
2970 | OTOpndNewobj it = new OTOpndNewobj (); | ||
2971 | it.ctor = ctor; | ||
2972 | it.args = args; | ||
2973 | return it; | ||
2974 | } | ||
2975 | |||
2976 | private OTOpndNewobj () { } | ||
2977 | |||
2978 | public override bool HasSideEffects { | ||
2979 | get { | ||
2980 | foreach (OTOpnd arg in args) { | ||
2981 | if (arg.HasSideEffects) return true; | ||
2982 | } | ||
2983 | return false; | ||
2984 | } | ||
2985 | } | ||
2986 | |||
2987 | public override void CountRefs (bool writing) | ||
2988 | { | ||
2989 | foreach (OTOpnd arg in args) { | ||
2990 | arg.CountRefs (false); | ||
2991 | } | ||
2992 | } | ||
2993 | |||
2994 | public override OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
2995 | { | ||
2996 | if (SameAs (oldopnd)) { | ||
2997 | rc = true; | ||
2998 | return newopnd; | ||
2999 | } | ||
3000 | for (int i = 0; i < args.Length; i ++) { | ||
3001 | args[i] = args[i].ReplaceOperand (oldopnd, newopnd, ref rc); | ||
3002 | } | ||
3003 | return this; | ||
3004 | } | ||
3005 | |||
3006 | public override bool SameAs (OTOpnd other) | ||
3007 | { | ||
3008 | if (!(other is OTOpndNewobj)) return false; | ||
3009 | OTOpndNewobj otherno = (OTOpndNewobj) other; | ||
3010 | if (otherno.ctor.DeclaringType != ctor.DeclaringType) return false; | ||
3011 | if (otherno.args.Length != args.Length) return false; | ||
3012 | for (int i = 0; i < args.Length; i ++) { | ||
3013 | if (!args[i].SameAs (otherno.args[i])) return false; | ||
3014 | } | ||
3015 | return true; | ||
3016 | } | ||
3017 | |||
3018 | public override string PrintableString { | ||
3019 | get { | ||
3020 | StringBuilder sb = new StringBuilder (); | ||
3021 | sb.Append ("newobj "); | ||
3022 | sb.Append (ctor.DeclaringType.Name); | ||
3023 | sb.Append (" ("); | ||
3024 | bool first = true; | ||
3025 | foreach (OTOpnd arg in args) { | ||
3026 | if (!first) sb.Append (", "); | ||
3027 | sb.Append (arg.PrintableString); | ||
3028 | first = false; | ||
3029 | } | ||
3030 | sb.Append (')'); | ||
3031 | return sb.ToString (); | ||
3032 | } | ||
3033 | } | ||
3034 | } | ||
3035 | |||
3036 | /** | ||
3037 | * Rotation value. | ||
3038 | */ | ||
3039 | private class OTOpndRot : OTOpnd { | ||
3040 | private OTOpnd x, y, z, w; | ||
3041 | |||
3042 | public OTOpndRot (OTOpnd x, OTOpnd y, OTOpnd z, OTOpnd w) | ||
3043 | { | ||
3044 | this.x = StripFloatCast (x); | ||
3045 | this.y = StripFloatCast (y); | ||
3046 | this.z = StripFloatCast (z); | ||
3047 | this.w = StripFloatCast (w); | ||
3048 | } | ||
3049 | |||
3050 | public override bool HasSideEffects { | ||
3051 | get { | ||
3052 | return x.HasSideEffects || y.HasSideEffects || z.HasSideEffects || w.HasSideEffects; | ||
3053 | } | ||
3054 | } | ||
3055 | |||
3056 | public override void CountRefs (bool writing) | ||
3057 | { | ||
3058 | x.CountRefs (false); | ||
3059 | y.CountRefs (false); | ||
3060 | z.CountRefs (false); | ||
3061 | w.CountRefs (false); | ||
3062 | } | ||
3063 | |||
3064 | public override OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
3065 | { | ||
3066 | if (SameAs (oldopnd)) { | ||
3067 | rc = true; | ||
3068 | return newopnd; | ||
3069 | } | ||
3070 | x = x.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
3071 | y = y.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
3072 | z = z.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
3073 | w = w.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
3074 | return this; | ||
3075 | } | ||
3076 | |||
3077 | public override bool SameAs (OTOpnd other) | ||
3078 | { | ||
3079 | if (!(other is OTOpndRot)) return false; | ||
3080 | OTOpndRot otherv = (OTOpndRot) other; | ||
3081 | return otherv.x.SameAs (x) && otherv.y.SameAs (y) && otherv.z.SameAs (z) && otherv.w.SameAs (w); | ||
3082 | } | ||
3083 | |||
3084 | public override string PrintableString { | ||
3085 | get { | ||
3086 | return "<" + x.PrintableString + ", " + y.PrintableString + ", " + z.PrintableString + ", " + w.PrintableString + ">"; | ||
3087 | } | ||
3088 | } | ||
3089 | } | ||
3090 | |||
3091 | /** | ||
3092 | * Static field. | ||
3093 | */ | ||
3094 | private class OTOpndSField : OTOpnd { | ||
3095 | private FieldInfo field; | ||
3096 | |||
3097 | public OTOpndSField (FieldInfo field) | ||
3098 | { | ||
3099 | this.field = field; | ||
3100 | } | ||
3101 | |||
3102 | public override bool HasSideEffects { | ||
3103 | get { | ||
3104 | return false; | ||
3105 | } | ||
3106 | } | ||
3107 | |||
3108 | public override bool SameAs (OTOpnd other) | ||
3109 | { | ||
3110 | if (!(other is OTOpndSField)) return false; | ||
3111 | OTOpndSField othersfield = (OTOpndSField) other; | ||
3112 | return (field.Name == othersfield.field.Name) && (field.DeclaringType == othersfield.field.DeclaringType); | ||
3113 | } | ||
3114 | |||
3115 | public override string PrintableString { | ||
3116 | get { | ||
3117 | if (field.DeclaringType == typeof (ScriptBaseClass)) return field.Name; | ||
3118 | return field.DeclaringType.Name + "." + field.Name; | ||
3119 | } | ||
3120 | } | ||
3121 | } | ||
3122 | |||
3123 | /** | ||
3124 | * Call to string.Compare(). | ||
3125 | * See use cases in BinOpStr: | ||
3126 | * strcmp (a, b) ceq 0 | ||
3127 | * (strcmp (a, b) ceq 0) xor 1 => we translate to: strcmp (a, b) cne 0 | ||
3128 | * strcmp (a, b) clt 0 | ||
3129 | * strcmp (a, b) clt 1 // <= | ||
3130 | * strcmp (a, b) cgt 0 | ||
3131 | * strcmp (a, b) cgt -1 // >= | ||
3132 | * ...but then optimized by ScriptCollector if followed by br{false,true}: | ||
3133 | * ceq + xor 1 + brtrue => bne.un | ||
3134 | * ceq + xor 1 + brfalse => beq | ||
3135 | * ceq + brtrue => beq | ||
3136 | * ceq + brfalse => bne.un | ||
3137 | * cgt + brtrue => bgt | ||
3138 | * cgt + brfalse => ble | ||
3139 | * clt + brtrue => blt | ||
3140 | * clt + brfalse => bge | ||
3141 | * So we end up with these cases: | ||
3142 | * strcmp (a, b) ceq 0 | ||
3143 | * strcmp (a, b) cne 0 | ||
3144 | * strcmp (a, b) clt 0 | ||
3145 | * strcmp (a, b) clt 1 | ||
3146 | * strcmp (a, b) cgt 0 | ||
3147 | * strcmp (a, b) cgt -1 | ||
3148 | * strcmp (a, b) beq 0 | ||
3149 | * strcmp (a, b) bne.un 0 | ||
3150 | * strcmp (a, b) bgt 0 | ||
3151 | * strcmp (a, b) ble 0 | ||
3152 | * strcmp (a, b) bgt -1 | ||
3153 | * strcmp (a, b) ble -1 | ||
3154 | * strcmp (a, b) blt 0 | ||
3155 | * strcmp (a, b) bge 0 | ||
3156 | * strcmp (a, b) blt 1 | ||
3157 | * strcmp (a, b) bge 1 | ||
3158 | * ... so we pretty them up in OTOpndBinOp | ||
3159 | */ | ||
3160 | private class OTOpndStrCmp : OTOpnd { | ||
3161 | private static Dictionary<string,string> binops = InitBinops (); | ||
3162 | private static Dictionary<string,string> InitBinops () | ||
3163 | { | ||
3164 | Dictionary<string,string> d = new Dictionary<string,string> (); | ||
3165 | d["ceq 0"] = "ceq"; | ||
3166 | d["cne 0"] = "cne"; | ||
3167 | d["clt 0"] = "clt"; | ||
3168 | d["clt 1"] = "cle"; | ||
3169 | d["cgt 0"] = "cgt"; | ||
3170 | d["cgt -1"] = "cge"; | ||
3171 | d["beq 0"] = "ceq"; | ||
3172 | d["bne.un 0"] = "cne"; | ||
3173 | d["bgt 0"] = "cgt"; | ||
3174 | d["ble 0"] = "cle"; | ||
3175 | d["bgt -1"] = "cge"; | ||
3176 | d["ble -1"] = "clt"; | ||
3177 | d["blt 0"] = "clt"; | ||
3178 | d["bge 0"] = "cge"; | ||
3179 | d["blt 1"] = "cle"; | ||
3180 | d["bge 1"] = "cgt"; | ||
3181 | return d; | ||
3182 | } | ||
3183 | |||
3184 | private OTOpnd arg0; | ||
3185 | private OTOpnd arg1; | ||
3186 | |||
3187 | public OTOpndStrCmp (OTOpnd arg0, OTOpnd arg1) | ||
3188 | { | ||
3189 | this.arg0 = arg0; | ||
3190 | this.arg1 = arg1; | ||
3191 | } | ||
3192 | |||
3193 | /** | ||
3194 | * Try to make something a script writer would recognize. | ||
3195 | * If we can't, then we leave it as a call to xmrStringCompare(). | ||
3196 | * this = some strcmp(a,b) | ||
3197 | * opCode = hopefully some cxx or bxx from above table | ||
3198 | * rite = hopefully some constant from above table | ||
3199 | */ | ||
3200 | public OTOpnd MakeBinOp (MyOp opCode, OTOpnd rite) | ||
3201 | { | ||
3202 | if (!(rite is OTOpndInt)) return null; | ||
3203 | int riteint = ((OTOpndInt) rite).value; | ||
3204 | string key = opCode.name + ' ' + riteint; | ||
3205 | string cxxopname; | ||
3206 | if (!binops.TryGetValue (key, out cxxopname)) return null; | ||
3207 | return OTOpndBinOp.Make (arg0, MyOp.GetByName (cxxopname), arg1); | ||
3208 | } | ||
3209 | public OTOpnd MakeUnOp (MyOp opCode) | ||
3210 | { | ||
3211 | if (opCode == MyOp.Brfalse) return OTOpndBinOp.Make (arg0, MyOp.Ceq, arg1); | ||
3212 | if (opCode == MyOp.Brtrue) return OTOpndBinOp.Make (arg0, MyOp.Cne, arg1); | ||
3213 | return null; | ||
3214 | } | ||
3215 | |||
3216 | public override bool HasSideEffects { | ||
3217 | get { | ||
3218 | return false; | ||
3219 | } | ||
3220 | } | ||
3221 | |||
3222 | public override void CountRefs (bool writing) | ||
3223 | { | ||
3224 | arg0.CountRefs (writing); | ||
3225 | arg1.CountRefs (writing); | ||
3226 | } | ||
3227 | |||
3228 | public override OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
3229 | { | ||
3230 | if (SameAs (oldopnd)) { | ||
3231 | rc = true; | ||
3232 | return newopnd; | ||
3233 | } | ||
3234 | arg0 = arg0.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
3235 | arg1 = arg1.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
3236 | return this; | ||
3237 | } | ||
3238 | |||
3239 | public override bool SameAs (OTOpnd other) | ||
3240 | { | ||
3241 | if (!(other is OTOpndStrCmp)) return false; | ||
3242 | return arg0.SameAs (((OTOpndStrCmp) other).arg0) && arg1.SameAs (((OTOpndStrCmp) other).arg1); | ||
3243 | } | ||
3244 | |||
3245 | public override string PrintableString { | ||
3246 | get { | ||
3247 | return "xmrStringCompare (" + arg0.PrintableString + ", " + arg1.PrintableString + ")"; | ||
3248 | } | ||
3249 | } | ||
3250 | } | ||
3251 | |||
3252 | /** | ||
3253 | * Unary operator. | ||
3254 | */ | ||
3255 | private class OTOpndUnOp : OTOpnd { | ||
3256 | public MyOp opCode; | ||
3257 | public OTOpnd value; | ||
3258 | |||
3259 | private static Dictionary<string,string> brfops = InitBrfOps (); | ||
3260 | private static Dictionary<string,string> InitBrfOps () | ||
3261 | { | ||
3262 | Dictionary<string,string> d = new Dictionary<string,string> (); | ||
3263 | d["beq"] = "cne"; | ||
3264 | d["bge"] = "clt"; | ||
3265 | d["bgt"] = "cle"; | ||
3266 | d["ble"] = "cgt"; | ||
3267 | d["blt"] = "cge"; | ||
3268 | d["bne.un"] = "ceq"; | ||
3269 | d["ceq"] = "cne"; | ||
3270 | d["cge"] = "clt"; | ||
3271 | d["cgt"] = "cle"; | ||
3272 | d["cle"] = "cgt"; | ||
3273 | d["clt"] = "cge"; | ||
3274 | d["cne"] = "ceq"; | ||
3275 | return d; | ||
3276 | } | ||
3277 | |||
3278 | public static OTOpnd Make (MyOp opCode, OTOpnd value) | ||
3279 | { | ||
3280 | // (brfalse (brfalse (x))) => (brtrue (x)) | ||
3281 | if ((opCode == MyOp.Brfalse) && (value is OTOpndUnOp) && (((OTOpndUnOp) value).opCode == MyOp.Brfalse)) { | ||
3282 | ((OTOpndUnOp) value).opCode = MyOp.Brtrue; | ||
3283 | return value; | ||
3284 | } | ||
3285 | |||
3286 | // (brfalse (brtrue (x))) => (brfalse (x)) | ||
3287 | if ((opCode == MyOp.Brfalse) && (value is OTOpndUnOp) && (((OTOpndUnOp) value).opCode == MyOp.Brtrue)) { | ||
3288 | ((OTOpndUnOp) value).opCode = MyOp.Brfalse; | ||
3289 | return value; | ||
3290 | } | ||
3291 | |||
3292 | // (brtrue (brfalse (x))) => (brfalse (x)) | ||
3293 | if ((opCode == MyOp.Brtrue) && (value is OTOpndUnOp) && (((OTOpndUnOp) value).opCode == MyOp.Brfalse)) { | ||
3294 | return value; | ||
3295 | } | ||
3296 | |||
3297 | // (brtrue (brtrue (x))) => (brtrue (x)) | ||
3298 | if ((opCode == MyOp.Brtrue) && (value is OTOpndUnOp) && (((OTOpndUnOp) value).opCode == MyOp.Brtrue)) { | ||
3299 | return value; | ||
3300 | } | ||
3301 | |||
3302 | // (brfalse (x beq y)) => (x bne y) etc | ||
3303 | string brfop; | ||
3304 | if ((opCode == MyOp.Brfalse) && (value is OTOpndBinOp) && brfops.TryGetValue (((OTOpndBinOp) value).opCode.name, out brfop)) { | ||
3305 | ((OTOpndBinOp) value).opCode = MyOp.GetByName (brfop); | ||
3306 | return value; | ||
3307 | } | ||
3308 | |||
3309 | // (brtrue (x beq y)) => (x beq y) etc | ||
3310 | if ((opCode == MyOp.Brtrue) && (value is OTOpndBinOp) && brfops.ContainsKey (((OTOpndBinOp) value).opCode.name)) { | ||
3311 | return value; | ||
3312 | } | ||
3313 | |||
3314 | // strcmp() can be a special case | ||
3315 | if (value is OTOpndStrCmp) { | ||
3316 | OTOpnd strcmp = ((OTOpndStrCmp) value).MakeUnOp (opCode); | ||
3317 | if (strcmp != null) return strcmp; | ||
3318 | } | ||
3319 | |||
3320 | // nothing special, save opcode and value | ||
3321 | OTOpndUnOp it = new OTOpndUnOp (); | ||
3322 | it.opCode = opCode; | ||
3323 | it.value = value; | ||
3324 | return it; | ||
3325 | } | ||
3326 | |||
3327 | private OTOpndUnOp () { } | ||
3328 | |||
3329 | public override bool HasSideEffects { | ||
3330 | get { | ||
3331 | return value.HasSideEffects; | ||
3332 | } | ||
3333 | } | ||
3334 | |||
3335 | public override void CountRefs (bool writing) | ||
3336 | { | ||
3337 | value.CountRefs (false); | ||
3338 | } | ||
3339 | |||
3340 | public override OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
3341 | { | ||
3342 | if (SameAs (oldopnd)) { | ||
3343 | rc = true; | ||
3344 | return newopnd; | ||
3345 | } | ||
3346 | value = value.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
3347 | return this; | ||
3348 | } | ||
3349 | |||
3350 | public override bool SameAs (OTOpnd other) | ||
3351 | { | ||
3352 | if (!(other is OTOpndUnOp)) return false; | ||
3353 | OTOpndUnOp otherop = (OTOpndUnOp) other; | ||
3354 | return (opCode.ToString () == otherop.opCode.ToString ()) && value.SameAs (otherop.value); | ||
3355 | } | ||
3356 | |||
3357 | public override string PrintableString { | ||
3358 | get { | ||
3359 | StringBuilder sb = new StringBuilder (); | ||
3360 | sb.Append (opCode.source); | ||
3361 | sb.Append (' '); | ||
3362 | if (value is OTOpndBinOp) sb.Append ('('); | ||
3363 | sb.Append (value.PrintableString); | ||
3364 | if (value is OTOpndBinOp) sb.Append (')'); | ||
3365 | return sb.ToString (); | ||
3366 | } | ||
3367 | } | ||
3368 | } | ||
3369 | |||
3370 | /** | ||
3371 | * Vector value. | ||
3372 | */ | ||
3373 | private class OTOpndVec : OTOpnd { | ||
3374 | private OTOpnd x, y, z; | ||
3375 | |||
3376 | public OTOpndVec (OTOpnd x, OTOpnd y, OTOpnd z) | ||
3377 | { | ||
3378 | this.x = StripFloatCast (x); | ||
3379 | this.y = StripFloatCast (y); | ||
3380 | this.z = StripFloatCast (z); | ||
3381 | } | ||
3382 | |||
3383 | public override bool HasSideEffects { | ||
3384 | get { | ||
3385 | return x.HasSideEffects || y.HasSideEffects || z.HasSideEffects; | ||
3386 | } | ||
3387 | } | ||
3388 | |||
3389 | public override void CountRefs (bool writing) | ||
3390 | { | ||
3391 | x.CountRefs (false); | ||
3392 | y.CountRefs (false); | ||
3393 | z.CountRefs (false); | ||
3394 | } | ||
3395 | |||
3396 | public override OTOpnd ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd, ref bool rc) | ||
3397 | { | ||
3398 | if (SameAs (oldopnd)) { | ||
3399 | rc = true; | ||
3400 | return newopnd; | ||
3401 | } | ||
3402 | x = x.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
3403 | y = y.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
3404 | z = z.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
3405 | return this; | ||
3406 | } | ||
3407 | |||
3408 | public override bool SameAs (OTOpnd other) | ||
3409 | { | ||
3410 | if (!(other is OTOpndVec)) return false; | ||
3411 | OTOpndVec otherv = (OTOpndVec) other; | ||
3412 | return otherv.x.SameAs (x) && otherv.y.SameAs (y) && otherv.z.SameAs (z); | ||
3413 | } | ||
3414 | |||
3415 | public override string PrintableString { | ||
3416 | get { | ||
3417 | return "<" + x.PrintableString + ", " + y.PrintableString + ", " + z.PrintableString + ">"; | ||
3418 | } | ||
3419 | } | ||
3420 | } | ||
3421 | |||
3422 | /** | ||
3423 | * Constants. | ||
3424 | */ | ||
3425 | private class OTOpndDouble : OTOpnd { | ||
3426 | public double value; | ||
3427 | public OTOpndDouble (double value) { this.value = value; } | ||
3428 | public override bool HasSideEffects { get { return false; } } | ||
3429 | public override bool SameAs (OTOpnd other) | ||
3430 | { | ||
3431 | if (!(other is OTOpndDouble)) return false; | ||
3432 | return ((OTOpndDouble) other).value == value; | ||
3433 | } | ||
3434 | public override string PrintableString { | ||
3435 | get { | ||
3436 | string s = value.ToString (); | ||
3437 | long i; | ||
3438 | if (long.TryParse (s, out i)) { | ||
3439 | s += ".0"; | ||
3440 | } | ||
3441 | return s; | ||
3442 | } | ||
3443 | } | ||
3444 | } | ||
3445 | private class OTOpndFloat : OTOpnd { | ||
3446 | public float value; | ||
3447 | public OTOpndFloat (float value) { this.value = value; } | ||
3448 | public override bool HasSideEffects { get { return false; } } | ||
3449 | public override bool SameAs (OTOpnd other) | ||
3450 | { | ||
3451 | if (!(other is OTOpndFloat)) return false; | ||
3452 | return ((OTOpndFloat) other).value == value; | ||
3453 | } | ||
3454 | public override string PrintableString { | ||
3455 | get { | ||
3456 | string s = value.ToString (); | ||
3457 | long i; | ||
3458 | if (long.TryParse (s, out i)) { | ||
3459 | s += ".0"; | ||
3460 | } | ||
3461 | return s; | ||
3462 | } | ||
3463 | } | ||
3464 | } | ||
3465 | private class OTOpndInt : OTOpnd { | ||
3466 | public int value; | ||
3467 | public OTOpndInt (int value) { this.value = value; } | ||
3468 | public override bool HasSideEffects { get { return false; } } | ||
3469 | public override bool SameAs (OTOpnd other) | ||
3470 | { | ||
3471 | if (!(other is OTOpndInt)) return false; | ||
3472 | return ((OTOpndInt) other).value == value; | ||
3473 | } | ||
3474 | public override string PrintableString { get { return value.ToString (); } } | ||
3475 | } | ||
3476 | private class OTOpndNull : OTOpnd { | ||
3477 | public override bool HasSideEffects { get { return false; } } | ||
3478 | public override bool SameAs (OTOpnd other) | ||
3479 | { | ||
3480 | return other is OTOpndNull; | ||
3481 | } | ||
3482 | public override string PrintableString { get { return "undef"; } } | ||
3483 | } | ||
3484 | private class OTOpndString : OTOpnd { | ||
3485 | public string value; | ||
3486 | public OTOpndString (string value) { this.value = value; } | ||
3487 | public override bool HasSideEffects { get { return false; } } | ||
3488 | public override bool SameAs (OTOpnd other) | ||
3489 | { | ||
3490 | if (!(other is OTOpndString)) return false; | ||
3491 | return ((OTOpndString) other).value == value; | ||
3492 | } | ||
3493 | public override string PrintableString { | ||
3494 | get { | ||
3495 | StringBuilder sb = new StringBuilder (); | ||
3496 | TokenDeclInline.PrintParamString (sb, value); | ||
3497 | return sb.ToString (); | ||
3498 | } | ||
3499 | } | ||
3500 | } | ||
3501 | |||
3502 | /****************************************\ | ||
3503 | * Tokens what are in statement list. * | ||
3504 | \****************************************/ | ||
3505 | |||
3506 | public abstract class OTStmt { | ||
3507 | |||
3508 | /** | ||
3509 | * Increment reference counts. | ||
3510 | */ | ||
3511 | public abstract void CountRefs (); | ||
3512 | |||
3513 | /** | ||
3514 | * Strip out any of the behind-the-scenes code such as stack capture/restore. | ||
3515 | * By default, there is no change. | ||
3516 | */ | ||
3517 | public virtual bool StripStuff (LinkedListNode<OTStmt> link) | ||
3518 | { | ||
3519 | return false; | ||
3520 | } | ||
3521 | |||
3522 | /** | ||
3523 | * Replace the oldopnd operand with the newopnd operand if it is present. | ||
3524 | * Return whether or not it was found and replaced. | ||
3525 | */ | ||
3526 | public abstract bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd); | ||
3527 | |||
3528 | /** | ||
3529 | * Detect and modify for do/for/if/while structures. | ||
3530 | */ | ||
3531 | public virtual bool DetectDoForIfWhile (LinkedListNode<OTStmt> link) | ||
3532 | { | ||
3533 | return false; | ||
3534 | } | ||
3535 | |||
3536 | /** | ||
3537 | * If this statement is the old statement, replace it with the given new statement. | ||
3538 | * Also search any sub-ordinate statements. | ||
3539 | * **NOTE**: minimally implemented to replace a Jump with a Break or Continue | ||
3540 | */ | ||
3541 | public abstract OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt); | ||
3542 | |||
3543 | /** | ||
3544 | * Print the statement out on the given printer with the given indenting. | ||
3545 | * The first line is already indented, subsequent lines must be indented as given. | ||
3546 | * This method should leave the printer at the end of the line. | ||
3547 | */ | ||
3548 | public abstract void PrintStmt (TextWriter twout, string indent); | ||
3549 | |||
3550 | /** | ||
3551 | * Strip all statements following this statement | ||
3552 | * because this statement jumps somewhere. | ||
3553 | */ | ||
3554 | protected bool StripStuffForTerminal (LinkedListNode<OTStmt> link) | ||
3555 | { | ||
3556 | // strip all statements following jump until seeing some label | ||
3557 | bool rc = false; | ||
3558 | if (link != null) { | ||
3559 | LinkedListNode<OTStmt> nextlink; | ||
3560 | while ((nextlink = link.Next) != null) { | ||
3561 | if (nextlink.Value is OTStmtLabel) break; | ||
3562 | nextlink.List.Remove (nextlink); | ||
3563 | rc = true; | ||
3564 | } | ||
3565 | } | ||
3566 | return rc; | ||
3567 | } | ||
3568 | } | ||
3569 | |||
3570 | /**************************\ | ||
3571 | * Primitive statements * | ||
3572 | \**************************/ | ||
3573 | |||
3574 | /** | ||
3575 | * Begin catch block (catch). | ||
3576 | */ | ||
3577 | private class OTStmtBegCatBlk : OTStmt { | ||
3578 | public OTStmtBegExcBlk tryblock; | ||
3579 | public OTStmtBlock catchblock; | ||
3580 | |||
3581 | private Type excType; | ||
3582 | |||
3583 | public OTStmtBegCatBlk (Type excType) | ||
3584 | { | ||
3585 | this.excType = excType; | ||
3586 | } | ||
3587 | |||
3588 | public override void CountRefs () | ||
3589 | { | ||
3590 | catchblock.CountRefs (); | ||
3591 | } | ||
3592 | |||
3593 | public override bool StripStuff (LinkedListNode<OTStmt> link) | ||
3594 | { | ||
3595 | return catchblock.StripStuff (null); | ||
3596 | } | ||
3597 | |||
3598 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
3599 | { | ||
3600 | return catchblock.ReplaceOperand (oldopnd, newopnd); | ||
3601 | } | ||
3602 | |||
3603 | public override bool DetectDoForIfWhile (LinkedListNode<OTStmt> link) | ||
3604 | { | ||
3605 | return catchblock.DetectDoForIfWhile (link); | ||
3606 | } | ||
3607 | |||
3608 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
3609 | { | ||
3610 | catchblock = (OTStmtBlock) catchblock.ReplaceStatement (oldstmt, newstmt); | ||
3611 | return this; | ||
3612 | } | ||
3613 | |||
3614 | /** | ||
3615 | * Print out the catch block including its enclosed statements. | ||
3616 | */ | ||
3617 | public override void PrintStmt (TextWriter twout, string indent) | ||
3618 | { | ||
3619 | twout.Write ("catch (" + excType.Name + ") "); | ||
3620 | catchblock.PrintStmt (twout, indent); | ||
3621 | } | ||
3622 | } | ||
3623 | |||
3624 | /** | ||
3625 | * Begin exception block (try). | ||
3626 | */ | ||
3627 | private class OTStmtBegExcBlk : OTStmt { | ||
3628 | |||
3629 | // statements within the try { } not including any catch or finally | ||
3630 | public OTStmtBlock tryblock; | ||
3631 | |||
3632 | // list of all catch { } blocks associated with this try { } | ||
3633 | public LinkedList<OTStmtBegCatBlk> catches = new LinkedList<OTStmtBegCatBlk> (); | ||
3634 | |||
3635 | // possible single finally { } associated with this try | ||
3636 | public OTStmtBegFinBlk finblock; // might be null | ||
3637 | |||
3638 | public override void CountRefs () | ||
3639 | { | ||
3640 | tryblock.CountRefs (); | ||
3641 | foreach (OTStmtBegCatBlk catblock in catches) { | ||
3642 | catblock.CountRefs (); | ||
3643 | } | ||
3644 | if (finblock != null) finblock.CountRefs (); | ||
3645 | } | ||
3646 | |||
3647 | /** | ||
3648 | * Strip behind-the-scenes info from all the sub-blocks. | ||
3649 | */ | ||
3650 | public override bool StripStuff (LinkedListNode<OTStmt> link) | ||
3651 | { | ||
3652 | // strip behind-the-scenes info from all the sub-blocks. | ||
3653 | bool rc = tryblock.StripStuff (null); | ||
3654 | foreach (OTStmtBegCatBlk catblk in catches) { | ||
3655 | rc |= catblk.StripStuff (null); | ||
3656 | } | ||
3657 | if (finblock != null) rc |= finblock.StripStuff (null); | ||
3658 | if (rc) return true; | ||
3659 | |||
3660 | // change: | ||
3661 | // try { | ||
3662 | // ... | ||
3663 | // } | ||
3664 | // to: | ||
3665 | // { | ||
3666 | // ... | ||
3667 | // } | ||
3668 | // note that an empty catch () { } has meaning so can't be stripped | ||
3669 | // empty finally { } blocks strips itself from the try | ||
3670 | if ((catches.Count == 0) && (finblock == null) && (link != null)) { | ||
3671 | link.List.AddAfter (link, tryblock); | ||
3672 | tryblock = null; | ||
3673 | link.List.Remove (link); | ||
3674 | return true; | ||
3675 | } | ||
3676 | |||
3677 | return false; | ||
3678 | } | ||
3679 | |||
3680 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
3681 | { | ||
3682 | bool rc = tryblock.ReplaceOperand (oldopnd, newopnd); | ||
3683 | foreach (OTStmtBegCatBlk catblk in catches) { | ||
3684 | rc |= catblk.ReplaceOperand (oldopnd, newopnd); | ||
3685 | } | ||
3686 | if (finblock != null) rc |= finblock.ReplaceOperand (oldopnd, newopnd); | ||
3687 | return rc; | ||
3688 | } | ||
3689 | |||
3690 | public override bool DetectDoForIfWhile (LinkedListNode<OTStmt> link) | ||
3691 | { | ||
3692 | bool rc = tryblock.DetectDoForIfWhile (link); | ||
3693 | foreach (OTStmtBegCatBlk catblk in catches) { | ||
3694 | rc |= catblk.DetectDoForIfWhile (link); | ||
3695 | } | ||
3696 | if (finblock != null) rc |= finblock.DetectDoForIfWhile (link); | ||
3697 | return rc; | ||
3698 | } | ||
3699 | |||
3700 | /** | ||
3701 | * Assume we will never try to replace the try block itself. | ||
3702 | * But go through all our sub-ordinates statements. | ||
3703 | */ | ||
3704 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
3705 | { | ||
3706 | tryblock = (OTStmtBlock) tryblock.ReplaceStatement (oldstmt, newstmt); | ||
3707 | for (LinkedListNode<OTStmtBegCatBlk> catlink = catches.First; catlink != null; catlink = catlink.Next) { | ||
3708 | catlink.Value = (OTStmtBegCatBlk) catlink.Value.ReplaceStatement (oldstmt, newstmt); | ||
3709 | } | ||
3710 | if (finblock != null) finblock = (OTStmtBegFinBlk) finblock.ReplaceStatement (oldstmt, newstmt); | ||
3711 | return this; | ||
3712 | } | ||
3713 | |||
3714 | /** | ||
3715 | * Print out the try block including its enclosed statements. | ||
3716 | * And since the try is the only thing pushed to the outer block, | ||
3717 | * we also print out all the catch and finally blocks. | ||
3718 | */ | ||
3719 | public override void PrintStmt (TextWriter twout, string indent) | ||
3720 | { | ||
3721 | twout.Write ("try "); | ||
3722 | tryblock.PrintStmt (twout, indent); | ||
3723 | foreach (OTStmtBegCatBlk catblk in catches) { | ||
3724 | twout.Write (' '); | ||
3725 | catblk.PrintStmt (twout, indent); | ||
3726 | } | ||
3727 | if (finblock != null) { | ||
3728 | twout.Write (' '); | ||
3729 | finblock.PrintStmt (twout, indent); | ||
3730 | } | ||
3731 | } | ||
3732 | } | ||
3733 | |||
3734 | /** | ||
3735 | * Begin finally block (finally). | ||
3736 | */ | ||
3737 | private class OTStmtBegFinBlk : OTStmt { | ||
3738 | public OTStmtBegExcBlk tryblock; | ||
3739 | public OTStmtBlock finblock; | ||
3740 | |||
3741 | public override void CountRefs () | ||
3742 | { | ||
3743 | finblock.CountRefs (); | ||
3744 | } | ||
3745 | |||
3746 | /** | ||
3747 | * Strip behind-the-scene parts from the finally block. | ||
3748 | */ | ||
3749 | public override bool StripStuff (LinkedListNode<OTStmt> link) | ||
3750 | { | ||
3751 | // strip behind-the-scenes parts from finally block itself | ||
3752 | if (finblock.StripStuff (null)) return true; | ||
3753 | |||
3754 | // if finblock is empty, delete the finally from the try | ||
3755 | if (finblock.blkstmts.Count == 0) { | ||
3756 | tryblock.finblock = null; | ||
3757 | return true; | ||
3758 | } | ||
3759 | |||
3760 | return false; | ||
3761 | } | ||
3762 | |||
3763 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
3764 | { | ||
3765 | return finblock.ReplaceOperand (oldopnd, newopnd); | ||
3766 | } | ||
3767 | |||
3768 | public override bool DetectDoForIfWhile (LinkedListNode<OTStmt> link) | ||
3769 | { | ||
3770 | return finblock.DetectDoForIfWhile (link); | ||
3771 | } | ||
3772 | |||
3773 | /** | ||
3774 | * Assume we will never try to replace the finally block itself. | ||
3775 | * But go through all our sub-ordinates statements. | ||
3776 | */ | ||
3777 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
3778 | { | ||
3779 | finblock = (OTStmtBlock) finblock.ReplaceStatement (oldstmt, newstmt); | ||
3780 | return this; | ||
3781 | } | ||
3782 | |||
3783 | /** | ||
3784 | * Print out the finally block including its enclosed statements. | ||
3785 | */ | ||
3786 | public override void PrintStmt (TextWriter twout, string indent) | ||
3787 | { | ||
3788 | twout.Write ("finally "); | ||
3789 | finblock.PrintStmt (twout, indent); | ||
3790 | } | ||
3791 | } | ||
3792 | |||
3793 | /** | ||
3794 | * Simple if jump/break/continue statement. | ||
3795 | */ | ||
3796 | private class OTStmtCond : OTStmt { | ||
3797 | public OTOpnd valu; | ||
3798 | public OTStmt stmt; // jump, break, continue only | ||
3799 | |||
3800 | public OTStmtCond (OTOpnd valu, OTStmt stmt) | ||
3801 | { | ||
3802 | this.valu = valu; | ||
3803 | this.stmt = stmt; | ||
3804 | } | ||
3805 | |||
3806 | public override void CountRefs () | ||
3807 | { | ||
3808 | valu.CountRefs (false); | ||
3809 | stmt.CountRefs (); | ||
3810 | } | ||
3811 | |||
3812 | public override bool StripStuff (LinkedListNode<OTStmt> link) | ||
3813 | { | ||
3814 | // we assume that callMode is always CallMode_NORMAL, ie, not doing a stack capture or restore | ||
3815 | // so the 'if (arg$0.callMode bne.un 0) ...' is deleted | ||
3816 | // and the 'if (arg$0.callMode bne.un 1) ...' becomes unconditional | ||
3817 | // it can also be __xmrinst.callMode instead of arg$0 | ||
3818 | if (valu is OTOpndBinOp) { | ||
3819 | OTOpndBinOp binop = (OTOpndBinOp) valu; | ||
3820 | if ((binop.left is OTOpndField) && (binop.opCode.ToString () == "bne.un") && (binop.rite is OTOpndInt)) { | ||
3821 | OTOpndField leftfield = (OTOpndField) binop.left; | ||
3822 | if (leftfield.field.Name == _callMode) { | ||
3823 | bool ok = false; | ||
3824 | if (leftfield.obj is OTOpndArg) { | ||
3825 | ok = ((OTOpndArg) leftfield.obj).index == 0; | ||
3826 | } | ||
3827 | if (leftfield.obj is OTOpndLocal) { | ||
3828 | ok = ((OTOpndLocal) leftfield.obj).local.name.StartsWith (_xmrinstlocal); | ||
3829 | } | ||
3830 | if (ok) { | ||
3831 | OTOpndInt riteint = (OTOpndInt) binop.rite; | ||
3832 | |||
3833 | // delete 'if ((arg$0).callMode bne.un 0) ...' | ||
3834 | if (riteint.value == XMRInstAbstract.CallMode_NORMAL) { | ||
3835 | link.List.Remove (link); | ||
3836 | return true; | ||
3837 | } | ||
3838 | |||
3839 | // make 'if ((arg$0).callMode bne.un 1) ...' unconditional | ||
3840 | if (riteint.value == XMRInstAbstract.CallMode_SAVE) { | ||
3841 | link.Value = stmt; | ||
3842 | return true; | ||
3843 | } | ||
3844 | } | ||
3845 | } | ||
3846 | } | ||
3847 | } | ||
3848 | |||
3849 | // similarly we assume that doGblInit is always 0 to eliminate the code at beginning of default state_entry() | ||
3850 | // so the 'if (brfalse __xmrinst.doGblInit) ...' is made unconditional | ||
3851 | if (valu is OTOpndUnOp) { | ||
3852 | OTOpndUnOp unop = (OTOpndUnOp) valu; | ||
3853 | if ((unop.opCode == MyOp.Brfalse) && (unop.value is OTOpndField)) { | ||
3854 | OTOpndField valuefield = (OTOpndField) unop.value; | ||
3855 | if (valuefield.field.Name == _doGblInit) { | ||
3856 | bool ok = false; | ||
3857 | if (valuefield.obj is OTOpndLocal) { | ||
3858 | ok = ((OTOpndLocal) valuefield.obj).local.name.StartsWith (_xmrinstlocal); | ||
3859 | } | ||
3860 | if (ok) { | ||
3861 | |||
3862 | // make 'if (brfalse __xmrinst.doGblInit) ...' unconditional | ||
3863 | link.Value = stmt; | ||
3864 | return true; | ||
3865 | } | ||
3866 | } | ||
3867 | } | ||
3868 | } | ||
3869 | |||
3870 | return false; | ||
3871 | } | ||
3872 | |||
3873 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
3874 | { | ||
3875 | bool rc = stmt.ReplaceOperand (oldopnd, newopnd); | ||
3876 | valu = valu.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
3877 | return rc; | ||
3878 | } | ||
3879 | |||
3880 | /** | ||
3881 | * Maybe this simple if statement is part of a script-level if/then/else statement. | ||
3882 | */ | ||
3883 | public override bool DetectDoForIfWhile (LinkedListNode<OTStmt> link) | ||
3884 | { | ||
3885 | return OTStmtIf.Detect (link); | ||
3886 | } | ||
3887 | |||
3888 | /** | ||
3889 | * Assume we won't replace the if statement itself. | ||
3890 | * But search all our sub-ordinate statements. | ||
3891 | */ | ||
3892 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
3893 | { | ||
3894 | stmt = stmt.ReplaceStatement (oldstmt, newstmt); | ||
3895 | return this; | ||
3896 | } | ||
3897 | |||
3898 | public override void PrintStmt (TextWriter twout, string indent) | ||
3899 | { | ||
3900 | twout.Write ("if (" + StripBrtrue (valu).PrintableString + ") "); | ||
3901 | stmt.PrintStmt (twout, indent); | ||
3902 | } | ||
3903 | |||
3904 | /** | ||
3905 | * Scan forward for a given label definition. | ||
3906 | * Put intervening statements in a statement block. | ||
3907 | * @param link = start scanning after this statement | ||
3908 | * @param label = look for this label definition | ||
3909 | * @param block = where to return intervening statement block | ||
3910 | * @returns null: label definition not found | ||
3911 | * else: label definition statement | ||
3912 | */ | ||
3913 | private static LinkedListNode<OTStmt> ScanForLabel (LinkedListNode<OTStmt> link, | ||
3914 | OTLabel label, out OTStmtBlock block) | ||
3915 | { | ||
3916 | block = new OTStmtBlock (); | ||
3917 | while ((link = link.Next) != null) { | ||
3918 | if (link.Value is OTStmtLabel) { | ||
3919 | if (((OTStmtLabel) link.Value).label == label) break; | ||
3920 | } | ||
3921 | block.blkstmts.AddLast (link.Value); | ||
3922 | } | ||
3923 | return link; | ||
3924 | } | ||
3925 | |||
3926 | /** | ||
3927 | * Strip statements after link up to and including donelink. | ||
3928 | */ | ||
3929 | private static void StripInterveningStatements (LinkedListNode<OTStmt> link, LinkedListNode<OTStmt> donelink) | ||
3930 | { | ||
3931 | LinkedListNode<OTStmt> striplink; | ||
3932 | do { | ||
3933 | striplink = link.Next; | ||
3934 | striplink.List.Remove (striplink); | ||
3935 | } while (striplink != donelink); | ||
3936 | } | ||
3937 | } | ||
3938 | |||
3939 | /** | ||
3940 | * Jump to a label. | ||
3941 | */ | ||
3942 | private class OTStmtJump : OTStmt { | ||
3943 | public OTLabel label; | ||
3944 | |||
3945 | public static OTStmt Make (OTLabel label) | ||
3946 | { | ||
3947 | // jumps to __retlbl are return statements | ||
3948 | // note that is is safe to say it is a valueless return because | ||
3949 | // valued returns are done with this construct: | ||
3950 | // __retval = ....; | ||
3951 | // jump __retlbl; | ||
3952 | // and those __retval = statements have been changed to return statements already | ||
3953 | if (label.name.StartsWith (_retlbl)) return new OTStmtRet (null); | ||
3954 | |||
3955 | // other jumps are really jumps | ||
3956 | OTStmtJump it = new OTStmtJump (); | ||
3957 | it.label = label; | ||
3958 | return it; | ||
3959 | } | ||
3960 | |||
3961 | private OTStmtJump () { } | ||
3962 | |||
3963 | public override void CountRefs () | ||
3964 | { | ||
3965 | label.lbljumps ++; | ||
3966 | } | ||
3967 | |||
3968 | public override bool StripStuff (LinkedListNode<OTStmt> link) | ||
3969 | { | ||
3970 | if (link == null) return false; | ||
3971 | |||
3972 | // strip statements following unconditional jump until next label | ||
3973 | bool rc = StripStuffForTerminal (link); | ||
3974 | |||
3975 | // if we (now) have: | ||
3976 | // jump label; | ||
3977 | // @label; | ||
3978 | // ... delete this jump | ||
3979 | if (link.Next != null) { | ||
3980 | OTStmtLabel nextlabel = (OTStmtLabel) link.Next.Value; | ||
3981 | if (nextlabel.label == label) { | ||
3982 | link.List.Remove (link); | ||
3983 | rc = true; | ||
3984 | } | ||
3985 | } | ||
3986 | |||
3987 | return rc; | ||
3988 | } | ||
3989 | |||
3990 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
3991 | { | ||
3992 | return false; | ||
3993 | } | ||
3994 | |||
3995 | /** | ||
3996 | * This is actually what ReplaceStatement() is currently used for. | ||
3997 | * It replaces a jump with a break or a continue. | ||
3998 | */ | ||
3999 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
4000 | { | ||
4001 | if ((oldstmt is OTStmtJump) && (((OTStmtJump) oldstmt).label == label)) return newstmt; | ||
4002 | return this; | ||
4003 | } | ||
4004 | |||
4005 | public override void PrintStmt (TextWriter twout, string indent) | ||
4006 | { | ||
4007 | twout.Write ("jump " + label.PrintableName + ';'); | ||
4008 | } | ||
4009 | } | ||
4010 | |||
4011 | /** | ||
4012 | * Label definition point. | ||
4013 | */ | ||
4014 | private class OTStmtLabel : OTStmt { | ||
4015 | public OTLabel label; | ||
4016 | |||
4017 | private OTDecompile decompile; | ||
4018 | |||
4019 | public static void AddLast (OTDecompile decompile, OTLabel label) | ||
4020 | { | ||
4021 | OTStmtLabel it = new OTStmtLabel (); | ||
4022 | it.label = label; | ||
4023 | it.decompile = decompile; | ||
4024 | decompile.AddLastStmt (it); | ||
4025 | } | ||
4026 | |||
4027 | private OTStmtLabel () { } | ||
4028 | |||
4029 | public override void CountRefs () | ||
4030 | { | ||
4031 | // don't increment label.lbljumps | ||
4032 | // cuz we don't want the positioning | ||
4033 | // to count as a reference, only jumps | ||
4034 | // to the label should count | ||
4035 | } | ||
4036 | |||
4037 | public override bool StripStuff (LinkedListNode<OTStmt> link) | ||
4038 | { | ||
4039 | // if label has nothing jumping to it, remove the label | ||
4040 | if (link != null) { | ||
4041 | label.lbljumps = 0; | ||
4042 | decompile.topBlock.CountRefs (); | ||
4043 | if (label.lbljumps == 0) { | ||
4044 | link.List.Remove (link); | ||
4045 | return true; | ||
4046 | } | ||
4047 | } | ||
4048 | |||
4049 | return false; | ||
4050 | } | ||
4051 | |||
4052 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
4053 | { | ||
4054 | return false; | ||
4055 | } | ||
4056 | |||
4057 | public override bool DetectDoForIfWhile (LinkedListNode<OTStmt> link) | ||
4058 | { | ||
4059 | if (OTStmtDo.Detect (link)) return true; | ||
4060 | if (OTStmtFor.Detect (link, true)) return true; | ||
4061 | if (OTStmtFor.Detect (link, false)) return true; | ||
4062 | return false; | ||
4063 | } | ||
4064 | |||
4065 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
4066 | { | ||
4067 | return this; | ||
4068 | } | ||
4069 | |||
4070 | public override void PrintStmt (TextWriter twout, string indent) | ||
4071 | { | ||
4072 | twout.Write ("@" + label.PrintableName + ';'); | ||
4073 | } | ||
4074 | } | ||
4075 | |||
4076 | /** | ||
4077 | * Return with or without value. | ||
4078 | */ | ||
4079 | private class OTStmtRet : OTStmt { | ||
4080 | public OTOpnd value; // might be null | ||
4081 | |||
4082 | public OTStmtRet (OTOpnd value) | ||
4083 | { | ||
4084 | this.value = value; | ||
4085 | } | ||
4086 | |||
4087 | public override void CountRefs () | ||
4088 | { | ||
4089 | if (value != null) value.CountRefs (false); | ||
4090 | } | ||
4091 | |||
4092 | public override bool StripStuff (LinkedListNode<OTStmt> link) | ||
4093 | { | ||
4094 | return StripStuffForTerminal (link); | ||
4095 | } | ||
4096 | |||
4097 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
4098 | { | ||
4099 | bool rc = false; | ||
4100 | if (value != null) value = value.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
4101 | return rc; | ||
4102 | } | ||
4103 | |||
4104 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
4105 | { | ||
4106 | return this; | ||
4107 | } | ||
4108 | |||
4109 | public override void PrintStmt (TextWriter twout, string indent) | ||
4110 | { | ||
4111 | if (value == null) { | ||
4112 | twout.Write ("return;"); | ||
4113 | } else { | ||
4114 | twout.Write ("return " + value.PrintableString + ';'); | ||
4115 | } | ||
4116 | } | ||
4117 | } | ||
4118 | |||
4119 | /** | ||
4120 | * Store value in variable. | ||
4121 | */ | ||
4122 | private class OTStmtStore : OTStmt { | ||
4123 | public OTOpnd varwr; | ||
4124 | public OTOpnd value; | ||
4125 | |||
4126 | private OTDecompile decompile; | ||
4127 | |||
4128 | public static void AddLast (OTDecompile decompile, OTOpnd varwr, OTOpnd value) | ||
4129 | { | ||
4130 | OTStmtStore it = new OTStmtStore (varwr, value, decompile); | ||
4131 | decompile.AddLastStmt (it); | ||
4132 | } | ||
4133 | |||
4134 | public OTStmtStore (OTOpnd varwr, OTOpnd value, OTDecompile decompile) | ||
4135 | { | ||
4136 | this.varwr = varwr; | ||
4137 | this.value = value; | ||
4138 | this.decompile = decompile; | ||
4139 | } | ||
4140 | |||
4141 | public override void CountRefs () | ||
4142 | { | ||
4143 | varwr.CountRefs (true); | ||
4144 | value.CountRefs (false); | ||
4145 | } | ||
4146 | |||
4147 | public override bool StripStuff (LinkedListNode<OTStmt> link) | ||
4148 | { | ||
4149 | // strip out stores to __mainCallNo | ||
4150 | if (varwr is OTOpndLocal) { | ||
4151 | OTOpndLocal local = (OTOpndLocal) varwr; | ||
4152 | if (local.local.name.StartsWith (_mainCallNo)) { | ||
4153 | link.List.Remove (link); | ||
4154 | return true; | ||
4155 | } | ||
4156 | } | ||
4157 | |||
4158 | // strip out stores to local vars where the var is not read | ||
4159 | // but convert the value to an OTStmtVoid in case it is a call | ||
4160 | if (varwr is OTOpndLocal) { | ||
4161 | OTOpndLocal local = (OTOpndLocal) varwr; | ||
4162 | local.local.nlclreads = 0; | ||
4163 | decompile.topBlock.CountRefs (); | ||
4164 | if (local.local.nlclreads == 0) { | ||
4165 | OTStmt voidstmt = OTStmtVoid.Make (value); | ||
4166 | if (voidstmt == null) link.List.Remove (link); | ||
4167 | else link.Value = voidstmt; | ||
4168 | return true; | ||
4169 | } | ||
4170 | } | ||
4171 | |||
4172 | // strip out bla = newobj HeapTrackerList (...); | ||
4173 | if (value is OTOpndNewobj) { | ||
4174 | OTOpndNewobj valueno = (OTOpndNewobj) value; | ||
4175 | if (valueno.ctor.DeclaringType == typeof (HeapTrackerList)) { | ||
4176 | link.List.Remove (link); | ||
4177 | return true; | ||
4178 | } | ||
4179 | } | ||
4180 | |||
4181 | // strip out bla = newobj HeapTrackerObject (...); | ||
4182 | if (value is OTOpndNewobj) { | ||
4183 | OTOpndNewobj valueno = (OTOpndNewobj) value; | ||
4184 | if (valueno.ctor.DeclaringType == typeof (HeapTrackerObject)) { | ||
4185 | link.List.Remove (link); | ||
4186 | return true; | ||
4187 | } | ||
4188 | } | ||
4189 | |||
4190 | // strip out bla = newobj HeapTrackerString (...); | ||
4191 | if (value is OTOpndNewobj) { | ||
4192 | OTOpndNewobj valueno = (OTOpndNewobj) value; | ||
4193 | if (valueno.ctor.DeclaringType == typeof (HeapTrackerString)) { | ||
4194 | link.List.Remove (link); | ||
4195 | return true; | ||
4196 | } | ||
4197 | } | ||
4198 | |||
4199 | // convert tmp$n = bla bla; | ||
4200 | // .... tmp$n ....; | ||
4201 | // to | ||
4202 | // .... bla bla ....; | ||
4203 | // gets rid of vast majority of temps | ||
4204 | if (varwr is OTOpndLocal) { | ||
4205 | OTOpndLocal temp = (OTOpndLocal) varwr; | ||
4206 | if (temp.local.name.StartsWith ("tmp$")) { | ||
4207 | temp.local.nlclreads = 0; | ||
4208 | temp.local.nlclwrites = 0; | ||
4209 | decompile.topBlock.CountRefs (); | ||
4210 | if ((temp.local.nlclreads == 1) && (temp.local.nlclwrites == 1) && (link.Next != null)) { | ||
4211 | OTStmt nextstmt = link.Next.Value; | ||
4212 | if (!(nextstmt is OTStmtBlock)) { | ||
4213 | if (nextstmt.ReplaceOperand (varwr, value)) { | ||
4214 | link.List.Remove (link); | ||
4215 | return true; | ||
4216 | } | ||
4217 | } | ||
4218 | } | ||
4219 | |||
4220 | // also try to convert: | ||
4221 | // tmp$n = ... asdf ... << we are here (link) | ||
4222 | // lcl = tmp$n; << nextstore | ||
4223 | // ... qwer tmp$n ... | ||
4224 | // ... no further references to tmp$n | ||
4225 | // to: | ||
4226 | // lcl = ... asdf ... | ||
4227 | // ... qwer lcl ... | ||
4228 | if ((temp.local.nlclreads == 2) && (temp.local.nlclwrites == 1) && | ||
4229 | (link.Next != null) && (link.Next.Value is OTStmtStore)) { | ||
4230 | OTStmtStore nextstore = (OTStmtStore) link.Next.Value; | ||
4231 | if ((nextstore.varwr is OTOpndLocal) && (nextstore.value is OTOpndLocal) && (link.Next.Next != null)) { | ||
4232 | OTOpndLocal localopnd = (OTOpndLocal) nextstore.varwr; | ||
4233 | OTOpndLocal tempopnd = (OTOpndLocal) nextstore.value; | ||
4234 | if (tempopnd.local == temp.local) { | ||
4235 | OTStmt finalstmt = link.Next.Next.Value; | ||
4236 | if (finalstmt.ReplaceOperand (tempopnd, localopnd)) { | ||
4237 | nextstore.value = value; | ||
4238 | link.List.Remove (link); | ||
4239 | return true; | ||
4240 | } | ||
4241 | } | ||
4242 | } | ||
4243 | } | ||
4244 | } | ||
4245 | } | ||
4246 | |||
4247 | // convert: | ||
4248 | // dup$n = ... asdf ... << we are here | ||
4249 | // lcl = dup$n; | ||
4250 | // ... qwer dup$n ... | ||
4251 | // ... no further references to dup$n | ||
4252 | // to: | ||
4253 | // lcl = ... asdf ... | ||
4254 | // ... qwer lcl ... | ||
4255 | if ((varwr is OTOpndDup) && (link != null)) { | ||
4256 | OTOpndDup vardup = (OTOpndDup) varwr; | ||
4257 | LinkedListNode<OTStmt> nextlink = link.Next; | ||
4258 | vardup.ndupreads = 0; | ||
4259 | decompile.topBlock.CountRefs (); | ||
4260 | if ((vardup.ndupreads == 2) && (nextlink != null) && (nextlink.Value is OTStmtStore)) { | ||
4261 | |||
4262 | // point to the supposed lcl = dup$n statement | ||
4263 | OTStmtStore nextstore = (OTStmtStore) nextlink.Value; | ||
4264 | LinkedListNode<OTStmt> nextlink2 = nextlink.Next; | ||
4265 | if ((nextstore.varwr is OTOpndLocal) && (nextstore.value == vardup) && (nextlink2 != null)) { | ||
4266 | |||
4267 | // get the local var being written and point to the ... qwer dup$n ... statement | ||
4268 | OTOpndLocal varlcl = (OTOpndLocal) nextstore.varwr; | ||
4269 | OTStmt nextstmt2 = nextlink2.Value; | ||
4270 | |||
4271 | // try to replace dup$n in qwer with lcl | ||
4272 | if (nextstmt2.ReplaceOperand (vardup, varlcl)) { | ||
4273 | |||
4274 | // successful, replace dup$n in asdf with lcl | ||
4275 | // and delete the lcl = dup$n statement | ||
4276 | varwr = varlcl; | ||
4277 | nextlink.List.Remove (nextlink); | ||
4278 | return true; | ||
4279 | } | ||
4280 | } | ||
4281 | } | ||
4282 | } | ||
4283 | |||
4284 | // convert: | ||
4285 | // dup$n = ... asdf ... << we are here | ||
4286 | // ... qwer dup$n ... | ||
4287 | // ... no further references to dup$n | ||
4288 | // to: | ||
4289 | // ... qwer ... asdf ... ... | ||
4290 | if ((varwr is OTOpndDup) && (link != null)) { | ||
4291 | OTOpndDup vardup = (OTOpndDup) varwr; | ||
4292 | LinkedListNode<OTStmt> nextlink = link.Next; | ||
4293 | vardup.ndupreads = 0; | ||
4294 | decompile.topBlock.CountRefs (); | ||
4295 | if ((vardup.ndupreads == 1) && (nextlink != null)) { | ||
4296 | |||
4297 | // point to the ... qwer dup$n ... statement | ||
4298 | OTStmt nextstmt = nextlink.Value; | ||
4299 | |||
4300 | // try to replace dup$n in qwer with ... asdf ... | ||
4301 | if (nextstmt.ReplaceOperand (vardup, value)) { | ||
4302 | |||
4303 | // successful, delete the dup$n = ... asdf ... statement | ||
4304 | link.List.Remove (link); | ||
4305 | return true; | ||
4306 | } | ||
4307 | } | ||
4308 | } | ||
4309 | |||
4310 | // look for list initialization [ ... ] | ||
4311 | if (OTOpndListIni.Detect (link)) return true; | ||
4312 | |||
4313 | // __xmrinst = (XMRInstAbstract) arg$0 indicates this is an event handler | ||
4314 | // so strip it out and set the flag | ||
4315 | if ((varwr is OTOpndLocal) && (value is OTOpndCast)) { | ||
4316 | OTOpndLocal lcl = (OTOpndLocal) varwr; | ||
4317 | OTOpndCast cast = (OTOpndCast) value; | ||
4318 | if (lcl.local.name.StartsWith (_xmrinstlocal) && (cast.value is OTOpndArg)) { | ||
4319 | link.List.Remove (link); | ||
4320 | return true; | ||
4321 | } | ||
4322 | } | ||
4323 | |||
4324 | // local = [ (optional cast) ] __xmrinst.ehArgs[n] is a definition of event handler arg #n | ||
4325 | // if found, make it event handler arg list definition | ||
4326 | OTOpnd valuenocast = value; | ||
4327 | if (valuenocast is OTOpndCast) valuenocast = ((OTOpndCast) value).value; | ||
4328 | if ((varwr is OTOpndLocal) && (valuenocast is OTOpndArrayElem)) { | ||
4329 | OTOpndArrayElem array = (OTOpndArrayElem) valuenocast; | ||
4330 | if ((array.array is OTOpndField) && (array.index is OTOpndInt)) { | ||
4331 | OTOpndField arrayfield = (OTOpndField) array.array; | ||
4332 | if ((arrayfield.obj is OTOpndLocal) && | ||
4333 | ((OTOpndLocal) arrayfield.obj).local.name.StartsWith (_xmrinstlocal) && | ||
4334 | (arrayfield.field.Name == _ehArgs)) { | ||
4335 | int index = ((OTOpndInt) array.index).value; | ||
4336 | decompile.eharglist[index] = ((OTOpndLocal) varwr).local; | ||
4337 | link.List.Remove (link); | ||
4338 | return true; | ||
4339 | } | ||
4340 | } | ||
4341 | } | ||
4342 | |||
4343 | // __retval$n = ...; => return ...; | ||
4344 | if (varwr is OTOpndLocal) { | ||
4345 | OTOpndLocal lcl = (OTOpndLocal) varwr; | ||
4346 | if (lcl.local.name.StartsWith (_retval)) { | ||
4347 | link.Value = new OTStmtRet (value); | ||
4348 | return true; | ||
4349 | } | ||
4350 | } | ||
4351 | |||
4352 | return false; | ||
4353 | } | ||
4354 | |||
4355 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
4356 | { | ||
4357 | bool rc = false; | ||
4358 | if (value != null) value = value.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
4359 | return rc; | ||
4360 | } | ||
4361 | |||
4362 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
4363 | { | ||
4364 | return this; | ||
4365 | } | ||
4366 | |||
4367 | public override void PrintStmt (TextWriter twout, string indent) | ||
4368 | { | ||
4369 | // print x = x + 1 as x += 1, but don't print x = x < 3 as x <= 3 | ||
4370 | if (value is OTOpndBinOp) { | ||
4371 | OTOpndBinOp valuebo = (OTOpndBinOp) value; | ||
4372 | if (varwr.SameAs (valuebo.left) && " add and div mul or rem shl shr sub xor ".Contains (' ' + valuebo.opCode.name + ' ')) { | ||
4373 | twout.Write (varwr.PrintableString + ' ' + valuebo.opCode.source + "= " + valuebo.rite.PrintableString + ';'); | ||
4374 | return; | ||
4375 | } | ||
4376 | } | ||
4377 | |||
4378 | twout.Write (varwr.PrintableString + " = " + value.PrintableString + ';'); | ||
4379 | } | ||
4380 | } | ||
4381 | |||
4382 | /** | ||
4383 | * Dispatch to a table of labels. | ||
4384 | */ | ||
4385 | private class OTStmtSwitch : OTStmt { | ||
4386 | private OTOpnd index; | ||
4387 | private OTLabel[] labels; | ||
4388 | |||
4389 | public OTStmtSwitch (OTOpnd index, OTLabel[] labels) | ||
4390 | { | ||
4391 | this.index = index; | ||
4392 | this.labels = labels; | ||
4393 | } | ||
4394 | |||
4395 | public override void CountRefs () | ||
4396 | { | ||
4397 | index.CountRefs (false); | ||
4398 | foreach (OTLabel label in labels) { | ||
4399 | label.lbljumps ++; | ||
4400 | } | ||
4401 | } | ||
4402 | |||
4403 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
4404 | { | ||
4405 | bool rc = false; | ||
4406 | if (index != null) index = index.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
4407 | return rc; | ||
4408 | } | ||
4409 | |||
4410 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
4411 | { | ||
4412 | return this; | ||
4413 | } | ||
4414 | |||
4415 | public override void PrintStmt (TextWriter twout, string indent) | ||
4416 | { | ||
4417 | twout.Write ("switch (" + index.PrintableString + ") {\n"); | ||
4418 | for (int i = 0; i < labels.Length; i ++) { | ||
4419 | twout.Write (indent + INDENT + "case " + i + ": jump " + labels[i].name + ";\n"); | ||
4420 | } | ||
4421 | twout.Write (indent + '}'); | ||
4422 | } | ||
4423 | } | ||
4424 | |||
4425 | /** | ||
4426 | * Throw an exception. | ||
4427 | */ | ||
4428 | private class OTStmtThrow : OTStmt { | ||
4429 | private OTOpnd value; | ||
4430 | private OTDecompile decompile; | ||
4431 | |||
4432 | public OTStmtThrow (OTOpnd value, OTDecompile decompile) | ||
4433 | { | ||
4434 | this.value = value; | ||
4435 | this.decompile = decompile; | ||
4436 | } | ||
4437 | |||
4438 | public override void CountRefs () | ||
4439 | { | ||
4440 | value.CountRefs (false); | ||
4441 | } | ||
4442 | |||
4443 | public override bool StripStuff (LinkedListNode<OTStmt> link) | ||
4444 | { | ||
4445 | return StripStuffForTerminal (link); | ||
4446 | } | ||
4447 | |||
4448 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
4449 | { | ||
4450 | bool rc = false; | ||
4451 | if (value != null) value = value.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
4452 | return rc; | ||
4453 | } | ||
4454 | |||
4455 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
4456 | { | ||
4457 | return this; | ||
4458 | } | ||
4459 | |||
4460 | public override void PrintStmt (TextWriter twout, string indent) | ||
4461 | { | ||
4462 | // throw newobj ScriptUndefinedStateException ("x") => state x | ||
4463 | if (value is OTOpndNewobj) { | ||
4464 | OTOpndNewobj valueno = (OTOpndNewobj) value; | ||
4465 | if ((valueno.ctor.DeclaringType == typeof (ScriptUndefinedStateException)) && | ||
4466 | (valueno.args.Length == 1) && (valueno.args[0] is OTOpndString)) { | ||
4467 | OTOpndString arg0 = (OTOpndString) valueno.args[0]; | ||
4468 | twout.Write ("state " + arg0.value + "; /* throws undefined state exception */"); | ||
4469 | return; | ||
4470 | } | ||
4471 | } | ||
4472 | |||
4473 | // throw newobj ScriptChangeStateException (n) => state n | ||
4474 | if (value is OTOpndNewobj) { | ||
4475 | OTOpndNewobj valueno = (OTOpndNewobj) value; | ||
4476 | if ((valueno.ctor.DeclaringType == typeof (ScriptChangeStateException)) && | ||
4477 | (valueno.args.Length == 1) && (valueno.args[0] is OTOpndInt)) { | ||
4478 | OTOpndInt arg0 = (OTOpndInt) valueno.args[0]; | ||
4479 | twout.Write ("state " + decompile.scriptObjCode.stateNames[arg0.value] + ';'); | ||
4480 | return; | ||
4481 | } | ||
4482 | } | ||
4483 | |||
4484 | // throwing something else, output as is | ||
4485 | twout.Write ("throw " + value.PrintableString + ';'); | ||
4486 | } | ||
4487 | } | ||
4488 | |||
4489 | /** | ||
4490 | * Call with void return, or really anything that we discard the value of after computing it. | ||
4491 | */ | ||
4492 | private class OTStmtVoid : OTStmt { | ||
4493 | private OTOpnd value; | ||
4494 | |||
4495 | public static void AddLast (OTDecompile decompile, OTOpnd value) | ||
4496 | { | ||
4497 | OTStmt it = OTStmtVoid.Make (value); | ||
4498 | if (it != null) decompile.AddLastStmt (it); | ||
4499 | } | ||
4500 | |||
4501 | public static OTStmt Make (OTOpnd value) | ||
4502 | { | ||
4503 | if (!value.HasSideEffects) return null; | ||
4504 | OTStmtVoid it = new OTStmtVoid (); | ||
4505 | it.value = value; | ||
4506 | return it; | ||
4507 | } | ||
4508 | |||
4509 | private OTStmtVoid () { } | ||
4510 | |||
4511 | public override void CountRefs () | ||
4512 | { | ||
4513 | value.CountRefs (false); | ||
4514 | } | ||
4515 | |||
4516 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
4517 | { | ||
4518 | bool rc = false; | ||
4519 | value = value.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
4520 | return rc; | ||
4521 | } | ||
4522 | |||
4523 | public override bool StripStuff (LinkedListNode<OTStmt> link) | ||
4524 | { | ||
4525 | // strip out calls to CheckRunQuick() and CheckRunStack() | ||
4526 | if (value is OTOpndCall) { | ||
4527 | OTOpndCall call = (OTOpndCall) value; | ||
4528 | MethodInfo method = call.method; | ||
4529 | if ((method.Name == _checkRunQuick) || (method.Name == _checkRunStack)) { | ||
4530 | link.List.Remove (link); | ||
4531 | return true; | ||
4532 | } | ||
4533 | } | ||
4534 | |||
4535 | return false; | ||
4536 | } | ||
4537 | |||
4538 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
4539 | { | ||
4540 | return this; | ||
4541 | } | ||
4542 | |||
4543 | public override void PrintStmt (TextWriter twout, string indent) | ||
4544 | { | ||
4545 | twout.Write (value.PrintableString + ';'); | ||
4546 | } | ||
4547 | } | ||
4548 | |||
4549 | /***************************\ | ||
4550 | * Structured statements * | ||
4551 | \***************************/ | ||
4552 | |||
4553 | /** | ||
4554 | * Block of statements. | ||
4555 | */ | ||
4556 | private class OTStmtBlock : OTStmt { | ||
4557 | public LinkedList<OTStmt> blkstmts = new LinkedList<OTStmt> (); | ||
4558 | |||
4559 | public override void CountRefs () | ||
4560 | { | ||
4561 | foreach (OTStmt stmt in blkstmts) { | ||
4562 | stmt.CountRefs (); | ||
4563 | } | ||
4564 | } | ||
4565 | |||
4566 | /** | ||
4567 | * Scrub out all references to behind-the-scenes parts and simplify. | ||
4568 | */ | ||
4569 | public override bool StripStuff (LinkedListNode<OTStmt> link) | ||
4570 | { | ||
4571 | // loop through all sub-statements to strip out behind-the-scenes references | ||
4572 | bool rc = false; | ||
4573 | loop: | ||
4574 | for (LinkedListNode<OTStmt> stmtlink = blkstmts.First; stmtlink != null; stmtlink = stmtlink.Next) { | ||
4575 | if (stmtlink.Value.StripStuff (stmtlink)) { | ||
4576 | rc = true; | ||
4577 | goto loop; | ||
4578 | } | ||
4579 | } | ||
4580 | if (rc) return true; | ||
4581 | |||
4582 | // try to merge this block into outer block | ||
4583 | // change: | ||
4584 | // { | ||
4585 | // ... | ||
4586 | // { << link points here | ||
4587 | // ... | ||
4588 | // } | ||
4589 | // ... | ||
4590 | // } | ||
4591 | // to: | ||
4592 | // { | ||
4593 | // ... | ||
4594 | // ... | ||
4595 | // ... | ||
4596 | // } | ||
4597 | if (link != null) { | ||
4598 | LinkedListNode<OTStmt> nextlink; | ||
4599 | while ((nextlink = blkstmts.Last) != null) { | ||
4600 | nextlink.List.Remove (nextlink); | ||
4601 | link.List.AddAfter (link, nextlink); | ||
4602 | } | ||
4603 | link.List.Remove (link); | ||
4604 | return true; | ||
4605 | } | ||
4606 | |||
4607 | return rc; | ||
4608 | } | ||
4609 | |||
4610 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
4611 | { | ||
4612 | bool rc = false; | ||
4613 | foreach (OTStmt stmt in blkstmts) { | ||
4614 | rc |= stmt.ReplaceOperand (oldopnd, newopnd); | ||
4615 | } | ||
4616 | return rc; | ||
4617 | } | ||
4618 | |||
4619 | /** | ||
4620 | * Check each statement in the block to see if it starts a do/for/if/while statement. | ||
4621 | */ | ||
4622 | public override bool DetectDoForIfWhile (LinkedListNode<OTStmt> link) | ||
4623 | { | ||
4624 | bool rc = false; | ||
4625 | loop: | ||
4626 | for (link = blkstmts.First; link != null; link = link.Next) { | ||
4627 | if (link.Value.DetectDoForIfWhile (link)) { | ||
4628 | rc = true; | ||
4629 | goto loop; | ||
4630 | } | ||
4631 | } | ||
4632 | return rc; | ||
4633 | } | ||
4634 | |||
4635 | /** | ||
4636 | * Assume we will never try to replace the block itself. | ||
4637 | * But go through all our sub-ordinates statements. | ||
4638 | */ | ||
4639 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
4640 | { | ||
4641 | for (LinkedListNode<OTStmt> childlink = blkstmts.First; childlink != null; childlink = childlink.Next) { | ||
4642 | childlink.Value = childlink.Value.ReplaceStatement (oldstmt, newstmt); | ||
4643 | } | ||
4644 | return this; | ||
4645 | } | ||
4646 | |||
4647 | /** | ||
4648 | * Print out the block including its enclosed statements. | ||
4649 | */ | ||
4650 | public override void PrintStmt (TextWriter twout, string indent) | ||
4651 | { | ||
4652 | switch (blkstmts.Count) { | ||
4653 | case 0: { | ||
4654 | twout.Write ("{ }"); | ||
4655 | break; | ||
4656 | } | ||
4657 | ////case 1: { | ||
4658 | //// blkstmts.First.Value.PrintStmt (twout, indent); | ||
4659 | //// break; | ||
4660 | ////} | ||
4661 | default: { | ||
4662 | twout.Write ('{'); | ||
4663 | PrintBodyAndEnd (twout, indent); | ||
4664 | break; | ||
4665 | } | ||
4666 | } | ||
4667 | } | ||
4668 | |||
4669 | public void PrintBodyAndEnd (TextWriter twout, string indent) | ||
4670 | { | ||
4671 | string newindent = indent + INDENT; | ||
4672 | foreach (OTStmt stmt in blkstmts) { | ||
4673 | twout.Write ('\n' + indent); | ||
4674 | if (!(stmt is OTStmtLabel)) twout.Write (INDENT); | ||
4675 | else twout.Write (LABELINDENT); | ||
4676 | stmt.PrintStmt (twout, newindent); | ||
4677 | } | ||
4678 | twout.Write ('\n' + indent + '}'); | ||
4679 | } | ||
4680 | } | ||
4681 | |||
4682 | /** | ||
4683 | * 'do' statement. | ||
4684 | */ | ||
4685 | private class OTStmtDo : OTStmt { | ||
4686 | private OTOpnd dotest; | ||
4687 | private OTStmtBlock dobody; | ||
4688 | |||
4689 | /** | ||
4690 | * See if we have a do loop... | ||
4691 | * @doloop_<suffix>; << link points here | ||
4692 | * ... <dobody> ... | ||
4693 | * [ if (dotest) ] jump doloop_<suffix>; | ||
4694 | */ | ||
4695 | public static bool Detect (LinkedListNode<OTStmt> link) | ||
4696 | { | ||
4697 | // see if we have label starting with 'doloop_' | ||
4698 | OTLabel looplabel = ((OTStmtLabel) link.Value).label; | ||
4699 | if (!looplabel.name.StartsWith (_doLoop)) return false; | ||
4700 | |||
4701 | // good chance we have a do loop | ||
4702 | OTStmtDo it = new OTStmtDo (); | ||
4703 | |||
4704 | // scan ahead looking for the terminating cond/jump loop | ||
4705 | // also gather up the statements for the do body block | ||
4706 | it.dobody = new OTStmtBlock (); | ||
4707 | LinkedListNode<OTStmt> nextlink; | ||
4708 | for (nextlink = link.Next; nextlink != null; nextlink = nextlink.Next) { | ||
4709 | OTStmt nextstmt = nextlink.Value; | ||
4710 | |||
4711 | // add statement to do body | ||
4712 | it.dobody.blkstmts.AddLast (nextlink.Value); | ||
4713 | |||
4714 | // check for something what jumps to loop label | ||
4715 | // that gives us the end of the loop | ||
4716 | OTStmt maybejump = nextstmt; | ||
4717 | if (nextstmt is OTStmtCond) { | ||
4718 | maybejump = ((OTStmtCond) nextstmt).stmt; | ||
4719 | } | ||
4720 | if ((maybejump is OTStmtJump) && (((OTStmtJump) maybejump).label == looplabel)) { | ||
4721 | break; | ||
4722 | } | ||
4723 | } | ||
4724 | |||
4725 | // make sure we found the jump back to the loop label | ||
4726 | if (nextlink == null) return false; | ||
4727 | |||
4728 | // remove all statements from caller's block including the continue label if any | ||
4729 | // but leave the break label alone it will be removed later if unreferenced | ||
4730 | // and leave the initial loop label intact for now | ||
4731 | for (LinkedListNode<OTStmt> remlink = null; (remlink = link.Next) != null;) { | ||
4732 | link.List.Remove (remlink); | ||
4733 | if (remlink == nextlink) break; | ||
4734 | } | ||
4735 | |||
4736 | // take test condition from last statement of body | ||
4737 | // it should be an cond/jump or just a jump to the loop label | ||
4738 | LinkedListNode<OTStmt> lastlink = it.dobody.blkstmts.Last; | ||
4739 | OTStmt laststmt = lastlink.Value; | ||
4740 | if (laststmt is OTStmtCond) { | ||
4741 | it.dotest = ((OTStmtCond) laststmt).valu; | ||
4742 | } else { | ||
4743 | it.dotest = new OTOpndInt (1); | ||
4744 | } | ||
4745 | lastlink.List.Remove (lastlink); | ||
4746 | |||
4747 | // finally replace the loop label with the whole do statement | ||
4748 | link.Value = it; | ||
4749 | |||
4750 | // tell caller we made a change | ||
4751 | return true; | ||
4752 | } | ||
4753 | |||
4754 | public override void CountRefs () | ||
4755 | { | ||
4756 | if (dotest != null) dotest.CountRefs (false); | ||
4757 | if (dobody != null) dobody.CountRefs (); | ||
4758 | } | ||
4759 | |||
4760 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
4761 | { | ||
4762 | return dobody.ReplaceOperand (oldopnd, newopnd); | ||
4763 | } | ||
4764 | |||
4765 | public override bool DetectDoForIfWhile (LinkedListNode<OTStmt> link) | ||
4766 | { | ||
4767 | return dobody.DetectDoForIfWhile (link); | ||
4768 | } | ||
4769 | |||
4770 | /** | ||
4771 | * Assume we won't replace the do statement itself. | ||
4772 | * But search all our sub-ordinate statements. | ||
4773 | */ | ||
4774 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
4775 | { | ||
4776 | dobody = (OTStmtBlock) dobody.ReplaceStatement (oldstmt, newstmt); | ||
4777 | return this; | ||
4778 | } | ||
4779 | |||
4780 | public override void PrintStmt (TextWriter twout, string indent) | ||
4781 | { | ||
4782 | // output do body | ||
4783 | twout.Write ("do "); | ||
4784 | dobody.PrintStmt (twout, indent); | ||
4785 | |||
4786 | // output while part | ||
4787 | twout.Write (" while (" + StripBrtrue (dotest).PrintableString + ");"); | ||
4788 | } | ||
4789 | } | ||
4790 | |||
4791 | /** | ||
4792 | * 'for' or 'while' statement. | ||
4793 | */ | ||
4794 | private class OTStmtFor : OTStmt { | ||
4795 | private bool iswhile; | ||
4796 | private OTOpnd fortest; | ||
4797 | private OTStmtBlock forbody; | ||
4798 | private OTStmt forinit; | ||
4799 | private OTStmt forstep; | ||
4800 | |||
4801 | /** | ||
4802 | * See if we have a for or while loop... | ||
4803 | * <forinit> | ||
4804 | * @forloop_<suffix>; << link points here | ||
4805 | * [ if (<fortest>) jump forbreak_<suffix>; ] | ||
4806 | * ... <forbody> ... | ||
4807 | * jump forloop_<suffix>; | ||
4808 | * [ @forbreak_<suffix>; ] | ||
4809 | */ | ||
4810 | public static bool Detect (LinkedListNode<OTStmt> link, bool iswhile) | ||
4811 | { | ||
4812 | string loopname = iswhile ? _whileLoop : _forLoop; | ||
4813 | string breakname = iswhile ? _whileBreak : _forBreak; | ||
4814 | |||
4815 | // see if we have label starting with 'forloop_' | ||
4816 | OTLabel looplabel = ((OTStmtLabel) link.Value).label; | ||
4817 | if (!looplabel.name.StartsWith (loopname)) return false; | ||
4818 | |||
4819 | // good chance we have a for loop | ||
4820 | OTStmtFor it = new OTStmtFor (); | ||
4821 | it.iswhile = iswhile; | ||
4822 | |||
4823 | // all labels end with this suffix | ||
4824 | string suffix = looplabel.name.Substring (loopname.Length); | ||
4825 | |||
4826 | // scan ahead looking for the 'jump forloop_<suffix>;' statement | ||
4827 | // also gather up the statements for the for body block | ||
4828 | it.forbody = new OTStmtBlock (); | ||
4829 | LinkedListNode<OTStmt> lastlink; | ||
4830 | for (lastlink = link; (lastlink = lastlink.Next) != null;) { | ||
4831 | |||
4832 | // check for jump forloop that tells us where loop ends | ||
4833 | if (lastlink.Value is OTStmtJump) { | ||
4834 | OTStmtJump lastjump = (OTStmtJump) lastlink.Value; | ||
4835 | if (lastjump.label == looplabel) break; | ||
4836 | } | ||
4837 | |||
4838 | // add to body block | ||
4839 | it.forbody.blkstmts.AddLast (lastlink.Value); | ||
4840 | } | ||
4841 | |||
4842 | // make sure we found the 'jump forloop' where the for loop ends | ||
4843 | if (lastlink == null) return false; | ||
4844 | |||
4845 | // remove all statements from caller's block including final jump | ||
4846 | // but leave the loop label in place | ||
4847 | for (LinkedListNode<OTStmt> nextlink = null; (nextlink = link.Next) != null;) { | ||
4848 | link.List.Remove (nextlink); | ||
4849 | if (nextlink == lastlink) break; | ||
4850 | } | ||
4851 | |||
4852 | // if statement before loop label is an assignment, use it for the init statement | ||
4853 | if (!iswhile && (link.Previous != null) && (link.Previous.Value is OTStmtStore)) { | ||
4854 | it.forinit = link.Previous.Value; | ||
4855 | link.List.Remove (link.Previous); | ||
4856 | } | ||
4857 | |||
4858 | // if first statement of for body is 'if (...) jump breaklabel' use it for the test value | ||
4859 | if ((it.forbody.blkstmts.First != null) && (it.forbody.blkstmts.First.Value is OTStmtCond)) { | ||
4860 | OTStmtCond condstmt = (OTStmtCond) it.forbody.blkstmts.First.Value; | ||
4861 | if ((condstmt.stmt is OTStmtJump) && (((OTStmtJump) condstmt.stmt).label.name == breakname + suffix)) { | ||
4862 | it.fortest = OTOpndUnOp.Make (MyOp.Brfalse, condstmt.valu); | ||
4863 | it.forbody.blkstmts.RemoveFirst (); | ||
4864 | } | ||
4865 | } | ||
4866 | |||
4867 | // if last statement of body is an assigment, | ||
4868 | // use the assignment as the step statement | ||
4869 | if (!iswhile && (it.forbody.blkstmts.Last != null) && | ||
4870 | (it.forbody.blkstmts.Last.Value is OTStmtStore)) { | ||
4871 | LinkedListNode<OTStmt> storelink = it.forbody.blkstmts.Last; | ||
4872 | storelink.List.Remove (storelink); | ||
4873 | it.forstep = storelink.Value; | ||
4874 | } | ||
4875 | |||
4876 | // finally replace the loop label with the whole for statement | ||
4877 | link.Value = it; | ||
4878 | |||
4879 | // tell caller we made a change | ||
4880 | return true; | ||
4881 | } | ||
4882 | |||
4883 | public override void CountRefs () | ||
4884 | { | ||
4885 | if (fortest != null) fortest.CountRefs (false); | ||
4886 | if (forbody != null) forbody.CountRefs (); | ||
4887 | if (forinit != null) forinit.CountRefs (); | ||
4888 | if (forstep != null) forstep.CountRefs (); | ||
4889 | } | ||
4890 | |||
4891 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
4892 | { | ||
4893 | return forbody.ReplaceOperand (oldopnd, newopnd) | | ||
4894 | ((forinit != null) && forinit.ReplaceOperand (oldopnd, newopnd)) | | ||
4895 | ((forstep != null) && forstep.ReplaceOperand (oldopnd, newopnd)); | ||
4896 | } | ||
4897 | |||
4898 | public override bool DetectDoForIfWhile (LinkedListNode<OTStmt> link) | ||
4899 | { | ||
4900 | return forbody.DetectDoForIfWhile (link) | | ||
4901 | ((forinit != null) && forinit.DetectDoForIfWhile (link)) | | ||
4902 | ((forstep != null) && forstep.DetectDoForIfWhile (link)); | ||
4903 | } | ||
4904 | |||
4905 | /** | ||
4906 | * Assume we won't replace the for statement itself. | ||
4907 | * But search all our sub-ordinate statements. | ||
4908 | */ | ||
4909 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
4910 | { | ||
4911 | forbody = (OTStmtBlock) forbody.ReplaceStatement (oldstmt, newstmt); | ||
4912 | if (forinit != null) forinit = forinit.ReplaceStatement (oldstmt, newstmt); | ||
4913 | if (forstep != null) forstep = forstep.ReplaceStatement (oldstmt, newstmt); | ||
4914 | return this; | ||
4915 | } | ||
4916 | |||
4917 | public override void PrintStmt (TextWriter twout, string indent) | ||
4918 | { | ||
4919 | if (iswhile) { | ||
4920 | twout.Write ("while ("); | ||
4921 | if (fortest == null) { | ||
4922 | twout.Write ("TRUE"); | ||
4923 | } else { | ||
4924 | twout.Write (StripBrtrue (fortest).PrintableString); | ||
4925 | } | ||
4926 | } else { | ||
4927 | twout.Write ("for ("); | ||
4928 | if (forinit != null) { | ||
4929 | forinit.PrintStmt (twout, indent + INDENT); | ||
4930 | } else { | ||
4931 | twout.Write (';'); | ||
4932 | } | ||
4933 | if (fortest != null) { | ||
4934 | twout.Write (' ' + StripBrtrue (fortest).PrintableString); | ||
4935 | } | ||
4936 | twout.Write (';'); | ||
4937 | if (forstep != null) { | ||
4938 | StringWriter sw = new StringWriter (); | ||
4939 | sw.Write (' '); | ||
4940 | forstep.PrintStmt (sw, indent + INDENT); | ||
4941 | StringBuilder sb = sw.GetStringBuilder (); | ||
4942 | int sl = sb.Length; | ||
4943 | if ((sl > 0) && (sb[sl-1] == ';')) sb.Remove (-- sl, 1); | ||
4944 | twout.Write (sb.ToString ()); | ||
4945 | } | ||
4946 | } | ||
4947 | |||
4948 | twout.Write (") "); | ||
4949 | forbody.PrintStmt (twout, indent); | ||
4950 | } | ||
4951 | } | ||
4952 | |||
4953 | /** | ||
4954 | * if/then/else block. | ||
4955 | */ | ||
4956 | private class OTStmtIf : OTStmt { | ||
4957 | private OTOpnd testvalu; | ||
4958 | private OTStmt thenstmt; | ||
4959 | private OTStmt elsestmt; // might be null | ||
4960 | |||
4961 | /** | ||
4962 | * Try to detect a structured if statement. | ||
4963 | * | ||
4964 | * if (condition) jump ifdone_<suffix>; << link points here | ||
4965 | * ... then body ... | ||
4966 | * @ifdone_<suffix>; | ||
4967 | * | ||
4968 | * if (condition) jump ifelse_<suffix>; | ||
4969 | * ... then body ... | ||
4970 | * jump ifdone_<suffix>; << optional if true body doesn't fall through | ||
4971 | * @ifelse_<suffix>; | ||
4972 | * ... else body ... | ||
4973 | * @ifdone_<suffix>; | ||
4974 | */ | ||
4975 | public static bool Detect (LinkedListNode<OTStmt> link) | ||
4976 | { | ||
4977 | OTStmtCond condstmt = (OTStmtCond) link.Value; | ||
4978 | if (!(condstmt.stmt is OTStmtJump)) return false; | ||
4979 | |||
4980 | OTStmtJump jumpstmt = (OTStmtJump) condstmt.stmt; | ||
4981 | if (jumpstmt.label.name.StartsWith (_ifDone)) { | ||
4982 | |||
4983 | // then-only if | ||
4984 | |||
4985 | // skip forward to find the ifdone_<suffix> label | ||
4986 | // also save the intervening statements for the then body | ||
4987 | OTStmtBlock thenbody; | ||
4988 | LinkedListNode<OTStmt> donelink = ScanForLabel (link, jumpstmt.label, out thenbody); | ||
4989 | |||
4990 | // make sure we found matching label | ||
4991 | if (donelink == null) return false; | ||
4992 | |||
4993 | // replace the jump ifdone_<suffix> with the <then body> | ||
4994 | OTStmtIf it = new OTStmtIf (); | ||
4995 | it.thenstmt = thenbody; | ||
4996 | |||
4997 | // replace the test value with the opposite | ||
4998 | it.testvalu = OTOpndUnOp.Make (MyOp.Brfalse, condstmt.valu); | ||
4999 | condstmt.valu = null; | ||
5000 | |||
5001 | // strip out the true body statements from the main code including the ifdone_<suffix> label | ||
5002 | StripInterveningStatements (link, donelink); | ||
5003 | |||
5004 | // replace the simple conditional with the if/then/else block | ||
5005 | link.Value = it; | ||
5006 | |||
5007 | // tell caller we changed something | ||
5008 | return true; | ||
5009 | } | ||
5010 | |||
5011 | if (jumpstmt.label.name.StartsWith (_ifElse)) { | ||
5012 | string suffix = jumpstmt.label.name.Substring (_ifElse.Length); | ||
5013 | |||
5014 | // if/then/else | ||
5015 | OTStmtIf it = new OTStmtIf (); | ||
5016 | |||
5017 | // skip forward to find the ifelse_<suffix> label | ||
5018 | // also save the intervening statements for the true body | ||
5019 | OTStmtBlock thenbody; | ||
5020 | LinkedListNode<OTStmt> elselink = ScanForLabel (link, jumpstmt.label, out thenbody); | ||
5021 | |||
5022 | // make sure we found matching label | ||
5023 | if (elselink != null) { | ||
5024 | |||
5025 | // the last statement of the then body might be a jump ifdone_<suffix> | ||
5026 | LinkedListNode<OTStmt> lastthenlink = thenbody.blkstmts.Last; | ||
5027 | if ((lastthenlink != null) && (lastthenlink.Value is OTStmtJump)) { | ||
5028 | OTStmtJump jumpifdone = (OTStmtJump) lastthenlink.Value; | ||
5029 | if (jumpifdone.label.name == _ifDone + suffix) { | ||
5030 | |||
5031 | lastthenlink.List.Remove (lastthenlink); | ||
5032 | |||
5033 | // skip forward to find the ifdone_<suffix> label | ||
5034 | // also save the intervening statements for the else body | ||
5035 | OTStmtBlock elsebody; | ||
5036 | LinkedListNode<OTStmt> donelink = ScanForLabel (elselink, jumpifdone.label, out elsebody); | ||
5037 | if (donelink != null) { | ||
5038 | |||
5039 | // replace the jump ifdone_<suffix> with the <true body> | ||
5040 | it.thenstmt = thenbody; | ||
5041 | |||
5042 | // save the else body as well | ||
5043 | it.elsestmt = elsebody; | ||
5044 | |||
5045 | // replace the test value with the opposite | ||
5046 | it.testvalu = OTOpndUnOp.Make (MyOp.Brfalse, condstmt.valu); | ||
5047 | condstmt.valu = null; | ||
5048 | |||
5049 | // strip out the true and else body statements from the main code including the ifdone_<suffix> label | ||
5050 | StripInterveningStatements (link, donelink); | ||
5051 | |||
5052 | // replace the simple conditional with the if/then/else block | ||
5053 | link.Value = it; | ||
5054 | |||
5055 | // tell caller we changed something | ||
5056 | return true; | ||
5057 | } | ||
5058 | } | ||
5059 | } | ||
5060 | |||
5061 | // missing the jump _ifDone_<suffix>, so make it a simple if/then | ||
5062 | // if (condition) jump ifelse_<suffix>; << link | ||
5063 | // ... then body ... << encapsulated in block thenbody | ||
5064 | // @ifelse_<suffix>; << elselink | ||
5065 | // ... else body ... << still inline and leave it there | ||
5066 | // @ifdone_<suffix>; << strip this out | ||
5067 | |||
5068 | // replace the jump ifelse_<suffix> with the <true body> | ||
5069 | it.thenstmt = thenbody; | ||
5070 | |||
5071 | // replace the test value with the opposite | ||
5072 | it.testvalu = OTOpndUnOp.Make (MyOp.Brfalse, condstmt.valu); | ||
5073 | condstmt.valu = null; | ||
5074 | |||
5075 | // strip out the then body statements from the main code including the ifelse_<suffix> label | ||
5076 | StripInterveningStatements (link, elselink); | ||
5077 | |||
5078 | // there's a dangling unused ifdone_<suffix> label ahead that has to be stripped | ||
5079 | for (LinkedListNode<OTStmt> donelink = link; (donelink = donelink.Next) != null;) { | ||
5080 | if ((donelink.Value is OTStmtLabel) && (((OTStmtLabel) donelink.Value).label.name == _ifDone + suffix)) { | ||
5081 | donelink.List.Remove (donelink); | ||
5082 | break; | ||
5083 | } | ||
5084 | } | ||
5085 | |||
5086 | // replace the simple conditional with the if/then/else block | ||
5087 | link.Value = it; | ||
5088 | |||
5089 | // tell caller we changed something | ||
5090 | return true; | ||
5091 | } | ||
5092 | } | ||
5093 | |||
5094 | return false; | ||
5095 | } | ||
5096 | |||
5097 | private OTStmtIf () { } | ||
5098 | |||
5099 | public override void CountRefs () | ||
5100 | { | ||
5101 | if (testvalu != null) testvalu.CountRefs (false); | ||
5102 | if (thenstmt != null) thenstmt.CountRefs (); | ||
5103 | if (elsestmt != null) elsestmt.CountRefs (); | ||
5104 | } | ||
5105 | |||
5106 | public override bool ReplaceOperand (OTOpnd oldopnd, OTOpnd newopnd) | ||
5107 | { | ||
5108 | bool rc = thenstmt.ReplaceOperand (oldopnd, newopnd); | ||
5109 | testvalu = testvalu.ReplaceOperand (oldopnd, newopnd, ref rc); | ||
5110 | return rc; | ||
5111 | } | ||
5112 | |||
5113 | public override bool DetectDoForIfWhile (LinkedListNode<OTStmt> link) | ||
5114 | { | ||
5115 | return ((thenstmt != null) && thenstmt.DetectDoForIfWhile (link)) | | ||
5116 | ((elsestmt != null) && elsestmt.DetectDoForIfWhile (link)); | ||
5117 | } | ||
5118 | |||
5119 | /** | ||
5120 | * Assume we won't replace the if statement itself. | ||
5121 | * But search all our sub-ordinate statements. | ||
5122 | */ | ||
5123 | public override OTStmt ReplaceStatement (OTStmt oldstmt, OTStmt newstmt) | ||
5124 | { | ||
5125 | thenstmt = thenstmt.ReplaceStatement (oldstmt, newstmt); | ||
5126 | if (elsestmt != null) elsestmt = elsestmt.ReplaceStatement (oldstmt, newstmt); | ||
5127 | return this; | ||
5128 | } | ||
5129 | |||
5130 | public override void PrintStmt (TextWriter twout, string indent) | ||
5131 | { | ||
5132 | twout.Write ("if (" + StripBrtrue (testvalu).PrintableString + ") "); | ||
5133 | OTStmt thenst = ReduceStmtBody (thenstmt, false); | ||
5134 | thenst.PrintStmt (twout, indent); | ||
5135 | if (elsestmt != null) { | ||
5136 | twout.Write ('\n' + indent + "else "); | ||
5137 | OTStmt elsest = ReduceStmtBody (elsestmt, true); | ||
5138 | elsest.PrintStmt (twout, indent); | ||
5139 | } | ||
5140 | } | ||
5141 | |||
5142 | // strip block off a single jump so it prints inline instead of with braces around it | ||
5143 | // also, if this is part of else, strip block for ifs to make else if statement | ||
5144 | private static OTStmt ReduceStmtBody (OTStmt statement, bool stripif) | ||
5145 | { | ||
5146 | OTStmt onestmt = statement; | ||
5147 | if ((onestmt is OTStmtBlock) && (((OTStmtBlock) onestmt).blkstmts.Count == 1)) { | ||
5148 | onestmt = ((OTStmtBlock) onestmt).blkstmts.First.Value; | ||
5149 | if ((onestmt is OTStmtJump) || (stripif && (onestmt is OTStmtIf))) { | ||
5150 | return onestmt; | ||
5151 | } | ||
5152 | } | ||
5153 | return statement; | ||
5154 | } | ||
5155 | |||
5156 | /** | ||
5157 | * Scan forward for a given label definition. | ||
5158 | * Put intervening statements in a statement block. | ||
5159 | * @param link = start scanning after this statement | ||
5160 | * @param label = look for this label definition | ||
5161 | * @param block = where to return intervening statement block | ||
5162 | * @returns null: label definition not found | ||
5163 | * else: label definition statement | ||
5164 | */ | ||
5165 | private static LinkedListNode<OTStmt> ScanForLabel (LinkedListNode<OTStmt> link, | ||
5166 | OTLabel label, out OTStmtBlock block) | ||
5167 | { | ||
5168 | block = new OTStmtBlock (); | ||
5169 | while ((link = link.Next) != null) { | ||
5170 | if (link.Value is OTStmtLabel) { | ||
5171 | if (((OTStmtLabel) link.Value).label == label) break; | ||
5172 | } | ||
5173 | block.blkstmts.AddLast (link.Value); | ||
5174 | } | ||
5175 | return link; | ||
5176 | } | ||
5177 | |||
5178 | /** | ||
5179 | * Strip statements after link up to and including donelink. | ||
5180 | */ | ||
5181 | private static void StripInterveningStatements (LinkedListNode<OTStmt> link, LinkedListNode<OTStmt> donelink) | ||
5182 | { | ||
5183 | LinkedListNode<OTStmt> striplink; | ||
5184 | do { | ||
5185 | striplink = link.Next; | ||
5186 | striplink.List.Remove (striplink); | ||
5187 | } while (striplink != donelink); | ||
5188 | } | ||
5189 | } | ||
5190 | |||
5191 | private class MyOp { | ||
5192 | public int index; | ||
5193 | public OpCode sysop; | ||
5194 | public string name; | ||
5195 | public string source; | ||
5196 | |||
5197 | private static Dictionary<string,MyOp> myopsbyname = new Dictionary<string,MyOp> (); | ||
5198 | private static int nextindex = 0; | ||
5199 | |||
5200 | public MyOp (OpCode sysop) | ||
5201 | { | ||
5202 | this.index = nextindex ++; | ||
5203 | this.sysop = sysop; | ||
5204 | this.name = sysop.Name; | ||
5205 | myopsbyname.Add (name, this); | ||
5206 | } | ||
5207 | |||
5208 | public MyOp (OpCode sysop, string source) | ||
5209 | { | ||
5210 | this.index = nextindex ++; | ||
5211 | this.sysop = sysop; | ||
5212 | this.name = sysop.Name; | ||
5213 | this.source = source; | ||
5214 | myopsbyname.Add (name, this); | ||
5215 | } | ||
5216 | |||
5217 | public MyOp (string name) | ||
5218 | { | ||
5219 | this.index = nextindex ++; | ||
5220 | this.name = name; | ||
5221 | myopsbyname.Add (name, this); | ||
5222 | } | ||
5223 | |||
5224 | public MyOp (string name, string source) | ||
5225 | { | ||
5226 | this.index = nextindex ++; | ||
5227 | this.name = name; | ||
5228 | this.source = source; | ||
5229 | myopsbyname.Add (name, this); | ||
5230 | } | ||
5231 | |||
5232 | public static MyOp GetByName (string name) | ||
5233 | { | ||
5234 | return myopsbyname[name]; | ||
5235 | } | ||
5236 | |||
5237 | public override string ToString () | ||
5238 | { | ||
5239 | return name; | ||
5240 | } | ||
5241 | |||
5242 | // these copied from OpCodes.cs | ||
5243 | public static readonly MyOp Nop = new MyOp (OpCodes.Nop); | ||
5244 | public static readonly MyOp Break = new MyOp (OpCodes.Break); | ||
5245 | public static readonly MyOp Ldarg_0 = new MyOp (OpCodes.Ldarg_0); | ||
5246 | public static readonly MyOp Ldarg_1 = new MyOp (OpCodes.Ldarg_1); | ||
5247 | public static readonly MyOp Ldarg_2 = new MyOp (OpCodes.Ldarg_2); | ||
5248 | public static readonly MyOp Ldarg_3 = new MyOp (OpCodes.Ldarg_3); | ||
5249 | public static readonly MyOp Ldloc_0 = new MyOp (OpCodes.Ldloc_0); | ||
5250 | public static readonly MyOp Ldloc_1 = new MyOp (OpCodes.Ldloc_1); | ||
5251 | public static readonly MyOp Ldloc_2 = new MyOp (OpCodes.Ldloc_2); | ||
5252 | public static readonly MyOp Ldloc_3 = new MyOp (OpCodes.Ldloc_3); | ||
5253 | public static readonly MyOp Stloc_0 = new MyOp (OpCodes.Stloc_0); | ||
5254 | public static readonly MyOp Stloc_1 = new MyOp (OpCodes.Stloc_1); | ||
5255 | public static readonly MyOp Stloc_2 = new MyOp (OpCodes.Stloc_2); | ||
5256 | public static readonly MyOp Stloc_3 = new MyOp (OpCodes.Stloc_3); | ||
5257 | public static readonly MyOp Ldarg_S = new MyOp (OpCodes.Ldarg_S); | ||
5258 | public static readonly MyOp Ldarga_S = new MyOp (OpCodes.Ldarga_S); | ||
5259 | public static readonly MyOp Starg_S = new MyOp (OpCodes.Starg_S); | ||
5260 | public static readonly MyOp Ldloc_S = new MyOp (OpCodes.Ldloc_S); | ||
5261 | public static readonly MyOp Ldloca_S = new MyOp (OpCodes.Ldloca_S); | ||
5262 | public static readonly MyOp Stloc_S = new MyOp (OpCodes.Stloc_S); | ||
5263 | public static readonly MyOp Ldnull = new MyOp (OpCodes.Ldnull); | ||
5264 | public static readonly MyOp Ldc_I4_M1 = new MyOp (OpCodes.Ldc_I4_M1); | ||
5265 | public static readonly MyOp Ldc_I4_0 = new MyOp (OpCodes.Ldc_I4_0); | ||
5266 | public static readonly MyOp Ldc_I4_1 = new MyOp (OpCodes.Ldc_I4_1); | ||
5267 | public static readonly MyOp Ldc_I4_2 = new MyOp (OpCodes.Ldc_I4_2); | ||
5268 | public static readonly MyOp Ldc_I4_3 = new MyOp (OpCodes.Ldc_I4_3); | ||
5269 | public static readonly MyOp Ldc_I4_4 = new MyOp (OpCodes.Ldc_I4_4); | ||
5270 | public static readonly MyOp Ldc_I4_5 = new MyOp (OpCodes.Ldc_I4_5); | ||
5271 | public static readonly MyOp Ldc_I4_6 = new MyOp (OpCodes.Ldc_I4_6); | ||
5272 | public static readonly MyOp Ldc_I4_7 = new MyOp (OpCodes.Ldc_I4_7); | ||
5273 | public static readonly MyOp Ldc_I4_8 = new MyOp (OpCodes.Ldc_I4_8); | ||
5274 | public static readonly MyOp Ldc_I4_S = new MyOp (OpCodes.Ldc_I4_S); | ||
5275 | public static readonly MyOp Ldc_I4 = new MyOp (OpCodes.Ldc_I4); | ||
5276 | public static readonly MyOp Ldc_I8 = new MyOp (OpCodes.Ldc_I8); | ||
5277 | public static readonly MyOp Ldc_R4 = new MyOp (OpCodes.Ldc_R4); | ||
5278 | public static readonly MyOp Ldc_R8 = new MyOp (OpCodes.Ldc_R8); | ||
5279 | public static readonly MyOp Dup = new MyOp (OpCodes.Dup); | ||
5280 | public static readonly MyOp Pop = new MyOp (OpCodes.Pop); | ||
5281 | public static readonly MyOp Jmp = new MyOp (OpCodes.Jmp); | ||
5282 | public static readonly MyOp Call = new MyOp (OpCodes.Call); | ||
5283 | public static readonly MyOp Calli = new MyOp (OpCodes.Calli); | ||
5284 | public static readonly MyOp Ret = new MyOp (OpCodes.Ret); | ||
5285 | public static readonly MyOp Br_S = new MyOp (OpCodes.Br_S); | ||
5286 | public static readonly MyOp Brfalse_S = new MyOp (OpCodes.Brfalse_S); | ||
5287 | public static readonly MyOp Brtrue_S = new MyOp (OpCodes.Brtrue_S); | ||
5288 | public static readonly MyOp Beq_S = new MyOp (OpCodes.Beq_S, "=="); | ||
5289 | public static readonly MyOp Bge_S = new MyOp (OpCodes.Bge_S, ">="); | ||
5290 | public static readonly MyOp Bgt_S = new MyOp (OpCodes.Bgt_S, ">"); | ||
5291 | public static readonly MyOp Ble_S = new MyOp (OpCodes.Ble_S, "<="); | ||
5292 | public static readonly MyOp Blt_S = new MyOp (OpCodes.Blt_S, "<"); | ||
5293 | public static readonly MyOp Bne_Un_S = new MyOp (OpCodes.Bne_Un_S, "!="); | ||
5294 | public static readonly MyOp Bge_Un_S = new MyOp (OpCodes.Bge_Un_S); | ||
5295 | public static readonly MyOp Bgt_Un_S = new MyOp (OpCodes.Bgt_Un_S); | ||
5296 | public static readonly MyOp Ble_Un_S = new MyOp (OpCodes.Ble_Un_S); | ||
5297 | public static readonly MyOp Blt_Un_S = new MyOp (OpCodes.Blt_Un_S); | ||
5298 | public static readonly MyOp Br = new MyOp (OpCodes.Br); | ||
5299 | public static readonly MyOp Brfalse = new MyOp (OpCodes.Brfalse, "!"); | ||
5300 | public static readonly MyOp Brtrue = new MyOp (OpCodes.Brtrue, "!!"); | ||
5301 | public static readonly MyOp Beq = new MyOp (OpCodes.Beq, "=="); | ||
5302 | public static readonly MyOp Bge = new MyOp (OpCodes.Bge, ">="); | ||
5303 | public static readonly MyOp Bgt = new MyOp (OpCodes.Bgt, ">"); | ||
5304 | public static readonly MyOp Ble = new MyOp (OpCodes.Ble, "<="); | ||
5305 | public static readonly MyOp Blt = new MyOp (OpCodes.Blt, "<"); | ||
5306 | public static readonly MyOp Bne_Un = new MyOp (OpCodes.Bne_Un, "!="); | ||
5307 | public static readonly MyOp Bge_Un = new MyOp (OpCodes.Bge_Un); | ||
5308 | public static readonly MyOp Bgt_Un = new MyOp (OpCodes.Bgt_Un); | ||
5309 | public static readonly MyOp Ble_Un = new MyOp (OpCodes.Ble_Un); | ||
5310 | public static readonly MyOp Blt_Un = new MyOp (OpCodes.Blt_Un); | ||
5311 | public static readonly MyOp Switch = new MyOp (OpCodes.Switch); | ||
5312 | public static readonly MyOp Ldind_I1 = new MyOp (OpCodes.Ldind_I1); | ||
5313 | public static readonly MyOp Ldind_U1 = new MyOp (OpCodes.Ldind_U1); | ||
5314 | public static readonly MyOp Ldind_I2 = new MyOp (OpCodes.Ldind_I2); | ||
5315 | public static readonly MyOp Ldind_U2 = new MyOp (OpCodes.Ldind_U2); | ||
5316 | public static readonly MyOp Ldind_I4 = new MyOp (OpCodes.Ldind_I4); | ||
5317 | public static readonly MyOp Ldind_U4 = new MyOp (OpCodes.Ldind_U4); | ||
5318 | public static readonly MyOp Ldind_I8 = new MyOp (OpCodes.Ldind_I8); | ||
5319 | public static readonly MyOp Ldind_I = new MyOp (OpCodes.Ldind_I); | ||
5320 | public static readonly MyOp Ldind_R4 = new MyOp (OpCodes.Ldind_R4); | ||
5321 | public static readonly MyOp Ldind_R8 = new MyOp (OpCodes.Ldind_R8); | ||
5322 | public static readonly MyOp Ldind_Ref = new MyOp (OpCodes.Ldind_Ref); | ||
5323 | public static readonly MyOp Stind_Ref = new MyOp (OpCodes.Stind_Ref); | ||
5324 | public static readonly MyOp Stind_I1 = new MyOp (OpCodes.Stind_I1); | ||
5325 | public static readonly MyOp Stind_I2 = new MyOp (OpCodes.Stind_I2); | ||
5326 | public static readonly MyOp Stind_I4 = new MyOp (OpCodes.Stind_I4); | ||
5327 | public static readonly MyOp Stind_I8 = new MyOp (OpCodes.Stind_I8); | ||
5328 | public static readonly MyOp Stind_R4 = new MyOp (OpCodes.Stind_R4); | ||
5329 | public static readonly MyOp Stind_R8 = new MyOp (OpCodes.Stind_R8); | ||
5330 | public static readonly MyOp Add = new MyOp (OpCodes.Add, "+"); | ||
5331 | public static readonly MyOp Sub = new MyOp (OpCodes.Sub, "-"); | ||
5332 | public static readonly MyOp Mul = new MyOp (OpCodes.Mul, "*"); | ||
5333 | public static readonly MyOp Div = new MyOp (OpCodes.Div, "/"); | ||
5334 | public static readonly MyOp Div_Un = new MyOp (OpCodes.Div_Un); | ||
5335 | public static readonly MyOp Rem = new MyOp (OpCodes.Rem, "%"); | ||
5336 | public static readonly MyOp Rem_Un = new MyOp (OpCodes.Rem_Un); | ||
5337 | public static readonly MyOp And = new MyOp (OpCodes.And, "&"); | ||
5338 | public static readonly MyOp Or = new MyOp (OpCodes.Or, "|"); | ||
5339 | public static readonly MyOp Xor = new MyOp (OpCodes.Xor, "^"); | ||
5340 | public static readonly MyOp Shl = new MyOp (OpCodes.Shl, "<<"); | ||
5341 | public static readonly MyOp Shr = new MyOp (OpCodes.Shr, ">>"); | ||
5342 | public static readonly MyOp Shr_Un = new MyOp (OpCodes.Shr_Un); | ||
5343 | public static readonly MyOp Neg = new MyOp (OpCodes.Neg, "-"); | ||
5344 | public static readonly MyOp Not = new MyOp (OpCodes.Not, "~"); | ||
5345 | public static readonly MyOp Conv_I1 = new MyOp (OpCodes.Conv_I1); | ||
5346 | public static readonly MyOp Conv_I2 = new MyOp (OpCodes.Conv_I2); | ||
5347 | public static readonly MyOp Conv_I4 = new MyOp (OpCodes.Conv_I4); | ||
5348 | public static readonly MyOp Conv_I8 = new MyOp (OpCodes.Conv_I8); | ||
5349 | public static readonly MyOp Conv_R4 = new MyOp (OpCodes.Conv_R4); | ||
5350 | public static readonly MyOp Conv_R8 = new MyOp (OpCodes.Conv_R8); | ||
5351 | public static readonly MyOp Conv_U4 = new MyOp (OpCodes.Conv_U4); | ||
5352 | public static readonly MyOp Conv_U8 = new MyOp (OpCodes.Conv_U8); | ||
5353 | public static readonly MyOp Callvirt = new MyOp (OpCodes.Callvirt); | ||
5354 | public static readonly MyOp Cpobj = new MyOp (OpCodes.Cpobj); | ||
5355 | public static readonly MyOp Ldobj = new MyOp (OpCodes.Ldobj); | ||
5356 | public static readonly MyOp Ldstr = new MyOp (OpCodes.Ldstr); | ||
5357 | public static readonly MyOp Newobj = new MyOp (OpCodes.Newobj); | ||
5358 | public static readonly MyOp Castclass = new MyOp (OpCodes.Castclass); | ||
5359 | public static readonly MyOp Isinst = new MyOp (OpCodes.Isinst); | ||
5360 | public static readonly MyOp Conv_R_Un = new MyOp (OpCodes.Conv_R_Un); | ||
5361 | public static readonly MyOp Unbox = new MyOp (OpCodes.Unbox); | ||
5362 | public static readonly MyOp Throw = new MyOp (OpCodes.Throw); | ||
5363 | public static readonly MyOp Ldfld = new MyOp (OpCodes.Ldfld); | ||
5364 | public static readonly MyOp Ldflda = new MyOp (OpCodes.Ldflda); | ||
5365 | public static readonly MyOp Stfld = new MyOp (OpCodes.Stfld); | ||
5366 | public static readonly MyOp Ldsfld = new MyOp (OpCodes.Ldsfld); | ||
5367 | public static readonly MyOp Ldsflda = new MyOp (OpCodes.Ldsflda); | ||
5368 | public static readonly MyOp Stsfld = new MyOp (OpCodes.Stsfld); | ||
5369 | public static readonly MyOp Stobj = new MyOp (OpCodes.Stobj); | ||
5370 | public static readonly MyOp Conv_Ovf_I1_Un = new MyOp (OpCodes.Conv_Ovf_I1_Un); | ||
5371 | public static readonly MyOp Conv_Ovf_I2_Un = new MyOp (OpCodes.Conv_Ovf_I2_Un); | ||
5372 | public static readonly MyOp Conv_Ovf_I4_Un = new MyOp (OpCodes.Conv_Ovf_I4_Un); | ||
5373 | public static readonly MyOp Conv_Ovf_I8_Un = new MyOp (OpCodes.Conv_Ovf_I8_Un); | ||
5374 | public static readonly MyOp Conv_Ovf_U1_Un = new MyOp (OpCodes.Conv_Ovf_U1_Un); | ||
5375 | public static readonly MyOp Conv_Ovf_U2_Un = new MyOp (OpCodes.Conv_Ovf_U2_Un); | ||
5376 | public static readonly MyOp Conv_Ovf_U4_Un = new MyOp (OpCodes.Conv_Ovf_U4_Un); | ||
5377 | public static readonly MyOp Conv_Ovf_U8_Un = new MyOp (OpCodes.Conv_Ovf_U8_Un); | ||
5378 | public static readonly MyOp Conv_Ovf_I_Un = new MyOp (OpCodes.Conv_Ovf_I_Un); | ||
5379 | public static readonly MyOp Conv_Ovf_U_Un = new MyOp (OpCodes.Conv_Ovf_U_Un); | ||
5380 | public static readonly MyOp Box = new MyOp (OpCodes.Box); | ||
5381 | public static readonly MyOp Newarr = new MyOp (OpCodes.Newarr); | ||
5382 | public static readonly MyOp Ldlen = new MyOp (OpCodes.Ldlen); | ||
5383 | public static readonly MyOp Ldelema = new MyOp (OpCodes.Ldelema); | ||
5384 | public static readonly MyOp Ldelem_I1 = new MyOp (OpCodes.Ldelem_I1); | ||
5385 | public static readonly MyOp Ldelem_U1 = new MyOp (OpCodes.Ldelem_U1); | ||
5386 | public static readonly MyOp Ldelem_I2 = new MyOp (OpCodes.Ldelem_I2); | ||
5387 | public static readonly MyOp Ldelem_U2 = new MyOp (OpCodes.Ldelem_U2); | ||
5388 | public static readonly MyOp Ldelem_I4 = new MyOp (OpCodes.Ldelem_I4); | ||
5389 | public static readonly MyOp Ldelem_U4 = new MyOp (OpCodes.Ldelem_U4); | ||
5390 | public static readonly MyOp Ldelem_I8 = new MyOp (OpCodes.Ldelem_I8); | ||
5391 | public static readonly MyOp Ldelem_I = new MyOp (OpCodes.Ldelem_I); | ||
5392 | public static readonly MyOp Ldelem_R4 = new MyOp (OpCodes.Ldelem_R4); | ||
5393 | public static readonly MyOp Ldelem_R8 = new MyOp (OpCodes.Ldelem_R8); | ||
5394 | public static readonly MyOp Ldelem_Ref = new MyOp (OpCodes.Ldelem_Ref); | ||
5395 | public static readonly MyOp Stelem_I = new MyOp (OpCodes.Stelem_I); | ||
5396 | public static readonly MyOp Stelem_I1 = new MyOp (OpCodes.Stelem_I1); | ||
5397 | public static readonly MyOp Stelem_I2 = new MyOp (OpCodes.Stelem_I2); | ||
5398 | public static readonly MyOp Stelem_I4 = new MyOp (OpCodes.Stelem_I4); | ||
5399 | public static readonly MyOp Stelem_I8 = new MyOp (OpCodes.Stelem_I8); | ||
5400 | public static readonly MyOp Stelem_R4 = new MyOp (OpCodes.Stelem_R4); | ||
5401 | public static readonly MyOp Stelem_R8 = new MyOp (OpCodes.Stelem_R8); | ||
5402 | public static readonly MyOp Stelem_Ref = new MyOp (OpCodes.Stelem_Ref); | ||
5403 | public static readonly MyOp Ldelem = new MyOp (OpCodes.Ldelem); | ||
5404 | public static readonly MyOp Stelem = new MyOp (OpCodes.Stelem); | ||
5405 | public static readonly MyOp Unbox_Any = new MyOp (OpCodes.Unbox_Any); | ||
5406 | public static readonly MyOp Conv_Ovf_I1 = new MyOp (OpCodes.Conv_Ovf_I1); | ||
5407 | public static readonly MyOp Conv_Ovf_U1 = new MyOp (OpCodes.Conv_Ovf_U1); | ||
5408 | public static readonly MyOp Conv_Ovf_I2 = new MyOp (OpCodes.Conv_Ovf_I2); | ||
5409 | public static readonly MyOp Conv_Ovf_U2 = new MyOp (OpCodes.Conv_Ovf_U2); | ||
5410 | public static readonly MyOp Conv_Ovf_I4 = new MyOp (OpCodes.Conv_Ovf_I4); | ||
5411 | public static readonly MyOp Conv_Ovf_U4 = new MyOp (OpCodes.Conv_Ovf_U4); | ||
5412 | public static readonly MyOp Conv_Ovf_I8 = new MyOp (OpCodes.Conv_Ovf_I8); | ||
5413 | public static readonly MyOp Conv_Ovf_U8 = new MyOp (OpCodes.Conv_Ovf_U8); | ||
5414 | public static readonly MyOp Refanyval = new MyOp (OpCodes.Refanyval); | ||
5415 | public static readonly MyOp Ckfinite = new MyOp (OpCodes.Ckfinite); | ||
5416 | public static readonly MyOp Mkrefany = new MyOp (OpCodes.Mkrefany); | ||
5417 | public static readonly MyOp Ldtoken = new MyOp (OpCodes.Ldtoken); | ||
5418 | public static readonly MyOp Conv_U2 = new MyOp (OpCodes.Conv_U2); | ||
5419 | public static readonly MyOp Conv_U1 = new MyOp (OpCodes.Conv_U1); | ||
5420 | public static readonly MyOp Conv_I = new MyOp (OpCodes.Conv_I); | ||
5421 | public static readonly MyOp Conv_Ovf_I = new MyOp (OpCodes.Conv_Ovf_I); | ||
5422 | public static readonly MyOp Conv_Ovf_U = new MyOp (OpCodes.Conv_Ovf_U); | ||
5423 | public static readonly MyOp Add_Ovf = new MyOp (OpCodes.Add_Ovf); | ||
5424 | public static readonly MyOp Add_Ovf_Un = new MyOp (OpCodes.Add_Ovf_Un); | ||
5425 | public static readonly MyOp Mul_Ovf = new MyOp (OpCodes.Mul_Ovf); | ||
5426 | public static readonly MyOp Mul_Ovf_Un = new MyOp (OpCodes.Mul_Ovf_Un); | ||
5427 | public static readonly MyOp Sub_Ovf = new MyOp (OpCodes.Sub_Ovf); | ||
5428 | public static readonly MyOp Sub_Ovf_Un = new MyOp (OpCodes.Sub_Ovf_Un); | ||
5429 | public static readonly MyOp Endfinally = new MyOp (OpCodes.Endfinally); | ||
5430 | public static readonly MyOp Leave = new MyOp (OpCodes.Leave); | ||
5431 | public static readonly MyOp Leave_S = new MyOp (OpCodes.Leave_S); | ||
5432 | public static readonly MyOp Stind_I = new MyOp (OpCodes.Stind_I); | ||
5433 | public static readonly MyOp Conv_U = new MyOp (OpCodes.Conv_U); | ||
5434 | public static readonly MyOp Prefix7 = new MyOp (OpCodes.Prefix7); | ||
5435 | public static readonly MyOp Prefix6 = new MyOp (OpCodes.Prefix6); | ||
5436 | public static readonly MyOp Prefix5 = new MyOp (OpCodes.Prefix5); | ||
5437 | public static readonly MyOp Prefix4 = new MyOp (OpCodes.Prefix4); | ||
5438 | public static readonly MyOp Prefix3 = new MyOp (OpCodes.Prefix3); | ||
5439 | public static readonly MyOp Prefix2 = new MyOp (OpCodes.Prefix2); | ||
5440 | public static readonly MyOp Prefix1 = new MyOp (OpCodes.Prefix1); | ||
5441 | public static readonly MyOp Prefixref = new MyOp (OpCodes.Prefixref); | ||
5442 | public static readonly MyOp Arglist = new MyOp (OpCodes.Arglist); | ||
5443 | public static readonly MyOp Ceq = new MyOp (OpCodes.Ceq, "=="); | ||
5444 | public static readonly MyOp Cgt = new MyOp (OpCodes.Cgt, ">"); | ||
5445 | public static readonly MyOp Cgt_Un = new MyOp (OpCodes.Cgt_Un); | ||
5446 | public static readonly MyOp Clt = new MyOp (OpCodes.Clt, "<"); | ||
5447 | public static readonly MyOp Clt_Un = new MyOp (OpCodes.Clt_Un); | ||
5448 | public static readonly MyOp Ldftn = new MyOp (OpCodes.Ldftn); | ||
5449 | public static readonly MyOp Ldvirtftn = new MyOp (OpCodes.Ldvirtftn); | ||
5450 | public static readonly MyOp Ldarg = new MyOp (OpCodes.Ldarg); | ||
5451 | public static readonly MyOp Ldarga = new MyOp (OpCodes.Ldarga); | ||
5452 | public static readonly MyOp Starg = new MyOp (OpCodes.Starg); | ||
5453 | public static readonly MyOp Ldloc = new MyOp (OpCodes.Ldloc); | ||
5454 | public static readonly MyOp Ldloca = new MyOp (OpCodes.Ldloca); | ||
5455 | public static readonly MyOp Stloc = new MyOp (OpCodes.Stloc); | ||
5456 | public static readonly MyOp Localloc = new MyOp (OpCodes.Localloc); | ||
5457 | public static readonly MyOp Endfilter = new MyOp (OpCodes.Endfilter); | ||
5458 | public static readonly MyOp Unaligned = new MyOp (OpCodes.Unaligned); | ||
5459 | public static readonly MyOp Volatile = new MyOp (OpCodes.Volatile); | ||
5460 | public static readonly MyOp Tailcall = new MyOp (OpCodes.Tailcall); | ||
5461 | public static readonly MyOp Initobj = new MyOp (OpCodes.Initobj); | ||
5462 | public static readonly MyOp Constrained = new MyOp (OpCodes.Constrained); | ||
5463 | public static readonly MyOp Cpblk = new MyOp (OpCodes.Cpblk); | ||
5464 | public static readonly MyOp Initblk = new MyOp (OpCodes.Initblk); | ||
5465 | public static readonly MyOp Rethrow = new MyOp (OpCodes.Rethrow); | ||
5466 | public static readonly MyOp Sizeof = new MyOp (OpCodes.Sizeof); | ||
5467 | public static readonly MyOp Refanytype = new MyOp (OpCodes.Refanytype); | ||
5468 | public static readonly MyOp Readonly = new MyOp (OpCodes.Readonly); | ||
5469 | |||
5470 | // used internally | ||
5471 | public static readonly MyOp Cge = new MyOp ("cge", ">="); | ||
5472 | public static readonly MyOp Cle = new MyOp ("cle", "<="); | ||
5473 | public static readonly MyOp Cne = new MyOp ("cne", "!="); | ||
5474 | } | ||
5475 | } | ||
5476 | } | ||