Пример #1
0
        private Assembly LoadAssembly(string srcName, string nsName)
        {
            try
            {
                string srcDir = Path.GetDirectoryName(srcName);
                string outDir = ".";

                Scanner scanner = new Scanner(srcName);
                Parser parser = new Parser(scanner);

                string traceFileName = Path.Combine(srcDir ?? "", "trace.txt");
                parser.trace = new StreamWriter(new FileStream(traceFileName, FileMode.Create));
                parser.tab = new Tab(parser);
                parser.dfa = new DFA(parser);
                parser.pgen = new at.jku.ssw.Coco.ParserGen(parser);

                parser.tab.srcName = srcName;
                parser.tab.srcDir = srcDir;
                parser.tab.nsName = nsName;
                parser.tab.outDir = outDir;

                parser.Parse();

                parser.trace.Close();

                if (parser.errors.count != 0)
                {
                    throw new InvalidOperationException($"Failed to parse grammar file! Found {parser.errors.count} errors.");
                }

                var parameters = new CompilerParameters
                {
                    GenerateExecutable = false,
                    GenerateInMemory = true,
                    OutputAssembly = nsName,
                    TreatWarningsAsErrors = false
                };
                parameters.ReferencedAssemblies.Add("System.dll");
                parameters.ReferencedAssemblies.Add("mscorlib.dll");
                parameters.ReferencedAssemblies.Add("Microsoft.CSharp.dll");
                parameters.ReferencedAssemblies.Add("XCompilR.Library.dll");

                var codeProvider = new CSharpCodeProvider(new Dictionary<string, string>
                {
                    { "CompilerVersion", "v4.0" }
                });
                var results = codeProvider.CompileAssemblyFromFile(parameters, "Parser.cs", "Scanner.cs");

                if (results.Errors.HasErrors || results.Errors.HasWarnings)
                {
                    throw new InvalidOperationException($"Failed to generate dynamic assembly! Found {results.Errors.Count} errors.");
                }

                return results.CompiledAssembly;
            }
            catch (Exception exception)
            {
                throw new XCompileException($"Could not create {nsName} assembly!", exception);
            }
        }
Пример #2
0
    public static bool Generate(
        string srcName, 
        string ddtString, 
        string frameDir, 
        string nsName, 
        bool directDebug,
        Action<string> writeMessage, 
        Action<string> writeError)
    {
        string traceFileName = null;
        try
        {
            int pos = srcName.LastIndexOf('/');
            if (pos < 0) pos = srcName.LastIndexOf('\\');
            string file = srcName;
            string srcDir = srcName.Substring(0, pos + 1);

            Scanner scanner = new Scanner(file);
            Parser parser = new Parser(scanner);

            traceFileName = srcDir + "trace.txt";
            parser.trace = new StreamWriter(new FileStream(traceFileName, FileMode.Create));
            parser.tab = new Tab(parser);
            parser.dfa = new DFA(parser);
            parser.pgen = new ParserGen(parser);
            parser.pgen.DirectDebug = directDebug;

            parser.tab.srcName = srcName;
            parser.tab.srcDir = srcDir;
            parser.tab.nsName = nsName;
            parser.tab.frameDir = frameDir;
            if (ddtString != null) parser.tab.SetDDT(ddtString);

            parser.errors.WriteMessage = writeMessage;
            parser.errors.WriteError = writeError;

            parser.errors.realFile = srcName;

            parser.Parse();

            parser.trace.Close();
            FileInfo f = new FileInfo(traceFileName);
            if (f.Length == 0) f.Delete();
            else writeMessage("trace output is in " + traceFileName);
            writeMessage(String.Format("{0} errors detected", parser.errors.count));
            return parser.errors.count <= 0;
        }
        catch (IOException ex)
        {
            writeError(ex.Message);
            return false;
        }
        catch (FatalError ex)
        {
            writeError(ex.Message);
            return false;
        }
    }
Пример #3
0
        public static int Main(string[] arg)
        {
            Console.WriteLine("Coco/R C# (Apr 23, 2010)");
            string srcName = null, nsName = null, prefixName = null;
            string frameDir = null, ddtString = null, outDir = null;
            bool makeBackup = false;
            bool traceToFile = true;
            int retVal = 1;

            for (int i = 0; i < arg.Length; i++) {
            if (arg[i] == "-help") {
                printUsage(null);
                return 0;
            }
            else if (arg[i] == "-namespace") {
                if (++i == arg.Length) {
                    printUsage("missing parameter on -namespace");
                    return retVal;
                }
                nsName = arg[i];
            }
            else if (arg[i] == "-prefix") {
                if (++i == arg.Length) {
                    printUsage("missing parameter on -prefix");
                    return retVal;
                }
                prefixName = arg[i];
            }
            else if (arg[i] == "-frames") {
                if (++i == arg.Length) {
                    printUsage("missing parameter on -frames");
                    return retVal;
                }
                frameDir = arg[i];
            }
            else if (arg[i] == "-trace") {
                if (++i == arg.Length) {
                    printUsage("missing parameter on -trace");
                    return retVal;
                }
                traceToFile = true;
                ddtString = arg[i];
            }
            else if (arg[i] == "-trace2") {
                if (++i == arg.Length) {
                    printUsage("missing parameter on -trace2");
                    return retVal;
                }
                traceToFile = false;
                ddtString = arg[i];
            }
            else if (arg[i] == "-o") {
                if (++i == arg.Length) {
                    printUsage("missing parameter on -o");
                    return retVal;
                }
                outDir = arg[i];
            }
            else if (arg[i] == "-bak") {
                makeBackup = true;
            }
            else if (arg[i][0] == '-') {
                printUsage("Error: unknown option: '" + arg[i] + "'");
                return retVal;
            }
            else if (srcName != null) {
                printUsage("grammar can only be specified once");
                return retVal;
            }
            else {
                srcName = arg[i];
            }
            }

            if (srcName != null)
            {
            string traceFileName = null;
            try {
                string srcDir = Path.GetDirectoryName(srcName);

                Scanner scanner = new Scanner(srcName);
                Parser parser   = new Parser(scanner);
                parser.tab      = new Tab(parser);

                parser.tab.srcName    = srcName;
                parser.tab.srcDir     = srcDir;
                parser.tab.nsName     = nsName;
                parser.tab.prefixName = prefixName;
                parser.tab.frameDir = frameDir;
                parser.tab.outDir   = (outDir != null) ? outDir : srcDir;
                parser.tab.SetDDT(ddtString);
                parser.tab.makeBackup = makeBackup;

                if (traceToFile) {
                    traceFileName = Path.Combine(parser.tab.outDir, "trace.txt");
                    parser.tab.trace = new StreamWriter(new FileStream(traceFileName, FileMode.Create));
                }
                parser.dfa = new DFA(parser);
                parser.pgen = new ParserGen(parser);

                parser.Parse();

                if (traceToFile) {
                    parser.tab.trace.Close();
                    FileInfo f = new FileInfo(traceFileName);
                    if (f.Length == 0) f.Delete();
                    else Console.WriteLine("trace output is in " + traceFileName);
                }
                Console.WriteLine("{0} errors detected", parser.errors.count);
                if (parser.errors.count == 0) { retVal = 0; }
            } catch (IOException) {
                Console.WriteLine("-- could not open " + traceFileName);
            } catch (FatalError e) {
                Console.WriteLine("-- " + e.Message);
            }
            } else {
            printUsage(null);
            }
            return retVal;
        }
Пример #4
0
        string tokenString; // used in declarations of literal tokens

        #endregion Fields

        #region Constructors

        /*-------------------------------------------------------------------------*/
        public Parser(Scanner scanner)
        {
            this.scanner = scanner;
            errors = new Errors();
        }
Пример #5
0
        public static int Main(string[] arg)
        {
            Console.WriteLine("Coco/R (Oct 1, 2008)");
            string srcName = null, nsName = null, frameDir = null, ddtString = null,
            traceFileName = null, outDir = null;
            int retVal = 1;
            for (int i = 0; i < arg.Length; i++) {
            if (arg[i] == "-namespace" && i < arg.Length - 1) nsName = arg[++i];
            else if (arg[i] == "-frames" && i < arg.Length - 1) frameDir = arg[++i];
            else if (arg[i] == "-trace" && i < arg.Length - 1) ddtString = arg[++i];
            else if (arg[i] == "-o" && i < arg.Length - 1) outDir = arg[++i];
            else srcName = arg[i];
            }
            if (arg.Length > 0 && srcName != null) {
            try {
                string srcDir = Path.GetDirectoryName(srcName);

                Scanner scanner = new Scanner(srcName);
                Parser parser = new Parser(scanner);

                traceFileName = Path.Combine(srcDir, "trace.txt");
                parser.trace = new StreamWriter(new FileStream(traceFileName, FileMode.Create));
                parser.tab = new Tab(parser);
                parser.dfa = new DFA(parser);
                parser.pgen = new ParserGen(parser);

                parser.tab.srcName = srcName;
                parser.tab.srcDir = srcDir;
                parser.tab.nsName = nsName;
                parser.tab.frameDir = frameDir;
                parser.tab.outDir = (outDir != null) ? outDir : srcDir;
                if (ddtString != null) parser.tab.SetDDT(ddtString);

                parser.Parse();

                parser.trace.Close();
                FileInfo f = new FileInfo(traceFileName);
                if (f.Length == 0) f.Delete();
                else Console.WriteLine("trace output is in " + traceFileName);
                Console.WriteLine("{0} errors detected", parser.errors.count);
                if (parser.errors.count == 0) { retVal = 0; }
            } catch (IOException) {
                Console.WriteLine("-- could not open " + traceFileName);
            } catch (FatalError e) {
                Console.WriteLine("-- " + e.Message);
            }
            } else {
            Console.WriteLine("Usage: Coco Grammar.ATG {{Option}}{0}" +
                              "Options:{0}" +
                              "  -namespace <namespaceName>{0}" +
                              "  -frames    <frameFilesDirectory>{0}" +
                              "  -trace     <traceString>{0}" +
                              "  -o         <outputDirectory>{0}" +
                              "Valid characters in the trace string:{0}" +
                              "  A  trace automaton{0}" +
                              "  F  list first/follow sets{0}" +
                              "  G  print syntax graph{0}" +
                              "  I  trace computation of first sets{0}" +
                              "  J  list ANY and SYNC sets{0}" +
                              "  P  print statistics{0}" +
                              "  S  list symbol table{0}" +
                              "  X  list cross reference table{0}" +
                              "Scanner.frame and Parser.frame files needed in ATG directory{0}" +
                        "or in a directory specified in the -frames option.",
                              Environment.NewLine);
            }
            return retVal;
        }
Пример #6
0
        /// <summary>
        /// Called by SharpDevelop when your tool has to generate code.
        /// </summary>
        /// <param name="item">
        /// The file for which your tool should generate code.
        /// </param>
        public void GenerateCode(FileProjectItem item, CustomToolContext context)
        {
            string dir = Path.GetDirectoryName(item.FileName);
            string traceFile = Path.Combine(dir, "trace.txt");
            string parserOutFile = Path.Combine(dir, "Parser.cs");
            string scannerOutFile = Path.Combine(dir, "Scanner.cs");

            ErrorsInTaskService.ClearAllErrors();
            CocoCategory.ClearText();
            CocoCategory.AppendLine("Generating " + Path.GetFileName(item.FileName) + "...");

            using (FileStream inputStream = File.OpenRead(item.FileName)) {
                Scanner scanner = new Scanner(inputStream);
                Parser parser = new Parser(scanner);
                parser.errors = new ErrorsInTaskService(item.FileName);
                parser.errors.errorStream = new MessageViewCategoryWriter(CocoCategory);
                parser.tab = new Tab(parser);
                parser.tab.trace = new LazyTextWriter(delegate { return new StreamWriter(traceFile); } );
                parser.dfa = new DFA(parser);
                parser.pgen = new ParserGen(parser);
                parser.tab.srcName = item.FileName;
                parser.tab.srcDir = Path.GetDirectoryName(item.FileName);
                parser.tab.nsName = context.OutputNamespace;
                parser.tab.frameDir = parser.tab.srcDir;
                parser.tab.outDir = parser.tab.srcDir;
                try {
                    parser.Parse();
                } catch (FatalError err) {
                    CocoCategory.AppendLine("Fatal error: " + err.Message);
                    return;
                } finally {
                    parser.tab.trace.Close();
                }

                CocoCategory.AppendLine("Done. " + parser.errors.count + " error(s).");
            }

            if (File.Exists(parserOutFile)) {
                context.EnsureOutputFileIsInProject(item, parserOutFile);
            }
            if (File.Exists(scannerOutFile)) {
                context.EnsureOutputFileIsInProject(item, scannerOutFile);
            }
        }
        public override byte[] GenerateCode(string fileName, string fileContents)
        {
            var result = new StringBuilder();

            try
            {
                using (var tempDir = new TempDirectory())
                {
                    string fileDir = Path.GetDirectoryName(fileName);
                    string outDir = tempDir.DirectoryInfo.FullName;

                    string scannerFile = Path.Combine(outDir, "scanner.cs");
                    string parserFile = Path.Combine(outDir, "parser.cs");
                    string traceFile = Path.Combine(outDir, "trace.txt");

                    var scanner = new Coco.Scanner(fileName);
                    var parser = new Coco.Parser(scanner);

                    using (var traceWriter = File.CreateText(traceFile))
                    {
                        parser.errors.errorStream = traceWriter;
                        parser.tab = new Coco.Tab(parser);
                        parser.dfa = new Coco.DFA(parser);
                        parser.pgen = new Coco.ParserGen(parser);

                        parser.tab.srcName = fileName;
                        parser.tab.srcDir = fileDir;
                        parser.tab.nsName = this.DefaultNamespace;
                        parser.tab.frameDir = fileDir;
                        parser.tab.outDir = outDir;
                        parser.tab.trace = traceWriter;
                        parser.tab.SetDDT("P");

                        parser.Parse();
                    }

                    if (File.Exists(scannerFile))
                    {
                        result.AppendLine(File.ReadAllText(scannerFile));
                    }

                    if (File.Exists(parserFile))
                    {
                        result.AppendLine(File.ReadAllText(parserFile));
                    }

                    if (File.Exists(traceFile))
                    {
                        result.AppendLine("/*** OUTPUT ***");
                        result.AppendLine(File.ReadAllText(traceFile));
                        result.AppendLine("*/");
                    }
                }
            }
            catch (Exception ex)
            {
                result.Length = 0;
                result.AppendLine("/*** INTERNAL ERROR ***");
                result.AppendLine(ex.ToString());
                result.AppendLine("*/");
            }

            return Encoding.UTF8.GetBytes(result.ToString());
        }
Пример #8
0
        public static int Main(string[] arg)
        {
            Console.WriteLine("Coco/R (Oct 1, 2008)");
            string srcName = null, nsName = null, frameDir = null, ddtString = null,
                   traceFileName = null, outDir = null;
            int retVal = 1;

            for (int i = 0; i < arg.Length; i++)
            {
                if (arg[i] == "-namespace" && i < arg.Length - 1)
                {
                    nsName = arg[++i];
                }
                else if (arg[i] == "-frames" && i < arg.Length - 1)
                {
                    frameDir = arg[++i];
                }
                else if (arg[i] == "-trace" && i < arg.Length - 1)
                {
                    ddtString = arg[++i];
                }
                else if (arg[i] == "-o" && i < arg.Length - 1)
                {
                    outDir = arg[++i];
                }
                else
                {
                    srcName = arg[i];
                }
            }
            if (arg.Length > 0 && srcName != null)
            {
                try {
                    string srcDir = Path.GetDirectoryName(srcName);

                    Scanner scanner = new Scanner(srcName);
                    Parser  parser  = new Parser(scanner);

                    traceFileName = Path.Combine(srcDir, "trace.txt");
                    parser.trace  = new StreamWriter(new FileStream(traceFileName, FileMode.Create));
                    parser.tab    = new Tab(parser);
                    parser.dfa    = new DFA(parser);
                    parser.pgen   = new ParserGen(parser);

                    parser.tab.srcName  = srcName;
                    parser.tab.srcDir   = srcDir;
                    parser.tab.nsName   = nsName;
                    parser.tab.frameDir = frameDir;
                    parser.tab.outDir   = (outDir != null) ? outDir : srcDir;
                    if (ddtString != null)
                    {
                        parser.tab.SetDDT(ddtString);
                    }

                    parser.Parse();

                    parser.trace.Close();
                    FileInfo f = new FileInfo(traceFileName);
                    if (f.Length == 0)
                    {
                        f.Delete();
                    }
                    else
                    {
                        Console.WriteLine("trace output is in " + traceFileName);
                    }
                    Console.WriteLine("{0} errors detected", parser.errors.count);
                    if (parser.errors.count == 0)
                    {
                        retVal = 0;
                    }
                } catch (IOException) {
                    Console.WriteLine("-- could not open " + traceFileName);
                } catch (FatalError e) {
                    Console.WriteLine("-- " + e.Message);
                }
            }
            else
            {
                Console.WriteLine("Usage: Coco Grammar.ATG {{Option}}{0}" +
                                  "Options:{0}" +
                                  "  -namespace <namespaceName>{0}" +
                                  "  -frames    <frameFilesDirectory>{0}" +
                                  "  -trace     <traceString>{0}" +
                                  "  -o         <outputDirectory>{0}" +
                                  "Valid characters in the trace string:{0}" +
                                  "  A  trace automaton{0}" +
                                  "  F  list first/follow sets{0}" +
                                  "  G  print syntax graph{0}" +
                                  "  I  trace computation of first sets{0}" +
                                  "  J  list ANY and SYNC sets{0}" +
                                  "  P  print statistics{0}" +
                                  "  S  list symbol table{0}" +
                                  "  X  list cross reference table{0}" +
                                  "Scanner.frame and Parser.frame files needed in ATG directory{0}" +
                                  "or in a directory specified in the -frames option.",
                                  Environment.NewLine);
            }
            return(retVal);
        }