///////////////////////////////////////////////////////////////////////////////////////////////
public bool Add(IEnumerable <Regex> keys, Type enumType, IEnumerable <Enum> values, ref Result error)
{
object zeroValue = EnumOps.TryGetEnum(enumType, 0, ref error);
if (zeroValue != null)
{
IEnumerator <Enum> enumerator = values.GetEnumerator(); /* throw */
bool moveNext = true;
foreach (Regex key in keys)
{
//
// NOTE: If we run out of values before keys, zero fill the
// rest.
//
object value = zeroValue;
//
// NOTE: Are we able to continue moving through the items?
//
if (moveNext)
{
//
// NOTE: Move to the next item. If this fails, there are
// no more items and we cannot move any farther.
//
if (!enumerator.MoveNext())
{
moveNext = false;
}
//
// NOTE: Get the value of the current item.
//
value = enumerator.Current;
}
//
// NOTE: Add this key/value pair to the dictionary.
//
this.Add(key, (Enum)value); /* throw */
}
return(true);
}
return(false);
}
///////////////////////////////////////////////////////////////////////
//
// WARNING: Do not use this method from the GlobalConfiguration class.
//
public static bool TryGetEnumAppSetting(
string name, /* in */
Type enumType, /* in */
string oldValue, /* in */
out object value, /* out */
ref Result error /* out */
)
{
string stringValue;
if (!TryGetAppSetting(name, out stringValue, ref error))
{
value = null;
return(false);
}
object enumValue = null;
if (EnumOps.IsFlagsEnum(enumType))
{
enumValue = Utility.TryParseFlagsEnum(
null, enumType, oldValue, stringValue,
null, true, true, true, ref error);
}
else
{
enumValue = Utility.TryParseEnum(
enumType, stringValue, true, true,
ref error);
}
if (!(enumValue is Enum))
{
value = null;
return(false);
}
value = enumValue;
return(true);
}
///////////////////////////////////////////////////////////////////////
public bool TryGetValue(
string key,
Type enumType,
out object value,
ref Result error
)
{
Enum enumValue;
if (this.TryGetValue(key, out enumValue))
{
value = EnumOps.TryGetEnum(enumType, enumValue, ref error);
return(true);
}
else
{
value = EnumOps.TryGetEnum(enumType, 0, ref error);
return(false);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
#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);
}
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 fileName = arguments[1];
if (interpreter.HasChannels(ref result))
{
MapOpenAccess access = MapOpenAccess.Default;
int permissions = 0; // NOTE: This is ONLY parsed, NOT used for opening the file.
string type = null;
if (arguments.Count >= 3)
{
Result enumString = arguments[2];
if (!String.IsNullOrEmpty(enumString))
{
//
// HACK: Translate illegal mode char "+" to what our Enum uses.
// This strategy will backfire later if we ever decide to
// allow parsing of the access mode as "flags" (via GetOptions).
//
enumString = enumString.Replace(Characters.PlusSign.ToString(), "Plus");
}
code = StringOps.StringToEnumList(interpreter, enumString, ref enumString);
if (code == ReturnCode.Ok)
{
object enumValue = EnumOps.TryParseEnum(
typeof(MapOpenAccess), enumString,
true, true);
if (enumValue is MapOpenAccess)
{
access = (MapOpenAccess)enumValue;
}
else
{
enumString = ScriptOps.BadValue(
"invalid", "access mode", arguments[2],
Enum.GetNames(typeof(MapOpenAccess)), null, null);
code = ReturnCode.Error;
}
}
if (code != ReturnCode.Ok)
{
//
// NOTE: Transfer local result from above and add to the error info.
//
result = enumString;
Engine.AddErrorInformation(interpreter, result,
String.Format("{0} while processing open access modes \"{1}\"",
Environment.NewLine, FormatOps.Ellipsis(arguments[2])));
}
}
if ((code == ReturnCode.Ok) && (arguments.Count >= 4))
{
code = Value.GetInteger2(
(IGetValue)arguments[3], ValueFlags.AnyInteger,
interpreter.CultureInfo, ref permissions, ref result);
}
if (code == ReturnCode.Ok)
{
if (arguments.Count >= 5)
{
type = arguments[4];
}
OptionDictionary options = new OptionDictionary(
new IOption[] {
#if CONSOLE
new Option(null, OptionFlags.None, 1, Index.Invalid, "-stdin", null),
new Option(null, OptionFlags.None, 1, Index.Invalid, "-stdout", null),
new Option(null, OptionFlags.None, 1, Index.Invalid, "-stderr", null),
#else
new Option(null, OptionFlags.Unsupported, 1, Index.Invalid, "-stdin", null),
new Option(null, OptionFlags.Unsupported, 1, Index.Invalid, "-stdout", null),
new Option(null, OptionFlags.Unsupported, 1, Index.Invalid, "-stderr", null),
#endif
new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-channelid", null),
new Option(null, OptionFlags.MustHaveIntegerValue, Index.Invalid, Index.Invalid, "-buffersize", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-autoflush", null),
new Option(typeof(HostStreamFlags), OptionFlags.MustHaveEnumValue, Index.Invalid, Index.Invalid, "-streamflags",
new Variant(HostStreamFlags.Default)),
new Option(typeof(FileOptions), OptionFlags.MustHaveEnumValue, Index.Invalid, Index.Invalid, "-options",
new Variant(FileOptions.None)),
new Option(typeof(FileShare), OptionFlags.MustHaveEnumValue, Index.Invalid, Index.Invalid, "-share",
new Variant(FileShare.Read))
});
int argumentIndex = Index.Invalid;
if (arguments.Count > 5)
{
code = interpreter.GetOptions(options, arguments, 0, 5, Index.Invalid, true, ref argumentIndex, ref result);
}
else
{
code = ReturnCode.Ok;
}
if (code == ReturnCode.Ok)
{
if (argumentIndex == Index.Invalid)
{
Variant value = null;
string channelId = null;
if (options.IsPresent("-channelid", ref value))
{
channelId = value.ToString();
}
if ((channelId == null) ||
(interpreter.DoesChannelExist(channelId) != ReturnCode.Ok))
{
#if CONSOLE
if (options.IsPresent("-stdin"))
{
//
// NOTE: Enforce the proper access for the standard input
// channel.
//
if (access == MapOpenAccess.RdOnly)
{
try
{
IStreamHost streamHost = interpreter.Host;
//
// NOTE: *WARNING* This option causes the "fileName",
// "access", "permissions", and "type" arguments
// to be ignored.
//
lock (interpreter.SyncRoot) /* TRANSACTIONAL */
{
if (streamHost.In == null)
{
int?bufferSize = null;
if (options.IsPresent("-buffersize", ref value))
{
bufferSize = (int)value.Value;
}
streamHost.In = (bufferSize != null) ?
Console.OpenStandardInput((int)bufferSize) :
Console.OpenStandardInput();
}
}
code = interpreter.ModifyStandardChannels(
streamHost, channelId, ChannelType.Input |
ChannelType.ErrorOnExist, ref result);
if (code == ReturnCode.Ok)
{
result = (channelId != null) ? channelId : StandardChannel.Input;
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
result = e;
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"illegal access mode \"{0}\", standard input " +
"can only be opened using access mode \"{1}\"",
access, MapOpenAccess.RdOnly);
code = ReturnCode.Error;
}
}
else if (options.IsPresent("-stdout"))
{
//
// NOTE: Enforce the proper access for the standard output
// channel.
//
if (access == MapOpenAccess.WrOnly)
{
try
{
IStreamHost streamHost = interpreter.Host;
//
// NOTE: *WARNING* This option causes the "fileName",
// "access", "permissions", and "type" arguments
// to be ignored.
//
lock (interpreter.SyncRoot) /* TRANSACTIONAL */
{
if (streamHost.Out == null)
{
int?bufferSize = null;
if (options.IsPresent("-buffersize", ref value))
{
bufferSize = (int)value.Value;
}
streamHost.Out = (bufferSize != null) ?
Console.OpenStandardOutput((int)bufferSize) :
Console.OpenStandardOutput();
}
}
code = interpreter.ModifyStandardChannels(
streamHost, channelId, ChannelType.Output |
ChannelType.ErrorOnExist, ref result);
if (code == ReturnCode.Ok)
{
result = (channelId != null) ? channelId : StandardChannel.Output;
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
result = e;
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"illegal access mode \"{0}\", standard output " +
"can only be opened using access mode \"{1}\"",
access, MapOpenAccess.WrOnly);
code = ReturnCode.Error;
}
}
else if (options.IsPresent("-stderr"))
{
//
// NOTE: Enforce the proper access for the standard error
// channel.
//
if (access == MapOpenAccess.WrOnly)
{
try
{
IStreamHost streamHost = interpreter.Host;
//
// NOTE: *WARNING* This option causes the "fileName",
// "access", "permissions", and "type" arguments
// to be ignored.
//
lock (interpreter.SyncRoot) /* TRANSACTIONAL */
{
if (streamHost.Error == null)
{
int?bufferSize = null;
if (options.IsPresent("-buffersize", ref value))
{
bufferSize = (int)value.Value;
}
streamHost.Error = (bufferSize != null) ?
Console.OpenStandardError((int)bufferSize) :
Console.OpenStandardError();
}
}
code = interpreter.ModifyStandardChannels(
streamHost, channelId, ChannelType.Error |
ChannelType.ErrorOnExist, ref result);
if (code == ReturnCode.Ok)
{
result = (channelId != null) ? channelId : StandardChannel.Error;
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
result = e;
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"illegal access mode \"{0}\", standard error " +
"can only be opened using access mode \"{1}\"",
access, MapOpenAccess.WrOnly);
code = ReturnCode.Error;
}
}
else
#endif
{
Stream stream = null;
bool autoFlush = false;
switch (type)
{
case null: /* FALL-THROUGH */
case /* String.Empty */ "": /* FALL-THROUGH */
case "file":
{
try
{
HostStreamFlags hostStreamFlags = HostStreamFlags.OpenCommand;
FileAccess fileAccess = FileOps.FileAccessFromAccess(access);
FileMode fileMode = FileOps.FileModeFromAccess(access);
FileShare fileShare = FileShare.Read;
if (options.IsPresent("-streamflags", ref value))
{
hostStreamFlags = (HostStreamFlags)value.Value;
}
if (options.IsPresent("-share", ref value))
{
fileShare = (FileShare)value.Value;
}
int bufferSize = Channel.DefaultBufferSize;
if (options.IsPresent("-buffersize", ref value))
{
bufferSize = (int)value.Value;
}
FileOptions fileOptions = FileOptions.None;
if (options.IsPresent("-options", ref value))
{
fileOptions = (FileOptions)value.Value;
}
if (options.IsPresent("-autoflush"))
{
autoFlush = true;
}
bool seekToEof = false;
//
// HACK: Check for special case where they want to Append
// and Read/ReadWrite.
//
if (((fileAccess == FileAccess.Read) ||
(fileAccess == FileAccess.ReadWrite)) &&
(FlagOps.HasFlags(access, MapOpenAccess.SeekToEof, true) ||
FlagOps.HasFlags(access, MapOpenAccess.Append, true)))
{
seekToEof = true;
}
code = interpreter.GetStream(
fileName, fileMode, fileAccess, fileShare, bufferSize,
fileOptions, Channel.StrictGetStream, ref hostStreamFlags,
ref stream, ref result);
if (code == ReturnCode.Ok)
{
if ((stream != null) && seekToEof)
{
stream.Seek(0, SeekOrigin.End);
}
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
result = e;
code = ReturnCode.Error;
}
break;
}
default:
{
result = String.Format(
"unsupported channel type \"{0}\"",
type);
code = ReturnCode.Error;
break;
}
}
//
// NOTE: Did we manage to open the file successfully?
//
if (code == ReturnCode.Ok)
{
StreamFlags flags = StreamFlags.PreventClose;
if (channelId == null)
{
channelId = FormatOps.Id("file", null, interpreter.NextId());
}
code = interpreter.AddFileOrSocketChannel(
channelId, stream, options, flags,
FlagOps.HasFlags(access, MapOpenAccess.Append, true),
autoFlush, null, ref result);
if (code == ReturnCode.Ok)
{
result = channelId;
}
}
}
}
else
{
result = String.Format(
"can't add \"{0}\": channel already exists",
channelId);
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"open fileName ?access? ?permissions? ?type? ?options?\"";
code = ReturnCode.Error;
}
}
}
}
else
{
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"open fileName ?access? ?permissions? ?type? ?options?\"";
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;
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count >= 1)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.Unsafe, Index.Invalid, Index.Invalid, "-force", null),
new Option(null, OptionFlags.Unsafe, Index.Invalid, Index.Invalid, "-fail", null),
new Option(null, OptionFlags.MustHaveValue, Index.Invalid, Index.Invalid, "-message", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-current", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, Option.EndOfOptions, null)
});
int argumentIndex = Index.Invalid;
if (arguments.Count > 1)
{
code = interpreter.GetOptions(options, arguments, 0, 1, Index.Invalid, false, ref argumentIndex, ref result);
}
else
{
code = ReturnCode.Ok;
}
if (code == ReturnCode.Ok)
{
if ((argumentIndex == Index.Invalid) ||
((argumentIndex + 1) == arguments.Count))
{
bool force = false;
if (options.IsPresent("-force"))
{
force = true;
}
bool fail = false;
if (options.IsPresent("-fail"))
{
fail = true;
}
Variant value = null;
string message = null;
if (options.IsPresent("-message", ref value))
{
message = value.ToString();
}
//
// NOTE: The default exit code is "success" (i.e. zero).
//
ExitCode exitCode = ResultOps.SuccessExitCode();
if (options.IsPresent("-current"))
{
exitCode = interpreter.ExitCode;
}
//
// NOTE: Was an exit code specified in the command?
//
if (argumentIndex != Index.Invalid)
{
object enumValue = EnumOps.TryParseEnum(
typeof(ExitCode), arguments[argumentIndex],
true, true, ref result);
if (enumValue is ExitCode)
{
exitCode = (ExitCode)enumValue;
}
else
{
result = ScriptOps.BadValue(
null, "exit code", arguments[argumentIndex],
Enum.GetNames(typeof(ExitCode)), null, ", or an integer");
code = ReturnCode.Error;
}
}
//
// NOTE: Make sure we succeeded at coverting the exit code to an integer.
//
if (code == ReturnCode.Ok)
{
//
// NOTE: Make sure the interpreter host, if any, agrees to exit (i.e. it may deny the
// request if the application is doing something that should not be interrupted).
//
code = interpreter.CanExit(exitCode, force, fail, message, ref result);
if (code == ReturnCode.Ok)
{
//
// NOTE: Exit the application (either by marking the current interpreter as "exited"
// or physically exiting the containing process).
//
TraceOps.DebugTrace(String.Format(
"Execute: {0}, interpreter = {1}, message = {2}",
force && fail ?
"forcibly failing" : force ? "forcibly exiting" : "exiting",
FormatOps.InterpreterNoThrow(interpreter), FormatOps.WrapOrNull(message)),
typeof(Exit).Name, TracePriority.Command);
if (force)
{
#if !MONO
if (fail && !CommonOps.Runtime.IsMono())
{
try
{
//
// NOTE: Using this method to exit a script is NOT recommended unless
// you are trying to prevent damaging another part of the system.
//
// MONO: This method is not supported by the Mono runtime.
//
Environment.FailFast(message);
/* NOT REACHED */
result = "failed to exit process";
code = ReturnCode.Error;
}
catch (Exception e)
{
result = e;
code = ReturnCode.Error;
}
}
else
#endif
{
//
// BUGFIX: Try to dispose our containing interpreter now. We must do
// this to prevent it from being disposed on a random GC thread.
//
try
{
interpreter.Dispose();
interpreter = null;
}
catch (Exception e)
{
result = e;
code = ReturnCode.Error;
}
//
// NOTE: If we could not dispose the interpreter properly, complain;
// however, keep exiting anyway.
//
if (code != ReturnCode.Ok)
{
DebugOps.Complain(interpreter, code, result);
}
try
{
//
// NOTE: Using this method to exit a script is NOT recommended unless
// you are running a standalone script in the Eagle Shell (i.e.
// you are not hosted within another application).
//
Environment.Exit((int)exitCode);
/* NOT REACHED */
result = "failed to exit process";
code = ReturnCode.Error;
}
catch (Exception e)
{
result = e;
code = ReturnCode.Error;
}
}
}
else
{
interpreter.ExitCode = exitCode;
interpreter.Exit = true;
result = String.Empty;
code = ReturnCode.Ok;
}
}
}
}
else
{
if ((argumentIndex != Index.Invalid) &&
Option.LooksLikeOption(arguments[argumentIndex]))
{
result = OptionDictionary.BadOption(options, arguments[argumentIndex]);
}
else
{
result = "wrong # args: should be \"exit ?options? ?returnCode?\"";
}
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"exit ?options? ?returnCode?\"";
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)
{
string subCommand = arguments[1];
bool tried = false;
code = ScriptOps.TryExecuteSubCommandFromEnsemble(
interpreter, this, clientData, arguments, false,
false, ref subCommand, ref tried, ref result);
if ((code == ReturnCode.Ok) && !tried)
{
switch (subCommand)
{
case "active":
{
if (arguments.Count == 2)
{
IEventManager eventManager = interpreter.EventManager;
if (EventOps.ManagerIsOk(eventManager))
{
result = eventManager.Active;
code = ReturnCode.Ok;
}
else
{
result = "event manager not available";
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"after active\"";
code = ReturnCode.Error;
}
break;
}
case "cancel":
{
if (arguments.Count >= 3)
{
string text;
if (arguments.Count == 3)
{
text = arguments[2];
}
else
{
text = ListOps.Concat(arguments, 2);
}
IEventManager eventManager = interpreter.EventManager;
if (EventOps.ManagerIsOk(eventManager))
{
code = eventManager.CancelEvents(
text, false, false, ref result);
}
else
{
result = "event manager not available";
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"after cancel arg ?arg ...?\"";
code = ReturnCode.Error;
}
break;
}
case "clear":
{
if (arguments.Count == 2)
{
IEventManager eventManager = interpreter.EventManager;
if (EventOps.ManagerIsOk(eventManager))
{
code = eventManager.ClearEvents(ref result);
if (code == ReturnCode.Ok)
{
result = String.Empty;
}
}
else
{
result = "event manager not available";
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"after clear\"";
code = ReturnCode.Error;
}
break;
}
case "counts":
{
if (arguments.Count == 2)
{
IEventManager eventManager = interpreter.EventManager;
if (EventOps.ManagerIsOk(eventManager))
{
result = StringList.MakeList(
"enabled", eventManager.Enabled,
"active", eventManager.Active,
"createEventCount", Event.CreateCount,
"disposeEventCount", Event.DisposeCount,
"queueEventCount", eventManager.QueueEventCount,
"queueIdleEventCount", eventManager.QueueIdleEventCount,
"eventCount", eventManager.EventCount,
"idleEventCount", eventManager.IdleEventCount,
"totalEventCount", eventManager.TotalEventCount,
"maximumEventCount", eventManager.MaximumEventCount,
"maximumIdleEventCount", eventManager.MaximumIdleEventCount,
"maybeDisposeEventCount", eventManager.MaybeDisposeEventCount,
"reallyDisposeEventCount", eventManager.ReallyDisposeEventCount,
"interpreterEventCount", interpreter.EventCount,
#if NATIVE && TCL
"interpreterTclEventCount", interpreter.TclEventCount,
#endif
"interpreterWaitCount", interpreter.WaitCount,
"interpreterWaitSpinCount", interpreter.WaitSpinCount);
code = ReturnCode.Ok;
}
else
{
result = "event manager not available";
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"after counts\"";
code = ReturnCode.Error;
}
break;
}
case "dump":
{
if (arguments.Count == 2)
{
IEventManager eventManager = interpreter.EventManager;
if (EventOps.ManagerIsOk(eventManager))
{
code = eventManager.Dump(ref result);
}
else
{
result = "event manager not available";
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"after dump\"";
code = ReturnCode.Error;
}
break;
}
case "enable":
{
if ((arguments.Count == 2) || (arguments.Count == 3))
{
IEventManager eventManager = interpreter.EventManager;
if (EventOps.ManagerIsOk(eventManager))
{
if (arguments.Count == 3)
{
bool enabled = false;
code = Value.GetBoolean2(
arguments[2], ValueFlags.AnyBoolean,
interpreter.CultureInfo, ref enabled, ref result);
if (code == ReturnCode.Ok)
{
eventManager.Enabled = enabled;
}
}
if (code == ReturnCode.Ok)
{
result = eventManager.Enabled;
}
}
else
{
result = "event manager not available";
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"after enable ?enabled?\"";
code = ReturnCode.Error;
}
break;
}
case "flags":
{
if ((arguments.Count == 2) || (arguments.Count == 3))
{
lock (interpreter.SyncRoot) /* TRANSACTIONAL */
{
if (arguments.Count == 3)
{
object enumValue = EnumOps.TryParseFlagsEnum(
interpreter, typeof(EventFlags),
interpreter.AfterEventFlags.ToString(),
arguments[2], interpreter.CultureInfo,
true, true, true, ref result);
if (enumValue is EventFlags)
{
interpreter.AfterEventFlags = (EventFlags)enumValue;
}
else
{
code = ReturnCode.Error;
}
}
if (code == ReturnCode.Ok)
{
result = interpreter.AfterEventFlags;
}
}
}
else
{
result = "wrong # args: should be \"after flags ?flags?\"";
code = ReturnCode.Error;
}
break;
}
case "idle":
{
if (arguments.Count >= 3)
{
IEventManager eventManager = interpreter.EventManager;
if (EventOps.ManagerIsOk(eventManager))
{
//
// FIXME: PRI 5: Somewhat arbitrary, we cannot be "idle" with no
// windows message loop.
//
string name = FormatOps.Id(this.Name, null, interpreter.NextId());
DateTime now = TimeOps.GetUtcNow();
DateTime dateTime = now.AddMilliseconds(EventManager.MinimumIdleWaitTime);
string text;
if (arguments.Count == 3)
{
text = arguments[2];
}
else
{
text = ListOps.Concat(arguments, 2);
}
IScript script = interpreter.CreateAfterScript(
name, null, null, ScriptTypes.Idle, text,
now, EngineMode.EvaluateScript, ScriptFlags.None,
clientData, true);
code = eventManager.QueueScript(
name, dateTime, script, script.EventFlags,
EventPriority.Idle, ref result);
if (code == ReturnCode.Ok)
{
result = name;
}
}
else
{
result = "event manager not available";
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"after idle arg ?arg ...?\"";
code = ReturnCode.Error;
}
break;
}
case "info":
{
if ((arguments.Count == 2) || (arguments.Count == 3))
{
IEventManager eventManager = interpreter.EventManager;
if (EventOps.ManagerIsOk(eventManager))
{
if (arguments.Count == 3)
{
IEvent @event = null;
code = eventManager.GetEvent(
arguments[2], ref @event, ref result);
if (code == ReturnCode.Ok)
{
if (EventManager.IsScriptEvent(@event))
{
if (@event.ClientData != null)
{
IScript script = @event.ClientData.Data as IScript;
if (script != null)
{
result = script.ToString();
}
else
{
result = String.Format(
"event \"{0}\" clientData is not a script",
arguments[2]);
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"event \"{0}\" has invalid clientData",
arguments[2]);
code = ReturnCode.Error;
}
}
else
{
result = String.Format(
"event \"{0}\" is not an after event",
arguments[2]);
code = ReturnCode.Error;
}
}
}
else
{
StringList list = null;
code = eventManager.ListEvents(null, false, ref list, ref result);
if (code == ReturnCode.Ok)
{
result = list;
}
}
}
else
{
result = "event manager not available";
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"after info ?id?\"";
code = ReturnCode.Error;
}
break;
}
default:
{
long milliseconds = 0; // for idle, execute the script right now.
code = Value.GetWideInteger2(
subCommand, ValueFlags.AnyWideInteger,
interpreter.CultureInfo, ref milliseconds, ref result);
if (code == ReturnCode.Ok)
{
if (arguments.Count == 2)
{
//
// BUGBUG: This call will never timeout if we cannot obtain
// the interpreter lock.
//
code = EventOps.Wait(
interpreter, PerformanceOps.GetMicroseconds(milliseconds),
false, false, ref result);
if (code == ReturnCode.Ok)
{
result = String.Empty;
}
}
else if (arguments.Count >= 3)
{
IEventManager eventManager = interpreter.EventManager;
if (EventOps.ManagerIsOk(eventManager))
{
string name = FormatOps.Id(this.Name, null, interpreter.NextId());
DateTime now = TimeOps.GetUtcNow();
DateTime dateTime = now.AddMilliseconds(milliseconds);
string text;
if (arguments.Count == 3)
{
text = arguments[2];
}
else
{
text = ListOps.Concat(arguments, 2);
}
IScript script = interpreter.CreateAfterScript(
name, null, null, ScriptTypes.Timer, text,
now, EngineMode.EvaluateScript, ScriptFlags.None,
clientData, false);
code = eventManager.QueueScript(
name, dateTime, script, script.EventFlags,
EventPriority.After, ref result);
if (code == ReturnCode.Ok)
{
result = name;
}
}
else
{
result = "event manager not available";
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"after milliseconds arg ?arg ...?\"";
code = ReturnCode.Error;
}
}
else
{
result = ScriptOps.BadSubCommand(
interpreter, null, "argument", subCommand, this, null, ", or a number");
}
break;
}
}
}
}
else
{
result = "wrong # args: should be \"after option ?arg ...?\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region IExecuteArgument Members
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Argument value,
ref Result error
)
{
ReturnCode code = ReturnCode.Ok;
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count == (this.Arguments + 1))
{
Variant variant1 = null;
code = Value.GetVariant(interpreter,
(IGetValue)arguments[1], ValueFlags.AnyVariant,
interpreter.CultureInfo, ref variant1, ref error);
int intValue = 0;
if (code == ReturnCode.Ok)
{
code = Value.GetInteger2(
(IGetValue)arguments[2], ValueFlags.AnyInteger,
interpreter.CultureInfo, ref intValue, ref error);
}
MidpointRounding rounding = MidpointRounding.ToEven; // TODO: Good default?
if (code == ReturnCode.Ok)
{
object enumValue = EnumOps.TryParseEnum(
typeof(MidpointRounding), arguments[3], true,
true, ref error);
if (enumValue is MidpointRounding)
{
rounding = (MidpointRounding)enumValue;
}
else
{
code = ReturnCode.Error;
}
}
if (code == ReturnCode.Ok)
{
try
{
if (variant1.IsDouble())
{
//
// NOTE: No FixPrecision, Already rounding.
//
value = Math.Round((double)variant1.Value, intValue, rounding);
}
else if (variant1.IsDecimal())
{
//
// NOTE: No FixPrecision, Already rounding.
//
value = Math.Round((decimal)variant1.Value, intValue, rounding);
}
else if (variant1.IsWideInteger())
{
value = ((long)variant1.Value);
}
else if (variant1.IsInteger())
{
value = ((int)variant1.Value);
}
else if (variant1.IsBoolean())
{
value = ((bool)variant1.Value);
}
else
{
error = String.Format(
"unsupported variant type for function \"{0}\"",
base.Name);
code = ReturnCode.Error;
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
error = String.Format(
"caught math exception: {0}",
e);
code = ReturnCode.Error;
}
}
}
else
{
if (arguments.Count > (this.Arguments + 1))
{
error = String.Format(
"too many arguments for math function \"{0}\"",
base.Name);
}
else
{
error = String.Format(
"too few arguments for math function \"{0}\"",
base.Name);
}
code = ReturnCode.Error;
}
}
else
{
error = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
error = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region IExecuteArgument Members
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Argument value,
ref Result error
)
{
ReturnCode code = ReturnCode.Ok;
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count == (this.Arguments + 1))
{
lock (interpreter.SyncRoot) /* TRANSACTIONAL */
{
object enumValue = EnumOps.TryParseFlagsEnum(
interpreter, typeof(ExpressionFlags),
interpreter.ExpressionFlags.ToString(),
arguments[1], interpreter.CultureInfo,
true, true, true, ref error);
if (enumValue is ExpressionFlags)
{
try
{
interpreter.ExpressionFlags = (ExpressionFlags)enumValue;
value = interpreter.ExpressionFlags;
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
error = String.Format(
"caught math exception: {0}",
e);
code = ReturnCode.Error;
}
}
else
{
code = ReturnCode.Error;
}
}
}
else
{
if (arguments.Count > (this.Arguments + 1))
{
error = String.Format(
"too many arguments for math function \"{0}\"",
base.Name);
}
else
{
error = String.Format(
"too few arguments for math function \"{0}\"",
base.Name);
}
code = ReturnCode.Error;
}
}
else
{
error = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
error = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
///////////////////////////////////////////////////////////////////////
public static IOption FromString(
Interpreter interpreter,
string text,
AppDomain appDomain,
ValueFlags valueFlags,
CultureInfo cultureInfo,
ref Result error
)
{
StringList list = null;
if (Parser.SplitList(
interpreter, text, 0, Length.Invalid, true,
ref list, ref error) != ReturnCode.Ok)
{
return(null);
}
if (list.Count < MinimumElementCount)
{
error = String.Format(
"cannot create option, only {0} of {1} " +
"required elements were specified", list.Count,
MinimumElementCount);
return(null);
}
bool allowInteger;
bool strict;
bool verbose;
bool noCase;
_Public.Value.ExtractTypeValueFlags(
valueFlags, out allowInteger, out strict,
out verbose, out noCase);
object enumValue = EnumOps.TryParseFlagsEnum(
interpreter, typeof(OptionFlags), null,
list[0], cultureInfo, allowInteger, strict,
noCase, ref error);
if (!(enumValue is OptionFlags))
{
return(null);
}
OptionFlags optionFlags = (OptionFlags)enumValue;
string name = list[1];
if (name == null)
{
error = "invalid option name";
return(null);
}
int nextIndex = MinimumElementCount;
Type type = null;
if (FlagOps.HasFlags(
optionFlags, OptionFlags.MustBeEnumMask, false))
{
if (nextIndex >= list.Count)
{
error = String.Format(
"option with {0} or {1} flags must have type name",
FormatOps.WrapOrNull(OptionFlags.MustBeEnum),
FormatOps.WrapOrNull(OptionFlags.MustBeEnumList));
return(null);
}
ResultList errors = null;
if (_Public.Value.GetType(
interpreter, list[nextIndex], null, appDomain,
_Public.Value.GetTypeValueFlags(optionFlags),
cultureInfo, ref type, ref errors) != ReturnCode.Ok)
{
error = errors;
return(null);
}
nextIndex++;
}
Variant value = null;
if (ScriptOps.GetOptionValue(
interpreter, list, type, optionFlags, false, allowInteger,
strict, noCase, cultureInfo, ref value, ref nextIndex,
ref error) != ReturnCode.Ok)
{
return(null);
}
int groupIndex = _Constants.Index.Invalid;
if (nextIndex < list.Count)
{
if (_Public.Value.GetInteger2(
list[nextIndex], ValueFlags.AnyInteger, cultureInfo,
ref groupIndex, ref error) != ReturnCode.Ok)
{
return(null);
}
nextIndex++;
}
return(new Option(
type, optionFlags, groupIndex, _Constants.Index.Invalid,
name, value));
}
///////////////////////////////////////////////////////////////////////
public static IOption FromString( /* COMPAT: Eagle beta. */
Interpreter interpreter,
string text,
AppDomain appDomain,
bool allowInteger,
bool strict,
bool verbose,
bool noCase,
CultureInfo cultureInfo,
ref Result error
)
{
StringList list = null;
if (Parser.SplitList(
interpreter, text, 0, Length.Invalid, true,
ref list, ref error) != ReturnCode.Ok)
{
return(null);
}
if (list.Count < StandardElementCount)
{
error = String.Format(
"cannot create option, only {0} of {1} " +
"required elements were specified", list.Count,
StandardElementCount);
return(null);
}
Type type = null;
ResultList errors = null;
if (_Public.Value.GetType(
interpreter, list[0], null, appDomain,
_Public.Value.GetTypeValueFlags(
allowInteger, strict, verbose,
noCase), cultureInfo, ref type,
ref errors) != ReturnCode.Ok)
{
error = errors;
return(null);
}
object enumValue = EnumOps.TryParseFlagsEnum(
interpreter, typeof(OptionFlags), null,
list[1], cultureInfo, allowInteger, strict,
noCase, ref error);
if (!(enumValue is OptionFlags))
{
return(null);
}
OptionFlags optionFlags = (OptionFlags)enumValue;
int groupIndex = 0;
if (_Public.Value.GetInteger2(
list[2], ValueFlags.AnyInteger, cultureInfo,
ref groupIndex, ref error) != ReturnCode.Ok)
{
return(null);
}
int index = 0;
if (_Public.Value.GetInteger2(
list[3], ValueFlags.AnyInteger, cultureInfo,
ref index, ref error) != ReturnCode.Ok)
{
return(null);
}
string name = list[4];
if (name == null)
{
error = "invalid option name";
return(null);
}
int nextIndex = StandardElementCount;
Variant value = null;
if (ScriptOps.GetOptionValue(
interpreter, list, type, optionFlags, true, allowInteger,
strict, noCase, cultureInfo, ref value, ref nextIndex,
ref error) != ReturnCode.Ok)
{
return(null);
}
return(new Option(
type, optionFlags, groupIndex, index, name, value));
}
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 == 3) || (arguments.Count == 4))
{
string channelId = arguments[1];
Channel channel = interpreter.GetChannel(channelId, ref result);
if (channel != null)
{
long offset = 0;
code = Value.GetWideInteger2(
(IGetValue)arguments[2], ValueFlags.AnyWideInteger,
interpreter.CultureInfo, ref offset, ref result);
if (code == ReturnCode.Ok)
{
SeekOrigin origin = SeekOrigin.Begin;
if (arguments.Count >= 4)
{
object enumValue = EnumOps.TryParseEnum(
typeof(MapSeekOrigin), arguments[3],
true, true);
if (enumValue is MapSeekOrigin)
{
origin = (SeekOrigin)enumValue;
}
else
{
result = String.Format(
"bad origin \"{0}\": must be start, current, or end",
arguments[3]);
code = ReturnCode.Error;
}
}
if (code == ReturnCode.Ok)
{
try
{
if (channel.CanSeek)
{
channel.Seek(offset, origin);
result = String.Empty;
}
else
{
result = String.Format(
"error during seek on \"{0}\": invalid argument",
channelId);
code = ReturnCode.Error;
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
result = e;
code = ReturnCode.Error;
}
}
}
}
else
{
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"seek channelId offset ?origin?\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
///////////////////////////////////////////////////////////////////////////////////////
#region IExecute Members
public override ReturnCode Execute(
Interpreter interpreter,
IClientData clientData,
ArgumentList arguments,
ref Result result
)
{
if (interpreter != null)
{
if (arguments != null)
{
if (arguments.Count >= 2)
{
VariableFlags flags = VariableFlags.None;
object enumValue = EnumOps.TryParseFlagsEnum(
interpreter, typeof(VariableFlags),
flags.ToString(), arguments[1],
interpreter.CultureInfo, true, true,
true, ref result);
if (enumValue is VariableFlags)
{
flags = (VariableFlags)enumValue;
if (arguments.Count > 2)
{
for (int argumentIndex = 2;
argumentIndex < arguments.Count;
argumentIndex++)
{
if (interpreter.UnsetVariable(flags,
arguments[argumentIndex],
ref result) != ReturnCode.Ok)
{
return(ReturnCode.Error);
}
}
result = String.Empty;
return(ReturnCode.Ok);
}
//
// NOTE: Do nothing if no more arguments supplied,
// so as to match command documentation
// (COMPAT: Tcl).
//
result = String.Empty;
return(ReturnCode.Ok);
}
else
{
return(ReturnCode.Error);
}
}
else
{
result = "wrong # args: should be \"unsetf varFlags ?varName varName ...?\"";
return(ReturnCode.Error);
}
}
else
{
result = "invalid argument list";
return(ReturnCode.Error);
}
}
else
{
result = "invalid interpreter";
return(ReturnCode.Error);
}
}
///////////////////////////////////////////////////////////////////////
#if XML
private static ReturnCode FromDocument(
XmlDocument document,
InterpreterSettings interpreterSettings,
ref Result error
)
{
if (document == null)
{
error = "invalid xml document";
return(ReturnCode.Error);
}
if (interpreterSettings == null)
{
error = "invalid interpreter settings";
return(ReturnCode.Error);
}
XmlElement documentElement = document.DocumentElement;
if (documentElement == null)
{
error = "invalid xml document element";
return(ReturnCode.Error);
}
XmlNode node;
node = documentElement.SelectSingleNode("Args");
if ((node != null) && !String.IsNullOrEmpty(node.InnerText))
{
StringList list = null;
if (Parser.SplitList(
null, node.InnerText, 0, Length.Invalid, false,
ref list, ref error) == ReturnCode.Ok)
{
interpreterSettings.Args = list;
}
else
{
return(ReturnCode.Error);
}
}
node = documentElement.SelectSingleNode("CreateFlags");
if ((node != null) && !String.IsNullOrEmpty(node.InnerText))
{
object enumValue = EnumOps.TryParseEnum(
typeof(CreateFlags), node.InnerText,
true, true, ref error);
if (enumValue is CreateFlags)
{
interpreterSettings.CreateFlags = (CreateFlags)enumValue;
}
else
{
return(ReturnCode.Error);
}
}
node = documentElement.SelectSingleNode("InitializeFlags");
if ((node != null) && !String.IsNullOrEmpty(node.InnerText))
{
object enumValue = EnumOps.TryParseEnum(
typeof(InitializeFlags), node.InnerText,
true, true, ref error);
if (enumValue is InitializeFlags)
{
interpreterSettings.InitializeFlags = (InitializeFlags)enumValue;
}
else
{
return(ReturnCode.Error);
}
}
node = documentElement.SelectSingleNode("ScriptFlags");
if ((node != null) && !String.IsNullOrEmpty(node.InnerText))
{
object enumValue = EnumOps.TryParseEnum(
typeof(ScriptFlags), node.InnerText,
true, true, ref error);
if (enumValue is ScriptFlags)
{
interpreterSettings.ScriptFlags = (ScriptFlags)enumValue;
}
else
{
return(ReturnCode.Error);
}
}
node = documentElement.SelectSingleNode("InterpreterFlags");
if ((node != null) && !String.IsNullOrEmpty(node.InnerText))
{
object enumValue = EnumOps.TryParseEnum(
typeof(InterpreterFlags), node.InnerText,
true, true, ref error);
if (enumValue is InterpreterFlags)
{
interpreterSettings.InterpreterFlags = (InterpreterFlags)enumValue;
}
else
{
return(ReturnCode.Error);
}
}
node = documentElement.SelectSingleNode("AutoPathList");
if ((node != null) && !String.IsNullOrEmpty(node.InnerText))
{
StringList list = null;
if (Parser.SplitList(
null, node.InnerText, 0, Length.Invalid, false,
ref list, ref error) == ReturnCode.Ok)
{
interpreterSettings.AutoPathList = list;
}
else
{
return(ReturnCode.Error);
}
}
return(ReturnCode.Ok);
}
///////////////////////////////////////////////////////////////////////
//
// HACK: This is a horrible hack to workaround the issue with not being
// able to use plugin enumerated types from the "primary"
// application domain when the plugin has been loaded in isolated
// mode.
//
public static ReturnCode FixupOptions(
IPluginData pluginData,
OptionDictionary options,
bool strict,
ref Result error
)
{
if (pluginData == null)
{
if (strict)
{
error = "invalid plugin data";
return(ReturnCode.Error);
}
return(ReturnCode.Ok);
}
if (options == null)
{
if (strict)
{
error = "invalid options";
return(ReturnCode.Error);
}
return(ReturnCode.Ok);
}
if (!IsIsolated(pluginData))
{
return(ReturnCode.Ok);
}
Assembly assembly = pluginData.Assembly;
foreach (KeyValuePair <string, IOption> pair in options)
{
IOption option = pair.Value;
if (option == null)
{
continue;
}
//
// HACK: Skip options that do not have enumerated types.
// For now, these are the only options we really have to
// worry about because they are the only ones that can
// directly refer to user-defined types [of any kind].
//
if (!option.HasFlags(OptionFlags.MustBeEnum, true))
{
continue;
}
//
// NOTE: Grab the enumerated (?) type and figure out if it
// came from the plugin assembly. If not, ignore it and
// continue.
//
Type type = option.Type;
if ((type == null) || !type.IsEnum ||
!Object.ReferenceEquals(type.Assembly, assembly))
{
continue;
}
//
// NOTE: Get the current value of the option.
//
object oldValue = option.InnerValue;
TypeCode typeCode = TypeCode.Empty;
//
// NOTE: Attempt to get the new value for the integral type for
// the enumeration value of this option, if any. We must
// do this even if the original value is null because we
// must have the type code to properly reset the option
// flags.
//
object newValue = EnumOps.ConvertToTypeCodeValue(
type, (oldValue != null) ? oldValue : 0, ref typeCode,
ref error);
if (newValue == null)
{
return(ReturnCode.Error);
}
//
// NOTE: Get the option flags required for the integral type.
//
OptionFlags flags = GetEnumOptionFlags(typeCode, strict);
if (flags == OptionFlags.None)
{
error = String.Format(
"unsupported type code for enumerated type \"{0}\"",
type);
return(ReturnCode.Error);
}
//
// NOTE: Special handling for "flags" enumerations here.
//
if (EnumOps.IsFlagsEnum(type))
{
//
// HACK: Substitute our placeholder flags enumerated type.
// It does not know about the textual values provided
// by the actual enumerated type; however, at least
// they can use the custom flags enumeration handling
// (i.e. the "+" and "-" operators, etc).
//
option.Type = typeof(StubFlagsEnum);
}
else
{
//
// NOTE: Remove the MustBeEnum flag for this option and add
// the flag(s) needed for its integral type.
//
option.Flags &= ~OptionFlags.MustBeEnum;
option.Flags |= flags;
//
// NOTE: Clear the type for the option. The type property
// is only meaningful for enumeration-based options
// and we are converting this option to use some kind
// of integral type.
//
option.Type = null;
}
//
// NOTE: If necessary, set the new [default] value for this
// option to the one we converted to an integral type
// value above. If the old (original) value was null, we
// just discard the new value which will be zero anyhow.
//
option.Value = (oldValue != null) ? new Variant(newValue) : null;
}
return(ReturnCode.Ok);
}
///////////////////////////////////////////////////////////////////////////////////////
#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 == 3) || (arguments.Count == 4))
{
VariableFlags flags = VariableFlags.None;
object enumValue = EnumOps.TryParseFlagsEnum(
interpreter, typeof(VariableFlags),
flags.ToString(), arguments[1],
interpreter.CultureInfo, true, true,
true, ref result);
if (enumValue is VariableFlags)
{
flags = (VariableFlags)enumValue;
if (arguments.Count == 3)
{
code = interpreter.GetVariableValue(
flags, arguments[2], ref result, ref result);
}
else if (arguments.Count == 4)
{
code = interpreter.SetVariableValue(
flags, arguments[2], arguments[3], null, ref result);
if (code == ReturnCode.Ok)
{
//
// NOTE: Maybe it was append mode? Re-get the value now.
//
code = interpreter.GetVariableValue(
flags, arguments[2], ref result, ref result);
}
}
}
else
{
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"setf varFlags varName ?newValue?\"";
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)
{
string channelId = arguments[1];
Channel channel = interpreter.GetChannel(channelId, ref result);
if (channel != null)
{
try
{
if (arguments.Count >= 4)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.MustHaveBooleanValue, Index.Invalid, Index.Invalid, "-blocking", null),
new Option(null, OptionFlags.MustHaveEncodingValue, Index.Invalid, Index.Invalid, "-encoding", null),
new Option(null, OptionFlags.MustHaveListValue, Index.Invalid, Index.Invalid, "-translation", null)
});
int argumentIndex = Index.Invalid;
code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, true, ref argumentIndex, ref result);
if (code == ReturnCode.Ok)
{
if (argumentIndex == Index.Invalid)
{
Variant value = null;
bool? blockingMode = null;
if (options.IsPresent("-blocking"))
{
blockingMode = (bool)value.Value;
}
Encoding encoding = null;
if (options.IsPresent("-encoding", ref value))
{
encoding = (Encoding)value.Value;
}
StringList translationNames = null;
if (options.IsPresent("-translation", ref value))
{
translationNames = (StringList)value.Value;
}
StreamTranslationList translation = null;
if (translationNames != null)
{
if ((translationNames.Count == 1) || (translationNames.Count == 2))
{
translation = new StreamTranslationList();
foreach (string translationName in translationNames)
{
object enumValue = EnumOps.TryParseEnum(
typeof(StreamTranslation), translationName,
true, true);
if (enumValue is StreamTranslation)
{
translation.Add((StreamTranslation)enumValue);
}
else
{
result = ScriptOps.BadValue(
null, "value for -translation", translationName,
Enum.GetNames(typeof(StreamTranslation)),
null, null);
code = ReturnCode.Error;
break;
}
}
}
else
{
result = "bad value for -translation: must be a one or two element list";
code = ReturnCode.Error;
}
}
if (code == ReturnCode.Ok)
{
if (blockingMode != null)
{
channel.SetBlockingMode((bool)blockingMode);
}
if (encoding != null)
{
channel.SetEncoding(encoding);
}
if (translation != null)
{
channel.SetTranslation(translation);
}
result = String.Empty;
}
}
else
{
result = "wrong # args: should be \"fconfigure channelId ?optionName? ?value?\"";
code = ReturnCode.Error;
}
}
}
else if (arguments.Count == 3)
{
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null, OptionFlags.MustHaveBooleanValue, Index.Invalid, Index.Invalid, "-blocking", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-encoding", null),
new Option(null, OptionFlags.None, Index.Invalid, Index.Invalid, "-translation", null)
});
int argumentIndex = Index.Invalid;
code = interpreter.GetOptions(options, arguments, 0, 2, Index.Invalid, true, ref argumentIndex, ref result);
if (code == ReturnCode.Ok)
{
if (argumentIndex == Index.Invalid)
{
StringList list = new StringList();
if (options.IsPresent("-blocking"))
{
list.Add(channel.GetBlockingMode().ToString());
}
if (options.IsPresent("-encoding"))
{
list.Add(channel.GetEncoding().WebName);
}
if (options.IsPresent("-translation"))
{
list.Add(channel.GetTranslation().ToString());
}
if (list.Count > 1)
{
result = list;
}
else if (list.Count == 1)
{
result = list[0];
}
else
{
result = String.Empty;
}
}
else
{
result = "wrong # args: should be \"fconfigure channelId ?optionName? ?value?\"";
code = ReturnCode.Error;
}
}
}
else
{
Encoding encoding = channel.GetEncoding();
StreamTranslationList translation = channel.GetTranslation();
result = StringList.MakeList(
"-blocking", channel.GetBlockingMode(),
"-encoding", (encoding != null) ?
encoding.WebName : StringOps.NullEncodingName,
"-translation", translation);
}
}
catch (Exception e)
{
Engine.SetExceptionErrorCode(interpreter, e);
result = e;
code = ReturnCode.Error;
}
}
else
{
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"fconfigure channelId ?optionName? ?value?\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
