Ejemplo n.º 1
0
 public void AddInstruction(T1Instruction instruction)
 {
     Instructions.Add(instruction);
 }
Ejemplo n.º 2
0
        private void RunInstruction(T1Instruction instruction)
        {
            switch (instruction.Type)
            {
            // Variable table should contain scope pointer as well as variable id
            case T1InstructionType.Assignment:
                EvaluateExpression(((T1InstructionAssignment)instruction).Expression);
                if (((T1InstructionAssignment)instruction).Variable.VariableType != ExpressionType)
                {
                    throw new Exception("Runtime error: Variable type mismatch in expression");
                }

                ((T1InstructionAssignment)instruction).Variable.Scope.VariableTable[((T1InstructionAssignment)instruction).Variable.VariableId] = new T1Variable(((T1InstructionAssignment)instruction).Variable.VariableType, ExpressionResult);

                break;

            case T1InstructionType.ConditionalJump:
                EvaluateExpression(((T1InstructionConditionalJump)instruction).Expression);

                if ((int)ExpressionResult != 0)
                {
                    instructionPointer = LabelTable[((T1InstructionConditionalJump)instruction).LabelId] + 1;
                }

                break;

            case T1InstructionType.ExpressionEvaluation:
                EvaluateExpression(((T1InstructionEvaluateExpression)instruction).Expression);
                break;

            case T1InstructionType.FunctionCall:
                T1Scope newScope = (T1Scope)SubScopes[((T1InstructionFunctionCall)instruction).FunctionId];     // .Clone();
                newScope.ParentScope = this;

                // Variable assignments for arguments
                for (int i = 0; i < ((T1InstructionFunctionCall)instruction).Arguments.Count; i++)
                {
                    newScope.VariableTable[i + 1] = new T1Variable(((T1InstructionFunctionCall)instruction).Arguments[i].VariableType, ((T1InstructionFunctionCall)instruction).Arguments[i].Operand);
                }

                newScope.Run();
                break;

            case T1InstructionType.FunctionDeclaration:
                T1Scope subScope = ((T1InstructionFunctionDeclaration)instruction).FunctionScope;

                // Return value
                T1Variable returnValue = null;
                switch (((T1InstructionFunctionDeclaration)instruction).ReturnType)
                {
                case T1VariableType.Void:
                    returnValue = new T1Variable(T1VariableType.Void);
                    break;

                case T1VariableType.Byte:
                    returnValue = new T1Variable(T1VariableType.Byte);
                    break;

                case T1VariableType.Double:
                    returnValue = new T1Variable(T1VariableType.Double);
                    break;

                case T1VariableType.Int:
                    returnValue = new T1Variable(T1VariableType.Int);
                    break;

                case T1VariableType.String:
                    returnValue = new T1Variable(T1VariableType.String);
                    break;
                }

                subScope.VariableTable.Add(returnValue);

                // Arguments
                for (int i = 0; i < ((T1InstructionFunctionDeclaration)instruction).Arguments.Count; i++)
                {
                    T1Variable newArgument = null;
                    switch (((T1InstructionFunctionDeclaration)instruction).Arguments[i].VariableType)
                    {
                    case T1VariableType.Void:
                        newArgument = new T1Variable(T1VariableType.Void);
                        break;

                    case T1VariableType.Byte:
                        newArgument = new T1Variable(T1VariableType.Byte);
                        break;

                    case T1VariableType.Double:
                        newArgument = new T1Variable(T1VariableType.Double);
                        break;

                    case T1VariableType.Int:
                        newArgument = new T1Variable(T1VariableType.Int);
                        break;

                    case T1VariableType.String:
                        newArgument = new T1Variable(T1VariableType.String);
                        break;
                    }

                    subScope.VariableTable.Add(newArgument);
                }

                SubScopes.Add(subScope);
                break;

            case T1InstructionType.Import:
                break;

            case T1InstructionType.Jump:
                instructionPointer = LabelTable[((T1InstructionJump)instruction).LabelId] + 1;
                break;

            case T1InstructionType.LabelSet:
                LabelTable.Add(instructionPointer);
                break;

            case T1InstructionType.VariableDeclaration:
                T1Variable newVariable = null;

                switch (((T1InstructionVariableDeclaration)instruction).VariableType)
                {
                case T1VariableType.Void:
                    newVariable = new T1Variable(T1VariableType.Void, VariableTable.Count);
                    break;

                case T1VariableType.Byte:
                    newVariable = new T1Variable(T1VariableType.Byte, VariableTable.Count);
                    break;

                case T1VariableType.Double:
                    newVariable = new T1Variable(T1VariableType.Double, VariableTable.Count);
                    break;

                case T1VariableType.Int:
                    newVariable = new T1Variable(T1VariableType.Int, VariableTable.Count);
                    break;

                case T1VariableType.String:
                    newVariable = new T1Variable(T1VariableType.String, VariableTable.Count);
                    break;
                }

                VariableTable.Add(newVariable);
                break;

            case T1InstructionType.Return:
                instructionPointer = Instructions.Count;

                break;
            }
        }
Ejemplo n.º 3
0
        private void CompileScript()
        {
            List <string> primitiveTypes = new List <string>()
            {
                "void", "int", "string", "byte", "double"
            };
            List <string> statements = new List <string>()
            {
                "for", "if", "while", "return"
            };

            VariableTableItems = new List <T1TableItem>();
            FunctionTableItems = new List <T1TableItem>();
            T1Instruction CurrentInstruction = null;
            T1Scope       CurrentScope       = new T1Scope();

            CurrentLine  = 1;
            CurrentToken = 0;

            string token;

            while (CurrentToken < Tokens.Count)
            {
                token = GetNextToken();

                if (primitiveTypes.Contains(token))
                {
                    string typeName = token;

                    // function or variable declaration
                    string identifierName = GetNextToken();

                    // test whether identifier stands in any of the tables
                    if (TableContains(VariableTableItems, identifierName) || TableContains(FunctionTableItems, identifierName))
                    {
                        throw new Exception("Identifier redeclared: " + identifierName + " [" + CurrentLine + "]");
                    }

                    token = GetNextToken();
                    T1VariableType variableType = GetVariableTypeFromToken(token);

                    if (token == "(")
                    {
                        // this seems to be a function declaration
                        FunctionTableItems.Add(new T1TableItem(identifierName, FunctionTableItems.Count - 1, CurrentScope));

                        token = GetNextToken();
                        List <T1InstructionVariableDeclaration> arguments = new List <T1InstructionVariableDeclaration>();

                        while (token != ")")
                        {
                            if (primitiveTypes.Contains(token))
                            {
                                typeName       = token;
                                identifierName = GetNextToken();

                                arguments.Add(new T1InstructionVariableDeclaration(GetVariableTypeFromToken(typeName)));
                                if (TableContains(VariableTableItems, identifierName))
                                {
                                    throw new Exception("Argumant redeclared: " + identifierName + " [" + CurrentLine + "]");
                                }

                                token = GetNextToken();
                                if (token == ",")
                                {
                                    token = GetNextToken();
                                }
                            }

                            token = GetNextToken();
                        }

                        token = GetNextToken();
                        if (token != "{")
                        {
                            throw new Exception("{ expected [" + CurrentLine + "]");
                        }

                        T1Scope functionScope = new T1Scope();
                        AddInstruction(new T1InstructionFunctionDeclaration(arguments, T1VariableType.Int, 0, functionScope));

                        token = GetNextToken();
                        while (token != "}")
                        {
                            // is it a function call?
                            if (TableContains(FunctionTableItems, token))
                            {
                            }
                            // is it an assignment?
                            else if (TableContains(VariableTableItems, token))
                            {
                            }
                            // is it a variable declaration?
                            else if (primitiveTypes.Contains(token))
                            {
                            }
                            // is it a statement?
                            else if (statements.Contains(token))
                            {
                                if (token == "if")
                                {
                                }
                                else if (token == "for")
                                {
                                    token = GetNextToken();
                                    if (token != "(")
                                    {
                                        throw new Exception("\"(\" expected but " + token + " found");
                                    }
                                }
                                else if (token == "while")
                                {
                                    token = GetNextToken();
                                    if (token != "(")
                                    {
                                        throw new Exception("\"(\" expected but " + token + " found");
                                    }
                                }
                                else if (token == "return")
                                {
                                }
                                else
                                {
                                    throw new Exception("Undexpected statement or keyword: " + token + " [" + CurrentLine + "]");
                                }
                            }
                            else
                            {
                                throw new Exception("Unexpected statement starter: " + token + " [" + CurrentLine + "]");
                            }

                            token = GetNextToken();
                        }
                    }
                    else if (token == "=" || token == ";")
                    {
                        // this seems to be a variable declaration
                        if (token == "=")
                        {
                            CompileExpression();
                        }
                        else
                        {
                            VariableTableItems.Add(new T1TableItem(identifierName, VariableTableItems.Count - 1, CurrentScope));

                            CurrentInstruction = new T1InstructionVariableDeclaration(variableType);
                            CurrentScope.AddInstruction(CurrentInstruction);
                        }
                    }
                    else
                    {
                        throw new Exception("Unexpected identifier: " + token + " [" + CurrentLine + "]");
                    }
                }
                else if (token == "\n")
                {
                    CurrentLine++;
                }
                else if (token == ";")
                {
                    // skip to the next statement
                }
                else
                {
                    throw new Exception("Unexpected identifier: " + token + " [" + CurrentLine + "]");
                }

                CurrentToken++;
            }
        }