public object __getattribute__(CodeContext /*!*/ context, string name) { PythonTypeSlot slot; object res; if (GetType() != typeof(PythonModule) && DynamicHelpers.GetPythonType(this).TryResolveMixedSlot(context, name, out slot) && slot.TryGetValue(context, this, DynamicHelpers.GetPythonType(this), out res)) { return(res); } switch (name) { // never look in the dict for these... case "__dict__": return(__dict__); case "__class__": return(DynamicHelpers.GetPythonType(this)); } if (_dict.TryGetValue(name, out res)) { return(res); } // fall back to object to provide all of our other attributes (e.g. __setattr__, etc...) return(ObjectOps.__getattribute__(context, this, name)); }
public PythonTuple __reduce__(CodeContext context) { return(PythonTuple.MakeTuple( DynamicHelpers.GetPythonType(this), PythonTuple.MakeTuple(_items.GetItems()), GetType() == typeof(SetCollection) ? null : ObjectOps.ReduceProtocol0(context, this)[2] )); }
public string __repr__(CodeContext context) { if (_comInterfaceIndex != -1) { return(string.Format("<COM method offset {0}: {1} at {2}>", _comInterfaceIndex, DynamicHelpers.GetPythonType(this).Name, _id)); } return(ObjectOps.__repr__(this)); }
public string __repr__(CodeContext context) { if (DynamicHelpers.GetPythonType(this).BaseTypes[0] == _SimpleCData) { // direct subtypes have a custom repr return(String.Format("{0}({1})", DynamicHelpers.GetPythonType(this).Name, GetDataRepr(context))); } return(ObjectOps.__repr__(this)); }
public PythonTuple __reduce__(CodeContext /*!*/ context) { return(PythonTuple.MakeTuple( DynamicHelpers.GetPythonType(this), PythonTuple.MakeTuple( PythonOps.MakeString(this), "latin-1" ), GetType() == typeof(Bytes) ? null : ObjectOps.ReduceProtocol0(context, this)[2] )); }
/////////////////////////////////////////////////////////////////////// #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); }
/////////////////////////////////////////////////////////////////////// #region IExecute Members public override ReturnCode Execute( Interpreter interpreter, IClientData clientData, ArgumentList arguments, ref Result result ) { bool raw = this.Raw; Delegate @delegate = this.Delegate; if (raw) { return(Engine.ExecuteDelegate( @delegate, arguments, ref result)); } else { return(ObjectOps.InvokeDelegate( interpreter, @delegate, arguments, ref result)); } }
public static int getsizeof(object o) { return(ObjectOps.__sizeof__(o)); }
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 ReturnCode UploadDataAsync( Interpreter interpreter, IClientData clientData, StringList arguments, CallbackFlags callbackFlags, Uri uri, string method, byte[] rawData, ref Result error ) { TraceOps.DebugTrace(String.Format( "UploadDataAsync: interpreter = {0}, clientData = {1}, " + "arguments = {2}, callbackFlags = {3}, uri = {4}, " + "method = {5}, rawData = {6}", FormatOps.InterpreterNoThrow(interpreter), FormatOps.WrapOrNull(clientData), FormatOps.WrapOrNull(true, true, arguments), FormatOps.WrapOrNull(callbackFlags), FormatOps.WrapOrNull(uri), FormatOps.WrapOrNull(method), FormatOps.WrapOrNull(rawData)), typeof(WebOps).Name, TracePriority.NetworkDebug); ReturnCode code = ReturnCode.Ok; WebClient webClient = null; try { ICallback callback = CommandCallback.Create( MarshalFlags.Default, callbackFlags, ObjectFlags.Callback, ByRefArgumentFlags.None, interpreter, null, null, arguments, ref error); if (callback != null) { try { Result localError = null; webClient = CreateClient( interpreter, "UploadDataAsync", clientData, ref localError); if (webClient != null) { callback.ClientData = new ClientData( new AnyTriplet <WebClient, Uri, IAnyPair <string, byte[]> >( webClient, uri, new AnyPair <string, byte[]>(method, rawData))); webClient.UploadDataCompleted += new UploadDataCompletedEventHandler( UploadDataAsyncCompleted); /* NO RESULT */ webClient.UploadDataAsync( uri, method, rawData, callback); } else if (localError != null) { error = localError; code = ReturnCode.Error; } else { error = "could not create web client"; code = ReturnCode.Error; } } catch (Exception e) { error = e; code = ReturnCode.Error; } } else { code = ReturnCode.Error; } } finally { if ((code != ReturnCode.Ok) && (webClient != null)) { ReturnCode disposeCode; Result disposeError = null; disposeCode = ObjectOps.TryDispose( webClient, ref disposeError); if (disposeCode != ReturnCode.Ok) { DebugOps.Complain( interpreter, disposeCode, disposeError); } } } return(code); }