diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Project/PythonBinding.csproj b/src/AddIns/BackendBindings/Python/PythonBinding/Project/PythonBinding.csproj index e30237378c..ba1b6be44d 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Project/PythonBinding.csproj +++ b/src/AddIns/BackendBindings/Python/PythonBinding/Project/PythonBinding.csproj @@ -58,6 +58,9 @@ ..\..\RequiredLibraries\Microsoft.Scripting.dll + + ..\..\RequiredLibraries\Microsoft.Scripting.Metadata.dll + 3.0 @@ -183,6 +186,10 @@ Chiron.exe.Config Always + + License.Rtf + Always + Always diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonAstWalker.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonAstWalker.cs index 1674f4095a..26dcf0d648 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonAstWalker.cs +++ b/src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonAstWalker.cs @@ -48,8 +48,10 @@ namespace ICSharpCode.PythonBinding public override bool Walk(ClassDefinition classDefinition) { - PythonClass c = new PythonClass(compilationUnit, classDefinition); - WalkClassBody(c, classDefinition.Body); + if (classDefinition.Parent != null) { + PythonClass c = new PythonClass(compilationUnit, classDefinition); + WalkClassBody(c, classDefinition.Body); + } return false; } diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonMethodOrClassBodyRegion.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonMethodOrClassBodyRegion.cs index 1c5acbc67d..4288be7e27 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonMethodOrClassBodyRegion.cs +++ b/src/AddIns/BackendBindings/Python/PythonBinding/Project/Src/PythonMethodOrClassBodyRegion.cs @@ -23,7 +23,16 @@ namespace ICSharpCode.PythonBinding public static DomRegion GetBodyRegion(Statement body, SourceLocation header) { int columnAfterColonCharacter = header.Column + 1; - return new DomRegion(header.Line, header.Column + 1, body.End.Line, body.End.Column); + SourceLocation bodyEnd = GetBodyEndLocation(body); + return new DomRegion(header.Line, columnAfterColonCharacter, bodyEnd.Line, bodyEnd.Column); + } + + static SourceLocation GetBodyEndLocation(Statement body) + { + if (body.Parent != null) { + return body.End; + } + return SourceLocation.Invalid; } public static DomRegion GetBodyRegion(FunctionDefinition methodDefinition) diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Designer/EventHandlerAlreadyExistsTestFixture.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Designer/EventHandlerAlreadyExistsTestFixture.cs index 99dc272e22..bc9be20ed7 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Designer/EventHandlerAlreadyExistsTestFixture.cs +++ b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Designer/EventHandlerAlreadyExistsTestFixture.cs @@ -52,19 +52,20 @@ namespace PythonBinding.Tests.Designer protected override string GetTextEditorCode() { - return "from System.Windows.Forms import Form\r\n" + - "\r\n" + - "class MainForm(Form):\r\n" + - "\tdef __init__(self):\r\n" + - "\t\tself.InitializeComponents()\r\n" + - "\t\r\n" + - "\tdef InitializeComponents(self):\r\n" + - "\t\tself._button1 = System.Windows.Forms.Button()\r\n" + - "\t\tself._button1.Click += mybuttonclick\r\n" + - "\t\tself.Controls.Add(self._button1)\r\n" + - "\t\r\n" + - "\tdef mybuttonclick(self, sender, e)\r\n" + - "\t\tpass\r\n"; + return + "from System.Windows.Forms import Form\r\n" + + "\r\n" + + "class MainForm(Form):\r\n" + + " def __init__(self):\r\n" + + " self.InitializeComponents()\r\n" + + " \r\n" + + " def InitializeComponents(self):\r\n" + + " self._button1 = System.Windows.Forms.Button()\r\n" + + " self._button1.Click += mybuttonclick\r\n" + + " self.Controls.Add(self._button1)\r\n" + + " \r\n" + + " def mybuttonclick(self, sender, e):\r\n" + + " pass\r\n"; } } } diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Designer/EventHandlerExistsWithIncorrectParameterCountTestFixture.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Designer/EventHandlerExistsWithIncorrectParameterCountTestFixture.cs index ca077412fd..20f78d7b8c 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Designer/EventHandlerExistsWithIncorrectParameterCountTestFixture.cs +++ b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Designer/EventHandlerExistsWithIncorrectParameterCountTestFixture.cs @@ -28,8 +28,9 @@ namespace PythonBinding.Tests.Designer public void ExpectedCodeAfterEventHandlerInserted() { string expectedCode = GetTextEditorCode(); - string eventHandler = "\tdef mybuttonclick(self, sender, e):\r\n" + - "\t\tpass"; + string eventHandler = + "\tdef mybuttonclick(self, sender, e):\r\n" + + "\t\tpass"; expectedCode = expectedCode + "\r\n" + eventHandler; Assert.AreEqual(expectedCode, viewContent.DesignerCodeFileContent); @@ -37,18 +38,19 @@ namespace PythonBinding.Tests.Designer protected override string GetTextEditorCode() { - return "from System.Windows.Forms import Form\r\n" + - "\r\n" + - "class MainForm(Form):\r\n" + - "\tdef __init__(self):\r\n" + - "\t\tself.InitializeComponents()\r\n" + - "\t\r\n" + - "\tdef InitializeComponents(self):\r\n" + - "\t\tself._button1 = System.Windows.Forms.Button()\r\n" + - "\t\tself._button1.Click += mybuttonclick\r\n" + - "\t\r\n" + - "\tdef mybuttonclick(self)\r\n" + - "\t\tpass\r\n"; + return + "from System.Windows.Forms import Form\r\n" + + "\r\n" + + "class MainForm(Form):\r\n" + + "\tdef __init__(self):\r\n" + + "\t\tself.InitializeComponents()\r\n" + + "\t\r\n" + + "\tdef InitializeComponents(self):\r\n" + + "\t\tself._button1 = System.Windows.Forms.Button()\r\n" + + "\t\tself._button1.Click += mybuttonclick\r\n" + + "\t\r\n" + + "\tdef mybuttonclick(self):\r\n" + + "\t\tpass\r\n"; } } } diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Parsing/InvalidCastInPythonParserTestFixture.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Parsing/InvalidCastInPythonParserTestFixture.cs index 7a01b300fb..ad347b3f8c 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Parsing/InvalidCastInPythonParserTestFixture.cs +++ b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Parsing/InvalidCastInPythonParserTestFixture.cs @@ -34,9 +34,10 @@ namespace PythonBinding.Tests.Parsing [TestFixture] public class InvalidCastInPythonParserTestFixture { - string code = "class Project(id): \r\n" + - " def __init__ Project_ID(): \r\n" + - " #i\r\n"; + string code = + "class Project(id): \r\n" + + " def __init__ Project_ID(): \r\n" + + " #i\r\n"; /// /// Check that IronPython bug has been fixed exists. diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveBuiltInRoundMethodTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveBuiltInRoundMethodTests.cs index b63f7e7d72..76df154c88 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveBuiltInRoundMethodTests.cs +++ b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Resolver/ResolveBuiltInRoundMethodTests.cs @@ -44,10 +44,10 @@ namespace PythonBinding.Tests.Resolver } [Test] - public void ResolveResultContainingTypeHasTwoRoundMethods() + public void ResolveResultContainingTypeHasFourRoundMethods() { List exitMethods = GetRoundMethods(); - Assert.AreEqual(2, exitMethods.Count); + Assert.AreEqual(4, exitMethods.Count); } List GetRoundMethods() @@ -78,10 +78,10 @@ namespace PythonBinding.Tests.Resolver } [Test] - public void OneRoundMethodHasTwoParameters() + public void ThreeRoundMethodsHaveTwoParameters() { int parameterCount = 2; - Assert.AreEqual(1, GetRoundMethods(parameterCount).Count); + Assert.AreEqual(3, GetRoundMethods(parameterCount).Count); } [Test] diff --git a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Utils/Tests/PythonParserHelperTests.cs b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Utils/Tests/PythonParserHelperTests.cs index 48342494cb..b96bea91b8 100644 --- a/src/AddIns/BackendBindings/Python/PythonBinding/Test/Utils/Tests/PythonParserHelperTests.cs +++ b/src/AddIns/BackendBindings/Python/PythonBinding/Test/Utils/Tests/PythonParserHelperTests.cs @@ -17,7 +17,7 @@ namespace PythonBinding.Tests.Utils.Tests { string code = "class foo:\r\n" + - "pass"; + " pass"; ParseInformation parseInfo = PythonParserHelper.CreateParseInfo(code); Assert.AreEqual("foo", parseInfo.CompilationUnit.Classes[0].Name); diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/Chiron.exe b/src/AddIns/BackendBindings/Python/RequiredLibraries/Chiron.exe index 40a6ed44cf..bf15938eaf 100644 Binary files a/src/AddIns/BackendBindings/Python/RequiredLibraries/Chiron.exe and b/src/AddIns/BackendBindings/Python/RequiredLibraries/Chiron.exe differ diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.Modules.dll b/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.Modules.dll index 478dbe20cb..5d0dd5b46e 100755 Binary files a/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.Modules.dll and b/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.Modules.dll differ diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.Modules.xml b/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.Modules.xml index fd3e677134..003129316a 100644 --- a/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.Modules.xml +++ b/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.Modules.xml @@ -4,6 +4,1932 @@ IronPython.Modules + + + This class represents adler32 checksum algorithm + + + + + This static method returns adler32 checksum of the buffer data + + + + + Implementation of the Deflate compression algorithm. + + + + + Maximum memory level + + + + + Defalult compression method + + + + + Default memory level + + + + + block not completed, need more input or more output + + + + + Block internalFlush performed + + + + + Finish started, need only more output at next deflate + + + + + finish done, accept no more input or output + + + + + preset dictionary flag in zlib header + + + + + The deflate compression method + + + + + The size of the buffer + + + + + repeat previous bit length 3-6 times (2 bits of repeat count) + + + + + repeat a zero length 3-10 times (3 bits of repeat count) + + + + + repeat a zero length 11-138 times (7 bits of repeat count) + + + + + Deflate class congiration table + + + + + Pointer back to this zlib stream + + + + + As the name implies + + + + + Output still pending + + + + + Size of Pending_buf + + + + + Next pending byte to output to the stream + + + + + Number of bytes in the pending buffer + + + + + suppress zlib header and adler32 + + + + + UNKNOWN, BINARY or ASCII + + + + + STORED (for zip only) or DEFLATED + + + + + Value of internalFlush parameter for previous deflate call + + + + + LZ77 Window size (32K by default) + + + + + log2(w_size) (8..16) + + + + + w_size - 1 + + + + + Sliding Window. Input bytes are ReadPos into the second half of the Window, + and move to the first half later to keep a dictionary of at least wSize + bytes. With this organization, matches are limited to a distance of + wSize-MAX_MATCH bytes, but this ensures that IO is always + performed with a length multiple of the block size. Also, it limits + the Window size to 64K, which is quite useful on MSDOS. + To do: use the user input buffer as sliding Window. + + + + + Actual size of Window: 2*wSize, except when the user input buffer is directly used as sliding Window. + + + + + Link to older string with same hash index. To limit the size of this + array to 64K, this link is maintained only for the last 32K strings. + An index in this array is thus a Window index modulo 32K. + + + + + Heads of the hash chains or NIL. + + + + + hash index of string to be inserted + + + + + number of elements in hash table + + + + + log2(hash_size) + + + + + hash_size-1 + + + + + Number of bits by which ins_h must be shifted at each input + step. It must be such that after MIN_MATCH steps, the oldest + byte no longer takes part in the hash key, that is: + hash_shift * MIN_MATCH >= hash_bits + + + + + Window position at the beginning of the current output block. Gets negative when the Window is moved backwards. + + + + + length of best match + + + + + previous match + + + + + set if previous match exists + + + + + start of string to insert + + + + + start of matching string + + + + + number of valid bytes ahead in Window + + + + + Length of the best match at previous step. Matches not greater than this + are discarded. This is used in the lazy match evaluation. + + + + + To speed up deflation, hash chains are never searched beyond this + length. A higher limit improves compression ratio but degrades the speed. + + + + + Attempt to find a better match only when the current match is strictly + smaller than this value. This mechanism is used only for compression + levels >= 4. + + + + + compression level (1..9) + + + + + favor or force Huffman coding + + + + + Use a faster search when the previous match is longer than this + + + + + Stop searching when current match exceeds this + + + + + literal and length tree + + + + + distance tree + + + + + Huffman tree for bit lengths + + + + + Desc for literal tree + + + + + desc for distance tree + + + + + desc for bit length tree + + + + + number of codes at each bit length for an optimal tree + + + + + heap used to build the Huffman trees + + + + + number of elements in the heap + + + + + element of largest frequency + + + + + Depth of each subtree used as tie breaker for trees of equal frequency + + + + + index for literals or lengths + + + + + Size of match buffer for literals/lengths. There are 4 reasons for + limiting lit_bufsize to 64K: + - frequencies can be kept in 16 bit counters + - if compression is not successful for the first block, all input + data is still in the Window so we can still emit a stored block even + when input comes from standard input. (This can also be done for + all blocks if lit_bufsize is not greater than 32K.) + - if compression is not successful for a file smaller than 64K, we can + even emit a stored file instead of a stored block (saving 5 bytes). + This is applicable only for zip (not gzip or zlib). + - creating new Huffman trees less frequently may not provide fast + adaptation to changes in the input data statistics. (Take for + example a binary file with poorly compressible code followed by + a highly compressible string table.) Smaller buffer sizes give + fast adaptation but have of course the overhead of transmitting + trees more frequently. + - I can't count above 4 + + + + + running index in l_buf + + + + + index of pendig_buf + + + + + bit length of current block with optimal trees + + + + + bit length of current block with static trees + + + + + number of string matches in current block + + + + + bit length of EOB code for last block + + + + + Output buffer. bits are inserted starting at the bottom (least + significant bits). + + + + + Number of valid bits in bi_buf. All bits above the last valid bit + are always zero. + + + + + Default constructor + + + + + Initialization + + + + + Initialize the tree data structures for a new zlib stream. + + + + + Initializes block + + + + + Restore the heap property by moving down the tree starting at node k, + exchanging a node with the smallest of its two sons if necessary, stopping + when the heap property is re-established (each father smaller than its + two sons). + + + + + Scan a literal or distance tree to determine the frequencies of the codes + in the bit length tree. + + + + + Construct the Huffman tree for the bit lengths and return the index in + bl_order of the last bit length code to send. + + + + + Send the header for a block using dynamic Huffman trees: the counts, the + lengths of the bit length codes, the literal tree and the distance tree. + IN assertion: lcodes >= 257, dcodes >= 1, blcodes >= 4. + + + + + Send a literal or distance tree in compressed form, using the codes in + bl_tree. + + + + + Output a byte on the stream. + IN assertion: there is enough room in Pending_buf. + + + + + Adds a byte to the buffer + + + + + Send one empty static block to give enough lookahead for inflate. + This takes 10 bits, of which 7 may remain in the bit buffer. + The current inflate code requires 9 bits of lookahead. If the + last two codes for the previous block (real code plus EOB) were coded + on 5 bits or less, inflate may have only 5+3 bits of lookahead to decode + the last real code. In this case we send two empty static blocks instead + of one. (There are no problems if the previous block is stored or fixed.) + To simplify the code, we assume the worst case of last real code encoded + on one bit only. + + + + + Save the match info and tally the frequency counts. Return true if + the current block must be flushed. + + + + + Send the block data compressed using the given Huffman trees + + + + + Set the data type to ASCII or BINARY, using a crude approximation: + binary if more than 20% of the bytes are <= 6 or >= 128, ascii otherwise. + IN assertion: the fields freq of dyn_ltree are set and the total of all + frequencies does not exceed 64K (to fit in an int on 16 bit machines). + + + + + Flush the bit buffer, keeping at most 7 bits in it. + + + + + Flush the bit buffer and align the output on a byte boundary + + + + + Copy a stored block, storing first the length and its + one's complement if requested. + + + + + Flushes block + + + + + Copy without compression as much as possible from the input stream, return + the current block state. + This function does not insert new strings in the dictionary since + uncompressible data is probably not useful. This function is used + only for the level=0 compression option. + NOTE: this function should be optimized to avoid extra copying from + Window to Pending_buf. + + + + + Send a stored block + + + + + Determine the best encoding for the current block: dynamic trees, static + trees or store, and output the encoded block to the zip file. + + + + + Fill the Window when the lookahead becomes insufficient. + Updates strstart and lookahead. + + IN assertion: lookahead less than MIN_LOOKAHEAD + OUT assertions: strstart less than or equal to window_size-MIN_LOOKAHEAD + At least one byte has been ReadPos, or _avail_in == 0; reads are + performed for at least two bytes (required for the zip translate_eol + option -- not supported here). + + + + + Compress as much as possible from the input stream, return the current + block state. + This function does not perform lazy evaluation of matches and inserts + new strings in the dictionary only for unmatched strings or for short + matches. It is used only for the fast compression options. + + + + + Same as above, but achieves better compression. We use a lazy + evaluation for matches: a match is finally adopted only if there is + no better match at the next Window position. + + + + + Finds the longest matching data part + + + + + Deflate algorithm initialization + + ZStream object + Compression level + Window bits + A result code + + + + Initializes deflate algorithm + + ZStream object + Compression level + Operation result result code + + + + Deflate algorithm initialization + + ZStream object + Compression level + Compression method + Window bits + Memory level + Compression strategy + Operation result code + + + + Resets the current state of deflate object + + + + + Finish compression with deflate algorithm + + + + + Sets deflate algorithm parameters + + + + + Sets deflate dictionary + + + + + Performs data compression with the deflate algorithm + + + + + Static constructor initializes config_table + + + + + Compression level + + + + + Number of bytes in the pending buffer + + + + + Output still pending + + + + + Next pending byte to output to the stream + + + + + suppress zlib header and adler32 + + + + + Deflate algorithm configuration parameters class + + + + + reduce lazy search above this match length + + + + + do not perform lazy search above this match length + + + + + quit search above this match length + + + + + Constructor which initializes class inner fields + + + + + current inflate_block mode + + + + + if STORED, bytes left to copy + + + + + table lengths (14 bits) + + + + + index into blens (or border) + + + + + bit lengths of codes + + + + + bit length tree depth + + + + + bit length decoding tree + + + + + if CODES, current state + + + + + true if this block is the last block + + + + + bits in bit buffer + + + + + bit buffer + + + + + single malloc for tree space + + + + + sliding Window + + + + + one byte after sliding Window + + + + + Window ReadPos pointer + + + + + Window WritePos pointer + + + + + need check + + + + + check on output + + + + + Resets this InfBlocks class instance + + + + + Block processing functions + + + + + Frees inner buffers + + + + + Sets dictionary + + + + + Returns true if inflate is currently at the End of a block generated + by Z_SYNC_FLUSH or Z_FULL_FLUSH. + + + + + copy as much as possible from the sliding Window to the output area + + + + + sliding window + + + + + one byte after sliding Window + + + + + Window ReadPos pointer + + + + + Window WritePos pointer + + + + + bits in bit buffer + + + + + bit buffer + + + + + Inflate codes mode + + + + + This class is used by the InfBlocks class + + + + + current inflate_codes mode + + + + + length + + + + + pointer into tree + + + + + current index of the tree + + + + + + + + + + ltree bits decoded per branch + + + + + dtree bits decoded per branch + + + + + literal/length/eob tree + + + + + literal/length/eob tree index + + + + + distance tree + + + + + distance tree index + + + + + Constructor which takes literal, distance trees, corresponding bites decoded for branches, corresponding indexes and a ZStream object + + + + + Constructor which takes literal, distance trees, corresponding bites decoded for branches and a ZStream object + + + + + Block processing method + + An instance of the InfBlocks class + A ZStream object + A result code + + + + Frees allocated resources + + + + + Fast inflate procedure. Called with number of bytes left to WritePos in Window at least 258 + (the maximum string length) and number of input bytes available + at least ten. The ten bytes are six bytes for the longest length/ + distance pair plus four bytes for overloading the bit buffer. + + + + + This enumeration contains modes of inflate processing + + + + + waiting for method byte + + + + + waiting for flag byte + + + + + four dictionary check bytes to go + + + + + three dictionary check bytes to go + + + + + two dictionary check bytes to go + + + + + one dictionary check byte to go + + + + + waiting for inflateSetDictionary + + + + + decompressing blocks + + + + + four check bytes to go + + + + + three check bytes to go + + + + + two check bytes to go + + + + + one check byte to go + + + + + finished check, done + + + + + got an error--stay here + + + + + current inflate mode + + + + + if FLAGS, method byte + + + + + computed check value + + + + + stream check value + + + + + if BAD, inflateSync's marker bytes count + + + + + flag for no wrapper + + + + + log2(Window size) (8..15, defaults to 15) + + + + + current inflate_blocks state + + + + + Resets the Inflate algorithm + + A ZStream object + A result code + + + + Finishes the inflate algorithm processing + + A ZStream object + Operation result code + + + + Initializes the inflate algorithm + + A ZStream object + Window size + Operation result code + + + + Runs inflate algorithm + + A ZStream object + Flush strategy + Operation result code + + + + Sets dictionary for the inflate operation + + A ZStream object + An array of byte - dictionary + Dictionary length + Operation result code + + + + Inflate synchronization + + A ZStream object + Operation result code + + + + Returns true if inflate is currently at the End of a block generated + by Z_SYNC_FLUSH or Z_FULL_FLUSH. This function is used by one PPP + implementation to provide an additional safety check. PPP uses Z_SYNC_FLUSH + but removes the length bytes of the resulting empty stored block. When + decompressing, PPP checks that at the End of input packet, inflate is + waiting for these length bytes. + + + + + Contains utility information for the InfTree class + + + + + Given a list of code lengths and a maximum table size, make a set of + tables to decode that set of codes. + + Return (int)ZLibResultCode.Z_OK on success, (int)ZLibResultCode.Z_DATA_ERROR if the given code set is incomplete (the tables are still built in this case), (int)ZLibResultCode.Z_DATA_ERROR if the input is invalid (an over-subscribed set of lengths), or (int)ZLibResultCode.Z_DATA_ERROR if not enough memory. + + + + + Build trees + + + + + Builds dynamic trees + + + + + Build fixed trees + + + + + Bit length codes must not exceed MAX_BL_BITS bits + + + + + This class represents a tree and is used in the Deflate class + + + + + The dynamic tree + + + + + Largest code with non zero frequency + + + + + the corresponding static tree + + + + + Mapping from a distance to a distance code. dist is the distance - 1 and + must not have side effects. _dist_code[256] and _dist_code[257] are never + used. + + + + + Compute the optimal bit lengths for a tree and update the total bit length + for the current block. + IN assertion: the fields freq and dad are set, heap[heap_max] and + above are the tree nodes sorted by increasing frequency. + OUT assertions: the field count is set to the optimal bit length, the + array bl_count contains the frequencies for each bit length. + The length opt_len is updated; static_len is also updated if stree is + not null. + + + + + Construct one Huffman tree and assigns the code bit strings and lengths. + Update the total bit length for the current block. + IN assertion: the field freq is set for all tree elements. + OUT assertions: the fields count and code are set to the optimal bit length + and corresponding code. The length opt_len is updated; static_len is + also updated if stree is not null. The field max_code is set. + + + + + Generate the codes for a given tree and bit counts (which need not be + optimal). + IN assertion: the array bl_count contains the bit length statistics for + the given tree and the field count is set for all tree elements. + OUT assertion: the field code is set for all tree elements of non + zero code length. + + + + + Reverse the first count bits of a code, using straightforward code (a faster + method would use a table) + + + + + The dynamic tree + + + + + Largest code with non zero frequency + + + + + the corresponding static tree + + + + + Some constants for specifying compression levels. Methods which takes a compression level as a parameter expects an integer value from 0 to 9. You can either specify an integer value or use constants for some most widely used compression levels. + + + + + No compression should be used at all. + + + + + Minimal compression, but greatest speed. + + + + + Maximum compression, but slowest. + + + + + Select default compression level (good compression, good speed). + + + + + Compression strategies. The strategy parameter is used to tune the compression algorithm. The strategy parameter only affects the compression ratio but not the correctness of the compressed output even if it is not set appropriately. + + + + + This strategy is designed for filtered data. Data which consists of mostly small values, with random distribution should use Z_FILTERED. With this strategy, less string matching is performed. + + + + + Z_HUFFMAN_ONLY forces Huffman encoding only (no string match) + + + + + The default strategy is the most commonly used. With this strategy, string matching and huffman compression are balanced. + + + + + Flush strategies + + + + + Do not internalFlush data, but just write data as normal to the output buffer. This is the normal way in which data is written to the output buffer. + + + + + Obsolete. You should use Z_SYNC_FLUSH instead. + + + + + All pending output is flushed to the output buffer and the output is aligned on a byte boundary, so that the decompressor can get all input data available so far. + + + + + All output is flushed as with Z_SYNC_FLUSH, and the compression state is reset so that decompression can restart from this point if previous compressed data has been damaged or if random access is desired. Using Z_FULL_FLUSH too often can seriously degrade the compression. ZLib_InflateSync will locate points in the compression string where a full has been performed. + + + + + Notifies the module that the input has now been exhausted. Pending input is processed, pending output is flushed and calls return with Z_STREAM_END if there was enough output space. + + + + + Results of operations in ZLib library + + + + + No failure was encountered, the operation completed without problem. + + + + + No failure was encountered, and the input has been exhausted. + + + + + A preset dictionary is required for decompression of the data. + + + + + An internal error occurred + + + + + The stream structure was inconsistent + + + + + Input data has been corrupted (for decompression). + + + + + Memory allocation failed. + + + + + There was not enough space in the output buffer. + + + + + The version supplied does not match that supported by the ZLib module. + + + + + States of deflate operation + + + + + Data block types, i.e. binary or ascii text + + + + + Helper class + + + + + Max Window size + + + + + preset dictionary flag in zlib header + + + + + The size of the buffer + + + + + Deflate compression method index + + + + + see definition of array dist_code below + + + + + This method returns the literal value received + + The literal to return + The received value + + + + This method returns the literal value received + + The literal to return + The received value + + + + This method returns the literal value received + + The literal to return + The received value + + + + This method returns the literal value received + + The literal to return + The received value + + + + Performs an unsigned bitwise right shift with the specified number + + Number to operate on + Ammount of bits to shift + The resulting number from the shift operation + + + + Performs an unsigned bitwise right shift with the specified number + + Number to operate on + Ammount of bits to shift + The resulting number from the shift operation + + + + Performs an unsigned bitwise right shift with the specified number + + Number to operate on + Ammount of bits to shift + The resulting number from the shift operation + + + + Performs an unsigned bitwise right shift with the specified number + + Number to operate on + Ammount of bits to shift + The resulting number from the shift operation + + + Reads a number of characters from the current source Stream and writes the data to the target array at the specified index. + The source Stream to ReadPos from. + Contains the array of characters ReadPos from the source Stream. + The starting index of the target array. + The maximum number of characters to ReadPos from the source Stream. + The number of characters ReadPos. The number will be less than or equal to count depending on the data available in the source Stream. Returns -1 if the End of the stream is reached. + + + Reads a number of characters from the current source TextReader and writes the data to the target array at the specified index. + The source TextReader to ReadPos from + Contains the array of characteres ReadPos from the source TextReader. + The starting index of the target array. + The maximum number of characters to ReadPos from the source TextReader. + The number of characters ReadPos. The number will be less than or equal to count depending on the data available in the source TextReader. Returns -1 if the End of the stream is reached. + + + + Converts a string to an array of bytes + + The string to be converted + The new array of bytes + + + + Converts an array of bytes to an array of chars + + The array of bytes to convert + The new array of chars + + + + Copies large array which was passed as srcBuf to the Initialize method into the destination array which were passes as destBuff + + The number of bytes copied + + + + ZStream is used to store user data to compress/decompress. + + + + + Maximum memory level + + + + + Next input byte array + + + + + Index of the first byte in the input array. + + + + + Number of bytes available at _next_in + + + + + total nb of input bytes ReadPos so far + + + + + Byte array for the next output block + + + + + Index of the first byte in the _next_out array + + + + + Remaining free space at _next_out + + + + + Total number of bytes in output array + + + + + A string to store operation result message (corresponding to result codes) + + + + + A deflate object to perform data compression + + + + + Inflate object to perform data decompression + + + + + Best guess about the data type: ascii or binary + + + + + A checksum computed with Adler algorithm + + + + + Initializes the internal stream state for decompression. The fields , must be + initialized before by the caller. If is not null and is large + enough (the exact value depends on the compression method), determines the compression + method from the ZLib header and allocates all data structures accordingly; otherwise the allocation will be deferred + to the first call of . + + + inflateInit returns if success, if there was not enough memory, + if the ZLib library version is incompatible with the version assumed by the caller. + is set to null if there is no error message. does not perform any decompression + apart from reading the ZLib header if present: this will be done by . (So and + may be modified, but and are unchanged.) + + + + + This is another version of with an extra parameter. The fields , must be + initialized before by the caller. If is not null and is large enough + (the exact value depends on the compression method), determines the compression method from + the ZLib header and allocates all data structures accordingly; otherwise the allocation will be deferred to the first + call of . + + The windowBits parameter is the base two logarithm of the maximum window size (the size of the history buffer). + It should be in the range 8..15 for this version of the library. The default value is 15 if is used instead. + If a compressed stream with a larger window size is given as input, will return with the error code + instead of trying to allocate a larger window. + + inflateInit returns if success, if there was not enough memory, + if a parameter is invalid (such as a negative memLevel). is set to null + if there is no error message. does not perform any decompression apart from reading the ZLib header + if present: this will be done by . (So and may be modified, + but and are unchanged.) + + + + + This method decompresses as much data as possible, and stops when the input buffer () becomes empty or + the output buffer () becomes full. It may some introduce some output latency (reading input without producing any output) + except when forced to flush. + The detailed semantics are as follows. performs one or both of the following actions: + + + Decompress more input starting at and update and + accordingly. If not all input can be processed (because there is not enough room in the output buffer), is updated and + processing will resume at this point for the next call of . + Provide more output starting at and update and + accordingly. provides as much output as possible, until there is no more input data or no more space in + the output buffer (see below about the parameter). + + + + Flush strategy to use. + + Before the call of , the application should ensure that at least one of the actions is possible, by providing + more input and/or consuming more output, and updating the next_* and avail_* values accordingly. The application can consume the uncompressed + output when it wants, for example when the output buffer is full (avail_out == 0), or after each call of . + If returns and with zero , it must be called again + after making room in the output buffer because there might be more output pending. + If the parameter is set to , flushes + as much output as possible to the output buffer. The flushing behavior of is not specified for values of + the parameter other than and , + but the current implementation actually flushes as much output as possible anyway. + should normally be called until it returns or an error. + However if all decompression is to be performed in a single step (a single call of inflate), the parameter + should be set to . In this case all pending input is processed and all pending output is flushed; + must be large enough to hold all the uncompressed data. (The size of the uncompressed data may have been + saved by the compressor for this purpose.) The next operation on this stream must be to deallocate the decompression + state. The use of is never required, but can be used to inform that a faster + routine may be used for the single call. + If a preset dictionary is needed at this point (see ), sets strm-adler + to the adler32 checksum of the dictionary chosen by the compressor and returns ; otherwise it + sets strm->adler to the adler32 checksum of all output produced so far (that is, bytes) and returns + , or an error code as described below. At the end of the stream, + ) checks that its computed adler32 checksum is equal to that saved by the compressor and returns + only if the checksum is correct. + + + returns if some progress has been made (more input processed or more output produced), + if the end of the compressed data has been reached and all uncompressed output has been produced, + if a preset dictionary is needed at this point, if + the input data was corrupted (input stream not conforming to the ZLib format or incorrect adler32 checksum), + if the stream structure was inconsistent (for example if or + was null), if there was not enough memory, + if no progress is possible or if there was not enough room in the output buffer + when is used. In the case, the application + may then call to look for a good compression block. + + + + + All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any + pending output. + + + inflateEnd returns if success, + if the stream state was inconsistent. In the error case, msg may be set but then points to a static string (which must not be deallocated). + + + + + Skips invalid compressed data until a full flush point (see the description of deflate with Z_FULL_FLUSH) can be found, + or until all available input is skipped. No output is provided. + + + returns if a full flush point has been found, + if no more input was provided, if no flush point has been found, or + if the stream structure was inconsistent. In the success case, the application may save the current + current value of which indicates where valid compressed data was found. In the error case, the application may repeatedly + call , providing more input each time, until success or end of the input data. + + + + + Initializes the decompression dictionary from the given uncompressed byte sequence. This function must be called immediately after a call of if this call returned . The dictionary chosen by the compressor can be determined from the Adler32 value returned by this call of . The compressor and decompresser must use exactly the same dictionary. + + A byte array - a dictionary. + The length of the dictionary. + + inflateSetDictionary returns if success, if a parameter is invalid (such as null dictionary) or the stream state is inconsistent, if the given dictionary doesn't match the expected one (incorrect Adler32 value). inflateSetDictionary does not perform any decompression: this will be done by subsequent calls of . + + + + + Initializes the internal stream state for compression. + + An integer value from 0 to 9 indicating the desired compression level. + + deflateInit returns if success, if there was not enough memory, + if level is not a valid compression level. is set to null if there is + no error message. does not perform any compression: this will be done by . + + + + + Initializes the internal stream state for compression. + + An integer value from 0 to 9 indicating the desired compression level. + The windowBits parameter is the base two logarithm of the window size (the size of the history buffer). It should be in the + range 8..15 for this version of the library. Larger values of this parameter result in better compression at the expense of memory usage. + The default value is 15 if deflateInit is used instead. + + deflateInit returns if success, if there was not enough memory, + if level is not a valid compression level. is set to null if there + is no error message. does not perform any compression: this will be done by . + + + + + Deflate compresses as much data as possible, and stops when the input buffer becomes empty or the + output buffer becomes full. It may introduce some output latency (reading input without producing any output) + except when forced to flush. + The detailed semantics are as follows. deflate performs one or both of the following actions: + + Compress more input starting at and update and accordingly. + If not all input can be processed (because there is not enough room in the output buffer), and + are updated and processing will resume at this point for the next call of . + Provide more output starting at and update and accordingly. + This action is forced if the parameter flush is non zero. Forcing flush frequently degrades the compression ratio, so this parameter should + be set only when necessary (in interactive applications). Some output may be provided even if flush is not set. + + + + The flush strategy to use. + + + Before the call of , the application should ensure that at least one of the actions is possible, by providing + more input and/or consuming more output, and updating or accordingly ; + should never be zero before the call. The application can consume the compressed output when it wants, for example when the output buffer is full + (avail_out == 0), or after each call of . If returns + and with zero , it must be called again after making room in the output buffer because there might be more output pending. + + + If the parameter is set to , all pending output is flushed to the + output buffer and the output is aligned on a byte boundary, so that the decompressor can get all input + data available so far. (In particular is zero after the call if enough output space has been provided before the call.) + Flushing may degrade compression for some compression algorithms and so it should be used only when necessary. + + + If flush is set to , all output is flushed as with , + and the compression state is reset so that decompression can restart from this point if previous compressed data has been damaged or if + random access is desired. Using too often can seriously degrade the compression. + + + + + If deflate returns with == 0, this function must be called again with the same value of the flush + parameter and more output space (updated ), until the flush is complete ( returns with + non-zero ). + + + If the parameter is set to , pending input is processed, pending + output is flushed and deflate returns with if there was enough output space ; + if deflate returns with , this function must be called again with + and more output space (updated ) but no more input data, until it returns with + or an error. After deflate has returned , the only possible operation on the stream is + . + + can be used immediately after if all the compression is to be + done in a single step. In this case, avail_out must be at least 0.1% larger than avail_in plus 12 bytes. If deflate does not return + Z_STREAM_END, then it must be called again as described above. + + + sets strm-> adler to the adler32 checksum of all input read so far (that is, bytes). + + + may update data_type if it can make a good guess about the input data type (Z_ASCII or Z_BINARY). + In doubt, the data is considered binary. This field is only for information purposes and does not affect the compression algorithm in any manner. + + + returns if some progress has been made (more input processed or more output produced), + if all input has been consumed and all output has been produced (only when flush is set to + ), if the stream state was inconsistent (for example if + or was null), if no progress is possible + (for example or was zero). + + + + + + All dynamically allocated data structures for this stream are freed. This function discards any unprocessed input and does not flush any pending + output. + + + deflateEnd returns if success, if the stream state was inconsistent, + if the stream was freed prematurely (some input or output was discarded). In the error case, + may be set but then points to a static string (which must not be deallocated). + + + + + Dynamically update the compression level and compression strategy. The interpretation of level is as in . + This can be used to switch between compression and straight copy of the input data, or to switch to a different kind of input data + requiring a different strategy. If the compression level is changed, the input available so far is compressed with the old level + (and may be flushed); the new level will take effect only at the next call of + + An integer value indicating the desired compression level. + A flush strategy to use. + + Before the call of , the stream state must be set as for a call of , since the + currently available input may have to be compressed and flushed. In particular, must be non-zero. + + + deflateParams returns if success, if the source stream + state was inconsistent or if a parameter was invalid, if was zero. + + + + + Initializes the compression dictionary from the given byte sequence without producing any compressed output. This function must be called + immediately after , before any call of . The compressor and decompressor must use + exactly the same dictionary (see ). + + A byte array - a dictionary. + The length of the dictionary byte array + + + The dictionary should consist of strings (byte sequences) that are likely to be encountered later in the data to be compressed, + with the most commonly used strings preferably put towards the end of the dictionary. Using a dictionary is most useful when the data + to be compressed is short and can be predicted with good accuracy; the data can then be compressed better than with the default empty dictionary. + + Depending on the size of the compression data structures selected by , a part of the dictionary may + in effect be discarded, for example if the dictionary is larger than the window size in . Thus the strings most likely + to be useful should be put at the end of the dictionary, not at the front. + Upon return of this function, adler is set to the Adler32 value of the dictionary; the decompresser may later use this value to determine + which dictionary has been used by the compressor. (The Adler32 value applies to the whole dictionary even if only a subset of the dictionary + is actually used by the compressor.) + + + deflateSetDictionary returns if success, or if a parameter + is invalid (such as null dictionary) or the stream state is inconsistent (for example if has already been + called for this stream or if the compression method is bsort). does not perform any compression: + this will be done by . + + + + + Flush as much pending output as possible. All output goes through this function so some applications may wish to + modify it to avoid allocating a large buffer and copying into it. + + + + + + Read a new buffer from the current input stream, update the adler32 and total number of bytes read. All input goes + through this function so some applications may wish to modify it to avoid allocating a large buffer and copying from it. + + + + + + Frees all inner buffers. + + + + + Adler-32 value for uncompressed data processed so far. + + + + + Best guess about the data type: ascii or binary + + + + + Gets/Sets the next input byte array. + + + + + Index of the first byte in the input array. + + + + + Gets/Sets the number of bytes available in the input buffer. + + + + + Gets/Sets the total number of bytes in the input buffer. + + + + + Gets/Sets the buffer for the next output data. + + + + + Gets/Sets the index of the first byte in the byte array to write to. + + + + + Gets/Sets the remaining free space in the buffer. + + + + + Gets/Sets the total number of bytes in the output array. + + + + + Gets sets the last error message occurred during class operations. + + + + + A deflate object to perform data compression + + + + + Inflate object to perform data decompression + + + + + Exceptions that occur in ZStream + + + + + Default constructor. + + + + + Constructor which takes one parameter - an error message + + Creates an optimized encoding mapping that can be consumed by an optimized version of charmap_encode. @@ -30,7 +1956,17 @@ portions of modules. - + + + Convert string or bytes into bytes + + + + + Convert most bytearray-like objects into IList of byte + + + BytesIO([initializer]) -> object @@ -38,28 +1974,34 @@ buffer, ready for reading and writing. - + close() -> None. Disable all I/O operations. - - - flush() -> None. Does nothing. - - - + getvalue() -> bytes. Retrieve the entire contents of the BytesIO object. - + True if the file is closed. + + + Read and decode the next chunk from the buffered reader. Returns true if EOF was + not reached. Places decoded string in _decodedChars. + + + + + Remove all 'b's from mode string to simplify parsing + + Walks the queue calling back to the specified delegate for @@ -76,19 +2018,19 @@ Convert object to ushort, throwing ValueError on overflow. - + Interface for "file-like objects" that implement the protocol needed by load() and friends. This enables the creation of thin wrappers that make fast .NET types and slow Python types look the same. - + Interface for "file-like objects" that implement the protocol needed by dump() and friends. This enables the creation of thin wrappers that make fast .NET types and slow Python types look the same. - + Call the appropriate reduce method for obj and pickle the object using the resulting data. Use the first available of @@ -132,6 +2074,11 @@ Write value in pickle decimalnl_short format. + + + Write value in pickle decimalnl_short format. + + Write value in pickle decimalnl_long format. @@ -174,6 +2121,13 @@ append no more than BatchSize items at a time. + + + Emit a series of opcodes that will set all (key, value) pairs indexed by + iter in the object at the top of the stack. Use SETITEMS if possible, + but append no more than BatchSize items at a time. + + Emit a series of opcodes that will set all (key, value) pairs indexed by @@ -229,6 +2183,26 @@ CultureInfo. + + + Error function on real values + + + + + Complementary error function on real values: erfc(x) = 1 - erf(x) + + + + + Gamma function on real values + + + + + Natural log of absolute value of Gamma function + + Checks for the specific permissions, provided by the mode parameter, are available for the provided path. Permissions can be: @@ -243,6 +2217,12 @@ is shared by multiple runtimes. + + + lstat(path) -> stat result + Like stat(path), but do not follow symbolic links. + + spawns a new process. @@ -1128,6 +3108,15 @@ required to represent the integer followed by the bytes + + + Duplicates a subprocess handle which was created for piping. + + This is only called when we're duplicating the handle to make it inheritable to the child process. In CPython + the parent handle is always reliably garbage collected. Because we know this handle is not going to be + used we close the handle being duplicated. + + Special hash function because IStructuralEquatable.GetHashCode is not allowed to throw. @@ -1159,5 +3148,11 @@ Special equality function because IStructuralEquatable.Equals is not allowed to throw. + + + Returns the underlying .NET RegistryKey + + + diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.dll b/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.dll index 7fb3ef70e8..8d2e4067f5 100755 Binary files a/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.dll and b/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.dll differ diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.xml b/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.xml index b2bdca27cf..025bbaab70 100644 --- a/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.xml +++ b/src/AddIns/BackendBindings/Python/RequiredLibraries/IronPython.xml @@ -54,13 +54,13 @@ Gets or creates the FunctionCode object for this FunctionDefinition. - + Gets the expression for updating the dynamic stack trace at runtime when an exception is thrown. - + Gets the expression for the actual updating of the line number for stack traces to be available @@ -212,13 +212,211 @@ Ensures the underlying array is long enough to accomodate the given index The site storage type corresponding to the given index - + - Provides more specific type information for Python dictionaries which are not strongly typed. + Interface used to mark objects which contain a dictionary of custom attributes that shadow + their existing attributes in a dynamic fashion. + + + + + Ensures that a non-null IDictionary instance is created for CustomAttributes and + returns it. + + + + + 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. - This attribute can be applied to fields, parameters, proeprties, and return values. It can be - inspected to get type information about the types of the keys and values of the expected - dictionary or the returned dictionary. + 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. + + + + + 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. + + + + + 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. + + + + + Gets the PythonBinder associated with tihs CodeContext + + + + + 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. + + + + + 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. + + + + + 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. + + + + + 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. + + + + + 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. + + + + + 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. + + + + + 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. + + + + + 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. + + + + + Provides a cache from Type/name -> PythonTypeSlot and also allows access to + all members (and remembering whether all members are cached). + + + + + 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. + + + + + 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. + + + + + 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. + + + + + Checks to see if all members have been populated for the provided type. + + + + + 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. + + + + + 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. + + + + + Implements a built-in module which is instanced per PythonContext. + + Implementers can subclass this type and then have a module which has efficient access + to internal state (this doesn't need to go through PythonContext.GetModuleState). These + modules can also declare module level globals which they'd like to provide efficient + access to by overloading GetGlobalVariableNames. When Initialize is called these + globals are provided and can be cached in the instance for fast global access. + + Just like normal static modules these modules are registered with the PythonModuleAttribute. + + + + + Initializes the module for it's first usage. By default this calls PerformModuleReload with the + the dictionary. + + The CodeContext for the module. + A list of globals which have optimize access. Contains at least all of the global variables reutrned by GetGlobalVariableNames. + + + + Gets a list of variable names which should have optimized storage (instances of PythonGlobal objects). + The module receives the global objects during the Initialize call and can hold onto them for + direct access to global members. + + + + + Called when the user attempts to reload() on your module and by the base class Initialize method. + + This provides an opportunity to allocate any per-module data which is not simply function definitions. + + A common usage here is to create exception objects which are allocated by the module using PythonExceptions.CreateSubType. + + + + + Provides access to the PythonContext which this module was created for. + + + + + Provides access to the CodeContext for the module. Returns null before Initialize() is called. + + + + + Copy on write constant dictionary storage used for dictionaries created with constant items. @@ -233,7 +431,7 @@ aruond large operations and call lock free functions. - + Adds items from this dictionary into the other dictionary @@ -263,6 +461,21 @@ Provides fast access to the __import__ attribute if the dictionary storage supports caching it. + + + Provides more specific type information for Python dictionaries which are not strongly typed. + + This attribute can be applied to fields, parameters, proeprties, and return values. It can be + inspected to get type information about the types of the keys and values of the expected + dictionary or the returned dictionary. + + + + + Adapts an IDictionary[object, object] for use as a PythonDictionary used for + our debug frames. Also hides the special locals which start with $. + + An interface that is implemented on DynamicMetaObjects. @@ -374,131 +587,6 @@ ArgBuilder which provides the CodeContext parameter to a method. - - - 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. - - - - - 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. - - - - - Gets the PythonBinder associated with tihs CodeContext - - - - - 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. - - - - - 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. - - - - - 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. - - - - - 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. - - - - - 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. - - - - - 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. - - - - - 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. - - - - - 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. - - - - - Provides a cache from Type/name -> PythonTypeSlot and also allows access to - all members (and remembering whether all members are cached). - - - - - 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. - - - - - 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. - - - - - 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. - - - - - Checks to see if all members have been populated for the provided type. - - - - - 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. - - - - - 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. - - Small reducable node which just fetches the value from a ClosureCell @@ -615,6 +703,186 @@ __contains__ + + + Singleton used for dictionaries which contain no items. + + + + + Represents the set of extension methods which are loaded into a module. + + This set is immutable (as far the external viewer is considered). When a + new extension method set is loaded into a module we create a new ExtensionMethodsSet object. + + Multiple modules which have the same set of extension methods use the same set. + + + + + Returns all of the extension methods with the given name. + + + + + Returns all of the extension methods which are applicable for the given type. + + + + + Tracks the extension types that are loaded for a given assembly. + + We can have either types, namespaces, or a full assembly added as a reference. + + When the user just adds types we just add them to the type hash set. + + When the user adds namespaces we add them to the namespaces hashset. On the + next lookup we'll lazily load the types from that namespace and put them in Types. + + When the user adds assemblies we set the value to the NotYetLoadedButFullAssembly + value. The next load request will load the types from that namespace and put them + in Types. When we do that we'll mark the assembly as FullyLoaded so we don't + have to go through that again if the user adds a namespace. + + + + + ModuleDictionaryStorage for a built-in module which is bound to a specific instance. + + These modules don't need to use PythonContext.GetModuleState() for storage and therefore + can provide efficient access to internal variables. They can also cache PythonGlobal + objects and provide efficient access to module globals. + + To the end user these modules appear just like any other module. These modules are + implemented by subclassing the BuiltinPythonModule class. + + + + + Enables lazy initialization of module dictionaries. + + + + + Gets all of the extra names and values stored in the dictionary. + + + + + Attemps to sets a value in the extra keys. Returns true if the value is set, false if + the value is not an extra key. + + + + + Attempts to get a value from the extra keys. Returns true if the value is an extra + key and has a value. False if it is not an extra key or doesn't have a value. + + + + + Attempts to remove the key. Returns true if the key is removed, false + if the key was not removed, or null if the key is not an extra key. + + + + + A TypeSlot is an item that gets stored in a type's dictionary. Slots provide an + opportunity to customize access at runtime when a value is get or set from a dictionary. + + + + + Gets the value stored in the slot for the given instance binding it to an instance if one is provided and + the slot binds to instances. + + + + + Sets the value of the slot for the given instance. + + true if the value was set, false if it can't be set + + + + Deletes the value stored in the slot from the instance. + + true if the value was deleted, false if it can't be deleted + + + + Gets an expression which is used for accessing this slot. If the slot lookup fails the error expression + is used again. + + The default implementation just calls the TryGetValue method. Subtypes of PythonTypeSlot can override + this and provide a more optimal implementation. + + + + + True if generating code for gets can result in more optimal accesses. + + + + + True if TryGetValue will always succeed, false if it may fail. + + This is used to optimize away error generation code. + + + + + Defines the internal interface used for accessing weak references and adding finalizers + to user-defined types. + + + + + Gets the current WeakRefTracker for an object that can be used to + append additional weak references. + + + + + Attempts to set the WeakRefTracker for an object. Used on the first + addition of a weak ref tracker to an object. If the object doesn't + support adding weak references then it returns false. + + + + + Sets a WeakRefTracker on an object for the purposes of supporting finalization. + All user types (new-style and old-style) support finalization even if they don't + support weak-references, and therefore this function always succeeds. Note the + slot used to store the WeakRefTracker is still shared between SetWeakRef and + SetFinalizer if a type supports both. + + + + + + Provides a list of all the members of an instance. ie. all the keys in the + dictionary of the object. Note that it can contain objects that are not strings. + + Such keys can be added in IronPython using syntax like: + obj.__dict__[100] = someOtherObject + + This Python specific version also supports filtering based upon the show cls + flag by flowing in the code context. + + + + + Validates that the current self object is usable for this method. + + + + + Marks a class as being hidden from the Python hierarchy. This is applied to the base class + and then all derived types will not see the base class in their hierarchy and will not be + able to access members declaredo on the base class. + + Provides more specific type information for Python lists which are not strongly typed. @@ -792,6 +1060,11 @@ Include comments in the parse tree + + + Generated code should support light exceptions + + Manages the acquisition of profiling data for a single ScriptRuntime @@ -839,11 +1112,6 @@ Wraps a call to a MethodInfo with profiling capture for that MethodInfo - - - Wraps a call to a MethodInfo with profiling capture for that MethodInfo - - Encapsulates profiler data to return to clients @@ -902,6 +1170,12 @@ Determines delegate type for the Python function + + + 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. + + Provides globals for when we need to lookup into a dictionary for each global access. @@ -944,6 +1218,26 @@ be exec or eval code. + + + Creates a new PythonAst without a body. ParsingFinished should be called afterwards to set + the body. + + + + + 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. + + a mapping of where each line begins + The body of code + The language features which were set during parsing. + Binds an AST and makes it capable of being reduced and compiled. Before calling Bind an AST cannot successfully @@ -991,6 +1285,11 @@ True if absolute imports are enabled + + + True if this is on-disk code which we don't really have an AST for. + + Represents a reference to a name. A PythonReference is created for each name @@ -1119,36 +1418,8 @@ - - Updates the call site when the current rule is no longer applicable. - - - - - Enables lazy initialization of module dictionaries. - - - - - Gets all of the extra names and values stored in the dictionary. - - - - - Attemps to sets a value in the extra keys. Returns true if the value is set, false if - the value is not an extra key. - - - - - Attempts to get a value from the extra keys. Returns true if the value is an extra - key and has a value. False if it is not an extra key or doesn't have a value. - - - - - Attempts to remove the key. Returns true if the key is removed, false - if the key was not removed, or null if the key is not an extra key. + + Updates the call site when the current rule is no longer applicable. @@ -1189,6 +1460,12 @@ uses this service to get the correct remoting semantics. + + + Returns an ObjectHandle to a delegate of type Action[Action] which calls the current + command dispatcher. + + Marks that the return value of a function might include NotImplemented. @@ -1396,7 +1673,7 @@ we want to pass in the tuple - + Adds the target of the call to the rule. @@ -1573,7 +1850,7 @@ this. - + Looks up the associated PythonTypeSlot from the object. Indicates if the result came from a standard .NET type in which case we will fallback to the sites binder. @@ -2017,7 +2294,7 @@ current ScriptRuntime. - + SetCommandDispatcher(commandDispatcher) @@ -2201,51 +2478,6 @@ then calls the original function. - - - A TypeSlot is an item that gets stored in a type's dictionary. Slots provide an - opportunity to customize access at runtime when a value is get or set from a dictionary. - - - - - Gets the value stored in the slot for the given instance binding it to an instance if one is provided and - the slot binds to instances. - - - - - Sets the value of the slot for the given instance. - - true if the value was set, false if it can't be set - - - - Deletes the value stored in the slot from the instance. - - true if the value was deleted, false if it can't be deleted - - - - Gets an expression which is used for accessing this slot. If the slot lookup fails the error expression - is used again. - - The default implementation just calls the TryGetValue method. Subtypes of PythonTypeSlot can override - this and provide a more optimal implementation. - - - - - True if generating code for gets can result in more optimal accesses. - - - - - True if TryGetValue will always succeed, false if it may fail. - - This is used to optimize away error generation code. - - Decorator for verifying the return type of functions. @@ -2346,7 +2578,7 @@ Provides an enumerable of the parsed format. The elements of the tuple are: - the text proceeding the format information + the text preceding the format information the field name the format spec the conversion @@ -2528,6 +2760,27 @@ OperatorStrings (a Python specific operator) + + + Sets the current command dispatcher for the Python command line. The previous dispatcher + is returned. Null can be passed to remove the current command dispatcher. + + The command dispatcher will be called with a delegate to be executed. The command dispatcher + should invoke the target delegate in the desired context. + + A common use for this is to enable running all REPL commands on the UI thread while the REPL + continues to run on a non-UI thread. + + The ipy.exe REPL will call into PythonContext.DispatchCommand to dispatch each execution to + the correct thread. Other REPLs can do the same to support this functionality as well. + + + + + Dispatches the command to the current command dispatcher. If there is no current command + dispatcher the command is executed immediately on the current thread. + + Gets a function which can be used for comparing two values. If cmp is not null @@ -2627,47 +2880,6 @@ Created for a user-defined function. - - - Defines the internal interface used for accessing weak references and adding finalizers - to user-defined types. - - - - - Gets the current WeakRefTracker for an object that can be used to - append additional weak references. - - - - - Attempts to set the WeakRefTracker for an object. Used on the first - addition of a weak ref tracker to an object. If the object doesn't - support adding weak references then it returns false. - - - - - Sets a WeakRefTracker on an object for the purposes of supporting finalization. - All user types (new-style and old-style) support finalization even if they don't - support weak-references, and therefore this function always succeeds. Note the - slot used to store the WeakRefTracker is still shared between SetWeakRef and - SetFinalizer if a type supports both. - - - - - - Provides a list of all the members of an instance. ie. all the keys in the - dictionary of the object. Note that it can contain objects that are not strings. - - Such keys can be added in IronPython using syntax like: - obj.__dict__[100] = someOtherObject - - This Python specific version also supports filtering based upon the show cls - flag by flowing in the code context. - - Python ctor - maps to function.__new__ @@ -2853,6 +3065,11 @@ Enable profiling code + + + Returns a regular expression of Python files which should not be emitted in debug mode. + + Gets the CPython version which IronPython will emulate. Currently limited @@ -2904,136 +3121,256 @@ the user has done an import clr. - + - Provides storage which is flowed into a callers site. The same storage object is - flowed for multiple calls enabling the callee to cache data that can be re-used - across multiple calls. + General-purpose storage used for Python sets and frozensets. - Data is a public field so that this works properly with DynamicSite's as the reference - type (and EnsureInitialize) + The set storage is thread-safe for multiple readers or writers. + + Mutations to the set involve a simple locking strategy of locking on the SetStorage object + itself to ensure mutual exclusion. + + Reads against the set happen lock-free. When the set is mutated, it adds or removes buckets + in an atomic manner so that the readers will see a consistent picture as if the read + occurred either before or after the mutation. - + - Provides a representation and parsing for the default formatting specification. This is used - by object.__format__, int.__format__, long.__format__, and float.__format__ to do the common - format spec parsing. - - The default specification is: - - format_spec = [[fill]align][sign][#][0][width][.precision][type] - fill = a character other than } - align = "<" | ">" | "=" | "^" - sign = "+" | "-" | " " - width = integer - precision = integer - type = "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "x" | "X" | "%" + Creates a new set storage with no buckets - + - Parses a format spec and returns a new StringFormatSpec object. + Creates a new set storage with no buckets - + - BuiltinFunction represents any standard CLR function exposed to Python. - This is used for both methods on standard Python types such as list or tuple - and for methods from arbitrary .NET assemblies. - - All calls are made through the optimizedTarget which is created lazily. - - TODO: Back BuiltinFunction's by MethodGroup's. - + Adds a new item to the set, unless an equivalent item is already present + - + - Interface used for things which can convert to delegates w/o code gen. Currently - this is just non-overloaded builtin functions and bound builtin functions. Avoiding - the code gen is not only nice for compilation but it also enables delegates to be added - in C# and removed in Python. + Static helper which adds the given non-null item with a precomputed hash code. Returns + true if the item was added, false if it was already present in the set. - + - Creates a new builtin function for a static .NET function. This is used for module methods - and well-known __new__ methods. + Lock-free helper on a non-null item with a pre-calculated hash code. Removes the item + if it is present in the set, otherwise adds it. - + - Creates a built-in function for a .NET method declared on a type. + Clears the contents of the set - + - Creates a bound built-in function. The instance may be null for built-in functions - accessed for None. + Clones the set, returning a new SetStorage object - + - Returns a BuiltinFunction bound to the provided type arguments. Returns null if the binding - cannot be performed. + Checks to see if the given item exists in the set - + - Returns a descriptor for the built-in function if one is - neededed + Checks to see if the given item exists in the set, and tries to hash it even + if it is known not to be in the set. + + + + + + + Adds items from this set into the other set - + - Makes a test for the built-in function against the private _data - which is unique per built-in function. + Removes the first set element in the iteration order. + true if an item was removed, false if the set was empty - + - Helper for generating the call to a builtin function. This is used for calls from built-in method - descriptors and built-in functions w/ and w/o a bound instance. + Removes an item from the set and returns true if it was present, otherwise returns + false + + + + + Removes an item from the set and returns true if it was removed. The item will always + be hashed, throwing if it is unhashable - even if the set has no buckets. + + + + + Lock-free helper to remove a non-null item + + + + + Determines whether the current set shares no elements with the given set + + + + + Determines whether the current set is a subset of the given set + + + + + Determines whether the current set is a strict subset of the given set + + + + + Mutates this set to contain its union with 'other'. The caller must lock the current + set if synchronization is desired. + + + + + Mutates this set to contain its intersection with 'other'. The caller must lock the + current set if synchronization is desired. + + + + + Mutates this set to contain its symmetric difference with 'other'. The caller must + lock the current set if synchronization is desired. + + + + + Mutates this set to contain its difference with 'other'. The caller must lock the + current set if synchronization is desired. + + + + + Computes the union of self and other, returning an entirely new set. This method is + thread-safe and makes no modifications to self or other. + + + + + Computes the intersection of self and other, returning an entirely new set. This + method is thread-safe and makes no modifications to self or other. + + + + + Computes the symmetric difference of self and other, returning an entirely new set. + This method is thread-safe and makes no modifications to self or other. + + + + + Computes the difference of self and other, returning an entirely new set. This + method is thread-safe and makes no modifications to self or other. + + + + + Helper to hash the given item w/ support for null + + + + + Helper which ensures that the first argument x requires the least work to enumerate + + + + + A factory which creates a SetStorage object from any Python iterable. It extracts + the underlying storage of a set or frozen set without copying, which is left to the + caller if necessary. + + + + + A factory which creates a SetStorage object from any Python iterable. It extracts + the underlying storage of a set or frozen set without copying, which is left to the + caller if necessary. + Returns true if the given object was a set or frozen set, false otherwise. + + + + + A factory which creates a SetStorage object from any Python iterable. It extracts + the underlying storage of a set or frozen set, copying in the former case, to return + a SetStorage object that is guaranteed not to receive any outside mutations. + + + + + Extracts the SetStorage object from o if it is a set or frozenset and returns true. + Otherwise returns false. + + + + + Creates a hashable set from the given set, or does nothing if the given object + is not a set. + + True if o is a set or frozenset, false otherwise + + + + Returns the number of items currently in the set + + + + + Used to store a single hashed item. - This provides all sorts of common checks on top of the call while the caller provides a delegate - to do the actual call. The common checks include: - check for generic-only methods - reversed operator support - transforming arguments so the default binder can understand them (currently user defined mapping types to PythonDictionary) - returning NotImplemented from binary operators - Warning when calling certain built-in functions - + Bucket is not serializable because it stores the computed hash code, which could change + between serialization and deserialization. - The call binder we're doing the call for - An expression which points to the code context - the meta object for the built in function - true if we're calling with an instance - The arguments being passed to the function - A restriction for the built-in function, method desc, etc... - A delegate to perform the actual call to the method. - + - Gets the target methods that we'll be calling. + Provides storage which is flowed into a callers site. The same storage object is + flowed for multiple calls enabling the callee to cache data that can be re-used + across multiple calls. + + Data is a public field so that this works properly with DynamicSite's as the reference + type (and EnsureInitialize) - + - True if the method should be visible to non-CLS opt-in callers + Provides a representation and parsing for the default formatting specification. This is used + by object.__format__, int.__format__, long.__format__, and float.__format__ to do the common + format spec parsing. + + The default specification is: + + format_spec = [[fill]align][sign][#][0][width][,][.precision][type] + fill = a character other than } + align = "<" | ">" | "=" | "^" + sign = "+" | "-" | " " + width = integer + precision = integer + type = "b" | "c" | "d" | "e" | "E" | "f" | "F" | "g" | "G" | "n" | "o" | "x" | "X" | "%" - + - Provides (for reflected methods) a mapping from a signature to the exact target - which takes this signature. - signature with syntax like the following: - someClass.SomeMethod.Overloads[str, int]("Foo", 123) + Parses a format spec and returns a new StringFormatSpec object. - + - Gets the overload dictionary for the logical function. These overloads - are never bound to an instance. + Optimized storage for setting exc_type, exc_value, and exc_traceback. + + This optimization can go away in Python 3.0 when these attributes are no longer used. @@ -3292,26 +3629,6 @@ Summary description for Token. - - - True if the quotation is written using ', false if written using " - - - - - True if the string is a raw-string (preceeded w/ r character) - - - - - True if the string is Unicode string (preceeded w/ a u character) - - - - - True if the string is triple quoted (''' or """) - - IronPython tokenizer @@ -3319,7 +3636,7 @@ - Used to support legacy CreateParser API. + Used to create tokenizer for hosting API. @@ -3327,12 +3644,22 @@ Returns whether the + + + Resizes an array to a speficied new size and copies a portion of the original array into its beginning. + + 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. + + + Equality comparer that can compare strings to our current token w/o creating a new string first. + + A simple Python command-line should mimic the standard python.exe @@ -3569,6 +3896,11 @@ Returns the ScriptScope associated with the module. + + + Gets the list of loaded Python module files names which are available in the provided ScriptEngine. + + A strongly-typed resource class, for looking up localized strings, etc. @@ -3860,7 +4192,7 @@ items arary - + Creates a new dictionary storage with the given set of buckets and size. Used when cloning the dictionary storage. @@ -3879,11 +4211,17 @@ - Static add helper that works over a single set of buckets. Used for + Add helper that works over a single set of buckets. Used for both the normal add case as well as the resize case. - + + + Add helper which adds the given key/value (where the key is not null) with + a pre-computed hash code. + + + Removes an entry from the dictionary and returns true if the entry was removed or false. @@ -3902,14 +4240,6 @@ Checks to see if the key exists in the dictionary. - - - Static helper to see if the key exists in the provided bucket array. - - Used so the contains check can run against a buckets while a writer - replaces the buckets. - - Trys to get the value associated with the given key and returns true @@ -3924,7 +4254,7 @@ replaces the buckets. - + Clears the contents of the dictionary. @@ -3946,16 +4276,15 @@ - Used to store a single hashed key/value and a linked list of - collisions. + Used to store a single hashed key/value. Bucket is not serializable because it stores the computed hash code which could change between serialization and deserialization. - + - Special marker bucket used during deserialization to not add + Special marker NullValue used during deserialization to not add an extra field to the dictionary storage type. @@ -4051,12 +4380,12 @@ Creates a new style Python exception from the .NET exception - + Internal helper to associate a .NET exception and a Python exception. - + Internal helper to get the associated Python exception from a .NET exception. @@ -4066,13 +4395,25 @@ Converts the DLR SyntaxErrorException into a Python new-style SyntaxError instance. - + + + Creates a PythonType for a built-in module. These types are mutable like + normal user types. + + + Creates a PythonType for a built-in module. These types are mutable like normal user types. - + + + Creates a PythonType for a built-in module, where the type may inherit + from multiple bases. These types are mutable like normal user types. + + + Creates a new type for a built-in exception which derives from another Python type. . These types are built-in and immutable like any other normal type. For @@ -4080,11 +4421,16 @@ are like user defined types. thread.error.x = 3 is legal. - + Creates a new type for a built-in exception which is the root concrete type. + + + Gets the list of DynamicStackFrames for the current exception. + + Base class for all Python exception objects. @@ -4188,11 +4534,6 @@ tuple code formatted. - - - Creates a CLR Exception for this Python exception - - Initializes the Python exception from a .NET exception @@ -4540,18 +4881,16 @@ stream -> the stream to wrap in a file object. - + - float overload of range - reports TypeError if the float is outside the range of normal integers. - - The method binder would usally report an OverflowError in this case. + object overload of range - attempts to convert via __int__, and __trunc__ if arg is + an OldInstance - + - float overload of range - reports TypeError if the float is outside the range of normal integers. - - The method binder would usally report an OverflowError in this case. + object overload of range - attempts to convert via __int__, and __trunc__ if arg is + an OldInstance @@ -4627,7 +4966,7 @@ Function codes created this way do support recursion enforcement and are therefore registered in the global function code registry. - + Constructor to create a FunctionCode at runtime. @@ -4667,11 +5006,14 @@ until the lock is released. - + Creates a FunctionCode object for exec/eval/execfile'd/compile'd code. The code is then executed in a specific CodeContext by calling the .Call method. + + If the code is being used for compile (vs. exec/eval/execfile) then it needs to be + registered incase our tracing mode changes. @@ -4792,11 +5134,6 @@ for purposes of recursion enforcement or tracing. - - - Validates that the current self object is usable for this method. - - General conversion routine TryConvert - tries to convert the object to the desired type. @@ -4818,7 +5155,16 @@ Attempts to convert value into a index usable for slicing and return the integer - value. If the conversion fails false is returned. + value. If the conversion fails false is returned. + + If throwOverflowError is true then BigInteger's outside the normal range of integers will + result in an OverflowError. + + + + + Attempts to convert value into a index usable for slicing and return the integer + value. If the conversion fails false is returned. If throwOverflowError is true then BigInteger's outside the normal range of integers will result in an OverflowError. @@ -4925,7 +5271,7 @@ Fields set by Throw() to communicate an exception to the yield point. These are plumbed through the generator to become parameters to Raise(...) invoked - at the yield suspenion point in the generator. + at the yield suspension point in the generator. @@ -5016,6 +5362,12 @@ a module and returns the module. + + + Gateway into importing ... called from Ops. Performs the initial import of + a module and returns the module. This version returns light exceptions instead of throwing. + + Gateway into importing ... called from Ops. This is called after @@ -5584,6 +5936,11 @@ exec code in globals [, locals ] + + + Called from generated code at the start of a catch block. + + Get an exception tuple for the "current" exception. This is used for sys.exc_info() @@ -5726,6 +6083,16 @@ original type of exception requested a TypeEror exception + + + Gets a list of DynamicStackFrames for the given exception. These stack frames + can be programmatically inspected to understand the frames the exception crossed + through including Python frames. + + Dynamic stack frames are not preserved when an exception crosses an app domain + boundary. + + Helper clas for calls to unicode(...). We generate code which checks if unicode @@ -5776,7 +6143,7 @@ replacement_field = "{" field_name ["!" conversion] [":" format_spec] "}" field_name = (identifier | integer) ("." identifier | "[" element_index "]")* - format_spec: [[fill]align][sign][#][0][width][.precision][type] + format_spec: [[fill]align][sign][#][0][width][,][.precision][type] Conversion can be 'r' for repr or 's' for string. @@ -5853,6 +6220,11 @@ doesn't collide with other operators. + + + Sets the mode to text or binary. Returns true if previously set to text, false if previously set to binary. + + Truncates the file to the current length as indicated by tell(). @@ -5908,25 +6280,6 @@ Provides dictionary based storage which is backed by a Scope object. - - - Common interface shared by both Set and FrozenSet - - - - - Contains common set functionality between set and frozenSet - - - - - Creates a set that can be hashable. If the set is currently a FrozenSet the - set is returned. If the set is a normal Set then a FrozenSet is returned - with its contents. - - - - Mutable set class @@ -5934,13 +6287,7 @@ - Appends one IEnumerable to an existing set - - - - - - Appends one or more IEnumerables to an existing set + Appends an IEnumerable to an existing set @@ -6039,6 +6386,14 @@ TODO: Should we attempt to unify all versions which share the same keys? + + + Interface used for things which can convert to delegates w/o code gen. Currently + this is just non-overloaded builtin functions and bound builtin functions. Avoiding + the code gen is not only nice for compilation but it also enables delegates to be added + in C# and removed in Python. + + Represents a set of attributes that different functions can have. @@ -6075,6 +6430,11 @@ This enables simple .NET operator methods to be mapped into the Python semantics. + + + A method declared on a built-in module + + OperatorMapping provides a mapping from DLR operators to their associated .NET methods. @@ -6135,6 +6495,11 @@ Set if the type is user defined + + + Set if the type has __abstractmethods__ defined + + Implements fast binding for user defined types. This ensures that common highly dynamic @@ -6177,7 +6542,7 @@ - + Creates a new PythonType which is a subclass of the specified PythonType. @@ -6185,7 +6550,23 @@ primary example of this is the exception system. - + + + Creates a new PythonType which is a subclass of the specified PythonTypes. + + Used for runtime defined new-style classes which require multiple inheritance. The + primary example of this is the exception system. + + + + + Creates a new PythonType which is a subclass of the specified PythonTypes. + + Used for runtime defined new-style classes which require multiple inheritance. The + primary example of this is the exception system. + + + Creates a new PythonType which is a subclass of the specified PythonType. @@ -6193,6 +6574,22 @@ primary example of this is the exception system. + + + Creates a new PythonType which is a subclass of the specified PythonTypes. + + Used for runtime defined new-style classes which require multiple inheritance. The + primary example of this is the exception system. + + + + + Creates a new PythonType which is a subclass of the specified PythonTypes. + + Used for runtime defined new-style classes which require multiple inheritance. The + primary example of this is the exception system. + + Creates a new PythonType object which represents an Old-style class. @@ -6488,7 +6885,7 @@ Calculates the method resolution order for a Python class the rules are: - If A is a subtype of B, then A has precedence (A >B) + If A is a subtype of B, then A has precedence (A > B) If C appears before D in the list of bases then C > D If E > F in one __mro__ then E > F in all __mro__'s for our subtype @@ -6541,11 +6938,6 @@ Creates a new module backed by a Scope. Used for creating modules for foreign Scope's. - - - Creates a new module backed by a Scope. Used for creating modules for Python code. - - Creates a new PythonModule with the specified dictionary. @@ -6917,6 +7309,104 @@ MemberBinder which searches only the current type and it's extension types to find a member. + + + BuiltinFunction represents any standard CLR function exposed to Python. + This is used for both methods on standard Python types such as list or tuple + and for methods from arbitrary .NET assemblies. + + All calls are made through the optimizedTarget which is created lazily. + + TODO: Back BuiltinFunction's by MethodGroup's. + + + + + Creates a new builtin function for a static .NET function. This is used for module methods + and well-known __new__ methods. + + + + + Creates a built-in function for a .NET method declared on a type. + + + + + Creates a bound built-in function. The instance may be null for built-in functions + accessed for None. + + + + + Returns a BuiltinFunction bound to the provided type arguments. Returns null if the binding + cannot be performed. + + + + + Returns a descriptor for the built-in function if one is + neededed + + + + + Makes a test for the built-in function against the private _data + which is unique per built-in function. + + + + + Helper for generating the call to a builtin function. This is used for calls from built-in method + descriptors and built-in functions w/ and w/o a bound instance. + + This provides all sorts of common checks on top of the call while the caller provides a delegate + to do the actual call. The common checks include: + check for generic-only methods + reversed operator support + transforming arguments so the default binder can understand them (currently user defined mapping types to PythonDictionary) + returning NotImplemented from binary operators + Warning when calling certain built-in functions + + + The call binder we're doing the call for + An expression which points to the code context + the meta object for the built in function + true if we're calling with an instance + The arguments being passed to the function + A restriction for the built-in function, method desc, etc... + A delegate to perform the actual call to the method. + + + + Gets the target methods that we'll be calling. + + + + + True if the method should be visible to non-CLS opt-in callers + + + + + Provides (for reflected methods) a mapping from a signature to the exact target + which takes this signature. + signature with syntax like the following: + someClass.SomeMethod.Overloads[str, int]("Foo", 123) + + + + + Gets the overload dictionary for the logical function. These overloads + are never bound to an instance. + + + + + Returns the instance used for binding. This differs on module functions implemented + using instance methods so the built-in functions there don't expose the instance. + + A custom built-in function which supports indexing @@ -6992,6 +7482,11 @@ Convenience function for users to call directly + + + True if generating code for gets can result in more optimal accesses. + + single finalizable instance used to track and deliver all the diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/License.Rtf b/src/AddIns/BackendBindings/Python/RequiredLibraries/License.Rtf index 9cadaea828..3a7ceb4fde 100644 --- a/src/AddIns/BackendBindings/Python/RequiredLibraries/License.Rtf +++ b/src/AddIns/BackendBindings/Python/RequiredLibraries/License.Rtf @@ -1,70 +1,138 @@ -{\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff31507\deff0\stshfdbch31505\stshfloch31506\stshfhich31506\stshfbi31507\deflang1033\deflangfe1033\themelang1033\themelangfe0\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f34\fbidi \froman\fcharset1\fprq2{\*\panose 02040503050406030204}Cambria Math;} -{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fdbmajor\f31501\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;} -{\fhimajor\f31502\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria;}{\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;} -{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fdbminor\f31505\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;} -{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}{\fbiminor\f31507\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f39\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} -{\f40\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\f42\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f43\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f44\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);} -{\f45\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\f46\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f47\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);} -{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;} -{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);} -{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbmajor\f31518\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} -{\fdbmajor\f31519\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbmajor\f31521\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbmajor\f31522\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;} -{\fdbmajor\f31523\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbmajor\f31524\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbmajor\f31525\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;} -{\fdbmajor\f31526\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhimajor\f31528\fbidi \froman\fcharset238\fprq2 Cambria CE;}{\fhimajor\f31529\fbidi \froman\fcharset204\fprq2 Cambria Cyr;} -{\fhimajor\f31531\fbidi \froman\fcharset161\fprq2 Cambria Greek;}{\fhimajor\f31532\fbidi \froman\fcharset162\fprq2 Cambria Tur;}{\fhimajor\f31535\fbidi \froman\fcharset186\fprq2 Cambria Baltic;} -{\fbimajor\f31538\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbimajor\f31539\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbimajor\f31541\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;} -{\fbimajor\f31542\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbimajor\f31543\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbimajor\f31544\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);} -{\fbimajor\f31545\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbimajor\f31546\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\flominor\f31548\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} -{\flominor\f31549\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flominor\f31551\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flominor\f31552\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;} -{\flominor\f31553\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flominor\f31554\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flominor\f31555\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;} -{\flominor\f31556\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbminor\f31558\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbminor\f31559\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} -{\fdbminor\f31561\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbminor\f31562\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbminor\f31563\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);} -{\fdbminor\f31564\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbminor\f31565\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbminor\f31566\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);} -{\fhiminor\f31568\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\fhiminor\f31569\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\fhiminor\f31571\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\fhiminor\f31572\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;} -{\fhiminor\f31575\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}{\fbiminor\f31578\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fbiminor\f31579\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} -{\fbiminor\f31581\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbiminor\f31582\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fbiminor\f31583\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);} -{\fbiminor\f31584\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbiminor\f31585\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fbiminor\f31586\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}} -{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0;\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0; -\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;}{\*\defchp \fs22\loch\af31506\hich\af31506\dbch\af31505 }{\*\defpap \ql \li0\ri0\sa200\sl276\slmult1 -\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 }\noqfpromote {\stylesheet{\ql \li0\ri0\sa200\sl276\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af31507\afs22\alang1025 -\ltrch\fcs0 \fs22\lang1033\langfe1033\loch\f31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp1033 \snext0 \sqformat \spriority0 Normal;}{\*\cs10 \additive \ssemihidden \sunhideused \spriority1 Default Paragraph Font;}{\* +{\rtf1\adeflang1025\ansi\ansicpg1252\uc1\adeff31507\deff0\stshfdbch31505\stshfloch31506\stshfhich31506\stshfbi0\deflang1033\deflangfe1033\themelang1033\themelangfe0\themelangcs0{\fonttbl{\f0\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f34\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria Math;} +{\f37\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;}{\flomajor\f31500\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;} +{\fdbmajor\f31501\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhimajor\f31502\fbidi \froman\fcharset0\fprq2{\*\panose 02040503050406030204}Cambria;} +{\fbimajor\f31503\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\flominor\f31504\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;} +{\fdbminor\f31505\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\fhiminor\f31506\fbidi \fswiss\fcharset0\fprq2{\*\panose 020f0502020204030204}Calibri;} +{\fbiminor\f31507\fbidi \froman\fcharset0\fprq2{\*\panose 02020603050405020304}Times New Roman;}{\f39\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\f40\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} +{\f42\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\f43\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\f44\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\f45\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);} +{\f46\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\f47\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\f379\fbidi \froman\fcharset238\fprq2 Cambria Math CE;}{\f380\fbidi \froman\fcharset204\fprq2 Cambria Math Cyr;} +{\f382\fbidi \froman\fcharset161\fprq2 Cambria Math Greek;}{\f383\fbidi \froman\fcharset162\fprq2 Cambria Math Tur;}{\f386\fbidi \froman\fcharset186\fprq2 Cambria Math Baltic;}{\f387\fbidi \froman\fcharset163\fprq2 Cambria Math (Vietnamese);} +{\f409\fbidi \fswiss\fcharset238\fprq2 Calibri CE;}{\f410\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\f412\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\f413\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;} +{\f416\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}{\f417\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\flomajor\f31508\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} +{\flomajor\f31509\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\flomajor\f31511\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flomajor\f31512\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;} +{\flomajor\f31513\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\flomajor\f31514\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flomajor\f31515\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;} +{\flomajor\f31516\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fdbmajor\f31518\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbmajor\f31519\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} +{\fdbmajor\f31521\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fdbmajor\f31522\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbmajor\f31523\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);} +{\fdbmajor\f31524\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fdbmajor\f31525\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbmajor\f31526\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);} +{\fhimajor\f31528\fbidi \froman\fcharset238\fprq2 Cambria CE;}{\fhimajor\f31529\fbidi \froman\fcharset204\fprq2 Cambria Cyr;}{\fhimajor\f31531\fbidi \froman\fcharset161\fprq2 Cambria Greek;}{\fhimajor\f31532\fbidi \froman\fcharset162\fprq2 Cambria Tur;} +{\fhimajor\f31535\fbidi \froman\fcharset186\fprq2 Cambria Baltic;}{\fhimajor\f31536\fbidi \froman\fcharset163\fprq2 Cambria (Vietnamese);}{\fbimajor\f31538\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} +{\fbimajor\f31539\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbimajor\f31541\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbimajor\f31542\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;} +{\fbimajor\f31543\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbimajor\f31544\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbimajor\f31545\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;} +{\fbimajor\f31546\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\flominor\f31548\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\flominor\f31549\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;} +{\flominor\f31551\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\flominor\f31552\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\flominor\f31553\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);} +{\flominor\f31554\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\flominor\f31555\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\flominor\f31556\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);} +{\fdbminor\f31558\fbidi \froman\fcharset238\fprq2 Times New Roman CE;}{\fdbminor\f31559\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fdbminor\f31561\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;} +{\fdbminor\f31562\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;}{\fdbminor\f31563\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fdbminor\f31564\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);} +{\fdbminor\f31565\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;}{\fdbminor\f31566\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}{\fhiminor\f31568\fbidi \fswiss\fcharset238\fprq2 Calibri CE;} +{\fhiminor\f31569\fbidi \fswiss\fcharset204\fprq2 Calibri Cyr;}{\fhiminor\f31571\fbidi \fswiss\fcharset161\fprq2 Calibri Greek;}{\fhiminor\f31572\fbidi \fswiss\fcharset162\fprq2 Calibri Tur;} +{\fhiminor\f31575\fbidi \fswiss\fcharset186\fprq2 Calibri Baltic;}{\fhiminor\f31576\fbidi \fswiss\fcharset163\fprq2 Calibri (Vietnamese);}{\fbiminor\f31578\fbidi \froman\fcharset238\fprq2 Times New Roman CE;} +{\fbiminor\f31579\fbidi \froman\fcharset204\fprq2 Times New Roman Cyr;}{\fbiminor\f31581\fbidi \froman\fcharset161\fprq2 Times New Roman Greek;}{\fbiminor\f31582\fbidi \froman\fcharset162\fprq2 Times New Roman Tur;} +{\fbiminor\f31583\fbidi \froman\fcharset177\fprq2 Times New Roman (Hebrew);}{\fbiminor\f31584\fbidi \froman\fcharset178\fprq2 Times New Roman (Arabic);}{\fbiminor\f31585\fbidi \froman\fcharset186\fprq2 Times New Roman Baltic;} +{\fbiminor\f31586\fbidi \froman\fcharset163\fprq2 Times New Roman (Vietnamese);}}{\colortbl;\red0\green0\blue0;\red0\green0\blue255;\red0\green255\blue255;\red0\green255\blue0;\red255\green0\blue255;\red255\green0\blue0;\red255\green255\blue0; +\red255\green255\blue255;\red0\green0\blue128;\red0\green128\blue128;\red0\green128\blue0;\red128\green0\blue128;\red128\green0\blue0;\red128\green128\blue0;\red128\green128\blue128;\red192\green192\blue192;}{\*\defchp +\fs22\loch\af31506\hich\af31506\dbch\af31505 }{\*\defpap \ql \li0\ri0\sa200\sl276\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 }\noqfpromote {\stylesheet{\ql \li0\ri0\sa200\sl276\slmult1 +\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af31507\afs22\alang1025 \ltrch\fcs0 \fs22\lang1033\langfe1033\loch\f31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp1033 \snext0 \sqformat \spriority0 Normal;} +{\*\cs10 \additive \ssemihidden \sunhideused \spriority1 Default Paragraph Font;}{\* \ts11\tsrowd\trftsWidthB3\trpaddl108\trpaddr108\trpaddfl3\trpaddft3\trpaddfb3\trpaddfr3\trcbpat1\trcfpat1\tblind0\tblindtype3\tscellwidthfts0\tsvertalt\tsbrdrt\tsbrdrl\tsbrdrb\tsbrdrr\tsbrdrdgl\tsbrdrdgr\tsbrdrh\tsbrdrv \ql \li0\ri0\sa200\sl276\slmult1 -\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af31507\afs22\alang1025 \ltrch\fcs0 \fs22\lang1033\langfe1033\loch\f31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp1033 -\snext11 \ssemihidden \sunhideused \sqformat Normal Table;}}{\*\rsidtbl \rsid11612883}{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0\msmallFrac0\mdispDef1\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0\mnaryLim1}{\info{\author dinov}{\operator dinov} -{\creatim\yr2007\mo10\dy30\hr14\min43}{\revtim\yr2007\mo10\dy30\hr14\min43}{\version2}{\edmins1}{\nofpages2}{\nofwords404}{\nofchars2212}{\*\company Microsoft}{\nofcharsws2611}{\vern32893}}{\*\xmlnstbl {\xmlns1 http://schemas.microsoft.com/office/word/200 -3/wordml}}\paperw12240\paperh15840\margl1440\margr1440\margt1440\margb1440\gutter0\ltrsect +\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs22\alang1025 \ltrch\fcs0 \fs22\lang1033\langfe1033\loch\f31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp1033 +\snext11 \ssemihidden \sunhideused \sqformat Normal Table;}{\s15\ql \li0\ri0\sb100\sa100\sbauto1\saauto1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0 \rtlch\fcs1 \af0\afs24\alang1025 \ltrch\fcs0 +\fs24\lang1033\langfe1033\cgrid\langnp1033\langfenp1033 \sbasedon0 \snext15 \ssemihidden \sunhideused \styrsid12260020 Normal (Web);}{\*\cs16 \additive \rtlch\fcs1 \af0 \ltrch\fcs0 \ul\cf2 \sbasedon10 \ssemihidden \sunhideused \styrsid12260020 Hyperlink;} +}{\*\listtable{\list\listtemplateid186961718{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\levelspace0\levelindent0{\leveltext\'02\'00.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \hres0\chhres0 \fi-360\li720 +\jclisttab\tx720\lin720 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\'02\'01.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \hres0\chhres0 \fi-360\li1440 +\jclisttab\tx1440\lin1440 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\'02\'02.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \hres0\chhres0 \fi-360\li2160 +\jclisttab\tx2160\lin2160 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\'02\'03.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \hres0\chhres0 \fi-360\li2880 +\jclisttab\tx2880\lin2880 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\'02\'04.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \hres0\chhres0 \fi-360\li3600 +\jclisttab\tx3600\lin3600 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\'02\'05.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \hres0\chhres0 \fi-360\li4320 +\jclisttab\tx4320\lin4320 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\'02\'06.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \hres0\chhres0 \fi-360\li5040 +\jclisttab\tx5040\lin5040 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\'02\'07.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \hres0\chhres0 \fi-360\li5760 +\jclisttab\tx5760\lin5760 }{\listlevel\levelnfc4\levelnfcn4\leveljc0\leveljcn0\levelfollow0\levelstartat1\lvltentative\levelspace0\levelindent0{\leveltext\'02\'08.;}{\levelnumbers\'01;}\rtlch\fcs1 \af0 \ltrch\fcs0 \hres0\chhres0 \fi-360\li6480 +\jclisttab\tx6480\lin6480 }{\listname ;}\listid259719883}}{\*\listoverridetable{\listoverride\listid259719883\listoverridecount0\ls1}}{\*\pgptbl {\pgp\ipgp2\itap0\li0\ri0\sb0\sa0}{\pgp\ipgp0\itap0\li0\ri0\sb0\sa0}}{\*\rsidtbl \rsid11612883\rsid12260020} +{\mmathPr\mmathFont34\mbrkBin0\mbrkBinSub0\msmallFrac0\mdispDef1\mlMargin0\mrMargin0\mdefJc1\mwrapIndent1440\mintLim0\mnaryLim1}{\info{\author dinov}{\operator Dino Viehland}{\creatim\yr2007\mo10\dy30\hr14\min43}{\revtim\yr2010\mo7\dy8\hr11\min35} +{\version3}{\edmins1}{\nofpages3}{\nofwords1419}{\nofchars7907}{\*\company Microsoft}{\nofcharsws9308}{\vern32771}}{\*\xmlnstbl {\xmlns1 http://schemas.microsoft.com/office/word/2003/wordml}} +\paperw12240\paperh15840\margl1440\margr1440\margt1440\margb1440\gutter0\ltrsect \widowctrl\ftnbj\aenddoc\trackmoves1\trackformatting1\donotembedsysfont0\relyonvml0\donotembedlingdata1\grfdocevents0\validatexml0\showplaceholdtext0\ignoremixedcontent0\saveinvalidxml0\showxmlerrors0\horzdoc\dghspace120\dgvspace120\dghorigin1701 \dgvorigin1984\dghshow0\dgvshow3\jcompress\viewkind1\viewscale100\rsidroot11612883 \fet0{\*\wgrffmtfilter 2450}\ilfomacatclnup0\ltrpar \sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\*\pnseclvl1\pnucrm\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl2 \pnucltr\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl3\pndec\pnstart1\pnindent720\pnhang {\pntxta .}}{\*\pnseclvl4\pnlcltr\pnstart1\pnindent720\pnhang {\pntxta )}}{\*\pnseclvl5\pndec\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl6 \pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl7\pnlcrm\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl8\pnlcltr\pnstart1\pnindent720\pnhang {\pntxtb (}{\pntxta )}}{\*\pnseclvl9\pnlcrm\pnstart1\pnindent720\pnhang -{\pntxtb (}{\pntxta )}}\pard\plain \ltrpar\ql \li0\ri0\sb100\sa100\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 \rtlch\fcs1 \af31507\afs22\alang1025 \ltrch\fcs0 -\fs22\lang1033\langfe1033\loch\af31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \ab\af0\afs28 \ltrch\fcs0 \b\f0\fs28\insrsid11612883 \hich\af0\dbch\af31505\loch\f0 Microsoft }{\rtlch\fcs1 \ab\af0\afs28 \ltrch\fcs0 -\b\f0\fs28\insrsid11612883 \hich\af0\dbch\af31505\loch\f0 Public }{\rtlch\fcs1 \ab\af0\afs28 \ltrch\fcs0 \b\f0\fs28\insrsid11612883 \hich\af0\dbch\af31505\loch\f0 License (Ms-PL) -\par }{\rtlch\fcs1 \ab\af0\afs24 \ltrch\fcs0 \b\f0\fs24\insrsid11612883 \hich\af0\dbch\af31505\loch\f0 -This license governs use of the accompanying software. If you use the software, you accept this license. If you do not accept the license, do not use the software.}{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid11612883 -\par }{\rtlch\fcs1 \ab\af0\afs36 \ltrch\fcs0 \b\f0\fs36\insrsid11612883 \hich\af0\dbch\af31505\loch\f0 1. Definitions -\par }{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid11612883 \hich\af0\dbch\af31505\loch\f0 \hich\f0 The terms \'93\loch\f0 \hich\f0 reproduce,\'94\loch\f0 \hich\f0 \'93\loch\f0 \hich\f0 reproduction,\'94\loch\f0 \hich\f0 \'93 -\hich\af0\dbch\af31505\loch\f0 \hich\f0 derivative works,\'94\loch\f0 \hich\f0 and \'93\loch\f0 \hich\f0 distribution\'94\loch\f0 have the same meaning here as under U.S. copyright law. -\par \hich\af0\dbch\af31505\loch\f0 \hich\f0 A \'93\loch\f0 \hich\f0 contribution\'94\loch\f0 is the original software, or any additions or changes to the software. -\par \hich\af0\dbch\af31505\loch\f0 \hich\f0 A \'93\loch\f0 \hich\f0 contributor\'94\loch\f0 is any person that distributes its contribution under this\hich\af0\dbch\af31505\loch\f0 license. -\par \loch\af0\dbch\af31505\hich\f0 \'93\loch\f0 \hich\f0 Licensed patents\'94\loch\f0 are a contributor\hich\f0 \rquote \loch\f0 s patent claims that read directly on its contribution. -\par }{\rtlch\fcs1 \ab\af0\afs36 \ltrch\fcs0 \b\f0\fs36\insrsid11612883 \hich\af0\dbch\af31505\loch\f0 2. Grant of Rights -\par }{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid11612883 \hich\af0\dbch\af31505\loch\f0 (A) Copyright Grant- Subject to the terms of this license, including the license conditions and limitations in section 3, each contrib -\hich\af0\dbch\af31505\loch\f0 utor grants you a non-exclusive, worldwide, royalty-free copyright license to reproduce its contribution, prepare derivative works of its contribution, and distribute its contribution or any derivative works that you create. - -\par \hich\af0\dbch\af31505\loch\f0 (B) Patent Grant- Subject to th\hich\af0\dbch\af31505\loch\f0 -e terms of this license, including the license conditions and limitations in section 3, each contributor grants you a non-exclusive, worldwide, royalty-free license under its licensed patents to make, have made, use, sell, offer for sale, import, and/or o -\hich\af0\dbch\af31505\loch\f0 t\hich\af0\dbch\af31505\loch\f0 herwise dispose of its contribution in the software or derivative works of the contribution in the software. -\par }{\rtlch\fcs1 \ab\af0\afs36 \ltrch\fcs0 \b\f0\fs36\insrsid11612883 \hich\af0\dbch\af31505\loch\f0 3. Conditions and Limitations -\par }{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid11612883 \hich\af0\dbch\af31505\loch\f0 (A) No Trademark License- This license does not grant you rights to use any contributors\hich\f0 \rquote \loch\f0 name, logo, or trademarks. -\par \hich\af0\dbch\af31505\loch\f0 (B) If you bring a patent claim against any contributor over patents that you claim are infringed by the software, your patent license from such contributor to the software ends automatically. -\par \hich\af0\dbch\af31505\loch\f0 (C) If you distribute any portion of the software, you must ret\hich\af0\dbch\af31505\loch\f0 ain all copyright, patent, trademark, and attribution notices that are present in the software. -\par \hich\af0\dbch\af31505\loch\f0 (D) If you distribute any portion of the software in source code form, you may do so only under this license by including a complete copy of this license with y\hich\af0\dbch\af31505\loch\f0 -our distribution. If you distribute any portion of the software in compiled or object code form, you may only do so under a license that complies with this license. -\par \hich\af0\dbch\af31505\loch\f0 \hich\f0 (E) The software is licensed \'93\loch\f0 \hich\f0 as-is.\'94\loch\f0 You bear the risk of using it. The contributors give \hich\af0\dbch\af31505\loch\f0 -no express warranties, guarantees or conditions. You may have additional consumer rights under your local laws which this license cannot change. To the extent permitted under your local laws, the contributors exclude the implied warranties of merchantabil -\hich\af0\dbch\af31505\loch\f0 i\hich\af0\dbch\af31505\loch\f0 ty, fitness for a particular purpose and non-infringement. -\par }\pard \ltrpar\ql \li0\ri0\nowidctlpar\wrapdefault\faauto\rin0\lin0\itap0 {\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid11612883 +{\pntxtb (}{\pntxta )}}\pard\plain \ltrpar\qc \li0\ri0\sb100\sa100\sbauto1\saauto1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid12260020 \rtlch\fcs1 \af31507\afs22\alang1025 \ltrch\fcs0 +\fs22\lang1033\langfe1033\loch\af31506\hich\af31506\dbch\af31505\cgrid\langnp1033\langfenp1033 {\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 Apache License\line Version 2.0, January 2004\line }{\field\fldedit{\*\fldinst { +\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 HYPERLINK "http://www.apache.org/licenses/" }}{\fldrslt {\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\ul\cf2\insrsid12260020\charrsid12260020 http://www.apache.org/licenses/}}} +\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 +\par }\pard \ltrpar\ql \li0\ri0\sb100\sa100\sbauto1\saauto1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid12260020 {\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION +\par }{\rtlch\fcs1 \ab\af0\afs24 \ltrch\fcs0 \b\f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkstart definitions}1. Definitions}{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkend definitions}. +\par "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. +\par "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. +\par "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause + the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. +\par "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. +\par "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. +\par "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. +\par "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). +\par "Derivative Works" shall mean any work, whether in Source or Object form, that is ba +sed on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works th +at remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. +\par "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that +Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, +" +submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are + managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." +\par "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. +\par }{\rtlch\fcs1 \ab\af0\afs24 \ltrch\fcs0 \b\f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkstart copyright}2. Grant of Copyright License}{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkend copyright} +. Subject to the terms and conditions of this License, each Contri +butor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative + Works in Source or Object form. +\par }{\rtlch\fcs1 \ab\af0\afs24 \ltrch\fcs0 \b\f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkstart patent}3. Grant of Patent License}{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkend patent} +. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this se +ction) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alon +e + or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution in +corporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. +\par }{\rtlch\fcs1 \ab\af0\afs24 \ltrch\fcs0 \b\f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkstart redistribution}4. Redistribution}{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkend redistribution} +. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: +\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af0 \ltrch\fcs0 \dbch\af0\insrsid12260020\charrsid12260020 \hich\af0\dbch\af0\loch\f0 a.\tab}}\pard \ltrpar\ql \fi-360\li720\ri0\sb100\sa240\sbauto1\widctlpar +\jclisttab\tx720\wrapdefault\aspalpha\aspnum\faauto\ls1\adjustright\rin0\lin720\itap0\pararsid12260020 {\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 You must give any other recipients of t +he Work or Derivative Works a copy of this License; and +\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af0 \ltrch\fcs0 \dbch\af0\insrsid12260020\charrsid12260020 \hich\af0\dbch\af0\loch\f0 b.\tab}You must cause any modified files to carry prominent notices stating that You changed the files; and +\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af0 \ltrch\fcs0 \dbch\af0\insrsid12260020\charrsid12260020 \hich\af0\dbch\af0\loch\f0 c.\tab}You must retain, in the Source form of any Derivative Works that You distribute, all copyrigh +t, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and +\par {\listtext\pard\plain\ltrpar \rtlch\fcs1 \af0 \ltrch\fcs0 \dbch\af0\insrsid12260020\charrsid12260020 \hich\af0\dbch\af0\loch\f0 d.\tab}}\pard \ltrpar\ql \fi-360\li720\ri0\sb100\sa100\sbauto1\saauto1\widctlpar +\jclisttab\tx720\wrapdefault\aspalpha\aspnum\faauto\ls1\adjustright\rin0\lin720\itap0\pararsid12260020 {\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 +If the Work includes a "NOTICE" text file as part of its distribution, then any Derivati +ve Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTI +C +E text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear +. + The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provide +d that such additional attribution notices cannot be construed as modifying the License. +\par }\pard \ltrpar\ql \li0\ri0\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid12260020 {\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 +You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribut +ion of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. +\par }\pard \ltrpar\ql \li0\ri0\sb100\sa100\sbauto1\saauto1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid12260020 {\rtlch\fcs1 \ab\af0\afs24 \ltrch\fcs0 \b\f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkstart contributions +}5. Submission of Contributions}{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkend contributions}. Unless You explicitly stat +e otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall sup +ersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. +\par }{\rtlch\fcs1 \ab\af0\afs24 \ltrch\fcs0 \b\f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkstart trademarks}6. Trademarks}{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkend trademarks} +. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the +Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. +\par }{\rtlch\fcs1 \ab\af0\afs24 \ltrch\fcs0 \b\f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkstart no-warranty}7. Disclaimer of Warranty}{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkend no-warranty} +. Unless required by applicable law or agreed to in writing, Licensor provides the +Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, o +r FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. +\par }{\rtlch\fcs1 \ab\af0\afs24 \ltrch\fcs0 \b\f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkstart no-liability}8. Limitation of Liability}{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkend no-liability}. In no e +vent and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, +i +ncluding any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, com +puter failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. +\par }{\rtlch\fcs1 \ab\af0\afs24 \ltrch\fcs0 \b\f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkstart additional}9. Accepting Warranty or Additional Liability}{\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 {\*\bkmkend additional +}. While redistributing the Work or Derivative Works + thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and + +on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any + such warranty or additional liability. +\par See }{\field\fldedit{\*\fldinst {\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 HYPERLINK "http://www.codeplex.com/IronPython/Wiki/View.aspx?title=FAQ&referringTitle=Home" }}{\fldrslt {\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 +\f0\fs24\ul\cf2\insrsid12260020\charrsid12260020 FAQ}}}\sectd \ltrsect\linex0\sectdefaultcl\sftnbj {\rtlch\fcs1 \af0\afs24 \ltrch\fcs0 \f0\fs24\insrsid12260020\charrsid12260020 for answers to frequently asked questions about this license. +\par }\pard \ltrpar\ql \li0\ri0\sa200\sl276\slmult1\widctlpar\wrapdefault\aspalpha\aspnum\faauto\adjustright\rin0\lin0\itap0\pararsid12260020 {\rtlch\fcs1 \af31507\afs24 \ltrch\fcs0 \insrsid11612883\charrsid12260020 \par }{\*\themedata 504b030414000600080000002100828abc13fa0000001c020000130000005b436f6e74656e745f54797065735d2e786d6cac91cb6ac3301045f785fe83d0b6d8 72ba28a5d8cea249777d2cd20f18e4b12d6a8f843409c9df77ecb850ba082d74231062ce997b55ae8fe3a00e1893f354e9555e6885647de3a8abf4fbee29bbd7 2a3150038327acf409935ed7d757e5ee14302999a654e99e393c18936c8f23a4dc072479697d1c81e51a3b13c07e4087e6b628ee8cf5c4489cf1c4d075f92a0b @@ -170,8 +238,8 @@ fffffffffffffffffdfffffffeffffffffffffffffffffffffffffffffffffffffffffffffffffff ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff -ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffffec69d9888b8b3d4c859eaf6cd158be0f0000000000000000000000009055 -58f93d1bc801feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000 +ffffffffffffffffffffffffffffffff52006f006f007400200045006e00740072007900000000000000000000000000000000000000000000000000000000000000000000000000000000000000000016000500ffffffffffffffffffffffffec69d9888b8b3d4c859eaf6cd158be0f0000000000000000000000002093 +a94acc1ecb01feffffff00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff00000000000000000000000000000000000000000000000000000000 00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff0000000000000000000000000000000000000000000000000000 000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000ffffffffffffffffffffffff000000000000000000000000000000000000000000000000 0000000000000000000000000000000000000000000000000105000000000000}} \ No newline at end of file diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Dynamic.dll b/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Dynamic.dll index 00f466c554..b28b36c6b7 100644 Binary files a/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Dynamic.dll and b/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Dynamic.dll differ diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.Debugging.dll b/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.Debugging.dll deleted file mode 100644 index 640741a109..0000000000 Binary files a/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.Debugging.dll and /dev/null differ diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.Metadata.dll b/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.Metadata.dll new file mode 100644 index 0000000000..2d1bcf4d2f Binary files /dev/null and b/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.Metadata.dll differ diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.Silverlight.dll b/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.Silverlight.dll new file mode 100644 index 0000000000..1ad08ce6de Binary files /dev/null and b/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.Silverlight.dll differ diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.dll b/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.dll index ce080e65ed..0c26390608 100755 Binary files a/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.dll and b/src/AddIns/BackendBindings/Python/RequiredLibraries/Microsoft.Scripting.dll differ diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/ipy.exe b/src/AddIns/BackendBindings/Python/RequiredLibraries/ipy.exe index b923fb1317..04d79829a3 100755 Binary files a/src/AddIns/BackendBindings/Python/RequiredLibraries/ipy.exe and b/src/AddIns/BackendBindings/Python/RequiredLibraries/ipy.exe differ diff --git a/src/AddIns/BackendBindings/Python/RequiredLibraries/ipyw.exe b/src/AddIns/BackendBindings/Python/RequiredLibraries/ipyw.exe index b30f8af3a2..266fb29bd7 100644 Binary files a/src/AddIns/BackendBindings/Python/RequiredLibraries/ipyw.exe and b/src/AddIns/BackendBindings/Python/RequiredLibraries/ipyw.exe differ diff --git a/src/Setup/Files.wxs b/src/Setup/Files.wxs index eb5d6281ee..8ede901007 100644 --- a/src/Setup/Files.wxs +++ b/src/Setup/Files.wxs @@ -1092,11 +1092,6 @@ - - - - - @@ -1111,6 +1106,12 @@ + + + + + + diff --git a/src/Setup/Setup.wxs b/src/Setup/Setup.wxs index 074f22fd8d..e88c6061a3 100644 --- a/src/Setup/Setup.wxs +++ b/src/Setup/Setup.wxs @@ -408,12 +408,13 @@ - + + - +