Example #1
0
        public static Value Evaluate(Syntax syntax, Environment environment, Frame frame = null)
        {
            var result = Value.Nil;

            // create environment
            var lexical = null as Environment;

            if (frame != null)
            {
                lexical = Environment.Create(environment, Symbol.NULL, frame);
            }

            lexical = new Environment(environment, Symbol.Intern("LEXICAL"), true);

            // expand code
            var ast = AstBuilder.Expand(syntax, lexical);

            // generate the code
            var lambda   = new CodeGenerator(lexical.Count);
            var regnum   = lambda.GenerateTopLambda(lexical, ast);
            var template = lambda.GetTemplate();

            // evaluate code
            VarpVM vm = new VarpVM();

            result = vm.RunTemplate(template, environment, frame);

            if (result.RefVal is Frame)
            {
                result = vm.RunClosure(result.RefVal as Frame);
            }

            return(result);
        }
Example #2
0
    private void OnValidate()
    {
        var sbsyntax = new System.Text.StringBuilder();
        var sbast    = new System.Text.StringBuilder();
        var sbcode   = new System.Text.StringBuilder();
        var sbeval   = new System.Text.StringBuilder();

        try
        {
            // ------------------------------------------------------------------
            // Parse scheme
            // ------------------------------------------------------------------

            lexer = new Tokenizer(new StringReader(testString), "TokenizerTest");

            do
            {
                // PARSER
                var syntax = Parser.Parse(lexer);
                if (syntax == null)
                {
                    break;
                }
                if (detailedSyntaxTree)
                {
                    sbsyntax.AppendLine(Inspector.Inspect(syntax, InspectOptions.PrettyPrint));
                }
                else
                {
                    sbsyntax.AppendLine(Inspector.Inspect(syntax));
                }

                // ENVIRONMENT
                var lexical = new Environment(SystemEnvironment.Top, Symbol.NULL, true);

                // AST
                var ast = AstBuilder.Expand(syntax, lexical);
                sbast.AppendLine(ast.Inspect());

                // COCEGENERATOR
                var gen      = new CodeGenerator(lexical.Count);
                var temp     = gen.GenerateTopLambda(lexical, ast);
                var template = gen.GetTemplate();
                sbcode.AppendLine(template.Inspect());

                // EVALUATE
                var vm    = new VarpVM();
                var vmres = vm.RunTemplate(template, SystemEnvironment.Top);
                if (vmres.RefVal is Frame)
                {
                    vmres = vm.RunClosure(vmres.RefVal as Frame);
                }
                sbeval.Append(Inspector.Inspect(vmres));
            } while (lexer.LastToken != null);

            syntaxString = sbsyntax.ToString();
            astString    = sbast.ToString();
            codeString   = sbcode.ToString();
            evalString   = sbeval.ToString();
            InspectEnvironment();
        }
        catch (SchemeError ex)
        {
            sbeval.Append(ex.Message);

            syntaxString = sbsyntax.ToString();
            astString    = sbast.ToString();
            codeString   = sbcode.ToString();
            evalString   = sbeval.ToString();
            InspectEnvironment();
        }
        catch (System.Exception ex)
        {
            syntaxString = sbsyntax.ToString();
            astString    = sbast.ToString();
            codeString   = sbcode.ToString();
            evalString   = sbeval.ToString();
            InspectEnvironment();

            throw ex;
        }
    }