Beispiel #1
0
        public CompilationResult CompileFromSource(
            TextWriter errorWriter,
            TextWriter warningWriter,
            TextWriter logWriter,
            string sourceCodePath,
            //string[] include
            string outputFilePath,
            string platformInfo,
            CompilerFlags flags
            )
        {
            try
            {
                if (!File.Exists(sourceCodePath))
                {
                    throw new FileNotFoundException("Source code file not found.", sourceCodePath);
                }

                var platform = Platforms.GetPlatformByName(platformInfo);
                if (platform == null)
                {
                    throw new Exception("Invalid platform name.");
                }

                flags = platform.ReviseFlags(flags);

                var outputObjPath = Path.Combine(Path.GetDirectoryName(outputFilePath), "obj");

                if (!Directory.Exists(outputObjPath))
                {
                    Directory.CreateDirectory(outputObjPath);
                }

                CompileFromSource(sourceCodePath, outputObjPath, outputFilePath, platform, flags, errorWriter,
                                  warningWriter, logWriter);

                return(new CompilationResult(true));
            }
            catch (Exception ex)
            {
                var dispatchInfo = ExceptionDispatchInfo.Capture(ex);
                return(new CompilationResult(false)
                {
                    Exception = dispatchInfo.SourceException
                });
            }
        }
Beispiel #2
0
        public Context CompileFromSource(
            IPlatform platform,
            CompilerFlags flags,
            TextWriter errorWriter,
            TextWriter warningWriter,
            TextWriter logWriter,
            TextWriter metaWriter,
            TextWriter codeWriter,
            string sourceCodePath
            )
        {
            var context = new Context(this, platform, flags, errorWriter, warningWriter, logWriter);

            context.Includes.Add(Path.GetDirectoryName(sourceCodePath));

            return(CompileFromSource(context, metaWriter, codeWriter, true, sourceCodePath));
        }
Beispiel #3
0
        public void CompileFromSource(string sourceCodePath, string outputObjPath,
                                      string outputFilePath, IPlatform platform, CompilerFlags flags, TextWriter errorWriter,
                                      TextWriter warningWriter, TextWriter logWriter)
        {
            var tempSrcPath = Path.Combine(outputObjPath,
                                           Path.GetFileNameWithoutExtension(outputFilePath) + ".src" + Path.GetExtension(outputFilePath) + ".bin");
            var tempMetaPath = Path.Combine(outputObjPath,
                                            Path.GetFileNameWithoutExtension(outputFilePath) + ".meta" + Path.GetExtension(outputFilePath) +
                                            ".bin");

            using (var codeOutputFile = new FileStream(tempSrcPath,
                                                       FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read))
                using (var metaOutputFile = new FileStream(tempMetaPath,
                                                           FileMode.OpenOrCreate, FileAccess.ReadWrite, FileShare.Read))

                    using (var codeWriter = new StreamWriter(codeOutputFile))
                        using (var metaWriter = new StreamWriter(metaOutputFile))

                            using (var outputFile = new FileStream(outputFilePath,
                                                                   FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read))
                                using (var outputWriter = new StreamWriter(outputFile))
                                {
                                    codeOutputFile.SetLength(0);
                                    metaOutputFile.SetLength(0);

                                    var context = CompileFromSource(
                                        platform,
                                        flags,
                                        errorWriter,
                                        warningWriter,
                                        logWriter,
                                        metaWriter,
                                        codeWriter,
                                        sourceCodePath
                                        );

                                    codeWriter.Flush();
                                    metaWriter.Flush();

                                    codeOutputFile.Flush();
                                    metaOutputFile.Flush();

                                    codeOutputFile.Position = 0;
                                    metaOutputFile.Position = 0;

                                    var codeReader = new StreamReader(codeOutputFile);
                                    var metaReader = new StreamReader(metaOutputFile);

                                    outputFile.SetLength(0);

                                    string line;
                                    while ((line = metaReader.ReadLine()) != null)
                                    {
                                        outputWriter.WriteLine(line);
                                    }

                                    if (context.Flags.UseSegments)
                                    {
                                        context.GetMetaInfoTranspiler().WriteSeparator(context, outputWriter);
                                    }

                                    while ((line = codeReader.ReadLine()) != null)
                                    {
                                        outputWriter.WriteLine(line);
                                    }
                                }
        }