internal static bool TryCreate(RubyContext /*!*/ context, string /*!*/ path, out FileSystemInfo result) { PlatformAdaptationLayer pal = context.Platform; result = null; if (pal.FileExists(path)) { result = new FileInfo(path); } else if (pal.DirectoryExists(path)) { result = new DirectoryInfo(path); #if !SILVERLIGHT } else if (path.ToUpperInvariant().Equals(NUL_VALUE)) { result = new DeviceInfo(NUL_VALUE); #endif } else { return(false); } return(true); }
private void TestPath(string path, int patternEnd, bool isLastPathSegment) { if (!isLastPathSegment) { DoGlob(path, patternEnd, false); return; } if (!NoEscapes) { path = Unescape(path, _stripTwo ? 2 : 0); } else if (_stripTwo) { path = path.Substring(2); } if (_pal.DirectoryExists(path)) { _result.Add(path); } else if (!_dirOnly && _pal.FileExists(path)) { _result.Add(path); } }
public override bool FileExists(string path) { if (IsRelativePath(path)) { return(getDirectory().GetFile(path.Substring(2)).Exists); } else { return(innerPal.FileExists(path)); } }
public override bool FileExists(string path) { if (IsRelativePath(path)) { path = RemoveDotSlash(path); return(getDirectory().GetFile(path).Exists); } else { return(innerPal.FileExists(path)); } }
private static PythonTuple FindModulePath(CodeContext /*!*/ context, string name, List path) { Debug.Assert(path != null); if (name == null) { throw PythonOps.TypeError("find_module() argument 1 must be string, not None"); } PlatformAdaptationLayer pal = context.LanguageContext.DomainManager.Platform; foreach (object d in path) { string dir = d as string; if (dir == null) { continue; // skip invalid entries } string pathName = Path.Combine(dir, name); if (pal.DirectoryExists(pathName)) { if (pal.FileExists(Path.Combine(pathName, "__init__.py"))) { return(PythonTuple.MakeTuple(null, pathName, PythonTuple.MakeTuple("", "", PackageDirectory))); } } string fileName = pathName + ".py"; if (pal.FileExists(fileName)) { Stream fs = pal.OpenInputFileStream(fileName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite); PythonFile pf = PythonFile.Create(context, fs, fileName, "U"); return(PythonTuple.MakeTuple(pf, fileName, PythonTuple.MakeTuple(".py", "U", PythonSource))); } } throw PythonOps.ImportError("No module named {0}", name); }
private void TestPath(string path, int patternEnd, bool isLastPathSegment) { if (!isLastPathSegment) { DoGlob(path, patternEnd, false); return; } string pathName = path.Replace('\\', '/'); if (_stripTwo) { pathName = pathName.Substring(2); } if (_pal.DirectoryExists(pathName)) { _result.Add(pathName); } else if (!_dirOnly && _pal.FileExists(pathName)) { _result.Add(pathName); } }
internal static bool TryCreate(RubyContext /*!*/ context, string /*!*/ path, out FileSystemInfo result) { PlatformAdaptationLayer pal = context.DomainManager.Platform; result = null; if (pal.FileExists(path)) { result = new FileInfo(path); } else if (pal.DirectoryExists(path)) { result = new DirectoryInfo(path); } else if (path.ToUpper().Equals(NUL_VALUE)) { result = null; } else { return(false); } return(true); }
public zipimporter(CodeContext /*!*/ context, object pathObj, [ParamDictionary] IDictionary <object, object> kwArgs) { PlatformAdaptationLayer pal = context.LanguageContext.DomainManager.Platform; string prefix, input, path; if (pathObj == null) { throw PythonOps.TypeError("must be string, not None"); } if (!(pathObj is string)) { throw PythonOps.TypeError("must be string, not {0}", pathObj.GetType()); } if (kwArgs.Count > 0) { throw PythonOps.TypeError("zipimporter() does not take keyword arguments"); } path = pathObj as string; if (path.Length == 0) { throw MakeError(context, "archive path is empty"); } if (path.Length > MAXPATHLEN) { throw MakeError(context, "archive path too long"); } string buf = path.Replace(Path.AltDirectorySeparatorChar, Path.DirectorySeparatorChar); input = buf; path = string.Empty; prefix = string.Empty; try { while (!string.IsNullOrEmpty(buf)) { if (pal.FileExists(buf)) { path = buf; break; } buf = Path.GetDirectoryName(buf); } } catch { throw MakeError(context, "not a Zip file"); } if (!string.IsNullOrEmpty(path)) { PythonDictionary zip_directory_cache = context.LanguageContext.GetModuleState( _zip_directory_cache_key) as PythonDictionary; if (zip_directory_cache != null && zip_directory_cache.ContainsKey(path)) { _files = zip_directory_cache[path] as PythonDictionary; } else { _files = ReadDirectory(context, path); zip_directory_cache.Add(path, _files); } } else { throw MakeError(context, "not a Zip file"); } _prefix = input.Replace(path, string.Empty); // add trailing SEP if (!string.IsNullOrEmpty(_prefix) && !_prefix.EndsWith(Path.DirectorySeparatorChar.ToString(), StringComparison.Ordinal)) { _prefix = _prefix.Substring(1); _prefix += Path.DirectorySeparatorChar; } _archive = path; }
private static void GetExecutable(PlatformAdaptationLayer /*!*/ pal, string /*!*/ command, out string executable, out string arguments) { command = command.Trim(' '); if (command.Length == 0) { throw RubyExceptions.CreateEINVAL(command); } // This seems to be quite complicated: // 1) If the first part of the command is a shell command (DIR, ECHO, ...) or // if the command contains unquoted <, > or | then // it uses ENV['COMSPEC'] to execute the command: %COMSPEC% /c "COMMAND" // 2) It looks for the shortest prefix of command that is separated by space from the rest of the command that is either // a) An absolute path to an executable file. // b) Try prepend paths from ENV['PATH'] // c) Try Environment.SpecialFolder.System. // d) Try SHGetFolderPath(CSIDL_WINDOWS) - we can't get this from Environment.SpecialFolder, so we need to use // ENV["SystemRoot"] environment variable. // In each step it tries to append ".exe" or ".com" extension if the path doesn't exist. // // For example, if the command is `x/a b/x` and the directory structure is // x\a b\x.exe // x\a.exe // it executes a.exe. // // MRI probably calls CreateProcess Win32 API with lpApplicationName it resolves as described above and // lpCommandLine == command. System.Diagnostics.Process also uses this API with lpApplicationName == NULL and // lpCommandLine == '"{ProcessStartInfo.FileName}" {ProcessStartInfo.Arguments}'. // // Although CreateProcess does all the searching for an executable if passed no lpApplicationName, // we need to do it ourselves because it is slightly different in MRI (is that a bug?) and also because System.Diagnostics.Process // quotes the FileName :( // string comspec = pal.GetEnvironmentVariable("COMSPEC"); if (!pal.FileExists(comspec)) { comspec = null; } if (comspec != null && IndexOfUnquotedSpecialCharacter(command) >= 0) { executable = comspec; arguments = "/c \"" + command + "\""; return; } int start = 0; while (true) { int next = command.IndexOf(' ', start); executable = (next >= 0) ? command.Substring(0, next) : command; arguments = (next >= 0) ? command.Substring(next + 1) : ""; if (start == 0 && comspec != null && IsShellCommand(executable)) { executable = comspec; arguments = "/c \"" + command + "\""; return; } try { foreach (var path in GetExecutableFiles(pal, executable)) { if (pal.FileExists(path)) { // We need to set the path we found as executable. Althought makes command line of the target process // different from when called by MRI it will execute the right process. If we passed the original executable name // CreateProcess might resolve it to a different executable. executable = path; return; } } } catch (Exception e) { if (next < 0) { throw RubyExceptions.CreateENOENT(command, e); } } if (next < 0) { throw RubyExceptions.CreateENOENT(command); } start = next + 1; while (start < command.Length && command[start] == ' ') { start++; } } }