public TableSet(int line, Expression table, Expression index, Expression @value, bool isTable, int timestamp) : base(line) { this.table = table; this.index = index; this.value = @value; this.isTable = isTable; this.timestamp = timestamp; }
public TableSet(int line, Expression table, Expression index, Expression @value, bool isTable, int timestamp) : base(line) { this.table = table; this.index = index; this.value = @value; this.isTable = isTable; this.timestamp = timestamp; }
public RegisterSet(int line, int register, Expression @value) : base(line) { this.register = register; this.value = @value; // // if(value.isMultiple()) { // System.out.println("-- multiple @" + register); // } // }
public RegisterSet(int line, int register, Expression @value) : base(line) { this.register = register; this.value = @value; // // if(value.isMultiple()) { // System.out.println("-- multiple @" + register); // } // }
public virtual void addLast(Target target, Expression @value) { if(targets.Contains(target)) { int index = targets.IndexOf(target); targets.RemoveAt(index); @value = values[index]; values.RemoveAt(index); } targets.Add(target); values.Add(@value); allnil = allnil && @value.isNil(); }
public override Expression asExpression(Registers r) { bool transpose = false; Expression leftExpression = r.getKExpression(left, line); Expression rightExpression = r.getKExpression(right, line); if (((left | right) & 256) == 0) { transpose = r.getUpdated(left, line) > r.getUpdated(right, line); } else { transpose = rightExpression.getConstantIndex() < leftExpression.getConstantIndex(); } string op = !transpose ? "<=" : ">="; Expression rtn = new BinaryExpression(op, !transpose ? leftExpression : rightExpression, !transpose ? rightExpression : leftExpression, Expression.PRECEDENCE_COMPARE, Expression.ASSOCIATIVITY_LEFT); if (_invert) { rtn = new UnaryExpression("not ", rtn, Expression.PRECEDENCE_UNARY); } return(rtn); }
public UpvalueSet(int line, string upvalue, Expression @value) : base(line) { target = new UpvalueTarget(upvalue); this.value = @value; }
public virtual void setValue(int register, int line, Expression expression) { values[register,line] = expression; updated[register,line] = line; }
public IfThenEndBlockOperation(int line, Assignment _assign, Expression _expr) : base(line) { assign = _assign; expr = _expr; }
public ReturnOperation(int line, Expression[] values) : base(line) { this.values = values; }
public TableTarget(Expression table, Expression index) { this.table = table; this.index = index; }
abstract public void useExpression(Expression expression);
public TableTarget(Expression table, Expression index) { this.table = table; this.index = index; }
public override void useExpression(Expression expression) { left.useExpression(expression); right.useExpression(expression); }
public UpvalueSet(int line, string upvalue, Expression @value) : base(line) { target = new UpvalueTarget(upvalue); this.value = @value; }
public virtual void addFirst(Target target, Expression @value) { targets.Insert(0, target); values.Insert(0, @value); allnil = allnil && @value.isNil(); }
public Assignment(Target target, Expression @value) { targets.Add(target); values.Add(@value); allnil = allnil && @value.isNil(); }
public ReturnOperation(int line, Expression @value) : base(line) { values = new Expression[1]; values[0] = @value; }
public SetBlockOperation(int line, Target target, Expression value) : base(line) { _target = target; _value = value; }
public override void useExpression(Expression expression) { // Do nothing }
public abstract void useExpression(Expression expression);
public GlobalSet(int line, string global, Expression @value) : base(line) { this.global = global; this.value = @value; }
public ReturnOperation(int line, Expression @value) : base(line) { values = new Expression[1]; values[0] = @value; }
public override void useExpression(Expression expression) { left.useExpression(expression); right.useExpression(expression); }
private List<Operation> processLine(int line) { List<Operation> operations = new List<Operation>(); int A = code.A(line); int B = code.B(line); int C = code.C(line); int Bx = code.Bx(line); switch(code.op(line)) { case Op.MOVE: operations.Add(new RegisterSet(line, A, r.getExpression(B, line))); break; case Op.LOADK: operations.Add(new RegisterSet(line, A, f.getConstantExpression(Bx))); break; case Op.LOADBOOL: operations.Add(new RegisterSet(line, A, new ConstantExpression(new Constant(B != 0 ? LBoolean.LTRUE : LBoolean.LFALSE), -1))); break; case Op.LOADNIL: { int maximum; if(function.header.version.usesOldLoadNilEncoding()) { maximum = B; } else { maximum = A + B; } while(A <= maximum) { operations.Add(new RegisterSet(line, A, Expression.NIL)); A++; } break; } //JAVA TO VB & C# CONVERTER TODO TASK: C# does not allow fall-through from a non-empty 'case': case Op.GETUPVAL: operations.Add(new RegisterSet(line, A, upvalues.getExpression(B))); break; case Op.GETTABUP: if(B == 0 && (C & 0x100) != 0) { operations.Add(new RegisterSet(line, A, f.getGlobalExpression(C & 0xFF))); //TODO: check } else { operations.Add(new RegisterSet(line, A, new TableReference(upvalues.getExpression(B), r.getKExpression(C, line)))); } break; case Op.GETGLOBAL: operations.Add(new RegisterSet(line, A, f.getGlobalExpression(Bx))); break; case Op.GETTABLE: operations.Add(new RegisterSet(line, A, new TableReference(r.getExpression(B, line), r.getKExpression(C, line)))); break; case Op.SETUPVAL: operations.Add(new UpvalueSet(line, upvalues.getName(B), r.getExpression(A, line))); break; case Op.SETTABUP: if(A == 0 && (B & 0x100) != 0) { operations.Add(new GlobalSet(line, f.getGlobalName(B & 0xFF), r.getKExpression(C, line))); //TODO: check } else { operations.Add(new TableSet(line, upvalues.getExpression(A), r.getKExpression(B, line), r.getKExpression(C, line), true, line)); } break; case Op.SETGLOBAL: operations.Add(new GlobalSet(line, f.getGlobalName(Bx), r.getExpression(A, line))); break; case Op.SETTABLE: operations.Add(new TableSet(line, r.getExpression(A, line), r.getKExpression(B, line), r.getKExpression(C, line), true, line)); break; case Op.NEWTABLE: operations.Add(new RegisterSet(line, A, new TableLiteral(B, C))); break; case Op.SELF: { // We can later determine is : syntax was used by comparing subexpressions with == Expression common = r.getExpression(B, line); operations.Add(new RegisterSet(line, A + 1, common)); operations.Add(new RegisterSet(line, A, new TableReference(common, r.getKExpression(C, line)))); break; } //JAVA TO VB & C# CONVERTER TODO TASK: C# does not allow fall-through from a non-empty 'case': case Op.ADD: operations.Add(new RegisterSet(line, A, Expression.makeADD(r.getKExpression(B, line), r.getKExpression(C, line)))); break; case Op.SUB: operations.Add(new RegisterSet(line, A, Expression.makeSUB(r.getKExpression(B, line), r.getKExpression(C, line)))); break; case Op.MUL: operations.Add(new RegisterSet(line, A, Expression.makeMUL(r.getKExpression(B, line), r.getKExpression(C, line)))); break; case Op.DIV: operations.Add(new RegisterSet(line, A, Expression.makeDIV(r.getKExpression(B, line), r.getKExpression(C, line)))); break; case Op.MOD: operations.Add(new RegisterSet(line, A, Expression.makeMOD(r.getKExpression(B, line), r.getKExpression(C, line)))); break; case Op.POW: operations.Add(new RegisterSet(line, A, Expression.makePOW(r.getKExpression(B, line), r.getKExpression(C, line)))); break; case Op.UNM: operations.Add(new RegisterSet(line, A, Expression.makeUNM(r.getExpression(B, line)))); break; case Op.NOT: operations.Add(new RegisterSet(line, A, Expression.makeNOT(r.getExpression(B, line)))); break; case Op.LEN: operations.Add(new RegisterSet(line, A, Expression.makeLEN(r.getExpression(B, line)))); break; case Op.CONCAT: Expression @value1 = r.getExpression(C, line); //Remember that CONCAT is right associative. while(C-- > B) { @value1 = Expression.makeCONCAT(r.getExpression(C, line), @value1); } operations.Add(new RegisterSet(line, A, @value1)); break; //JAVA TO VB & C# CONVERTER TODO TASK: C# does not allow fall-through from a non-empty 'case': case Op.JMP: case Op.EQ: case Op.LT: case Op.LE: case Op.TEST: case Op.TESTSET: // Do nothing... handled with branches break; case Op.CALL: { bool multiple = (C >= 3 || C == 0); if(B == 0) B = registers - A; if(C == 0) C = registers - A + 1; Expression function2 = r.getExpression(A, line); Expression[] arguments = new Expression[B - 1]; for(int register = A + 1; register <= A + B - 1; register++) { arguments[register - A - 1] = r.getExpression(register, line); } FunctionCall @value = new FunctionCall(function2, arguments, multiple); if(C == 1) { operations.Add(new CallOperation(line, @value)); } else { if(C == 2 && !multiple) { operations.Add(new RegisterSet(line, A, @value)); } else { for(int register = A; register <= A + C - 2; register++) { operations.Add(new RegisterSet(line, register, @value)); } } } break; } //JAVA TO VB & C# CONVERTER TODO TASK: C# does not allow fall-through from a non-empty 'case': case Op.TAILCALL: { if(B == 0) B = registers - A; Expression function1 = r.getExpression(A, line); Expression[] arguments = new Expression[B - 1]; for(int register = A + 1; register <= A + B - 1; register++) { arguments[register - A - 1] = r.getExpression(register, line); } FunctionCall @value2 = new FunctionCall(function1, arguments, true); operations.Add(new ReturnOperation(line, @value2)); skip[line + 1] = true; break; } //JAVA TO VB & C# CONVERTER TODO TASK: C# does not allow fall-through from a non-empty 'case': case Op.RETURN: { if(B == 0) B = registers - A + 1; Expression[] values = new Expression[B - 1]; for(int register = A; register <= A + B - 2; register++) { values[register - A] = r.getExpression(register, line); } operations.Add(new ReturnOperation(line, values)); break; } //JAVA TO VB & C# CONVERTER TODO TASK: C# does not allow fall-through from a non-empty 'case': case Op.FORLOOP: case Op.FORPREP: case Op.TFORCALL: case Op.TFORLOOP: // Do nothing... handled with branches break; case Op.SETLIST: if(C == 0) { C = code.codepoint(line + 1); skip[line + 1] = true; } if(B == 0) { B = registers - A - 1; } Expression table = r.getValue(A, line); for(int i = 1; i <= B; i++) { operations.Add(new TableSet(line, table, new ConstantExpression(new Constant((C - 1) * 50 + i), -1), r.getExpression(A + i, line), false, r.getUpdated(A + i, line))); } break; //JAVA TO VB & C# CONVERTER TODO TASK: C# does not allow fall-through from a non-empty 'case': case Op.CLOSE: break; case Op.CLOSURE: LFunction f2 = functions[Bx]; operations.Add(new RegisterSet(line, A, new ClosureExpression(f2, declList, line + 1))); if(function.header.version.usesInlineUpvalueDeclarations()) { // Skip upvalue declarations for(int i = 0; i < f2.numUpvalues; i++) { skip[line + 1 + i] = true; } } break; //JAVA TO VB & C# CONVERTER TODO TASK: C# does not allow fall-through from a non-empty 'case': case Op.VARARG: bool multiple1 = (B != 2); if(B == 1) throw new Exception(); if(B == 0) B = registers - A + 1; Expression @value3 = new Vararg(B - 1, multiple1); for(int register = A; register <= A + B - 2; register++) { operations.Add(new RegisterSet(line, register, @value3)); } break; //JAVA TO VB & C# CONVERTER TODO TASK: C# does not allow fall-through from a non-empty 'case': default: throw new Exception("Illegal instruction: " + code.op(line)); } return operations; }
public override void useExpression(Expression expression) { // Do nothing }
public GlobalSet(int line, string global, Expression @value) : base(line) { this.global = global; this.value = @value; }