예제 #1
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
        private void Pow(ProgramContext context, string baseVal, string exponent, string storeIn)
        {
            double value1 = context.Memory.ResolveToSingleValue(baseVal);
            double value2 = context.Memory.ResolveToSingleValue(exponent);

            context.Memory.SetVarValue(storeIn, new List <double> {
                Math.Pow(value1, value2)
            });
        }
예제 #2
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
        private void Tan(ProgramContext context, string val, string storeIn)
        {
            double value = context.Memory.ResolveToSingleValue(val);

            context.Memory.SetVarValue(storeIn, new List <double>()
            {
                Math.Tan(value)
            });
        }
예제 #3
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
        private void Swi(ProgramContext context, string val1, string val2, string val3)
        {
            double first  = context.Memory.ResolveToSingleValue(val1);
            double second = context.Memory.ResolveToSingleValue(val2);
            int    lineNo = (int)context.Memory.ResolveToSingleValue(val3);

            ConsoleWriter.Write("SWI, PC at " + context.ProgramCounter + " before and ", OutputLevel.DEBUG);
            if (first < second)
            {
                context.ProgramCounter = context.LineToTokenNumber(lineNo) - 1;                 // -1 as will increment when next instruction requested
            }
            ConsoleWriter.WriteLine(context.ProgramCounter + " after", OutputLevel.DEBUG);
        }
예제 #4
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
        private void Brk(ProgramContext context, string val1, string val2, string varName)
        {
            double first  = context.Memory.ResolveToSingleValue(val1);
            double second = context.Memory.ResolveToSingleValue(val2);

            if (first < second)
            {
                context.ProgramCounter = context.ProgramLength; //End prog
                return;
            }
            else
            {
                context.Memory.SetVarValue(varName, Math.Abs(first - second));
            }
        }
예제 #5
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
        private void Lod(ProgramContext context, Tree <Token> instruction)
        {
            string fileName  = instruction.Root.Children[0].Value.Lexeme;
            string stdPrefix = "std::";

            if (fileName.Contains(stdPrefix))
            {
                string execuatbleLocation = new Uri(Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().GetName().CodeBase)).LocalPath;
                fileName = execuatbleLocation + @"\std\" + fileName.Split(stdPrefix, StringSplitOptions.RemoveEmptyEntries)[0];
            }
            Interpreter moduleInterpreter;

            try
            {
                moduleInterpreter = new Interpreter(fileName);

                Node <Token> passedValToken = instruction.Root.Children[1];
                if (passedValToken.Value.TokenType == TokenType.PassableArray)
                {
                    string varName = passedValToken.Value.Lexeme.Split(Lexer.passableArrayModifier)[1];
                    // In this case, pass the entire array into the first variable of the loaded module
                    moduleInterpreter.ProgramContext.Memory.SetPassedValue(context.Memory.ResolveToValue(varName));
                }
                else
                {
                    // In this case, each element of the value into each declared variable in turn
                    moduleInterpreter.ProgramContext.Memory.SetPassedValues(context.Memory.ResolveToValue(passedValToken.Value.Lexeme));
                }
            }
            catch (Exception ex)
            {
                throw new ModuleLoadException("Could not resolve module " + fileName + ". With context - " + context.ToString(), ex);
            }

            try
            {
                moduleInterpreter.Run();
                context.Memory.SetVarValue(instruction.Root.Children[2].Value.Lexeme, moduleInterpreter.ProgramContext.Memory.GetFullValue("return"));
            }
            catch (Exception ex)
            {
                throw new RuntimeException("Module " + fileName + " caused exception with context - " + moduleInterpreter.ProgramContext.ToString(), ex);
            }
        }
예제 #6
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
        private void Rea(ProgramContext context, string storeIn)
        {
            ConsoleWriter.Write(">", OutputLevel.PROGRAM);
            string        input = Console.ReadLine();
            List <double> values;

            try
            {
                values = input.Split(", ", StringSplitOptions.RemoveEmptyEntries).Select(x =>
                {
                    return(input[0] == '#'
                    ? BitConverter.Int64BitsToDouble(Convert.ToInt64(input.Split('#', StringSplitOptions.RemoveEmptyEntries)[0], 16))
                    : double.Parse(x));
                }).ToList();
            }
            catch (Exception ex)
            {
                throw new RuntimeException("Could not read values from console in: " + input + "." + context, ex);
            }

            context.Memory.SetVarValue(storeIn, values);
        }
예제 #7
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
        public Interpreter(string programPath, Operators operators = null)
        {
            if (operators == null)
            {
                operators = Operators.GetInstance(Operators.New());
            }
            this.operators = operators;

            string source;

            try
            {
                source = File.ReadAllText(programPath);
            }
            catch (Exception ex)
            {
                throw new ModuleLoadException("Could not load module " + programPath, ex);
            }

            List <Token> tokens = Lexer.Lex(source, operators);

            syntaxTree     = new SyntaxTree(tokens);
            programContext = new ProgramContext(operators, syntaxTree);
        }
예제 #8
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
        public ProgramContext RunCommand(Tree <Token> instruction, ProgramContext context)
        {
            ConsoleWriter.WriteLine(Environment.NewLine + "Instruction: " + instruction);
            ConsoleWriter.WriteLine(context.ToString());

            Ops op = context.Operators.ToOp(instruction.Root.Value.Lexeme);

            ConsoleWriter.WriteLine("Run: " + instruction);
            switch (op)
            {
            case Ops.ADD:
                Add(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme, instruction.Root.Children[2].Value.Lexeme);
                break;

            case Ops.SUB:
                Sub(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme, instruction.Root.Children[2].Value.Lexeme);
                break;

            case Ops.MUL:
                Mul(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme, instruction.Root.Children[2].Value.Lexeme);
                break;

            case Ops.DIV:
                Div(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme, instruction.Root.Children[2].Value.Lexeme);
                break;

            case Ops.MOD:
                Mod(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme, instruction.Root.Children[2].Value.Lexeme);
                break;

            case Ops.PUT:
                Put(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme, instruction.Root.Children[2].Value.Lexeme);
                break;

            case Ops.GET:
                Get(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme, instruction.Root.Children[2].Value.Lexeme);
                break;

            case Ops.SWI:
                Swi(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme, instruction.Root.Children[2].Value.Lexeme);
                break;

            case Ops.BRK:
                Brk(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme, instruction.Root.Children[2].Value.Lexeme);
                break;

            case Ops.ALS:
                AddAlias(context, instruction);
                break;

            case Ops.OUT:
                Out(context, instruction);
                break;

            case Ops.LOD:
                Lod(context, instruction);
                break;

            case Ops.SIN:
                Sin(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme);
                break;

            case Ops.COS:
                Cos(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme);
                break;

            case Ops.TAN:
                Tan(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme);
                break;

            case Ops.POW:
                Pow(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme, instruction.Root.Children[2].Value.Lexeme);
                break;

            case Ops.REA:
                Rea(context, instruction.Root.Children[0].Value.Lexeme);
                break;

            case Ops.CLR:
                Clr(context, instruction.Root.Children[0].Value.Lexeme);
                break;

            case Ops.LEN:
                Len(context, instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme);
                break;

            case Ops.NUL:
                break;

            default:
                throw new NotImplementedException("Op " + op + " has not been implemented in the interpreter");
            }
            return(context);
        }
예제 #9
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
        private void Len(ProgramContext context, string valOrVar, string var)
        {
            List <double> value = context.Memory.ResolveToValue(valOrVar);

            context.Memory.SetVarValue(var, value.Count);
        }
예제 #10
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
 private void Clr(ProgramContext context, string varName)
 {
     context.Memory.Clear(varName);
 }
예제 #11
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
 private void Out(ProgramContext context, Tree <Token> instruction)
 {
     string[] output = instruction.Root.Children.Where(n => n.Value.TokenType != TokenType.Delimiter)
                       .Select(n => n.Value.TokenType == TokenType.StringLiteral ? n.Value.Lexeme : "[" + string.Join(", ", context.Memory.ResolveToValue(n.Value.Lexeme)) + "]").ToArray();
     ConsoleWriter.WriteLine(String.Join(' ', output), OutputLevel.PROGRAM);
 }
예제 #12
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
        private void Get(ProgramContext context, string index, string array, string var)
        {
            double value = context.Memory.GetFromArray(array, (int)context.Memory.ResolveToSingleValue(index));

            context.Memory.SetVarValue(var, value);
        }
예제 #13
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
 private void Put(ProgramContext context, string index, string array, string value)
 {
     context.Memory.SetVarValue(array, context.Memory.ResolveToSingleValue(value), (int)context.Memory.ResolveToSingleValue(index));
 }
예제 #14
0
파일: Interpreter.cs 프로젝트: Slord6/Spice
 private void AddAlias(ProgramContext context, Tree <Token> instruction)
 {
     context.Operators.AddAlias(instruction.Root.Children[0].Value.Lexeme, instruction.Root.Children[1].Value.Lexeme);
 }