///////////////////////////////////////////////////////////////////////
private static bool IsHashAlgorithm(
Type type,
ref string subTypeName
)
{
if (type == null)
{
return(false);
}
if (MarshalOps.IsAssignableFrom(typeof(HMAC), type))
{
subTypeName = "mac";
return(true);
}
if (MarshalOps.IsAssignableFrom(typeof(KeyedHashAlgorithm), type))
{
subTypeName = "keyed";
return(true);
}
if (MarshalOps.IsAssignableFrom(typeof(HashAlgorithm), type))
{
subTypeName = "normal";
return(true);
}
return(false);
}
public static object load(PythonFile /*!*/ file)
{
if (file == null)
{
throw PythonOps.TypeError("expected file, found None");
}
return(MarshalOps.GetObject(FileEnumerator(file)));
}
public static object load(CodeContext /*!*/ context, PythonIOModule._IOBase /*!*/ file)
{
if (file == null)
{
throw PythonOps.TypeError("expected file, found None");
}
return(MarshalOps.GetObject(FileEnumerator(context, file)));
}
public static string dumps(object value, int version)
{
byte[] bytes = MarshalOps.GetBytes(value, version);
StringBuilder sb = new StringBuilder(bytes.Length);
for (int i = 0; i < bytes.Length; i++)
{
sb.Append((char)bytes[i]);
}
return(sb.ToString());
}
///////////////////////////////////////////////////////////////////////
#region Public Static Methods
public static string Wrap(
Interpreter interpreter,
object value
)
{
//
// HACK: Currently, it is impossible to pass a string that
// happens to represent an existing opaque object
// handle to any managed method via [object invoke],
// et al. This is because there must be internal
// calls (inside the binder and method overload
// resolution engine) that automatically convert any
// such string to the underlying raw object value for
// [object invoke] to be truly useful. This method
// is an extremely nasty hack that works around this
// issue.
//
if (interpreter != null)
{
string name = null;
if (interpreter.GetObject(
value, LookupFlags.MarshalNoVerbose,
ref name) == ReturnCode.Ok)
{
Result result = null;
if (MarshalOps.FixupReturnValue(
interpreter, interpreter.Binder,
interpreter.CultureInfo, null, ObjectFlags.None,
null, ObjectOptionType.None, null, null, name,
true, ObjectOps.GetDefaultDispose(), false,
false, false, ref result) == ReturnCode.Ok)
{
return(result);
}
}
else if (value is string)
{
return((string)value);
}
}
return(null);
}
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)
{
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)
{
//
// NOTE: Programmatically interact with the debugger (breakpoint, watch,
// eval, etc).
//
switch (subCommand)
{
case "clear":
{
if (arguments.Count == 2)
{
code = interpreter.ClearCallbackQueue(ref result);
if (code == ReturnCode.Ok)
{
result = String.Empty;
}
}
else
{
result = "wrong # args: should be \"callback clear\"";
code = ReturnCode.Error;
}
break;
}
case "count":
{
if (arguments.Count == 2)
{
int count = 0;
code = interpreter.CountCallbacks(ref count, ref result);
if (code == ReturnCode.Ok)
{
result = count;
}
}
else
{
result = "wrong # args: should be \"callback count\"";
code = ReturnCode.Error;
}
break;
}
case "dequeue":
{
if (arguments.Count >= 2)
{
OptionDictionary options = ObjectOps.GetDequeueOptions();
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)
{
if (argumentIndex == Index.Invalid)
{
Type returnType;
ObjectFlags objectFlags;
string objectName;
string interpName;
bool create;
bool dispose;
bool alias;
bool aliasRaw;
bool aliasAll;
bool aliasReference;
bool toString;
ObjectOps.ProcessFixupReturnValueOptions(
options, null, out returnType, out objectFlags,
out objectName, out interpName, out create,
out dispose, out alias, out aliasRaw, out aliasAll,
out aliasReference, out toString);
//
// NOTE: Which Tcl interpreter do we want a command alias created
// in, if any?
//
ICallback callback = null;
code = interpreter.DequeueCallback(ref callback, ref result);
if (code == ReturnCode.Ok)
{
ObjectOptionType objectOptionType = ObjectOptionType.Dequeue |
ObjectOps.GetOptionType(aliasRaw, aliasAll);
code = MarshalOps.FixupReturnValue(
interpreter, interpreter.Binder, interpreter.CultureInfo,
returnType, objectFlags, ObjectOps.GetInvokeOptions(
objectOptionType), objectOptionType, objectName, interpName,
callback, create, dispose, alias, aliasReference, toString,
ref result);
}
}
else
{
result = "wrong # args: should be \"callback dequeue ?options?\"";
code = ReturnCode.Error;
}
}
}
else
{
result = "wrong # args: should be \"callback dequeue ?options?\"";
code = ReturnCode.Error;
}
break;
}
case "enqueue":
{
if (arguments.Count >= 3)
{
ICallback callback = CommandCallback.Create(
MarshalFlags.Default, CallbackFlags.Default,
ObjectFlags.Callback, ByRefArgumentFlags.None,
interpreter, clientData, null, new StringList(
arguments, 2), ref result);
if (callback != null)
{
code = interpreter.EnqueueCallback(callback, ref result);
if (code == ReturnCode.Ok)
{
result = String.Empty;
}
}
else
{
code = ReturnCode.Error;
}
}
else
{
result = "wrong # args: should be \"callback enqueue name ?arg ...?\"";
code = ReturnCode.Error;
}
break;
}
case "execute":
{
if (arguments.Count == 2)
{
code = interpreter.ExecuteCallbackQueue(ref result);
}
else
{
result = "wrong # args: should be \"callback execute\"";
code = ReturnCode.Error;
}
break;
}
case "list":
{
if ((arguments.Count == 2) || (arguments.Count == 3))
{
string pattern = null;
if (arguments.Count == 3)
{
pattern = arguments[2];
}
StringList list = null;
code = interpreter.ListCallbacks(
pattern, false, ref list, ref result);
if (code == ReturnCode.Ok)
{
result = list;
}
}
else
{
result = "wrong # args: should be \"callback list ?pattern?\"";
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 \"callback option ?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 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 "deserialize":
{
if (arguments.Count >= 4)
{
#if SERIALIZATION
OptionDictionary options = ObjectOps.GetDeserializeOptions();
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) && ((argumentIndex + 2) == arguments.Count))
{
bool verbose;
bool strictType;
bool noCase;
ObjectOps.ProcessGetTypeOptions(
options, out verbose, out strictType, out noCase);
Type returnType;
ObjectFlags objectFlags;
string objectName;
string interpName;
bool create;
bool dispose;
bool alias;
bool aliasRaw;
bool aliasAll;
bool aliasReference;
bool toString;
ObjectOps.ProcessFixupReturnValueOptions(
options, null, out returnType, out objectFlags,
out objectName, out interpName, out create,
out dispose, out alias, out aliasRaw, out aliasAll,
out aliasReference, out toString);
if (noCase)
{
objectFlags |= ObjectFlags.NoCase;
}
Variant value = null;
Encoding encoding = null;
if (options.IsPresent("-encoding", ref value))
{
encoding = (Encoding)value.Value;
}
if (code == ReturnCode.Ok)
{
Type objectType = null;
ResultList errors = null;
code = Value.GetType(interpreter,
arguments[argumentIndex], null, interpreter.GetAppDomain(),
Value.GetTypeValueFlags(strictType, verbose, noCase),
interpreter.CultureInfo, ref objectType, ref errors);
if (code == ReturnCode.Ok)
{
byte[] bytes = null;
code = StringOps.GetBytes(
encoding, arguments[argumentIndex + 1],
EncodingType.Default, ref bytes, ref result);
if (code == ReturnCode.Ok)
{
object @object = null;
code = XmlOps.Deserialize(
objectType, bytes, ref @object, ref result);
if (code == ReturnCode.Ok)
{
ObjectOptionType objectOptionType =
ObjectOptionType.Deserialize |
ObjectOps.GetOptionType(aliasRaw, aliasAll);
code = MarshalOps.FixupReturnValue(
interpreter, interpreter.Binder, interpreter.CultureInfo,
returnType, objectFlags, ObjectOps.GetInvokeOptions(
objectOptionType), objectOptionType, objectName, interpName,
@object, create, dispose, alias, aliasReference, toString,
ref result);
}
}
}
else
{
errors.Insert(0, String.Format(
"type \"{0}\" not found",
arguments[argumentIndex]));
result = errors;
}
}
}
else
{
if ((argumentIndex != Index.Invalid) &&
Option.LooksLikeOption(arguments[argumentIndex]))
{
result = OptionDictionary.BadOption(options, arguments[argumentIndex]);
}
else
{
result = "wrong # args: should be \"xml deserialize ?options? type xml\"";
}
code = ReturnCode.Error;
}
}
#else
result = "not implemented";
code = ReturnCode.Error;
#endif
}
else
{
result = "wrong # args: should be \"xml deserialize ?options? type xml\"";
code = ReturnCode.Error;
}
break;
}
case "serialize":
{
if (arguments.Count >= 4)
{
#if SERIALIZATION
OptionDictionary options = ObjectOps.GetSerializeOptions();
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) && ((argumentIndex + 2) == arguments.Count))
{
bool noCase = false;
if (options.IsPresent("-nocase"))
{
noCase = true;
}
bool strictType = false;
if (options.IsPresent("-stricttype"))
{
strictType = true;
}
bool verbose = false;
if (options.IsPresent("-verbose"))
{
verbose = true;
}
Variant value = null;
Encoding encoding = null;
if (options.IsPresent("-encoding", ref value))
{
encoding = (Encoding)value.Value;
}
if (code == ReturnCode.Ok)
{
Type objectType = null;
ResultList errors = null;
code = Value.GetType(interpreter,
arguments[argumentIndex], null, interpreter.GetAppDomain(),
Value.GetTypeValueFlags(strictType, verbose, noCase),
interpreter.CultureInfo, ref objectType, ref errors);
if (code == ReturnCode.Ok)
{
IObject @object = null;
code = interpreter.GetObject(
arguments[argumentIndex + 1], LookupFlags.Default,
ref @object, ref result);
if (code == ReturnCode.Ok)
{
byte[] bytes = null;
code = XmlOps.Serialize(
(@object != null) ? @object.Value : null,
objectType, null, ref bytes, ref result);
if (code == ReturnCode.Ok)
{
string stringValue = null;
code = StringOps.GetString(
encoding, bytes, EncodingType.Default,
ref stringValue, ref result);
if (code == ReturnCode.Ok)
{
result = stringValue;
}
}
}
}
else
{
errors.Insert(0, String.Format(
"type \"{0}\" not found",
arguments[argumentIndex]));
result = errors;
}
}
}
else
{
if ((argumentIndex != Index.Invalid) &&
Option.LooksLikeOption(arguments[argumentIndex]))
{
result = OptionDictionary.BadOption(options, arguments[argumentIndex]);
}
else
{
result = "wrong # args: should be \"xml serialize ?options? type object\"";
}
code = ReturnCode.Error;
}
}
#else
result = "not implemented";
code = ReturnCode.Error;
#endif
}
else
{
result = "wrong # args: should be \"xml serialize ?options? type object\"";
code = ReturnCode.Error;
}
break;
}
case "validate":
{
if (arguments.Count == 4)
{
XmlDocument document = null;
code = XmlOps.LoadString(
arguments[3], ref document, ref result);
if (code == ReturnCode.Ok)
{
code = XmlOps.Validate(
arguments[2], document, ref result);
if (code == ReturnCode.Ok)
{
result = String.Empty;
}
}
}
else
{
result = "wrong # args: should be \"xml validate schemaXml documentXml\"";
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 \"xml option ?arg ...?\"";
code = ReturnCode.Error;
}
}
else
{
result = "invalid argument list";
code = ReturnCode.Error;
}
}
else
{
result = "invalid interpreter";
code = ReturnCode.Error;
}
return(code);
}
public static object loads(string @string)
{
return(MarshalOps.GetObject(StringEnumerator(@string)));
}
///////////////////////////////////////////////////////////////////////
private static void GetDataReaderFieldValues(
IDataReader reader,
DateTimeBehavior dateTimeBehavior,
DateTimeKind dateTimeKind,
string dateTimeFormat,
string nullValue,
bool clear,
bool allowNull,
bool pairs,
bool names,
ref StringList list
)
{
if (reader == null)
{
return;
}
int fieldCount = reader.FieldCount;
if (clear || (list == null))
{
list = new StringList();
}
for (int index = 0; index < fieldCount; index++)
{
object value = reader.GetValue(index);
if (allowNull ||
((value != null) && (value != DBNull.Value)))
{
if (pairs)
{
StringList element = new StringList();
if (names)
{
element.Add(reader.GetName(index));
}
element.Add(MarshalOps.FixupDataValue(
value, dateTimeBehavior, dateTimeKind,
dateTimeFormat, nullValue));
list.Add(element.ToString());
}
else
{
if (names)
{
list.Add(reader.GetName(index));
}
list.Add(MarshalOps.FixupDataValue(
value, dateTimeBehavior, dateTimeKind,
dateTimeFormat, nullValue));
}
}
}
}
public static object loads([BytesConversion] IList <byte> bytes)
{
return(MarshalOps.GetObject(bytes.GetEnumerator()));
}
public static Bytes dumps(object value, int version = PythonMarshal.version)
{
return(Bytes.Make(MarshalOps.GetBytes(value, version)));
}
///////////////////////////////////////////////////////////////////////////////////////////////
#region IEnumerable Members
public IEnumerator GetEnumerator()
{
//
// NOTE: Make sure that the variable they supplied is valid before we try to
// use it as the basis of our enumerator.
//
if (interpreter != null)
{
//
// HACK: Handle the global "env" array specially. We must do this because
// our global "env" array has no backing storage (unlike Tcl's) and
// we do not have a trace operation for "get names" or "get names
// and values".
//
if (interpreter.IsEnvironmentVariable(variable))
{
IDictionary environment =
Environment.GetEnvironmentVariables();
if (environment != null)
{
return(environment.Keys.GetEnumerator());
}
else
{
DebugOps.Complain(interpreter, ReturnCode.Error,
"environment variables unavailable");
}
}
else if (interpreter.IsTestsVariable(variable))
{
Result error = null;
StringDictionary tests = interpreter.GetAllTestInformation(
false, ref error);
if (tests != null)
{
return((IEnumerator)tests.Keys.GetEnumerator());
}
else
{
DebugOps.Complain(interpreter, ReturnCode.Error, error);
}
}
else if (interpreter.IsSystemArrayVariable(variable))
{
ReturnCode code;
StringList keys = null;
Result error = null;
code = MarshalOps.GetArrayElementKeys(
interpreter, EntityOps.GetSystemArray(variable),
StringOps.DefaultMatchMode, null, false, ref keys,
ref error);
if (code == ReturnCode.Ok)
{
return(keys.GetEnumerator());
}
else
{
DebugOps.Complain(interpreter, code, error);
}
}
else
{
#if DATA
DatabaseVariable databaseVariable = null;
if (interpreter.IsDatabaseVariable(variable, ref databaseVariable))
{
Result error = null;
ObjectDictionary database = databaseVariable.GetList(
interpreter, true, false, ref error);
if (database != null)
{
return((IEnumerator)database.Keys.GetEnumerator());
}
else
{
DebugOps.Complain(interpreter, ReturnCode.Error, error);
}
}
else
#endif
{
if (variable != null)
{
ElementDictionary arrayValue = variable.ArrayValue;
if ((arrayValue != null) && (arrayValue.Keys != null))
{
return(arrayValue.Keys.GetEnumerator());
}
}
}
}
}
//
// NOTE: While the MSDN documentation does not seem to prohibit returning
// null here, there may be components and/or applications that would
// consider it "bad form"; therefore, we simply return an enumerator
// that does nothing.
//
return(new NullEnumerator <object>());
}