///////////////////////////////////////////////////////////////////////
public static bool HasFlags(
EventWaitFlags flags,
EventWaitFlags hasFlags,
bool all
)
{
if (all)
{
return((flags & hasFlags) == hasFlags);
}
else
{
return((flags & hasFlags) != EventWaitFlags.None);
}
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region IExecute Members
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)
{
//
// NOTE: Grab the variable and event wait flags from the
// interpreter and use them as the defaults for the
// associated options.
//
EventWaitFlags eventWaitFlags = interpreter.EventWaitFlags;
VariableFlags variableFlags = interpreter.EventVariableFlags;
OptionDictionary options = new OptionDictionary(
new IOption[] {
new Option(null,
OptionFlags.MustHaveObjectValue | OptionFlags.Unsafe,
Index.Invalid, Index.Invalid, "-handle", null),
new Option(typeof(EventWaitFlags),
OptionFlags.MustHaveEnumValue | OptionFlags.Unsafe,
Index.Invalid, Index.Invalid, "-eventwaitflags",
new Variant(eventWaitFlags)),
new Option(typeof(VariableFlags),
OptionFlags.MustHaveEnumValue | OptionFlags.Unsafe,
Index.Invalid, Index.Invalid, "-variableflags",
new Variant(variableFlags)),
new Option(null,
OptionFlags.MustHaveIntegerValue | OptionFlags.Unsafe,
Index.Invalid, Index.Invalid, "-limit", null),
new Option(null, OptionFlags.Unsafe, Index.Invalid,
Index.Invalid, "-force", null),
new Option(null, OptionFlags.Unsafe, Index.Invalid,
Index.Invalid, "-nocomplain", null),
new Option(null, OptionFlags.Unsafe, Index.Invalid,
Index.Invalid, "-leaveresult", 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)
{
if ((argumentIndex != Index.Invalid) &&
((argumentIndex + 1) == arguments.Count))
{
Variant value = null;
EventWaitHandle @event = null;
if (options.IsPresent("-handle", ref value))
{
IObject @object = (IObject)value.Value;
if ((@object.Value == null) ||
(@object.Value is EventWaitHandle))
{
@event = (EventWaitHandle)@object.Value;
}
else
{
result = "option value has invalid EventWaitHandle";
code = ReturnCode.Error;
}
}
if (code == ReturnCode.Ok)
{
int limit = 0;
if (options.IsPresent("-limit", ref value))
{
limit = (int)value.Value;
}
if (options.IsPresent("-eventwaitflags", ref value))
{
eventWaitFlags = (EventWaitFlags)value.Value;
}
if (options.IsPresent("-variableflags", ref value))
{
variableFlags = (VariableFlags)value.Value;
}
bool force = false;
if (options.IsPresent("-force"))
{
force = true;
}
bool noComplain = false;
if (options.IsPresent("-nocomplain"))
{
noComplain = true;
}
bool leaveResult = false;
if (options.IsPresent("-leaveresult"))
{
leaveResult = true;
}
//
// NOTE: Typically, we do not want to enter a wait state if
// there are no events queued because there would be
// no possible way to ever (gracefully) exit the wait;
// however, there are exceptions to this.
//
if (force || interpreter.ShouldWaitVariable())
{
//
// HACK: The call to ThreadOps.IsStaThread here is made
// under the assumption that no user-interface
// thread can exist without also being an STA
// thread. This may eventually prove to be false;
// however, currently WinForms, WPF, et al require
// this (i.e. an STA thread).
//
if (!FlagOps.HasFlags(
eventWaitFlags, EventWaitFlags.UserInterface,
true) && ThreadOps.IsStaThread())
{
eventWaitFlags |= EventWaitFlags.UserInterface;
}
code = interpreter.WaitVariable(eventWaitFlags,
variableFlags, arguments[argumentIndex], limit,
@event, ref result);
if ((code != ReturnCode.Ok) && noComplain)
{
code = ReturnCode.Ok;
}
if ((code == ReturnCode.Ok) && !leaveResult)
{
Engine.ResetResult(interpreter, ref result);
}
}
else
{
result = String.Format(
"can't wait for variable \"{0}\": would wait forever",
arguments[1]);
code = ReturnCode.Error;
}
}
}
else
{
if ((argumentIndex != Index.Invalid) &&
Option.LooksLikeOption(arguments[argumentIndex]))
{
result = OptionDictionary.BadOption(
options, arguments[argumentIndex]);
}
else
{
result = "wrong # args: should be \"vwait ?options? varName\"";
}
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"vwait ?options? varName\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
