svn+ssh://pythondev@svn.python.org/python/trunk
........
r60178 | georg.brandl | 2008-01-21 22:05:49 +0100 (Mon, 21 Jan 2008) | 2 lines
#1715: include sub-extension modules in pydoc text output.
........
r60179 | georg.brandl | 2008-01-21 22:14:21 +0100 (Mon, 21 Jan 2008) | 2 lines
Add a "const" to make gcc happy.
........
r60180 | georg.brandl | 2008-01-21 22:19:07 +0100 (Mon, 21 Jan 2008) | 2 lines
Add the correct build dir when building with pydebug.
........
r60181 | georg.brandl | 2008-01-21 22:23:15 +0100 (Mon, 21 Jan 2008) | 3 lines
Patch #
1720595: add T_BOOL to the range of structmember types.
Patch by Angelo Mottola, reviewed by MvL, tests by me.
........
r60182 | georg.brandl | 2008-01-21 22:28:32 +0100 (Mon, 21 Jan 2008) | 2 lines
Reformat some ugly code.
........
r60187 | brett.cannon | 2008-01-22 00:50:16 +0100 (Tue, 22 Jan 2008) | 4 lines
Make's MAKEFLAGS variable is set to a string containing the single-letter
arguments to Make. This means there are no hyphens. Fix the '-s' check to
silence distutils to now work.
........
r60188 | gregory.p.smith | 2008-01-22 01:19:41 +0100 (Tue, 22 Jan 2008) | 3 lines
accepts and closes issue #
1221598: adds an optional callback to ftplib.FTP
storbinary() and storlines() methods.
........
r60189 | gregory.p.smith | 2008-01-22 02:12:02 +0100 (Tue, 22 Jan 2008) | 2 lines
Replace spam.acquire() try: ... finally: spam.release() with "with spam:"
........
r60190 | gregory.p.smith | 2008-01-22 02:20:42 +0100 (Tue, 22 Jan 2008) | 4 lines
- Fix Issue #
1703448: A joined thread could show up in the
threading.enumerate() list after the join() for a brief period until
it actually exited.
........
r60193 | georg.brandl | 2008-01-22 08:53:31 +0100 (Tue, 22 Jan 2008) | 2 lines
Fix \xhh specs, #1889.
........
r60198 | christian.heimes | 2008-01-22 16:01:25 +0100 (Tue, 22 Jan 2008) | 1 line
Fixed a missing (X) in define
........
r60199 | christian.heimes | 2008-01-22 16:25:18 +0100 (Tue, 22 Jan 2008) | 2 lines
Don't repeat yourself
Added the macros PyModule_AddIntMacro and PyModule_AddStringMacro. They shorten PyModule_AddIntConstant(m, "AF_INET", AF_INET) to PyModule_AddIntMacro(m, AF_INET)
........
r60201 | raymond.hettinger | 2008-01-22 20:51:41 +0100 (Tue, 22 Jan 2008) | 1 line
Document when to use izip_longest().
........
r60202 | georg.brandl | 2008-01-22 20:56:03 +0100 (Tue, 22 Jan 2008) | 2 lines
Fix for #
1087741 patch.
........
r60203 | raymond.hettinger | 2008-01-22 21:18:53 +0100 (Tue, 22 Jan 2008) | 1 line
Give zip() the same guarantee as izip() for left-to-right evaluation.
........
r60204 | raymond.hettinger | 2008-01-22 23:09:26 +0100 (Tue, 22 Jan 2008) | 1 line
Improve variable name in sample code
........
r60205 | gregory.p.smith | 2008-01-23 00:15:34 +0100 (Wed, 23 Jan 2008) | 2 lines
docstring and comment updates suggested by Giampaolo Rodola'
........
r60207 | raymond.hettinger | 2008-01-23 01:04:40 +0100 (Wed, 23 Jan 2008) | 1 line
Let pprint() support sets and frozensets (suggested by David Mertz).
........
r60208 | guido.van.rossum | 2008-01-23 02:18:27 +0100 (Wed, 23 Jan 2008) | 4 lines
I'm tired of these tests breaking at Google due to our large number of
users and groups in LDAP/NIS. So I'm limiting the extra-heavy part of
the tests to passwd/group files with at most 1000 entries.
........
is exposed to Python programs as ``types.ModuleType``.
-.. cfunction:: int PyModule_Check(PyObject *p)
+.. cmacro:: int PyModule_Check(PyObject *p)
Return true if *p* is a module object, or a subtype of a module object.
-.. cfunction:: int PyModule_CheckExact(PyObject *p)
+.. cmacro:: int PyModule_CheckExact(PyObject *p)
Return true if *p* is a module object, but not a subtype of
:cdata:`PyModule_Type`.
Add a string constant to *module* as *name*. This convenience function can be
used from the module's initialization function. The string *value* must be
null-terminated. Return ``-1`` on error, ``0`` on success.
+
+
+.. cmacro:: int PyModule_AddIntMacro(PyObject *module, macro)
+
+ Add an int constant to *module*. The name and the value are taken from
+ *macro*. For example ``PyModule_AddConstant(module, AF_INET)`` adds the int
+ constant *AF_INET* with the value of *AF_INET* to *module*.
+ Return ``-1`` on error, ``0`` on success.
+
+
+.. cmacro:: int PyModule_AddStringMacro(PyObject *module, macro)
+
+ Add a string constant to *module*.
+
sequence argument, it returns an iterator of 1-tuples. With no arguments, it
returns an empty iterator.
+ The left-to-right evaluation order of the iterables is guaranteed. This
+ makes possible an idiom for clustering a data series into n-length groups
+ using ``zip(*[iter(s)]*n)``.
+
.. rubric:: Footnotes
iterables = [iter(it) for it in iterables)
while True:
args = [next(it) for it in iterables]
- yield function(*args)
+ if function is None:
+ yield tuple(args)
+ else:
+ yield function(*args)
.. function:: islice(iterable, [start,] stop [, step])
When no iterables are specified, return a zero length iterator.
- Note, the left-to-right evaluation order of the iterables is guaranteed. This
- makes possible an idiom for clustering a data series into n-length groups using
- ``izip(*[iter(s)]*n)``. For data that doesn't fit n-length groups exactly, the
- last tuple can be pre-padded with fill values using ``izip(*[chain(s,
- [None]*(n-1))]*n)``.
+ The left-to-right evaluation order of the iterables is guaranteed. This
+ makes possible an idiom for clustering a data series into n-length groups
+ using ``izip(*[iter(s)]*n)``.
+<<<<<<< .working
Note, when :func:`izip` is used with unequal length inputs, subsequent
iteration over the longer iterables cannot reliably be continued after
:func:`izip` terminates. Potentially, up to one entry will be missing from
the iterator for retrieval with ``next(it)``). In general, :func:`izip`
should only be used with unequal length inputs when you don't care about
trailing, unmatched values from the longer iterables.
+=======
+ :func:`izip` should only be used with unequal length inputs when you don't
+ care about trailing, unmatched values from the longer iterables. If those
+ values are important, use :func:`izip_longest` instead.
+>>>>>>> .merge-right.r60208
.. function:: izip_longest(*iterables[, fillvalue])
Dictionaries are sorted by key before the display is computed.
+.. versionchanged:: 2.6
+ Added support for :class:`set` and :class:`frozenset`.
+
The :mod:`pprint` module defines one class:
.. First the implementation class:
(4)
Individual code units which form parts of a surrogate pair can be encoded using
- this escape sequence.
+ this escape sequence. Unlike in Standard C, exactly two hex digits are required.
(5)
Any Unicode character can be encoded this way, but characters outside the Basic
PyAPI_FUNC(int) PyModule_AddObject(PyObject *, const char *, PyObject *);
PyAPI_FUNC(int) PyModule_AddIntConstant(PyObject *, const char *, long);
PyAPI_FUNC(int) PyModule_AddStringConstant(PyObject *, const char *, const char *);
-
+#define PyModule_AddIntMacro(m, c) PyModule_AddIntConstant(m, #c, c)
+#define PyModule_AddStringMacro(m, c) PyModule_AddStringConstant(m, #c, c)
#define PYTHON_API_VERSION 1013
#define PYTHON_API_STRING "1013"
*/
#ifndef Py_IS_FINITE
#ifdef HAVE_FINITE
-#define Py_IS_FINITE(X) finite
+#define Py_IS_FINITE(X) finite(X)
#else
#define Py_IS_FINITE(X) (!Py_IS_INFINITY(X) && !Py_IS_NAN(X))
#endif
/* Added by Jack: strings contained in the structure */
#define T_STRING_INPLACE 13
+/* Added by Lillo: bools contained in the structure (assumed char) */
+#define T_BOOL 14
+
#define T_OBJECT_EX 16 /* Like T_OBJECT, but raises AttributeError
when the value is NULL, instead of
converting to None. */
# Changes and improvements suggested by Steve Majewski.
# Modified by Jack to work on the mac.
# Modified by Siebren to support docstrings and PASV.
+# Modified by Phil Schwartz to add storbinary and storlines callbacks.
#
import os
expected size may be None if it could not be determined.
Optional `rest' argument can be a string that is sent as the
- argument to a RESTART command. This is essentially a server
+ argument to a REST command. This is essentially a server
marker used to tell the server to skip over any data up to the
given marker.
"""
return resp
def retrbinary(self, cmd, callback, blocksize=8192, rest=None):
- """Retrieve data in binary mode.
-
- `cmd' is a RETR command. `callback' is a callback function is
- called for each block. No more than `blocksize' number of
- bytes will be read from the socket. Optional `rest' is passed
- to transfercmd().
-
- A new port is created for you. Return the response code.
+ """Retrieve data in binary mode. A new port is created for you.
+
+ Args:
+ cmd: A RETR command.
+ callback: A single parameter callable to be called on each
+ block of data read.
+ blocksize: The maximum number of bytes to read from the
+ socket at one time. [default: 8192]
+ rest: Passed to transfercmd(). [default: None]
+
+ Returns:
+ The response code.
"""
self.voidcmd('TYPE I')
conn = self.transfercmd(cmd, rest)
return self.voidresp()
def retrlines(self, cmd, callback = None):
- '''Retrieve data in line mode.
- The argument is a RETR or LIST command.
- The callback function (2nd argument) is called for each line,
- with trailing CRLF stripped. This creates a new port for you.
- print_line() is the default callback.'''
+ """Retrieve data in line mode. A new port is created for you.
+
+ Args:
+ cmd: A RETR, LIST, NLST, or MLSD command.
+ callback: An optional single parameter callable that is called
+ for each line with the trailing CRLF stripped.
+ [default: print_line()]
+
+ Returns:
+ The response code.
+ """
if callback is None: callback = print_line
resp = self.sendcmd('TYPE A')
conn = self.transfercmd(cmd)
conn.close()
return self.voidresp()
- def storbinary(self, cmd, fp, blocksize=8192):
- '''Store a file in binary mode.'''
+ def storbinary(self, cmd, fp, blocksize=8192, callback=None):
+ """Store a file in binary mode. A new port is created for you.
+
+ Args:
+ cmd: A STOR command.
+ fp: A file-like object with a read(num_bytes) method.
+ blocksize: The maximum data size to read from fp and send over
+ the connection at once. [default: 8192]
+ callback: An optional single parameter callable that is called on
+ on each block of data after it is sent. [default: None]
+
+ Returns:
+ The response code.
+ """
self.voidcmd('TYPE I')
conn = self.transfercmd(cmd)
while 1:
buf = fp.read(blocksize)
if not buf: break
conn.sendall(buf)
+ if callback: callback(buf)
conn.close()
return self.voidresp()
- def storlines(self, cmd, fp):
- '''Store a file in line mode.'''
+ def storlines(self, cmd, fp, callback=None):
+ """Store a file in line mode. A new port is created for you.
+
+ Args:
+ cmd: A STOR command.
+ fp: A file-like object with a readline() method.
+ callback: An optional single parameter callable that is called on
+ on each line after it is sent. [default: None]
+
+ Returns:
+ The response code.
+ """
self.voidcmd('TYPE A')
conn = self.transfercmd(cmd)
while 1:
if buf[-1] in CRLF: buf = buf[:-1]
buf = buf + CRLF
conn.sendall(buf)
+ if callback: callback(buf)
conn.close()
return self.voidresp()
def size(self, filename):
'''Retrieve the size of a file.'''
- # Note that the RFC doesn't say anything about 'SIZE'
+ # The SIZE command is defined in RFC-3659
resp = self.sendcmd('SIZE ' + filename)
if resp[:3] == '213':
s = resp[3:].strip()
write('}')
return
- if (issubclass(typ, list) and r is list.__repr__) or \
- (issubclass(typ, tuple) and r is tuple.__repr__):
+ if ((issubclass(typ, list) and r is list.__repr__) or
+ (issubclass(typ, tuple) and r is tuple.__repr__) or
+ (issubclass(typ, set) and r is set.__repr__) or
+ (issubclass(typ, frozenset) and r is frozenset.__repr__)
+ ):
if issubclass(typ, list):
write('[')
endchar = ']'
+ elif issubclass(typ, set):
+ write('{')
+ endchar = '}'
+ object = sorted(object)
+ indent += 4
+ elif issubclass(typ, frozenset):
+ write('frozenset([')
+ endchar = '])'
+ object = sorted(object)
+ indent += 9
else:
write('(')
endchar = ')'
if visiblename(key, all):
data.append((key, value))
+ modpkgs = []
+ modpkgs_names = set()
if hasattr(object, '__path__'):
- modpkgs = []
for importer, modname, ispkg in pkgutil.iter_modules(object.__path__):
+ modpkgs_names.add(modname)
if ispkg:
modpkgs.append(modname + ' (package)')
else:
result = result + self.section(
'PACKAGE CONTENTS', '\n'.join(modpkgs))
+ # Detect submodules as sometimes created by C extensions
+ submodules = []
+ for key, value in inspect.getmembers(object, inspect.ismodule):
+ if value.__name__.startswith(name + '.') and key not in modpkgs_names:
+ submodules.append(key)
+ if submodules:
+ submodules.sort()
+ result = result + self.section(
+ 'SUBMODULES', join(submodules, '\n'))
+
if classes:
classlist = [value for key, value in classes]
contents = [self.formattree(
(especially for Guido :-)"""
from distutils.util import get_platform
s = "build/lib.%s-%.3s" % (get_platform(), sys.version)
+ if hasattr(sys, 'gettotalrefcount'):
+ s += '-pydebug'
s = os.path.join(os.path.dirname(sys.path[-1]), s)
sys.path.append(s)
"""Something just to look at via pydoc."""
+import types
+
class A_classic:
"A classic class."
def A_method(self):
del inst.desc[self.attr]
x = property(get_desc('x'), set_desc('x'), del_desc('x'), 'prop x')
+
+
+submodule = types.ModuleType(__name__ + '.submodule',
+ """A submodule, which should appear in its parent's summary""")
for e in entries:
self.check_value(e)
+ if len(entries) > 1000: # Huge group file (NIS?) -- skip the rest
+ return
+
for e in entries:
e2 = grp.getgrgid(e.gr_gid)
self.check_value(e2)
except OSError:
pass
+ def test_subclass(self):
+ class anon_mmap(mmap.mmap):
+ def __new__(klass, *args, **kwargs):
+ return mmap.mmap.__new__(klass, -1, *args, **kwargs)
+ anon_mmap(PAGESIZE)
+
+
def test_main():
run_unittest(MmapTests)
entriesbyname.setdefault(e.pw_name, []).append(e)
entriesbyuid.setdefault(e.pw_uid, []).append(e)
+ if len(entries) > 1000: # Huge passwd file (NIS?) -- skip the rest
+ return
+
# check whether the entry returned by getpwuid()
# for each uid is among those from getpwall() for this uid
for e in entries:
import warnings, unittest, sys
from test import test_support
-ts=test_structmembersType(1,2,3,4,5,6,7,8,9.99999,10.1010101010)
+ts=test_structmembersType(False, 1, 2, 3, 4, 5, 6, 7, 8,
+ 9.99999, 10.1010101010)
class ReadWriteTests(unittest.TestCase):
def test_types(self):
- ts.T_BYTE=CHAR_MAX
+ ts.T_BOOL = True
+ self.assertEquals(ts.T_BOOL, True)
+ ts.T_BOOL = False
+ self.assertEquals(ts.T_BOOL, False)
+ self.assertRaises(TypeError, setattr, ts, 'T_BOOL', 1)
+
+ ts.T_BYTE = CHAR_MAX
self.assertEquals(ts.T_BYTE, CHAR_MAX)
- ts.T_BYTE=CHAR_MIN
+ ts.T_BYTE = CHAR_MIN
self.assertEquals(ts.T_BYTE, CHAR_MIN)
- ts.T_UBYTE=UCHAR_MAX
+ ts.T_UBYTE = UCHAR_MAX
self.assertEquals(ts.T_UBYTE, UCHAR_MAX)
- ts.T_SHORT=SHRT_MAX
+ ts.T_SHORT = SHRT_MAX
self.assertEquals(ts.T_SHORT, SHRT_MAX)
- ts.T_SHORT=SHRT_MIN
+ ts.T_SHORT = SHRT_MIN
self.assertEquals(ts.T_SHORT, SHRT_MIN)
- ts.T_USHORT=USHRT_MAX
+ ts.T_USHORT = USHRT_MAX
self.assertEquals(ts.T_USHORT, USHRT_MAX)
- ts.T_INT=INT_MAX
+ ts.T_INT = INT_MAX
self.assertEquals(ts.T_INT, INT_MAX)
- ts.T_INT=INT_MIN
+ ts.T_INT = INT_MIN
self.assertEquals(ts.T_INT, INT_MIN)
- ts.T_UINT=UINT_MAX
+ ts.T_UINT = UINT_MAX
self.assertEquals(ts.T_UINT, UINT_MAX)
- ts.T_LONG=LONG_MAX
+ ts.T_LONG = LONG_MAX
self.assertEquals(ts.T_LONG, LONG_MAX)
- ts.T_LONG=LONG_MIN
+ ts.T_LONG = LONG_MIN
self.assertEquals(ts.T_LONG, LONG_MIN)
- ts.T_ULONG=ULONG_MAX
+ ts.T_ULONG = ULONG_MAX
self.assertEquals(ts.T_ULONG, ULONG_MAX)
## T_LONGLONG and T_ULONGLONG may not be present on some platforms
if hasattr(ts, 'T_LONGLONG'):
- ts.T_LONGLONG=LLONG_MAX
+ ts.T_LONGLONG = LLONG_MAX
self.assertEquals(ts.T_LONGLONG, LLONG_MAX)
- ts.T_LONGLONG=LLONG_MIN
+ ts.T_LONGLONG = LLONG_MIN
self.assertEquals(ts.T_LONGLONG, LLONG_MIN)
- ts.T_ULONGLONG=ULLONG_MAX
+ ts.T_ULONGLONG = ULLONG_MAX
self.assertEquals(ts.T_ULONGLONG, ULLONG_MAX)
## make sure these will accept a plain int as well as a long
- ts.T_LONGLONG=3
+ ts.T_LONGLONG = 3
self.assertEquals(ts.T_LONGLONG, 3)
- ts.T_ULONGLONG=4
+ ts.T_ULONGLONG = 4
self.assertEquals(ts.T_ULONGLONG, 4)
def test_byte_max(self):
with test_support.catch_warning() as w:
- ts.T_BYTE=CHAR_MAX+1
+ ts.T_BYTE = CHAR_MAX+1
self.has_warned(w)
def test_byte_min(self):
with test_support.catch_warning() as w:
- ts.T_BYTE=CHAR_MIN-1
+ ts.T_BYTE = CHAR_MIN-1
self.has_warned(w)
def test_ubyte_max(self):
with test_support.catch_warning() as w:
- ts.T_UBYTE=UCHAR_MAX+1
+ ts.T_UBYTE = UCHAR_MAX+1
self.has_warned(w)
def test_short_max(self):
with test_support.catch_warning() as w:
- ts.T_SHORT=SHRT_MAX+1
+ ts.T_SHORT = SHRT_MAX+1
self.has_warned(w)
def test_short_min(self):
with test_support.catch_warning() as w:
- ts.T_SHORT=SHRT_MIN-1
+ ts.T_SHORT = SHRT_MIN-1
self.has_warned(w)
def test_ushort_max(self):
with test_support.catch_warning() as w:
- ts.T_USHORT=USHRT_MAX+1
+ ts.T_USHORT = USHRT_MAX+1
self.has_warned(w)
"""])
self.assertEqual(rc, 42)
+ def test_enumerate_after_join(self):
+ # Try hard to trigger #1703448: a thread is still returned in
+ # threading.enumerate() after it has been join()ed.
+ enum = threading.enumerate
+ old_interval = sys.getcheckinterval()
+ sys.setcheckinterval(1)
+ try:
+ for i in range(1, 1000):
+ t = threading.Thread(target=lambda: None)
+ t.start()
+ t.join()
+ l = enum()
+ self.assertFalse(t in l,
+ "#1703448 triggered after %d trials: %s" % (i, l))
+ finally:
+ sys.setcheckinterval(old_interval)
+
+
class ThreadingExceptionTests(unittest.TestCase):
# A RuntimeError should be raised if Thread.start() is called
# multiple times.
return self._flag
def set(self):
- self._cond.acquire()
- try:
+ with self._cond:
self._flag = True
self._cond.notifyAll()
- finally:
- self._cond.release()
def clear(self):
- self._cond.acquire()
- try:
+ with self._cond:
self._flag = False
- finally:
- self._cond.release()
def wait(self, timeout=None):
- self._cond.acquire()
- try:
+ with self._cond:
if not self._flag:
self._cond.wait(timeout)
- finally:
- self._cond.release()
# Helper to generate new thread names
_counter = 0
if __debug__:
self._note("%s.__bootstrap(): normal return", self)
finally:
- self._stop()
- try:
- self._delete()
- except:
- pass
+ with _active_limbo_lock:
+ self._stop()
+ try:
+ # We don't call self.__delete() because it also
+ # grabs _active_limbo_lock.
+ del _active[_get_ident()]
+ except:
+ pass
def _stop(self):
- self._block.acquire()
- self._stopped = True
- self._block.notifyAll()
- self._block.release()
+ with self._block:
+ self._stopped = True
+ self._block.notifyAll()
def _delete(self):
"Remove current thread from the dict of currently running threads."
# since it isn't if dummy_threading is *not* being used then don't
# hide the exception.
- _active_limbo_lock.acquire()
- try:
+ with _active_limbo_lock:
try:
del _active[_get_ident()]
except KeyError:
if 'dummy_threading' not in _sys.modules:
raise
- finally:
- _active_limbo_lock.release()
def join(self, timeout=None):
if not self._initialized:
if __debug__:
if not self._stopped:
self._note("%s.join(): waiting until thread stops", self)
- self._block.acquire()
- try:
+ with self._block:
if timeout is None:
while not self._stopped:
self._block.wait()
else:
if __debug__:
self._note("%s.join(): thread stopped", self)
- finally:
- self._block.release()
def getName(self):
assert self._initialized, "Thread.__init__() not called"
# Build the shared modules
sharedmods: $(BUILDPYTHON)
@case $$MAKEFLAGS in \
- *-s*) $(RUNSHARED) CC='$(CC)' LDSHARED='$(BLDSHARED)' OPT='$(OPT)' ./$(BUILDPYTHON) -E $(srcdir)/setup.py -q build;; \
+ *s*) $(RUNSHARED) CC='$(CC)' LDSHARED='$(BLDSHARED)' OPT='$(OPT)' ./$(BUILDPYTHON) -E $(srcdir)/setup.py -q build;; \
*) $(RUNSHARED) CC='$(CC)' LDSHARED='$(BLDSHARED)' OPT='$(OPT)' ./$(BUILDPYTHON) -E $(srcdir)/setup.py build;; \
esac
#define AddSym(d, n, f, v) {PyObject *o = f(v); PyDict_SetItemString(d, n, o); Py_DECREF(o);}
typedef struct {
+ char bool_member;
char byte_member;
unsigned char ubyte_member;
short short_member;
} test_structmembers;
static struct PyMemberDef test_members[] = {
+ {"T_BOOL", T_BOOL, offsetof(test_structmembers, structmembers.bool_member), 0, NULL},
{"T_BYTE", T_BYTE, offsetof(test_structmembers, structmembers.byte_member), 0, NULL},
{"T_UBYTE", T_UBYTE, offsetof(test_structmembers, structmembers.ubyte_member), 0, NULL},
{"T_SHORT", T_SHORT, offsetof(test_structmembers, structmembers.short_member), 0, NULL},
};
-static PyObject *test_structmembers_new(PyTypeObject *type, PyObject *args, PyObject *kwargs){
- static char *keywords[]={"T_BYTE", "T_UBYTE", "T_SHORT", "T_USHORT", "T_INT", "T_UINT",
- "T_LONG", "T_ULONG", "T_FLOAT", "T_DOUBLE",
- #ifdef HAVE_LONG_LONG
+static PyObject *
+test_structmembers_new(PyTypeObject *type, PyObject *args, PyObject *kwargs)
+{
+ static char *keywords[] = {
+ "T_BOOL", "T_BYTE", "T_UBYTE", "T_SHORT", "T_USHORT",
+ "T_INT", "T_UINT", "T_LONG", "T_ULONG",
+ "T_FLOAT", "T_DOUBLE",
+#ifdef HAVE_LONG_LONG
"T_LONGLONG", "T_ULONGLONG",
- #endif
+#endif
NULL};
- static char *fmt="|bBhHiIlkfd"
- #ifdef HAVE_LONG_LONG
+ static char *fmt = "|bbBhHiIlkfd"
+#ifdef HAVE_LONG_LONG
"LK"
- #endif
+#endif
;
- test_structmembers *ob=PyObject_New(test_structmembers, type);
- if (ob==NULL)
+ test_structmembers *ob;
+ ob = PyObject_New(test_structmembers, type);
+ if (ob == NULL)
return NULL;
memset(&ob->structmembers, 0, sizeof(all_structmembers));
if (!PyArg_ParseTupleAndKeywords(args, kwargs, fmt, keywords,
- &ob->structmembers.byte_member, &ob->structmembers.ubyte_member,
- &ob->structmembers.short_member, &ob->structmembers.ushort_member,
- &ob->structmembers.int_member, &ob->structmembers.uint_member,
- &ob->structmembers.long_member, &ob->structmembers.ulong_member,
- &ob->structmembers.float_member, &ob->structmembers.double_member
- #ifdef HAVE_LONG_LONG
- ,&ob->structmembers.longlong_member, &ob->structmembers.ulonglong_member
- #endif
- )){
+ &ob->structmembers.bool_member,
+ &ob->structmembers.byte_member,
+ &ob->structmembers.ubyte_member,
+ &ob->structmembers.short_member,
+ &ob->structmembers.ushort_member,
+ &ob->structmembers.int_member,
+ &ob->structmembers.uint_member,
+ &ob->structmembers.long_member,
+ &ob->structmembers.ulong_member,
+ &ob->structmembers.float_member,
+ &ob->structmembers.double_member
+#ifdef HAVE_LONG_LONG
+ , &ob->structmembers.longlong_member,
+ &ob->structmembers.ulonglong_member
+#endif
+ )) {
Py_DECREF(ob);
return NULL;
- }
+ }
return (PyObject *)ob;
}
-static void test_structmembers_free(PyObject *ob){
+static void
+test_structmembers_free(PyObject *ob)
+{
PyObject_FREE(ob);
}
0, /* tp_hash */
0, /* tp_call */
0, /* tp_str */
- PyObject_GenericGetAttr,
- PyObject_GenericSetAttr,
+ PyObject_GenericGetAttr, /* tp_getattro */
+ PyObject_GenericSetAttr, /* tp_setattro */
0, /* tp_as_buffer */
0, /* tp_flags */
"Type containing all structmember types",
0, /* tp_iter */
0, /* tp_iternext */
0, /* tp_methods */
- test_members, /* tp_members */
+ test_members, /* tp_members */
0,
0,
0,
0,
0,
0,
- test_structmembers_new, /* tp_new */
+ test_structmembers_new, /* tp_new */
};
}
#endif /* UNIX */
- PyObject_Del(m_obj);
+ Py_TYPE(m_obj)->tp_free((PyObject*)m_obj);
}
static PyObject *
{
PyObject* utf8 = NULL;
const char *s;
- char *newl[2] = {NULL, NULL};
+ const char *newl[2] = {NULL, NULL};
int lineno = 0;
tok->enc = NULL;
tok->str = str;
addr += l->offset;
switch (l->type) {
+ case T_BOOL:
+ v = PyBool_FromLong(*(char*)addr);
+ break;
case T_BYTE:
v = PyLong_FromLong(*(char*)addr);
break;
}
addr += l->offset;
switch (l->type) {
+ case T_BOOL:{
+ if (!PyBool_Check(v)) {
+ PyErr_SetString(PyExc_TypeError,
+ "attribute value type must be bool");
+ return -1;
+ }
+ if (v == Py_True)
+ *(char*)addr = (char) 1;
+ else
+ *(char*)addr = (char) 0;
+ break;
+ }
case T_BYTE:{
long long_val = PyLong_AsLong(v);
if ((long_val == -1) && PyErr_Occurred())
projects / python / commitdiff