<?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.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.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="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