CODESYS Forge

<?xml version="1.0"?>

<doc>

    <assembly>

        <name>IronPython</name>

    </assembly>

    <members>

        <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="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.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="M:IronPython.Compiler.Ast.ClassDefinition.GetParentClosureTuple">

            <summary>

            Gets the closure tuple from our parent context.

            </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="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="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="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.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="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="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="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.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.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.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.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.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.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="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.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.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="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="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="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.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="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.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.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.ContextArgBuilder">

            <summary>

            ArgBuilder which provides the CodeContext parameter to a method.

            </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="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.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.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.CreateFallback">

            <summary>

            Fallback action for performing a new() on a foreign IDynamicMetaObjectProvider.  used

            when call falls back.

            </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.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.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