예제 #1
0
        public static void DataBind(this Motor engine, Route route)
        {
            var list = new Dictionary<string, object>();

            var function = engine.RuntimeContext.Runnable.FunctionTable[route.Action];

            var instructions = engine.RuntimeContext.Runnable.Instructions;

            for (int i = function.EntryPoint; i < instructions.Length; i++)
            {
                var inst = instructions[i];

                if (inst.OpCode == OpCode.DCL)
                {
                    var value = route.Context.Request[inst.Operands[0].Value.ToString()] ?? string.Empty;

                    list.Add(inst.Operands[0].Value.ToString(), value);
                }

                if (inst.OpCode == OpCode.EMP) break;
            }

            foreach (var keypar in list.Reverse())
            {
                var op = new Operand(OperandType.Literal, keypar.Value);

                engine.RuntimeContext.Runnable.ParamStack.Push(op);
            }
        }
예제 #2
0
        public OperandResolver In(Operand operand)
        {
            target = operand;

            if (target.Value != null)
                targetName = target.Value.ToString();

            return this;
        }
예제 #3
0
        public void SimpleInstruction()
        {
            var op0 = new Operand(OperandType.Variable, "x", 0);
            var op1 = new Operand(OperandType.Literal, 1, 0);

            var inst = new Instruction(OpCode.MOV, 1, op0, op1);
            var inst2 = new Instruction(OpCode.MOV, 2, op0, op1);

            Assert.AreEqual("00001:", inst.IndexName);
            Assert.AreEqual("00002:", inst2.IndexName);
        }
        public void CreateStream()
        {
            var op0 = new Operand(OperandType.Literal, 1, 0);
            var op1 = new Operand(OperandType.Literal, 1, 0);

            var runtimeStream = new InstrucStream(
                new Instruction(OpCode.ADD, 1, op0, op1),
                new Instruction(OpCode.MOV, 2, op0, op1)
                );

            Assert.AreEqual(2, runtimeStream.Size);
        }
예제 #5
0
        public Instruction[] GetInstructions2()
        {
            var list = new List<Instruction>();

            var op_name = new Operand(OperandType.Variable, "name");
            var op_name2 = new Operand(OperandType.Variable, "name2");
            var op_value = new Operand(OperandType.Literal, "Ricardo");

            list.Add(new Instruction(OpCode.DCL, 0, op_name));
            list.Add(new Instruction(OpCode.DCL, 1, op_name2));
            list.Add(new Instruction(OpCode.MOV, 2, op_name, op_value));
            list.Add(new Instruction(OpCode.MOV, 3, op_name2, op_name));
            list.Add(new Instruction(OpCode.EXIT, 4));

            return list.ToArray();
        }
예제 #6
0
 public OperandResolver At(int index)
 {
     target = context.CurrentInst.Operands[index];
     targetName = target.Value.ToString();
     return this;
 }
예제 #7
0
        private bool ProcessJump(Operand firstOp, Operand secondOp)
        {
            var fp = firstOp.Value; //float.Parse(firstOp.Value.ToString());
            var sp = secondOp.Value; // float.Parse(secondOp.Value.ToString());

            switch (Instruction.OpCode)
            {
                case OpCode.JG: if (JG(fp, sp)) return true; break;
                case OpCode.JL: if (JL(fp, sp)) return true; break;
                case OpCode.JGE: if (JGE(fp, sp)) return true; break;
                case OpCode.JLE: if (JLE(fp, sp)) return true; break;
            }

            return false;
        }
예제 #8
0
        private void ProcessPUSH()
        {
            var operand = Instruction.Operands[0];

            var @new = new Operand(OperandType.Literal, operand.Value);

            if (operand.Type == OperandType.Variable)
                @new.Value = opResolver.At(0).Value();

            if (@new.Value == null)
                new Ops().ThrowVarNonInit(operand.Value.ToString());

            context.Runnable.ParamStack.Push(@new);
        }
예제 #9
0
        private void ProcessHostedFunction(string name)
        {
            var handler = Container.ResolveHandler(name);
            var function = Container.Resolve(name);

            IList<object> parameters = new List<object>();

            foreach (Operand item in ParamStack)
            {
                if (item.Type == OperandType.Literal)
                {
                    if (item.Value != null)
                        parameters.Add(item.Value);
                }
                else
                {
                    parameters.Add(SymbolValue(item.Value.ToString()));
                }
            }

            var result = handler != null ? handler.Invoke(parameters.Reverse().ToArray()) : function.Executar(parameters.Reverse().ToArray());

            var operand = new Operand(OperandType.Literal, result);

            ParamStack.Clear();

            if (!Container.IsVoid(name))
                ParamStack.Push(operand);
        }
예제 #10
0
        private void ProcessCALL()
        {
            var name = opResolver.At(0).Name();

            if (Container.IsRegistered(name))
            {
                ProcessHostedFunction(name);
                return;
            }

            var returnInst = context.Runnable.Instructions[Instruction.Index + 1];

            var returnAddress = new Operand(OperandType.InstructionRef, returnInst);

            RuntimeStack.Push(returnAddress);

            var function = context.Runnable.RetrieveFunction(name);

            context.Runnable.IP = function.EntryPoint;

            RuntimeStack.Push(function);

            context.CurrentFunction = null;
        }
예제 #11
0
        private void ProcessArithmetic(bool stack)
        {
            float f1, f2;

            if (stack)
            {
                var op2 = ParamStack.Pop() as Operand;
                var op1 = ParamStack.Pop() as Operand;

                f1 = float.Parse(op1.Value.ToString());
                f2 = float.Parse(op2.Value.ToString());
            }
            else
            {
                Operand op = null;
                object opValue = null;

                var name = opResolver.At(0).SymbolId();

                var curValue = SymbolValue(name);

                if (Instruction.OperandCount > 1)
                    op = Instruction.Operands[1];

                if (op != null)
                    opValue = opResolver.At(1).Value();

                if (curValue == null)
                    throw new Exception("Variable was not initialized.");

                f1 = float.Parse(curValue.ToString());
                f2 = 0f;

                if (opValue != null)
                    f2 = float.Parse(opValue.ToString());
            }

            switch (context.CurrentInst.OpCode)
            {
                case OpCode.SADD:
                case OpCode.ADD: f1 += f2; break;
                case OpCode.SSUB:
                case OpCode.SUB: f1 -= f2; break;
                case OpCode.SMUL:
                case OpCode.MUL: f1 *= f2; break;
                case OpCode.SDIV:
                case OpCode.DIV: f1 /= f2; break;
                case OpCode.SMOD:
                case OpCode.MOD: f1 %= f2; break;
                case OpCode.POW: f1 = (float)Math.Pow(f1, f2); break;
                case OpCode.INC: f1++; break;
                case OpCode.DEC: f1--; break;
                case OpCode.NEG: f1 = -f1; break;
            }

            int r;

            if (stack)
            {
                var result = new Operand(OperandType.Literal, int.TryParse(f1.ToString(), out r) ? r : f1);

                ParamStack.Push(result);
            }
            else
            {
                object value = int.TryParse(f1.ToString(), out r) ? r : f1;

                SetSymbolValue(Instruction.Operands[0], value);
            }
        }
예제 #12
0
        public object SetSymbolValue(Operand target, Operand opvalue)
        {
            var id = opResolver.In(target).SymbolId();
            var name = opResolver.Name();
            var _value = opResolver.In(opvalue).Value();

            int? index = null;

            if (target.IndexOffSet != null)
                index = ResolveIndex(target.IndexOffSet);

            return SymbolTable.SetSymbolValue(name, id, context.CurrentFunction.Name, _value, index);
        }
예제 #13
0
        public object SetSymbolValue(Operand target, object value)
        {
            SetSymbolValue(target, new Operand(OperandType.Literal, value));

            return value;
        }