示例#1
0
 protected void OnLog(string sMsg)
 {
     DebugPrint?.Invoke(sMsg);
 }
        private void Interpret()
        {
            object[] operation;
            object   akkumulator;
            object   register;

            scopes = new Scopes();
            scopes.PushScope(external);
            scopes.PushScope();

            int startTime = Environment.TickCount;

            Cancel  = false;
            running = true;

            pc = 0;

            bool accepted;
            // bool continues;
            object xPos;
            object defaultRenamed;
            object yPos;


            while ((pc < code.Count - 1) & running)
            {
                akkumulator = null;
                register    = null;

                operation = (Object[])code[pc];

                switch ((Opcodes)operation.GetValue(0))
                {
                // Konstante allozieren
                case Opcodes.opAllocConst:
                {
                    // Parameter:    Name der Konstanten; Wert
                    scopes.Allocate(operation.GetValue(1).ToString(), operation.GetValue(2).ToString(), Identifier.IdentifierTypes.idConst);
                    break;
                }

                // Variable allozieren
                case Opcodes.opAllocVar:
                {
                    // Parameter:    Name der Variablen
                    scopes.Allocate(operation.GetValue(1).ToString());
                    break;
                }

                // Wert auf den Stack schieben
                case Opcodes.opPushValue:
                {
                    // Parameter:    Wert
                    scopes.Push(operation.GetValue(1));
                    break;
                }

                // Wert einer Variablen auf den Stack schieben
                case Opcodes.opPushVariable:
                {
                    // Parameter:    Variablenname
                    string name;
                    try
                    {
                        var tmp = operation.GetValue(1);
                        if (tmp.GetType() == typeof(Identifier))
                        {
                            name = ((Identifier)tmp).value.ToString();
                        }
                        else
                        {
                            name = tmp.ToString();
                        }
                        register = scopes.Retrieve(name);
                    }
                    catch (Exception)
                    {
                        // Variable nicht alloziert, also bei Host nachfragen
                        accepted = false;
                        Retrieve?.Invoke(operation.GetValue(1).ToString(), register.ToString(), accepted);
                        if (!accepted)
                        {
                            // der Host weiss nichts von der Var. Implizit anlegen tun wir
                            // sie aber nicht, da sie hier auf sie sofort lesend zugegriffen
                            // würde

                            running = false;
                            ErrorObject.Raise((int)InterpreterError.runErrors.errUnknownVar, "Code.Run", "Unknown variable '" + operation.GetValue(1) + "'", 0, 0, 0);
                        }
                    }

                    if (register == null)
                    {
                        running = false;
                        ErrorObject.Raise((int)InterpreterError.runErrors.errUninitializedVar, "Code.Run", "Variable '" + operation.GetValue(1) + "' not hasn´t been assigned a Value yet", 0, 0, 0);
                    }
                    else
                    {
                        if (register.GetType() == typeof(Identifier))
                        {
                            scopes.Push(((Identifier)register).value);
                        }
                        else
                        {
                            scopes.Push(register.ToString());
                        }
                    }

                    break;
                }

                // entfernt obersten Wert vom Stack
                case Opcodes.opPop:
                {
                    scopes.PopScopes();
                    break;
                }

                // legt den n-ten Stackwert zuoberst auf den Stack
                case Opcodes.opPopWithIndex:
                {
                    // Parameter:    Index in den Stack (von oben an gezählt: 0..n)
                    object result;
                    register = scopes.Pop(Convert.ToInt32(operation.GetValue(1)));
                    if (register is Identifier)
                    {
                        result = ((Identifier)register).value;
                    }
                    else
                    {
                        result = register;
                    }
                    scopes.Push(result);
                    break;
                }

                // Wert auf dem Stack einer Variablen zuweisen
                case Opcodes.opAssign:
                {
                    // Parameter:    Variablenname
                    // Stack:        der zuzuweisende Wert

                    object result;
                    register = scopes.Pop();
                    if (register is Identifier)
                    {
                        result = ((Identifier)register).value;
                    }
                    else
                    {
                        result = register;
                    }
                    if (!scopes.Assign(operation.GetValue(1).ToString(), result))
                    {
                        ;
                    }
                    {
                        // Variable nicht alloziert, also Host anbieten
                        accepted = false;


                        Assign?.Invoke(operation.GetValue(1).ToString(), result.ToString(), ref accepted);
                        if (!accepted)
                        {
                            // Host hat nicht mit Var am Hut, dann legen wir
                            // sie eben selbst an
                            scopes.Allocate(operation.GetValue(1).ToString(), result.ToString());
                        }
                    }

                    break;
                }

                case Opcodes.opAdd:
                case Opcodes.opSub:
                case Opcodes.opMultiplication:
                case Opcodes.opDivision:
                case Opcodes.opDiv:
                case Opcodes.opMod:
                case Opcodes.opPower:
                case Opcodes.opStringConcat:
                case Opcodes.opOr:
                case Opcodes.opAnd:
                case Opcodes.opEq:
                case Opcodes.opNotEq:
                case Opcodes.oplt:
                case Opcodes.opLEq:
                case Opcodes.opGt:
                case Opcodes.opGEq:
                    BinaryMathOperators(operation, akkumulator, register);
                    break;

                case Opcodes.opNegate:
                case Opcodes.opNot:
                case Opcodes.opFactorial:
                case Opcodes.opSin:
                case Opcodes.opCos:
                case Opcodes.opTan:
                case Opcodes.opATan:
                    UnaryMathOperators(operation);
                    break;

                case Opcodes.opDebugPrint:
                {
                    string msg = string.Empty;


                    register = scopes.PopScopes();
                    if (register != null)
                    {
                        msg = ((Identifier)register).value.ToString();
                    }

                    DebugPrint?.Invoke(msg);


                    break;
                }

                case Opcodes.opDebugClear:
                {
                    DebugClear?.Invoke();
                    break;
                }

                case Opcodes.opDebugShow:
                {
                    DebugShow?.Invoke();
                    break;
                }

                case Opcodes.opDebugHide:
                {
                    DebugHide?.Invoke();
                    break;
                }

                case Opcodes.opMessage:
                {
                    try
                    {
                        string msg  = string.Empty;
                        int    type = 0;
                        register    = scopes.PopScopes();       // Message
                        akkumulator = scopes.PopScopes().value; // Type
                        if (register is Identifier)
                        {
                            if (register != null)
                            {
                                if (register.GetType() == typeof(Identifier))
                                {
                                    msg = ((Identifier)register).value.ToString();
                                }
                                else
                                {
                                    msg = register.ToString();
                                }
                            }
                        }


                        if (akkumulator != null)
                        {
                            if (akkumulator.GetType() == typeof(Identifier))
                            {
                                type = Convert.ToInt32(((Identifier)akkumulator).value);
                            }
                            else
                            {
                                type = Convert.ToInt32(akkumulator);
                            }
                        }


                        Message?.Invoke(type, msg);
                    }
                    catch (Exception)
                    {
                        Message?.Invoke(-1, string.Empty);
                    }

                    break;
                }

                case Opcodes.opMsgbox:
                {
                    if (!AllowUi)
                    {
                        running = false;
                        ErrorObject.Raise((int)InterpreterError.runErrors.errNoUIallowed, "Code.Run", "MsgBox-Statement cannot be executed when no UI-elements are allowed", 0, 0, 0);
                    }

                    register    = scopes.PopScopes().value; // Title
                    akkumulator = scopes.PopScopes().value; // Buttons

                    try
                    {
                        // TODO:InputBox  // scopes.Push(MsgBox(scopes.Pop, (MsgBoxStyle)Akkumulator.ToString(), Register));
                    }
                    catch (Exception ex)
                    {
                        running = false;
                        ErrorObject.Raise((int)InterpreterError.runErrors.errMath, "Code.Run", "Error during MsgBox-call: " + ex.HResult + " (" + ex.Message + ")", 0, 0, 0);
                    }

                    break;
                }

                case Opcodes.opDoEvents:
                {
                    break;
                }

                case Opcodes.opInputbox:
                {
                    if (!AllowUi)
                    {
                        running = false;
                        ErrorObject.Raise((int)InterpreterError.runErrors.errNoUIallowed, "Code.Run", "Inputbox-Statement cannot be executed when no UI-elements are allowed", 0, 0, 0);
                    }

                    yPos           = scopes.PopScopes().value;
                    xPos           = scopes.PopScopes().value;
                    defaultRenamed = scopes.PopScopes().value;
                    register       = scopes.PopScopes().value;
                    akkumulator    = scopes.PopScopes().value;

                    try
                    {
                        // TODO:InputBox
                        //string Anwert = Microsoft.VisualBasic.Interaction.InputBox(Akkumulator.ToString(), Register.ToString(), defaultRenamed.ToString(), Convert.ToInt32(xPos), Convert.ToInt32(yPos));
                        //scopes.Push(Anwert);
                    }
                    catch (Exception ex)
                    {
                        running = false;
                        ErrorObject.Raise((int)InterpreterError.runErrors.errMath, "Code.Run", "Error during MsgBox-call: " + ex.HResult + " (" + ex.Message + ")", 0, 0, 0);
                    }

                    break;
                }

                case Opcodes.opJump:
                {
                    pc = Convert.ToInt32(operation.GetValue(1)) - 1;
                    break;
                }

                case Opcodes.opJumpTrue:
                {
                    akkumulator = scopes.PopScopes().value;
                    if (Convert.ToBoolean(akkumulator))
                    {
                        pc = Convert.ToInt32(operation.GetValue(1)) - 1;
                    }
                    break;
                }

                case Opcodes.opJumpFalse:
                {
                    akkumulator = scopes.PopScopes().value;
                    if (!Convert.ToBoolean(akkumulator))
                    {
                        pc = Convert.ToInt32(operation.GetValue(1)) - 1;
                    }
                    break;
                }

                case Opcodes.opJumpPop:
                {
                    pc = Convert.ToInt32(scopes.PopScopes().value) - 1;
                    break;
                }

                case Opcodes.opPushScope:
                {
                    scopes.PushScope();
                    break;
                }

                case Opcodes.opPopScope:
                {
                    scopes.PopScopes();
                    break;
                }

                case Opcodes.opCall:
                {
                    scopes.Allocate("~RETURNADDR", (pc + 1).ToString(), Identifier.IdentifierTypes.idConst);
                    pc = Convert.ToInt32(operation.GetValue(1)) - 1;
                    break;
                }

                case Opcodes.opReturn:
                {
                    pc = Convert.ToInt32(Convert.ToDouble(scopes.Retrieve("~RETURNADDR").value, CultureInfo.InvariantCulture) - 1);
                    break;
                }
                }


                pc = pc + 1; // zum nächsten Befehl

                // wurde Interpretation unterbrochen?
                if (Cancel)
                {
                    running = false;
                    ErrorObject.Raise((int)InterpreterError.runErrors.errCancelled, "Code.Run", "Code execution aborted", 0, 0, 0);
                }

                // Timeout erreicht?
                var tickPassed = (Environment.TickCount - startTime);
                if (CodeTimeout > 0 && tickPassed >= CodeTimeout)
                {
                    running = false;
                    ErrorObject.Raise((int)InterpreterError.runErrors.errTimedOut, "Code.Run", "Timeout reached: code execution has been aborted", 0, 0, 0);
                }
            }

            running = false;
        }
 private void OnDebugPrint(string s)
 {
     DebugPrint?.Invoke(this, s);
 }