traverseda
/
cpython
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Merged revisions 59696-59702 via svnmerge from 

svn+ssh://pythondev@svn.python.org/python/trunk

........
  r59696 | amaury.forgeotdarc | 2008-01-04 03:04:15 +0100 (Fri, 04 Jan 2008) | 11 lines

  Partial port of r59682 from py3k.

  On Windows, when import fails to load a dll module, the message says
  "error code 193" instead of a more informative text.

  It turns out that FormatMessage needs additional parameters for some error codes.
  For example: 193 means "%1 is not a valid Win32 application".
  Since it is impossible to know which parameter to pass, we use
  FORMAT_MESSAGE_IGNORE_INSERTS to get the raw message, which is still better
  than the number.
........
  r59698 | andrew.kuchling | 2008-01-04 03:26:00 +0100 (Fri, 04 Jan 2008) | 1 line

  Typo fix
........
  r59699 | andrew.kuchling | 2008-01-04 03:31:40 +0100 (Fri, 04 Jan 2008) | 1 line

  Add math items; other edits
........
  r59700 | christian.heimes | 2008-01-04 03:46:19 +0100 (Fri, 04 Jan 2008) | 1 line

  Fixed refleak tests for _struct changes
........
  r59701 | christian.heimes | 2008-01-04 03:54:42 +0100 (Fri, 04 Jan 2008) | 1 line

  Added _struct._clearcache() for regression tests
........
This commit is contained in:
Christian Heimes 2008-01-04 03:08:33 +00:00
parent a34706f101
commit 3f419afac5
2 changed files with 46 additions and 112 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

47
Doc/whatsnew/2.6.rst
View File

@ -483,6 +483,32 @@ PEP 3119: Abstract Base Classes
XXX
How to identify a file object?
ABCs are a collection of classes describing various interfaces.
Classes can derive from an ABC to indicate they support that ABC's
interface. Concrete classes should obey the semantics specified by
an ABC, but Python can't check this; it's up to the implementor.
A metaclass lets you declare that an existing class or type
derives from a particular ABC. You can even
class AppendableSequence:
__metaclass__ = ABCMeta
AppendableSequence.register(list)
assert issubclass(list, AppendableSequence)
assert isinstance([], AppendableSequence)
@abstractmethod decorator -- you can't instantiate classes w/
an abstract method.
@abstractproperty decorator
@abstractproperty
def readonly(self):
return self._x
.. seealso::
:pep:`3119` - Introducing Abstract Base Classes
@ -554,12 +580,22 @@ Here are all of the changes that Python 2.6 makes to the core Python language.
* More floating-point features were also added. The :func:`float` function
will now turn the strings ``+nan`` and ``-nan`` into the corresponding
IEEE 754 Not a Number values, and ``+inf`` and ``-inf`` into
IEEE 754 Not A Number values, and ``+inf`` and ``-inf`` into
positive or negative infinity. This works on any platform with
IEEE 754 semantics. (Contributed by Christian Heimes.)
.. Patch 1635.
Other functions in the :mod:`math` module, :func:`isinf` and
:func:`isnan`, return true if their floating-point argument is
infinite or Not A Number.
.. Patch 1640
The ``math.copysign(x, y)`` function
copies the sign bit of an IEEE 754 number, returning the absolute
value of *x* combined with the sign bit of *y*. For example,
``math.copysign(1, -0.0)`` returns -1.0. (Contributed by Christian
Heimes.)
* Changes to the :class:`Exception` interface
as dictated by :pep:`352` continue to be made. For 2.6,
the :attr:`message` attribute is being deprecated in favor of the
@ -612,6 +648,10 @@ Here are all of the changes that Python 2.6 makes to the core Python language.
Optimizations
-------------
* All of the functions in the :mod:`struct` module have been rewritten in
C, thanks to work at the Need For Speed sprint.
(Contributed by Raymond Hettinger.)
* Internally, a bit is now set in type objects to indicate some of the standard
built-in types. This speeds up checking if an object is a subclass of one of
these types. (Contributed by Neal Norwitz.)
@ -1074,12 +1114,13 @@ Changes to Python's build process and to the C API include:
.. Issue 1635
* Some macros were renamed. :cmacro:`Py_Size()` became :cmacro:`Py_SIZE()`,
* Some macros were renamed to make it clearer that they are macros,
not functions. :cmacro:`Py_Size()` became :cmacro:`Py_SIZE()`,
:cmacro:`Py_Type()` became :cmacro:`Py_TYPE()`, and
:cmacro:`Py_Refcnt()` became :cmacro:`Py_REFCNT()`. Macros for backward
compatibility are still available for Python 2.6.
.. Issue 1629: XXX why was this done?
.. Issue 1629
.. ======================================================================

111
Lib/struct.py
View File

@ -1,109 +1,2 @@
"""
Functions to convert between Python values and C structs.
Python strings are used to hold the data representing the C struct
and also as format strings to describe the layout of data in the C struct.
The optional first format char indicates byte order, size and alignment:
@: native order, size & alignment (default)
=: native order, std. size & alignment
<: little-endian, std. size & alignment
>: big-endian, std. size & alignment
!: same as >
The remaining chars indicate types of args and must match exactly;
these can be preceded by a decimal repeat count:
x: pad byte (no data); c:char; b:signed byte; B:unsigned byte;
h:short; H:unsigned short; i:int; I:unsigned int;
l:long; L:unsigned long; f:float; d:double.
Special cases (preceding decimal count indicates length):
s:string (array of char); p: pascal string (with count byte).
Special case (only available in native format):
P:an integer type that is wide enough to hold a pointer.
Special case (not in native mode unless 'long long' in platform C):
q:long long; Q:unsigned long long
Whitespace between formats is ignored.
The variable struct.error is an exception raised on errors.
"""
__version__ = '3.0'
from _struct import Struct as _Struct, error
class Struct(_Struct):
def __init__(self, fmt):
if isinstance(fmt, str):
fmt = bytes(fmt, 'ascii')
elif isinstance(fmt, buffer):
fmt = bytes(fmt)
_Struct.__init__(self, fmt)
_MAXCACHE = 100
_cache = {}
def _compile(fmt):
# Internal: compile struct pattern
if len(_cache) >= _MAXCACHE:
_cache.clear()
s = Struct(fmt)
_cache[fmt] = s
return s
def calcsize(fmt):
"""
Return size of C struct described by format string fmt.
See struct.__doc__ for more on format strings.
"""
try:
o = _cache[fmt]
except KeyError:
o = _compile(fmt)
return o.size
def pack(fmt, *args):
"""
Return string containing values v1, v2, ... packed according to fmt.
See struct.__doc__ for more on format strings.
"""
try:
o = _cache[fmt]
except KeyError:
o = _compile(fmt)
return bytes(o.pack(*args))
def pack_into(fmt, buf, offset, *args):
"""
Pack the values v1, v2, ... according to fmt, write
the packed bytes into the writable buffer buf starting at offset.
See struct.__doc__ for more on format strings.
"""
try:
o = _cache[fmt]
except KeyError:
o = _compile(fmt)
o.pack_into(buf, offset, *args)
def unpack(fmt, s):
"""
Unpack the string, containing packed C structure data, according
to fmt. Requires len(string)==calcsize(fmt).
See struct.__doc__ for more on format strings.
"""
try:
o = _cache[fmt]
except KeyError:
o = _compile(fmt)
return o.unpack(s)
def unpack_from(fmt, buf, offset=0):
"""
Unpack the buffer, containing packed C structure data, according to
fmt starting at offset. Requires len(buffer[offset:]) >= calcsize(fmt).
See struct.__doc__ for more on format strings.
"""
try:
o = _cache[fmt]
except KeyError:
o = _compile(fmt)
return o.unpack_from(buf, offset)
from _struct import *
from _struct import _clearcache