Esempio n. 1
0
        void CheckLeaveSamples()
        {
            var samples = Directory.GetFiles(SampleDirectory);

            Assert.NotEmpty(samples);

            foreach (var sampleFile in samples)
            {
                var sourceCode = File.ReadAllText(sampleFile);

                var isBadSample = sourceCode.Contains("<bad>");

                var ast = GetAst(sourceCode);

                var rootScope = new SymbolScope();

                var generator = new IntermediateCodeGenerator(rootScope);
                generator.ReturnCheckEnabled = true;// enable leave check

                if (isBadSample)
                {
                    Assert.Throws <SemanticException>(() => generator.ProcessProgram(ast));
                }
                else
                {
                    generator.ProcessProgram(ast);
                }
            }

            TestOutput.WriteLine($"{samples.Length} samples tested");
        }
Esempio n. 2
0
        private static List <IntermediateCode> GenerateIntermediateCode(ICodeUnit ast)
        {
            var generator = new IntermediateCodeGenerator();
            var codes     = generator.Generate(ast).ToList();

            return(codes);
        }
Esempio n. 3
0
        private static IReadOnlyCollection <IntermediateCode> Generate(ICodeUnit unit)
        {
            var sut    = new IntermediateCodeGenerator();
            var actual = sut.Generate(unit);
            var namer  = new ImplicitReferenceNameAssigner();

            namer.AssignNames(unit);

            return(actual.ToList().AsReadOnly());
        }
Esempio n. 4
0
        void JustNoException()
        {
            var samples = Directory.GetFiles(SampleDirectory, "*.c0");

            Assert.NotEmpty(samples);

            foreach (var sampleFile in samples)
            {
                var sourceCode = File.ReadAllText(sampleFile);

                var ast = GetAst(sourceCode);

                var rootScope = new SymbolScope();

                var generator = new IntermediateCodeGenerator(rootScope);
                generator.CodeGenerationEnabled = true;
                generator.ReturnCheckEnabled    = true;

                generator.ProcessProgram(ast);

                // Scope are pushed and poped corrctly
                Assert.Equal(rootScope, generator.SymbolScope);


                // Generate assembly code
                var asm        = new AssemblyCodeGenerator(generator.GlobalBuilder);
                var codeLines  = asm.Generate();
                var outputName = sampleFile + ".s";
                File.WriteAllLines(outputName, codeLines);

                // Write machine code
                var exeData = asm.Executable.GetData();
                var exeName = sampleFile.Replace(".c0", ".o0");
                File.WriteAllBytes(exeName, exeData);
            }

            TestOutput.WriteLine($"{samples.Length} samples tested");
        }
Esempio n. 5
0
        static List <Instruction> Generate(string sourceCode)
        {
            var lexer  = new Lexer(sourceCode);
            var tokens = lexer.Parse().ToList();

            var tokenReader       = new TokenReader(tokens);
            var syntacticAnalyzer = new SyntacticAnalyzer(tokenReader);

            var success = syntacticAnalyzer.TryOperatorExpression(out OperatorExpressionAst ast);

            Assert.True(success);
            Assert.True(tokenReader.ReachedEnd);

            var rootScope = new SymbolScope();
            var generator = new IntermediateCodeGenerator(rootScope);

            generator.CodeGenerationEnabled = true;
            generator.ReturnCheckEnabled    = true;

            generator.ProcessOperatorExpression(ast);

            return(generator.ExpressionBucket.Pop());
        }
Esempio n. 6
0
        void CheckAllSamples()
        {
            var samples = Directory.GetFiles(SampleDirectory);

            Assert.NotEmpty(samples);

            foreach (var sampleFile in samples)
            {
                var sourceCode     = File.ReadAllText(sampleFile);
                var sourceDeclStat = GetDeclarationStatisticsFromSource(sourceCode);

                var isBadSample = sourceCode.Contains("<bad>");

                var ast = GetAst(sourceCode);

                var rootScope  = new HookableScope();
                var actualStat = new List <(string, string)>();
                rootScope.HookFunction = symbol =>
                {
                    if (symbol is FunctionSymbol function)
                    {
                        actualStat.Add((function.Name, "fn"));
                    }
                    else if (symbol is VariableSymbol variable)
                    {
                        var typeString = variable.Type switch
                        {
                            DataType.Long => "int",
                            DataType.Double => "double",
                            _ => throw new Exception()
                        };
                        if (!variable.IsConstant)
                        {
                            actualStat.Add((variable.Name, typeString));
                        }
                        else
                        {
                            actualStat.Add((variable.Name, "const " + typeString));
                        }
                    }
                };

                var generator = new IntermediateCodeGenerator(rootScope);

                if (isBadSample)
                {
                    Assert.Throws <SemanticException>(() => generator.ProcessProgram(ast));
                }
                else
                {
                    generator.ProcessProgram(ast);

                    // Scope are pushed and poped corrctly
                    Assert.Equal(rootScope, generator.SymbolScope);

                    // Check the declaration stat
                    Assert.Equal(sourceDeclStat.Count, actualStat.Count);

                    for (int i = 0; i < actualStat.Count; i++)
                    {
                        Assert.Equal(sourceDeclStat[i], actualStat[i]);
                    }
                }
            }

            TestOutput.WriteLine($"{samples.Length} samples tested");
        }
    }