/////////////////////////////////////////////////////////////////////// bool IDictionary <string, T> .ContainsKey( string key ) { return(base.ContainsKey( PathOps.TranslatePath(key, translationType))); }
/////////////////////////////////////////////////////////////////////// public new bool ContainsKey( string key ) { return(base.ContainsKey( PathOps.TranslatePath(key, translationType))); }
/////////////////////////////////////////////////////////////////////////////////////////////// public static bool MatchFileName( Interpreter interpreter, IScriptLocation location1, IScriptLocation location2, bool exact ) { if ((location1 == null) && (location2 == null)) { return(true); } else if ((location1 == null) || (location2 == null)) { return(false); } else if (exact) { if (PathOps.HasPathWildcard(location1.FileName) || PathOps.HasPathWildcard(location2.FileName)) { return(false); } } return(MatchFileName(interpreter, location1.FileName, location2.FileName)); }
/////////////////////////////////////////////////////////////////////////////////////////////// public override int GetHashCode() { return(CommonOps.HashCodes.Combine( PathOps.GetHashCode(fileName), startLine.GetHashCode(), endLine.GetHashCode())); }
/////////////////////////////////////////////////////////////////////// void IDictionary <string, T> .Add( string key, T value ) { base.Add(PathOps.TranslatePath(key, translationType), value); }
/////////////////////////////////////////////////////////////////////// public new void Add( string key, T value ) { base.Add(PathOps.TranslatePath(key, translationType), value); }
/////////////////////////////////////////////////////////////////////// bool IDictionary <string, T> .TryGetValue( string key, out T value ) { return(base.TryGetValue( PathOps.TranslatePath(key, translationType), out value)); }
/////////////////////////////////////////////////////////////////////// public new bool TryGetValue( string key, out T value ) { return(base.TryGetValue( PathOps.TranslatePath(key, translationType), out value)); }
/////////////////////////////////////////////////////////////////////////////////////////////// public StringPairList ToList(bool scrub) { StringPairList list = new StringPairList(); list.Add("FileName", scrub ? PathOps.ScrubPath( GlobalState.GetBasePath(), fileName) : fileName); list.Add("StartLine", startLine.ToString()); list.Add("EndLine", endLine.ToString()); list.Add("ViaSource", viaSource.ToString()); return(list); }
/////////////////////////////////////////////////////////////////////////////////////////////// #region Public Static Methods public static string NormalizeFileName( Interpreter interpreter, string fileName ) { if (!PathOps.HasPathWildcard(fileName) && PathOps.HasDirectory(fileName)) { return(PathOps.GetUnixPath(PathOps.ResolveFullPath( interpreter, fileName))); } return(fileName); }
/////////////////////////////////////////////////////////////////////// public StringPairList ToList( bool scrub ) { StringPairList list = new StringPairList(); list.Add("type", type); list.Add("text", text); list.Add("fileName", scrub ? PathOps.ScrubPath( GlobalState.GetBasePath(), fileName) : fileName); list.Add("startLine", startLine.ToString()); list.Add("endLine", endLine.ToString()); list.Add("viaSource", viaSource.ToString()); list.Add("engineMode", engineMode.ToString()); list.Add("scriptFlags", scriptFlags.ToString()); list.Add("engineFlags", engineFlags.ToString()); list.Add("substitutionFlags", substitutionFlags.ToString()); list.Add("eventFlags", eventFlags.ToString()); list.Add("expressionFlags", expressionFlags.ToString()); #if XML list.Add("blockType", blockType.ToString()); list.Add("timeStamp", timeStamp.ToString()); list.Add("publicKeyToken", publicKeyToken); list.Add("signature", ArrayOps.ToHexadecimalString(signature)); #endif #if CAS_POLICY if (!scrub) { list.Add("evidence", (evidence != null) ? evidence.ToString() : null); list.Add("hashValue", ArrayOps.ToHexadecimalString(hashValue)); list.Add("hashAlgorithm", (hashAlgorithm != null) ? hashAlgorithm.ToString() : null); } #endif return(list); }
/////////////////////////////////////////////////////////////////////// public static ReturnCode GetCertificate2( string fileName, ref X509Certificate2 certificate2, ref Result error ) { X509Certificate certificate = null; if (GetCertificate(fileName, ref certificate, ref error) == ReturnCode.Ok) { if (certificate != null) { try { certificate2 = new X509Certificate2(certificate); return(ReturnCode.Ok); } catch (Exception e) { error = e; } } else { error = "invalid certificate"; } } #if DEBUG if (!PathOps.IsSameFile( Interpreter.GetActive(), fileName, GlobalState.GetAssemblyLocation())) #endif { TraceOps.DebugTrace(String.Format( "GetCertificate2: file {0} query failure, error = {1}", FormatOps.WrapOrNull(fileName), FormatOps.WrapOrNull(true, true, error)), typeof(CertificateOps).Name, TracePriority.SecurityError); } return(ReturnCode.Error); }
/////////////////////////////////////////////////////////////////////////////////////////////// public static bool MatchFileName( Interpreter interpreter, string path1, string path2 ) { // // BUGBUG: This might be too slow? // if (PathOps.HasPathWildcard(path2)) { return(StringOps.Match( interpreter, StringOps.DefaultMatchMode, path1, path2, PathOps.NoCase)); } else { return(PathOps.IsSameFile(interpreter, path1, path2)); } }
/////////////////////////////////////////////////////////////////////// #region IPlugin Members public override Stream GetStream( Interpreter interpreter, string name, ref Result error ) { if (String.IsNullOrEmpty(name)) { error = "invalid stream name"; return(null); } Assembly assembly = this.Assembly; if (assembly == null) { error = "plugin assembly not available"; return(null); } try { Stream stream = assembly.GetManifestResourceStream( PathOps.MakeRelativePath(name, true)); if (stream != null) { return(stream); } else { error = "stream not found"; } } catch (Exception e) { error = e; } return(null); }
/////////////////////////////////////////////////////////////////////// #region Public Certificate Methods public static ReturnCode GetCertificate( string fileName, ref X509Certificate certificate, ref Result error ) { if (!String.IsNullOrEmpty(fileName)) { try { certificate = X509Certificate.CreateFromSignedFile( fileName); return(ReturnCode.Ok); } catch (Exception e) { error = e; } } else { error = "invalid file name"; } #if DEBUG if (!PathOps.IsSameFile( Interpreter.GetActive(), fileName, GlobalState.GetAssemblyLocation())) #endif { TraceOps.DebugTrace(String.Format( "GetCertificate: file {0} query failure, error = {1}", FormatOps.WrapOrNull(fileName), FormatOps.WrapOrNull(true, true, error)), typeof(CertificateOps).Name, TracePriority.SecurityError); } return(ReturnCode.Error); }
public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { ReturnCode code = ReturnCode.Ok; if (interpreter != null) { if (arguments != null) { if (arguments.Count == 1) { result = PathOps.GetUnixPath(Directory.GetCurrentDirectory()); } else { result = "wrong # args: should be \"pwd\""; code = ReturnCode.Error; } } else { result = "invalid argument list"; code = ReturnCode.Error; } } else { result = "invalid interpreter"; code = ReturnCode.Error; } return(code); }
/////////////////////////////////////////////////////////////////////////////////////////////// #region IComparer<IScriptLocation> Members public int Compare( IScriptLocation x, IScriptLocation y ) { if ((x == null) && (y == null)) { return(0); } else if (x == null) { return(-1); } else if (y == null) { return(1); } else { int result = PathOps.CompareFileNames(x.FileName, y.FileName); if (result != 0) { return(result); } result = LogicOps.Compare(x.StartLine, y.StartLine); if (result != 0) { return(result); } return(LogicOps.Compare(x.EndLine, y.EndLine)); } }
/////////////////////////////////////////////////////////////////////// public static ReturnCode LoadFile( string fileName, ref XmlDocument document, ref Result error ) { if (String.IsNullOrEmpty(fileName)) { error = "invalid file name"; return(ReturnCode.Error); } bool remoteUri = PathOps.IsRemoteUri(fileName); if (!remoteUri && !File.Exists(fileName)) { error = String.Format( "couldn't read file \"{0}\": no such file or directory", fileName); return(ReturnCode.Error); } try { document = new XmlDocument(); document.Load(fileName); /* throw */ return(ReturnCode.Ok); } catch (Exception e) { error = e; } return(ReturnCode.Error); }
/////////////////////////////////////////////////////////////////////// #region Generic Xml Handling Methods public static bool CouldBeDocument( string path ) { if (String.IsNullOrEmpty(path)) { return(false); } string extension = PathOps.GetExtension(path); if (String.IsNullOrEmpty(extension)) { return(false); } if (String.Equals(extension, FileExtension.Markup, PathOps.ComparisonType)) { return(true); } return(false); }
/////////////////////////////////////////////////////////////////////// #region System.Collections.Generic.IDictionary<string, TValue> Overrides T IDictionary <string, T> .this[string key] { get { return(base[PathOps.TranslatePath(key, translationType)]); } set { base[PathOps.TranslatePath(key, translationType)] = value; } }
/////////////////////////////////////////////////////////////////////// private static AppDomainSetup CreateSetup( Interpreter interpreter, /* OPTIONAL */ string baseDirectory, string packagePath, bool useBasePath, ref Result error ) { string basePath = baseDirectory; if (useBasePath && (basePath == null) && (interpreter != null)) { basePath = interpreter.PluginBaseDirectory; } Result localError = null; if (useBasePath && (basePath == null)) { basePath = GetBasePath( interpreter, packagePath, ref localError); } if (!useBasePath || (basePath != null)) { // // NOTE: Check if the package path is located under the base // path. // bool packageUnderBasePath = (packagePath != null) ? PathOps.IsUnderPath(interpreter, packagePath, basePath) : false; // // NOTE: Verify that the package path is either usable or // superfluous. // if ((packagePath == null) || !useBasePath || packageUnderBasePath) { // // NOTE: Grab the full path for the Eagle core library // assembly. // string assemblyPath = GetAssemblyPath(); // // NOTE: Check if the assembly path is located under // the base path. // bool assemblyUnderBasePath = (assemblyPath != null) ? PathOps.IsUnderPath(interpreter, assemblyPath, basePath) : false; // // NOTE: Verify that the assembly path is either usable // or superfluous. // if ((assemblyPath == null) || !useBasePath || assemblyUnderBasePath) { AppDomainSetup appDomainSetup = new AppDomainSetup(); // // NOTE: Use the base directory of the Eagle install // as the base directory for the new isolated // application domain. // appDomainSetup.ApplicationBase = useBasePath ? basePath : (packagePath != null) ? packagePath : assemblyPath; // // NOTE: If we are using the base path of the Eagle // core library assembly, then we need to modify // the private binary path so that it includes // both the directory containing that assembly // and the directory containing the package; // otherwise, we can simply skip this step. // if (useBasePath) { // // TODO: May need to add more options here. // string relativeAssemblyPath = (assemblyPath != null) && assemblyUnderBasePath? assemblyPath.Remove(0, basePath.Length).Trim( PathOps.DirectoryChars) : null; string privateBinPath = relativeAssemblyPath; string relativePackagePath = (packagePath != null) && packageUnderBasePath? packagePath.Remove(0, basePath.Length).Trim( PathOps.DirectoryChars) : null; if (!String.IsNullOrEmpty(relativePackagePath)) { if (!String.IsNullOrEmpty(privateBinPath)) { privateBinPath += Characters.SemiColon; } privateBinPath += relativePackagePath; } appDomainSetup.PrivateBinPath = privateBinPath; } return(appDomainSetup); } else { error = "assembly path is not under base path"; } } else { error = "package path is not under base path"; } } else if (localError == null) { error = "invalid base path"; } else { error = localError; } return(null); }
/////////////////////////////////////////////////////////////////////// #if APPDOMAINS || ISOLATED_INTERPRETERS || ISOLATED_PLUGINS private static string GetBasePath( Interpreter interpreter, /* OPTIONAL */ string packagePath, ref Result error ) { // // NOTE: Fetch the raw base directory for the currently executing // application binary. It is now possible to override the // value used here via the environment. // string path0 = AssemblyOps.GetAnchorPath(); if (path0 == null) { path0 = GlobalState.GetRawBinaryBasePath(); } // // NOTE: First, try to use the effective path to the core library // assembly. This is used to verify that this candidate // application domain base path contains the core library // assembly somewhere underneath it. // string path1 = GetAssemblyPath(); if (PathOps.IsUnderPath(interpreter, path1, path0)) { if ((packagePath == null) || PathOps.IsUnderPath(interpreter, packagePath, path0)) { return(path0); } } // // NOTE: Second, try to use the raw base path for the assembly. // This is used to verify that this candidate application // domain base path contains the core library assembly // somewhere underneath it. // string path2 = GlobalState.GetRawBasePath(); if (PathOps.IsUnderPath(interpreter, path1, path2)) { if ((packagePath == null) || PathOps.IsUnderPath(interpreter, packagePath, path2)) { return(path2); } } // // NOTE: At this point, we have failed to figure out a base path // for the application domain to be created that actually // contains the core library assembly. // error = String.Format( "cannot determine usable base path for the new application " + "domain for interpreter {0}, with the raw binary base path " + "{1}, assembly path {2}, and raw base path {3}", FormatOps.InterpreterNoThrow(interpreter), FormatOps.DisplayPath(path0), FormatOps.DisplayPath(path1), FormatOps.DisplayPath(path2)); return(null); }
/////////////////////////////////////////////////////////////////////////////////////////////// #region IExecute Members public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { ReturnCode code = ReturnCode.Ok; if (interpreter != null) { if (arguments != null) { if (arguments.Count >= 2) { string subCommand = arguments[1]; bool tried = false; code = ScriptOps.TryExecuteSubCommandFromEnsemble( interpreter, this, clientData, arguments, true, false, ref subCommand, ref tried, ref result); if ((code == ReturnCode.Ok) && !tried) { switch (subCommand) { case "forget": { if (arguments.Count >= 2) { code = interpreter.PkgForget( new StringList(arguments, 2), ref result); } else { result = "wrong # args: should be \"package forget ?package package ...?\""; code = ReturnCode.Error; } break; } case "ifneeded": { if ((arguments.Count == 4) || (arguments.Count == 5)) { Version version = null; code = Value.GetVersion( arguments[3], interpreter.CultureInfo, ref version, ref result); if (code == ReturnCode.Ok) { string text = null; if (arguments.Count == 5) { text = arguments[4]; } code = interpreter.PkgIfNeeded( arguments[2], version, text, interpreter.PackageFlags, ref result); } } else { result = "wrong # args: should be \"package ifneeded package version ?script?\""; code = ReturnCode.Error; } break; } case "indexes": { if ((arguments.Count == 2) || (arguments.Count == 3)) { string pattern = null; if (arguments.Count == 3) { pattern = arguments[2]; } code = interpreter.PkgIndexes( pattern, false, ref result); } else { result = "wrong # args: should be \"package indexes ?pattern?\""; code = ReturnCode.Error; } break; } case "info": { if (arguments.Count == 3) { IPackage package = null; code = interpreter.GetPackage( arguments[2], LookupFlags.Default, ref package, ref result); if (code == ReturnCode.Ok) { bool scrub = interpreter.IsSafe(); PackageFlags flags = package.Flags; Guid id = AttributeOps.GetObjectId(package); result = StringList.MakeList( "kind", package.Kind, "id", package.Id.Equals(Guid.Empty) ? id : package.Id, "name", package.Name, "description", package.Description, "indexFileName", scrub ? PathOps.ScrubPath( GlobalState.GetBasePath(), package.IndexFileName) : package.IndexFileName, "provideFileName", scrub ? PathOps.ScrubPath( GlobalState.GetBasePath(), package.ProvideFileName) : package.ProvideFileName, "flags", flags, "loaded", (package.Loaded != null) ? package.Loaded : null, "ifNeeded", (!scrub && (package.IfNeeded != null)) ? package.IfNeeded.KeysAndValuesToString(null, false) : null); } } else { result = "wrong # args: should be \"package info name\""; code = ReturnCode.Error; } break; } case "loaded": { if ((arguments.Count == 2) || (arguments.Count == 3)) { string pattern = null; if (arguments.Count == 3) { pattern = arguments[2]; } code = interpreter.PkgLoaded( pattern, false, false, ref result); } else { result = "wrong # args: should be \"package loaded ?pattern?\""; code = ReturnCode.Error; } break; } case "names": { if ((arguments.Count == 2) || (arguments.Count == 3)) { string pattern = null; if (arguments.Count == 3) { pattern = arguments[2]; } code = interpreter.PkgNames( pattern, false, ref result); } else { result = "wrong # args: should be \"package names ?pattern?\""; code = ReturnCode.Error; } break; } case "present": { if (arguments.Count >= 3) { OptionDictionary options = new OptionDictionary( new IOption[] { new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-exact", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null) }); int argumentIndex = Index.Invalid; code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, false, ref argumentIndex, ref result); if (code == ReturnCode.Ok) { if ((argumentIndex != Index.Invalid) && ((argumentIndex + 2) >= arguments.Count)) { bool exact = false; if (options.IsPresent("-exact")) { exact = true; } Version version = null; if ((argumentIndex + 1) < arguments.Count) { code = Value.GetVersion( arguments[argumentIndex + 1], interpreter.CultureInfo, ref version, ref result); } if (code == ReturnCode.Ok) { code = interpreter.PresentPackage( arguments[argumentIndex], version, exact, ref result); } } else { if ((argumentIndex != Index.Invalid) && Option.LooksLikeOption(arguments[argumentIndex])) { result = OptionDictionary.BadOption(options, arguments[argumentIndex]); } else { result = "wrong # args: should be \"package present ?-exact? package ?version?\""; } code = ReturnCode.Error; } } } else { result = "wrong # args: should be \"package present ?-exact? package ?version?\""; code = ReturnCode.Error; } break; } case "provide": { if ((arguments.Count == 3) || (arguments.Count == 4)) { PackageFlags flags = interpreter.PackageFlags; if (!FlagOps.HasFlags(flags, PackageFlags.NoProvide, true)) { Version version = null; if (arguments.Count == 4) { code = Value.GetVersion(arguments[3], interpreter.CultureInfo, ref version, ref result); } if (code == ReturnCode.Ok) { code = interpreter.PkgProvide(arguments[2], version, flags, ref result); } } else { // // HACK: Do nothing, provide no package, and return nothing. // result = String.Empty; code = ReturnCode.Ok; } } else { result = "wrong # args: should be \"package provide package ?version?\""; code = ReturnCode.Error; } break; } case "relativefilename": { if ((arguments.Count == 3) || (arguments.Count == 4)) { PathComparisonType pathComparisonType = PathComparisonType.Default; if (arguments.Count == 4) { object enumValue = EnumOps.TryParseFlagsEnum( interpreter, typeof(PathComparisonType), pathComparisonType.ToString(), arguments[3], interpreter.CultureInfo, true, true, true, ref result); if (enumValue is EventFlags) { pathComparisonType = (PathComparisonType)enumValue; } else { code = ReturnCode.Error; } } if (code == ReturnCode.Ok) { string fileName = null; code = PackageOps.GetRelativeFileName( interpreter, arguments[2], pathComparisonType, ref fileName, ref result); if (code == ReturnCode.Ok) { result = fileName; } } } else { result = "wrong # args: should be \"package relativefilename fileName ?type?\""; code = ReturnCode.Error; } break; } case "require": { if (arguments.Count >= 3) { OptionDictionary options = new OptionDictionary( new IOption[] { new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-exact", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null) }); int argumentIndex = Index.Invalid; code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, false, ref argumentIndex, ref result); if (code == ReturnCode.Ok) { if ((argumentIndex != Index.Invalid) && ((argumentIndex + 2) >= arguments.Count)) { bool exact = false; if (options.IsPresent("-exact")) { exact = true; } Version version = null; if ((argumentIndex + 1) < arguments.Count) { code = Value.GetVersion( arguments[argumentIndex + 1], interpreter.CultureInfo, ref version, ref result); } if (code == ReturnCode.Ok) { code = interpreter.RequirePackage( arguments[argumentIndex], version, exact, ref result); } // // NOTE: This is a new feature. If the initial attempt to // require a package fails, call the package fallback // delegate for the interpreter and then try requiring // the package again. // if ((code != ReturnCode.Ok) && !ScriptOps.HasFlags( interpreter, InterpreterFlags.NoPackageFallback, true)) { PackageCallback packageFallback = interpreter.PackageFallback; if (packageFallback != null) { code = packageFallback( interpreter, arguments[argumentIndex], version, null, interpreter.PackageFlags, exact, ref result); if (code == ReturnCode.Ok) { code = interpreter.RequirePackage( arguments[argumentIndex], version, exact, ref result); } } } // // BUGFIX: This is really a new feature. In the event of a failure // here, we now fallback to the "unknown package handler", // just like Tcl does. // if ((code != ReturnCode.Ok) && !ScriptOps.HasFlags( interpreter, InterpreterFlags.NoPackageUnknown, true)) { string text = interpreter.PackageUnknown + Characters.Space + Parser.Quote(arguments[argumentIndex]); if (version != null) { text += Characters.Space + Parser.Quote(version.ToString()); } code = interpreter.EvaluateScript(text, ref result); /* EXEMPT */ if (code == ReturnCode.Ok) { code = interpreter.RequirePackage( arguments[argumentIndex], version, exact, ref result); } } } else { if ((argumentIndex != Index.Invalid) && Option.LooksLikeOption(arguments[argumentIndex])) { result = OptionDictionary.BadOption(options, arguments[argumentIndex]); } else { result = "wrong # args: should be \"package require ?-exact? package ?version?\""; } code = ReturnCode.Error; } } } else { result = "wrong # args: should be \"package require ?-exact? package ?version?\""; code = ReturnCode.Error; } break; } case "reset": { if (arguments.Count == 2) { code = interpreter.ResetPkgIndexes(ref result); if (code == ReturnCode.Ok) { result = String.Empty; } } else { result = "wrong # args: should be \"package reset\""; code = ReturnCode.Error; } break; } case "scan": { if (arguments.Count >= 2) { OptionDictionary options = new OptionDictionary( new IOption[] { new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-interpreter", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-preferfilesystem", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-preferhost", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-host", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-normal", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-nonormal", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-recursive", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-resolve", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-refresh", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-autopath", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null) }); int argumentIndex = Index.Invalid; if (arguments.Count > 2) { code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, true, ref argumentIndex, ref result); } else { code = ReturnCode.Ok; } if (code == ReturnCode.Ok) { lock (interpreter.SyncRoot) /* TRANSACTIONAL */ { PackageIndexFlags flags; if (options.IsPresent("-interpreter")) { flags = interpreter.PackageIndexFlags; } else { flags = PackageIndexFlags.Default; } if (options.IsPresent("-preferfilesystem")) { flags |= PackageIndexFlags.PreferFileSystem; } if (options.IsPresent("-preferhost")) { flags |= PackageIndexFlags.PreferHost; } if (options.IsPresent("-host")) { flags |= PackageIndexFlags.Host; } if (options.IsPresent("-normal")) { flags |= PackageIndexFlags.Normal; } if (options.IsPresent("-nonormal")) { flags |= PackageIndexFlags.NoNormal; } if (options.IsPresent("-recursive")) { flags |= PackageIndexFlags.Recursive; } if (options.IsPresent("-refresh")) { flags |= PackageIndexFlags.Refresh; } if (options.IsPresent("-resolve")) { flags |= PackageIndexFlags.Resolve; } bool autoPath = false; if (options.IsPresent("-autopath")) { autoPath = true; } StringList paths; if (argumentIndex != Index.Invalid) { // // NOTE: Refresh the specified path list. // paths = new StringList(arguments, argumentIndex); } else { // // NOTE: Refresh the default path list. // paths = GlobalState.GetAutoPathList(interpreter, autoPath); // // NOTE: Did they request the auto-path be rebuilt? // if (autoPath) { // // NOTE: Since the actual auto-path may have changed, // update the variable now. We disable traces // here because we manually rescan, if necessary, // below. // code = interpreter.SetLibraryVariableValue( VariableFlags.SkipTrace, TclVars.AutoPath, (paths != null) ? paths.ToString() : null, ref result); } } if (code == ReturnCode.Ok) { PackageIndexDictionary packageIndexes = interpreter.CopyPackageIndexes(); if (code == ReturnCode.Ok) { code = PackageOps.FindAll( interpreter, paths, flags, ref packageIndexes, ref result); } if (code == ReturnCode.Ok) { interpreter.PackageIndexes = packageIndexes; result = String.Empty; } } } } } else { result = "wrong # args: should be \"package scan ?options? ?dir dir ...?\""; code = ReturnCode.Error; } break; } case "unknown": { if ((arguments.Count == 2) || (arguments.Count == 3)) { if (arguments.Count == 3) { interpreter.PackageUnknown = arguments[2]; result = String.Empty; } else { result = interpreter.PackageUnknown; } code = ReturnCode.Ok; } else { result = "wrong # args: should be \"package unknown ?command?\""; code = ReturnCode.Error; } break; } case "vcompare": { if (arguments.Count == 4) { Version version1 = null; code = Value.GetVersion( arguments[2], interpreter.CultureInfo, ref version1, ref result); Version version2 = null; if (code == ReturnCode.Ok) { code = Value.GetVersion( arguments[3], interpreter.CultureInfo, ref version2, ref result); } if (code == ReturnCode.Ok) { result = PackageOps.VersionCompare(version1, version2); } } else { result = "wrong # args: should be \"package vcompare version1 version2\""; code = ReturnCode.Error; } break; } case "versions": { if (arguments.Count == 3) { code = interpreter.PkgVersions( arguments[2], ref result); } else { result = "wrong # args: should be \"package versions package\""; code = ReturnCode.Error; } break; } case "vloaded": { if ((arguments.Count == 2) || (arguments.Count == 3)) { string pattern = null; if (arguments.Count == 3) { pattern = arguments[2]; } code = interpreter.PkgLoaded( pattern, false, true, ref result); } else { result = "wrong # args: should be \"package vloaded ?pattern?\""; code = ReturnCode.Error; } break; } case "vsatisfies": { if (arguments.Count == 4) { PackageFlags flags = interpreter.PackageFlags; if (!FlagOps.HasFlags(flags, PackageFlags.AlwaysSatisfy, true)) { Version version1 = null; code = Value.GetVersion(arguments[2], interpreter.CultureInfo, ref version1, ref result); Version version2 = null; if (code == ReturnCode.Ok) { code = Value.GetVersion( arguments[3], interpreter.CultureInfo, ref version2, ref result); } if (code == ReturnCode.Ok) { result = PackageOps.VersionSatisfies( version1, version2, false); } } else { // // HACK: Always fake that this was a satisfied package request. // result = true; code = ReturnCode.Ok; } } else { result = "wrong # args: should be \"package vsatisfies version1 version2\""; code = ReturnCode.Error; } break; } case "withdraw": { if ((arguments.Count == 3) || (arguments.Count == 4)) { Version version = null; if (arguments.Count == 4) { code = Value.GetVersion( arguments[3], interpreter.CultureInfo, ref version, ref result); } if (code == ReturnCode.Ok) { code = interpreter.WithdrawPackage( arguments[2], version, ref result); } } else { result = "wrong # args: should be \"package withdraw package ?version?\""; code = ReturnCode.Error; } break; } default: { result = ScriptOps.BadSubCommand( interpreter, null, null, subCommand, this, null, null); code = ReturnCode.Error; break; } } } } else { result = "wrong # args: should be \"package arg ?arg ...?\""; code = ReturnCode.Error; } } else { result = "invalid argument list"; code = ReturnCode.Error; } } else { result = "invalid interpreter"; code = ReturnCode.Error; } return(code); }
/////////////////////////////////////////////////////////////////////// private static string GetNativeLibraryFileName( Interpreter interpreter /* NOT USED */ ) { string path = CommonOps.Environment.GetVariable( EnvVars.UtilityPath); if (!String.IsNullOrEmpty(path)) { if (File.Exists(path)) { return(path); } if (Directory.Exists(path)) { string fileName = PathOps.CombinePath( null, path, DllName.Utility); if (File.Exists(fileName)) { return(fileName); } // // TODO: Is this strictly necessary here? It is known // at this point that this file does not exist. // Setting the path here only controls the result // returned in non-strict mode (below). // path = fileName; } // // NOTE: If the environment variable was set and the utility // library could not be found, force an invalid result // to be returned. This ends up skipping the standard // automatic utility library detection logic. // lock (syncRoot) { return(strictPath ? null : path); } } // // HACK: If the processor architecture ends up being "AMD64", we // want it to be "x64" instead, to match the platform name // used by the native utility library project itself. // string processorName = PlatformOps.GetAlternateProcessorName( RuntimeOps.GetProcessorArchitecture(), true, false); if (processorName != null) { path = PathOps.CombinePath( null, GlobalState.GetAssemblyPath(), processorName, DllName.Utility); if (File.Exists(path)) { return(path); } } path = PathOps.CombinePath( null, GlobalState.GetAssemblyPath(), DllName.Utility); if (File.Exists(path)) { return(path); } lock (syncRoot) { return(strictPath ? null : path); } }
/////////////////////////////////////////////////////////////////////// bool IDictionary <string, T> .Remove( string key ) { return(base.Remove(PathOps.TranslatePath(key, translationType))); }
public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { ReturnCode code; if (interpreter != null) { if (arguments != null) { if (arguments.Count >= 2) { OptionDictionary options = new OptionDictionary( new IOption[] { new Option(null, OptionFlags.Unsafe, Index.Invalid, Index.Invalid, "-nocommands", null), new Option(null, OptionFlags.Unsafe, Index.Invalid, Index.Invalid, "-nofunctions", null), new Option(null, OptionFlags.Unsafe, Index.Invalid, Index.Invalid, "-nopolicies", null), new Option(null, OptionFlags.Unsafe, Index.Invalid, Index.Invalid, "-notraces", null), new Option(null, OptionFlags.Unsafe, Index.Invalid, Index.Invalid, "-noprovide", null), new Option(null, OptionFlags.Unsafe, Index.Invalid, Index.Invalid, "-noresources", null), new Option(null, OptionFlags.Unsafe, Index.Invalid, Index.Invalid, "-verifiedonly", null), new Option(null, OptionFlags.Unsafe, Index.Invalid, Index.Invalid, "-trustedonly", null), #if ISOLATED_PLUGINS new Option(null, OptionFlags.Unsafe, Index.Invalid, Index.Invalid, "-noisolated", null), #else new Option(null, OptionFlags.Unsafe | OptionFlags.Unsupported, Index.Invalid, Index.Invalid, "-noisolated", null), #endif new Option(null, OptionFlags.MustHaveObjectValue, Index.Invalid, Index.Invalid, "-clientdata", null), new Option(null, OptionFlags.MustHaveObjectValue, Index.Invalid, Index.Invalid, "-data", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null) }); int argumentIndex = Index.Invalid; code = interpreter.GetOptions(options, arguments, 0, 1, Index.Invalid, false, ref argumentIndex, ref result); if (code == ReturnCode.Ok) { // // NOTE: There should be a minimum of one and a maximum // of three arguments after the final option. // if ((argumentIndex != Index.Invalid) && ((argumentIndex + 3) >= arguments.Count)) { string path = ((argumentIndex + 2) < arguments.Count) ? (string)arguments[argumentIndex + 2] : String.Empty; Interpreter slaveInterpreter = null; code = interpreter.GetNestedSlaveInterpreter( path, LookupFlags.Interpreter, false, ref slaveInterpreter, ref result); if (code == ReturnCode.Ok) { Variant value = null; IClientData localClientData = clientData; if (options.IsPresent("-clientdata", ref value)) { IObject @object = (IObject)value.Value; if ((@object.Value == null) || (@object.Value is IClientData)) { localClientData = (IClientData)@object.Value; } else { result = "option value has invalid clientData"; code = ReturnCode.Error; } } if (code == ReturnCode.Ok) { if (options.IsPresent("-data", ref value)) { IObject @object = (IObject)value.Value; if (@object != null) { localClientData = _Public.ClientData.WrapOrReplace( localClientData, @object.Value); } else { result = "option value has invalid data"; code = ReturnCode.Error; } } if (code == ReturnCode.Ok) { // // NOTE: All plugins loaded by this command are considered // as having been loaded "on demand". // PluginFlags pluginFlags = PluginFlags.Demand; // // NOTE: Add the plugin flags for the target interpreter. // pluginFlags |= slaveInterpreter.PluginFlags; #if ISOLATED_PLUGINS // // NOTE: Disable loading this plugin into an isolated // application domain (i.e. load it into the default // application domain for the target interpreter). // if (options.IsPresent("-noisolated")) { pluginFlags &= ~PluginFlags.Isolated; } #endif if (options.IsPresent("-nocommands")) { pluginFlags |= PluginFlags.NoCommands; } if (options.IsPresent("-nofunctions")) { pluginFlags |= PluginFlags.NoFunctions; } if (options.IsPresent("-nopolicies")) { pluginFlags |= PluginFlags.NoPolicies; } if (options.IsPresent("-notraces")) { pluginFlags |= PluginFlags.NoTraces; } if (options.IsPresent("-noprovide")) { pluginFlags |= PluginFlags.NoProvide; } if (options.IsPresent("-noresources")) { pluginFlags |= PluginFlags.NoResources; } if (options.IsPresent("-verifiedonly")) { pluginFlags |= PluginFlags.VerifiedOnly; } if (options.IsPresent("-trustedonly")) { pluginFlags |= PluginFlags.TrustedOnly; } string fileName = PathOps.ResolveFullPath( interpreter, arguments[argumentIndex]); if (!String.IsNullOrEmpty(fileName)) { string typeName = null; if ((argumentIndex + 1) < arguments.Count) { typeName = arguments[argumentIndex + 1]; } IPlugin plugin = null; long token = 0; try { code = slaveInterpreter.LoadPlugin( fileName, #if CAS_POLICY null, null, AssemblyHashAlgorithm.None, #endif typeName, localClientData, pluginFlags, ref plugin, ref result); if (code == ReturnCode.Ok) { code = slaveInterpreter.AddPlugin( plugin, localClientData, ref token, ref result); } } finally { if (code != ReturnCode.Ok) { if (token != 0) { // // NOTE: Terminate and remove the plugin now. // This does not unload the associated // AppDomain, if any. // ReturnCode removeCode; Result removeResult = null; removeCode = slaveInterpreter.RemovePlugin( token, localClientData, ref removeResult); if (removeCode != ReturnCode.Ok) { DebugOps.Complain( slaveInterpreter, removeCode, removeResult); } } if (plugin != null) { // // NOTE: Unload the plugin. This basically does // "nothing" unless the plugin was isolated. // In that case, it unloads the associated // AppDomain. // ReturnCode unloadCode; Result unloadResult = null; unloadCode = slaveInterpreter.UnloadPlugin( plugin, localClientData, pluginFlags | PluginFlags.SkipTerminate, ref unloadResult); if (unloadCode != ReturnCode.Ok) { DebugOps.Complain( slaveInterpreter, unloadCode, unloadResult); } } } } } else { result = "invalid file name"; code = ReturnCode.Error; } } } } } else { if ((argumentIndex != Index.Invalid) && Option.LooksLikeOption(arguments[argumentIndex])) { result = OptionDictionary.BadOption(options, arguments[argumentIndex]); } else { result = "wrong # args: should be \"load ?options? fileName ?packageName? ?interp?\""; } code = ReturnCode.Error; } } } else { result = "wrong # args: should be \"load ?options? fileName ?packageName? ?interp?\""; code = ReturnCode.Error; } } else { result = "invalid argument list"; code = ReturnCode.Error; } } else { result = "invalid interpreter"; code = ReturnCode.Error; } return(code); }
public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { ReturnCode code = ReturnCode.Ok; if (interpreter != null) { if (arguments != null) { if (arguments.Count >= 2) { OptionDictionary options = new OptionDictionary( new IOption[] { new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-debug", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-commandline", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-dequote", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-quoteall", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-unicode", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-ignorestderr", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-killonerror", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-keepnewline", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-noexitcode", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-nocapture", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-shell", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-nocarriagereturns", null), // simple switch new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-trimall", null), // simple switch new Option(typeof(ExitCode), OptionFlags.MustHaveEnumValue, Index.Invalid, Index.Invalid, "-success", null), // success exit code new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-domainname", null), new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-username", null), new Option(null, OptionFlags.MustHaveSecureStringValue, Index.Invalid, Index.Invalid, "-password", null), new Option(null, OptionFlags.MustHaveListValue, Index.Invalid, Index.Invalid, "-preprocessarguments", null), // command new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-directory", null), // directory name new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-processid", null), // varName for processId new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-exitcode", null), // varName for exitCode new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-stdin", null), // varName for StdIn input new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-stdout", null), // varName for StdOut output new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-stderr", null), // varName for StdErr output new Option(typeof(EventFlags), OptionFlags.MustHaveEnumValue, Index.Invalid, Index.Invalid, "-eventflags", new Variant(interpreter.EngineEventFlags)), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null) }); int argumentIndex = Index.Invalid; code = interpreter.GetOptions(options, arguments, 0, 1, Index.Invalid, true, ref argumentIndex, ref result); if (code == ReturnCode.Ok) { if (argumentIndex != Index.Invalid) { bool debug = false; if (options.IsPresent("-debug")) { debug = true; } bool commandLine = false; if (options.IsPresent("-commandline")) { commandLine = true; } bool dequote = false; if (options.IsPresent("-dequote")) { dequote = true; } bool quoteAll = false; if (options.IsPresent("-quoteall")) { quoteAll = true; } bool captureExitCode = true; if (options.IsPresent("-noexitcode")) { captureExitCode = false; } bool captureInput = true; bool captureOutput = true; if (options.IsPresent("-nocapture")) { captureInput = false; captureOutput = false; } bool useUnicode = false; if (options.IsPresent("-unicode")) { useUnicode = true; } bool ignoreStdErr = false; if (options.IsPresent("-ignorestderr")) { ignoreStdErr = true; } bool killOnError = false; if (options.IsPresent("-killonerror")) { killOnError = true; } bool keepNewLine = false; if (options.IsPresent("-keepnewline")) { keepNewLine = true; } bool carriageReturns = true; if (options.IsPresent("-nocarriagereturns")) { carriageReturns = false; } bool trimAll = false; if (options.IsPresent("-trimall")) { trimAll = true; } bool useShellExecute = false; if (options.IsPresent("-shell")) { useShellExecute = true; } Variant value = null; ExitCode?successExitCode = null; if (options.IsPresent("-success", ref value)) { successExitCode = (ExitCode)value.Value; } string domainName = null; if (options.IsPresent("-domainname", ref value)) { domainName = value.ToString(); } string userName = null; if (options.IsPresent("-username", ref value)) { userName = value.ToString(); } SecureString password = null; if (options.IsPresent("-password", ref value)) { password = (SecureString)value.Value; } string directory = null; if (options.IsPresent("-directory", ref value)) { directory = value.ToString(); } string processIdVarName = null; if (options.IsPresent("-processid", ref value)) { processIdVarName = value.ToString(); } string exitCodeVarName = null; if (options.IsPresent("-exitcode", ref value)) { exitCodeVarName = value.ToString(); } string stdInVarName = null; if (options.IsPresent("-stdin", ref value)) { stdInVarName = value.ToString(); } string stdOutVarName = null; if (options.IsPresent("-stdout", ref value)) { stdOutVarName = value.ToString(); } string stdErrVarName = null; if (options.IsPresent("-stderr", ref value)) { stdErrVarName = value.ToString(); } EventFlags eventFlags = interpreter.EngineEventFlags; if (options.IsPresent("-eventflags", ref value)) { eventFlags = (EventFlags)value.Value; } StringList list = null; if (options.IsPresent("-preprocessarguments", ref value)) { list = (StringList)value.Value; } int argumentStopIndex = arguments.Count - 1; bool background = false; if (arguments[arguments.Count - 1] == Characters.Ampersand.ToString()) { argumentStopIndex--; background = true; } string execFileName = arguments[argumentIndex]; if (!PathOps.IsRemoteUri(execFileName)) { execFileName = PathOps.GetNativePath(execFileName); } string execArguments = null; if ((argumentIndex + 1) < arguments.Count) { if (commandLine) { execArguments = RuntimeOps.BuildCommandLine( ArgumentList.GetRangeAsStringList(arguments, argumentIndex + 1, argumentStopIndex, dequote), quoteAll); } else { execArguments = ListOps.Concat(arguments, argumentIndex + 1, argumentStopIndex); } } Result input = null; if ((code == ReturnCode.Ok) && !useShellExecute && captureInput && (stdInVarName != null)) { code = interpreter.GetVariableValue(VariableFlags.None, stdInVarName, ref input, ref result); } if (debug) { TraceOps.DebugTrace(String.Format( "Execute: interpreter = {0}, domainName = {1}, userName = {2}, " + "password = {3}, execFileName = {4}, execArguments = {5}, " + "directory = {6}, input = {7}, eventFlags = {8}, debug = {9}, " + "commandLine = {10}, dequote = {11}, quoteAll = {12}, " + "useShellExecute = {13}, captureExitCode = {14}, " + "captureInput = {15}, captureOutput = {16}, useUnicode = {17}, " + "ignoreStdErr = {18}, killOnError = {19}, keepNewLine = {20}, " + "carriageReturns = {21}, trimAll = {22}, background = {23}, " + "successExitCode = {24}, processIdVarName = {25}, exitCodeVarName = {26}, " + "stdInVarName = {27}, stdOutVarName = {28}, stdErrVarName = {29}", FormatOps.InterpreterNoThrow(interpreter), FormatOps.WrapOrNull(domainName), FormatOps.WrapOrNull(userName), FormatOps.WrapOrNull(password), FormatOps.WrapOrNull(execFileName), FormatOps.WrapOrNull(execArguments), FormatOps.WrapOrNull(directory), FormatOps.WrapOrNull(input), FormatOps.WrapOrNull(eventFlags), debug, commandLine, dequote, quoteAll, useShellExecute, captureExitCode, captureInput, captureOutput, useUnicode, ignoreStdErr, killOnError, keepNewLine, carriageReturns, trimAll, background, FormatOps.WrapOrNull(successExitCode), FormatOps.WrapOrNull(processIdVarName), FormatOps.WrapOrNull(exitCodeVarName), FormatOps.WrapOrNull(stdInVarName), FormatOps.WrapOrNull(stdOutVarName), FormatOps.WrapOrNull(stdErrVarName)), typeof(Exec).Name, TracePriority.Command); } int processId = 0; ExitCode exitCode = ResultOps.SuccessExitCode(); Result error = null; if (code == ReturnCode.Ok) { if (list != null) { list.Add(execFileName); list.Add(directory); list.Add(execArguments); code = interpreter.EvaluateScript(list.ToString(), ref result); if (code == ReturnCode.Return) { execArguments = result; code = ReturnCode.Ok; } else if (code == ReturnCode.Continue) { code = ReturnCode.Ok; goto done; } } if (code == ReturnCode.Ok) { code = ProcessOps.ExecuteProcess( interpreter, domainName, userName, password, execFileName, execArguments, directory, input, eventFlags, useShellExecute, captureExitCode, captureOutput, useUnicode, ignoreStdErr, killOnError, keepNewLine, background, !background, ref processId, ref exitCode, ref result, ref error); } } done: if (debug) { TraceOps.DebugTrace(String.Format( "Execute: interpreter = {0}, domainName = {1}, userName = {2}, " + "password = {3}, execFileName = {4}, execArguments = {5}, " + "directory = {6}, input = {7}, eventFlags = {8}, debug = {9}, " + "commandLine = {10}, dequote = {11}, quoteAll = {12}, " + "useShellExecute = {13}, captureExitCode = {14}, " + "captureInput = {15}, captureOutput = {16}, useUnicode = {17}, " + "ignoreStdErr = {18}, killOnError = {19}, keepNewLine = {20}, " + "carriageReturns = {21}, trimAll = {22}, background = {23}, " + "successExitCode = {24}, processIdVarName = {25}, exitCodeVarName = {26}, " + "stdInVarName = {27}, stdOutVarName = {28}, stdErrVarName = {29}, " + "processId = {30}, exitCode = {31}, result = {32}, error = {33}", FormatOps.InterpreterNoThrow(interpreter), FormatOps.WrapOrNull(domainName), FormatOps.WrapOrNull(userName), FormatOps.WrapOrNull(password), FormatOps.WrapOrNull(execFileName), FormatOps.WrapOrNull(execArguments), FormatOps.WrapOrNull(directory), FormatOps.WrapOrNull(input), FormatOps.WrapOrNull(eventFlags), debug, commandLine, dequote, quoteAll, useShellExecute, captureExitCode, captureInput, captureOutput, useUnicode, ignoreStdErr, killOnError, keepNewLine, carriageReturns, trimAll, background, FormatOps.WrapOrNull(successExitCode), FormatOps.WrapOrNull(processIdVarName), FormatOps.WrapOrNull(exitCodeVarName), FormatOps.WrapOrNull(stdInVarName), FormatOps.WrapOrNull(stdOutVarName), FormatOps.WrapOrNull(stdErrVarName), processId, exitCode, FormatOps.WrapOrNull(true, true, result), FormatOps.WrapOrNull(true, true, error)), typeof(Exec).Name, TracePriority.Command); } // // NOTE: Even upon failure, always set the variable to contain // process Id, if applicable. // if (processIdVarName != null) { /* IGNORED */ interpreter.SetVariableValue( /* EXEMPT */ VariableFlags.NoReady, processIdVarName, processId.ToString(), null); } if (code == ReturnCode.Ok) { // // NOTE: Remove all carriage returns from output (leaving // only line feeds as line separators)? // if (!carriageReturns) { if (!String.IsNullOrEmpty(result)) { result = result.Replace( Characters.CarriageReturnString, String.Empty); } if (!String.IsNullOrEmpty(error)) { error = error.Replace( Characters.CarriageReturnString, String.Empty); } } // // NOTE: Remove all surrounding whitespace from the output? // if (trimAll) { if (!String.IsNullOrEmpty(result)) { result = result.Trim(); } if (!String.IsNullOrEmpty(error)) { error = error.Trim(); } } // // NOTE: Now, "result" contains any StdOut output and "error" // contains any StdErr output. // if ((code == ReturnCode.Ok) && !background && captureExitCode && (exitCodeVarName != null)) { code = interpreter.SetVariableValue(VariableFlags.None, exitCodeVarName, exitCode.ToString(), null, ref error); } if ((code == ReturnCode.Ok) && !useShellExecute && !background && captureOutput && (stdOutVarName != null)) { code = interpreter.SetVariableValue(VariableFlags.None, stdOutVarName, result, null, ref error); } if ((code == ReturnCode.Ok) && !useShellExecute && !background && captureOutput && (stdErrVarName != null)) { code = interpreter.SetVariableValue(VariableFlags.None, stdErrVarName, error, null, ref error); } // // NOTE: If they specified a "success" exit code, make sure // that is the same as the exit code we actually got // from the process. // if ((code == ReturnCode.Ok) && !background && captureExitCode && (successExitCode != null) && (exitCode != successExitCode)) { /* IGNORED */ interpreter.SetVariableValue( /* EXEMPT */ Engine.ErrorCodeVariableFlags, TclVars.ErrorCode, StringList.MakeList( "CHILDSTATUS", processId, exitCode), null); Engine.SetErrorCodeSet(interpreter, true); error = "child process exited abnormally"; code = ReturnCode.Error; } if (code != ReturnCode.Ok) { // // NOTE: Transfer error to command result. // result = error; } } else { // // NOTE: Transfer error to command result. // result = error; } } else { result = "wrong # args: should be \"exec ?options? arg ?arg ...?\""; code = ReturnCode.Error; } } } else { result = "wrong # args: should be \"exec ?options? arg ?arg ...?\""; code = ReturnCode.Error; } } else { result = "invalid argument list"; code = ReturnCode.Error; } } else { result = "invalid interpreter"; code = ReturnCode.Error; } return(code); }
/////////////////////////////////////////////////////////////////////// public new bool Remove( string key ) { return(base.Remove(PathOps.TranslatePath(key, translationType))); }
public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { ReturnCode code; if (interpreter != null) { if (arguments != null) { if (arguments.Count >= 2) { OptionDictionary options = new OptionDictionary( new IOption[] { new Option(null, OptionFlags.MustHaveObjectValue, Index.Invalid, Index.Invalid, "-clientdata", null), new Option(null, OptionFlags.MustHaveObjectValue, Index.Invalid, Index.Invalid, "-data", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-nocase", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-keeplibrary", null), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-nocomplain", null), new Option(null, OptionFlags.MustHaveMatchModeValue, Index.Invalid, Index.Invalid, "-match", new Variant(StringOps.DefaultUnloadMatchMode)), new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null) }); int argumentIndex = Index.Invalid; code = interpreter.GetOptions(options, arguments, 0, 1, Index.Invalid, false, ref argumentIndex, ref result); if (code == ReturnCode.Ok) { // // NOTE: There should be a minimum of one and a maximum // of three arguments after the final option. // if ((argumentIndex != Index.Invalid) && ((argumentIndex + 3) >= arguments.Count)) { string path = ((argumentIndex + 2) < arguments.Count) ? (string)arguments[argumentIndex + 2] : String.Empty; Interpreter slaveInterpreter = null; code = interpreter.GetNestedSlaveInterpreter( path, LookupFlags.Interpreter, false, ref slaveInterpreter, ref result); if (code == ReturnCode.Ok) { Variant value = null; IClientData localClientData = clientData; if (options.IsPresent("-clientdata", ref value)) { IObject @object = (IObject)value.Value; if ((@object.Value == null) || (@object.Value is IClientData)) { localClientData = (IClientData)@object.Value; } else { result = "option value has invalid clientData"; code = ReturnCode.Error; } } if (code == ReturnCode.Ok) { if (options.IsPresent("-data", ref value)) { IObject @object = (IObject)value.Value; localClientData = _Public.ClientData.WrapOrReplace( localClientData, @object.Value); } MatchMode mode = StringOps.DefaultUnloadMatchMode; if (options.IsPresent("-match", ref value)) { mode = (MatchMode)value.Value; } bool noCase = false; if (options.IsPresent("-nocase")) { noCase = true; } if (slaveInterpreter.HasPlugins(ref result)) { string fileName = PathOps.ResolveFullPath( interpreter, arguments[argumentIndex]); if (!String.IsNullOrEmpty(fileName)) { string typeName = null; if ((argumentIndex + 1) < arguments.Count) { typeName = arguments[argumentIndex + 1]; } // // NOTE: Grab the plugin flags to match from the target // interpreter and add the Demand flag to them. // PluginFlags pluginFlags = slaveInterpreter.PluginFlags | PluginFlags.Demand; // // FIXME: PRI 4: Threading. // bool unload = false; StringList list = slaveInterpreter.CopyPluginKeys(); foreach (string name in list) { IPluginData pluginData = slaveInterpreter.GetPluginData(name); // // NOTE: Check that this plugin represents a loaded // assembly. // if (pluginData != null) { if ((pluginData.FileName != null) && PathOps.IsSameFile(interpreter, pluginData.FileName, fileName)) { if (String.IsNullOrEmpty(typeName) || StringOps.Match(interpreter, mode, pluginData.TypeName, typeName, noCase) || StringOps.Match(interpreter, mode, pluginData.Name, typeName, noCase)) { code = slaveInterpreter.UnloadPlugin( name, localClientData, pluginFlags, ref result); if (code == ReturnCode.Ok) { unload = true; } // // NOTE: Stop as soon as we match and // attempt to unload a plugin, // whether or not we actually // unloaded it. We always halt // on errors and since we only // support unloading a single // plugin at a time (even if // there are multiple plugins // contained in a particular // assembly file), we know it // is safe to stop now. // break; } } } } if ((code == ReturnCode.Ok) && !unload) { if (typeName != null) { result = String.Format( "type \"{0}\" and file \"{1}\" have never been loaded", typeName, fileName); } else { result = String.Format( "file \"{0}\" has never been loaded", fileName); } code = ReturnCode.Error; } } else { result = "invalid file name"; code = ReturnCode.Error; } } else { code = ReturnCode.Error; } } } } else { if ((argumentIndex != Index.Invalid) && Option.LooksLikeOption(arguments[argumentIndex])) { result = OptionDictionary.BadOption(options, arguments[argumentIndex]); } else { result = "wrong # args: should be \"unload ?options? fileName ?packageName? ?interp?\""; } code = ReturnCode.Error; } } } else { result = "wrong # args: should be \"unload ?options? fileName ?packageName? ?interp?\""; code = ReturnCode.Error; } } else { result = "invalid argument list"; code = ReturnCode.Error; } } else { result = "invalid interpreter"; code = ReturnCode.Error; } return(code); }
/////////////////////////////////////////////////////////////////////// #region System.Collections.Generic.Dictionary<string, TValue> Overrides public new T this[string key] { get { return(base[PathOps.TranslatePath(key, translationType)]); } set { base[PathOps.TranslatePath(key, translationType)] = value; } }