private static StringCollection GetCompilersOnPath() { PathScanner scanner = new PathScanner(); scanner.Add("cl.exe"); return(scanner.Scan("PATH")); }
/// <summary> /// Routine which checks if the resource compiler is present. /// </summary> /// <returns> /// <see langword="true" /> if the resource compiler is present; /// otherwise, <see langword="false" />. /// </returns> private static bool CheckResourceCompilerPresent() { PathScanner scanner = new PathScanner(); scanner.Add("rc.exe"); return(scanner.Scan("PATH").Count > 0); }
/// <summary> /// Routine which checks if the header files are present. /// </summary> /// <returns> /// <see langword="true" /> if the header files are present; otherwise, /// <see langword="false" />. /// </returns> private static bool CheckHeaderFilesPresent() { foreach (string headerFile in ExpectedHeaderFiles) { PathScanner scanner = new PathScanner(); scanner.Add(headerFile); if (scanner.Scan("INCLUDE").Count == 0) { return(false); } } return(true); }
/// <summary> /// Routine which checks if the libs are present. /// </summary> /// <returns> /// <see langword="true" /> if the libs are present; otherwise, /// <see langword="false" />. /// </returns> private static bool CheckLibsPresent() { foreach (string lib in ExpectedLibs) { PathScanner scanner = new PathScanner(); scanner.Add(lib); if (scanner.Scan("LIB").Count == 0) { return(false); } } return(true); }
private void AddChange(FsChange fsChange, bool notifyHasWork = true, bool withSubdirectories = false) { lock (_changes) { if (_changes.TryGetValue(fsChange.Path, out var oldFsChange)) { oldFsChange.Expired = true; } _changes[fsChange.Path] = fsChange; } if (withSubdirectories) { _pathScanner.Add(fsChange.Path); } if (notifyHasWork) { UpdateHasWork(); } }
private void AddChange(FsSenderChange fsSenderChange, bool notifyHasWork = true, bool withSubdirectories = false) { // ignore empty path if (string.IsNullOrEmpty(fsSenderChange.Path)) { return; } lock (_changes) { if (_changes.TryGetValue(fsSenderChange.Path, out var oldFsChange)) { oldFsChange.Expired = true; } if (fsSenderChange.ChangeType == FsChangeType.Rename && _changes.TryGetValue(fsSenderChange.OldPath, out var oldPathFsChange)) { // rename -> delete old, create new oldPathFsChange.Expired = true; _changes[fsSenderChange.OldPath] = FsSenderChange.CreateRemove(fsSenderChange.OldPath); fsSenderChange = FsSenderChange.CreateChange(fsSenderChange.Path); } _changes[fsSenderChange.Path] = fsSenderChange; } if (withSubdirectories) { _pathScanner.Add(fsSenderChange.Path); } if (notifyHasWork) { UpdateHasWork(); } }
protected string MKSExecute(string command) { // locate Source Integrity client on PATH PathScanner pathScanner = new PathScanner(); pathScanner.Add("si.exe"); StringCollection files = pathScanner.Scan(); if (files.Count == 0) { throw new BuildException("Could not find MKS Integrity Client on the system path.", Location); } // set up process Process proc = new Process(); proc.StartInfo.UseShellExecute = false; proc.StartInfo.CreateNoWindow = true; proc.StartInfo.RedirectStandardOutput = true; proc.StartInfo.RedirectStandardError = true; proc.StartInfo.FileName = files[0]; proc.StartInfo.Arguments = command; proc.Start(); proc.WaitForExit(); if (proc.ExitCode != 0) { throw new BuildException(proc.ExitCode.ToString(), Location, new Exception(proc.StandardError.ReadToEnd())); } else { return(proc.StandardOutput.ReadToEnd()); } }
/// <summary> /// Determines whether any file that are includes in the specified /// source file has been updated after the obj was compiled. /// </summary> /// <param name="srcFileName">The source file to check.</param> /// <param name="objLastWriteTime">The last write time of the compiled obj.</param> /// <returns> /// The full path to the include file that was modified after the obj /// was compiled, or <see langword="null" /> if no include files were /// modified since the obj was compiled. /// </returns> /// <remarks> /// <para> /// To determine what includes are defined in a source file, conditional /// directives are not honored. /// </para> /// <para> /// If a given include cannot be resolved to an existing file, then /// it will be considered stable. /// </para> /// </remarks> private string FindUpdatedInclude(string srcFileName, DateTime objLastWriteTime) { // quick and dirty code to check whether includes have been modified // after the source was last modified // TODO: recursively check includes Log(Level.Debug, "Checking whether includes of \"{0}\" have been" + " updated.", srcFileName); // holds the line we're parsing string line; // locate include directives in source file using (StreamReader sr = new StreamReader(srcFileName, true)) { while ((line = sr.ReadLine()) != null) { Match match = _includeRegex.Match(line); if (match.Groups.Count != 2) { continue; } string includeFile = match.Groups["includefile"].Value; Log(Level.Debug, "Checking include \"{0}\"...", includeFile); string resolvedInclude = _resolvedIncludes[includeFile] as string; if (resolvedInclude == null) { foreach (string includeDir in IncludeDirs.DirectoryNames) { string foundIncludeFile = FileUtils.CombinePaths(includeDir, includeFile); if (File.Exists(foundIncludeFile)) { Log(Level.Debug, "Found include \"{0}\" in" + " includedirs.", includeFile); resolvedInclude = foundIncludeFile; break; } } // if we could not locate include in include dirs and // source dir, then try to locate include in INCLUDE // env var if (resolvedInclude == null) { PathScanner pathScanner = new PathScanner(); pathScanner.Add(includeFile); StringCollection includes = pathScanner.Scan("INCLUDE"); if (includes.Count > 0) { Log(Level.Debug, "Found include \"{0}\" in" + " INCLUDE.", includeFile); resolvedInclude = includes[0]; } } // if we could not locate include in include dirs // and INCLUDE env var then check for include in base // directory (which is used as working dir) if (resolvedInclude == null) { string foundIncludeFile = FileUtils.CombinePaths( BaseDirectory.FullName, includeFile); if (File.Exists(foundIncludeFile)) { Log(Level.Debug, "Found include \"{0}\" in" + " working directory.", includeFile); resolvedInclude = foundIncludeFile; } } if (resolvedInclude != null) { _resolvedIncludes.Add(includeFile, resolvedInclude); } } if (resolvedInclude != null) { if (File.GetLastWriteTime(resolvedInclude) > objLastWriteTime) { return resolvedInclude; } } else { // TODO: what do we do if the include cannot be located ? // // for now we'll consider the obj file to be up-to-date Log(Level.Debug, "Include \"{0}\" could not be located.", includeFile); } } } return null; }
private void AddChange(FsSenderChange fsSenderChange, bool notifyHasWork = true, bool withSubdirectories = false) { if (_logger.IsDebug) { _logger.Log($"AddChange {fsSenderChange}", LogLevel.Debug); } // ignore empty path if (string.IsNullOrEmpty(fsSenderChange.Path)) { return; } lock (_changes) { if (_changes.TryGetValue(fsSenderChange.Path, out var oldFsChange)) { oldFsChange.Expired = true; _changes.Remove(oldFsChange.Path); // Rename + Change -> Combine if (fsSenderChange.IsChange && oldFsChange.IsRename) { fsSenderChange.Combine(oldFsChange); } } _changes.Add(fsSenderChange.Path, fsSenderChange); if (fsSenderChange.IsRename) { // replace changes inside OldPath to Path var oldPathPrefix = fsSenderChange.OldPath + "/"; var insideOldPathFsChanges = _changes.Values .Where(fsChange => !fsChange.Opened && (((fsChange.IsChange || fsChange.IsRename) && fsChange.Path.StartsWith(oldPathPrefix)) || (fsChange.IsRename && fsChange.OldPath.StartsWith(oldPathPrefix))) ) .ToList(); var index = oldPathPrefix.Length - 1; foreach (var insideOldPathFsChange in insideOldPathFsChanges) { insideOldPathFsChange.Expired = true; _changes.Remove(insideOldPathFsChange.Path); // update Path var newPath = insideOldPathFsChange.Path.StartsWith(oldPathPrefix) ? string.Concat(fsSenderChange.Path, insideOldPathFsChange.Path.AsSpan(index)) : insideOldPathFsChange.Path; var newChange = FsSenderChange.CreateWithPath(insideOldPathFsChange, newPath); // update OldPath if (newChange.IsRename && newChange.OldPath.StartsWith(oldPathPrefix)) { newChange.OldPath = string.Concat(fsSenderChange.Path, newChange.OldPath.AsSpan(index)); } AddChange(newChange); } // expire and combine change with OldPath if (_changes.TryGetValue(fsSenderChange.OldPath, out var oldPathFsChange) && !oldPathFsChange.Opened && oldPathFsChange.IsChange) { oldPathFsChange.Expired = true; // Change + Rename -> Combine fsSenderChange.Combine(oldPathFsChange); } } } if (withSubdirectories) { _pathScanner.Add(fsSenderChange.Path); } if (notifyHasWork) { UpdateHasWork(); } }