This is an automated email letting you know that sources
have recently been pushed out. You can download these newer
sources directly from
http://ironpython.codeplex.com/SourceControl/changeset/view/66283.
ADDED SOURCES
$/IronPython/IronPython_Main/Languages/IronPython/IronPythonTest/LightExceptionTests.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/PythonException.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/TypeErrorException.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/AttributeErrorException.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/SysModuleDictionaryStorage.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Win32Native.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Utils/HybridReferenceDictionary.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/LightCheckAndThrowExpression.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/LightExceptionRewriter.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/ILightExceptionAwareExpression.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/LightExceptionConvertingExpression.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/LightThrowExpression.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/LightLambdaExpression.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Actions/ILightExceptionBinder.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Runtime/LightExceptions.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Runtime/LightThrowingAttribute.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting.Core/Microsoft.Scripting.Core.ruleset
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting.Core/Microsoft.Scripting.ExtensionAttribute.ruleset
DELETED SOURCES
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Types/BuiltinFunction.Generated.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting.Core/Migrated
rules for Microsoft.Scripting.Core.ruleset
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting.Core/Migrated
rules for Microsoft.Scripting.ExtensionAttribute.ruleset
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Runtime/Operators.cs
MODIFIED SOURCES
$/IronPython/IronPython_Main/Languages/IronPython/IronPythonTest/LightExceptionTests.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/PythonException.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/TypeErrorException.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/AttributeErrorException.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/SysModuleDictionaryStorage.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Win32Native.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython.Modules/IronPython.Modules.ruleset
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/IronPython.ruleset
$/IronPython/IronPython_Main/Languages/IronPython/IronPythonConsole/IronPythonConsole.ruleset
$/IronPython/IronPython_Main/Languages/IronPython/IronPythonWindow/IronPythonWindow.ruleset
$/IronPython/IronPython_Main/Languages/IronPython/IronPython.Modules/mmap.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Modules/sys.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/ListComprehensionFor.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/DynamicGetMemberExpression.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/ReducableDynamicExpression.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Parser.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/OnDiskScriptCode.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/BytesWarningException.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/UnicodeException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/OSException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/PythonFunction.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/PythonContext.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython.Modules/_ctypes/CFuncPtr.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython.Modules/nt.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/SerializedScopeStatement.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/SyntaxWarningException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/MetaPythonType.Members.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/PythonSavableScriptCode.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/BufferException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/PythonExceptions.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/PythonBinaryOperationBinder.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/ConversionBinder.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/PythonGetMemberBinder.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/FunctionCode.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/IronPython.csproj
$/IronPython/IronPython_Main/Languages/IronPython/Scripts/generate_dynamic_instructions.py
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/ForStatement.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/CallExpression.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/TryStatement.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/LookupException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/FutureWarningException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/BindingWarnings.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Importer.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/PythonDynamicStackFrame.cs
$/IronPython/IronPython_Main/Languages/IronPython/Scripts/generate_exceptions.py
$/IronPython/IronPython_Main/Languages/IronPython/Scripts/generate_calls.py
$/IronPython/IronPython_Main/Languages/IronPython/IronPython.Modules/IronPython.Modules.csproj
$/IronPython/IronPython_Main/Languages/IronPython/IronPythonConsoleAny/IronPythonConsoleAny.csproj
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/ConstantExpression.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/GeneratorRewriter.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Types/PythonType.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Operations/PythonOps.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/EnvironmentException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/ObjectException.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/ParenthesisExpression.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython.Modules/cPickle.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/CollectableCompilationMode.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/ClassDefinition.cs
$/IronPython/IronPython_Main/Hosts/Silverlight/Chiron/DetailsForm.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/BinaryExpression.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython.Modules/socket.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/Node.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/CompilationMode.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/DynamicConvertExpression.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/ScopeStatement.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/ImportStatement.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/AstMethods.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/LookupCompilationMode.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/PythonAst.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/PythonNameBinder.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/Ast/FunctionDefinition.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Utils/HybridReferenceDictionary.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/LightCheckAndThrowExpression.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/LightExceptionRewriter.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/ILightExceptionAwareExpression.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/LightExceptionConvertingExpression.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/LightThrowExpression.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/LightLambdaExpression.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Actions/ILightExceptionBinder.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Runtime/LightExceptions.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Runtime/LightThrowingAttribute.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/SiteLocalStorageBuilder.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/MetaBuiltinMethodDescriptor.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/MetaBuiltinFunction.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/NewStringFormatter.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/PythonScriptCode.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/UncollectableCompilationMode.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/StopIterationException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/RuntimeException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/PendingDeprecationWarningException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/ContextArgBuilder.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/MetaPythonType.Calls.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/MetaUserObject.Members.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/PythonFunction.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Generator.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/PythonInvokeBinder.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/PythonDynamicExpression.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/UnicodeTranslateException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/RuntimeWarningException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/IndentationException.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Types/BuiltinFunction.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/ImportWarningException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPythonWindow/IronPythonWindow.csproj
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/WarningInfo.cs
$/IronPython/IronPython_Main/Languages/IronPython/Tests/regressions.py
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/UserWarningException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/UnicodeWarningException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Operations/StringOps.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/DeprecationWarningException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPythonConsole/IronPythonConsole.csproj
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/ClrModule.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/ReferenceException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/MetaPythonFunction.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Modules/Builtin.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/PythonBinder.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/FloatingPointException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/PythonProtocol.Operations.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPythonTest/EngineTest.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/BindingHelpers.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Profiler.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/ImportException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPythonTest/IronPythonTest.csproj
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/UncollectableCompilationMode.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPythonWindowAny/IronPythonWindowAny.csproj
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/PythonGlobal.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/RunnableScriptCode.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/ModuleOptions.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/CommonDictionaryStorage.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/ToDiskCompilationMode.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/AssertionException.Generated.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Exceptions/PythonExceptions.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Binding/PythonProtocol.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/PythonGlobalVariableExpression.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Compiler/RuntimeScriptCode.cs
$/IronPython/IronPython_Main/Languages/IronPython/IronPython/Runtime/Types/ReflectedEvent.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting.Core/Microsoft.Scripting.Core.ruleset
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Microsoft.Dynamic.ruleset
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Actions/Calls/KeywordArgBuilder.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Actions/Calls/ParamsArgBuilder.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Generation/CompilerHelpers.cs
$/IronPython/IronPython_Main/Languages/IronPython/Tests/test_builtinfunc.py
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/LightDynamicExpression.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Interpreter/Instructions/InstructionList.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Interpreter/BranchLabel.cs
$/IronPython/IronPython_Main/Languages/IronPython/Tests/Tools/baselines/sys.log
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting.Core/Microsoft.Scripting.Core.csproj
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Actions/Calls/MethodCandidate.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Interpreter/Interpreter.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Interpreter/LightCompiler.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/FlowControlRewriter.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Ast/GeneratorRewriter.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Actions/Calls/ParamsDictArgBuilder.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Actions/Calls/DefaultArgBuilder.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Interpreter/LoopCompiler.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Actions/Calls/ArgBuilder.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Runtime/ScriptingRuntimeHelpers.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Hosting/Shell/Remote/RemoteCommandDispatcher.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/ComInterop/IDispatchComObject.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Actions/Calls/ReferenceArgBuilder.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/SourceFileContentProvider.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Interpreter/Instructions/LabelInfo.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Actions/DefaultBinder.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Microsoft.Dynamic.csproj
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Interpreter/InterpretedFrame.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Actions/Calls/SimpleArgBuilder.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Utils/DynamicUtils.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Interpreter/LightDelegateCreator.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting.Core/Microsoft.Scripting.ExtensionAttribute.ruleset
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Hosting/TokenCategorizer.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Interpreter/LightLambda.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Interpreter/LocalVariables.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Interpreter/Instructions/ControlFlowInstructions.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Hosting/ScriptHost.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting.Core/Microsoft.Scripting.ExtensionAttribute.csproj
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Actions/Calls/BindingTarget.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Dynamic/Runtime/AmbiguousFileNameException.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Hosting/ScriptSource.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/SyntaxErrorException.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Hosting/ScriptScope.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/PlatformAdaptationLayer.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Hosting/ScriptIO.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Hosting/ErrorListener.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/SourceCodeReader.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting.Debugging/Microsoft.Scripting.Debugging.csproj
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/SymbolId.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Hosting/ObjectOperations.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Hosting/DocumentationOperations.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/SourceFileContentProvider.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Hosting/CompiledCode.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Hosting/ExceptionOperations.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Hosting/ScriptEngine.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Microsoft.Scripting.csproj
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Hosting/ScriptRuntime.cs
$/IronPython/IronPython_Main/Runtime/Microsoft.Scripting/Microsoft.Scripting.ruleset
CHECKIN COMMENTS
--------------------------------------------------------------------------------
Changeset Id: 1827690
Date: 5/22/2010 1:30:23 PM
Removes the BindDelegate paths for calling built-in functions and instead uses
the interpreter. Adds a new InterpretedBinder class for doing these bindings,
invalidating the interpreted binding, and promoting to a compiled binding.
Fixes an issue w/ the interpreter where we cannot interpret a method which is
an instance call on a value type (because the call doesn’t properly mutate the
value type).
(Shelveset: interpetedbuiltinfunctionsfinal2;REDMOND\dinov | SNAP CheckinId:
10822)
--------------------------------------------------------------------------------
Changeset Id: 1827425
Date: 5/21/2010 10:08:25 PM
This is a pretty big change (and there’s more to be done to plumb the feature
through)… It includes both the new light exception feature, some changes to
IronPython exception handling to make it more efficient, and some other
interpreter tweaks to make that more efficient as well, along with other fixes
to support things we didn’t properly handle before. Overall we are now pretty
competitive with CPython (we used to be about the same speed but something may
have regressed as the finishing touches came in – we’re now about 25% slower).
Let’s start with the various DLR changes.
First fixing things which were broken:
FlowControlRewriter doesn’t properly handle cross block jumps. I’ve added a
hack so that we can specifically handle the one sort of cross block jump we
need to support now.
GeneratorRewriter wasn’t properly handling assignments where the rhs is a label
expression. We now get support for properly re-writing these. This also shows
up over in the IronPython GeneratorRewriter as well.
Fix a bug where CompileAsVoid wasn’t tracking our current label block
Fix an issue in GenerateSystemCoreCsproj which was introduced when we changed
from Merlin to DLR
Fix an issue in run_host.cmd where our path is wrong preventing ipt from working
Interpreter Efficiency changes:
Added HybridReferenceDictionary for when we have a small number
of label targets and parameters. Rather than hashing we store them in an array
and spin through the array checking for pointer equality. When we get too many
we spill over into a dictionary.
Removed InterpreterFrame.FaultingInstruction – it’s no longer
used
Removed LightCompiler’s special handling for
MethodBase.GetCurrentMethod – it’s no longer used
Added singleton of empty locals so we don’t create empty arrays
every time we enter a block w/o variables.
Added support for LightLambdaExpression – these don’t have all
the validation of a normal lambda and can be light compiled w/o creating a
LambdaExpression. As part of this we now flow lambda names around rather than
holding onto the entire LambdaExpression.
Removed SkipInterpretExpression and the ParameterVisitor –these
are no longer used.
LightDynamicExpressions get a VisitChildren
implementation which prevents them from getting reduced when they’re visited.
They also get a virtual Rewrite method so that subclasses can customize
re-writing and pass on any additional information they need.
LightLambda: added code path for creating fast
ctor’s, improved the general code path so that we cache Delegate.CreateDelegate
calls instead of going through what was MakeRunMethodOrFastCtor every time.
Made OffsetInstruction.Fixup non-virtual
Added EmitDynamic<T*> overloads
Other interpreter changes:
Added some additional public surface area for
people consuming the interpreter directly.
Ok, onto the feature at hand… We add a new LightExceptions
class which is the entry point for everything light exception related. It
includes functions to re-write ASTs, to throw and check for light exceptions,
and for producing helpers such as an expression which performs a call to a
light-throwing method and wraps it in a check if it’s not consumed in a light
throwing area. We introduce a bunch of new types and interfaces as well:
ILightExceptionAwareExpression – this is an expression which
can be reduced in a way which enables it to support light exceptions. For
example we have LightThrowingCallExpression which implements this. When this
expression is normally reduced we reduce it to the method call plus a check and
.NET throw. When it’s reduced in the light aware it’s reduced to check and
light throw (which turns into a return or a branch to exception handling code).
ILightExceptionBinder – this represents a call site binder
which either supports calling with light exceptions or can be turned into a
binder which does. When we re-write an AST we check for dynamic nodes which
contain this type of binder. If we find them we get the light aware binder,
re-write the dynamic node, and add a check and light throw.
LightThrowingCallExpression – this is a public type which
represents a method call to an API which will throw light exceptions. It
implements ILightExceptionAwareExpression so that it gets properly reduced.
There’s a bunch of new internal types as well:
LightCheckAndThrowExpression: This is an expression which is
used at the boundaries of light code. It checks to see if the expression is a
light exception and if it is throws it.
LightExceptionRewriteExpression: This class is an expression
which reduces and lazily re-writes its contents so they’re light exception
aware. This makes it cheap for us to mark the node as needing a re-write when
producing the AST but not have the re-write occur until the node is reduced.
It’s also ILightExceptionAwareExpression so that if it’s outer body gets
re-written for light exceptions it’ll combine together with the inner body w/o
throwing a real exception.
LightExceptionRewriter: this is the core of the light
exception system. It re-writes a non-light exception aware AST to one that is
aware of light exceptions. There are two significant re-writes which happen
here. The first is for an expression which may produce a light exception.
Here we wrap this in a LightExceptionCheckExpression which does:
If((_lastValue = expr), IsLightException(_lastValue)) {
goto returnOrCurrentHandler(_lastValue);
} else {
_lastValue;
}
As we re-write the tree we keep track if we’re in a try block or not. As we do
so the goto either goes to the outer label for the entire expression or it goes
to the handler for the exception. We then re-write try blocks like this:
goto tryDone(
try {
if (LightExceptions.IsLightException(_lastValue = someCall)) {
goto ehLabel;
} else {
_lastValue
}
} catch(Exception e) {
handler;
}
)
ehLabel:
if ((e = GetLightException(_lastValue) as Exception)) != null) {
handler;
} else {
// unhandled exception, propagate up, either:
goto _returnValue(_lastValue);
// if we weren't in a nested exception handler or if we were:
goto _ehLabelOuter;
}
tryDone:
// yields either the value of the try block or the real catch block
// from the goto tryDone or it gets it's default value from ehLabel
// which is branched to when an exception is detected.
All of this combines together in the following way. We are
creating segments of the call stack in which light exceptions are passed
through rather than thrown. We do this via AST rewriting and using binders
which are aware if they support light exceptions or not. We start by
re-writing code which is likely to handle exceptions – currently all Python
code in a try body is considered likely to handle exceptions. Also if a piece
of code sees over 20 exceptions then we’ll also re-write it. So we re-write
one piece of code and it now all of its binders are marked as being light
exception aware. So when we call to another python function we can use the
light delegate target instead of the normal delegate target. And it can all
chain together nicely. If a light exception reaches the outer boundary then
it’s turned into a real exception.
Finally all of the light exception support has interpreter
support via instruction providers as well. This enables us to efficiently go
from the produced AST to the interpreter without creating a bunch of
intermediary DLR ASTs.
So with that let’s go onto the Python changes. Of course Python is updated to
use all of this stuff. That includes a few choice location where we implement
light throwing methods (nt.stat, import, and making eval use light exception
aware code as well), global variable access.
FunctionCode gains a new delegate for light throwing exceptions. We also no
longer register exec/eval code in our list of function codes (it’s going to go
away immediately so there’s no chance it can be re-executes w/ a change to
tracing)
All binders are updated to throw an exception via a helper which checks to see
if the binder is light exception aware and if so throws a light exception.
Calls to built-in functions now check for LightThrowingAttribute and if it’s
defined will add the check and re-throw if they’re not light throwing aware
calls.
Exceptions see a lot of changes. It turns out accessing the Data property of
an exception is quite expensive. So now we have derived exceptions for all
frequently thrown exception types. These exceptions implement
IPythonAwareException which lets us store the data we need on the exception
object w/o accessing the Data dictionary. This includes the exception frames
and the trace back object. We also lose our PythonExceptions.ToClrHelper in
favor of a field added to PythonType which gives us a delegate to convert
exceptions. Going from .NET to Python uses IPythonAwareException if it’s
available. This greatly speeds up the translation between Python and .NET.
There’s also a bunch of simplification to our frame unification in
PythonExceptions – most of this code seems to be redundant w/ other frame
unification code we have.
Efficiency changes:
We now use LightLambdaExpression rather than LambdaExpression.
This saves us all of the validation. I’ve also switched the delegate type over
to a non generic delegate type which is faster to create and faster to create
the LambdaExpression from as well.
We now use PythonDynamicExpression’s in more places and the
virtuals for changing this on compilation mode are now ReduceDynamic instead of
Reduce. Reduce now returns the light version if the args can handle it.
Added IInstructionProvider implementation to ConstantExpression
Simplified calls to UpdateStackTrace (removed method name, file
name, and MethodBase – these can all be derived from the function code object)
Added fast access for sys.exc_type, sys.exc_traceback, and
sys.exc_value so these aren’t really expensive as we handle exceptions (can be
removed in IronPython 3k), add a SysModuleDictionaryStorage which specializes
these.
Simplified the error reporting for binary operations – I
believe this code was optimized for when we had auto-templating support in the
DLR. Now that that is gone we may as well format the string before producing
the rule.
Small fixes:
Getfilesystemencoding() now matches CPython and returns mbcs
Fix a potential stack overflow for subclasses of
CommonDictionaryStorage which calculate Count based on a call to GetItems()
Fix an issue w/ returning the null value from
CommonDictionaryStorage
Fix an issue where we’re not re-calculating a function’s cached
compatibility after updating it’s function code.
(Shelveset: LightEhFinal3;REDMOND\dinov | SNAP CheckinId: 10820)
_______________________________________________
Users mailing list
Users@lists.ironpython.com
http://lists.ironpython.com/listinfo.cgi/users-ironpython.com
