You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7660 lines
396 KiB
7660 lines
396 KiB
<?xml version="1.0"?>
|
|
<doc>
|
|
<assembly>
|
|
<name>IronPython</name>
|
|
</assembly>
|
|
<members>
|
|
<member name="M:IronPython.Compiler.Ast.ClassDefinition.GetParentClosureTuple">
|
|
<summary>
|
|
Gets the closure tuple from our parent context.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.ComprehensionScope">
|
|
<summary>
|
|
Scope for the comprehension. Because scopes are usually statements and comprehensions are expressions
|
|
this doesn't actually show up in the AST hierarchy and instead hangs off the comprehension expression.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.FunctionDefinition.GetParentClosureTuple">
|
|
<summary>
|
|
Pulls the closure tuple from our function/generator which is flowed into each function call.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.FunctionDefinition.MakeFunctionExpression">
|
|
<summary>
|
|
Returns an expression which creates the function object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.FunctionDefinition.EnsureFunctionLambda">
|
|
<summary>
|
|
Creates the LambdaExpression which is the actual function body.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.FunctionDefinition.CreateFunctionLambda">
|
|
<summary>
|
|
Creates the LambdaExpression which implements the body of the function.
|
|
|
|
The functions signature is either "object Function(PythonFunction, ...)"
|
|
where there is one object parameter for each user defined parameter or
|
|
object Function(PythonFunction, object[]) for functions which take more
|
|
than PythonCallTargets.MaxArgs arguments.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.FunctionDefinition.GetDelegateType(IronPython.Compiler.Ast.Parameter[],System.Boolean,System.Delegate@)">
|
|
<summary>
|
|
Determines delegate type for the Python function
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.FunctionDefinition.ArbitraryGlobalsVisitor">
|
|
<summary>
|
|
Rewrites the tree for performing lookups against globals instead of being bound
|
|
against the optimized scope. This is used if the user creates a function using public
|
|
PythonFunction ctor.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.Node.CanThrow">
|
|
<summary>
|
|
Returns true if the node can throw, false otherwise. Used to determine
|
|
whether or not we need to update the current dynamic stack info.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.Node.AddFrame(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Creates a method frame for tracking purposes and enforces recursion
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.Node.RemoveFrame(System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Removes the frames from generated code for when we're compiling the tracing delegate
|
|
which will track the frames it's self.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.Node.LineNumberUpdated">
|
|
<summary>
|
|
A temporary variable to track if the current line number has been emitted via the fault update block.
|
|
|
|
For example consider:
|
|
|
|
try:
|
|
raise Exception()
|
|
except Exception, e:
|
|
# do something here
|
|
raise
|
|
|
|
At "do something here" we need to have already emitted the line number, when we re-raise we shouldn't add it
|
|
again. If we handled the exception then we should have set the bool back to false.
|
|
|
|
We also sometimes directly check _lineNoUpdated to avoid creating this unless we have nested exceptions.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.Node.LineNumberExpression">
|
|
<summary>
|
|
A temporary variable to track the current line number
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.Parameter">
|
|
<summary>
|
|
Parameter base class
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.Ast.Parameter._name">
|
|
<summary>
|
|
Position of the parameter: 0-based index
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.Parameter.Name">
|
|
<summary>
|
|
Parameter name
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.PythonAst">
|
|
<summary>
|
|
Top-level ast for all Python code. Typically represents a module but could also
|
|
be exec or eval code.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.PythonAst.#ctor(System.Boolean,IronPython.Runtime.ModuleOptions,System.Boolean,Microsoft.Scripting.Runtime.CompilerContext)">
|
|
<summary>
|
|
Creates a new PythonAst without a body. ParsingFinished should be called afterwards to set
|
|
the body.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.PythonAst.ParsingFinished(System.Int32[],IronPython.Compiler.Ast.Statement,IronPython.Runtime.ModuleOptions)">
|
|
<summary>
|
|
Called when parsing is complete, the body is built, the line mapping and language features are known.
|
|
|
|
This is used in conjunction with the constructor which does not take a body. It enables creating
|
|
the outer most PythonAst first so that nodes can always have a global parent. This lets an un-bound
|
|
tree to still provide it's line information immediately after parsing. When we set the location
|
|
of each node during construction we also set the global parent. When we name bind the global
|
|
parent gets replaced with the real parent ScopeStatement.
|
|
</summary>
|
|
<param name="lineLocations">a mapping of where each line begins</param>
|
|
<param name="body">The body of code</param>
|
|
<param name="languageFeatures">The language features which were set during parsing.</param>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.PythonAst.Bind">
|
|
<summary>
|
|
Binds an AST and makes it capable of being reduced and compiled. Before calling Bind an AST cannot successfully
|
|
be reduced.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.PythonAst.EnsureGlobalVariable(System.String)">
|
|
<summary>
|
|
Creates a variable at the global level. Called for known globals (e.g. __name__),
|
|
for variables explicitly declared global by the user, and names accessed
|
|
but not defined in the lexical scope.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.PythonAst.Reduce">
|
|
<summary>
|
|
Reduces the PythonAst to a LambdaExpression of type Type.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.PythonAst.TrueDivision">
|
|
<summary>
|
|
True division is enabled in this AST.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.PythonAst.AllowWithStatement">
|
|
<summary>
|
|
True if the with statement is enabled in this AST.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.PythonAst.AbsoluteImports">
|
|
<summary>
|
|
True if absolute imports are enabled
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.PythonAst.ToScriptCode">
|
|
<summary>
|
|
Returns a ScriptCode object for this PythonAst. The ScriptCode object
|
|
can then be used to execute the code against it's closed over scope or
|
|
to execute it against a different scope.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.PythonAst.MakeLookupCode">
|
|
<summary>
|
|
Rewrites the tree for performing lookups against globals instead of being bound
|
|
against the optimized scope. This is used if the user compiles optimied code and then
|
|
runs it against a different scope.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.PythonAst.OnDiskProxy">
|
|
<summary>
|
|
True if this is on-disk code which we don't really have an AST for.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.PythonReference">
|
|
<summary>
|
|
Represents a reference to a name. A PythonReference is created for each name
|
|
referred to in a scope (global, class, or function).
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.PythonVariable.ReadBeforeInitialized">
|
|
<summary>
|
|
True iff there is a path in control flow graph on which the variable is used before initialized (assigned or deleted).
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.PythonVariable.AccessedInNestedScope">
|
|
<summary>
|
|
True iff the variable is referred to from the inner scope.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.PythonWalker">
|
|
<summary>
|
|
PythonWalker class - The Python AST Walker (default result is true)
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.PythonWalkerNonRecursive">
|
|
<summary>
|
|
PythonWalkerNonRecursive class - The Python AST Walker (default result is false)
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.ScopeStatement.LocalParentTuple">
|
|
<summary>
|
|
The variable used to hold out parents closure tuple in our local scope.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.ScopeStatement.LocalContext">
|
|
<summary>
|
|
Gets the expression associated with the local CodeContext. If the function
|
|
doesn't have a local CodeContext then this is the global context.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.ScopeStatement.IsClosure">
|
|
<summary>
|
|
True if this scope accesses a variable from an outer scope.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.ScopeStatement.ContainsNestedFreeVariables">
|
|
<summary>
|
|
True if an inner scope is accessing a variable defined in this scope.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.ScopeStatement.NeedsLocalsDictionary">
|
|
<summary>
|
|
True if we are forcing the creation of a dictionary for storing locals.
|
|
|
|
This occurs for calls to locals(), dir(), vars(), unqualified exec, and
|
|
from ... import *.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.ScopeStatement.HasLateBoundVariableSets">
|
|
<summary>
|
|
True if variables can be set in a late bound fashion that we don't
|
|
know about at code gen time - for example via from foo import *.
|
|
|
|
This is tracked independently of the ContainsUnqualifiedExec/NeedsLocalsDictionary
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.ScopeStatement.GetOrMakeFunctionCode">
|
|
<summary>
|
|
Gets or creates the FunctionCode object for this FunctionDefinition.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.ScopeStatement.FreeVariables">
|
|
<summary>
|
|
Variables that are bound in an outer scope - but not a global scope
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.ScopeStatement.GlobalVariables">
|
|
<summary>
|
|
Variables that are bound to the global scope
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.ScopeStatement.CellVariables">
|
|
<summary>
|
|
Variables that are referred to from a nested scope and need to be
|
|
promoted to cells.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.ScopeStatement.GetUpdateTrackbackExpression(System.Linq.Expressions.ParameterExpression)">
|
|
<summary>
|
|
Gets the expression for updating the dynamic stack trace at runtime when an
|
|
exception is thrown.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.ScopeStatement.GetSaveLineNumberExpression(System.Linq.Expressions.ParameterExpression,System.Boolean)">
|
|
<summary>
|
|
Gets the expression for the actual updating of the line number for stack traces to be available
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.ScopeStatement.WrapScopeStatements(System.Linq.Expressions.Expression,System.Boolean)">
|
|
<summary>
|
|
Wraps the body of a statement which should result in a frame being available during
|
|
exception handling. This ensures the line number is updated as the stack is unwound.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.ScopeStatement.DelayedFunctionCode">
|
|
<summary>
|
|
Provides a place holder for the expression which represents
|
|
a FunctionCode. For functions/classes this gets updated after
|
|
the AST has been generated because the FunctionCode needs to
|
|
know about the tree which gets generated. For modules we
|
|
immediately have the value because it always comes in as a parameter.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.ScopeStatement.DelayedProfiling">
|
|
<summary>
|
|
Reducible node so that re-writing for profiling does not occur until
|
|
after the script code has been completed and is ready to be compiled.
|
|
|
|
Without this extra node profiling would force reduction of the node
|
|
and we wouldn't have setup our constant access correctly yet.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.SerializedScopeStatement">
|
|
<summary>
|
|
Fake ScopeStatement for FunctionCode's to hold on to after we have deserialized pre-compiled code.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Ast.SliceExpression.StepProvided">
|
|
<summary>
|
|
True if the user provided a step parameter (either providing an explicit parameter
|
|
or providing an empty step parameter) false if only start and stop were provided.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.Ast.TryStatement._body">
|
|
<summary>
|
|
The statements under the try-block.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.Ast.TryStatement._handlers">
|
|
<summary>
|
|
Array of except (catch) blocks associated with this try. NULL if there are no except blocks.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.Ast.TryStatement._else">
|
|
<summary>
|
|
The body of the optional Else block for this try. NULL if there is no Else block.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.Ast.TryStatement._finally">
|
|
<summary>
|
|
The body of the optional finally associated with this try. NULL if there is no finally block.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.TryStatement.TransformHandlers(System.Linq.Expressions.ParameterExpression)">
|
|
<summary>
|
|
Transform multiple python except handlers for a try block into a single catch body.
|
|
</summary>
|
|
<param name="exception">The variable for the exception in the catch block.</param>
|
|
<returns>Null if there are no except handlers. Else the statement to go inside the catch handler</returns>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.TryStatement.GetTracebackHeader(IronPython.Compiler.Ast.Statement,System.Linq.Expressions.ParameterExpression,System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Surrounds the body of an except block w/ the appropriate code for maintaining the traceback.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.Ast.VariableKind.Local">
|
|
<summary>
|
|
Local variable.
|
|
|
|
Local variables can be referenced from nested lambdas
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.Ast.VariableKind.Parameter">
|
|
<summary>
|
|
Parameter to a LambdaExpression
|
|
|
|
Like locals, they can be referenced from nested lambdas
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.Ast.VariableKind.Global">
|
|
<summary>
|
|
Global variable
|
|
|
|
Should only appear in global (top level) lambda.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.WithStatement.Reduce">
|
|
<summary>
|
|
WithStatement is translated to the DLR AST equivalent to
|
|
the following Python code snippet (from with statement spec):
|
|
|
|
mgr = (EXPR)
|
|
exit = mgr.__exit__ # Not calling it yet
|
|
value = mgr.__enter__()
|
|
exc = True
|
|
try:
|
|
VAR = value # Only if "as VAR" is present
|
|
BLOCK
|
|
except:
|
|
# The exceptional case is handled here
|
|
exc = False
|
|
if not exit(*sys.exc_info()):
|
|
raise
|
|
# The exception is swallowed if exit() returns true
|
|
finally:
|
|
# The normal and non-local-goto cases are handled here
|
|
if exc:
|
|
exit(None, None, None)
|
|
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.CollectableCompilationMode">
|
|
<summary>
|
|
A global allocator that puts all of the globals into an array access. The array is an
|
|
array of PythonGlobal objects. We then just close over the array for any inner functions.
|
|
|
|
Once compiled a RuntimeScriptCode is produced which is closed over the entire execution
|
|
environment.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.LookupCompilationMode">
|
|
<summary>
|
|
Provides globals for when we need to lookup into a dictionary for each global access.
|
|
|
|
This is the slowest form of globals and is only used when we need to run against an
|
|
arbitrary dictionary given to us by a user.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Ast.UncollectableCompilationMode">
|
|
<summary>
|
|
Implements globals which are backed by a static type, followed by an array if the static types' slots become full. The global
|
|
variables are stored in static fields on a type for fast access. The type also includes fields for constants and call sites
|
|
so they can be accessed much fasetr.
|
|
|
|
We don't generate any code into the type though - DynamicMethod's are much faster for code gen then normal ref emit.
|
|
</summary>
|
|
<summary>
|
|
Implements globals which are backed by a static type, followed by an array if the static types' slots become full. The global
|
|
variables are stored in static fields on a type for fast access. The type also includes fields for constants and call sites
|
|
so they can be accessed much fasetr.
|
|
|
|
We don't generate any code into the type though - DynamicMethod's are much faster for code gen then normal ref emit.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.StorageData.ContextStorageType(System.Int32)">
|
|
<summary>Ensures the underlying array is long enough to accomodate the given index</summary>
|
|
<returns>The context storage type corresponding to the given index</returns>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.StorageData.ConstantStorageType(System.Int32)">
|
|
<summary>Ensures the underlying array is long enough to accomodate the given index</summary>
|
|
<returns>The constant storage type corresponding to the given index</returns>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.StorageData.GlobalStorageType(System.Int32)">
|
|
<summary>Ensures the underlying array is long enough to accomodate the given index</summary>
|
|
<returns>The global storage type corresponding to the given index</returns>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Ast.SiteStorage`1.SiteStorageType(System.Int32)">
|
|
<summary>Ensures the underlying array is long enough to accomodate the given index</summary>
|
|
<returns>The site storage type corresponding to the given index</returns>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.ClosureExpression">
|
|
<summary>
|
|
Small reducable node which just fetches the value from a ClosureCell
|
|
object. Like w/ global variables the compiler recognizes these on
|
|
sets and turns them into assignments on the python global object.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.ClosureExpression.ClosureCell">
|
|
<summary>
|
|
Gets the expression which points at the closure cell.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.ClosureExpression.OriginalParameter">
|
|
<summary>
|
|
The original expression for the incoming parameter if this is a parameter closure. Otherwise
|
|
the value is null.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.ClosureExpression.PythonVariable">
|
|
<summary>
|
|
Gets the PythonVariable for which this closure expression was created.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.ClosureExpression.Create">
|
|
<summary>
|
|
Creates the storage for the closure cell. If this is a closure over a parameter it
|
|
captures the initial incoming parameter value.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.ClosureExpression.Reduce">
|
|
<summary>
|
|
Reduces the closure cell to a read of the value stored in the cell.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.ClosureExpression.Assign(System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Assigns a value to the closure cell.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.ClosureExpression.Delete">
|
|
<summary>
|
|
Removes the current value from the closure cell.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.ReferenceClosureInfo">
|
|
<summary>
|
|
Tracking for variables lifted into closure objects. Used to store information in a function
|
|
about the outer variables it accesses.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.CompilationMode">
|
|
<summary>
|
|
Specifies the compilation mode which will be used during the AST transformation
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.CompilationMode.ToDisk">
|
|
<summary>
|
|
Compilation will proceed in a manner in which the resulting AST can be serialized to disk.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.CompilationMode.Uncollectable">
|
|
<summary>
|
|
Compilation will use a type and declare static fields for globals. The resulting type
|
|
is uncollectible and therefore extended use of this will cause memory leaks.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.CompilationMode.Collectable">
|
|
<summary>
|
|
Compilation will use an array for globals. The resulting code will be fully collectible
|
|
and once all references are released will be collected.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.CompilationMode.Lookup">
|
|
<summary>
|
|
Compilation will force all global accesses to do a full lookup. This will also happen for
|
|
any unbound local references. This is the slowest form of code generation and is only
|
|
used for exec/eval code where we can run against an arbitrary dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.GeneratorRewriter">
|
|
<summary>
|
|
When finding a yield return or yield break, this rewriter flattens out
|
|
containing blocks, scopes, and expressions with stack state. All
|
|
scopes encountered have their variables promoted to the generator's
|
|
closure, so they survive yields.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.GeneratorRewriter.ToTemp(System.Linq.Expressions.Expression@)">
|
|
<summary>
|
|
Spills the right side into a temp, and replaces it with its temp.
|
|
Returns the expression that initializes the temp.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.GeneratorRewriter.MakeAssign(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Makes an assignment to this variable. Pushes the assignment as far
|
|
into the right side as possible, to allow jumps into it.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.DelayedTupleExpression">
|
|
<summary>
|
|
Accesses the property of a tuple. The node can be created first and then the tuple and index
|
|
type can be filled in before the tree is actually generated. This enables creation of these
|
|
nodes before the tuple type is actually known.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.LazyCode`1">
|
|
<summary>
|
|
Represents code which can be lazily compiled.
|
|
|
|
The code is created in an AST which provides the Expression of T and
|
|
whether or not the code should be interpreted. For non-pre compiled
|
|
scenarios the code will not be compiled until the 1st time it is run.
|
|
|
|
For pre-compiled scenarios the code is IExpressionSerializable and will
|
|
turn into a normal pre-compiled method.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.OnDiskScriptCode">
|
|
<summary>
|
|
A ScriptCode which has been loaded from an assembly which is saved on disk.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.OnDiskScriptCode.MakeAstFromSourceUnit(Microsoft.Scripting.SourceUnit)">
|
|
<summary>
|
|
Creates a fake PythonAst object which is represenative of the on-disk script code.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Compiler.Parser._languageFeatures">
|
|
<summary>
|
|
Language features initialized on parser construction and possibly updated during parsing.
|
|
The code can set the language features (e.g. "from __future__ import division").
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Parser.ParseInteractiveCode(Microsoft.Scripting.ScriptCodeParseResult@)">
|
|
<summary>
|
|
Parse one or more lines of interactive input
|
|
</summary>
|
|
<returns>null if input is not yet valid but could be with more lines</returns>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Parser.GetNextAutoIndentSize(System.String,System.Int32)">
|
|
<summary>
|
|
Given the interactive text input for a compound statement, calculate what the
|
|
indentation level of the next line should be
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Parser.ParseYieldExpression">
|
|
<summary>
|
|
Peek if the next token is a 'yield' and parse a yield expression. Else return null.
|
|
|
|
Called w/ yield already eaten.
|
|
</summary>
|
|
<returns>A yield expression if present, else null. </returns>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Parser.MaybeEatNewLine">
|
|
<summary>
|
|
Maybe eats a new line token returning true if the token was
|
|
eaten.
|
|
|
|
Python always tokenizes to have only 1 new line character in a
|
|
row. But we also craete NLToken's and ignore them except for
|
|
error reporting purposes. This gives us the same errors as
|
|
CPython and also matches the behavior of the standard library
|
|
tokenize module. This function eats any present NL tokens and throws
|
|
them away.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Parser.EatNewLine">
|
|
<summary>
|
|
Eats a new line token throwing if the next token isn't a new line.
|
|
|
|
Python always tokenizes to have only 1 new line character in a
|
|
row. But we also craete NLToken's and ignore them except for
|
|
error reporting purposes. This gives us the same errors as
|
|
CPython and also matches the behavior of the standard library
|
|
tokenize module. This function eats any present NL tokens and throws
|
|
them away.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.PythonCompilerOptions.#ctor">
|
|
<summary>
|
|
Creates a new PythonCompilerOptions with the default language features enabled.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.PythonCompilerOptions.#ctor(IronPython.Runtime.ModuleOptions)">
|
|
<summary>
|
|
Creates a new PythonCompilerOptions with the specified language features enabled.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.PythonCompilerOptions.#ctor(System.Boolean)">
|
|
<summary>
|
|
Creates a new PythonCompilerOptions and enables or disables true division.
|
|
|
|
This overload is obsolete, instead you should use the overload which takes a
|
|
ModuleOptions.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.PythonCompilerOptions.InitialIndent">
|
|
<summary>
|
|
Gets or sets the initial indentation. This can be set to allow parsing
|
|
partial blocks of code that are already indented.
|
|
|
|
For each element of the array there is an additional level of indentation.
|
|
Each integer value represents the number of spaces used for the indentation.
|
|
|
|
If this value is null then no indentation level is specified.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.PythonGlobal">
|
|
<summary>
|
|
Provides cached global variable for modules to enable optimized access to
|
|
module globals. Both the module global value and the cached value can be held
|
|
onto and the cached value can be invalidated by the providing LanguageContext.
|
|
|
|
The cached value is provided by the LanguageContext.GetModuleCache API.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.PythonGlobalVariableExpression">
|
|
<summary>
|
|
Small reducable node which just fetches the value from a PythonGlobal
|
|
object. The compiler recognizes these on sets and turns them into
|
|
assignments on the python global object.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.PythonSavableScriptCode">
|
|
<summary>
|
|
A ScriptCode which can be saved to disk. We only create this when called via
|
|
the clr.CompileModules API. This ScriptCode does not support running.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.PythonScriptCode">
|
|
<summary>
|
|
Represents a script code which can be dynamically bound to execute against
|
|
arbitrary Scope objects. This is used for code when the user runs against
|
|
a particular scope as well as for exec and eval code as well. It is also
|
|
used when tracing is enabled.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.ReducableDynamicExpression">
|
|
<summary>
|
|
Provides a wrapper around "dynamic" expressions which we've opened coded (for optimized code generation).
|
|
|
|
This lets us recognize both normal Dynamic and our own Dynamic expressions and apply the combo binder on them.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.RuntimeScriptCode">
|
|
<summary>
|
|
Represents a script code which can be consumed at runtime as-is. This code has
|
|
no external dependencies and is closed over its scope.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Token">
|
|
<summary>
|
|
Summary description for Token.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Tokenizer">
|
|
<summary>
|
|
IronPython tokenizer
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Tokenizer.#ctor(Microsoft.Scripting.ErrorSink,IronPython.Compiler.PythonCompilerOptions,System.Boolean)">
|
|
<summary>
|
|
Used to create tokenizer for hosting API.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Compiler.Tokenizer.TokenEqualityComparer">
|
|
<summary>
|
|
Equality comparer that can compare strings to our current token w/o creating a new string first.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Compiler.Tokenizer.EndContinues">
|
|
<summary>
|
|
True if the last characters in the buffer are a backslash followed by a new line indicating
|
|
that their is an incompletement statement which needs further input to complete.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Tokenizer.ReadNewline">
|
|
<summary>
|
|
Returns whether the
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Compiler.Tokenizer.ResizeInternal(System.Char[]@,System.Int32,System.Int32,System.Int32)">
|
|
<summary>
|
|
Resizes an array to a speficied new size and copies a portion of the original array into its beginning.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Hosting.Python">
|
|
<summary>
|
|
Provides helpers for interacting with IronPython.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateRuntime">
|
|
<summary>
|
|
Creates a new ScriptRuntime with the IronPython scipting engine pre-configured.
|
|
</summary>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateRuntime(System.Collections.Generic.IDictionary{System.String,System.Object})">
|
|
<summary>
|
|
Creates a new ScriptRuntime with the IronPython scipting engine pre-configured and
|
|
additional options.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateRuntime(System.AppDomain)">
|
|
<summary>
|
|
Creates a new ScriptRuntime with the IronPython scripting engine pre-configured
|
|
in the specified AppDomain. The remote ScriptRuntime may be manipulated from
|
|
the local domain but all code will run in the remote domain.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateRuntime(System.AppDomain,System.Collections.Generic.IDictionary{System.String,System.Object})">
|
|
<summary>
|
|
Creates a new ScriptRuntime with the IronPython scripting engine pre-configured
|
|
in the specified AppDomain with additional options. The remote ScriptRuntime may
|
|
be manipulated from the local domain but all code will run in the remote domain.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateEngine">
|
|
<summary>
|
|
Creates a new ScriptRuntime and returns the ScriptEngine for IronPython. If
|
|
the ScriptRuntime is required it can be acquired from the Runtime property
|
|
on the engine.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateEngine(System.Collections.Generic.IDictionary{System.String,System.Object})">
|
|
<summary>
|
|
Creates a new ScriptRuntime with the specified options and returns the
|
|
ScriptEngine for IronPython. If the ScriptRuntime is required it can be
|
|
acquired from the Runtime property on the engine.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateEngine(System.AppDomain)">
|
|
<summary>
|
|
Creates a new ScriptRuntime and returns the ScriptEngine for IronPython. If
|
|
the ScriptRuntime is required it can be acquired from the Runtime property
|
|
on the engine.
|
|
|
|
The remote ScriptRuntime may be manipulated from the local domain but
|
|
all code will run in the remote domain.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateEngine(System.AppDomain,System.Collections.Generic.IDictionary{System.String,System.Object})">
|
|
<summary>
|
|
Creates a new ScriptRuntime with the specified options and returns the
|
|
ScriptEngine for IronPython. If the ScriptRuntime is required it can be
|
|
acquired from the Runtime property on the engine.
|
|
|
|
The remote ScriptRuntime may be manipulated from the local domain but
|
|
all code will run in the remote domain.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.GetEngine(Microsoft.Scripting.Hosting.ScriptRuntime)">
|
|
<summary>
|
|
Given a ScriptRuntime gets the ScriptEngine for IronPython.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.GetSysModule(Microsoft.Scripting.Hosting.ScriptRuntime)">
|
|
<summary>
|
|
Gets a ScriptScope which is the Python sys module for the provided ScriptRuntime.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.GetSysModule(Microsoft.Scripting.Hosting.ScriptEngine)">
|
|
<summary>
|
|
Gets a ScriptScope which is the Python sys module for the provided ScriptEngine.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.GetBuiltinModule(Microsoft.Scripting.Hosting.ScriptRuntime)">
|
|
<summary>
|
|
Gets a ScriptScope which is the Python __builtin__ module for the provided ScriptRuntime.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.GetBuiltinModule(Microsoft.Scripting.Hosting.ScriptEngine)">
|
|
<summary>
|
|
Gets a ScriptScope which is the Python __builtin__ module for the provided ScriptEngine.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.GetClrModule(Microsoft.Scripting.Hosting.ScriptRuntime)">
|
|
<summary>
|
|
Gets a ScriptScope which is the Python clr module for the provided ScriptRuntime.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.GetClrModule(Microsoft.Scripting.Hosting.ScriptEngine)">
|
|
<summary>
|
|
Gets a ScriptScope which is the Python clr module for the provided ScriptEngine.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.ImportModule(Microsoft.Scripting.Hosting.ScriptRuntime,System.String)">
|
|
<summary>
|
|
Imports the Python module by the given name and returns its ScriptSCope. If the
|
|
module does not exist an exception is raised.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.ImportModule(Microsoft.Scripting.Hosting.ScriptEngine,System.String)">
|
|
<summary>
|
|
Imports the Python module by the given name and returns its ScriptSCope. If the
|
|
module does not exist an exception is raised.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.ImportModule(Microsoft.Scripting.Hosting.ScriptScope,System.String)">
|
|
<summary>
|
|
Imports the Python module by the given name and inserts it into the ScriptScope as that name. If the
|
|
module does not exist an exception is raised.
|
|
</summary>
|
|
<param name="scope"></param>
|
|
<param name="moduleName"></param>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.SetHostVariables(Microsoft.Scripting.Hosting.ScriptRuntime,System.String,System.String,System.String)">
|
|
<summary>
|
|
Sets sys.exec_prefix, sys.executable and sys.version and adds the prefix to sys.path
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.SetHostVariables(Microsoft.Scripting.Hosting.ScriptEngine,System.String,System.String,System.String)">
|
|
<summary>
|
|
Sets sys.exec_prefix, sys.executable and sys.version and adds the prefix to sys.path
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.SetTrace(Microsoft.Scripting.Hosting.ScriptEngine,IronPython.Runtime.Exceptions.TracebackDelegate)">
|
|
<summary>
|
|
Enables call tracing for the current thread in this ScriptEngine.
|
|
|
|
TracebackDelegate will be called back for each function entry, exit, exception, and line change.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.SetTrace(Microsoft.Scripting.Hosting.ScriptRuntime,IronPython.Runtime.Exceptions.TracebackDelegate)">
|
|
<summary>
|
|
Enables call tracing for the current thread for the Python engine in this ScriptRuntime.
|
|
|
|
TracebackDelegate will be called back for each function entry, exit, exception, and line change.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CallTracing(Microsoft.Scripting.Hosting.ScriptRuntime,System.Object,System.Object[])">
|
|
<summary>
|
|
Provides nested level debugging support when SetTrace or SetProfile are used.
|
|
|
|
This saves the current tracing information and then calls the provided object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CallTracing(Microsoft.Scripting.Hosting.ScriptEngine,System.Object,System.Object[])">
|
|
<summary>
|
|
Provides nested level debugging support when SetTrace or SetProfile are used.
|
|
|
|
This saves the current tracing information and then calls the provided object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateRuntimeSetup(System.Collections.Generic.IDictionary{System.String,System.Object})">
|
|
<summary>
|
|
Creates a ScriptRuntimeSetup object which includes the Python script engine with the specified options.
|
|
|
|
The ScriptRuntimeSetup object can then be additional configured and used to create a ScriptRuntime.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateLanguageSetup(System.Collections.Generic.IDictionary{System.String,System.Object})">
|
|
<summary>
|
|
Creates a LanguageSetup object which includes the Python script engine with the specified options.
|
|
|
|
The LanguageSetup object can be used with other LanguageSetup objects from other languages to
|
|
configure a ScriptRuntimeSetup object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateModule(Microsoft.Scripting.Hosting.ScriptEngine,System.String)">
|
|
<summary>
|
|
Creates a new PythonModule with the specified name and published it in sys.modules.
|
|
|
|
Returns the ScriptScope associated with the module.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateModule(Microsoft.Scripting.Hosting.ScriptEngine,System.String,System.String)">
|
|
<summary>
|
|
Creates a new PythonModule with the specified name and filename published it
|
|
in sys.modules.
|
|
|
|
Returns the ScriptScope associated with the module.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.CreateModule(Microsoft.Scripting.Hosting.ScriptEngine,System.String,System.String,System.String)">
|
|
<summary>
|
|
Creates a new PythonModule with the specified name, filename, and doc string and
|
|
published it in sys.modules.
|
|
|
|
Returns the ScriptScope associated with the module.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.Python.GetModuleFilenames(Microsoft.Scripting.Hosting.ScriptEngine)">
|
|
<summary>
|
|
Gets the list of loaded Python module files names which are available in the provided ScriptEngine.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Hosting.PythonCommandLine">
|
|
<summary>
|
|
A simple Python command-line should mimic the standard python.exe
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.PythonCommandLine.GetLogoDisplay">
|
|
<summary>
|
|
Returns the display look for IronPython.
|
|
|
|
The returned string uses This \n instead of Environment.NewLine for it's line seperator
|
|
because it is intended to be outputted through the Python I/O system.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.PythonCommandLine.InitializeExtensionDLLs">
|
|
<summary>
|
|
Loads any extension DLLs present in sys.prefix\DLLs directory and adds references to them.
|
|
|
|
This provides an easy drop-in location for .NET assemblies which should be automatically referenced
|
|
(exposed via import), COM libraries, and pre-compiled Python code.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.PythonCommandLine.TryInteractiveActionWorker">
|
|
<summary>
|
|
Attempts to run a single interaction and handle any language-specific
|
|
exceptions. Base classes can override this and call the base implementation
|
|
surrounded with their own exception handling.
|
|
|
|
Returns null if successful and execution should continue, or an exit code.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.PythonCommandLine.RunOneInteraction">
|
|
<summary>
|
|
Parses a single interactive command and executes it.
|
|
|
|
Returns null if successful and execution should continue, or the appropiate exit code.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Hosting.PythonConsoleOptions.SkipFirstSourceLine">
|
|
<summary>
|
|
Skip the first line of the code to execute. This is useful for executing Unix scripts which
|
|
have the command to execute specified in the first line.
|
|
This only apply to the script code executed by the ScriptEngine APIs, but not for other script code
|
|
that happens to get called as a result of the execution.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.PythonOptionsParser.ParseArgument(System.String)">
|
|
<exception cref="T:System.Exception">On error.</exception>
|
|
</member>
|
|
<member name="T:IronPython.Hosting.PythonService">
|
|
<summary>
|
|
Helper class for implementing the Python class.
|
|
|
|
This is exposed as a service through PythonEngine and the helper class
|
|
uses this service to get the correct remoting semantics.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Hosting.PythonService.GetLocalCommandDispatcher">
|
|
<summary>
|
|
Returns an ObjectHandle to a delegate of type Action[Action] which calls the current
|
|
command dispatcher.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Hosting.ErrorCodes.IncompleteStatement">
|
|
<summary>
|
|
The error involved an incomplete statement due to an unexpected EOF.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Hosting.ErrorCodes.IncompleteToken">
|
|
<summary>
|
|
The error involved an incomplete token.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Hosting.ErrorCodes.ErrorMask">
|
|
<summary>
|
|
The mask for the actual error values
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Hosting.ErrorCodes.SyntaxError">
|
|
<summary>
|
|
The error was a general syntax error
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Hosting.ErrorCodes.IndentationError">
|
|
<summary>
|
|
The error was an indentation error.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Hosting.ErrorCodes.TabError">
|
|
<summary>
|
|
The error was a tab error.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Hosting.ErrorCodes.NoCaret">
|
|
<summary>
|
|
syntax error shouldn't include a caret (no column offset should be included)
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.MaybeNotImplementedAttribute">
|
|
<summary>
|
|
Marks that the return value of a function might include NotImplemented.
|
|
|
|
This is added to an operator method to ensure that all necessary methods are called
|
|
if one cannot guarantee that it can perform the comparison.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Modules.Builtin.filter(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.PythonTuple)">
|
|
<summary>
|
|
Specialized version because enumerating tuples by Python's definition
|
|
doesn't call __getitem__, but filter does!
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Modules.Builtin.open(IronPython.Runtime.CodeContext,System.String,System.String,System.Int32)">
|
|
<summary>
|
|
Opens a file and returns a new file object.
|
|
|
|
name -> the name of the file to open.
|
|
mode -> the mode to open the file (r for reading, w for writing, a for appending, default is r).
|
|
bufsize -> the size of the buffer to be used (<= 0 indicates to use the default size)
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Modules.Builtin.open(IronPython.Runtime.CodeContext,System.IO.Stream)">
|
|
<summary>
|
|
Creates a new Python file object from a .NET stream object.
|
|
|
|
stream -> the stream to wrap in a file object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Modules.Builtin.range(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
object overload of range - attempts to convert via __int__, and __trunc__ if arg is
|
|
an OldInstance
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Modules.Builtin.range(IronPython.Runtime.CodeContext,System.Object,System.Object,System.Object)">
|
|
<summary>
|
|
object overload of range - attempts to convert via __int__, and __trunc__ if arg is
|
|
an OldInstance
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Modules.Builtin.GetRuntimeGeneratedCodeCompilerOptions(IronPython.Runtime.CodeContext,System.Boolean,IronPython.Runtime.CompileFlags)">
|
|
<summary>
|
|
Gets the appropriate LanguageContext to be used for code compiled with Python's compile, eval, execfile, etc...
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Modules.Builtin.GetCompilerInheritance(System.Object)">
|
|
<summary> Returns true if we should inherit our callers context (true division, etc...), false otherwise </summary>
|
|
</member>
|
|
<member name="M:IronPython.Modules.Builtin.GetCompilerFlags(System.Int32)">
|
|
<summary> Returns the default compiler flags or the flags the user specified. </summary>
|
|
</member>
|
|
<member name="M:IronPython.Modules.Builtin.GetExecEvalScopeOptional(IronPython.Runtime.CodeContext,IronPython.Runtime.PythonDictionary,System.Object,System.Boolean)">
|
|
<summary>
|
|
Gets a scope used for executing new code in optionally replacing the globals and locals dictionaries.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Modules.SysModule.callstats">
|
|
<summary>
|
|
Returns detailed call statistics. Not implemented in IronPython and always returns None.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Modules.SysModule.displayhookImpl(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Handles output of the expression statement.
|
|
Prints the value and sets the __builtin__._
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Modules._ast.AugLoad">
|
|
<summary>
|
|
Not used.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Modules._ast.AugStore">
|
|
<summary>
|
|
Not used.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Modules._ast.Suite">
|
|
<summary>
|
|
Not an actual node. We don't create this, but it's here for compatibility.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Resources">
|
|
<summary>
|
|
A strongly-typed resource class, for looking up localized strings, etc.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.ResourceManager">
|
|
<summary>
|
|
Returns the cached ResourceManager instance used by this class.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.Culture">
|
|
<summary>
|
|
Overrides the current thread's CurrentUICulture property for all
|
|
resource lookups using this strongly typed resource class.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.CantFindMember">
|
|
<summary>
|
|
Looks up a localized string similar to couldn't find member {0}.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.DefaultRequired">
|
|
<summary>
|
|
Looks up a localized string similar to default value must be specified here.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.DuplicateArgumentInFuncDef">
|
|
<summary>
|
|
Looks up a localized string similar to duplicate argument '{0}' in function definition.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.DuplicateKeywordArg">
|
|
<summary>
|
|
Looks up a localized string similar to duplicate keyword argument.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.EofInString">
|
|
<summary>
|
|
Looks up a localized string similar to <eof> while reading string.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.EofInTripleQuotedString">
|
|
<summary>
|
|
Looks up a localized string similar to EOF while scanning triple-quoted string.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.EolInSingleQuotedString">
|
|
<summary>
|
|
Looks up a localized string similar to EOL while scanning single-quoted string.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.ExpectedIndentation">
|
|
<summary>
|
|
Looks up a localized string similar to expected an indented block.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.ExpectedName">
|
|
<summary>
|
|
Looks up a localized string similar to expected name.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.ExpectingIdentifier">
|
|
<summary>
|
|
Looks up a localized string similar to Expecting identifier:.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.InconsistentWhitespace">
|
|
<summary>
|
|
Looks up a localized string similar to inconsistent use of tabs and spaces in indentation.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.IndentationMismatch">
|
|
<summary>
|
|
Looks up a localized string similar to unindent does not match any outer indentation level.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.InvalidArgumentValue">
|
|
<summary>
|
|
Looks up a localized string similar to Invalid argument value..
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.InvalidOperation_MakeGenericOnNonGeneric">
|
|
<summary>
|
|
Looks up a localized string similar to MakeGenericType on non-generic type.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.InvalidParameters">
|
|
<summary>
|
|
Looks up a localized string similar to Invalid parameter collection for the function..
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.InvalidToken">
|
|
<summary>
|
|
Looks up a localized string similar to invalid token
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.InvalidSyntax">
|
|
<summary>
|
|
Looks up a localized string similar to invalid syntax.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.KeywordCreateUnavailable">
|
|
<summary>
|
|
Looks up a localized string similar to object ({0}) is not creatable w/ keyword arguments.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.KeywordOutOfSequence">
|
|
<summary>
|
|
Looks up a localized string similar to keywords must come before * args.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.MemberDoesNotExist">
|
|
<summary>
|
|
Looks up a localized string similar to type does not have {0} field.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.MisplacedFuture">
|
|
<summary>
|
|
Looks up a localized string similar to from __future__ imports must occur at the beginning of the file.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.MisplacedReturn">
|
|
<summary>
|
|
Looks up a localized string similar to 'return' outside function.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.MisplacedYield">
|
|
<summary>
|
|
Looks up a localized string similar to 'yield' outside function.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.NewLineInDoubleQuotedString">
|
|
<summary>
|
|
Looks up a localized string similar to NEWLINE in double-quoted string.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.NewLineInSingleQuotedString">
|
|
<summary>
|
|
Looks up a localized string similar to NEWLINE in single-quoted string.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.NoFutureStar">
|
|
<summary>
|
|
Looks up a localized string similar to future statement does not support import *.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.NonKeywordAfterKeywordArg">
|
|
<summary>
|
|
Looks up a localized string similar to non-keyword arg after keyword arg.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.NotAChance">
|
|
<summary>
|
|
Looks up a localized string similar to not a chance.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.NotImplemented">
|
|
<summary>
|
|
Looks up a localized string similar to The method or operation is not implemented..
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.OneKeywordArgOnly">
|
|
<summary>
|
|
Looks up a localized string similar to only one ** allowed.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.OneListArgOnly">
|
|
<summary>
|
|
Looks up a localized string similar to only one * allowed.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.PythonContextRequired">
|
|
<summary>
|
|
Looks up a localized string similar to Context must be PythonCompilerContext.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.Slot_CantDelete">
|
|
<summary>
|
|
Looks up a localized string similar to cannot delete slot.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.Slot_CantGet">
|
|
<summary>
|
|
Looks up a localized string similar to cannot get slot.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.Slot_CantSet">
|
|
<summary>
|
|
Looks up a localized string similar to cannot set slot.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.StaticAccessFromInstanceError">
|
|
<summary>
|
|
Looks up a localized string similar to static property '{0}' of '{1}' can only be read through a type, not an instance.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.StaticAssignmentFromInstanceError">
|
|
<summary>
|
|
Looks up a localized string similar to static property '{0}' of '{1}' can only be assigned to through a type, not an instance.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.TokenHasNoValue">
|
|
<summary>
|
|
Looks up a localized string similar to no value for this token.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.TooManyVersions">
|
|
<summary>
|
|
Looks up a localized string similar to too many versions.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.UnexpectedToken">
|
|
<summary>
|
|
Looks up a localized string similar to unexpected token '{0}'.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Resources.UnknownFutureFeature">
|
|
<summary>
|
|
Looks up a localized string similar to future feature is not defined:.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.BindingWarnings">
|
|
<summary>
|
|
Provides support for emitting warnings when built in methods are invoked at runtime.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.Binders.Convert(System.Linq.Expressions.Expression,IronPython.Runtime.PythonContext,System.Type,Microsoft.Scripting.Actions.ConversionResultKind,System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Backwards compatible Convert for the old sites that need to flow CodeContext
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.Binders.InvokeSplat(IronPython.Runtime.PythonContext)">
|
|
<summary>
|
|
Creates a new InvokeBinder which will call with positional splatting.
|
|
|
|
The signature of the target site should be object(function), object[], retType
|
|
</summary>
|
|
<param name="state"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.Binders.InvokeKeywords(IronPython.Runtime.PythonContext)">
|
|
<summary>
|
|
Creates a new InvokeBinder which will call with positional and keyword splatting.
|
|
|
|
The signature of the target site should be object(function), object[], dictionary, retType
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.BindingHelpers">
|
|
<summary>
|
|
Common helpers used by the various binding logic.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.BindingHelpers.TryGetStaticFunction(IronPython.Runtime.PythonContext,System.String,System.Dynamic.DynamicMetaObject,IronPython.Runtime.Types.BuiltinFunction@)">
|
|
<summary>
|
|
Tries to get the BuiltinFunction for the given name on the type of the provided MetaObject.
|
|
|
|
Succeeds if the MetaObject is a BuiltinFunction or BuiltinMethodDescriptor.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.BindingHelpers.GetCallSignature(System.Dynamic.DynamicMetaObjectBinder)">
|
|
<summary>
|
|
Gets the best CallSignature from a MetaAction.
|
|
|
|
The MetaAction should be either a Python InvokeBinder, or a DLR InvokeAction or
|
|
CreateAction. For Python we can use a full-fidelity
|
|
</summary>
|
|
<param name="action"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.BindingHelpers.GenericInvokeMember(System.Dynamic.InvokeMemberBinder,IronPython.Runtime.Binding.ValidationInfo,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Transforms an invoke member into a Python GetMember/Invoke. The caller should
|
|
verify that the given attribute is not resolved against a normal .NET class
|
|
before calling this. If it is a normal .NET member then a fallback InvokeMember
|
|
is preferred.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.BindingHelpers.IsSubclassOf(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject)">
|
|
<summary>
|
|
Determines if the type associated with the first MetaObject is a subclass of the
|
|
type associated with the second MetaObject.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.BindingHelpers.AddRecursionCheck(IronPython.Runtime.PythonContext,System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Adds a try/finally which enforces recursion limits around the target method.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.BindingHelpers.InvokeFallback(System.Dynamic.DynamicMetaObjectBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Helper to do fallback for Invoke's so we can handle both StandardAction and Python's
|
|
InvokeBinder.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.BindingHelpers.GetComArguments(System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Converts arguments into a form which can be used for COM interop.
|
|
|
|
The argument is only converted if we have an IronPython specific
|
|
conversion when calling COM methods.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.BindingHelpers.GetComArgument(System.Dynamic.DynamicMetaObject)">
|
|
<summary>
|
|
Converts a single argument into a form which can be used for COM
|
|
interop.
|
|
|
|
The argument is only converted if we have an IronPython specific
|
|
conversion when calling COM methods.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.CompatibilityInvokeBinder">
|
|
<summary>
|
|
Fallback action for performing an invoke from Python. We translate the
|
|
CallSignature which supports splatting position and keyword args into
|
|
their expanded form.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.ConditionalBuilder">
|
|
<summary>
|
|
Builds up a series of conditionals when the False clause isn't yet known. We can
|
|
keep appending conditions and if true's. Each subsequent true branch becomes the
|
|
false branch of the previous condition and body. Finally a non-conditional terminating
|
|
branch must be added.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.ConditionalBuilder.AddCondition(System.Linq.Expressions.Expression,System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Adds a new conditional and body. The first call this becomes the top-level
|
|
conditional, subsequent calls will have it added as false statement of the
|
|
previous conditional.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.ConditionalBuilder.ExtendLastCondition(System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
If present, converts the finish condition body be a normal conditional body.
|
|
The builder instance will become unfinished again.
|
|
|
|
If no finish condition body is available, this extends the last condition check
|
|
with the new condition.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.ConditionalBuilder.FinishCondition(System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Adds the non-conditional terminating node.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Binding.ConditionalBuilder.NoConditions">
|
|
<summary>
|
|
Returns true if no conditions have been added
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Binding.ConditionalBuilder.IsFinal">
|
|
<summary>
|
|
Returns true if a final, non-conditional, body has been added.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.ConditionalBuilder.GetMetaObject(System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Gets the resulting meta object for the full body. FinishCondition
|
|
must have been called.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.ConditionalBuilder.AddVariable(System.Linq.Expressions.ParameterExpression)">
|
|
<summary>
|
|
Adds a variable which will be scoped at the level of the final expression.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.ContextArgBuilder">
|
|
<summary>
|
|
ArgBuilder which provides the CodeContext parameter to a method.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.CreateFallback">
|
|
<summary>
|
|
Fallback action for performing a new() on a foreign IDynamicMetaObjectProvider. used
|
|
when call falls back.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.FastGetBase">
|
|
<summary>
|
|
Base class for all of our fast get delegates. This holds onto the
|
|
delegate and provides the Update function.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.FastGetBase.Update(System.Runtime.CompilerServices.CallSite,System.Object,IronPython.Runtime.CodeContext)">
|
|
<summary>
|
|
Updates the call site when the current rule is no longer applicable.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.FastSetBase`1">
|
|
<summary>
|
|
Base class for all of our fast set delegates. This holds onto the
|
|
delegate and provides the Update and Optimize functions.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.FastSetBase`1.Update(System.Runtime.CompilerServices.CallSite,System.Object,`0)">
|
|
<summary>
|
|
Updates the call site when the current rule is no longer applicable.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.IComConvertible">
|
|
<summary>
|
|
An interface that is implemented on DynamicMetaObjects.
|
|
|
|
This allows objects to opt-into custom conversions when calling
|
|
COM APIs. The IronPython binders all call this interface before
|
|
doing any COM binding.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.IPythonExpandable">
|
|
<summary>
|
|
Interface used to mark objects which contain a dictionary of custom attributes that shadow
|
|
their existing attributes in a dynamic fashion. <seealso cref="T:MetaExpandable"/>
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.IPythonExpandable.EnsureCustomAttributes">
|
|
<summary>
|
|
Ensures that a non-null IDictionary instance is created for CustomAttributes and
|
|
returns it.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.MetaExpandable`1">
|
|
<summary>
|
|
Meta-object which allows IPythonExpandable objects to behave like Python objects in their
|
|
ability to dynamically add and remove new or existing custom attributes, generally shadowing
|
|
existing built-in members. <seealso cref="T:IPythonExpandable"/>
|
|
|
|
Getting: Member accesses first consult the object's CustomAttributes dictionary, then fall
|
|
through to the underlying object.
|
|
|
|
Setting: Values can be bound to any member name, shadowing any existing attributes except
|
|
public non-PythonHidden fields and properties, which will bypass the dictionary. Thus,
|
|
it is possible for SetMember to fail, for example if the property is read-only or of
|
|
the wrong type.
|
|
|
|
Deleting: Any member represented in the dictionary can be deleted, re-exposing the
|
|
underlying member if it exists. Any other deletions will fail.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.IPythonInvokable">
|
|
<summary>
|
|
Interface used to mark objects as being invokable from Python. These objects support
|
|
calling with splatted positional and keyword arguments.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Binding.IPythonSite.Context">
|
|
<summary>
|
|
Gets the PythonContext which the CallSiteBinder is associated with.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.MetaOldInstance">
|
|
<summary>
|
|
Provides a MetaObject for instances of Python's old-style classes.
|
|
|
|
TODO: Lots of CodeConetxt references, need to move CodeContext onto OldClass and pull it from there.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper">
|
|
<summary>
|
|
Performs the actual work of binding to the function.
|
|
|
|
Overall this works by going through the arguments and attempting to bind all the outstanding known
|
|
arguments - position arguments and named arguments which map to parameters are easy and handled
|
|
in the 1st pass for GetArgumentsForRule. We also pick up any extra named or position arguments which
|
|
will need to be passed off to a kw argument or a params array.
|
|
|
|
After all the normal args have been assigned to do a 2nd pass in FinishArguments. Here we assign
|
|
a value to either a value from the params list, kw-dict, or defaults. If there is ambiguity between
|
|
this (e.g. we have a splatted params list, kw-dict, and defaults) we call a helper which extracts them
|
|
in the proper order (first try the list, then the dict, then the defaults).
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetRestrictions">
|
|
<summary>
|
|
Makes the test for our rule.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetSimpleRestriction">
|
|
<summary>
|
|
Makes the test when we just have simple positional arguments.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetComplexRestriction">
|
|
<summary>
|
|
Makes the test when we have a keyword argument call or splatting.
|
|
</summary>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetArgumentsForRule">
|
|
<summary>
|
|
Gets the array of expressions which correspond to each argument for the function. These
|
|
correspond with the function as it's defined in Python and must be transformed for our
|
|
delegate type before being used.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.FinishArguments(System.Linq.Expressions.Expression[],System.Collections.Generic.List{System.Linq.Expressions.Expression},System.Collections.Generic.Dictionary{System.String,System.Linq.Expressions.Expression})">
|
|
<summary>
|
|
Binds any missing arguments to values from params array, kw dictionary, or default values.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.TryFinishList(System.Linq.Expressions.Expression[],System.Collections.Generic.List{System.Linq.Expressions.Expression})">
|
|
<summary>
|
|
Creates the argument for the list expansion parameter.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeParamsAddition(System.Collections.Generic.List{System.Linq.Expressions.Expression})">
|
|
<summary>
|
|
Adds extra positional arguments to the start of the expanded list.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.TryFinishDictionary(System.Linq.Expressions.Expression[],System.Collections.Generic.Dictionary{System.String,System.Linq.Expressions.Expression})">
|
|
<summary>
|
|
Creates the argument for the dictionary expansion parameter.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeDictionaryAddition(System.Collections.Generic.KeyValuePair{System.String,System.Linq.Expressions.Expression})">
|
|
<summary>
|
|
Adds an unbound keyword argument into the dictionary.
|
|
</summary>
|
|
<param name="kvp"></param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.AddCheckForNoExtraParameters(System.Linq.Expressions.Expression[])">
|
|
<summary>
|
|
Adds a check to the last parameter (so it's evaluated after we've extracted
|
|
all the parameters) to ensure that we don't have any extra params or kw-params
|
|
when we don't have a params array or params dict to expand them into.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ValidateNotDuplicate(System.Linq.Expressions.Expression,System.String,System.Int32)">
|
|
<summary>
|
|
Helper function to validate that a named arg isn't duplicated with by
|
|
a params list or the dictionary (or both).
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractNonDefaultValue(System.String)">
|
|
<summary>
|
|
Helper function to get a value (which has no default) from either the
|
|
params list or the dictionary (or both).
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractDictionaryArgument(System.String)">
|
|
<summary>
|
|
Helper function to get the specified variable from the dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractDefaultValue(System.Int32,System.Int32)">
|
|
<summary>
|
|
Helper function to extract the variable from defaults, or to call a helper
|
|
to check params / kw-dict / defaults to see which one contains the actual value.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractFromListOrDictionary(System.String)">
|
|
<summary>
|
|
Helper function to extract from the params list or dictionary depending upon
|
|
which one has an available value.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.ExtractNextParamsArg">
|
|
<summary>
|
|
Helper function to extract the next argument from the params list.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetArgumentsForTargetType(System.Linq.Expressions.Expression[])">
|
|
<summary>
|
|
Fixes up the argument list for the appropriate target delegate type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.GetFunctionParam">
|
|
<summary>
|
|
Helper function to get the function argument strongly typed.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeDictionaryCopy(System.Dynamic.DynamicMetaObject)">
|
|
<summary>
|
|
Called when the user is expanding a dictionary - we copy the user
|
|
dictionary and verify that it contains only valid string names.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeParamsCopy(System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Called when the user is expanding a params argument
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeDictionary(System.Collections.Generic.Dictionary{System.String,System.Linq.Expressions.Expression})">
|
|
<summary>
|
|
Called when the user hasn't supplied a dictionary to be expanded but the
|
|
function takes a dictionary to be expanded.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeParamsTuple(System.Collections.Generic.List{System.Linq.Expressions.Expression})">
|
|
<summary>
|
|
Helper function to create the expression for creating the actual tuple passed through.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.MakeFunctionInvoke(System.Linq.Expressions.Expression[])">
|
|
<summary>
|
|
Creates the code to invoke the target delegate function w/ the specified arguments.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonFunction.FunctionBinderHelper.AddInitialization(System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Appends the initialization code for the call to the function if any exists.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonObject.MakeDelegateTarget(System.Dynamic.DynamicMetaObjectBinder,System.Type,System.Dynamic.DynamicMetaObject)">
|
|
<summary>
|
|
Creates a target which creates a new dynamic method which contains a single
|
|
dynamic site that invokes the callable object.
|
|
|
|
TODO: This should be specialized for each callable object
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonType.MakeStandardDotNetTypeCall(System.Dynamic.DynamicMetaObjectBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Creating a standard .NET type is easy - we just call it's constructor with the provided
|
|
arguments.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonType.MakePythonTypeCall(System.Dynamic.DynamicMetaObjectBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Creating a Python type involves calling __new__ and __init__. We resolve them
|
|
and generate calls to either the builtin funcions directly or embed sites which
|
|
call the slots at runtime.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonType.TooManyArgsForDefaultNew(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Checks if we have a default new and init - in this case if we have any
|
|
arguments we don't allow the call.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaPythonType.MakeVersionCheck">
|
|
<summary>
|
|
Creates a test which tests the specific version of the type.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.MetaPythonType.GetBinderHelper`1">
|
|
<summary>
|
|
Base class for performing member binding. Derived classes override Add methods
|
|
to produce the actual final result based upon what the GetBinderHelper resolves.
|
|
</summary>
|
|
<typeparam name="TResult"></typeparam>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.MetaPythonType.MetaGetBinderHelper">
|
|
<summary>
|
|
Provides the normal meta binder binding.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.MetaPythonType.FastGetBinderHelper">
|
|
<summary>
|
|
Provides delegate based fast binding.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaUserObject.GetConversionFailedReturnValue(IronPython.Runtime.Binding.PythonConversionBinder,System.Dynamic.DynamicMetaObject)">
|
|
<summary>
|
|
Various helpers related to calling Python __*__ conversion methods
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaUserObject.Fallback(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject)">
|
|
<summary>
|
|
Helper for falling back - if we have a base object fallback to it first (which can
|
|
then fallback to the calling site), otherwise fallback to the calling site.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaUserObject.Fallback(System.Dynamic.SetMemberBinder,System.Dynamic.DynamicMetaObject)">
|
|
<summary>
|
|
Helper for falling back - if we have a base object fallback to it first (which can
|
|
then fallback to the calling site), otherwise fallback to the calling site.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.MetaUserObject.GetOrInvokeBinderHelper`1">
|
|
<summary>
|
|
Provides the lookup logic for resolving a Python object. Subclasses
|
|
provide the actual logic for producing the binding result. Currently
|
|
there are two forms of the binding result: one is the DynamicMetaObject
|
|
form used for non-optimized bindings. The other is the Func of CallSite,
|
|
object, CodeContext, object form which is used for fast binding and
|
|
pre-compiled rules.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.MetaUserObject.MetaGetBinderHelper">
|
|
<summary>
|
|
GetBinder which produces a DynamicMetaObject. This binder always
|
|
successfully produces a DynamicMetaObject which can perform the requested get.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaUserObject.MetaGetBinderHelper.MakeGetAttributeRule(IronPython.Runtime.Binding.MetaUserObject.GetBindingInfo,IronPython.Runtime.Types.IPythonObject,IronPython.Runtime.Types.PythonTypeSlot,System.Dynamic.DynamicMetaObject)">
|
|
<summary>
|
|
Makes a rule which calls a user-defined __getattribute__ function and falls back to __getattr__ if that
|
|
raises an AttributeError.
|
|
|
|
slot is the __getattribute__ method to be called.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaUserObject.MetaGetBinderHelper.MakeOldStyleAccess">
|
|
<summary>
|
|
Checks a range of the MRO to perform old-style class lookups if any old-style classes
|
|
are present. We will call this twice to produce a search before a slot and after
|
|
a slot.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaUserObject.TryGetGetAttribute(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,IronPython.Runtime.Types.PythonTypeSlot@)">
|
|
<summary>
|
|
Checks to see if this type has __getattribute__ that overrides all other attribute lookup.
|
|
|
|
This is more complex then it needs to be. The problem is that when we have a
|
|
mixed new-style/old-style class we have a weird __getattribute__ defined. When
|
|
we always dispatch through rules instead of PythonTypes it should be easy to remove
|
|
this.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaUserObject.MetaSetBinderHelper.FallbackSetError(System.Dynamic.SetMemberBinder,System.Dynamic.DynamicMetaObject)">
|
|
<summary>
|
|
Helper for falling back - if we have a base object fallback to it first (which can
|
|
then fallback to the calling site), otherwise fallback to the calling site.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaUserObject.FindSlot(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.Types.IPythonObject,System.Boolean@,System.Boolean@,System.Boolean@)">
|
|
<summary>
|
|
Looks up the associated PythonTypeSlot from the object. Indicates if the result
|
|
came from a standard .NET type in which case we will fallback to the sites binder.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaUserObject.FallbackGetError(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject)">
|
|
<summary>
|
|
Helper for falling back - if we have a base object fallback to it first (which can
|
|
then fallback to the calling site), otherwise fallback to the calling site.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.MetaUserObject.FallbackDeleteError(System.Dynamic.DeleteMemberBinder,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Helper for falling back - if we have a base object fallback to it first (which can
|
|
then fallback to the calling site), otherwise fallback to the calling site.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.MakeReadOnlyMemberError(System.Type,System.String)">
|
|
<summary>
|
|
Provides a way for the binder to provide a custom error message when lookup fails. Just
|
|
doing this for the time being until we get a more robust error return mechanism.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.MakeUndeletableMemberError(System.Type,System.String)">
|
|
<summary>
|
|
Provides a way for the binder to provide a custom error message when lookup fails. Just
|
|
doing this for the time being until we get a more robust error return mechanism.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.GetBinder(IronPython.Runtime.CodeContext)">
|
|
<summary>
|
|
Gets the PythonBinder associated with tihs CodeContext
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.TryLookupSlot(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
|
|
<summary>
|
|
Performs .NET member resolution. This looks within the given type and also
|
|
includes any extension members. Base classes and their extension members are
|
|
not searched.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.TryLookupProtectedSlot(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
|
|
<summary>
|
|
Performs .NET member resolution. This looks within the given type and also
|
|
includes any extension members. Base classes and their extension members are
|
|
not searched.
|
|
|
|
This version allows PythonType's for protected member resolution. It shouldn't
|
|
be called externally for other purposes.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.TryResolveSlot(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,IronPython.Runtime.Types.PythonType,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
|
|
<summary>
|
|
Performs .NET member resolution. This looks the type and any base types
|
|
for members. It also searches for extension members in the type and any base types.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.LookupMembers(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,IronPython.Runtime.PythonDictionary)">
|
|
<summary>
|
|
Gets the member names which are defined in this type and any extension members.
|
|
|
|
This search does not include members in any subtypes or their extension members.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.ResolveMemberNames(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,IronPython.Runtime.Types.PythonType,System.Collections.Generic.Dictionary{System.String,System.String})">
|
|
<summary>
|
|
Gets the member names which are defined in the type and any subtypes.
|
|
|
|
This search includes members in the type and any subtypes as well as extension
|
|
types of the type and its subtypes.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.MakeExtensionTypes">
|
|
<summary>
|
|
Creates the initial table of extension types. These are standard extension that we apply
|
|
to well known .NET types to make working with them better. Being added to this table does
|
|
not make a type a Python type though so that it's members are generally accessible w/o an
|
|
import clr and their type is not re-named.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.MakeSystemTypes">
|
|
<summary>
|
|
Creates a table of standard .NET types which are also standard Python types. These types have a standard
|
|
set of extension types which are shared between all runtimes.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.DomainManager_AssemblyLoaded(System.Object,Microsoft.Scripting.AssemblyLoadedEventArgs)">
|
|
<summary>
|
|
Event handler for when our domain manager has an assembly loaded by the user hosting the script
|
|
runtime. Here we can gather any information regarding extension methods.
|
|
|
|
Currently DLR-style extension methods become immediately available w/o an explicit import step.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.PythonBinder.SlotCache">
|
|
<summary>
|
|
Provides a cache from Type/name -> PythonTypeSlot and also allows access to
|
|
all members (and remembering whether all members are cached).
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.CacheSlot(System.Type,System.Boolean,System.String,IronPython.Runtime.Types.PythonTypeSlot,Microsoft.Scripting.Actions.MemberGroup)">
|
|
<summary>
|
|
Writes to a cache the result of a type lookup. Null values are allowed for the slots and they indicate that
|
|
the value does not exist.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.TryGetCachedSlot(System.Type,System.Boolean,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
|
|
<summary>
|
|
Looks up a cached type slot for the specified member and type. This may return true and return a null slot - that indicates
|
|
that a cached result for a member which doesn't exist has been stored. Otherwise it returns true if a slot is found or
|
|
false if it is not.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.TryGetCachedMember(System.Type,System.String,System.Boolean,Microsoft.Scripting.Actions.MemberGroup@)">
|
|
<summary>
|
|
Looks up a cached member group for the specified member and type. This may return true and return a null group - that indicates
|
|
that a cached result for a member which doesn't exist has been stored. Otherwise it returns true if a group is found or
|
|
false if it is not.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.IsFullyCached(System.Type,System.Boolean)">
|
|
<summary>
|
|
Checks to see if all members have been populated for the provided type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.CacheAll(System.Type,System.Boolean,System.Collections.Generic.Dictionary{System.String,System.Collections.Generic.KeyValuePair{IronPython.Runtime.Types.PythonTypeSlot,Microsoft.Scripting.Actions.MemberGroup}})">
|
|
<summary>
|
|
Populates the type with all the provided members and marks the type
|
|
as being fully cached.
|
|
|
|
The dictionary is used for the internal storage and should not be modified after
|
|
providing it to the cache.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonBinder.SlotCache.GetAllMembers(System.Type,System.Boolean)">
|
|
<summary>
|
|
Returns an enumerable object which provides access to all the members of the provided type.
|
|
|
|
The caller must check that the type is fully cached and populate the cache if it isn't before
|
|
calling this method.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonGetMemberBinder.Bind(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Python's Invoke is a non-standard action. Here we first try to bind through a Python
|
|
internal interface (IPythonInvokable) which supports CallSigantures. If that fails
|
|
and we have an IDO then we translate to the DLR protocol through a nested dynamic site -
|
|
this includes unsplatting any keyword / position arguments. Finally if it's just a plain
|
|
old .NET type we use the default binder which supports CallSignatures.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.PythonInvokeBinder">
|
|
<summary>
|
|
The Action used for Python call sites. This supports both splatting of position and keyword arguments.
|
|
|
|
When a foreign object is encountered the arguments are expanded into normal position/keyword arguments.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonInvokeBinder.Bind(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Python's Invoke is a non-standard action. Here we first try to bind through a Python
|
|
internal interface (IPythonInvokable) which supports CallSigantures. If that fails
|
|
and we have an IDO then we translate to the DLR protocol through a nested dynamic site -
|
|
this includes unsplatting any keyword / position arguments. Finally if it's just a plain
|
|
old .NET type we use the default binder which supports CallSignatures.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonInvokeBinder.Fallback(System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Fallback - performs the default binding operation if the object isn't recognized
|
|
as being invokable.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Binding.PythonInvokeBinder.Signature">
|
|
<summary>
|
|
Gets the CallSignature for this invocation which describes how the MetaObject array
|
|
is to be mapped.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonInvokeBinder.InvokeForeignObject(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Creates a nested dynamic site which uses the unpacked arguments.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonInvokeBinder.TranslateArguments(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[],System.Dynamic.CallInfo@,System.Collections.Generic.List{System.Linq.Expressions.Expression}@,System.Linq.Expressions.Expression@,System.Dynamic.BindingRestrictions@)">
|
|
<summary>
|
|
Translates our CallSignature into a DLR Argument list and gives the simple MetaObject's which are extracted
|
|
from the tuple or dictionary parameters being splatted.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Binding.PythonOperationBinder.ReturnType">
|
|
<summary>
|
|
The result type of the operation.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.PythonOperationKind">
|
|
<summary>
|
|
Custom dynamic site kinds for simple sites that just take a fixed set of parameters.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Documentation">
|
|
<summary>
|
|
Unary operator.
|
|
|
|
Gets various documentation about the object returned as a string
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.CallSignatures">
|
|
<summary>
|
|
Unary operator.
|
|
|
|
Gets information about the type of parameters, returned as a string.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.IsCallable">
|
|
<summary>
|
|
Unary operator.
|
|
|
|
Checks whether the object is callable or not, returns true if it is.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Contains">
|
|
<summary>
|
|
Binary operator.
|
|
|
|
Checks to see if the instance contains another object. Returns true or false.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Length">
|
|
<summary>
|
|
Unary operator.
|
|
|
|
Returns the number of items stored in the object.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Compare">
|
|
<summary>
|
|
Binary operator.
|
|
|
|
Compares two instances returning an integer indicating the relationship between them. May
|
|
throw if the object types are uncomparable.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.DivMod">
|
|
<summary>
|
|
Binary operator.
|
|
|
|
Returns both the dividend and quotioent of x / y.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.AbsoluteValue">
|
|
<summary>
|
|
Unary operator.
|
|
|
|
Get the absolute value of the instance.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Positive">
|
|
<summary>
|
|
Unary operator.
|
|
|
|
Gets the positive value of the instance.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Negate">
|
|
<summary>
|
|
Unary operator.
|
|
|
|
Negates the instance and return the new value.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.OnesComplement">
|
|
<summary>
|
|
Unary operator.
|
|
|
|
Returns the ones complement of the instance.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.IsFalse">
|
|
<summary>
|
|
Unary operator.
|
|
|
|
Boolean negation
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Not">
|
|
<summary>
|
|
Unary operator.
|
|
|
|
Negation, returns object
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.GetEnumeratorForIteration">
|
|
<summary>
|
|
Get enumerator for iteration binder. Returns a KeyValuePair<IEnumerator, IDisposable>
|
|
|
|
The IEnumerator is used for iteration. The IDisposable is provided if the object was an
|
|
IEnumerable or IEnumerable<T> and is a disposable object.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Add">
|
|
<summary>Operator for performing add</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Subtract">
|
|
<summary>Operator for performing sub</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Power">
|
|
<summary>Operator for performing pow</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Multiply">
|
|
<summary>Operator for performing mul</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.FloorDivide">
|
|
<summary>Operator for performing floordiv</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Divide">
|
|
<summary>Operator for performing div</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.TrueDivide">
|
|
<summary>Operator for performing truediv</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Mod">
|
|
<summary>Operator for performing mod</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.LeftShift">
|
|
<summary>Operator for performing lshift</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.RightShift">
|
|
<summary>Operator for performing rshift</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.BitwiseAnd">
|
|
<summary>Operator for performing and</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.BitwiseOr">
|
|
<summary>Operator for performing or</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ExclusiveOr">
|
|
<summary>Operator for performing xor</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.LessThan">
|
|
<summary>Operator for performing lt</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.GreaterThan">
|
|
<summary>Operator for performing gt</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.LessThanOrEqual">
|
|
<summary>Operator for performing le</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.GreaterThanOrEqual">
|
|
<summary>Operator for performing ge</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.Equal">
|
|
<summary>Operator for performing eq</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.NotEqual">
|
|
<summary>Operator for performing ne</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.LessThanGreaterThan">
|
|
<summary>Operator for performing lg</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceAdd">
|
|
<summary>Operator for performing in-place add</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceSubtract">
|
|
<summary>Operator for performing in-place sub</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlacePower">
|
|
<summary>Operator for performing in-place pow</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceMultiply">
|
|
<summary>Operator for performing in-place mul</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceFloorDivide">
|
|
<summary>Operator for performing in-place floordiv</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceDivide">
|
|
<summary>Operator for performing in-place div</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceTrueDivide">
|
|
<summary>Operator for performing in-place truediv</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceMod">
|
|
<summary>Operator for performing in-place mod</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceLeftShift">
|
|
<summary>Operator for performing in-place lshift</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceRightShift">
|
|
<summary>Operator for performing in-place rshift</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceBitwiseAnd">
|
|
<summary>Operator for performing in-place and</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceBitwiseOr">
|
|
<summary>Operator for performing in-place or</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.InPlaceExclusiveOr">
|
|
<summary>Operator for performing in-place xor</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseAdd">
|
|
<summary>Operator for performing reverse add</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseSubtract">
|
|
<summary>Operator for performing reverse sub</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReversePower">
|
|
<summary>Operator for performing reverse pow</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseMultiply">
|
|
<summary>Operator for performing reverse mul</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseFloorDivide">
|
|
<summary>Operator for performing reverse floordiv</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseDivide">
|
|
<summary>Operator for performing reverse div</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseTrueDivide">
|
|
<summary>Operator for performing reverse truediv</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseMod">
|
|
<summary>Operator for performing reverse mod</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseLeftShift">
|
|
<summary>Operator for performing reverse lshift</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseRightShift">
|
|
<summary>Operator for performing reverse rshift</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseBitwiseAnd">
|
|
<summary>Operator for performing reverse and</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseBitwiseOr">
|
|
<summary>Operator for performing reverse or</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseExclusiveOr">
|
|
<summary>Operator for performing reverse xor</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Binding.PythonOperationKind.ReverseDivMod">
|
|
<summary>Operator for performing reverse divmod</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.PythonProtocol">
|
|
<summary>
|
|
Provides binding logic which is implemented to follow various Python protocols. This includes
|
|
things such as calling __call__ to perform calls, calling __nonzero__/__len__ to convert to
|
|
bool, calling __add__/__radd__ to do addition, etc...
|
|
|
|
This logic gets shared between both the IDynamicMetaObjectProvider implementation for Python objects as well
|
|
as the Python sites. This ensures the logic we follow for our builtin types and user defined
|
|
types is identical and properly conforming to the various protocols.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.ConvertToBool(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject)">
|
|
<summary>
|
|
Gets a MetaObject which converts the provided object to a bool using __nonzero__ or __len__
|
|
protocol methods. This code is shared between both our fallback for a site and our MetaObject
|
|
for user defined objects.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.GetConvertByLengthBody(IronPython.Runtime.PythonContext,System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Used for conversions to bool
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.MakeContainsOperation(IronPython.Runtime.Binding.PythonOperationBinder,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Creates a rule for the contains operator. This is exposed via "x in y" in
|
|
IronPython. It is implemented by calling the __contains__ method on x and
|
|
passing in y.
|
|
|
|
If a type doesn't define __contains__ but does define __getitem__ then __getitem__ is
|
|
called repeatedly in order to see if the object is there.
|
|
|
|
For normal .NET enumerables we'll walk the iterator and see if it's present.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.PythonProtocol.ComparisonHelper">
|
|
<summary>
|
|
Delegate for finishing the comparison. This takes in a condition and a return value and needs to update the ConditionalBuilder
|
|
with the appropriate resulting body. The condition may be null.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.MakeOneCompareGeneric(IronPython.Runtime.Binding.SlotOrFunction,System.Boolean,System.Dynamic.DynamicMetaObject[],IronPython.Runtime.Binding.PythonProtocol.ComparisonHelper,IronPython.Runtime.Binding.ConditionalBuilder,System.Type)">
|
|
<summary>
|
|
Helper to handle a comparison operator call. Checks to see if the call can
|
|
return NotImplemented and allows the caller to modify the expression that
|
|
is ultimately returned (e.g. to turn __cmp__ into a bool after a comparison)
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.DoCoerce(IronPython.Runtime.PythonContext,IronPython.Runtime.Binding.ConditionalBuilder,IronPython.Runtime.Binding.PythonOperationKind,System.Dynamic.DynamicMetaObject[],System.Boolean,System.Func{System.Linq.Expressions.Expression,System.Linq.Expressions.Expression})">
|
|
<summary>
|
|
calls __coerce__ for old-style classes and performs the operation if the coercion is successful.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.MakeSortComparisonRule(System.Dynamic.DynamicMetaObject[],System.Dynamic.DynamicMetaObjectBinder,IronPython.Runtime.Binding.PythonOperationKind)">
|
|
<summary>
|
|
Makes the comparison rule which returns an int (-1, 0, 1). TODO: Better name?
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.MakeIndexerOperation(System.Dynamic.DynamicMetaObjectBinder,IronPython.Runtime.Binding.PythonIndexType,System.Dynamic.DynamicMetaObject[],System.Dynamic.DynamicMetaObject)">
|
|
<summary>
|
|
Python has three protocols for slicing:
|
|
Simple Slicing x[i:j]
|
|
Extended slicing x[i,j,k,...]
|
|
Long Slice x[start:stop:step]
|
|
|
|
The first maps to __*slice__ (get, set, and del).
|
|
This takes indexes - i, j - which specify the range of elements to be
|
|
returned. In the slice variants both i, j must be numeric data types.
|
|
The 2nd and 3rd are both __*item__.
|
|
This receives a single index which is either a Tuple or a Slice object (which
|
|
encapsulates the start, stop, and step values)
|
|
|
|
This is in addition to a simple indexing x[y].
|
|
|
|
For simple slicing and long slicing Python generates Operators.*Slice. For
|
|
the extended slicing and simple indexing Python generates a Operators.*Item
|
|
action.
|
|
|
|
Extended slicing maps to the normal .NET multi-parameter input.
|
|
|
|
So our job here is to first determine if we're to call a __*slice__ method or
|
|
a __*item__ method.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.ConvertArgs(System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Helper to convert all of the arguments to their known types.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.GetItemSliceArguments(IronPython.Runtime.PythonContext,IronPython.Runtime.Binding.PythonIndexType,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Gets the arguments that need to be provided to __*item__ when we need to pass a slice object.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.PythonProtocol.Callable">
|
|
<summary>
|
|
Base class for calling indexers. We have two subclasses that target built-in functions and user defined callable objects.
|
|
|
|
The Callable objects get handed off to ItemBuilder's which then call them with the appropriate arguments.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.Callable.MakeCallable(IronPython.Runtime.PythonContext,IronPython.Runtime.Binding.PythonIndexType,IronPython.Runtime.Types.BuiltinFunction,IronPython.Runtime.Types.PythonTypeSlot)">
|
|
<summary>
|
|
Creates a new CallableObject. If BuiltinFunction is available we'll create a BuiltinCallable otherwise
|
|
we create a SlotCallable.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.Callable.GetTupleArguments(System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Gets the arguments in a form that should be used for extended slicing.
|
|
|
|
Python defines that multiple tuple arguments received (x[1,2,3]) get
|
|
packed into a Tuple. For most .NET methods we just want to expand
|
|
this into the multiple index arguments. For slots and old-instances
|
|
we want to pass in the tuple
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.Callable.CompleteRuleTarget(System.Dynamic.DynamicMetaObjectBinder,System.Dynamic.DynamicMetaObject[],System.Func{System.Dynamic.DynamicMetaObject})">
|
|
<summary>
|
|
Adds the target of the call to the rule.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.PythonProtocol.BuiltinCallable">
|
|
<summary>
|
|
Subclass of Callable for a built-in function. This calls a .NET method performing
|
|
the appropriate bindings.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.PythonProtocol.SlotCallable">
|
|
<summary>
|
|
Callable to a user-defined callable object. This could be a Python function,
|
|
a class defining __call__, etc...
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.PythonProtocol.IndexBuilder">
|
|
<summary>
|
|
Base class for building a __*item__ or __*slice__ call.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.PythonProtocol.SliceBuilder">
|
|
<summary>
|
|
Derived IndexBuilder for calling __*slice__ methods
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.PythonProtocol.ItemBuilder">
|
|
<summary>
|
|
Derived IndexBuilder for calling __*item__ methods.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.GetIndexOperators(IronPython.Runtime.Binding.PythonIndexType,System.String@,System.String@,System.Int32@)">
|
|
<summary>
|
|
Helper to get the symbols for __*item__ and __*slice__ based upon if we're doing
|
|
a get/set/delete and the minimum number of arguments required for each of those.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.ShouldCoerce(IronPython.Runtime.PythonContext,IronPython.Runtime.Binding.PythonOperationKind,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject,System.Boolean)">
|
|
<summary>
|
|
Checks if a coercion check should be performed. We perform coercion under the following
|
|
situations:
|
|
1. Old instances performing a binary operator (excluding rich comparisons)
|
|
2. User-defined new instances calling __cmp__ but only if we wouldn't dispatch to a built-in __coerce__ on the parent type
|
|
|
|
This matches the behavior of CPython.
|
|
</summary>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.PythonProtocol.TypeError(System.Dynamic.DynamicMetaObjectBinder,System.String,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
Produces an error message for the provided message and type names. The error message should contain
|
|
string formatting characters ({0}, {1}, etc...) for each of the type names.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Binding.SlotOrFunction">
|
|
<summary>
|
|
Provides an abstraction for calling something which might be a builtin function or
|
|
might be some arbitrary user defined slot. If the object is a builtin function the
|
|
call will go directly to the underlying .NET method. If the object is an arbitrary
|
|
callable object we will setup a nested dynamic site for performing the additional
|
|
dispatch.
|
|
|
|
TODO: We could probably do a specific binding to the object if it's another IDyanmicObject.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.SlotOrFunction.GetCombinedTargets(IronPython.Runtime.Binding.SlotOrFunction,IronPython.Runtime.Binding.SlotOrFunction,IronPython.Runtime.Binding.SlotOrFunction@,IronPython.Runtime.Binding.SlotOrFunction@)">
|
|
<summary>
|
|
Combines two methods, which came from two different binary types, selecting the method which has the best
|
|
set of conversions (the conversions which result in the least narrowing).
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Binding.SlotOrFunction.TryGetBinder(IronPython.Runtime.PythonContext,System.Dynamic.DynamicMetaObject[],System.String,System.String,IronPython.Runtime.Binding.SlotOrFunction@,IronPython.Runtime.Types.PythonType@)">
|
|
<summary>
|
|
Tries to get a MethodBinder associated with the slot for the specified type.
|
|
|
|
If a method is found the binder is set and true is returned.
|
|
If nothing is found binder is null and true is returned.
|
|
If something other than a method is found false is returned.
|
|
|
|
TODO: Remove rop
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.BuiltinPythonModule">
|
|
<summary>
|
|
Implements a built-in module which is instanced per PythonContext.
|
|
|
|
Implementers can subclass this type and then have a module which has efficient access
|
|
to internal state (this doesn't need to go through PythonContext.GetModuleState). These
|
|
modules can also declare module level globals which they'd like to provide efficient
|
|
access to by overloading GetGlobalVariableNames. When Initialize is called these
|
|
globals are provided and can be cached in the instance for fast global access.
|
|
|
|
Just like normal static modules these modules are registered with the PythonModuleAttribute.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.BuiltinPythonModule.Initialize(IronPython.Runtime.CodeContext,System.Collections.Generic.Dictionary{System.String,IronPython.Compiler.PythonGlobal})">
|
|
<summary>
|
|
Initializes the module for it's first usage. By default this calls PerformModuleReload with the
|
|
the dictionary.
|
|
</summary>
|
|
<param name="codeContext">The CodeContext for the module.</param>
|
|
<param name="optimizedGlobals">A list of globals which have optimize access. Contains at least all of the global variables reutrned by GetGlobalVariableNames.</param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.BuiltinPythonModule.GetGlobalVariableNames">
|
|
<summary>
|
|
Gets a list of variable names which should have optimized storage (instances of PythonGlobal objects).
|
|
The module receives the global objects during the Initialize call and can hold onto them for
|
|
direct access to global members.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.BuiltinPythonModule.PerformModuleReload">
|
|
<summary>
|
|
Called when the user attempts to reload() on your module and by the base class Initialize method.
|
|
|
|
This provides an opportunity to allocate any per-module data which is not simply function definitions.
|
|
|
|
A common usage here is to create exception objects which are allocated by the module using PythonExceptions.CreateSubType.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.BuiltinPythonModule.Context">
|
|
<summary>
|
|
Provides access to the PythonContext which this module was created for.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.BuiltinPythonModule.Globals">
|
|
<summary>
|
|
Provides access to the CodeContext for the module. Returns null before Initialize() is called.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ByteArray">
|
|
<summary>
|
|
bytearray(string, encoding[, errors]) -> bytearray
|
|
bytearray(iterable) -> bytearray
|
|
|
|
Construct a mutable bytearray object from:
|
|
- an iterable yielding values in range(256), including:
|
|
+ a list of integer values
|
|
+ a bytes, bytearray, buffer, or array object
|
|
- a text string encoded using the specified encoding
|
|
|
|
bytearray([int]) -> bytearray
|
|
|
|
Construct a zero-ititialized bytearray of the specified length.
|
|
(default=0)
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ByteArray.istitle">
|
|
<summary>
|
|
return true if self is a titlecased string and there is at least one
|
|
character in self; also, uppercase characters may only follow uncased
|
|
characters (e.g. whitespace) and lowercase characters only cased ones.
|
|
return false otherwise.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ByteArray.join(System.Object)">
|
|
<summary>
|
|
Return a string which is the concatenation of the strings
|
|
in the sequence seq. The separator between elements is the
|
|
string providing this method
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ByteArray.op_Addition(IronPython.Runtime.ByteArray,System.String)">
|
|
<summary>
|
|
This overload is specifically implemented because in IronPython strings are unicode
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Bytes.istitle">
|
|
<summary>
|
|
return true if self is a titlecased string and there is at least one
|
|
character in self; also, uppercase characters may only follow uncased
|
|
characters (e.g. whitespace) and lowercase characters only cased ones.
|
|
return false otherwise.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Bytes.join(System.Object)">
|
|
<summary>
|
|
Return a string which is the concatenation of the strings
|
|
in the sequence seq. The separator between elements is the
|
|
string providing this method
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Bytes.ToByteArray">
|
|
<summary>
|
|
Returns a copy of the internal byte array.
|
|
</summary>
|
|
<returns>
|
|
System.Byte[]
|
|
</returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Bytes.GetUnsafeByteArray">
|
|
<summary>
|
|
This method returns the underlying byte array directly.
|
|
It should be used sparingly!
|
|
</summary>
|
|
<returns>
|
|
System.Byte[]
|
|
</returns>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ClassMethodAttribute">
|
|
<summary>
|
|
Marks a method as being a class method. The PythonType which was used to access
|
|
the method will then be passed as the first argument.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ClrModule">
|
|
<summary>
|
|
this class contains objecs and static methods used for
|
|
.NET/CLS interop with Python.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.GetCurrentRuntime(IronPython.Runtime.CodeContext)">
|
|
<summary>
|
|
Gets the current ScriptDomainManager that IronPython is loaded into. The
|
|
ScriptDomainManager can then be used to work with the language portion of the
|
|
DLR hosting APIs.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.Use(IronPython.Runtime.CodeContext,System.String)">
|
|
<summary>
|
|
Use(name) -> module
|
|
|
|
Attempts to load the specified module searching all languages in the loaded ScriptRuntime.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.Use(IronPython.Runtime.CodeContext,System.String,System.String)">
|
|
<summary>
|
|
Use(path, language) -> module
|
|
|
|
Attempts to load the specified module belonging to a specific language loaded into the
|
|
current ScriptRuntime.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.SetCommandDispatcher(IronPython.Runtime.CodeContext,System.Action{System.Action})">
|
|
<summary>
|
|
SetCommandDispatcher(commandDispatcher)
|
|
|
|
Sets the current command dispatcher for the Python command line.
|
|
|
|
The command dispatcher will be called with a delegate to be executed. The command dispatcher
|
|
should invoke the target delegate in the desired context.
|
|
|
|
A common use for this is to enable running all REPL commands on the UI thread while the REPL
|
|
continues to run on a non-UI thread.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.LoadTypeLibrary(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
LoadTypeLibrary(rcw) -> type lib desc
|
|
|
|
Gets an ITypeLib object from OLE Automation compatible RCW ,
|
|
reads definitions of CoClass'es and Enum's from this library
|
|
and creates an object that allows to instantiate coclasses
|
|
and get actual values for the enums.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.LoadTypeLibrary(IronPython.Runtime.CodeContext,System.Guid)">
|
|
<summary>
|
|
LoadTypeLibrary(guid) -> type lib desc
|
|
|
|
Reads the latest registered type library for the corresponding GUID,
|
|
reads definitions of CoClass'es and Enum's from this library
|
|
and creates a IDynamicMetaObjectProvider that allows to instantiate coclasses
|
|
and get actual values for the enums.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.AddReferenceToTypeLibrary(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
AddReferenceToTypeLibrary(rcw) -> None
|
|
|
|
Makes the type lib desc available for importing. See also LoadTypeLibrary.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.AddReferenceToTypeLibrary(IronPython.Runtime.CodeContext,System.Guid)">
|
|
<summary>
|
|
AddReferenceToTypeLibrary(guid) -> None
|
|
|
|
Makes the type lib desc available for importing. See also LoadTypeLibrary.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.GetClrType(System.Type)">
|
|
<summary>
|
|
Gets the CLR Type object from a given Python type object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.GetPythonType(System.Type)">
|
|
<summary>
|
|
Gets the Python type object from a given CLR Type object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.GetDynamicType(System.Type)">
|
|
<summary>
|
|
OBSOLETE: Gets the Python type object from a given CLR Type object.
|
|
|
|
Use clr.GetPythonType instead.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.accepts(System.Object[])">
|
|
<summary>
|
|
accepts(*types) -> ArgChecker
|
|
|
|
Decorator that returns a new callable object which will validate the arguments are of the specified types.
|
|
</summary>
|
|
<param name="types"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.returns(System.Object)">
|
|
<summary>
|
|
returns(type) -> ReturnChecker
|
|
|
|
Returns a new callable object which will validate the return type is of the specified type.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ClrModule.ArgChecker">
|
|
<summary>
|
|
Decorator for verifying the arguments to a function are of a specified type.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ClrModule.RuntimeArgChecker">
|
|
<summary>
|
|
Returned value when using clr.accepts/ArgChecker. Validates the argument types and
|
|
then calls the original function.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ClrModule.ReturnChecker">
|
|
<summary>
|
|
Decorator for verifying the return type of functions.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ClrModule.RuntimeReturnChecker">
|
|
<summary>
|
|
Returned value when using clr.returns/ReturnChecker. Calls the original function and
|
|
validates the return type is of a specified type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.Dir(System.Object)">
|
|
<summary>
|
|
returns the result of dir(o) as-if "import clr" has not been performed.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.DirClr(System.Object)">
|
|
<summary>
|
|
Returns the result of dir(o) as-if "import clr" has been performed.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.Convert(IronPython.Runtime.CodeContext,System.Object,System.Type)">
|
|
<summary>
|
|
Attempts to convert the provided object to the specified type. Conversions that
|
|
will be attempted include standard Python conversions as well as .NET implicit
|
|
and explicit conversions.
|
|
|
|
If the conversion cannot be performed a TypeError will be raised.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.CompileModules(IronPython.Runtime.CodeContext,System.String,System.Collections.Generic.IDictionary{System.String,System.Object},System.String[])">
|
|
<summary>
|
|
Provides a helper for compiling a group of modules into a single assembly. The assembly can later be
|
|
reloaded using the clr.AddReference API.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.CompileSubclassTypes(System.String,System.Object[])">
|
|
<summary>
|
|
clr.CompileSubclassTypes(assemblyName, *typeDescription)
|
|
|
|
Provides a helper for creating an assembly which contains pre-generated .NET
|
|
base types for new-style types.
|
|
|
|
This assembly can then be AddReferenced or put sys.prefix\DLLs and the cached
|
|
types will be used instead of generating the types at runtime.
|
|
|
|
This function takes the name of the assembly to save to and then an arbitrary
|
|
number of parameters describing the types to be created. Each of those
|
|
parameter can either be a plain type or a sequence of base types.
|
|
|
|
clr.CompileSubclassTypes(object) -> create a base type for object
|
|
clr.CompileSubclassTypes(object, str, System.Collections.ArrayList) -> create
|
|
base types for both object and ArrayList.
|
|
|
|
clr.CompileSubclassTypes(object, (object, IComparable)) -> create base types for
|
|
object and an object which implements IComparable.
|
|
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.GetSubclassedTypes">
|
|
<summary>
|
|
clr.GetSubclassedTypes() -> tuple
|
|
|
|
Returns a tuple of information about the types which have been subclassed.
|
|
|
|
This tuple can be passed to clr.CompileSubclassTypes to cache these
|
|
types on disk such as:
|
|
|
|
clr.CompileSubclassTypes('assembly', *clr.GetSubclassedTypes())
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ClrModule.FileStreamContentProvider">
|
|
<summary>
|
|
Provides a StreamContentProvider for a stream of content backed by a file on disk.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.BuildPackageMap(System.String[])">
|
|
<summary>
|
|
Goes through the list of files identifying the relationship between packages
|
|
and subpackages. Returns a dictionary with all of the package filenames (minus __init__.py)
|
|
mapping to their full name. For example given a structure:
|
|
|
|
C:\
|
|
someDir\
|
|
package\
|
|
__init__.py
|
|
a.py
|
|
b\
|
|
__init.py
|
|
c.py
|
|
|
|
Returns:
|
|
{r'C:\somedir\package' : 'package', r'C:\somedir\package\b', 'package.b'}
|
|
|
|
This can then be used for calculating the full module name of individual files
|
|
and packages. For example a's full name is "package.a" and c's full name is
|
|
"package.b.c".
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.GetProfilerData(IronPython.Runtime.CodeContext,System.Boolean)">
|
|
<summary>
|
|
Returns a list of profile data. The values are tuples of Profiler.Data objects
|
|
|
|
All times are expressed in the same unit of measure as DateTime.Ticks
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.ClearProfilerData(IronPython.Runtime.CodeContext)">
|
|
<summary>
|
|
Resets all profiler counters back to zero
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.EnableProfiler(IronPython.Runtime.CodeContext,System.Boolean)">
|
|
<summary>
|
|
Enable or disable profiling for the current ScriptEngine. This will only affect code
|
|
that is compiled after the setting is changed; previously-compiled code will retain
|
|
whatever setting was active when the code was originally compiled.
|
|
|
|
The easiest way to recompile a module is to reload() it.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.Serialize(System.Object)">
|
|
<summary>
|
|
Serializes data using the .NET serialization formatter for complex
|
|
types. Returns a tuple identifying the serialization format and the serialized
|
|
data which can be fed back into clr.Deserialize.
|
|
|
|
Current serialization formats include custom formats for primitive .NET
|
|
types which aren't already recognized as tuples. None is used to indicate
|
|
that the Binary .NET formatter is used.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ClrModule.Deserialize(System.String,System.String)">
|
|
<summary>
|
|
Deserializes the result of a Serialize call. This can be used to perform serialization
|
|
for .NET types which are serializable. This method is the callable object provided
|
|
from __reduce_ex__ for .serializable .NET types.
|
|
|
|
The first parameter indicates the serialization format and is the first tuple element
|
|
returned from the Serialize call.
|
|
|
|
The second parameter is the serialized data.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.CodeContext">
|
|
<summary>
|
|
Captures and flows the state of executing code from the generated
|
|
Python code into the IronPython runtime.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CodeContext.#ctor(IronPython.Runtime.PythonDictionary,IronPython.Runtime.ModuleContext)">
|
|
<summary>
|
|
Creates a new CodeContext which is backed by the specified Python dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.CodeContext.ModuleContext">
|
|
<summary>
|
|
Gets the module state for top-level code.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.CodeContext.GlobalScope">
|
|
<summary>
|
|
Gets the DLR scope object that corresponds to the global variables of this context.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.CodeContext.LanguageContext">
|
|
<summary>
|
|
Gets the PythonContext which created the CodeContext.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.CodeContext.GlobalDict">
|
|
<summary>
|
|
Gets the dictionary for the global variables from the ModuleContext.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.CodeContext.ShowCls">
|
|
<summary>
|
|
True if this global context should display CLR members on shared types (for example .ToString on int/bool/etc...)
|
|
|
|
False if these attributes should be hidden.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CodeContext.TryLookupName(System.String,System.Object@)">
|
|
<summary>
|
|
Attempts to lookup the provided name in this scope or any outer scope.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CodeContext.TryLookupBuiltin(System.String,System.Object@)">
|
|
<summary>
|
|
Looks up a global variable. If the variable is not defined in the
|
|
global scope then built-ins is consulted.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.CodeContext.Dict">
|
|
<summary>
|
|
Gets the dictionary used for storage of local variables.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CodeContext.TryGetVariable(System.String,System.Object@)">
|
|
<summary>
|
|
Attempts to lookup the variable in the local scope.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CodeContext.TryRemoveVariable(System.String)">
|
|
<summary>
|
|
Removes a variable from the local scope.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CodeContext.SetVariable(System.String,System.Object)">
|
|
<summary>
|
|
Sets a variable in the local scope.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CodeContext.TryGetGlobalVariable(System.String,System.Object@)">
|
|
<summary>
|
|
Gets a variable from the global scope.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CodeContext.SetGlobalVariable(System.String,System.Object)">
|
|
<summary>
|
|
Sets a variable in the global scope.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CodeContext.TryRemoveGlobalVariable(System.String)">
|
|
<summary>
|
|
Removes a variable from the global scope.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CodeContext.GetBuiltinsDict">
|
|
<summary>
|
|
Returns the dictionary associated with __builtins__ if one is
|
|
set or null if it's not available. If __builtins__ is a module
|
|
the module's dictionary is returned.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.CommonDictionaryStorage">
|
|
<summary>
|
|
General purpose storage used for most PythonDictionarys.
|
|
|
|
This dictionary storage is thread safe for multiple readers or writers.
|
|
|
|
Mutations to the dictionary involves a simple locking strategy of
|
|
locking on the DictionaryStorage object to ensure that only one
|
|
mutation happens at a time.
|
|
|
|
Reads against the dictionary happen lock free. When the dictionary is mutated
|
|
it is either adding or removing buckets in a thread-safe manner so that the readers
|
|
will either see a consistent picture as if the read occured before or after the mutation.
|
|
|
|
When resizing the dictionary the buckets are replaced atomically so that the reader
|
|
sees the new buckets or the old buckets. When reading the reader first reads
|
|
the buckets and then calls a static helper function to do the read from the bucket
|
|
array to ensure that readers are not seeing multiple bucket arrays.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.#ctor">
|
|
<summary>
|
|
Creates a new dictionary storage with no buckets
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.#ctor(System.Int32)">
|
|
<summary>
|
|
Creates a new dictionary storage with no buckets
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.#ctor(System.Object[],System.Boolean)">
|
|
<summary>
|
|
Creates a new dictionary geting values/keys from the
|
|
items arary
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.#ctor(IronPython.Runtime.CommonDictionaryStorage.Bucket[],System.Int32,System.Type,System.Func{System.Object,System.Int32},System.Func{System.Object,System.Object,System.Boolean},IronPython.Runtime.CommonDictionaryStorage.NullValue)">
|
|
<summary>
|
|
Creates a new dictionary storage with the given set of buckets
|
|
and size. Used when cloning the dictionary storage.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.Add(System.Object,System.Object)">
|
|
<summary>
|
|
Adds a new item to the dictionary, replacing an existing one if it already exists.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.Initialize">
|
|
<summary>
|
|
Initializes the buckets to their initial capacity, the caller
|
|
must check if the buckets are empty first.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.Add(IronPython.Runtime.CommonDictionaryStorage.Bucket[],System.Object,System.Object)">
|
|
<summary>
|
|
Add helper that works over a single set of buckets. Used for
|
|
both the normal add case as well as the resize case.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.AddWorker(IronPython.Runtime.CommonDictionaryStorage.Bucket[],System.Object,System.Object,System.Int32)">
|
|
<summary>
|
|
Add helper which adds the given key/value (where the key is not null) with
|
|
a pre-computed hash code.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.Remove(IronPython.Runtime.DictionaryStorage@,System.Object)">
|
|
<summary>
|
|
Removes an entry from the dictionary and returns true if the
|
|
entry was removed or false.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.RemoveAlwaysHash(System.Object)">
|
|
<summary>
|
|
Removes an entry from the dictionary and returns true if the
|
|
entry was removed or false. The key will always be hashed
|
|
so if it is unhashable an exception will be thrown - even
|
|
if the dictionary has no buckets.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.Contains(System.Object)">
|
|
<summary>
|
|
Checks to see if the key exists in the dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.TryGetValue(System.Object,System.Object@)">
|
|
<summary>
|
|
Trys to get the value associated with the given key and returns true
|
|
if it's found or false if it's not present.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.TryGetValue(IronPython.Runtime.CommonDictionaryStorage.Bucket[],System.Object,System.Object@)">
|
|
<summary>
|
|
Static helper to try and get the value from the dictionary.
|
|
|
|
Used so the value lookup can run against a buckets while a writer
|
|
replaces the buckets.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.CommonDictionaryStorage.Count">
|
|
<summary>
|
|
Returns the number of key/value pairs currently in the dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.Clear(IronPython.Runtime.DictionaryStorage@)">
|
|
<summary>
|
|
Clears the contents of the dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.Clone">
|
|
<summary>
|
|
Clones the storage returning a new DictionaryStorage object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CommonDictionaryStorage.Hash(System.Object)">
|
|
<summary>
|
|
Helper to hash the given key w/ support for null.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.CommonDictionaryStorage.Bucket">
|
|
<summary>
|
|
Used to store a single hashed key/value.
|
|
|
|
Bucket is not serializable because it stores the computed hash
|
|
code which could change between serialization and deserialization.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.CommonDictionaryStorage.DeserializationNullValue">
|
|
<summary>
|
|
Special marker NullValue used during deserialization to not add
|
|
an extra field to the dictionary storage type.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ConstantDictionaryStorage">
|
|
<summary>
|
|
Copy on write constant dictionary storage used for dictionaries created with constant items.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Converter.TryConvert(System.Object,System.Type,System.Object@)">
|
|
<summary>
|
|
General conversion routine TryConvert - tries to convert the object to the desired type.
|
|
Try to avoid using this method, the goal is to ultimately remove it!
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Converter.TryConvertToIEnumerator(System.Object,System.Collections.IEnumerator@)">
|
|
<summary>
|
|
This function tries to convert an object to IEnumerator, or wraps it into an adapter
|
|
Do not use this function directly. It is only meant to be used by Ops.GetEnumerator.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Converter.ConvertToIEnumerator(System.Object)">
|
|
<summary>
|
|
This function tries to convert an object to IEnumerator, or wraps it into an adapter
|
|
Do not use this function directly. It is only meant to be used by Ops.GetEnumerator.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Converter.TryConvertToIndex(System.Object,System.Boolean,System.Int32@)">
|
|
<summary>
|
|
Attempts to convert value into a index usable for slicing and return the integer
|
|
value. If the conversion fails false is returned.
|
|
|
|
If throwOverflowError is true then BigInteger's outside the normal range of integers will
|
|
result in an OverflowError.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Converter.TryConvertToIndex(System.Object,System.Boolean,System.Object@)">
|
|
<summary>
|
|
Attempts to convert value into a index usable for slicing and return the integer
|
|
value. If the conversion fails false is returned.
|
|
|
|
If throwOverflowError is true then BigInteger's outside the normal range of integers will
|
|
result in an OverflowError.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Converter.ImplicitConvertToInt32(System.Object)">
|
|
<summary>
|
|
Converts a value to int ignoring floats
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CustomDictionaryStorage.GetExtraItems">
|
|
<summary>
|
|
Gets all of the extra names and values stored in the dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CustomDictionaryStorage.TrySetExtraValue(System.String,System.Object)">
|
|
<summary>
|
|
Attemps to sets a value in the extra keys. Returns true if the value is set, false if
|
|
the value is not an extra key.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CustomDictionaryStorage.TryGetExtraValue(System.String,System.Object@)">
|
|
<summary>
|
|
Attempts to get a value from the extra keys. Returns true if the value is an extra
|
|
key and has a value. False if it is not an extra key or doesn't have a value.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.CustomDictionaryStorage.TryRemoveExtraValue(System.String)">
|
|
<summary>
|
|
Attempts to remove the key. Returns true if the key is removed, false
|
|
if the key was not removed, or null if the key is not an extra key.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.DebuggerDictionaryStorage">
|
|
<summary>
|
|
Adapts an IDictionary[object, object] for use as a PythonDictionary used for
|
|
our debug frames. Also hides the special locals which start with $.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.DictionaryOps">
|
|
<summary>
|
|
Provides both helpers for implementing Python dictionaries as well
|
|
as providing public methods that should be exposed on all dictionary types.
|
|
|
|
Currently these are published on IDictionary<object, object>
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.DictionaryStorage">
|
|
<summary>
|
|
Abstract base class for all PythonDictionary storage.
|
|
|
|
Defined as a class instead of an interface for performance reasons. Also not
|
|
using IDictionary* for keeping a simple interface.
|
|
|
|
Full locking is defined as being on the DictionaryStorage object it's self,
|
|
not an internal member. This enables subclasses to provide their own locking
|
|
aruond large operations and call lock free functions.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.DictionaryStorage.CopyTo(IronPython.Runtime.DictionaryStorage@)">
|
|
<summary>
|
|
Adds items from this dictionary into the other dictionary
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.DictionaryStorage.TryGetPath(System.Object@)">
|
|
<summary>
|
|
Provides fast access to the __path__ attribute if the dictionary storage supports caching it.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.DictionaryStorage.TryGetPackage(System.Object@)">
|
|
<summary>
|
|
Provides fast access to the __package__ attribute if the dictionary storage supports caching it.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.DictionaryStorage.TryGetBuiltins(System.Object@)">
|
|
<summary>
|
|
Provides fast access to the __builtins__ attribute if the dictionary storage supports caching it.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.DictionaryStorage.TryGetName(System.Object@)">
|
|
<summary>
|
|
Provides fast access to the __name__ attribute if the dictionary storage supports caching it.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.DictionaryStorage.TryGetImport(System.Object@)">
|
|
<summary>
|
|
Provides fast access to the __import__ attribute if the dictionary storage supports caching it.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.DontMapGetMemberNamesToDirAttribute">
|
|
<summary>
|
|
Marks a type so that IronPython will not expose types which have GetMemberNames
|
|
as having a __dir__ method.
|
|
|
|
Also suppresses __dir__ on something which implements IDynamicMetaObjectProvider
|
|
but is not an IPythonObject.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.DontMapICollectionToLenAttribute">
|
|
<summary>
|
|
Marks a type so that IronPython will not expose the ICollection interface out as
|
|
__len__.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.DontMapIDisposableToContextManagerAttribute">
|
|
<summary>
|
|
Marks a type so that IronPython will not expose the IDisposable interface out as
|
|
__enter__ and __exit__ methods of a context manager.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.DontMapIEnumerableToContainsAttribute">
|
|
<summary>
|
|
Marks a type so that IronPython will not expose the IEnumerable interface out as
|
|
__contains__
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.DontMapIEnumerableToIterAttribute">
|
|
<summary>
|
|
Marks a type so that IronPython will not expose the IEnumerable interface out as
|
|
__iter__
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.EmptyDictionaryStorage">
|
|
<summary>
|
|
Singleton used for dictionaries which contain no items.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Exceptions.GeneratorExitException">
|
|
<summary>
|
|
GeneratorExitException is a standard exception raised by Generator.Close() to allow a caller
|
|
to close out a generator.
|
|
</summary>
|
|
<remarks>GeneratorExit is introduced in Pep342 for Python2.5. </remarks>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Exceptions.IndentationException">
|
|
<summary>
|
|
.NET exception thrown when a Python syntax error is related to incorrect indentation.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Exceptions.PythonExceptions">
|
|
<summary>
|
|
Implementation of the Python exceptions module and the IronPython/CLR exception mapping
|
|
mechanism. The exception module is the parent module for all Python exception classes
|
|
and therefore is built-in to IronPython.dll instead of IronPython.Modules.dll.
|
|
|
|
The exception mapping mechanism is exposed as internal surface area available to only
|
|
IronPython / IronPython.Modules.dll. The actual exceptions themselves are all public.
|
|
|
|
Because the oddity of the built-in exception types all sharing the same physical layout
|
|
(see also PythonExceptions.BaseException) some classes are defined as classes w/ their
|
|
proper name and some classes are defined as PythonType fields. When a class is defined
|
|
for convenience their's also an _TypeName version which is the PythonType.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Exceptions.PythonExceptions.BaseException">
|
|
<summary>
|
|
Base class for all Python exception objects.
|
|
|
|
When users throw exceptions they typically throw an exception which is
|
|
a subtype of this. A mapping is maintained between Python exceptions
|
|
and .NET exceptions and a corresponding .NET exception is thrown which
|
|
is associated with the Python exception. This class represents the
|
|
base class for the Python exception hierarchy.
|
|
|
|
Users can catch exceptions rooted in either hierarchy. The hierarchy
|
|
determines whether the user catches the .NET exception object or the
|
|
Python exception object.
|
|
|
|
Most built-in Python exception classes are actually instances of the BaseException
|
|
class here. This is important because in CPython the exceptions do not
|
|
add new members and therefore their layouts are compatible for multiple
|
|
inheritance. The exceptions to this rule are the classes which define
|
|
their own fields within their type, therefore altering their layout:
|
|
EnvironmentError
|
|
SyntaxError
|
|
IndentationError (same layout as SyntaxError)
|
|
TabError (same layout as SyntaxError)
|
|
SystemExit
|
|
UnicodeDecodeError
|
|
UnicodeEncodeError
|
|
UnicodeTranslateError
|
|
|
|
These exceptions cannot be combined in multiple inheritance, e.g.:
|
|
class foo(EnvironmentError, IndentationError): pass
|
|
|
|
fails but they can be combined with anything which is just a BaseException:
|
|
class foo(UnicodeDecodeError, SystemError): pass
|
|
|
|
Therefore the majority of the classes are just BaseException instances with a
|
|
custom PythonType object. The specialized ones have their own .NET class
|
|
which inherits from BaseException. User defined exceptions likewise inherit
|
|
from this and have their own .NET class.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__init__(System.Object[])">
|
|
<summary>
|
|
Initializes the Exception object with an unlimited number of arguments
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.message">
|
|
<summary>
|
|
Returns the exception 'message' if only a single argument was provided
|
|
during creation or an empty string.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.args">
|
|
<summary>
|
|
Gets or sets the arguments used for creating the exception
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__reduce__">
|
|
<summary>
|
|
Returns a tuple of (type, (arg0, ..., argN)) for implementing pickling/copying
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__reduce_ex__(System.Int32)">
|
|
<summary>
|
|
Returns a tuple of (type, (arg0, ..., argN)) for implementing pickling/copying
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.Item(System.Int32)">
|
|
<summary>
|
|
Gets the nth member of the args property
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__dict__">
|
|
<summary>
|
|
Gets or sets the dictionary which is used for storing members not declared to have space reserved
|
|
within the exception object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__setstate__(IronPython.Runtime.PythonDictionary)">
|
|
<summary>
|
|
Updates the exception's state (dictionary) with the new values
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.clsException">
|
|
<summary>
|
|
Gets the CLR exception associated w/ this Python exception. Not visible
|
|
until a .NET namespace is imported.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.GetBoundMember(System.String)">
|
|
<summary>
|
|
Provides custom member lookup access that fallbacks to the dictionary
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.SetMemberAfter(System.String,System.Object)">
|
|
<summary>
|
|
Provides custom member assignment which stores values in the dictionary
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.DeleteCustomMember(System.String)">
|
|
<summary>
|
|
Provides custom member deletion which deletes values from the dictionary
|
|
or allows clearing 'message'.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.__repr__(IronPython.Runtime.CodeContext)">
|
|
<summary>
|
|
Implements __repr__ which returns the type name + the args
|
|
tuple code formatted.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.InitializeFromClr(System.Exception)">
|
|
<summary>
|
|
Initializes the Python exception from a .NET exception
|
|
</summary>
|
|
<param name="exception"></param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.BaseException.GetClrException">
|
|
<summary>
|
|
Helper to get the CLR exception associated w/ this Python exception
|
|
creating it if one has not already been created.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateThrowableForRaise(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.Object)">
|
|
<summary>
|
|
Creates a new throwable exception of type type where the type is an new-style exception.
|
|
|
|
Used at runtime when creating the exception from a user provided type via the raise statement.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateThrowableForRaise(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.OldClass,System.Object)">
|
|
<summary>
|
|
Creates a throwable exception of type type where the type is an OldClass.
|
|
|
|
Used at runtime when creating the exception form a user provided type that's an old class (via the raise statement).
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.ToClr(System.Object)">
|
|
<summary>
|
|
Returns the CLR exception associated with a Python exception
|
|
creating a new exception if necessary
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.ToPython(System.Exception)">
|
|
<summary>
|
|
Given a CLR exception returns the Python exception which most closely maps to the CLR exception.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.ToPythonNewStyle(System.Exception)">
|
|
<summary>
|
|
Creates a new style Python exception from the .NET exception
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.SetPythonException(System.Exception,System.Object)">
|
|
<summary>
|
|
Internal helper to associate a .NET exception and a Python exception.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.GetPythonException(System.Exception)">
|
|
<summary>
|
|
Internal helper to get the associated Python exception from a .NET exception.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.SyntaxErrorToPython(Microsoft.Scripting.SyntaxErrorException)">
|
|
<summary>
|
|
Converts the DLR SyntaxErrorException into a Python new-style SyntaxError instance.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
|
|
<summary>
|
|
Creates a PythonType for a built-in module. These types are mutable like
|
|
normal user types.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType,System.Type,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
|
|
<summary>
|
|
Creates a PythonType for a built-in module. These types are mutable like
|
|
normal user types.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType[],System.Type,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
|
|
<summary>
|
|
Creates a PythonType for a built-in module, where the type may inherit
|
|
from multiple bases. These types are mutable like normal user types.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.Types.PythonType,System.String,System.Func{System.String,System.Exception})">
|
|
<summary>
|
|
Creates a new type for a built-in exception which derives from another Python
|
|
type. . These types are built-in and immutable like any other normal type. For
|
|
example StandardError.x = 3 is illegal. This isn't for module exceptions which
|
|
are like user defined types. thread.error.x = 3 is legal.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.CreateSubType(IronPython.Runtime.Types.PythonType,System.Type,System.Func{System.String,System.Exception})">
|
|
<summary>
|
|
Creates a new type for a built-in exception which is the root concrete type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.PythonExceptions.GetDynamicStackFrames(System.Exception)">
|
|
<summary>
|
|
Gets the list of DynamicStackFrames for the current exception.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Exceptions.StopIterationException">
|
|
<summary>
|
|
.NET exception that is thrown to signal the end of iteration in Python
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Exceptions.SystemExitException">
|
|
<summary>
|
|
.NET exception that is thrown to shutdown the interpretter and exit the system.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.SystemExitException.GetExitCode(System.Object@)">
|
|
<summary>
|
|
Result of sys.exit(n)
|
|
</summary>
|
|
<param name="otherCode">
|
|
null if the script exited using "sys.exit(int_value)"
|
|
null if the script exited using "sys.exit(None)"
|
|
x if the script exited using "sys.exit(x)" where isinstance(x, int) == False
|
|
</param>
|
|
<returns>
|
|
int_value if the script exited using "sys.exit(int_value)"
|
|
1 otherwise
|
|
</returns>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Exceptions.TabException">
|
|
<summary>
|
|
.NET Exception thrown when a Python syntax error is related to incorrect tabs.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Exceptions.TraceBack.Extract">
|
|
<summary>
|
|
returns string containing human readable representation of traceback
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ExtensionMethodSet">
|
|
<summary>
|
|
Represents the set of extension methods which are loaded into a module.
|
|
|
|
This set is immutable (as far the external viewer is considered). When a
|
|
new extension method set is loaded into a module we create a new ExtensionMethodsSet object.
|
|
|
|
Multiple modules which have the same set of extension methods use the same set.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ExtensionMethodSet.AssemblyLoadInfo">
|
|
<summary>
|
|
Tracks the extension types that are loaded for a given assembly.
|
|
|
|
We can have either types, namespaces, or a full assembly added as a reference.
|
|
|
|
When the user just adds types we just add them to the type hash set.
|
|
|
|
When the user adds namespaces we add them to the namespaces hashset. On the
|
|
next lookup we'll lazily load the types from that namespace and put them in Types.
|
|
|
|
When the user adds assemblies we set the value to the NotYetLoadedButFullAssembly
|
|
value. The next load request will load the types from that namespace and put them
|
|
in Types. When we do that we'll mark the assembly as FullyLoaded so we don't
|
|
have to go through that again if the user adds a namespace.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ExtensionMethodSet.GetExtensionMethods(System.String)">
|
|
<summary>
|
|
Returns all of the extension methods with the given name.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ExtensionMethodSet.GetExtensionMethods(IronPython.Runtime.Types.PythonType)">
|
|
<summary>
|
|
Returns all of the extension methods which are applicable for the given type.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FormattingHelper.InvariantCommaNumberInfo">
|
|
<summary>
|
|
Helper NumberFormatInfo for use by int/BigInteger __format__ routines
|
|
for width specified leading zero support that contains ','s every 3 digits.
|
|
i.e. For use by d/g/G format specifiers. NOT for use by n format specifiers.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.FunctionAttributes.ArgumentList">
|
|
<summary>
|
|
Set if the function includes a *args argument list.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.FunctionAttributes.KeywordDictionary">
|
|
<summary>
|
|
Set if the function includes a **kwargs argument dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.FunctionAttributes.Generator">
|
|
<summary>
|
|
Set if the function is a generator.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.FunctionAttributes.FutureDivision">
|
|
<summary>
|
|
Set if the function was compiled with future division.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.FunctionAttributes.CanSetSysExcInfo">
|
|
<summary>
|
|
IronPython specific: Set if the function includes nested exception handling and therefore can alter
|
|
sys.exc_info().
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.FunctionAttributes.ContainsTryFinally">
|
|
<summary>
|
|
IronPython specific: Set if the function includes a try/finally block.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.FunctionCode">
|
|
<summary>
|
|
Represents a piece of code. This can reference either a CompiledCode
|
|
object or a Function. The user can explicitly call FunctionCode by
|
|
passing it into exec or eval.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.FunctionCode._CodeCreateAndUpdateDelegateLock">
|
|
<summary>
|
|
This is both the lock that is held while enumerating the threads or updating the thread accounting
|
|
information. It's also a marker CodeList which is put in place when we are enumerating the thread
|
|
list and all additions need to block.
|
|
|
|
This lock is also acquired whenever we need to calculate how a function's delegate should be created
|
|
so that we don't race against sys.settrace/sys.setprofile.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.FunctionCode.#ctor(IronPython.Runtime.PythonContext,System.Delegate,IronPython.Compiler.Ast.ScopeStatement,System.String,System.Int32)">
|
|
<summary>
|
|
Constructor used to create a FunctionCode for code that's been serialized to disk.
|
|
|
|
Code constructed this way cannot be interpreted or debugged using sys.settrace/sys.setprofile.
|
|
|
|
Function codes created this way do support recursion enforcement and are therefore registered in the global function code registry.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.FunctionCode.#ctor(IronPython.Runtime.PythonContext,System.Delegate,IronPython.Compiler.Ast.ScopeStatement,System.String,System.Nullable{System.Boolean},System.Boolean)">
|
|
<summary>
|
|
Constructor to create a FunctionCode at runtime.
|
|
|
|
Code constructed this way supports both being interpreted and debugged. When necessary the code will
|
|
be re-compiled or re-interpreted for that specific purpose.
|
|
|
|
Function codes created this way do support recursion enforcement and are therefore registered in the global function code registry.
|
|
|
|
the initial delegate provided here should NOT be the actual code. It should always be a delegate which updates our Target lazily.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.FunctionCode.RegisterFunctionCode(IronPython.Runtime.PythonContext)">
|
|
<summary>
|
|
Registers the current function code in our global weak list of all function codes.
|
|
|
|
The weak list can be enumerated with GetAllCode().
|
|
|
|
Ultimately there are 3 types of threads we care about races with:
|
|
1. Other threads which are registering function codes
|
|
2. Threads calling sys.settrace which require the world to stop and get updated
|
|
3. Threads running cleanup (thread pool thread, or call to gc.collect).
|
|
|
|
The 1st two must have perfect synchronization. We cannot have a thread registering
|
|
a new function which another thread is trying to update all of the functions in the world. Doing
|
|
so would mean we could miss adding tracing to a thread.
|
|
|
|
But the cleanup thread can run in parallel to either registrying or sys.settrace. The only
|
|
thing it needs to take a lock for is updating our accounting information about the
|
|
number of code objects are alive.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.FunctionCode.GetAllCode(IronPython.Runtime.PythonContext)">
|
|
<summary>
|
|
Enumerates all function codes for updating the current type of targets we generate.
|
|
|
|
While enumerating we hold a lock so that users cannot change sys.settrace/sys.setprofile
|
|
until the lock is released.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FunctionCode.co_cellvars">
|
|
<summary>
|
|
Returns a list of variable names which are accessed from nested functions.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FunctionCode.co_code">
|
|
<summary>
|
|
Returns the byte code. IronPython does not implement this and always
|
|
returns an empty string for byte code.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FunctionCode.co_consts">
|
|
<summary>
|
|
Returns a list of constants used by the function.
|
|
|
|
The first constant is the doc string, or None if no doc string is provided.
|
|
|
|
IronPython currently does not include any other constants than the doc string.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FunctionCode.co_filename">
|
|
<summary>
|
|
Returns the filename that the code object was defined in.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FunctionCode.co_firstlineno">
|
|
<summary>
|
|
Returns the 1st line number of the code object.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FunctionCode.co_flags">
|
|
<summary>
|
|
Returns a set of flags for the function.
|
|
|
|
0x04 is set if the function used *args
|
|
0x08 is set if the function used **args
|
|
0x20 is set if the function is a generator
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FunctionCode.co_freevars">
|
|
<summary>
|
|
Returns a list of free variables (variables accessed
|
|
from an outer scope). This does not include variables
|
|
accessed in the global scope.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FunctionCode.co_lnotab">
|
|
<summary>
|
|
Returns a mapping between byte code and line numbers. IronPython does
|
|
not implement this because byte code is not available.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FunctionCode.co_name">
|
|
<summary>
|
|
Returns the name of the code (function name, class name, or <module>).
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FunctionCode.co_names">
|
|
<summary>
|
|
Returns a list of global variable names accessed by the code.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FunctionCode.co_nlocals">
|
|
<summary>
|
|
Returns the number of local varaibles defined in the function.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.FunctionCode.co_stacksize">
|
|
<summary>
|
|
Returns the stack size. IronPython does not implement this
|
|
because byte code is not supported.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.FunctionCode.FromSourceUnit(Microsoft.Scripting.SourceUnit,IronPython.Compiler.PythonCompilerOptions,System.Boolean)">
|
|
<summary>
|
|
Creates a FunctionCode object for exec/eval/execfile'd/compile'd code.
|
|
|
|
The code is then executed in a specific CodeContext by calling the .Call method.
|
|
|
|
If the code is being used for compile (vs. exec/eval/execfile) then it needs to be
|
|
registered in case our tracing mode changes.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.FunctionCode.LazyCompileFirstTarget(IronPython.Runtime.PythonFunction)">
|
|
<summary>
|
|
Called the 1st time a function is invoked by our OriginalCallTarget* methods
|
|
over in PythonCallTargets. This computes the real delegate which needs to be
|
|
created for the function. Usually this means starting off interpretering. It
|
|
also involves adding the wrapper function for recursion enforcement.
|
|
|
|
Because this can race against sys.settrace/setprofile we need to take our
|
|
_ThreadIsEnumeratingAndAccountingLock to ensure no one is actively changing all
|
|
of the live functions.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.FunctionCode.UpdateDelegate(IronPython.Runtime.PythonContext,System.Boolean)">
|
|
<summary>
|
|
Updates the delegate based upon current Python context settings for recursion enforcement
|
|
and for tracing.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.FunctionCode.SetDebugTarget(IronPython.Runtime.PythonContext,System.Delegate)">
|
|
<summary>
|
|
Called to set the initial target delegate when the user has passed -X:Debug to enable
|
|
.NET style debugging.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.FunctionCode.GetGeneratorOrNormalLambdaTracing(IronPython.Runtime.PythonContext)">
|
|
<summary>
|
|
Gets the LambdaExpression for tracing.
|
|
|
|
If this is a generator function code then the lambda gets tranformed into the correct generator code.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.FunctionCode.GetGeneratorOrNormalLambda">
|
|
<summary>
|
|
Gets the correct final LambdaExpression for this piece of code.
|
|
|
|
This is either just _lambda or _lambda re-written to be a generator expression.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.FunctionCode.CodeList">
|
|
<summary>
|
|
Extremely light weight linked list of weak references used for tracking
|
|
all of the FunctionCode objects which get created and need to be updated
|
|
for purposes of recursion enforcement or tracing.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.PythonGenerator._active">
|
|
<summary>
|
|
True iff the thread is currently inside the generator (ie, invoking the _next delegate).
|
|
This can be used to enforce that a generator does not call back into itself.
|
|
Pep255 says that a generator should throw a ValueError if called reentrantly.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.PythonGenerator._LastFinalizer">
|
|
<summary>
|
|
We cache the GeneratorFinalizer of generators that were closed on the user
|
|
thread, and did not get finalized on the finalizer thread. We can then reuse
|
|
the object. Reusing objects with a finalizer is good because it reduces
|
|
the load on the GC's finalizer queue.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.PythonGenerator._excInfo">
|
|
<summary>
|
|
Fields set by Throw() to communicate an exception to the yield point.
|
|
These are plumbed through the generator to become parameters to Raise(...) invoked
|
|
at the yield suspension point in the generator.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.PythonGenerator._sendValue">
|
|
<summary>
|
|
Value sent by generator.send().
|
|
Since send() could send an exception, we need to keep this different from throwable's value.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonGenerator.throw(System.Object)">
|
|
<summary>
|
|
See PEP 342 (http://python.org/dev/peps/pep-0342/) for details of new methods on Generator.
|
|
Full signature including default params for throw is:
|
|
throw(type, value=None, traceback=None)
|
|
Use multiple overloads to resolve the default parameters.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonGenerator.throw(System.Object,System.Object,System.Object,System.Boolean)">
|
|
<summary>
|
|
Throw(...) is like Raise(...) being called from the yield point within the generator.
|
|
Note it must come from inside the generator so that the traceback matches, and so that it can
|
|
properly cooperate with any try/catch/finallys inside the generator body.
|
|
|
|
If the generator catches the exception and yields another value, that is the return value of g.throw().
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonGenerator.send(System.Object)">
|
|
<summary>
|
|
send() was added in Pep342. It sends a result back into the generator, and the expression becomes
|
|
the result of yield when used as an expression.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonGenerator.close(System.Boolean)">
|
|
<summary>
|
|
Close introduced in Pep 342.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonGenerator.__name__">
|
|
<summary>
|
|
Gets the name of the function that produced this generator object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonGenerator.MoveNextWorker">
|
|
<summary>
|
|
Core implementation of IEnumerator.MoveNext()
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonGenerator.NextWorker">
|
|
<summary>
|
|
Core implementation of Python's next() method.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonGenerator.CheckThrowableAndReturnSendValue">
|
|
<summary>
|
|
Helper called from PythonOps after the yield statement
|
|
Keepin this in a helper method:
|
|
- reduces generated code size
|
|
- allows better coupling with PythonGenerator.Throw()
|
|
- avoids throws from emitted code (which can be harder to debug).
|
|
</summary>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonGenerator.CheckThrowable">
|
|
<summary>
|
|
Called to throw an exception set by Throw().
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.PythonGenerator.GeneratorFlags.Closed">
|
|
<summary>
|
|
True if the generator has finished (is "closed"), else false.
|
|
Python language spec mandates that calling Next on a closed generator gracefully throws a StopIterationException.
|
|
This can never be reset.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.PythonGenerator.GeneratorFlags.CanSetSysExcInfo">
|
|
<summary>
|
|
True if the generator can set sys exc info and therefore needs exception save/restore.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Importer">
|
|
<summary>
|
|
Importer class - used for importing modules. Used by Ops and __builtin__
|
|
Singleton living on Python engine.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Importer.Import(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonTuple,System.Int32)">
|
|
<summary>
|
|
Gateway into importing ... called from Ops. Performs the initial import of
|
|
a module and returns the module.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Importer.ImportLightThrow(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonTuple,System.Int32)">
|
|
<summary>
|
|
Gateway into importing ... called from Ops. Performs the initial import of
|
|
a module and returns the module. This version returns light exceptions instead of throwing.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Importer.ImportFrom(IronPython.Runtime.CodeContext,System.Object,System.String)">
|
|
<summary>
|
|
Gateway into importing ... called from Ops. This is called after
|
|
importing the module and is used to return individual items from
|
|
the module. The outer modules dictionary is then updated with the
|
|
result.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Importer.ImportModule(IronPython.Runtime.CodeContext,System.Object,System.String,System.Boolean,System.Int32)">
|
|
<summary>
|
|
Called by the __builtin__.__import__ functions (general importing) and ScriptEngine (for site.py)
|
|
|
|
level indiciates whether to perform absolute or relative imports.
|
|
-1 indicates both should be performed
|
|
0 indicates only absolute imports should be performed
|
|
Positive numbers indicate the # of parent directories to search relative to the calling module
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Importer.TryGetNameAndPath(IronPython.Runtime.CodeContext,System.Object,System.String,System.Int32,System.String,System.String@,IronPython.Runtime.List@,IronPython.Runtime.PythonModule@)">
|
|
<summary>
|
|
Interrogates the importing module for __name__ and __path__, which determine
|
|
whether the imported module (whose name is 'name') is being imported as nested
|
|
module (__path__ is present) or as sibling.
|
|
|
|
For sibling import, the full name of the imported module is parent.sibling
|
|
For nested import, the full name of the imported module is parent.module.nested
|
|
where parent.module is the mod.__name__
|
|
</summary>
|
|
<param name="context"></param>
|
|
<param name="globals">the globals dictionary</param>
|
|
<param name="name">Name of the module to be imported</param>
|
|
<param name="full">Output - full name of the module being imported</param>
|
|
<param name="path">Path to use to search for "full"</param>
|
|
<param name="level">the import level for relaive imports</param>
|
|
<param name="parentMod">the parent module</param>
|
|
<param name="package">the global __package__ value</param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Importer.GetParentPathAndModule(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonModule@)">
|
|
<summary>
|
|
Given the parent module name looks up the __path__ property.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Importer.TryGetExistingOrMetaPathModule(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.List,System.Object@)">
|
|
<summary>
|
|
Trys to get an existing module and if that fails fall backs to searching
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Importer.TryLoadMetaPathModule(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.List,System.Object@)">
|
|
<summary>
|
|
Attempts to load a module from sys.meta_path as defined in PEP 302.
|
|
|
|
The meta_path provides a list of importer objects which can be used to load modules before
|
|
searching sys.path but after searching built-in modules.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Importer.FindAndLoadModuleFromImporter(IronPython.Runtime.CodeContext,System.Object,System.String,IronPython.Runtime.List,System.Object@)">
|
|
<summary>
|
|
Given a user defined importer object as defined in PEP 302 tries to load a module.
|
|
|
|
First the find_module(fullName, path) is invoked to get a loader, then load_module(fullName) is invoked
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Importer.FindImporterForPath(IronPython.Runtime.CodeContext,System.String)">
|
|
<summary>
|
|
Finds a user defined importer for the given path or returns null if no importer
|
|
handles this path.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Index">
|
|
<summary>
|
|
Wrapper class used when a user defined type (new-style or old-style)
|
|
defines __index__. We provide a conversion from all user defined
|
|
types to the Index type so they can be used for determing and method bind
|
|
time the most appropriate method to dispatch to.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.InstancedModuleDictionaryStorage">
|
|
<summary>
|
|
ModuleDictionaryStorage for a built-in module which is bound to a specific instance.
|
|
|
|
These modules don't need to use PythonContext.GetModuleState() for storage and therefore
|
|
can provide efficient access to internal variables. They can also cache PythonGlobal
|
|
objects and provide efficient access to module globals.
|
|
|
|
To the end user these modules appear just like any other module. These modules are
|
|
implemented by subclassing the BuiltinPythonModule class.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.IWeakReferenceable">
|
|
<summary>
|
|
Defines the internal interface used for accessing weak references and adding finalizers
|
|
to user-defined types.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.IWeakReferenceable.GetWeakRef">
|
|
<summary>
|
|
Gets the current WeakRefTracker for an object that can be used to
|
|
append additional weak references.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.IWeakReferenceable.SetWeakRef(IronPython.Runtime.WeakRefTracker)">
|
|
<summary>
|
|
Attempts to set the WeakRefTracker for an object. Used on the first
|
|
addition of a weak ref tracker to an object. If the object doesn't
|
|
support adding weak references then it returns false.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.IWeakReferenceable.SetFinalizer(IronPython.Runtime.WeakRefTracker)">
|
|
<summary>
|
|
Sets a WeakRefTracker on an object for the purposes of supporting finalization.
|
|
All user types (new-style and old-style) support finalization even if they don't
|
|
support weak-references, and therefore this function always succeeds. Note the
|
|
slot used to store the WeakRefTracker is still shared between SetWeakRef and
|
|
SetFinalizer if a type supports both.
|
|
</summary>
|
|
<param name="value"></param>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.IWeakReferenceableByProxy">
|
|
<summary>
|
|
Allow types to implement weakvreference tracking by returning a proxy.
|
|
|
|
The proxy can refer to the current Python context, whihc is the main purpose.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.IWeakReferenceableByProxy.GetWeakRefProxy(IronPython.Runtime.PythonContext)">
|
|
<summary>
|
|
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.IPythonMembersList">
|
|
<summary>
|
|
Provides a list of all the members of an instance. ie. all the keys in the
|
|
dictionary of the object. Note that it can contain objects that are not strings.
|
|
|
|
Such keys can be added in IronPython using syntax like:
|
|
obj.__dict__[100] = someOtherObject
|
|
|
|
This Python specific version also supports filtering based upon the show cls
|
|
flag by flowing in the code context.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.IParameterSequence">
|
|
<summary>
|
|
Represents a sequence which may have been provided as a set of parameters to an indexer.
|
|
|
|
TODO: This should be removed, and all uses of this should go to [SpecialName]object GetItem(..., params object[] keys)
|
|
and [SpecialName]void SetItem(..., params object [] keys) or this[params object[]xyz] which is also legal.
|
|
|
|
currently this exists for backwards compatibility w/ IronPython's "expandable tuples".
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.List.FromArrayNoCopy(System.Object[])">
|
|
<summary>
|
|
Creates a new list with the data in the array and a size
|
|
the same as the length of the array. The array is held
|
|
onto and may be mutated in the future by the list.
|
|
</summary>
|
|
<param name="data">params array to use for lists storage</param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.List.GetAddSize(System.Int32,System.Int32)">
|
|
<summary>
|
|
Gets a reasonable size for the addition of two arrays. We round
|
|
to a power of two so that we usually have some extra space if
|
|
the resulting array gets added to.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.List.AddNoLock(System.Object)">
|
|
<summary>
|
|
Non-thread safe adder, should only be used by internal callers that
|
|
haven't yet exposed their list.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.List.DoCompare(System.Object[],System.Collections.IComparer,System.Int32,System.Int32,System.Boolean)">
|
|
<summary>
|
|
Compares the two specified keys
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.List.Item(System.Object)">
|
|
<summary>
|
|
Supports __index__ on arbitrary types, also prevents __float__
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.OrderedLocker">
|
|
<summary>
|
|
we need to lock both objects (or copy all of one's data w/ it's lock held, and
|
|
then compare, which is bad). Therefore we have a strong order for locking on
|
|
the two objects based upon the hash code or object identity in case of a collision
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.LiteralParser">
|
|
<summary>
|
|
Summary description for ConstantValue.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.MemoryView.FixSlice(IronPython.Runtime.Slice,System.Int32,System.Int32@,System.Int32@)">
|
|
<summary>
|
|
MemoryView slicing is somewhat different and more restricted than
|
|
standard slicing.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Method.CheckSelf(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Validates that the current self object is usable for this method.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ModuleContext">
|
|
<summary>
|
|
Captures the globals and other state of module code.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ModuleContext.#ctor(IronPython.Runtime.PythonDictionary,IronPython.Runtime.PythonContext)">
|
|
<summary>
|
|
Creates a new ModuleContext which is backed by the specified dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ModuleContext.#ctor(IronPython.Runtime.PythonModule,IronPython.Runtime.PythonContext)">
|
|
<summary>
|
|
Creates a new ModuleContext for the specified module.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.ModuleContext.Globals">
|
|
<summary>
|
|
Gets the dictionary used for the global variables in the module
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.ModuleContext.Context">
|
|
<summary>
|
|
Gets the language context which created this module.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.ModuleContext.GlobalScope">
|
|
<summary>
|
|
Gets the DLR Scope object which is associated with the modules dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.ModuleContext.GlobalContext">
|
|
<summary>
|
|
Gets the global CodeContext object which is used for execution of top-level code.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.ModuleContext.Module">
|
|
<summary>
|
|
Gets the module object which this code is executing in.
|
|
|
|
This module may or may not be published in sys.modules. For user defined
|
|
code typically the module gets published at the start of execution. But if
|
|
this ModuleContext is attached to a Scope, or if we've just created a new
|
|
module context for executing code it will not be in sys.modules.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.ModuleContext.Features">
|
|
<summary>
|
|
Gets the features that code has been compiled with in the module.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.ModuleContext.ShowCls">
|
|
<summary>
|
|
Gets or sets whether code running in this context should display
|
|
CLR members (for example .ToString on objects).
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ModuleContext.InitializeBuiltins(System.Boolean)">
|
|
<summary>
|
|
Initializes __builtins__ for the module scope.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ModuleDictionaryStorage">
|
|
<summary>
|
|
Enables lazy initialization of module dictionaries.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ModuleGlobalCache">
|
|
<summary>
|
|
Cached global value. Created and maintained on a per-language basis. Default
|
|
implementation returns a singleton which indicates caching is not occuring.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ModuleGlobalCache.#ctor(System.Object)">
|
|
<summary>
|
|
Creates a new ModuleGlobalCache with the specified value.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.ModuleGlobalCache.IsCaching">
|
|
<summary>
|
|
True if the ModuleGlobalCache is participating in a caching strategy.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.ModuleGlobalCache.HasValue">
|
|
<summary>
|
|
True if there is currently a value associated with this global variable. False if
|
|
it is currently unassigned.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.ModuleGlobalCache.Value">
|
|
<summary>
|
|
Gets or sets the current cached value
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.ModuleGlobalCache.Changed(System.Object,Microsoft.Scripting.Runtime.ModuleChangeEventArgs)">
|
|
<summary>
|
|
Event handler for when the value has changed. Language implementors should call this when
|
|
the cached value is invalidated.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.TrueDivision">
|
|
<summary>
|
|
Enable true division (1/2 == .5)
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.ShowClsMethods">
|
|
<summary>
|
|
Indicates that .NET methods such as .ToString should be available on Python objects.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.Optimized">
|
|
<summary>
|
|
Indicates that the module should be generated in an optimal form which will result
|
|
in it being uncollectable.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.Initialize">
|
|
<summary>
|
|
Indicates when the module should be executed immedatiately upon creation.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.WithStatement">
|
|
<summary>
|
|
Enable usage of the with statement
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.AbsoluteImports">
|
|
<summary>
|
|
Enable absolute imports
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.NoBuiltins">
|
|
<summary>
|
|
Indiciates that __builtins__ should not be set in the module
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.ModuleBuiltins">
|
|
<summary>
|
|
Indiciates that when the module is initialized it should set __builtins__ to the __builtin__ module
|
|
instead of the __builtin__ dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.ExecOrEvalCode">
|
|
<summary>
|
|
Marks code as being created for exec, eval. Code generated this way will
|
|
be capable of running against different scopes and will do lookups at runtime
|
|
for free global variables.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.SkipFirstLine">
|
|
<summary>
|
|
Indiciates that the first line of code should be skipped.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.PrintFunction">
|
|
<summary>
|
|
Enable usage of print as a function for better compatibility with Python 3.0.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.Interpret">
|
|
<summary>
|
|
Forces the code to be interpreted rather than compiled
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.UnicodeLiterals">
|
|
<summary>
|
|
String Literals should be parsed as Unicode strings
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.Verbatim">
|
|
<summary>
|
|
Include comments in the parse tree
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.ModuleOptions.LightThrow">
|
|
<summary>
|
|
Generated code should support light exceptions
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.NewStringFormatter">
|
|
<summary>
|
|
New string formatter for 'str'.format(...) calls and support for the Formatter
|
|
library via the _formatter_parser / _formatter_field_name_split
|
|
methods.
|
|
|
|
We parse this format:
|
|
|
|
replacement_field = "{" field_name ["!" conversion] [":" format_spec] "}"
|
|
field_name = (identifier | integer) ("." attribute_name | "[" element_index "]")*
|
|
attribute_name = identifier
|
|
element_index = identifier
|
|
conversion = "r" | "s"
|
|
format_spec = any char, { must be balanced (for computed values), passed to __format__ method on object
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.FormatString(IronPython.Runtime.PythonContext,System.String,IronPython.Runtime.PythonTuple,System.Collections.Generic.IDictionary{System.Object,System.Object})">
|
|
<summary>
|
|
Runs the formatting operation on the given format and keyword arguments
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.GetFormatInfo(System.String)">
|
|
<summary>
|
|
Gets the formatting information for the given format. This is a list of tuples. The tuples
|
|
include:
|
|
|
|
text, field name, format spec, conversion
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.GetFieldNameInfo(System.String)">
|
|
<summary>
|
|
Parses a field name returning the argument name and an iterable
|
|
object which can be used to access the individual attribute
|
|
or element accesses. The iterator yields tuples of:
|
|
|
|
bool (true if attribute, false if element index), attribute/index value
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.NewStringFormatter.StringFormatParser">
|
|
<summary>
|
|
Base class used for parsing the format. Subclasss override Text/ReplacementField methods. Those
|
|
methods get called when they call Parse and then they can do the appropriate actions for the
|
|
format.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.Parse(System.String)">
|
|
<summary>
|
|
Gets an enumerable object for walking the parsed format.
|
|
|
|
TODO: object array? struct?
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.Parse">
|
|
<summary>
|
|
Provides an enumerable of the parsed format. The elements of the tuple are:
|
|
the text preceding the format information
|
|
the field name
|
|
the format spec
|
|
the conversion
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseDoubleBracket(System.Int32,System.String@)">
|
|
<summary>
|
|
Handles {{ and }} within the string. Returns true if a double bracket
|
|
is found and yields the text
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseConversion">
|
|
<summary>
|
|
Parses the conversion character and returns it
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.CheckEnd">
|
|
<summary>
|
|
Checks to see if we're at the end of the format. If there's no more characters left we report
|
|
the error, otherwise if we hit a } we return true to indicate parsing should stop.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseFormatSpec(System.Int32@)">
|
|
<summary>
|
|
Parses the format spec string and returns it.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseFieldName(System.Int32@)">
|
|
<summary>
|
|
Parses the field name and returns it.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.StringFormatParser.ParseFieldOrSpecWorker(System.Char[],System.Int32@)">
|
|
<summary>
|
|
Handles parsing the field name and the format spec and returns it. At the parse
|
|
level these are basically the same - field names just have more terminating characters.
|
|
|
|
The most complex part of parsing them is they both allow nested braces and require
|
|
the braces are matched. Strangely though the braces need to be matched across the
|
|
combined field and format spec - not within each format.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.NewStringFormatter.Formatter">
|
|
<summary>
|
|
Provides the built-in string formatter which is exposed to Python via the str.format API.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.Formatter.ReplaceComputedFormats(System.String)">
|
|
<summary>
|
|
Inspects a format spec to see if it contains nested format specs which
|
|
we need to compute. If so runs another string formatter on the format
|
|
spec to compute those values.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.Formatter.GetArgumentValue(IronPython.Runtime.NewStringFormatter.FieldName)">
|
|
<summary>
|
|
Given the field name gets the object from our arguments running
|
|
any of the member/index accessors.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.Formatter.ApplyConversion(System.Nullable{System.Char},System.Object)">
|
|
<summary>
|
|
Applies the known built-in conversions to the object if a conversion is
|
|
specified.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.Formatter.GetUnaccessedObject(IronPython.Runtime.NewStringFormatter.FieldName)">
|
|
<summary>
|
|
Gets the initial object represented by the field name - e.g. the 0 or
|
|
keyword name.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.Formatter.DoAccessors(IronPython.Runtime.NewStringFormatter.FieldName,System.Object)">
|
|
<summary>
|
|
Given the object value runs the accessors in the field name (if any) against the object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.ParseFieldName(System.String,System.Boolean)">
|
|
<summary>
|
|
Parses the field name including attribute access or element indexing.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.ParseFieldAccessors(System.String,System.Int32,System.Boolean)">
|
|
<summary>
|
|
Parses the field name including attribute access or element indexing.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.AccessorsToPython(System.Collections.Generic.IEnumerable{IronPython.Runtime.NewStringFormatter.FieldAccessor})">
|
|
<summary>
|
|
Converts accessors from our internal structure into a PythonTuple matching how CPython
|
|
exposes these
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.NewStringFormatter.ParseIdentifier(System.String,System.Boolean,System.Int32@)">
|
|
<summary>
|
|
Parses an identifier and returns it
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.NewStringFormatter.FieldName">
|
|
<summary>
|
|
Encodes all the information about the field name.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.NewStringFormatter.FieldAccessor">
|
|
<summary>
|
|
Encodes a single field accessor (.b or [number] or [str])
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ArrayOps.Multiply(System.Array,System.Int32)">
|
|
<summary>
|
|
Multiply two object[] arrays - slow version, we need to get the type, etc...
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ArrayOps.Multiply(System.Object[],System.Int32,System.Int32)">
|
|
<summary>
|
|
Multiply two object[] arrays - internal version used for objects backed by arrays
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ArrayOps.Add(System.Object[],System.Int32,System.Object[],System.Int32)">
|
|
<summary>
|
|
Add two arrays - internal versions for objects backed by arrays
|
|
</summary>
|
|
<param name="data1"></param>
|
|
<param name="size1"></param>
|
|
<param name="data2"></param>
|
|
<param name="size2"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Operations.CharOps">
|
|
<summary>
|
|
We override the behavior of equals, compare and hashcode to make
|
|
chars seem as much like strings as possible. In Python there is no
|
|
difference between these types.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Operations.CustomTypeDescHelpers">
|
|
<summary>
|
|
Helper class that all custom type descriptor implementations call for
|
|
the bulk of their implementation.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.DecimalOps.DecimalToFormatString(IronPython.Runtime.CodeContext,System.Decimal,IronPython.Runtime.StringFormatSpec)">
|
|
<summary>
|
|
Returns the digits for the format spec, no sign is included.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Operations.IDelegateConvertible">
|
|
<summary>
|
|
Interface used for things which can convert to delegates w/o code gen. Currently
|
|
this is just non-overloaded builtin functions and bound builtin functions. Avoiding
|
|
the code gen is not only nice for compilation but it also enables delegates to be added
|
|
in C# and removed in Python.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.DoubleOps.DoubleToFormatString(IronPython.Runtime.CodeContext,System.Double,IronPython.Runtime.StringFormatSpec)">
|
|
<summary>
|
|
Returns the digits for the format spec, no sign is included.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Operations.InstanceOps">
|
|
<summary>
|
|
InstanceOps contains methods that get added to CLS types depending on what
|
|
methods and constructors they define. These have not been added directly to
|
|
PythonType since they need to be added conditionally.
|
|
|
|
Possibilities include:
|
|
|
|
__new__, one of 3 __new__ sets can be added:
|
|
DefaultNew - This is the __new__ used for a PythonType (list, dict, object, etc...) that
|
|
has only 1 default public constructor that takes no parameters. These types are
|
|
mutable types, and __new__ returns a new instance of the type, and __init__ can be used
|
|
to re-initialize the types. This __new__ allows an unlimited number of arguments to
|
|
be passed if a non-default __init__ is also defined.
|
|
|
|
NonDefaultNew - This is used when a type has more than one constructor, or only has one
|
|
that takes more than zero parameters. This __new__ does not allow an arbitrary # of
|
|
extra arguments.
|
|
|
|
DefaultNewCls - This is the default new used for CLS types that have only a single ctor
|
|
w/ an arbitray number of arguments. This constructor allows setting of properties
|
|
based upon an extra set of kw-args, e.g.: System.Windows.Forms.Button(Text='abc'). It
|
|
is only used on non-Python types.
|
|
|
|
__init__:
|
|
For types that do not define __init__ we have an __init__ function that takes an
|
|
unlimited number of arguments and does nothing. All types share the same reference
|
|
to 1 instance of this.
|
|
|
|
next: Defined when a type is an enumerator to expose the Python iter protocol.
|
|
|
|
|
|
repr: Added for types that override ToString
|
|
|
|
get: added for types that implement IDescriptor
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.InstanceOps.DynamicDir(IronPython.Runtime.CodeContext,System.Dynamic.IDynamicMetaObjectProvider)">
|
|
<summary>
|
|
__dir__(self) -> Returns the list of members defined on a foreign IDynamicMetaObjectProvider.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.InstanceOps.EnterMethod(System.IDisposable)">
|
|
<summary>
|
|
Provides the implementation of __enter__ for objects which implement IDisposable.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.InstanceOps.ExitMethod(System.IDisposable,System.Object,System.Object,System.Object)">
|
|
<summary>
|
|
Provides the implementation of __exit__ for objects which implement IDisposable.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.InstanceOps.IsStaticTypeMemberInAll(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.String,System.Object@)">
|
|
<summary>
|
|
Determines if a type member can be imported. This is used to treat static types like modules.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.InstanceOps.ContainsGenericMethod``1(IronPython.Runtime.CodeContext,System.Collections.Generic.IEnumerable{``0},``0)">
|
|
<summary>
|
|
Implements __contains__ for types implementing IEnumerable of T.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.InstanceOps.ContainsMethod(IronPython.Runtime.CodeContext,System.Collections.IEnumerable,System.Object)">
|
|
<summary>
|
|
Implements __contains__ for types implementing IEnumerable
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.InstanceOps.ContainsGenericMethodIEnumerator``1(IronPython.Runtime.CodeContext,System.Collections.Generic.IEnumerator{``0},``0)">
|
|
<summary>
|
|
Implements __contains__ for types implementing IEnumerable of T.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.InstanceOps.ContainsMethodIEnumerator(IronPython.Runtime.CodeContext,System.Collections.IEnumerator,System.Object)">
|
|
<summary>
|
|
Implements __contains__ for types implementing IEnumerable
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.InstanceOps.SerializeReduce(IronPython.Runtime.CodeContext,System.Object,System.Int32)">
|
|
<summary>
|
|
Implements __reduce_ex__ for .NET types which are serializable. This uses the .NET
|
|
serializer to get a string of raw data which can be serialized.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Operations.ObjectOps">
|
|
<summary>
|
|
Contains Python extension methods that are added to object
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Operations.ObjectOps._nativelyPickleableTypes">
|
|
<summary> Types for which the pickle module has built-in support (from PEP 307 case 2) </summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Operations.ObjectOps.__class__">
|
|
<summary>
|
|
__class__, a custom slot so that it works for both objects and types.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__delattr__(IronPython.Runtime.CodeContext,System.Object,System.String)">
|
|
<summary>
|
|
Removes an attribute from the provided member
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__hash__(System.Object)">
|
|
<summary>
|
|
Returns the hash code of the given object
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__getattribute__(IronPython.Runtime.CodeContext,System.Object,System.String)">
|
|
<summary>
|
|
Gets the specified attribute from the object without running any custom lookup behavior
|
|
(__getattr__ and __getattribute__)
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__init__(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Initializes the object. The base class does nothing.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__init__(IronPython.Runtime.CodeContext,System.Object,System.Object[])">
|
|
<summary>
|
|
Initializes the object. The base class does nothing.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__init__(IronPython.Runtime.CodeContext,System.Object,System.Collections.Generic.IDictionary{System.Object,System.Object},System.Object[])">
|
|
<summary>
|
|
Initializes the object. The base class does nothing.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__new__(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType)">
|
|
<summary>
|
|
Creates a new instance of the type
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__new__(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.Object[])">
|
|
<summary>
|
|
Creates a new instance of the type
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__new__(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.Collections.Generic.IDictionary{System.Object,System.Object},System.Object[])">
|
|
<summary>
|
|
Creates a new instance of the type
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__reduce__(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Runs the pickle protocol
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__reduce_ex__(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Runs the pickle protocol
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__reduce_ex__(IronPython.Runtime.CodeContext,System.Object,System.Object)">
|
|
<summary>
|
|
Runs the pickle protocol
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__repr__(System.Object)">
|
|
<summary>
|
|
Returns the code representation of the object. The default implementation returns
|
|
a string which consists of the type and a unique numerical identifier.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__setattr__(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object)">
|
|
<summary>
|
|
Sets an attribute on the object without running any custom object defined behavior.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__sizeof__(System.Object)">
|
|
<summary>
|
|
Returns the number of bytes of memory required to allocate the object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.__str__(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Returns a friendly string representation of the object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.GetInitializedSlotValues(System.Object)">
|
|
<summary>
|
|
Return a dict that maps slot names to slot values, but only include slots that have been assigned to.
|
|
Looks up slots in base types as well as the current type.
|
|
|
|
Sort-of Python equivalent (doesn't look up base slots, while the real code does):
|
|
return dict([(slot, getattr(self, slot)) for slot in type(self).__slots__ if hasattr(self, slot)])
|
|
|
|
Return null if the object has no __slots__, or empty dict if it has __slots__ but none are initialized.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.ReduceProtocol0(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Implements the default __reduce_ex__ method as specified by PEP 307 case 2 (new-style instance, protocol 0 or 1)
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.FindClosestNonPythonBase(IronPython.Runtime.Types.PythonType)">
|
|
<summary>
|
|
Returns the closest base class (in terms of MRO) that isn't defined in Python code
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.ObjectOps.ReduceProtocol2(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Implements the default __reduce_ex__ method as specified by PEP 307 case 3 (new-style instance, protocol 2)
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Operations.PythonOps">
|
|
<summary>
|
|
Contains functions that are called directly from
|
|
generated code to perform low-level runtime functionality.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeDictFromItems(System.Object[])">
|
|
<summary>
|
|
Creates a new dictionary extracting the keys and values from the
|
|
provided data array. Keys/values are adjacent in the array with
|
|
the value coming first.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeHomogeneousDictFromItems(System.Object[])">
|
|
<summary>
|
|
Creates a new dictionary extracting the keys and values from the
|
|
provided data array. Keys/values are adjacent in the array with
|
|
the value coming first.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MultiplySequence``1(IronPython.Runtime.Operations.PythonOps.MultiplySequenceWorker{``0},``0,IronPython.Runtime.Index,System.Boolean)">
|
|
<summary>
|
|
Wraps up all the semantics of multiplying sequences so that all of our sequences
|
|
don't duplicate the same logic. When multiplying sequences we need to deal with
|
|
only multiplying by valid sequence types (ints, not floats), support coercion
|
|
to integers if the type supports it, not multiplying by None, and getting the
|
|
right semantics for multiplying by negative numbers and 1 (w/ and w/o subclasses).
|
|
|
|
This function assumes that it is only called for case where count is not implicitly
|
|
coercible to int so that check is skipped.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.CallWithContextAndThis(IronPython.Runtime.CodeContext,System.Object,System.Object,System.Object[])">
|
|
<summary>
|
|
Supports calling of functions that require an explicit 'this'
|
|
Currently, we check if the function object implements the interface
|
|
that supports calling with 'this'. If not, the 'this' object is dropped
|
|
and a normal call is made.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.CheckInitializedAttribute(System.Object,System.Object,System.String)">
|
|
<summary>
|
|
Called from generated code emitted by NewTypeMaker.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.GetUserDescriptor(System.Object,System.Object,System.Object)">
|
|
<summary>
|
|
Handles the descriptor protocol for user-defined objects that may implement __get__
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.TrySetUserDescriptor(System.Object,System.Object,System.Object)">
|
|
<summary>
|
|
Handles the descriptor protocol for user-defined objects that may implement __set__
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.TryDeleteUserDescriptor(System.Object,System.Object)">
|
|
<summary>
|
|
Handles the descriptor protocol for user-defined objects that may implement __delete__
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.RaiseAssertionError(IronPython.Runtime.CodeContext)">
|
|
<summary>
|
|
Python runtime helper for raising assertions. Used by AssertStatement.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.RaiseAssertionError(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Python runtime helper for raising assertions. Used by AssertStatement.
|
|
</summary>
|
|
<param name="msg">Object representing the assertion message</param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeList">
|
|
<summary>
|
|
Python runtime helper to create instance of Python List object.
|
|
</summary>
|
|
<returns>New instance of List</returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeList(System.Object[])">
|
|
<summary>
|
|
Python runtime helper to create a populated instance of Python List object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeListNoCopy(System.Object[])">
|
|
<summary>
|
|
Python runtime helper to create a populated instance of Python List object w/o
|
|
copying the array contents.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeListFromSequence(System.Object)">
|
|
<summary>
|
|
Python runtime helper to create a populated instance of Python List object.
|
|
|
|
List is populated by arbitrary user defined object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeEmptyList(System.Int32)">
|
|
<summary>
|
|
Python runtime helper to create an instance of Python List object.
|
|
|
|
List has the initial provided capacity.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeTuple(System.Object[])">
|
|
<summary>
|
|
Python runtime helper to create an instance of Tuple
|
|
</summary>
|
|
<param name="items"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeTupleFromSequence(System.Object)">
|
|
<summary>
|
|
Python runtime helper to create an instance of Tuple
|
|
</summary>
|
|
<param name="items"></param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.GetEnumeratorValues(IronPython.Runtime.CodeContext,System.Object,System.Int32)">
|
|
<summary>
|
|
Python Runtime Helper for enumerator unpacking (tuple assignments, ...)
|
|
Creates enumerator from the input parameter e, and then extracts
|
|
expected number of values, returning them as array
|
|
|
|
If the input is a Python tuple returns the tuples underlying data array. Callers
|
|
should not mutate the resulting tuple.
|
|
</summary>
|
|
<param name="context">The code context of the AST getting enumerator values.</param>
|
|
<param name="e">object to enumerate</param>
|
|
<param name="expected">expected number of objects to extract from the enumerator</param>
|
|
<returns>
|
|
array of objects (.Lengh == expected) if exactly expected objects are in the enumerator.
|
|
Otherwise throws exception
|
|
</returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeSlice(System.Object,System.Object,System.Object)">
|
|
<summary>
|
|
Python runtime helper to create instance of Slice object
|
|
</summary>
|
|
<param name="start">Start of the slice.</param>
|
|
<param name="stop">End of the slice.</param>
|
|
<param name="step">Step of the slice.</param>
|
|
<returns>Slice</returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.PrintNewline(IronPython.Runtime.CodeContext)">
|
|
<summary>
|
|
Prints newline into default standard output
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.PrintNewlineWithDest(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Prints newline into specified destination. Sets softspace property to false.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.PrintComma(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Prints value into default standard output with Python comma semantics.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.PrintCommaWithDest(IronPython.Runtime.CodeContext,System.Object,System.Object)">
|
|
<summary>
|
|
Prints value into specified destination with Python comma semantics.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.PrintExpressionValue(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Called from generated code when we are supposed to print an expression value
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.ImportTop(IronPython.Runtime.CodeContext,System.String,System.Int32)">
|
|
<summary>
|
|
Called from generated code for:
|
|
|
|
import spam.eggs
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.ImportBottom(IronPython.Runtime.CodeContext,System.String,System.Int32)">
|
|
<summary>
|
|
Python helper method called from generated code for:
|
|
|
|
import spam.eggs as ham
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.ImportWithNames(IronPython.Runtime.CodeContext,System.String,System.String[],System.Int32)">
|
|
<summary>
|
|
Called from generated code for:
|
|
|
|
from spam import eggs1, eggs2
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.ImportFrom(IronPython.Runtime.CodeContext,System.Object,System.String)">
|
|
<summary>
|
|
Imports one element from the module in the context of:
|
|
|
|
from module import a, b, c, d
|
|
|
|
Called repeatedly for all elements being imported (a, b, c, d above)
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.ImportStar(IronPython.Runtime.CodeContext,System.String,System.Int32)">
|
|
<summary>
|
|
Called from generated code for:
|
|
|
|
from spam import *
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.UnqualifiedExec(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Unqualified exec statement support.
|
|
A Python helper which will be called for the statement:
|
|
|
|
exec code
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.QualifiedExec(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.PythonDictionary,System.Object)">
|
|
<summary>
|
|
Qualified exec statement support,
|
|
Python helper which will be called for the statement:
|
|
|
|
exec code in globals [, locals ]
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.BuildExceptionInfo(IronPython.Runtime.CodeContext,System.Exception)">
|
|
<summary>
|
|
Called from generated code at the start of a catch block.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.GetExceptionInfo(IronPython.Runtime.CodeContext)">
|
|
<summary>
|
|
Get an exception tuple for the "current" exception. This is used for sys.exc_info()
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.GetExceptionInfoLocal(IronPython.Runtime.CodeContext,System.Exception)">
|
|
<summary>
|
|
Get an exception tuple for a given exception. This is like the inverse of MakeException.
|
|
</summary>
|
|
<param name="context">the code context</param>
|
|
<param name="ex">the exception to create a tuple for.</param>
|
|
<returns>a tuple of (type, value, traceback)</returns>
|
|
<remarks>This is called directly by the With statement so that it can get an exception tuple
|
|
in its own private except handler without disturbing the thread-wide sys.exc_info(). </remarks>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeRethrownException(IronPython.Runtime.CodeContext)">
|
|
<summary>
|
|
helper function for re-raised exceptions.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeRethrowExceptionWorker(System.Exception)">
|
|
<summary>
|
|
helper function for re-raised exception.
|
|
This entry point is used by 'raise' inside 'with' statement
|
|
</summary>
|
|
<param name="e"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeException(IronPython.Runtime.CodeContext,System.Object,System.Object,System.Object)">
|
|
<summary>
|
|
helper function for non-re-raise exceptions.
|
|
|
|
type is the type of exception to throw or an instance. If it
|
|
is an instance then value should be null.
|
|
|
|
If type is a type then value can either be an instance of type,
|
|
a Tuple, or a single value. This case is handled by EC.CreateThrowable.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.ExtractAnyArgument(IronPython.Runtime.PythonFunction,System.String,System.Int32,IronPython.Runtime.List,System.Collections.IDictionary)">
|
|
<summary>
|
|
Extracts an argument from either the dictionary or params
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.InitializeUserTypeSlots(IronPython.Runtime.Types.PythonType)">
|
|
<summary>
|
|
Creates a new array the values set to Uninitialized.Instance. The array
|
|
is large enough to hold for all of the slots allocated for the type and
|
|
its sub types.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.IsNumericObject(System.Object)">
|
|
<summary>
|
|
Helper to determine if the value is a simple numeric type (int or big int or bool) - used for OldInstance
|
|
deprecated form of slicing.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.IsNumericType(System.Type)">
|
|
<summary>
|
|
Helper to determine if the type is a simple numeric type (int or big int or bool) - used for OldInstance
|
|
deprecated form of slicing.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.IsNonExtensibleNumericType(System.Type)">
|
|
<summary>
|
|
Helper to determine if the type is a simple numeric type (int or big int or bool) but not a subclass
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.NormalizeBigInteger(System.Object,System.Numerics.BigInteger,System.Nullable{System.Int32}@)">
|
|
<summary>
|
|
For slicing. Fixes up a BigInteger and returns an integer w/ the length of the
|
|
object added if the value is negative.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.GetLengthOnce(System.Object,System.Nullable{System.Int32}@)">
|
|
<summary>
|
|
For slicing. Gets the length of the object, used to only get the length once.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.CheckTypeVersion(System.Object,System.Int32)">
|
|
<summary>
|
|
Helper method for DynamicSite rules that check the version of their dynamic object
|
|
TODO - Remove this method for more direct field accesses
|
|
</summary>
|
|
<param name="o"></param>
|
|
<param name="version"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.TestBoundBuiltinFunction(IronPython.Runtime.Types.BuiltinFunction,System.Object)">
|
|
<summary>
|
|
Called from generated code. Gets a builtin function and the BuiltinFunctionData associated
|
|
with the object. Tests to see if the function is bound and has the same data for the generated
|
|
rule.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.ConvertFromObject``1(System.Object)">
|
|
<summary>
|
|
Convert object to a given type. This code is equivalent to NewTypeMaker.EmitConvertFromObject
|
|
except that it happens at runtime instead of compile time.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.DefineDynamicAssembly(System.Reflection.AssemblyName,System.Reflection.Emit.AssemblyBuilderAccess)">
|
|
<summary>
|
|
Provides access to AppDomain.DefineDynamicAssembly which cannot be called from a DynamicMethod
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeNewCustomDelegate(System.Type[])">
|
|
<summary>
|
|
Generates a new delegate type. The last type in the array is the return type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeNewCustomDelegate(System.Type[],System.Nullable{System.Runtime.InteropServices.CallingConvention})">
|
|
<summary>
|
|
Generates a new delegate type. The last type in the array is the return type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.InitializeModule(System.Reflection.Assembly,System.String,System.String[])">
|
|
<summary>
|
|
Provides the entry point for a compiled module. The stub exe calls into InitializeModule which
|
|
does the actual work of adding references and importing the main module. Upon completion it returns
|
|
the exit code that the program reported via SystemExit or 0.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.InitializeModuleEx(System.Reflection.Assembly,System.String,System.String[],System.Boolean)">
|
|
<summary>
|
|
Provides the entry point for a compiled module. The stub exe calls into InitializeModule which
|
|
does the actual work of adding references and importing the main module. Upon completion it returns
|
|
the exit code that the program reported via SystemExit or 0.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.RemoveName(IronPython.Runtime.CodeContext,System.String)">
|
|
<summary>
|
|
Called from generated code, helper to remove a name
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.LookupName(IronPython.Runtime.CodeContext,System.String)">
|
|
<summary>
|
|
Called from generated code, helper to do name lookup
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.SetName(IronPython.Runtime.CodeContext,System.String,System.Object)">
|
|
<summary>
|
|
Called from generated code, helper to do name assignment
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.ToPython(System.IntPtr)">
|
|
<summary>
|
|
Returns an IntPtr in the proper way to CPython - an int or a Python long
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.MakeExceptionTypeError(System.Object,System.Boolean)">
|
|
<summary>
|
|
Create at TypeError exception for when Raise() can't create the exception requested.
|
|
</summary>
|
|
<param name="type">original type of exception requested</param>
|
|
<returns>a TypeEror exception</returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonOps.GetDynamicStackFrames(System.Exception)">
|
|
<summary>
|
|
Gets a list of DynamicStackFrames for the given exception. These stack frames
|
|
can be programmatically inspected to understand the frames the exception crossed
|
|
through including Python frames.
|
|
|
|
Dynamic stack frames are not preserved when an exception crosses an app domain
|
|
boundary.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Operations.UnicodeHelper">
|
|
<summary>
|
|
Helper clas for calls to unicode(...). We generate code which checks if unicode
|
|
is str and if it is we redirect those calls to the unicode function defined on this
|
|
class.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonTypeOps.GetInitMethod(IronPython.Runtime.CodeContext,IronPython.Runtime.Types.PythonType,System.Object)">
|
|
<summary>
|
|
Looks up __init__ avoiding calls to __getattribute__ and handling both
|
|
new-style and old-style classes in the MRO.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonTypeOps.GetBuiltinFunction(System.Type,System.String,System.String,System.Nullable{IronPython.Runtime.Types.FunctionType},System.Reflection.MemberInfo[])">
|
|
<summary>
|
|
Gets a builtin function for the given declaring type and member infos.
|
|
|
|
Given the same inputs this always returns the same object ensuring there's only 1 builtinfunction
|
|
for each .NET method.
|
|
|
|
This method takes both a cacheName and a pythonName. The cache name is the real method name. The pythonName
|
|
is the name of the method as exposed to Python.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonTypeOps.IsMethodAlwaysVisible(System.Type,System.Reflection.MemberInfo[])">
|
|
<summary>
|
|
Checks to see if the provided members are always visible for the given type.
|
|
|
|
This filters out methods such as GetHashCode and Equals on standard .NET
|
|
types that we expose directly as Python types (e.g. object, string, etc...).
|
|
|
|
It also filters out the base helper overrides that are added for supporting
|
|
super calls on user defined types.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonTypeOps.IsStaticFunction(System.Type,System.Reflection.MethodInfo)">
|
|
<summary>
|
|
a function is static if it's a static .NET method and it's defined on the type or is an extension method
|
|
with StaticExtensionMethod decoration.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.PythonTypeOps.EnsureBaseType(IronPython.Runtime.PythonTuple)">
|
|
<summary>
|
|
If we have only interfaces, we'll need to insert object's base
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Operations.ExtensibleString">
|
|
<summary>
|
|
ExtensibleString is the base class that is used for types the user defines
|
|
that derive from string. It carries along with it the string's value and
|
|
our converter recognizes it as a string.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Operations.StringOps">
|
|
<summary>
|
|
StringOps is the static class that contains the methods defined on strings, i.e. 'abc'
|
|
|
|
Here we define all of the methods that a Python user would see when doing dir('abc').
|
|
If the user is running in a CLS aware context they will also see all of the methods
|
|
defined in the CLS System.String type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.StringOps.capitalize(System.String)">
|
|
<summary>
|
|
Returns a copy of this string converted to uppercase
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.StringOps.istitle(System.String)">
|
|
<summary>
|
|
return true if self is a titlecased string and there is at least one
|
|
character in self; also, uppercase characters may only follow uncased
|
|
characters (e.g. whitespace) and lowercase characters only cased ones.
|
|
return false otherwise.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.StringOps.join(System.String,System.Object)">
|
|
<summary>
|
|
Return a string which is the concatenation of the strings
|
|
in the sequence seq. The separator between elements is the
|
|
string providing this method
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.StringOps.format(IronPython.Runtime.CodeContext,System.String,System.Object[])">
|
|
<summary>
|
|
Replaces each replacement field in the string with the provided arguments.
|
|
|
|
replacement_field = "{" field_name ["!" conversion] [":" format_spec] "}"
|
|
field_name = (identifier | integer) ("." identifier | "[" element_index "]")*
|
|
|
|
format_spec: [[fill]align][sign][#][0][width][,][.precision][type]
|
|
|
|
Conversion can be 'r' for repr or 's' for string.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.StringOps.format(IronPython.Runtime.CodeContext,System.String,System.Collections.Generic.IDictionary{System.Object,System.Object},System.Object[])">
|
|
<summary>
|
|
Replaces each replacement field in the string with the provided arguments.
|
|
|
|
replacement_field = "{" field_name ["!" conversion] [":" format_spec] "}"
|
|
field_name = (identifier | integer) ("." identifier | "[" element_index "]")*
|
|
|
|
format_spec: [[fill]align][sign][#][0][width][.precision][type]
|
|
|
|
Conversion can be 'r' for repr or 's' for string.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.StringOps.GetStartingOffset(System.Text.Encoding,System.Byte[])">
|
|
<summary>
|
|
Gets the starting offset checking to see if the incoming bytes already include a preamble.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Operations.StringOps.PythonEncoderFallbackBuffer">
|
|
When encoding or decoding strings if an error occurs CPython supports several different
|
|
behaviors, in addition it supports user-extensible behaviors as well. For the default
|
|
behavior we're ok - both of us support throwing and replacing. For custom behaviors
|
|
we define a single fallback for decoding and encoding that calls the python function to do
|
|
the replacement.
|
|
|
|
When we do the replacement we call the provided handler w/ a UnicodeEncodeError or UnicodeDecodeError
|
|
object which contains:
|
|
encoding (string, the encoding the user requested)
|
|
end (the end of the invalid characters)
|
|
object (the original string being decoded)
|
|
reason (the error, e.g. 'unexpected byte code', not sure of others)
|
|
start (the start of the invalid sequence)
|
|
|
|
The decoder returns a tuple of (unicode, int) where unicode is the replacement string
|
|
and int is an index where encoding should continue.
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.TypeGroupOps.GetItem(Microsoft.Scripting.Actions.TypeGroup,IronPython.Runtime.Types.PythonType[])">
|
|
<summary>
|
|
Indexer for generic parameter resolution. We bind to one of the generic versions
|
|
available in this type collision. A user can also do someType[()] to force to
|
|
bind to the non-generic version, but we will always present the non-generic version
|
|
when no bindings are available.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Operations.UserTypeOps.ToStringHelper(IronPython.Runtime.Types.IPythonObject)">
|
|
<summary>
|
|
Object.ToString() displays the CLI type name. But we want to display the class name (e.g.
|
|
'<foo object at 0x000000000000002C>' unless we've overridden __repr__ but not __str__ in
|
|
which case we'll display the result of __repr__.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Operations.UserTypeDebugView">
|
|
<summary>
|
|
Provides a debug view for user defined types. This class is declared as public
|
|
because it is referred to from generated code. You should not use this class.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Profiler">
|
|
<summary>
|
|
Manages the acquisition of profiling data for a single ScriptRuntime
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Profiler.GetProfiler(IronPython.Runtime.PythonContext)">
|
|
<summary>
|
|
Get the unique Profiler instance for this ScriptRuntime
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Profiler.GetProfilerIndex(System.Reflection.MethodBase)">
|
|
<summary>
|
|
Given a MethodBase, return an index into the array of perf data. Treat each
|
|
CLR method as unique.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Profiler.GetProfilerIndex(System.String)">
|
|
<summary>
|
|
Given the unique name of something we're profiling, return an index into the array of perf data.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Profiler.GetNewProfilerIndex(System.String)">
|
|
<summary>
|
|
Add a new profiler entry. Not all names are unique.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Profiler.GetProfile(System.Boolean)">
|
|
<summary>
|
|
Gets the current summary of profile data
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Profiler.Reset">
|
|
<summary>
|
|
Resets the current summary of profile data back to zero
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Profiler.AddProfiling(System.Linq.Expressions.Expression,System.Linq.Expressions.ParameterExpression,System.String,System.Boolean)">
|
|
<summary>
|
|
Adds profiling calls to a Python method.
|
|
Calculates both the time spent only in this method
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Profiler.AddProfiling(System.Linq.Expressions.Expression,System.Reflection.MethodBase)">
|
|
<summary>
|
|
Wraps a call to a MethodInfo with profiling capture for that MethodInfo
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Profiler.Data">
|
|
<summary>
|
|
Encapsulates profiler data to return to clients
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ProfilerTreatsAsExternalAttribute">
|
|
<summary>
|
|
Marks that this built-in method should be treated as external by the profiler.
|
|
When placed on a call emitted into a Python method, all the time spent in this
|
|
call will still show up in its parent's inclusive time, but will not be
|
|
part of its exclusive time.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.PythonAsciiEncoding">
|
|
<summary>
|
|
Simple implementation of ASCII encoding/decoding. The default instance (PythonAsciiEncoding.Instance) is
|
|
setup to always convert even values outside of the ASCII range. The EncoderFallback/DecoderFallbacks can
|
|
be replaced with versions that will throw exceptions instead though.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.PythonBuffer.BufferMeta">
|
|
<summary>
|
|
A DynamicMetaObject which is just used to support custom conversions to COM.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.IPythonArray">
|
|
<summary>
|
|
A marker interface so we can recognize and access sequence members on our array objects.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.PythonContext.NewObject">
|
|
<summary> stored for copy_reg module, used for reduce protocol </summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.PythonContext.PythonReconstructor">
|
|
<summary> stored for copy_reg module, used for reduce protocol </summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.#ctor(Microsoft.Scripting.Runtime.ScriptDomainManager,System.Collections.Generic.IDictionary{System.String,System.Object})">
|
|
<summary>
|
|
Creates a new PythonContext not bound to Engine.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonContext.RecursionLimit">
|
|
<summary>
|
|
Gets or sets the maximum depth of function calls. Equivalent to sys.getrecursionlimit
|
|
and sys.setrecursionlimit.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonContext.MainThread">
|
|
<summary>
|
|
Gets or sets the main thread which should be interupted by thread.interrupt_main
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.HasModuleState(System.Object)">
|
|
<summary>
|
|
Checks to see if module state has the current value stored already.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.GetModuleState(System.Object)">
|
|
<summary>
|
|
Gets per-runtime state used by a module. The module should have a unique key for
|
|
each piece of state it needs to store.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.SetModuleState(System.Object,System.Object)">
|
|
<summary>
|
|
Sets per-runtime state used by a module. The module should have a unique key for
|
|
each piece of state it needs to store.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.GetSetModuleState(System.Object,System.Object)">
|
|
<summary>
|
|
Sets per-runtime state used by a module and returns the previous value. The module
|
|
should have a unique key for each piece of state it needs to store.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.GetOrCreateModuleState``1(System.Object,System.Func{``0})">
|
|
<summary>
|
|
Sets per-runtime state used by a module and returns the previous value. The module
|
|
should have a unique key for each piece of state it needs to store.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.InitializeSystemState">
|
|
<summary>
|
|
Initializes the sys module on startup. Called both to load and reload sys
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.ReadOneLine(System.IO.StreamReader,System.Int32@)">
|
|
<summary>
|
|
Reads one line keeping track of the # of bytes read
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.HookAssemblyResolve">
|
|
<summary>
|
|
We use Assembly.LoadFile to load assemblies from a path specified by the script (in LoadAssemblyFromFileWithPath).
|
|
However, when the CLR loader tries to resolve any of assembly references, it will not be able to
|
|
find the dependencies, unless we can hook into the CLR loader.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.GetPythonService(Microsoft.Scripting.Hosting.ScriptEngine)">
|
|
<summary>
|
|
Returns (and creates if necessary) the PythonService that is associated with this PythonContext.
|
|
|
|
The PythonService is used for providing remoted convenience helpers for the DLR hosting APIs.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonContext.DefaultEncoding">
|
|
<summary>
|
|
Gets or sets the default encoding for this system state / engine.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonContext.BuiltinModules">
|
|
<summary>
|
|
Dictionary from name to type of all known built-in module names.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonContext.BuiltinModuleNames">
|
|
<summary>
|
|
Dictionary from type to name of all built-in modules.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonContext.BuiltinModuleInstance">
|
|
<summary>
|
|
TODO: Remove me, or stop caching built-ins. This is broken if the user changes __builtin__
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.GetMemberNames(System.Object)">
|
|
<summary>
|
|
Gets the member names associated with the object
|
|
TODO: Move "GetMemberNames" functionality into MetaObject implementations
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonContext.ErrorHandlers">
|
|
<summary> Dictionary of error handlers for string codecs. </summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonContext.SearchFunctions">
|
|
<summary> Table of functions used for looking for additional codecs. </summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.GetGenericSiteStorage``1">
|
|
<summary>
|
|
Gets a SiteLocalStorage when no call site is available.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.Operation(IronPython.Runtime.Binding.PythonOperationKind,System.Object,System.Object)">
|
|
<summary>
|
|
Invokes the specified operation on the provided arguments and returns the new resulting value.
|
|
|
|
operation is usually a value from StandardOperators (standard CLR/DLR operator) or
|
|
OperatorStrings (a Python specific operator)
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonContext.SharedContext">
|
|
<summary>
|
|
Returns a shared code context for the current PythonContext. This shared
|
|
context can be used for performing general operations which usually
|
|
require a CodeContext.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonContext.SharedOverloadResolverFactory">
|
|
<summary>
|
|
Returns an overload resolver for the current PythonContext. The overload
|
|
resolver will flow the shared context through as it's CodeContext.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonContext.SharedClsContext">
|
|
<summary>
|
|
Returns a shared code context for the current PythonContext. This shared
|
|
context can be used for doing lookups which need to occur as if they
|
|
happened in a module which has done "import clr".
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.GetSetCommandDispatcher(System.Action{System.Action})">
|
|
<summary>
|
|
Sets the current command dispatcher for the Python command line. The previous dispatcher
|
|
is returned. Null can be passed to remove the current command dispatcher.
|
|
|
|
The command dispatcher will be called with a delegate to be executed. The command dispatcher
|
|
should invoke the target delegate in the desired context.
|
|
|
|
A common use for this is to enable running all REPL commands on the UI thread while the REPL
|
|
continues to run on a non-UI thread.
|
|
|
|
The ipy.exe REPL will call into PythonContext.DispatchCommand to dispatch each execution to
|
|
the correct thread. Other REPLs can do the same to support this functionality as well.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.DispatchCommand(System.Action)">
|
|
<summary>
|
|
Dispatches the command to the current command dispatcher. If there is no current command
|
|
dispatcher the command is executed immediately on the current thread.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.GetComparer(System.Object,System.Type)">
|
|
<summary>
|
|
Gets a function which can be used for comparing two values. If cmp is not null
|
|
then the comparison will use the provided comparison function. Otherwise
|
|
it will use the normal Python semantics.
|
|
|
|
If type is null then a generic comparison function is returned. If type is
|
|
not null a comparison function is returned that's used for just that type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.Collect(System.Int32)">
|
|
<summary>
|
|
Performs a GC collection including the possibility of freeing weak data structures held onto by the Python runtime.
|
|
</summary>
|
|
<param name="generation"></param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonContext.GetPythonContext(System.Dynamic.DynamicMetaObjectBinder)">
|
|
<summary>
|
|
Gets a PythonContext given a DynamicMetaObjectBinder.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.UnaryOperators">
|
|
<summary>
|
|
List of unary operators which we have sites for to enable fast dispatch that
|
|
doesn't collide with other operators.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.DictionaryKeyEnumerator">
|
|
<summary>
|
|
Note:
|
|
IEnumerator innerEnum = Dictionary<K,V>.KeysCollections.GetEnumerator();
|
|
innerEnum.MoveNext() will throw InvalidOperation even if the values get changed,
|
|
which is supported in python
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.DictionaryValueEnumerator">
|
|
<summary>
|
|
Note:
|
|
IEnumerator innerEnum = Dictionary<K,V>.KeysCollections.GetEnumerator();
|
|
innerEnum.MoveNext() will throw InvalidOperation even if the values get changed,
|
|
which is supported in python
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.DictionaryItemEnumerator">
|
|
<summary>
|
|
Note:
|
|
IEnumerator innerEnum = Dictionary<K,V>.KeysCollections.GetEnumerator();
|
|
innerEnum.MoveNext() will throw InvalidOperation even if the values get changed,
|
|
which is supported in python
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.PythonDynamicStackFrame">
|
|
<summary>
|
|
A DynamicStackFrame which has Python specific data. Currently this
|
|
includes the code context which may provide access to locals and the
|
|
function code object which is needed to build frame objects from.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonDynamicStackFrame.CodeContext">
|
|
<summary>
|
|
Gets the code context of the function.
|
|
|
|
If the function included a call to locals() or the FullFrames
|
|
option is enabled then the code context includes all local variables.
|
|
|
|
Null if deserialized.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonDynamicStackFrame.Code">
|
|
<summary>
|
|
Gets the code object for this frame. This is used in creating
|
|
the trace back. Null if deserialized.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonFile.SetMode(IronPython.Runtime.CodeContext,System.Boolean)">
|
|
<summary>
|
|
Sets the mode to text or binary. Returns true if previously set to text, false if previously set to binary.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonFile.truncate">
|
|
<summary>
|
|
Truncates the file to the current length as indicated by tell().
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonFile.truncate(System.Int64)">
|
|
<summary>
|
|
Truncates the file to the specified length.
|
|
</summary>
|
|
<param name="size"></param>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.PythonFunction">
|
|
<summary>
|
|
Created for a user-defined function.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonFunction.#ctor(IronPython.Runtime.CodeContext,IronPython.Runtime.FunctionCode,IronPython.Runtime.PythonDictionary,System.String,IronPython.Runtime.PythonTuple,IronPython.Runtime.PythonTuple)">
|
|
<summary>
|
|
Python ctor - maps to function.__new__
|
|
|
|
y = func(x.__code__, globals(), 'foo', None, (a, ))
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonFunction.Context">
|
|
<summary>
|
|
The parent CodeContext in which this function was declared.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonFunction.FunctionCompatibility">
|
|
<summary>
|
|
Captures the # of args and whether we have kw / arg lists. This
|
|
enables us to share sites for simple calls (calls that don't directly
|
|
provide named arguments or the list/dict params).
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonFunction.CalculatedCachedCompat">
|
|
<summary>
|
|
Calculates the _compat value which is used for call-compatibility checks
|
|
for simple calls. Whenver any of the dependent values are updated this
|
|
must be called again.
|
|
|
|
The dependent values include:
|
|
_nparams - this is readonly, and never requies an update
|
|
_defaults - the user can mutate this (func_defaults) and that forces
|
|
an update
|
|
expand dict/list - based on nparams and flags, both read-only
|
|
|
|
Bits are allocated as:
|
|
00003fff - Normal argument count
|
|
0fffb000 - Default count
|
|
10000000 - unused
|
|
20000000 - expand list
|
|
40000000 - expand dict
|
|
80000000 - unused
|
|
|
|
Enforce recursion is added at runtime.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonFunction.IsGeneratorWithExceptionHandling">
|
|
<summary>
|
|
Generators w/ exception handling need to have some data stored
|
|
on them so that we appropriately set/restore the exception state.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonFunction.FunctionID">
|
|
<summary>
|
|
Returns an ID for the function if one has been assigned, or zero if the
|
|
function has not yet required the use of an ID.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonFunction.ExpandListPosition">
|
|
<summary>
|
|
Gets the position for the expand list argument or -1 if the function doesn't have an expand list parameter.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonFunction.ExpandDictPosition">
|
|
<summary>
|
|
Gets the position for the expand dictionary argument or -1 if the function doesn't have an expand dictionary parameter.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonFunction.NormalArgumentCount">
|
|
<summary>
|
|
Gets the number of normal (not params or kw-params) parameters.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonFunction.ExtraArguments">
|
|
<summary>
|
|
Gets the number of extra arguments (params or kw-params)
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.PythonHiddenAttribute">
|
|
<summary>
|
|
Marks a member as being hidden from Python code.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.PythonHiddenBaseClassAttribute">
|
|
<summary>
|
|
Marks a class as being hidden from the Python hierarchy. This is applied to the base class
|
|
and then all derived types will not see the base class in their hierarchy and will not be
|
|
able to access members declaredo on the base class.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.PythonModule">
|
|
<summary>
|
|
Python module. Stores classes, functions, and data. Usually a module
|
|
is created by importing a file or package from disk. But a module can also
|
|
be directly created by calling the module type and providing a name or
|
|
optionally a documentation string.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonModule.#ctor(IronPython.Runtime.PythonContext,Microsoft.Scripting.Runtime.Scope)">
|
|
<summary>
|
|
Creates a new module backed by a Scope. Used for creating modules for foreign Scope's.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonModule.#ctor(IronPython.Runtime.PythonDictionary)">
|
|
<summary>
|
|
Creates a new PythonModule with the specified dictionary.
|
|
|
|
Used for creating modules for builtin modules which don't have any code associated with them.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.PythonModuleAttribute">
|
|
<summary>
|
|
This assembly-level attribute specifies which types in the engine represent built-in Python modules.
|
|
|
|
Members of a built-in module type should all be static as an instance is never created.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonModuleAttribute.#ctor(System.String,System.Type,System.PlatformID[])">
|
|
<summary>
|
|
Creates a new PythonModuleAttribute that can be used to specify a built-in module that exists
|
|
within an assembly.
|
|
</summary>
|
|
<param name="name">The built-in module name</param>
|
|
<param name="type">The type that implements the built-in module.</param>
|
|
<param name="validPlatforms">The valid platform identifiers for this module.</param>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonModuleAttribute.Name">
|
|
<summary>
|
|
The built-in module name
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.PythonModuleAttribute.Type">
|
|
<summary>
|
|
The type that implements the built-in module
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.PythonNarrowing">
|
|
<summary>
|
|
Provides human readable names for how Python maps the various DLR NarrowingLevel's.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.PythonNarrowing.None">
|
|
<summary>
|
|
No narrowing conversions are performed
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.PythonNarrowing.BinaryOperator">
|
|
<summary>
|
|
Double/Single to Decimal
|
|
PythonTuple to Array
|
|
Generic conversions
|
|
BigInteger to Int64
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.PythonNarrowing.IndexOperator">
|
|
<summary>
|
|
Numeric conversions excluding from floating point values
|
|
Boolean conversions
|
|
Delegate conversions
|
|
Enumeration conversions
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.PythonNarrowing.All">
|
|
<summary>
|
|
Enables Python protocol conversions (__int__, etc...)
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.PythonScopeExtension">
|
|
<summary>
|
|
Provides storage of IronPython specific data in the DLR Scope ScopeExtension.
|
|
|
|
This enables IronPython to track code compilation flags such as from __future__
|
|
flags and import clr flags across multiple executions of user-provided scopes.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.PythonTuple.ToArray">
|
|
<summary>
|
|
Return a copy of this tuple's data array.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.TupleEnumerator">
|
|
<summary>
|
|
public class to get optimized
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.PythonTypeAttribute">
|
|
<summary>
|
|
Marks a type as being a PythonType for purposes of member lookup, creating instances, etc...
|
|
|
|
If defined a PythonType will use __new__ / __init__ when creating instances. This allows the
|
|
object to match the native Python behavior such as returning cached values from __new__ or
|
|
supporting initialization to run multiple times via __init__.
|
|
|
|
The attribute also allows you to specify an alternate type name. This allows the .NET name to
|
|
be different from the Python name so they can follow .NET naming conventions.
|
|
|
|
Types defining this attribute also don't show CLR methods such as Equals, GetHashCode, etc... until
|
|
the user has done an import clr.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.ScopeDictionaryStorage">
|
|
<summary>
|
|
Provides dictionary based storage which is backed by a Scope object.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.SequenceTypeInfoAttribute">
|
|
<summary>
|
|
Provides more specific type information for Python lists which are not strongly typed.
|
|
|
|
This attribute can be applied to fields, parameters, proeprties, and return values. It can be
|
|
inspected to get type information about the types of the values of the expected
|
|
list or the returned list.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.SetCollection">
|
|
<summary>
|
|
Mutable set class
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetCollection.update(System.Object)">
|
|
<summary>
|
|
Appends an IEnumerable to an existing set
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.FrozenSetCollection">
|
|
<summary>
|
|
Immutable set class
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.SetIterator">
|
|
<summary>
|
|
Iterator over sets
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.SetStorage">
|
|
<summary>
|
|
General-purpose storage used for Python sets and frozensets.
|
|
|
|
The set storage is thread-safe for multiple readers or writers.
|
|
|
|
Mutations to the set involve a simple locking strategy of locking on the SetStorage object
|
|
itself to ensure mutual exclusion.
|
|
|
|
Reads against the set happen lock-free. When the set is mutated, it adds or removes buckets
|
|
in an atomic manner so that the readers will see a consistent picture as if the read
|
|
occurred either before or after the mutation.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.#ctor">
|
|
<summary>
|
|
Creates a new set storage with no buckets
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.#ctor(System.Int32)">
|
|
<summary>
|
|
Creates a new set storage with no buckets
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.SetStorage.Count">
|
|
<summary>
|
|
Returns the number of items currently in the set
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.Add(System.Object)">
|
|
<summary>
|
|
Adds a new item to the set, unless an equivalent item is already present
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.AddWorker(IronPython.Runtime.SetStorage.Bucket[],System.Object,System.Int32,System.Func{System.Object,System.Object,System.Boolean},System.Int32@)">
|
|
<summary>
|
|
Static helper which adds the given non-null item with a precomputed hash code. Returns
|
|
true if the item was added, false if it was already present in the set.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.AddOrRemoveWorker(System.Object,System.Int32)">
|
|
<summary>
|
|
Lock-free helper on a non-null item with a pre-calculated hash code. Removes the item
|
|
if it is present in the set, otherwise adds it.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.Clear">
|
|
<summary>
|
|
Clears the contents of the set
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.Clone">
|
|
<summary>
|
|
Clones the set, returning a new SetStorage object
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.Contains(System.Object)">
|
|
<summary>
|
|
Checks to see if the given item exists in the set
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.ContainsAlwaysHash(System.Object)">
|
|
<summary>
|
|
Checks to see if the given item exists in the set, and tries to hash it even
|
|
if it is known not to be in the set.
|
|
</summary>
|
|
<param name="item"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.CopyTo(IronPython.Runtime.SetStorage)">
|
|
<summary>
|
|
Adds items from this set into the other set
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.Pop(System.Object@)">
|
|
<summary>
|
|
Removes the first set element in the iteration order.
|
|
</summary>
|
|
<returns>true if an item was removed, false if the set was empty</returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.Remove(System.Object)">
|
|
<summary>
|
|
Removes an item from the set and returns true if it was present, otherwise returns
|
|
false
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.RemoveAlwaysHash(System.Object)">
|
|
<summary>
|
|
Removes an item from the set and returns true if it was removed. The item will always
|
|
be hashed, throwing if it is unhashable - even if the set has no buckets.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.RemoveItem(System.Object)">
|
|
<summary>
|
|
Lock-free helper to remove a non-null item
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.IsDisjoint(IronPython.Runtime.SetStorage)">
|
|
<summary>
|
|
Determines whether the current set shares no elements with the given set
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.IsSubset(IronPython.Runtime.SetStorage)">
|
|
<summary>
|
|
Determines whether the current set is a subset of the given set
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.IsStrictSubset(IronPython.Runtime.SetStorage)">
|
|
<summary>
|
|
Determines whether the current set is a strict subset of the given set
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.UnionUpdate(IronPython.Runtime.SetStorage)">
|
|
<summary>
|
|
Mutates this set to contain its union with 'other'. The caller must lock the current
|
|
set if synchronization is desired.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.IntersectionUpdate(IronPython.Runtime.SetStorage)">
|
|
<summary>
|
|
Mutates this set to contain its intersection with 'other'. The caller must lock the
|
|
current set if synchronization is desired.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.SymmetricDifferenceUpdate(IronPython.Runtime.SetStorage)">
|
|
<summary>
|
|
Mutates this set to contain its symmetric difference with 'other'. The caller must
|
|
lock the current set if synchronization is desired.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.DifferenceUpdate(IronPython.Runtime.SetStorage)">
|
|
<summary>
|
|
Mutates this set to contain its difference with 'other'. The caller must lock the
|
|
current set if synchronization is desired.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.Union(IronPython.Runtime.SetStorage,IronPython.Runtime.SetStorage)">
|
|
<summary>
|
|
Computes the union of self and other, returning an entirely new set. This method is
|
|
thread-safe and makes no modifications to self or other.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.Intersection(IronPython.Runtime.SetStorage,IronPython.Runtime.SetStorage)">
|
|
<summary>
|
|
Computes the intersection of self and other, returning an entirely new set. This
|
|
method is thread-safe and makes no modifications to self or other.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.SymmetricDifference(IronPython.Runtime.SetStorage,IronPython.Runtime.SetStorage)">
|
|
<summary>
|
|
Computes the symmetric difference of self and other, returning an entirely new set.
|
|
This method is thread-safe and makes no modifications to self or other.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.Difference(IronPython.Runtime.SetStorage,IronPython.Runtime.SetStorage)">
|
|
<summary>
|
|
Computes the difference of self and other, returning an entirely new set. This
|
|
method is thread-safe and makes no modifications to self or other.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.SetStorage.Bucket">
|
|
<summary>
|
|
Used to store a single hashed item.
|
|
|
|
Bucket is not serializable because it stores the computed hash code, which could change
|
|
between serialization and deserialization.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.Hash(System.Object)">
|
|
<summary>
|
|
Helper to hash the given item w/ support for null
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.SortBySize(IronPython.Runtime.SetStorage@,IronPython.Runtime.SetStorage@)">
|
|
<summary>
|
|
Helper which ensures that the first argument x requires the least work to enumerate
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.GetItems(System.Object)">
|
|
<summary>
|
|
A factory which creates a SetStorage object from any Python iterable. It extracts
|
|
the underlying storage of a set or frozen set without copying, which is left to the
|
|
caller if necessary.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.GetItems(System.Object,IronPython.Runtime.SetStorage@)">
|
|
<summary>
|
|
A factory which creates a SetStorage object from any Python iterable. It extracts
|
|
the underlying storage of a set or frozen set without copying, which is left to the
|
|
caller if necessary.
|
|
Returns true if the given object was a set or frozen set, false otherwise.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.GetFrozenItems(System.Object)">
|
|
<summary>
|
|
A factory which creates a SetStorage object from any Python iterable. It extracts
|
|
the underlying storage of a set or frozen set, copying in the former case, to return
|
|
a SetStorage object that is guaranteed not to receive any outside mutations.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.GetItemsIfSet(System.Object,IronPython.Runtime.SetStorage@)">
|
|
<summary>
|
|
Extracts the SetStorage object from o if it is a set or frozenset and returns true.
|
|
Otherwise returns false.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.SetStorage.GetHashableSetIfSet(System.Object@)">
|
|
<summary>
|
|
Creates a hashable set from the given set, or does nothing if the given object
|
|
is not a set.
|
|
</summary>
|
|
<returns>True if o is a set or frozenset, false otherwise</returns>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.SiteLocalStorage`1">
|
|
<summary>
|
|
Provides storage which is flowed into a callers site. The same storage object is
|
|
flowed for multiple calls enabling the callee to cache data that can be re-used
|
|
across multiple calls.
|
|
|
|
Data is a public field so that this works properly with DynamicSite's as the reference
|
|
type (and EnsureInitialize)
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Slice.DeprecatedFixed(System.Object,System.Int32@,System.Int32@)">
|
|
<summary>
|
|
Gets the indices for the deprecated __getslice__, __setslice__, __delslice__ functions
|
|
|
|
This form is deprecated in favor of using __getitem__ w/ a slice object as an index. This
|
|
form also has subtly different mechanisms for fixing the slice index before calling the function.
|
|
|
|
If an index is negative and __len__ is not defined on the object than an AttributeError
|
|
is raised.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.StringFormatSpec">
|
|
<summary>
|
|
Provides a representation and parsing for the default formatting specification. This is used
|
|
by object.__format__, int.__format__, long.__format__, and float.__format__ to do the common
|
|
format spec parsing.
|
|
|
|
The default specification is:
|
|
|
|
format_spec = [[fill]align][sign][#][0][width][,][.precision][type]
|
|
fill = a character other than }
|
|
align = "<" | ">" | "=" | "^"
|
|
sign = "+" | "-" | " "
|
|
width = integer
|
|
precision = integer
|
|
type = "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "x" | "X" | "%"
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.StringFormatSpec.FromString(System.String)">
|
|
<summary>
|
|
Parses a format spec and returns a new StringFormatSpec object.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.StringFormatter">
|
|
<summary>
|
|
StringFormatter provides Python's % style string formatting services.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.StringFormatter.ReadMappingKey">
|
|
<summary>
|
|
Read a possible mapping key for %(key)s.
|
|
</summary>
|
|
<returns>The key name enclosed between the '%(key)s',
|
|
or null if there are no paranthesis such as '%s'.</returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.StringFormatter.AppendBase(System.Char,System.Int32)">
|
|
<summary>
|
|
AppendBase appends an integer at the specified radix doing all the
|
|
special forms for Python. We have a copy and paste version of this
|
|
for BigInteger below that should be kept in sync.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.StringFormatter.AppendBaseBigInt(System.Numerics.BigInteger,System.Char,System.Int32)">
|
|
<summary>
|
|
BigInteger version of AppendBase. Should be kept in sync w/ AppendBase
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.SysModuleDictionaryStorage">
|
|
<summary>
|
|
Optimized storage for setting exc_type, exc_value, and exc_traceback.
|
|
|
|
This optimization can go away in Python 3.0 when these attributes are no longer used.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.BuiltinFunction">
|
|
<summary>
|
|
BuiltinFunction represents any standard CLR function exposed to Python.
|
|
This is used for both methods on standard Python types such as list or tuple
|
|
and for methods from arbitrary .NET assemblies.
|
|
|
|
All calls are made through the optimizedTarget which is created lazily.
|
|
|
|
TODO: Back BuiltinFunction's by MethodGroup's.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeFunction(System.String,System.Reflection.MethodBase[],System.Type)">
|
|
<summary>
|
|
Creates a new builtin function for a static .NET function. This is used for module methods
|
|
and well-known __new__ methods.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeMethod(System.String,System.Reflection.MethodBase[],System.Type,IronPython.Runtime.Types.FunctionType)">
|
|
<summary>
|
|
Creates a built-in function for a .NET method declared on a type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.BuiltinFunction.#ctor(System.Object,IronPython.Runtime.Types.BuiltinFunction.BuiltinFunctionData)">
|
|
<summary>
|
|
Creates a bound built-in function. The instance may be null for built-in functions
|
|
accessed for None.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeGenericMethod(System.Type[])">
|
|
<summary>
|
|
Returns a BuiltinFunction bound to the provided type arguments. Returns null if the binding
|
|
cannot be performed.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.BuiltinFunction.GetDescriptor">
|
|
<summary>
|
|
Returns a descriptor for the built-in function if one is
|
|
neededed
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.BuiltinFunction.Targets">
|
|
<summary>
|
|
Gets the target methods that we'll be calling.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.BuiltinFunction.IsAlwaysVisible">
|
|
<summary>
|
|
True if the method should be visible to non-CLS opt-in callers
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeBoundFunctionTest(System.Linq.Expressions.Expression)">
|
|
<summary>
|
|
Makes a test for the built-in function against the private _data
|
|
which is unique per built-in function.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.BuiltinFunction.MakeBuiltinFunctionCall(System.Dynamic.DynamicMetaObjectBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[],System.Boolean,System.Dynamic.BindingRestrictions,System.Func{System.Dynamic.DynamicMetaObject[],IronPython.Runtime.Types.BuiltinFunction.BindingResult})">
|
|
<summary>
|
|
Helper for generating the call to a builtin function. This is used for calls from built-in method
|
|
descriptors and built-in functions w/ and w/o a bound instance.
|
|
|
|
This provides all sorts of common checks on top of the call while the caller provides a delegate
|
|
to do the actual call. The common checks include:
|
|
check for generic-only methods
|
|
reversed operator support
|
|
transforming arguments so the default binder can understand them (currently user defined mapping types to PythonDictionary)
|
|
returning NotImplemented from binary operators
|
|
Warning when calling certain built-in functions
|
|
|
|
</summary>
|
|
<param name="call">The call binder we're doing the call for</param>
|
|
<param name="codeContext">An expression which points to the code context</param>
|
|
<param name="function">the meta object for the built in function</param>
|
|
<param name="hasSelf">true if we're calling with an instance</param>
|
|
<param name="args">The arguments being passed to the function</param>
|
|
<param name="functionRestriction">A restriction for the built-in function, method desc, etc...</param>
|
|
<param name="bind">A delegate to perform the actual call to the method.</param>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.BuiltinFunction.Overloads">
|
|
<summary>
|
|
Provides (for reflected methods) a mapping from a signature to the exact target
|
|
which takes this signature.
|
|
signature with syntax like the following:
|
|
someClass.SomeMethod.Overloads[str, int]("Foo", 123)
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.BuiltinFunction.OverloadDictionary">
|
|
<summary>
|
|
Gets the overload dictionary for the logical function. These overloads
|
|
are never bound to an instance.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.BuiltinFunction.BindingSelf">
|
|
<summary>
|
|
Returns the instance used for binding. This differs on module functions implemented
|
|
using instance methods so the built-in functions there don't expose the instance.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.GenericBuiltinFunction">
|
|
<summary>
|
|
A custom built-in function which supports indexing
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.GenericBuiltinFunction.Item(System.Object[])">
|
|
<summary>
|
|
Use indexing on generic methods to provide a new reflected method with targets bound with
|
|
the supplied type arguments.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.BuiltinFunctionOverloadMapper.FindMatchingTargets(System.Type[],System.Collections.Generic.IList{System.Reflection.MethodBase},System.Boolean)">
|
|
<summary>
|
|
Find matching overloads by checking signature against available targets
|
|
</summary>
|
|
<param name="sig">Given signature</param>
|
|
<param name="targets">List of possible targets</param>
|
|
<param name="removeCodeContext">If set to true, the method will check whether the first paramter of the
|
|
target is of the type CodeContext and removes it</param>
|
|
<returns>Possible overloads</returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.BuiltinFunctionOverloadMapper.ThrowOverloadException(System.Type[],System.Collections.Generic.IList{System.Reflection.MethodBase})">
|
|
<summary>
|
|
Throws a formatted exception if no overload matchs.
|
|
</summary>
|
|
<param name="sig">Passed signature which should be used</param>
|
|
<param name="targets">Given targets, which does not fit to the signature</param>
|
|
<example>
|
|
<code language="cs" title="Cause overload exceptiob"><
|
|
]]></code>
|
|
</example>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.CustomAttributeTracker">
|
|
<summary>
|
|
Provides a CustomTracker which handles special fields which have custom
|
|
behavior on get/set.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.CustomInstanceDictionaryStorage">
|
|
<summary>
|
|
Provides custom, versioned, dictionary access for instances. Used for both
|
|
new-style and old-style instances.
|
|
|
|
Each class can allocate a version for instance storage using the
|
|
CustomInstanceDictionaryStorage.AllocateInstance method. The version allocated
|
|
is dependent upon the names which are likely to appear in the instance
|
|
dictionary. Currently these names are calculated by collecting the names
|
|
that are assigned to during the __init__ method and combining these with
|
|
all such names in the types MRO.
|
|
|
|
When creating the dictionary for storing instance values the class can then create
|
|
a PythonDictionary backed by a CustomInstanceDictionaryStorage with it's
|
|
version. When doing a get/set optimized code can then be produced that
|
|
verifies we have CustomInstanceDictionaryStorage and it has the
|
|
correct version. If we have a matching dictionary then gets/sets can turn
|
|
into simple array accesses rather than dictionary gets/sets. For programs
|
|
which access a large number of instance variables this can dramatically
|
|
speed up the program.
|
|
|
|
TODO: Should we attempt to unify all versions which share the same keys?
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.DocBuilder.GetOverloadDoc(System.Reflection.MethodBase,System.String,System.Int32,System.Boolean)">
|
|
<summary>
|
|
Creates a DLR OverloadDoc object which describes information about this overload.
|
|
</summary>
|
|
<param name="info">The method to document</param>
|
|
<param name="name">The name of the method if it should override the name in the MethodBase</param>
|
|
<param name="endParamSkip">Parameters to skip at the end - used for removing the value on a setter method</param>
|
|
<param name="includeSelf">true to include self on instance methods</param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.DocBuilder.AppendTypeFormat(System.Type,System.Text.StringBuilder,System.Reflection.ParameterInfo)">
|
|
<summary>
|
|
Converts a Type object into a string suitable for lookup in the help file. All generic types are
|
|
converted down to their generic type definition.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.DocBuilder.GetXPathDocument(System.Reflection.Assembly)">
|
|
<summary>
|
|
Gets the XPathDocument for the specified assembly, or null if one is not available.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.DocBuilder.GetXmlDoc(System.Reflection.MethodBase,System.String@,System.String@,System.Collections.Generic.List{System.Collections.Generic.KeyValuePair{System.String,System.String}}@)">
|
|
<summary>
|
|
Gets the Xml documentation for the specified MethodBase.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.DocBuilder.GetXmlDoc(System.Type,System.String@)">
|
|
<summary>
|
|
Gets the Xml documentation for the specified Type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.DocBuilder.GetXmlDocForProperty(System.Type,System.String,System.String@,System.String@)">
|
|
<summary>
|
|
Gets the Xml documentation for the specified Field.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.DocBuilder.GetXmlDoc(System.Reflection.EventInfo,System.String@,System.String@)">
|
|
<summary>
|
|
Gets the Xml documentation for the specified Field.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.DocBuilder.XmlToString(System.Xml.XPath.XPathNodeIterator)">
|
|
<summary>
|
|
Converts the XML as stored in the config file into a human readable string.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.DynamicBaseTypeAttribute">
|
|
<summary>
|
|
Marks a type as being a suitable type to be used for user-defined classes.
|
|
|
|
The requirements for this are that a type has to follow the patterns
|
|
that NewTypeMaker derived types follow. This includes:
|
|
The type's constructors must all take PythonType as the 1st parameter
|
|
which sets the underlying type for the actual object
|
|
The type needs to implement IPythonObject
|
|
Dictionary-based storage needs to be provided for setting individual members
|
|
Virtual methods exposed to Python need to support checking the types dictionary for invocations
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.FunctionType">
|
|
<summary>
|
|
Represents a set of attributes that different functions can have.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.FunctionType.None">
|
|
<summary>No flags have been set </summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.FunctionType.Function">
|
|
<summary>This is a function w/ no instance pointer </summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.FunctionType.Method">
|
|
<summary>This is a method that requires an instance</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.FunctionType.FunctionMethodMask">
|
|
<summary>Built-in functions can encapsulate both methods and functions, in which case both bits are set</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.FunctionType.AlwaysVisible">
|
|
<summary>True is the function/method should be visible from pure-Python code</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.FunctionType.ReversedOperator">
|
|
<summary>True if this is a __r*__ method for a CLS overloaded operator method</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.FunctionType.BinaryOperator">
|
|
<summary>
|
|
This method represents a binary operator method for a CLS overloaded operator method.
|
|
|
|
Being a binary operator causes the following special behaviors to kick in:
|
|
A failed binding at call time returns NotImplemented instead of raising an exception
|
|
A reversed operator will automatically be created if:
|
|
1. The parameters are both of the instance type
|
|
2. The parameters are in reversed order (other, this)
|
|
|
|
This enables simple .NET operator methods to be mapped into the Python semantics.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.FunctionType.ModuleMethod">
|
|
<summary>
|
|
A method declared on a built-in module
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.InstanceCreator">
|
|
<summary>
|
|
Base class for helper which creates instances. We have two derived types: One for user
|
|
defined types which prepends the type before calling, and one for .NET types which
|
|
doesn't prepend the type.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.IPythonObject">
|
|
<summary>
|
|
This interface is used for implementing parts of the IronPython type system. It
|
|
is not intended for consumption from user programs.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.IPythonObject.SetDict(IronPython.Runtime.PythonDictionary)">
|
|
<summary>
|
|
Thread-safe dictionary set. Returns the dictionary set or the previous value if already set or
|
|
null if the dictionary set isn't supported.
|
|
</summary>
|
|
<param name="dict"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.IPythonObject.ReplaceDict(IronPython.Runtime.PythonDictionary)">
|
|
<summary>
|
|
Dictionary replacement. Returns true if replaced, false if the dictionary set isn't supported.
|
|
</summary>
|
|
<param name="dict"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.Mro">
|
|
<summary>
|
|
Calculates the method resolution order for a Python class
|
|
the rules are:
|
|
If A is a subtype of B, then A has precedence (A > B)
|
|
If C appears before D in the list of bases then C > D
|
|
If E > F in one __mro__ then E > F in all __mro__'s for our subtype
|
|
|
|
class A(object): pass
|
|
class B(object): pass
|
|
class C(B): pass
|
|
class N(A,B,C): pass # illegal
|
|
|
|
This is because:
|
|
C.__mro__ == (C, B, object)
|
|
N.__mro__ == (N, A, B, C, object)
|
|
which would conflict, but:
|
|
|
|
N(B,A) is ok (N, B, a, object)
|
|
N(C, B, A) is ok (N, C, B, A, object)
|
|
|
|
Calculates a C3 MRO as described in "The Python 2.3 Method Resolution Order"
|
|
plus support for old-style classes.
|
|
|
|
We build up a list of our base classes MRO's plus our base classes themselves.
|
|
We go through the list in order. Look at the 1st class in the current list, and
|
|
if it's not the non-first class in any other list then remove it from all the lists
|
|
and append it to the mro. Otherwise continue to the next list. If all the classes at
|
|
the start are no-good then the MRO is bad and we throw.
|
|
|
|
For old-style classes if the old-style class is the only one in the list of bases add
|
|
it as a depth-first old-style MRO, otherwise compute a new-style mro for all the classes
|
|
and use that.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.Mro.Calculate(IronPython.Runtime.Types.PythonType,System.Collections.Generic.IList{IronPython.Runtime.Types.PythonType},System.Boolean)">
|
|
<summary>
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.NameConverter">
|
|
<summary>
|
|
Contains helper methods for converting C# names into Python names.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.NewTypeInfo">
|
|
<summary>
|
|
TypeInfo captures the minimal CLI information required by NewTypeMaker for a Python object
|
|
that inherits from a CLI type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeInfo.GetTypeInfo(System.String,IronPython.Runtime.PythonTuple)">
|
|
<summary>
|
|
"bases" contains a set of PythonTypes. These can include types defined in Python (say cpy1, cpy2),
|
|
CLI types (say cCLI1, cCLI2), and CLI interfaces (say iCLI1, iCLI2). Here are some
|
|
examples of how this works:
|
|
|
|
(bases) => baseType, {interfaceTypes}
|
|
|
|
(cpy1) => System.Object, {}
|
|
(cpy1, cpy2) => System.Object, {}
|
|
(cpy1, cCLI1, iCLI1, iCLI2) => cCLI1, {iCLI1, iCLI2}
|
|
[some type that satisfies the line above] =>
|
|
cCLI1, {iCLI1, iCLI2}
|
|
(cCLI1, cCLI2) => error
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeInfo.GetPythonTypes(System.String,System.Collections.Generic.ICollection{System.Object})">
|
|
<summary>
|
|
Filters out old-classes and throws if any non-types are included, returning a
|
|
yielding the remaining PythonType objects.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.NewTypeMaker">
|
|
<summary>
|
|
Python class hierarchy is represented using the __class__ field in the object. It does not
|
|
use the CLI type system for pure Python types. However, Python types which inherit from a
|
|
CLI type, or from a builtin Python type which is implemented in the engine by a CLI type,
|
|
do have to use the CLI type system to interoperate with the CLI world. This means that
|
|
objects of different Python types, but with the same CLI base type, can use the same CLI type -
|
|
they will just have different values for the __class__ field.
|
|
|
|
The easiest way to inspect the functionality implemented by NewTypeMaker is to persist the
|
|
generated IL using "ipy.exe -X:SaveAssemblies", and then inspect the
|
|
persisted IL using ildasm.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.LoadNewTypes(System.Reflection.Assembly)">
|
|
<summary>
|
|
Loads any available new types from the provided assembly and makes them
|
|
available via the GetNewType API.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.IsInstanceType(System.Type)">
|
|
<summary>
|
|
Is this a type used for instances Python types (and not for the types themselves)?
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.GetOriginalIndex(System.Reflection.ParameterInfo[],Microsoft.Scripting.Generation.ParameterInfoWrapper[],System.Int32)">
|
|
<summary>
|
|
Gets the position for the parameter which we are overriding.
|
|
</summary>
|
|
<param name="pis"></param>
|
|
<param name="overrideParams"></param>
|
|
<param name="i"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.DefineHelperInterface(System.Type)">
|
|
<summary>
|
|
Defines an interface on the type that forwards all calls
|
|
to a helper method in UserType. The method names all will
|
|
have Helper appended to them to get the name for UserType. The
|
|
UserType version should take 1 extra parameter (self).
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.OverrideMethods(System.Type,System.Collections.Generic.Dictionary{System.String,System.String[]})">
|
|
<summary>
|
|
Overrides methods - this includes all accessible virtual methods as well as protected non-virtual members
|
|
including statics and non-statics.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitBaseMethodDispatch(System.Reflection.MethodInfo,Microsoft.Scripting.Generation.ILGen)">
|
|
<summary>
|
|
Loads all the incoming arguments and forwards them to mi which
|
|
has the same signature and then returns the result
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitBaseClassCallCheckForProperties(Microsoft.Scripting.Generation.ILGen,System.Reflection.MethodInfo,System.String)">
|
|
<summary>
|
|
Emits code to check if the class has overridden this specific
|
|
function. For example:
|
|
|
|
MyDerivedType.SomeVirtualFunction = ...
|
|
or
|
|
|
|
class MyDerivedType(MyBaseType):
|
|
def SomeVirtualFunction(self, ...):
|
|
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitConvertFromObject(Microsoft.Scripting.Generation.ILGen,System.Type)">
|
|
<summary>
|
|
Emit code to convert object to a given type. This code is semantically equivalent
|
|
to PythonBinder.EmitConvertFromObject, except this version accepts ILGen whereas
|
|
PythonBinder accepts Compiler. The Binder will chagne soon and the two will merge.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitBaseClassCallCheckForEvents(Microsoft.Scripting.Generation.ILGen,System.Reflection.MethodInfo,System.String)">
|
|
<summary>
|
|
Emits code to check if the class has overridden this specific
|
|
function. For example:
|
|
|
|
MyDerivedType.SomeVirtualFunction = ...
|
|
or
|
|
|
|
class MyDerivedType(MyBaseType):
|
|
def SomeVirtualFunction(self, ...):
|
|
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitNonInheritedMethodLookup(System.String,Microsoft.Scripting.Generation.ILGen)">
|
|
<summary>
|
|
Emits the call to lookup a member defined in the user's type. Returns
|
|
the local which stores the resulting value and leaves a value on the
|
|
stack indicating the success of the lookup.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.CreateSuperCallHelper(System.Reflection.MethodInfo)">
|
|
<summary>
|
|
Creates a method for doing a base method dispatch. This is used to support
|
|
super(type, obj) calls.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.EmitClrCallStub(Microsoft.Scripting.Generation.ILGen,System.Reflection.MethodInfo,System.Reflection.Emit.LocalBuilder)">
|
|
<summary>
|
|
Generates stub to receive the CLR call and then call the dynamic language code.
|
|
This code is same as StubGenerator.cs in the Microsoft.Scripting, except it
|
|
accepts ILGen instead of Compiler.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.NewTypeMaker.GetOverriddenMethods(System.Type,System.String)">
|
|
<summary>
|
|
Called from PythonTypeOps - the BuiltinFunction._function lock must be held.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.ReturnFixer">
|
|
<summary>
|
|
Same as the DLR ReturnFixer, but accepts lower level constructs,
|
|
such as LocalBuilder, ParameterInfos and ILGen.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.OldInstance.Dictionary">
|
|
<summary>
|
|
Returns the dictionary used to store state for this object
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.OperatorMapping">
|
|
<summary>
|
|
OperatorMapping provides a mapping from DLR operators to their associated .NET methods.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.OperatorMapping.GetOperatorMapping(IronPython.Runtime.Binding.PythonOperationKind)">
|
|
<summary>
|
|
Given an operator returns the OperatorMapping associated with the operator or null
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.OperatorMapping.Operator">
|
|
<summary>
|
|
The operator the OperatorMapping provides info for.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.OperatorMapping.Name">
|
|
<summary>
|
|
The primary method name associated with the method. This method name is
|
|
usally in the form of op_Operator (e.g. op_Addition).
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.OperatorMapping.AlternateName">
|
|
<summary>
|
|
The secondary method name associated with the method. This method name is
|
|
usually a standard .NET method name with pascal casing (e.g. Add).
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.OperatorMapping.AlternateExpectedType">
|
|
<summary>
|
|
The return type that must match for the alternate operator to be valid.
|
|
|
|
This is available alternate operators don't have special names and therefore
|
|
could be confused for a normal method which isn't fulfilling the contract.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonSiteCache">
|
|
<summary>
|
|
Cached CallSites. User types are cached on the PythonType and System types are cached on the
|
|
PythonContext to avoid cross-runtime contamination due to the binder on the site.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonType">
|
|
<summary>
|
|
Represents a PythonType. Instances of PythonType are created via PythonTypeBuilder.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.PythonType._fastBindCtors">
|
|
<summary>
|
|
Provides delegates that will invoke a parameterless type ctor. The first key provides
|
|
the dictionary for a specific type, the 2nd key provides the delegate for a specific
|
|
call site type used in conjunction w/ our IFastInvokable implementation.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.PythonType._userTypeCtors">
|
|
<summary>
|
|
Shared built-in functions for creating instances of user defined types. Because all
|
|
types w/ the same UnderlyingSystemType share the same constructors these can be
|
|
shared across multiple types.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonTuple,IronPython.Runtime.PythonDictionary)">
|
|
<summary>
|
|
Creates a new type for a user defined type. The name, base classes (a tuple of type
|
|
objects), and a dictionary of members is provided.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.PythonTuple,IronPython.Runtime.PythonDictionary,System.String)">
|
|
<summary>
|
|
Creates a new type for a user defined type. The name, base classes (a tuple of type
|
|
objects), and a dictionary of members is provided.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.#ctor(System.Type)">
|
|
<summary>
|
|
Creates a new PythonType object which is backed by the specified .NET type for
|
|
storage. The type is considered a system type which can not be modified
|
|
by the user.
|
|
</summary>
|
|
<param name="underlyingSystemType"></param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.Types.PythonType,System.String,System.Func{System.String,System.Exception})">
|
|
<summary>
|
|
Creates a new PythonType which is a subclass of the specified PythonType.
|
|
|
|
Used for runtime defined new-style classes which require multiple inheritance. The
|
|
primary example of this is the exception system.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.Types.PythonType[],System.String)">
|
|
<summary>
|
|
Creates a new PythonType which is a subclass of the specified PythonTypes.
|
|
|
|
Used for runtime defined new-style classes which require multiple inheritance. The
|
|
primary example of this is the exception system.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.Types.PythonType[],System.Type,System.String,System.Func{System.String,System.Exception})">
|
|
<summary>
|
|
Creates a new PythonType which is a subclass of the specified PythonTypes.
|
|
|
|
Used for runtime defined new-style classes which require multiple inheritance. The
|
|
primary example of this is the exception system.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
|
|
<summary>
|
|
Creates a new PythonType which is a subclass of the specified PythonType.
|
|
|
|
Used for runtime defined new-style classes which require multiple inheritance. The
|
|
primary example of this is the exception system.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType[],System.String,System.String,System.String)">
|
|
<summary>
|
|
Creates a new PythonType which is a subclass of the specified PythonTypes.
|
|
|
|
Used for runtime defined new-style classes which require multiple inheritance. The
|
|
primary example of this is the exception system.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.PythonContext,IronPython.Runtime.Types.PythonType[],System.Type,System.String,System.String,System.String,System.Func{System.String,System.Exception})">
|
|
<summary>
|
|
Creates a new PythonType which is a subclass of the specified PythonTypes.
|
|
|
|
Used for runtime defined new-style classes which require multiple inheritance. The
|
|
primary example of this is the exception system.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.#ctor(IronPython.Runtime.Types.OldClass)">
|
|
<summary>
|
|
Creates a new PythonType object which represents an Old-style class.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.PythonType.TypeFlagHeapType">
|
|
<summary>
|
|
Used in copy_reg which is the only consumer of __flags__ in the standard library.
|
|
|
|
Set if the type is user defined
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.PythonType.TypeFlagAbstractMethodsDefined">
|
|
<summary>
|
|
Set if the type has __abstractmethods__ defined
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.IsIterable(IronPython.Runtime.CodeContext)">
|
|
<summary>
|
|
Check whether the current type is iterabel
|
|
</summary>
|
|
<param name="context"></param>
|
|
<returns>True if it is iterable</returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.__instancecheck__(System.Object)">
|
|
<summary>
|
|
Returns true if the specified object is an instance of this type.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonType.Name">
|
|
<summary>
|
|
Gets the name of the dynamic type
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonType.ResolutionOrder">
|
|
<summary>
|
|
Gets the resolution order used for attribute lookup
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.GetPythonType(System.Type)">
|
|
<summary>
|
|
Gets the dynamic type that corresponds with the provided static type.
|
|
|
|
Returns null if no type is available. TODO: In the future this will
|
|
always return a PythonType created by the DLR.
|
|
</summary>
|
|
<param name="type"></param>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.SetPythonType(System.Type,IronPython.Runtime.Types.PythonType)">
|
|
<summary>
|
|
Sets the python type that corresponds with the provided static type.
|
|
|
|
This is used for built-in types which have a metaclass. Currently
|
|
only used by ctypes.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext)">
|
|
<summary>
|
|
Allocates the storage for the instance running the .NET constructor. This provides
|
|
the creation functionality for __new__ implementations.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Allocates the storage for the instance running the .NET constructor. This provides
|
|
the creation functionality for __new__ implementations.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object,System.Object)">
|
|
<summary>
|
|
Allocates the storage for the instance running the .NET constructor. This provides
|
|
the creation functionality for __new__ implementations.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object,System.Object,System.Object)">
|
|
<summary>
|
|
Allocates the storage for the instance running the .NET constructor. This provides
|
|
the creation functionality for __new__ implementations.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object[])">
|
|
<summary>
|
|
Allocates the storage for the instance running the .NET constructor. This provides
|
|
the creation functionality for __new__ implementations.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.CreateInstance(IronPython.Runtime.CodeContext,System.Object[],System.String[])">
|
|
<summary>
|
|
Allocates the storage for the instance running the .NET constructor. This provides
|
|
the creation functionality for __new__ implementations.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonType.UnderlyingSystemType">
|
|
<summary>
|
|
Gets the underlying system type that is backing this type. All instances of this
|
|
type are an instance of the underlying system type.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonType.ExtensionType">
|
|
<summary>
|
|
Gets the extension type for this type. The extension type provides
|
|
a .NET type which can be inherited from to extend sealed classes
|
|
or value types which Python allows inheritance from.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonType.BaseTypes">
|
|
<summary>
|
|
Gets the base types from which this type inherits.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.IsSubclassOf(IronPython.Runtime.Types.PythonType)">
|
|
<summary>
|
|
Returns true if this type is a subclass of other
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonType.IsSystemType">
|
|
<summary>
|
|
True if the type is a system type. A system type is a type which represents an
|
|
underlying .NET type and not a subtype of one of these types.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.TryLookupSlot(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
|
|
<summary>
|
|
Looks up a slot on the dynamic type
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.TryResolveSlot(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
|
|
<summary>
|
|
Searches the resolution order for a slot matching by name
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.TryResolveMixedSlot(IronPython.Runtime.CodeContext,System.String,IronPython.Runtime.Types.PythonTypeSlot@)">
|
|
<summary>
|
|
Searches the resolution order for a slot matching by name.
|
|
|
|
Includes searching for methods in old-style classes
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.AddSlot(System.String,IronPython.Runtime.Types.PythonTypeSlot)">
|
|
<summary>
|
|
Internal helper to add a new slot to the type
|
|
</summary>
|
|
<param name="name"></param>
|
|
<param name="slot"></param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.TryGetMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object@)">
|
|
<summary>
|
|
Gets a value from a dynamic type and any sub-types. Values are stored in slots (which serve as a level of
|
|
indirection). This searches the types resolution order and returns the first slot that
|
|
contains the value.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.TryGetNonCustomMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object@)">
|
|
<summary>
|
|
Attempts to lookup a member w/o using the customizer. Equivelent to object.__getattribute__
|
|
but it doens't throw an exception.
|
|
</summary>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.TryGetBoundMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object@)">
|
|
<summary>
|
|
Gets a value from a dynamic type and any sub-types. Values are stored in slots (which serve as a level of
|
|
indirection). This searches the types resolution order and returns the first slot that
|
|
contains the value.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.TryGetNonCustomBoundMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object@)">
|
|
<summary>
|
|
Attempts to lookup a member w/o using the customizer.
|
|
</summary>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.TrySetMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object)">
|
|
<summary>
|
|
Sets a value on an instance. If a slot is available in the most derived type the slot
|
|
is set there, otherwise the value is stored directly in the instance.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.TrySetNonCustomMember(IronPython.Runtime.CodeContext,System.Object,System.String,System.Object)">
|
|
<summary>
|
|
Attempst to set a value w/o going through the customizer.
|
|
|
|
This enables languages to provide the "base" implementation for setting attributes
|
|
so that the customizer can call back here.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.GetMemberNames(IronPython.Runtime.CodeContext)">
|
|
<summary>
|
|
Returns a list of all slot names for the type and any subtypes.
|
|
</summary>
|
|
<param name="context">The context that is doing the inquiry of InvariantContext.Instance.</param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.GetMemberNames(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Returns a list of all slot names for the type, any subtypes, and the instance.
|
|
</summary>
|
|
<param name="context">The context that is doing the inquiry of InvariantContext.Instance.</param>
|
|
<param name="self">the instance to get instance members from, or null.</param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.AddUserTypeMembers(IronPython.Runtime.CodeContext,System.Collections.Generic.Dictionary{System.String,System.String},IronPython.Runtime.Types.PythonType,IronPython.Runtime.List)">
|
|
<summary>
|
|
Adds members from a user defined type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.AddInstanceMembers(System.Object,System.Collections.Generic.Dictionary{System.String,System.String},IronPython.Runtime.List)">
|
|
<summary>
|
|
Adds members from a user defined type instance
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.__clrtype__">
|
|
<summary>
|
|
Gets the .NET type which is used for instances of the Python type.
|
|
|
|
When overridden by a metaclass enables a customization of the .NET type which
|
|
is used for instances of the Python type. Meta-classes can construct custom
|
|
types at runtime which include new .NET methods, fields, custom attributes or
|
|
other features to better interoperate with .NET.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.InitializeSystemType">
|
|
<summary>
|
|
Initializes a PythonType that represents a standard .NET type. The same .NET type
|
|
can be shared with the Python type system. For example object, string, int,
|
|
etc... are all the same types.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.AddSystemConstructors">
|
|
<summary>
|
|
Creates a __new__ method for the type. If the type defines interesting constructors
|
|
then the __new__ method will call that. Otherwise if it has only a single argless
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.GetNextVersion">
|
|
<summary>
|
|
This will return a unique integer for every version of every type in the system.
|
|
This means that DynamicSite code can generate a check to see if it has the correct
|
|
PythonType and version with a single integer compare.
|
|
|
|
TODO - This method and related code should fail gracefully on overflow.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.AddSubType(IronPython.Runtime.Types.PythonType)">
|
|
<summary>
|
|
Internal helper function to add a subtype
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonType.SubTypes">
|
|
<summary>
|
|
Gets a list of weak references to all the subtypes of this class. May return null
|
|
if there are no subtypes of the class.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.PythonType.PythonTypeAttributes.SystemCtor">
|
|
<summary>
|
|
The type has a ctor which does not accept PythonTypes. This is used
|
|
for user defined types which implement __clrtype__
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.GetSharedWeakReference">
|
|
<summary>
|
|
Returns a CLR WeakReference object to this PythonType that can be shared
|
|
between anyone who needs a weak reference to the type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.IronPython#Runtime#Binding#IFastInvokable#MakeInvokeBinding``1(System.Runtime.CompilerServices.CallSite{``0},IronPython.Runtime.Binding.PythonInvokeBinder,IronPython.Runtime.CodeContext,System.Object[])">
|
|
<summary>
|
|
Implements fast binding for user defined types. This ensures that common highly dynamic
|
|
scenarios will run fast (for instance creating new types repeatedly and only creating a limited
|
|
number of instances of them). It also gives better code sharing amongst different subclasses
|
|
of the same types and improved startup time due to reduced code generation.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonType.FastBindingBuilderBase">
|
|
<summary>
|
|
Base class for doing fast type invoke binding. Subclasses are created using
|
|
reflection once during the binding. The subclasses can then proceed to do
|
|
the binding w/o using reflection. Otherwise we'd have lots more reflection
|
|
calls which would slow the binding up.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonType.FastBindingBuilderBase.GetOrCreateFastNew">
|
|
<summary>
|
|
Gets or creates delegate for calling the constructor function.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.LateBoundInitBinder">
|
|
<summary>
|
|
Used when a type overrides __new__ with a Python function or other object
|
|
that can return an arbitrary value. If the return value is not the same type
|
|
as the type which had __new__ then we need to lookup __init__ on the type
|
|
and invoke it. Also handles initialization for finalization when __del__
|
|
is defined for the same reasons.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.LateBoundInitBinder.Bind(System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject[])">
|
|
<summary>
|
|
target is the newly initialized value.
|
|
args are the arguments to be passed to __init__
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeDictSlot">
|
|
<summary>
|
|
Provides a slot object for the dictionary to allow setting of the dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeInfo">
|
|
<summary>
|
|
Helpers for interacting w/ .NET types. This includes:
|
|
|
|
Member resolution via GetMember/GetMembers. This performs a member lookup which includes the registered
|
|
extension types in the PythonBinder. Internally the class has many MemberResolver's which provide
|
|
the various resolution behaviors.
|
|
|
|
Cached member access - this is via static classes such as Object and provides various MemberInfo's so we're
|
|
not constantly looking up via reflection.
|
|
</summary>
|
|
</member>
|
|
<member name="F:IronPython.Runtime.Types.PythonTypeInfo._resolvers">
|
|
<summary> list of resolvers which we run to resolve items </summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMemberAll(IronPython.Runtime.Binding.PythonBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type,System.String)">
|
|
<summary>
|
|
Gets the statically known member from the type with the specific name. Searches the entire type hierarchy to find the specified member.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMembersAll(IronPython.Runtime.Binding.PythonBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
|
|
<summary>
|
|
Gets all the statically known members from the specified type. Searches the entire type hierarchy to get all possible members.
|
|
|
|
The result may include multiple resolution. It is the callers responsibility to only treat the 1st one by name as existing.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMember(IronPython.Runtime.Binding.PythonBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type,System.String)">
|
|
<summary>
|
|
Gets the statically known member from the type with the specific name. Searches only the specified type to find the member.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMembers(IronPython.Runtime.Binding.PythonBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
|
|
<summary>
|
|
Gets all the statically known members from the specified type. Searches only the specified type to find the members.
|
|
|
|
The result may include multiple resolution. It is the callers responsibility to only treat the 1st one by name as existing.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeInfo.MemberResolver">
|
|
<summary>
|
|
Abstract class used for resolving members. This provides two methods of member look. The first is looking
|
|
up a single member by name. The other is getting all of the members.
|
|
|
|
There are various subclasses of this which have different methods of resolving the members. The primary
|
|
function of the resolvers are to provide the name->value lookup. They also need to provide a simple name
|
|
enumerator. The enumerator is kept simple because it's allowed to return duplicate names as well as return
|
|
names of members that don't exist. The base MemberResolver will then verify their existance as well as
|
|
filter duplicates.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.MemberResolver.ResolveMember(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type,System.String)">
|
|
<summary>
|
|
Looks up an individual member and returns a MemberGroup with the given members.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.MemberResolver.ResolveMembers(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
|
|
<summary>
|
|
Returns a list of members that exist on the type. The ResolvedMember structure indicates both
|
|
the name and provides the MemberGroup.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.MemberResolver.GetCandidateNames(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
|
|
<summary>
|
|
Returns a list of possible members which could exist. ResolveMember needs to be called to verify their existance. Duplicate
|
|
names can also be returned.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeInfo.OneOffResolver">
|
|
<summary>
|
|
One off resolver for various special methods which are known by name. A delegate is provided to provide the actual member which
|
|
will be resolved.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeInfo.StandardResolver">
|
|
<summary>
|
|
Standard resolver for looking up .NET members. Uses reflection to get the members by name.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeInfo.EqualityResolver">
|
|
<summary>
|
|
Resolves methods mapped to __eq__ and __ne__ from IStructuralEquatable.Equals
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeInfo.ComparisonResolver">
|
|
<summary>
|
|
Resolves methods mapped to __gt__, __lt__, __ge__, __le__, as well as providing an alternate resolution
|
|
for __eq__ and __ne__, from the comparable type's CompareTo method.
|
|
|
|
This should be run after the EqualityResolver.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeInfo.OperatorResolver">
|
|
<summary>
|
|
Resolves methods mapped to __*__ methods automatically from the .NET operator.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.OperatorResolver.FilterAlternateMethods(IronPython.Runtime.Types.OperatorMapping,Microsoft.Scripting.Actions.MemberGroup)">
|
|
<summary>
|
|
Filters alternative methods out that don't match the expected signature and therefore
|
|
are just sharing a common method name.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.OperatorResolver.FilterObjectEquality(Microsoft.Scripting.Actions.MemberGroup)">
|
|
<summary>
|
|
Removes Object.Equals methods as we never return these for PythonOperationKind.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeInfo.PrivateBindingResolver">
|
|
<summary>
|
|
Provides bindings to private members when that global option is enabled.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeInfo.ProtectedMemberResolver">
|
|
<summary>
|
|
Provides resolutions for protected members that haven't yet been
|
|
subclassed by NewTypeMaker.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.MakeResolverTable">
|
|
<summary>
|
|
Creates the resolver table which includes all the possible resolutions.
|
|
</summary>
|
|
<returns></returns>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonTypeInfo.ComplexResolver">
|
|
<summary>
|
|
Provides a resolution for __complex__
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonTypeInfo.FloatResolver">
|
|
<summary>
|
|
Provides a resolution for __float__
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonTypeInfo.IntResolver">
|
|
<summary>
|
|
Provides a resolution for __int__
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonTypeInfo.BigIntegerResolver">
|
|
<summary>
|
|
Provides a resolution for __long__
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonTypeInfo.GetItemResolver">
|
|
<summary>
|
|
Provides a resolution for __getitem__
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonTypeInfo.SetItemResolver">
|
|
<summary>
|
|
Provides a resolution for __setitem__
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.StringResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
|
|
<summary>
|
|
Provides a resolution for __str__.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.ReprResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
|
|
<summary>
|
|
Provides a resolution for __repr__
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.TypeOverridesMethod(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type,System.String)">
|
|
<summary>
|
|
Helper to see if the type explicitly overrides the method. This ignores members
|
|
defined on object.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.HashResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
|
|
<summary>
|
|
Provides a resolution for __hash__ looking for IStructuralEquatable.GetHashCode.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.NewResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
|
|
<summary>
|
|
Provides a resolution for __new__. For standard .NET types __new__ resolves to their
|
|
constructor. For Python types they inherit __new__ from their base class.
|
|
|
|
TODO: Can we just always fallback to object.__new__? If not why not?
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.NextResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
|
|
<summary>
|
|
Provides a resolution for next
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.LengthResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
|
|
<summary>
|
|
Provides a resolution for __len__
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.IterResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
|
|
<summary>
|
|
Provides a resolution for __iter__
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.FallbackInequalityResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
|
|
<summary>
|
|
Looks for an Equals overload defined on the type and if one is present binds __ne__ to an
|
|
InstanceOps helper.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.ContainsResolver(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type)">
|
|
<summary>
|
|
Provides an implementation of __contains__. We can pull contains from:
|
|
ICollection of T which defines Contains directly
|
|
IList which defines Contains directly
|
|
IDictionary which defines Contains directly
|
|
IDictionary of K,V which defines Contains directly
|
|
IEnumerable of K which we have an InstaceOps helper for
|
|
IEnumerable which we have an instance ops helper for
|
|
IEnumerator of K which we have an InstanceOps helper for
|
|
IEnumerator which we have an instance ops helper for
|
|
|
|
String is ignored here because it defines __contains__ via extension methods already.
|
|
|
|
The lookup is well ordered and not dependent upon the order of values returned by reflection.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetEnumeratorContains(System.Type,System.Collections.Generic.IList{System.Type},System.Collections.Generic.List{Microsoft.Scripting.Actions.MemberTracker}@,System.Boolean@,System.Type,System.Type,System.String)">
|
|
<summary>
|
|
Helper for IEnumerable/IEnumerator __contains__
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeInfo.MemberBinder">
|
|
<summary>
|
|
Base class used for resolving a name into a member on the type.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.MemberBinder.GetBaseInstanceMethod(System.Type,System.String[])">
|
|
<summary>
|
|
Gets an instance op method for the given type and name.
|
|
|
|
Instance ops methods appaer on the base most class that's required to expose it. So
|
|
if we have: Array[int], Array, object we'd only add an instance op method to Array and
|
|
Array[int] inherits it. It's obviously not on object because if it was there we'd just
|
|
put the method in ObjectOps.
|
|
|
|
Therefore the different binders expose this at the appropriate times.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeInfo.ResolveBinder">
|
|
<summary>
|
|
MemberBinder which searches the entire type hierarchy and their extension types to find a member.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeInfo.LookupBinder">
|
|
<summary>
|
|
MemberBinder which searches only the current type and it's extension types to find a member.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetMemberGroup(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type,System.String)">
|
|
<summary>
|
|
Primary worker for getting the member(s) associated with a single name. Can be called with different MemberBinder's to alter the
|
|
scope of the search.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetResolvedMembers(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,Microsoft.Scripting.Actions.MemberRequestKind,System.Type)">
|
|
<summary>
|
|
Primary worker for returning a list of all members in a type. Can be called with different MemberBinder's to alter the scope
|
|
of the search.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.GetInstanceOpsMethod(System.Type,System.String[])">
|
|
<summary>
|
|
Helper to get a MemberGroup for methods declared on InstanceOps
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.FindCastMethod(IronPython.Runtime.Types.PythonTypeInfo.MemberBinder,System.Type,System.Collections.Generic.List{System.Type})">
|
|
<summary>
|
|
Helper to get the proper typecasting method, according to the following precedence rules:
|
|
|
|
1. Strongest (most specific) declaring type
|
|
2. Strongest (most specific) parameter type
|
|
3. Type of conversion
|
|
i. Implicit
|
|
ii. Explicit
|
|
4. Return type (order specified in toTypes)
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.MakeConversionResolver(System.Collections.Generic.List{System.Type})">
|
|
<summary>
|
|
Helper for creating a typecast resolver
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.MakeIndexerResolver(System.Boolean)">
|
|
<summary>
|
|
Helper for creating __getitem__/__setitem__ resolvers
|
|
</summary>
|
|
<param name="set">false for a getter, true for a setter</param>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.IncludeOperatorMethod(System.Type,IronPython.Runtime.Binding.PythonOperationKind)">
|
|
<summary>
|
|
Filters out methods which are present on standard .NET types but shouldn't be there in Python
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.FilterFieldAndEvent(Microsoft.Scripting.Actions.MemberGroup)">
|
|
<summary>
|
|
When private binding is enabled we can have a collision between the private Event
|
|
and private field backing the event. We filter this out and favor the event.
|
|
|
|
This matches the v1.0 behavior of private binding.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.ProtectedOnly(System.Reflection.MemberInfo)">
|
|
<summary>
|
|
Filters down to include only protected methods
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.FilterForwardReverseMethods(System.String,Microsoft.Scripting.Actions.MemberGroup,System.Type,IronPython.Runtime.Binding.PythonOperationKind)">
|
|
<summary>
|
|
If an operator is a reverisble operator (e.g. addition) then we need to filter down to just the forward/reverse
|
|
versions of the .NET method. For example consider:
|
|
|
|
String.op_Multiplication(int, string)
|
|
String.op_Multiplication(string, int)
|
|
|
|
If this method were defined on string it defines that you can do:
|
|
2 * 'abc'
|
|
or:
|
|
'abc' * 2
|
|
|
|
either of which will produce 'abcabc'. The 1st form is considered the reverse form because it is declared on string
|
|
but takes a non-string for the 1st argument. The 2nd is considered the forward form because it takes a string as the
|
|
1st argument.
|
|
|
|
When dynamically dispatching for 2 * 'abc' we'll first try __mul__ on int, which will fail with a string argument. Then we'll try
|
|
__rmul__ on a string which will succeed and dispatch to the (int, string) overload.
|
|
|
|
For multiplication in this case it's not too interesting because it's commutative. For addition this might be more interesting
|
|
if, for example, we had unicode and ASCII strings. In that case Unicode strings would define addition taking both unicode and
|
|
ASCII strings in both forms.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.AreTypesCompatible(System.Type,System.Type)">
|
|
<summary>
|
|
Checks to see if the parameter type and the declaring type are compatible to determine
|
|
if an operator is forward or reverse.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeInfo.IsPythonRecognizedOperator(System.String)">
|
|
<summary>
|
|
Checks to see if this is an operator method which Python recognizes. For example
|
|
op_Comma is not recognized by Python and therefore should exposed to the user as
|
|
a method that is callable by name.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.PythonTypeSlot">
|
|
<summary>
|
|
A TypeSlot is an item that gets stored in a type's dictionary. Slots provide an
|
|
opportunity to customize access at runtime when a value is get or set from a dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeSlot.TryGetValue(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.Types.PythonType,System.Object@)">
|
|
<summary>
|
|
Gets the value stored in the slot for the given instance binding it to an instance if one is provided and
|
|
the slot binds to instances.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeSlot.TrySetValue(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.Types.PythonType,System.Object)">
|
|
<summary>
|
|
Sets the value of the slot for the given instance.
|
|
</summary>
|
|
<returns>true if the value was set, false if it can't be set</returns>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeSlot.TryDeleteValue(IronPython.Runtime.CodeContext,System.Object,IronPython.Runtime.Types.PythonType)">
|
|
<summary>
|
|
Deletes the value stored in the slot from the instance.
|
|
</summary>
|
|
<returns>true if the value was deleted, false if it can't be deleted</returns>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonTypeSlot.CanOptimizeGets">
|
|
<summary>
|
|
True if generating code for gets can result in more optimal accesses.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.PythonTypeSlot.MakeGetExpression(IronPython.Runtime.Binding.PythonBinder,System.Linq.Expressions.Expression,System.Dynamic.DynamicMetaObject,System.Dynamic.DynamicMetaObject,IronPython.Runtime.Binding.ConditionalBuilder)">
|
|
<summary>
|
|
Gets an expression which is used for accessing this slot. If the slot lookup fails the error expression
|
|
is used again.
|
|
|
|
The default implementation just calls the TryGetValue method. Subtypes of PythonTypeSlot can override
|
|
this and provide a more optimal implementation.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.PythonTypeSlot.GetAlwaysSucceeds">
|
|
<summary>
|
|
True if TryGetValue will always succeed, false if it may fail.
|
|
|
|
This is used to optimize away error generation code.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.ReflectedEvent">
|
|
<summary>
|
|
The unbound representation of an event property
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.ReflectedEvent.BoundEvent">
|
|
<summary>
|
|
BoundEvent is the object that gets returned when the user gets an event object. An
|
|
BoundEvent tracks where the event was received from and is used to verify we get
|
|
a proper add when dealing w/ statics events.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.ReflectedExtensionProperty">
|
|
<summary>
|
|
Represents a ReflectedProperty created for an extension method. Logically the property is an
|
|
instance property but the method implementing it is static.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.ReflectedField.GetValue(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Convenience function for users to call directly
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.ReflectedField.SetValue(IronPython.Runtime.CodeContext,System.Object,System.Object)">
|
|
<summary>
|
|
This function can be used to set a field on a value type without emitting a warning. Otherwise it is provided only to have symmetry with properties which have GetValue/SetValue for supporting explicitly implemented interfaces.
|
|
|
|
Setting fields on value types usually warns because it can silently fail to update the value you expect. For example consider this example where Point is a value type with the public fields X and Y:
|
|
|
|
arr = System.Array.CreateInstance(Point, 10)
|
|
arr[0].X = 42
|
|
print arr[0].X
|
|
|
|
prints 0. This is because reading the value from the array creates a copy of the value. Setting the value then mutates the copy and the array does not get updated. The same problem exists when accessing members of a class.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.ReflectedGetterSetter">
|
|
<summary>
|
|
Base class for properties backed by methods. These include our slot properties,
|
|
indexers, and normal properties. This class provides the storage of these as well
|
|
as the storage of our optimized getter/setter methods, documentation for the property,
|
|
etc...
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.ReflectedIndexer">
|
|
<summary>
|
|
Provides access to non-default .NET indexers (aka properties w/ parameters).
|
|
|
|
C# doesn't support these, but both COM and VB.NET do. The types dictionary
|
|
gets populated w/a ReflectedGetterSetter indexer which is a descriptor. Getting
|
|
the descriptor returns a bound indexer. The bound indexer supports indexing.
|
|
We support multiple indexer parameters via expandable tuples.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.ReflectedProperty.CanOptimizeGets">
|
|
<summary>
|
|
True if generating code for gets can result in more optimal accesses.
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.ReflectedProperty.GetValue(IronPython.Runtime.CodeContext,System.Object)">
|
|
<summary>
|
|
Convenience function for users to call directly
|
|
</summary>
|
|
</member>
|
|
<member name="M:IronPython.Runtime.Types.ReflectedProperty.SetValue(IronPython.Runtime.CodeContext,System.Object,System.Object)">
|
|
<summary>
|
|
Convenience function for users to call directly
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.ReflectedSlotProperty">
|
|
<summary>
|
|
Represents a member of a user-defined type which defines __slots__. The names listed in
|
|
__slots__ have storage allocated for them with the type and provide fast get/set access.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.Runtime.Types.ReflectedSlotProperty.Index">
|
|
<summary>
|
|
Gets the index into the object array to be used for the slot storage.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.ResolvedMember">
|
|
<summary>
|
|
Couples a MemberGroup and the name which produces the member group together
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.Types.SlotFieldAttribute">
|
|
<summary>
|
|
Represents an ops-extension which adds a new slot. The slot can have arbitrary
|
|
get/set behavior above and beyond normal .NET methods or properties. This is
|
|
typically in regards to how it processes access from instances or subtypes.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.WeakRefTracker">
|
|
<summary>
|
|
single finalizable instance used to track and deliver all the
|
|
callbacks for a single object that has been weakly referenced by
|
|
one or more references and proxies. The reference to this object
|
|
is held in objects that implement IWeakReferenceable.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.InstanceFinalizer">
|
|
<summary>
|
|
Finalizable object used to hook up finalization calls for OldInstances.
|
|
|
|
We create one of these each time an object w/ a finalizer gets created. The
|
|
only reference to this object is the instance so when that goes out of context
|
|
this does as well and this will get finalized.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.Runtime.WrapperDescriptorAttribute">
|
|
<summary>
|
|
Marks a method/field/property as being a wrapper descriptor. A wrapper desriptor
|
|
is a member defined on PythonType but is available both for type and other
|
|
instances of type. For example type.__bases__.
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.BytesConversionAttribute">
|
|
<summary>
|
|
For IList<byte/> arguments: Marks that the argument is typed to accept a bytes or
|
|
bytearray object. This attribute disallows passing a Python list object and
|
|
auto-applying our generic conversion. It also enables conversion of a string to
|
|
a IList of byte in IronPython 2.6.
|
|
|
|
For string arguments: Marks that the argument is typed to accept a bytes object
|
|
as well. (2.6 only)
|
|
</summary>
|
|
</member>
|
|
<member name="T:IronPython.DictionaryTypeInfoAttribute">
|
|
<summary>
|
|
Provides more specific type information for Python dictionaries which are not strongly typed.
|
|
|
|
This attribute can be applied to fields, parameters, proeprties, and return values. It can be
|
|
inspected to get type information about the types of the keys and values of the expected
|
|
dictionary or the returned dictionary.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.Arguments">
|
|
<summary>
|
|
Gets the collection of command line arguments.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.Optimize">
|
|
<summary>
|
|
Should we strip out all doc strings (the -O command line option).
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.StripDocStrings">
|
|
<summary>
|
|
Should we strip out all doc strings (the -OO command line option).
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.WarningFilters">
|
|
<summary>
|
|
List of -W (warning filter) options collected from the command line.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.WarnPython30">
|
|
<summary>
|
|
Enables warnings related to Python 3.0 features.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.Python30">
|
|
<summary>
|
|
Enables 3.0 features that are implemented in IronPython.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.Debug">
|
|
<summary>
|
|
Enables debugging support. When enabled a .NET debugger can be attached
|
|
to the process to step through Python code.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.Inspect">
|
|
<summary>
|
|
Enables inspect mode. After running the main module the REPL will be started
|
|
within that modules context.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.NoUserSite">
|
|
<summary>
|
|
Suppresses addition of the user site directory. This is ignored by IronPython
|
|
except for updating sys.flags.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.NoSite">
|
|
<summary>
|
|
Disables import site on startup.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.IgnoreEnvironment">
|
|
<summary>
|
|
Ignore environment variables that configure the IronPython context.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.Verbose">
|
|
<summary>
|
|
Enables the verbose option which traces import statements. This is ignored by IronPython
|
|
except for setting sys.flags.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.RecursionLimit">
|
|
<summary>
|
|
Sets the maximum recursion depth. Setting to Int32.MaxValue will disable recursion
|
|
enforcement.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.Frames">
|
|
<summary>
|
|
Makes available sys._getframe. Local variables will not be available in frames unless the
|
|
function calls locals(), dir(), vars(), etc... For ensuring locals are always available use
|
|
the FullFrames option.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.FullFrames">
|
|
<summary>
|
|
Makes available sys._getframe. All locals variables will live on the heap (for a considerable
|
|
performance cost) enabling introspection of all code.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.Tracing">
|
|
<summary>
|
|
Tracing is always available. Without this option tracing is only enabled when sys.settrace
|
|
is called. This means code that was already running before sys.settrace will not be debuggable.
|
|
|
|
With this option pdb.set_trace and pdb.post_mortem will always work properly.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.IndentationInconsistencySeverity">
|
|
<summary>
|
|
Severity of a warning that indentation is formatted inconsistently.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.DivisionOptions">
|
|
<summary>
|
|
The division options (old, new, warn, warnall)
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.LightweightScopes">
|
|
<summary>
|
|
Forces all code to be compiled in a mode in which the code can be reliably collected by the CLR.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.EnableProfiler">
|
|
<summary>
|
|
Enable profiling code
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.NoDebug">
|
|
<summary>
|
|
Returns a regular expression of Python files which should not be emitted in debug mode.
|
|
</summary>
|
|
</member>
|
|
<member name="P:IronPython.PythonOptions.PythonVersion">
|
|
<summary>
|
|
Gets the CPython version which IronPython will emulate. Currently limited
|
|
to either 2.6 or 3.0.
|
|
</summary>
|
|
</member>
|
|
</members>
|
|
</doc>
|
|
|