public void Run()
        {
            string[] scripts = this.buildTargets.GetScriptsToCompile(this.scriptName);
            BuildSourceFilesCollection partitionedScripts = this.buildTargets.GetSourceFiles(scripts);
            TES5GlobalVariables        globalVariables    = this.esmAnalyzer.GlobalVariables;

            foreach (var buildTarget in this.buildTargets)
            {
                Dictionary <string, TES5GlobalScope> scriptsScopes = new Dictionary <string, TES5GlobalScope>();
                foreach (var buildScript in scripts)
                {
                    string scriptName = Path.GetFileNameWithoutExtension(buildScript);
                    string sourcePath = buildTarget.GetSourceFromPath(scriptName);
                    //string outputPath = buildTarget.getTranspileToPath(scriptName);
                    scriptsScopes.Add(scriptName, buildTarget.BuildScope(sourcePath, globalVariables));
                }

                TES5MultipleScriptsScope multipleScriptsScope = new TES5MultipleScriptsScope(scriptsScopes.Values, globalVariables);
                foreach (var buildScript in scripts)
                {
                    string          scriptName  = Path.GetFileNameWithoutExtension(buildScript);
                    string          sourcePath  = buildTarget.GetSourceFromPath(scriptName);
                    string          outputPath  = buildTarget.GetTranspileToPath(scriptName);
                    TES5GlobalScope globalScope = buildTarget.BuildScope(sourcePath, globalVariables);
                    buildTarget.Transpile(sourcePath, outputPath, globalScope, multipleScriptsScope);
                }
            }
        }
        public void Execute(string targets)
        {
            if (!PreExecutionChecks(true, true, false, false))
            {
                return;
            }
            Directory.CreateDirectory(DataDirectory.GetGraphDirectoryPath());
            Build build = new Build(Build.DEFAULT_BUILD_PATH); //This argument might well not be important in this case

            BuildTarget[]       buildTargets       = BuildTargetFactory.ParseCollection(targets, build);
            BuildTargetSimple[] buildTargetsSimple = BuildTargetFactory.GetCollection(buildTargets);
            ProgressWriter?     progressWriter     = null;
            Dictionary <string, List <string> > dependencyGraph = new Dictionary <string, List <string> >();
            Dictionary <string, List <string> > usageGraph      = new Dictionary <string, List <string> >();

            using (ESMAnalyzer esmAnalyzer = ESMAnalyzer.Load())
            {
                progressWriter = new ProgressWriter("Building Interoperable Compilation Graph", buildTargets.GetTotalSourceFiles());
                BuildSourceFilesCollection <BuildTargetSimple> sourceFiles = buildTargetsSimple.GetSourceFiles();
                using (StreamWriter errorLog = new StreamWriter(TES5ScriptDependencyGraph.ErrorLogPath, false))
                {
                    using (StreamWriter debugLog = new StreamWriter(TES5ScriptDependencyGraph.DebugLogPath, false))
                    {
                        foreach (var kvp in sourceFiles)
                        {
                            BuildTargetSimple buildTarget = kvp.Key;
                            var sourceBuildFiles          = kvp.Value;
                            foreach (var sourceFile in sourceBuildFiles)
                            {
                                string scriptName = sourceFile.Substring(0, sourceFile.Length - 4);//remove extension
                                string source     = buildTarget.GetSourceFromPath(scriptName);
                                ITES4CodeFilterable ast;
                                try
                                {
                                    ast = buildTarget.GetAST(source);
                                }
                                catch (EOFOnlyException) { continue; }//Ignore files that are only whitespace or comments.

                                /*catch (UnexpectedTokenException ex)
                                 * {//UnexpectedTokenExceptions no longer occur, so this code should not be invoked.
                                 *  errorLog.WriteLine(sourceFile + ":  " + ex.Message + Environment.NewLine);
                                 *  continue;
                                 * }*/
                                List <TES4ObjectProperty> propertiesAccesses = new List <TES4ObjectProperty>();
                                ast.Filter((data) =>
                                {
                                    TES4ObjectProperty?property = data as TES4ObjectProperty;
                                    if (property == null)
                                    {
                                        return(false);
                                    }
                                    propertiesAccesses.Add(property);
                                    return(true);
                                });
                                Dictionary <string, ITES5Type> preparedProperties = new Dictionary <string, ITES5Type>();
                                foreach (var property in propertiesAccesses)
                                {
                                    Match  match           = TES5ReferenceFactory.ReferenceAndPropertyNameRegex.Match(property.StringValue);
                                    string propertyName    = match.Groups[1].Value;
                                    string propertyKeyName = propertyName.ToLower();
                                    preparedProperties.AddIfNotContainsKey(propertyKeyName, () => esmAnalyzer.GetScriptTypeByEDID(propertyName));
                                }

                                debugLog.WriteLine(scriptName + " - " + preparedProperties.Count + " prepared");
                                string lowerScriptType = scriptName.ToLower();
                                foreach (var kvp2 in preparedProperties)
                                {
                                    var    preparedPropertyKey = kvp2.Key;
                                    string propertyTypeName    = preparedProperties[preparedPropertyKey].OriginalName;
                                    //Only keys are lowercased.
                                    string lowerPropertyType = propertyTypeName.ToLower();
                                    dependencyGraph.AddNewListIfNotContainsKeyAndAddValueToList(lowerPropertyType, lowerScriptType);
                                    usageGraph.AddNewListIfNotContainsKeyAndAddValueToList(lowerScriptType, lowerPropertyType);
                                    debugLog.WriteLine("Registering a dependency from " + scriptName + " to " + propertyTypeName);
                                }

                                progressWriter.IncrementAndWrite();
                            }
                        }
                    }
                }
            }
            progressWriter.Write("Saving");
            TES5ScriptDependencyGraph graph = new TES5ScriptDependencyGraph(dependencyGraph, usageGraph);

            buildTargets.WriteGraph(graph);
            progressWriter.WriteLast();
        }
        public void Execute(string targets)
        {
            if (!PreExecutionChecks(true, true, false, false))
            {
                return;
            }
            Directory.CreateDirectory(DataDirectory.GetGraphDirectoryPath());
            Build build = new Build(Build.DEFAULT_BUILD_PATH); //This argument might well not be important in this case

            using (BuildLogServices buildLogServices = new BuildLogServices(build))
            {
                BuildTargetCollection buildTargets = BuildTargetFactory.GetCollection(targets, build, buildLogServices);
                //if (!buildTargets.CanBuildAndWarnIfNot()) { return; }//WTM:  Change:  This doesn't matter for building graphs.
                Dictionary <string, List <string> > dependencyGraph = new Dictionary <string, List <string> >();
                Dictionary <string, List <string> > usageGraph      = new Dictionary <string, List <string> >();
                BuildSourceFilesCollection          sourceFiles     = buildTargets.GetSourceFiles();
                ProgressWriter     progressWriter = new ProgressWriter("Building Interoperable Compilation Graph", buildTargets.GetTotalSourceFiles());
                TES5TypeInferencer inferencer     = new TES5TypeInferencer(new ESMAnalyzer(), BuildTarget.StandaloneSourcePath);
                using (StreamWriter errorLog = new StreamWriter(TES5ScriptDependencyGraph.ErrorLogPath, false))
                {
                    using (StreamWriter debugLog = new StreamWriter(TES5ScriptDependencyGraph.DebugLogPath, false))
                    {
                        foreach (var kvp in sourceFiles)
                        {
                            var         buildTargetName  = kvp.Key;
                            var         sourceBuildFiles = kvp.Value;
                            BuildTarget buildTarget      = buildTargets.GetByName(buildTargetName);
                            foreach (var sourceFile in sourceBuildFiles)
                            {
                                string scriptName = sourceFile.Substring(0, sourceFile.Length - 4);
                                ITES4CodeFilterable AST;
                                try
                                {
                                    AST = buildTarget.GetAST(buildTarget.GetSourceFromPath(scriptName));
                                }
                                catch (EOFOnlyException) { continue; }//Ignore files that are only whitespace or comments.

                                /*catch (UnexpectedTokenException ex)
                                 * {//Exceptions no longer occur, so this code should not be invoked.
                                 *  errorLog.WriteLine(sourceFile + ":  " + ex.Message + Environment.NewLine);
                                 *  continue;
                                 * }*/
                                List <TES4ObjectProperty> propertiesAccesses = new List <TES4ObjectProperty>();
                                AST.Filter((data) =>
                                {
                                    TES4ObjectProperty property = data as TES4ObjectProperty;
                                    if (property == null)
                                    {
                                        return(false);
                                    }
                                    propertiesAccesses.Add(property);
                                    return(true);
                                });
                                Dictionary <string, TES5Property> preparedProperties      = new Dictionary <string, TES5Property>();
                                Dictionary <string, ITES5Type>    preparedPropertiesTypes = new Dictionary <string, ITES5Type>();
                                foreach (var property in propertiesAccesses)
                                {
                                    Match        match           = TES5ReferenceFactory.PropertyNameRegex.Match(property.StringValue);
                                    string       propertyName    = match.Groups[1].Value;
                                    string       propertyKeyName = propertyName.ToLower();
                                    bool         containedKey;
                                    TES5Property preparedProperty = preparedProperties.GetOrAdd(propertyKeyName, () => new TES5Property(propertyName, TES5BasicType.T_FORM, propertyName), out containedKey);
                                    ITES5Type    inferencingType  = inferencer.ResolveInferenceTypeByReferenceEdid(preparedProperty);
                                    if (!containedKey)
                                    {
                                        preparedPropertiesTypes.Add(propertyKeyName, inferencingType);
                                    }
                                    else
                                    {
                                        if (!inferencingType.Equals(preparedPropertiesTypes[propertyKeyName]))
                                        {
                                            throw new ConversionException("Cannot settle up the properties types - conflict.");
                                        }
                                    }
                                }

                                debugLog.WriteLine(scriptName + " - " + preparedProperties.Count + " prepared");
                                string lowerScriptType = scriptName.ToLower();
                                foreach (var kvp2 in preparedProperties)
                                {
                                    var    preparedPropertyKey = kvp2.Key;
                                    var    preparedProperty    = kvp2.Value;
                                    string propertyTypeName    = preparedPropertiesTypes[preparedPropertyKey].OriginalName;
                                    //Only keys are lowercased.
                                    string lowerPropertyType = propertyTypeName.ToLower();
                                    dependencyGraph.AddNewListIfNotContainsKeyAndAddValueToList(lowerPropertyType, lowerScriptType);
                                    usageGraph.AddNewListIfNotContainsKeyAndAddValueToList(lowerScriptType, lowerPropertyType);
                                    debugLog.WriteLine("Registering a dependency from " + scriptName + " to " + propertyTypeName);
                                }

                                progressWriter.IncrementAndWrite();
                            }
                        }
                    }
                }
                progressWriter.Write("Saving");
                TES5ScriptDependencyGraph graph = new TES5ScriptDependencyGraph(dependencyGraph, usageGraph);
                buildTargets.WriteGraph(graph);
                progressWriter.WriteLast();
            }
        }