Example #1
0
        public VMModule?CompileAndLink(
            string source,
            string filename,
            InteropResolver resolver,
            List <ParseError> parseErrors,
            List <LinkError> linkErrors
            )
        {
            Linker      linker       = new Linker(linkErrors);
            ParseModule parsedModule = CreateInputParseModuleFromInteropResolver(resolver);

            SetupLinkerWithInteropResolver(linker, resolver);

            ILModule?compiledModule = Compile(source, filename, parseErrors, parsedModule);

            if (compiledModule == null)
            {
                return(null);
            }

            linker.AddModule(compiledModule, export: true);

            VMModule linkedModule = linker.Link();

            if (linkErrors.Count > 0)
            {
                return(null);
            }

            return(linkedModule);
        }
Example #2
0
        private ParseModule CreateInputParseModuleFromInteropResolver(InteropResolver resolver)
        {
            ParseModule module = new ParseModule();

            module.Functions.AddRange(resolver.Bindings.Select(b => b.Prototype));
            module.Enums.AddRange(resolver.Enums);
            return(module);
        }
Example #3
0
        public ParseModule ParseAndAnalyze(
            string source,
            string filename,
            List <ParseError> errors,
            InteropResolver resolver
            )
        {
            ParseModule module = CreateInputParseModuleFromInteropResolver(resolver);

            return(ParseAndAnalyze(source, filename, errors, module));
        }
Example #4
0
        public ParseModule CreateHeaderModule()
        {
            ParseModule module = new ParseModule();

            module.Functions.AddRange(_bindings.Values.Select(binding => binding.Prototype));
            module.Enums.AddRange(_enums);
            foreach (var token in _tokenMap)
            {
                module.SymbolMap.Add(token.Key, token.Value);
            }
            return(module);
        }
Example #5
0
    public static void Main()
    {
        ParseModule pm = new ParseModule();

        pm.ParseString();
        Console.WriteLine();
        pm.ParseStringWithIFormatProvider();
        Console.WriteLine();
        pm.ParseWithCustomIFormatProvider();
        Console.WriteLine();
        pm.ParseWithStyle();
        pm.ParseOverload4();
    }
Example #6
0
        public ILModule?Compile(
            string source,
            string filename,
            List <ParseError> errors,
            ParseModule?targetModule = null
            )
        {
            ParseModule module = ParseAndAnalyze(source, filename, errors, targetModule);

            if (errors.Count > 0)
            {
                return(null);
            }
            return(Compile(module));
        }
Example #7
0
        public void solveTest()
        {
            var inputData = new Dictionary <double, string>()
            {
                [-67]      = "-12x3+3x2+5x+7",
                [23]       = "+23",
                [-2869983] = "-99999x5+9999x3+9999x2+99999x+9999",
            };

            foreach (var testRow in inputData)
            {
                var coefs = ParseModule.parseAll(testRow.Value);
                var rez   = ComputingModule.calculatePolynom(coefs, 2);
                Assert.AreEqual(testRow.Key, rez);
            }
        }
        public void ParseAll()
        {
            var testPolynoms = new Dictionary <string, List <int> >()
            {
                ["5"] = new List <int>()
                {
                    5
                },                            // +
                ["-5"] = new List <int>()
                {
                    -5
                },                               //+
                ["x+5"] = new List <int>()
                {
                    1, 5
                },
                ["2x2+3x+5"] = new List <int>()
                {
                    2, 3, 5
                },                                         // +
                ["-2x2+3x+5"] = new List <int>()
                {
                    -2, 3, 5
                },
                ["-12x2+3x+5"] = new List <int>()
                {
                    -12, 3, 5
                },
                ["-12x3+3x2+5x+7"] = new List <int>()
                {
                    -12, 3, 5, 7
                }
            };

            foreach (var testCase in testPolynoms)
            {
                Assert.AreEqual(
                    string.Join("", testCase.Value.Select(x => x.ToString()).ToArray()),
                    string.Join("", ParseModule.parseAll(testCase.Key).Select(x => x.ToString()).ToArray())
                    );
            }
        }
        public void OperandsFromString()
        {
            var testPolynoms = new Dictionary <string, List <string> >()
            {
                ["5"] = new List <string>()
                {
                    "+5"
                },
                ["-5"] = new List <string>()
                {
                    "-5"
                },
                ["x+5"] = new List <string>()
                {
                    "+x", "+5"
                },
                ["2x2+3x+5"] = new List <string>()
                {
                    "+2x2", "+3x", "+5"
                },
                ["-2x2+3x+5"] = new List <string>()
                {
                    "-2x2", "+3x", "+5"
                },
                ["-12x2+3x+5"] = new List <string>()
                {
                    "-12x2", "+3x", "+5"
                },
                ["-12x3+3x2+5x+7"] = new List <string>()
                {
                    "-12x3", "+3x2", "+5x", "+7"
                }
            };

            foreach (var testCase in testPolynoms)
            {
                Assert.AreEqual(
                    string.Join("", testCase.Value.ToArray()),
                    string.Join("", ParseModule.operandsFromString(testCase.Key).ToArray())
                    );
            }
        }
Example #10
0
        public ParseModule Parse(string?filePath, IEnumerable <Token> tokens, IList <ParseError> errors)
        {
            _filePath = filePath;
            _tokens.Clear();
            _tokens.AddRange(tokens);

            TokenSource tokenSource = new TokenSource(_tokens, 0, errors);

            ParseModule outputModule = new ParseModule();

            _symbolMap = outputModule.SymbolMap;

            ParseModuleHopper hopper = new ParseModuleHopper(outputModule);

            while (tokenSource.Peek().Type != TokenType.None)
            {
                ParseTopLevelStatement(ref tokenSource)?.AcceptTopLevelVisitor(hopper);
            }

            return(outputModule);
        }
Example #11
0
        public VMModule?CompileAndLink(
            ParseModule parsedModule,
            InteropResolver resolver,
            List <LinkError> linkErrors
            )
        {
            Linker linker = new Linker(linkErrors);

            SetupLinkerWithInteropResolver(linker, resolver);
            ILModule compiledModule = Compile(parsedModule);

            linker.AddModule(compiledModule, export: true);

            VMModule linkedModule = linker.Link();

            if (linkErrors.Count > 0)
            {
                return(null);
            }

            return(linkedModule);
        }
Example #12
0
        public void RunHeaderPass()
        {
            if (_parseModule != null)
            {
                throw new InvalidOperationException("RunHeaderPass has already been called");
            }

            Parser            parser = new Parser();
            List <ParseError> errors = new List <ParseError>();

            _parseModule = parser.Parse(_parseInput.GetFileInfo().FullPath, _parseInput.GetTokens(), errors);

            for (int i = 0, ilen = errors.Count; i < ilen; ++i)
            {
                ParseError error = errors[i];
                Diagnostics.Report(Diagnostics.Severity.Error,
                                   $"{error.Start.Line + 1},{error.Start.Column + 1}: {error.Message}");
            }

            if (_showAST)
            {
                PrintTreeVisitor treeVisitor = new PrintTreeVisitor(Console.Out);
                for (int i = 0, ilen = _parseModule.Functions.Count; i < ilen; ++i)
                {
                    _parseModule.Functions[i].AcceptTopLevelVisitor(treeVisitor);
                }
            }

            if (!_job._forceCodegen)
            {
                Diagnostics.ThrowIfErrors();
            }

            // Register module members with semantic analyzer
            _job._semanticAnalyzer.Register(_parseModule);
        }
Example #13
0
        public ParseModule ParseAndAnalyze(
            string source,
            string filename,
            List <ParseError> errors,
            ParseModule?headerModule = null
            )
        {
            Lexer        lexer  = new Lexer();
            List <Token> tokens = new List <Token>();

            lexer.LexFullModule(source, tokens);

            Parser           parser       = new Parser();
            ParseModule      outputModule = parser.Parse(filename, tokens, errors);
            SemanticAnalyzer analyzer     = new SemanticAnalyzer(errors);

            if (headerModule != null)
            {
                analyzer.Register(headerModule);
            }
            analyzer.Register(outputModule);
            analyzer.Process(outputModule);
            return(outputModule);
        }
Example #14
0
        public static void Main(string[] args)
        {
            bool          isInteractive      = false;
            bool          showLex            = false;
            bool          showAst            = false;
            bool          showIl             = false;
            bool          withDebugger       = false;
            bool          forceCodegen       = false;
            bool          run                = true;
            List <string> positionals        = new List <string>();
            List <int>    argsToPass         = new List <int>();
            List <string> libraryNames       = new List <string>();
            List <string> librarySearchPaths = new List <string>();

            for (int i = 0, ilen = args.Length; i < ilen; ++i)
            {
                string arg      = args[i].Trim();
                bool   argFound = true;

                switch (arg)
                {
                case "-i":
                    isInteractive = true;
                    break;

                case "--showlex":
                    showLex = true;
                    break;

                case "--showast":
                    showAst = true;
                    break;

                case "--showil":
                    showIl = true;
                    break;

                case "-a":
                    int argToPass;
                    Int32.TryParse(args[++i], out argToPass);
                    argsToPass.Add(argToPass);
                    break;

                case "-l":
                    libraryNames.Add(args[++i]);
                    break;

                case "-L":
                    librarySearchPaths.Add(args[++i]);
                    break;

                case "--debugger":
                    withDebugger = true;
                    break;

                case "--force-codegen":
                    // Indicate that the compiler should attempt to code gen IL, even if the parse stage failed.
                    // This can be helpful to diagnose generated IL for code that doesn't compile outside of a
                    // specific project due to undefined references. The parser tries its hardest to produce a
                    // usable AST, even if there are semantic errors. Syntax errors? Not so much.
                    forceCodegen = true;
                    break;

                case "--skip-run":
                    run = false;
                    break;

                default:
                    argFound = false;
                    break;
                }

                if (!argFound)
                {
                    if (!arg.Contains("-"))
                    {
                        positionals.Add(arg);
                    }
                }
            }

            InteropResolver    interopResolver = new InteropResolver();
            const BindingFlags bindingFlags    = BindingFlags.Public | BindingFlags.DeclaredOnly | BindingFlags.Static;

            foreach (string libraryName in libraryNames)
            {
                Assembly lib = LoadAssembly(libraryName, librarySearchPaths);
                interopResolver.ImportAssembly(lib, bindingFlags);
            }

            List <ParseModule> parseModules = new List <ParseModule>(positionals.Count);
            List <ParseError>  errors       = new List <ParseError>();

            void ParseTokens(string?filename, List <Token> tokens)
            {
                Parser      parser = new Parser();
                ParseModule module = parser.Parse(filename, tokens, errors);

                parseModules.Add(module);
            }

            if (positionals.Count > 0)
            {
                // File mode - parse one or more files into ParseModules
                for (int i = 0, ilen = positionals.Count; i < ilen; ++i)
                {
                    string filename = positionals[i];

                    Lexer        lexer  = new Lexer();
                    List <Token> tokens = new List <Token>();

                    string?input;

                    filename = Path.GetFullPath(filename);
                    using StreamReader reader = new StreamReader(filename);
                    while ((input = reader.ReadLine()) != null)
                    {
                        LexLine(input, lexer, tokens, verbose: showLex);
                    }

                    lexer.FinishLex(tokens);

                    ParseTokens(filename, tokens);
                }
            }
            else
            {
                // Interactive or StdIn mode - parse exactly one ParseModule
                Lexer        lexer  = new Lexer();
                List <Token> tokens = new List <Token>();

                string?input;

                if (isInteractive)
                {
                    WritePrompt();
                    while ((input = Console.ReadLine()) != null)
                    {
                        LexLine(input, lexer, tokens, verbose: showLex);
                        WritePrompt();
                    }
                }
                else
                {
                    while ((input = Console.In.ReadLine()) != null)
                    {
                        LexLine(input, lexer, tokens, verbose: showLex);
                    }
                }

                lexer.FinishLex(tokens);

                ParseTokens(null, tokens);
            }

            List <LinkError> linkErrors = new List <LinkError>();
            Linker           linker     = new Linker(linkErrors);

            SemanticAnalyzer analyzer = new SemanticAnalyzer(errors);

            List <SemanticModule> semanticModules = new List <SemanticModule>(parseModules.Count);

            analyzer.Register(interopResolver.CreateHeaderModule());

            foreach (ParseModule module in parseModules)
            {
                analyzer.Register(module);
            }

            foreach (ParseModule module in parseModules)
            {
                semanticModules.Add(analyzer.Process(module));

                if (showAst)
                {
                    PrintTreeVisitor treeVisitor = new PrintTreeVisitor(Console.Out);
                    foreach (StructNode structNode in module.Structs)
                    {
                        structNode.AcceptTopLevelVisitor(treeVisitor);
                    }
                    foreach (FunctionDefinitionNode function in module.Functions)
                    {
                        function.AcceptTopLevelVisitor(treeVisitor);
                    }
                }
            }

            for (int i = 0, ilen = errors.Count; i < ilen; ++i)
            {
                ParseError error = errors[i];
                Console.Error.WriteLine($"{error.Start.Line + 1},{error.Start.Column + 1}: {error.Message}");
            }

            if (errors.Count > 0 && !forceCodegen)
            {
                Environment.Exit(1);
            }

            foreach (SemanticModule module in semanticModules)
            {
                CodeGenerator generator = new CodeGenerator(module, analyzer.Context);
                ILModule      ilmodule  = generator.Generate();
                if (showIl)
                {
                    ilmodule.WriteListing(Console.Out);
                }

                linker.AddModule(ilmodule, export: true);
            }

            foreach (Binding binding in interopResolver.Bindings)
            {
                linker.AddFunctionBinding(binding.Prototype.Name, binding.Implementation, export: false);
            }

            VMModule vmModule = linker.Link();

            if (linkErrors.Count > 0)
            {
                foreach (LinkError error in linkErrors)
                {
                    Console.Error.WriteLine($"Link error: {error.Message}");
                }

                Environment.Exit(1);
            }

            List <string> loadErrors = new List <string>();

            if (!interopResolver.PrepareForExecution(vmModule, loadErrors))
            {
                foreach (string error in loadErrors)
                {
                    Console.Error.WriteLine($"Load error: {error}");
                }

                Environment.Exit(1);
            }

            if (!run)
            {
                Environment.Exit(0);
                return;
            }

            using VirtualMachine vm = new VirtualMachine();

            if (withDebugger)
            {
                Debugger   debugger   = new Debugger();
                VMDebugger vmDebugger = new VMDebugger(debugger, vm);
                vmDebugger.Break += () => HandleBreak(vm, debugger, vmDebugger);
                vmDebugger.Pause();
            }

            // TODO: Args to pass is broken
            if (!vm.Call(vmModule, "main", new byte[0], success => HandleExecutionFinished(vm, success)))
            {
                Console.Error.WriteLine("Failed to call main function.");
                Environment.Exit(-1);
            }
        }
Example #15
0
 public SemanticModule(ParseModule baseModule, Dictionary <IExpressionNode, IType> expressionResultTypes)
 {
     BaseModule            = baseModule;
     ExpressionResultTypes = expressionResultTypes;
 }
Example #16
0
 public ILModule Compile(ParseModule module)
 {
     throw new NotImplementedException();
     // CodeGenerator generator = new CodeGenerator(module, context);
     // return generator.Generate();
 }