mirror of https://github.com/python/cpython
#11515: fix several typos. Patch by Piotr Kasprzyk.
This commit is contained in:
parent
f6db0bbbee
commit
42da663e6f
|
@ -116,7 +116,7 @@ class FunctionTestCase(unittest.TestCase):
|
|||
self.assertEqual(result, 21)
|
||||
self.assertEqual(type(result), int)
|
||||
|
||||
# You cannot assing character format codes as restype any longer
|
||||
# You cannot assign character format codes as restype any longer
|
||||
self.assertRaises(TypeError, setattr, f, "restype", "i")
|
||||
|
||||
def test_floatresult(self):
|
||||
|
|
|
@ -5710,7 +5710,7 @@ def _parse_format_specifier(format_spec, _localeconv=None):
|
|||
|
||||
def _format_align(sign, body, spec):
|
||||
"""Given an unpadded, non-aligned numeric string 'body' and sign
|
||||
string 'sign', add padding and aligment conforming to the given
|
||||
string 'sign', add padding and alignment conforming to the given
|
||||
format specifier dictionary 'spec' (as produced by
|
||||
parse_format_specifier).
|
||||
|
||||
|
|
|
@ -17,7 +17,7 @@ class MIMEApplication(MIMENonMultipart):
|
|||
_encoder=encoders.encode_base64, **_params):
|
||||
"""Create an application/* type MIME document.
|
||||
|
||||
_data is a string containing the raw applicatoin data.
|
||||
_data is a string containing the raw application data.
|
||||
|
||||
_subtype is the MIME content type subtype, defaulting to
|
||||
'octet-stream'.
|
||||
|
|
|
@ -298,7 +298,7 @@ class GNUTranslations(NullTranslations):
|
|||
# Note: we unconditionally convert both msgids and msgstrs to
|
||||
# Unicode using the character encoding specified in the charset
|
||||
# parameter of the Content-Type header. The gettext documentation
|
||||
# strongly encourages msgids to be us-ascii, but some appliations
|
||||
# strongly encourages msgids to be us-ascii, but some applications
|
||||
# require alternative encodings (e.g. Zope's ZCML and ZPT). For
|
||||
# traditional gettext applications, the msgid conversion will
|
||||
# cause no problems since us-ascii should always be a subset of
|
||||
|
|
|
@ -799,7 +799,7 @@ class HTTPConnection:
|
|||
del self._buffer[:]
|
||||
# If msg and message_body are sent in a single send() call,
|
||||
# it will avoid performance problems caused by the interaction
|
||||
# between delayed ack and the Nagle algorithim.
|
||||
# between delayed ack and the Nagle algorithm.
|
||||
if isinstance(message_body, bytes):
|
||||
msg += message_body
|
||||
message_body = None
|
||||
|
|
|
@ -105,8 +105,8 @@ class EditorWindow(object):
|
|||
self.top = top = WindowList.ListedToplevel(root, menu=self.menubar)
|
||||
if flist:
|
||||
self.tkinter_vars = flist.vars
|
||||
#self.top.instance_dict makes flist.inversedict avalable to
|
||||
#configDialog.py so it can access all EditorWindow instaces
|
||||
#self.top.instance_dict makes flist.inversedict available to
|
||||
#configDialog.py so it can access all EditorWindow instances
|
||||
self.top.instance_dict = flist.inversedict
|
||||
else:
|
||||
self.tkinter_vars = {} # keys: Tkinter event names
|
||||
|
|
|
@ -13,7 +13,7 @@ What's New in IDLEfork 0.8.1?
|
|||
- New tarball released as a result of the 'revitalisation' of the IDLEfork
|
||||
project.
|
||||
|
||||
- This release requires python 2.1 or better. Compatability with earlier
|
||||
- This release requires python 2.1 or better. Compatibility with earlier
|
||||
versions of python (especially ancient ones like 1.5x) is no longer a
|
||||
priority in IDLEfork development.
|
||||
|
||||
|
|
|
@ -162,7 +162,7 @@ def _check_name(method):
|
|||
loader can handle.
|
||||
|
||||
The first argument (self) must define _name which the second argument is
|
||||
comapred against. If the comparison fails then ImportError is raised.
|
||||
compared against. If the comparison fails then ImportError is raised.
|
||||
|
||||
"""
|
||||
def inner(self, name, *args, **kwargs):
|
||||
|
|
|
@ -103,7 +103,7 @@ class NNTP:
|
|||
|
||||
readermode is sometimes necessary if you are connecting to an
|
||||
NNTP server on the local machine and intend to call
|
||||
reader-specific comamnds, such as `group'. If you get
|
||||
reader-specific commands, such as `group'. If you get
|
||||
unexpected NNTPPermanentErrors, you might need to set
|
||||
readermode.
|
||||
"""
|
||||
|
|
|
@ -5,7 +5,7 @@
|
|||
# file handles.
|
||||
|
||||
# The point of this example is to show that sys.setrecursionlimit() is a
|
||||
# hack, and not a robust solution. This example simply exercices a path
|
||||
# hack, and not a robust solution. This example simply exercises a path
|
||||
# where it takes many C-level recursions, consuming a lot of stack
|
||||
# space, for each Python-level recursion. So 1000 times this amount of
|
||||
# stack space may be too much for standard platforms already.
|
||||
|
|
|
@ -177,7 +177,7 @@ if 1:
|
|||
self.assertEqual(eval("-" + all_one_bits), -18446744073709551615)
|
||||
else:
|
||||
self.fail("How many bits *does* this machine have???")
|
||||
# Verify treatment of contant folding on -(sys.maxsize+1)
|
||||
# Verify treatment of constant folding on -(sys.maxsize+1)
|
||||
# i.e. -2147483648 on 32 bit platforms. Should return int, not long.
|
||||
self.assertTrue(isinstance(eval("%s" % (-sys.maxsize - 1)), int))
|
||||
self.assertTrue(isinstance(eval("%s" % (-sys.maxsize - 2)), int))
|
||||
|
|
|
@ -777,7 +777,7 @@ class ClassPropertiesAndMethods(unittest.TestCase):
|
|||
# see "A Monotonic Superclass Linearization for Dylan",
|
||||
# by Kim Barrett et al. (OOPSLA 1996)
|
||||
def test_consistency_with_epg(self):
|
||||
# Testing consistentcy with EPG...
|
||||
# Testing consistency with EPG...
|
||||
class Pane(object): pass
|
||||
class ScrollingMixin(object): pass
|
||||
class EditingMixin(object): pass
|
||||
|
|
|
@ -273,7 +273,7 @@ class StatAttributeTests(unittest.TestCase):
|
|||
except TypeError:
|
||||
pass
|
||||
|
||||
# Use the constructr with a too-long tuple.
|
||||
# Use the constructor with a too-long tuple.
|
||||
try:
|
||||
result2 = os.stat_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
|
||||
except TypeError:
|
||||
|
@ -320,7 +320,7 @@ class StatAttributeTests(unittest.TestCase):
|
|||
except TypeError:
|
||||
pass
|
||||
|
||||
# Use the constructr with a too-long tuple.
|
||||
# Use the constructor with a too-long tuple.
|
||||
try:
|
||||
result2 = os.statvfs_result((0,1,2,3,4,5,6,7,8,9,10,11,12,13,14))
|
||||
except TypeError:
|
||||
|
|
|
@ -7,7 +7,7 @@ from weakref import proxy
|
|||
# Misc tests from Tim Peters' re.doc
|
||||
|
||||
# WARNING: Don't change details in these tests if you don't know
|
||||
# what you're doing. Some of these tests were carefuly modeled to
|
||||
# what you're doing. Some of these tests were carefully modeled to
|
||||
# cover most of the code.
|
||||
|
||||
import unittest
|
||||
|
|
|
@ -584,7 +584,7 @@ class TestSet(TestJointOps):
|
|||
self.le_called = True
|
||||
return False
|
||||
|
||||
# This first tries the bulitin rich set comparison, which doesn't know
|
||||
# This first tries the builtin rich set comparison, which doesn't know
|
||||
# how to handle the custom object. Upon returning NotImplemented, the
|
||||
# corresponding comparison on the right object is invoked.
|
||||
myset = {1, 2, 3}
|
||||
|
|
|
@ -93,7 +93,7 @@ class ModuleTest(unittest.TestCase):
|
|||
# test all parameters used
|
||||
class CheckAllUsedFormatter(string.Formatter):
|
||||
def check_unused_args(self, used_args, args, kwargs):
|
||||
# Track which arguments actuallly got used
|
||||
# Track which arguments actually got used
|
||||
unused_args = set(kwargs.keys())
|
||||
unused_args.update(range(0, len(args)))
|
||||
|
||||
|
|
|
@ -692,7 +692,7 @@ class PyCatchWarningTests(CatchWarningTests):
|
|||
class BootstrapTest(unittest.TestCase):
|
||||
def test_issue_8766(self):
|
||||
# "import encodings" emits a warning whereas the warnings is not loaded
|
||||
# or not completly loaded (warnings imports indirectly encodings by
|
||||
# or not completely loaded (warnings imports indirectly encodings by
|
||||
# importing linecache) yet
|
||||
cwd = tempfile.mkdtemp()
|
||||
try:
|
||||
|
|
|
@ -1607,7 +1607,7 @@ class Wm:
|
|||
|
||||
class Tk(Misc, Wm):
|
||||
"""Toplevel widget of Tk which represents mostly the main window
|
||||
of an appliation. It has an associated Tcl interpreter."""
|
||||
of an application. It has an associated Tcl interpreter."""
|
||||
_w = '.'
|
||||
def __init__(self, screenName=None, baseName=None, className='Tk',
|
||||
useTk=1, sync=0, use=None):
|
||||
|
|
|
@ -148,7 +148,7 @@ class tixCommand:
|
|||
extensions) exist, then the image type is chosen according to the
|
||||
depth of the X display: xbm images are chosen on monochrome
|
||||
displays and color images are chosen on color displays. By using
|
||||
tix_ getimage, you can advoid hard coding the pathnames of the
|
||||
tix_ getimage, you can avoid hard coding the pathnames of the
|
||||
image files in your application. When successful, this command
|
||||
returns the name of the newly created image, which can be used to
|
||||
configure the -image option of the Tk and Tix widgets.
|
||||
|
|
|
@ -993,7 +993,7 @@ class Panedwindow(Widget, tkinter.PanedWindow):
|
|||
pane is either an integer index or the name of a managed subwindow.
|
||||
If kw is not given, returns a dict of the pane option values. If
|
||||
option is specified then the value for that option is returned.
|
||||
Otherwise, sets the options to the correspoding values."""
|
||||
Otherwise, sets the options to the corresponding values."""
|
||||
if option is not None:
|
||||
kw[option] = None
|
||||
return _val_or_dict(kw, self.tk.call, self._w, "pane", pane)
|
||||
|
|
|
@ -1464,7 +1464,7 @@ class TurtleScreen(TurtleScreenBase):
|
|||
Optional argument:
|
||||
picname -- a string, name of a gif-file or "nopic".
|
||||
|
||||
If picname is a filename, set the corresponing image as background.
|
||||
If picname is a filename, set the corresponding image as background.
|
||||
If picname is "nopic", delete backgroundimage, if present.
|
||||
If picname is None, return the filename of the current backgroundimage.
|
||||
|
||||
|
@ -3352,7 +3352,7 @@ class RawTurtle(TPen, TNavigator):
|
|||
def dot(self, size=None, *color):
|
||||
"""Draw a dot with diameter size, using color.
|
||||
|
||||
Optional argumentS:
|
||||
Optional arguments:
|
||||
size -- an integer >= 1 (if given)
|
||||
color -- a colorstring or a numeric color tuple
|
||||
|
||||
|
|
|
@ -1464,7 +1464,7 @@ class ElementInfo(object):
|
|||
return False
|
||||
|
||||
def isId(self, aname):
|
||||
"""Returns true iff the named attribte is a DTD-style ID."""
|
||||
"""Returns true iff the named attribute is a DTD-style ID."""
|
||||
return False
|
||||
|
||||
def isIdNS(self, namespaceURI, localName):
|
||||
|
|
|
@ -98,7 +98,7 @@ UNIVERSALARCHS = '32-bit'
|
|||
|
||||
ARCHLIST = universal_opts_map[UNIVERSALARCHS]
|
||||
|
||||
# Source directory (asume we're in Mac/BuildScript)
|
||||
# Source directory (assume we're in Mac/BuildScript)
|
||||
SRCDIR = os.path.dirname(
|
||||
os.path.dirname(
|
||||
os.path.dirname(
|
||||
|
|
|
@ -413,6 +413,7 @@ Kurt B. Kaiser
|
|||
Tamito Kajiyama
|
||||
Peter van Kampen
|
||||
Jacob Kaplan-Moss
|
||||
Piotr Kasprzyk
|
||||
Lou Kates
|
||||
Hiroaki Kawai
|
||||
Sebastien Keim
|
||||
|
|
|
@ -49,7 +49,7 @@
|
|||
So, there are 4 data structures holding processed arguments:
|
||||
- the inargs tuple (in PyCFuncPtr_call)
|
||||
- the callargs tuple (in PyCFuncPtr_call)
|
||||
- the 'struct argguments' array
|
||||
- the 'struct arguments' array
|
||||
- the 'void *' array
|
||||
|
||||
*/
|
||||
|
|
|
@ -59,24 +59,24 @@ enum { ASM_NEEDS_REGISTERS = 4 };
|
|||
|
||||
The stack layout we want looks like this:
|
||||
|
||||
| Return address from ffi_call_DARWIN | higher addresses
|
||||
| Return address from ffi_call_DARWIN | higher addresses
|
||||
|--------------------------------------------|
|
||||
| Previous backchain pointer 4 | stack pointer here
|
||||
|--------------------------------------------|<+ <<< on entry to
|
||||
| Saved r28-r31 4*4 | | ffi_call_DARWIN
|
||||
| Previous backchain pointer 4 | stack pointer here
|
||||
|--------------------------------------------|<+ <<< on entry to
|
||||
| Saved r28-r31 4*4 | | ffi_call_DARWIN
|
||||
|--------------------------------------------| |
|
||||
| Parameters (at least 8*4=32) | |
|
||||
|--------------------------------------------| |
|
||||
| Space for GPR2 4 | |
|
||||
|--------------------------------------------| | stack |
|
||||
| Reserved 2*4 | | grows |
|
||||
|--------------------------------------------| | down V
|
||||
| Space for callee's LR 4 | |
|
||||
|--------------------------------------------| | lower addresses
|
||||
|--------------------------------------------| | stack |
|
||||
| Reserved 2*4 | | grows |
|
||||
|--------------------------------------------| | down V
|
||||
| Space for callee's LR 4 | |
|
||||
|--------------------------------------------| | lower addresses
|
||||
| Saved CR 4 | |
|
||||
|--------------------------------------------| | stack pointer here
|
||||
| Current backchain pointer 4 |-/ during
|
||||
|--------------------------------------------| <<< ffi_call_DARWIN
|
||||
| Current backchain pointer 4 |-/ during
|
||||
|--------------------------------------------| <<< ffi_call_DARWIN
|
||||
|
||||
*/
|
||||
|
||||
|
@ -123,106 +123,106 @@ void ffi_prep_args(extended_cif *ecif, unsigned *const stack)
|
|||
i--, ptr++, p_argv++)
|
||||
{
|
||||
switch ((*ptr)->type)
|
||||
{
|
||||
/* If a floating-point parameter appears before all of the general-
|
||||
purpose registers are filled, the corresponding GPRs that match
|
||||
the size of the floating-point parameter are skipped. */
|
||||
case FFI_TYPE_FLOAT:
|
||||
double_tmp = *(float *)*p_argv;
|
||||
if (fparg_count >= NUM_FPR_ARG_REGISTERS)
|
||||
*(double *)next_arg = double_tmp;
|
||||
else
|
||||
*fpr_base++ = double_tmp;
|
||||
next_arg++;
|
||||
fparg_count++;
|
||||
FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
|
||||
break;
|
||||
{
|
||||
/* If a floating-point parameter appears before all of the general-
|
||||
purpose registers are filled, the corresponding GPRs that match
|
||||
the size of the floating-point parameter are skipped. */
|
||||
case FFI_TYPE_FLOAT:
|
||||
double_tmp = *(float *)*p_argv;
|
||||
if (fparg_count >= NUM_FPR_ARG_REGISTERS)
|
||||
*(double *)next_arg = double_tmp;
|
||||
else
|
||||
*fpr_base++ = double_tmp;
|
||||
next_arg++;
|
||||
fparg_count++;
|
||||
FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
|
||||
break;
|
||||
|
||||
case FFI_TYPE_DOUBLE:
|
||||
double_tmp = *(double *)*p_argv;
|
||||
if (fparg_count >= NUM_FPR_ARG_REGISTERS)
|
||||
*(double *)next_arg = double_tmp;
|
||||
else
|
||||
*fpr_base++ = double_tmp;
|
||||
next_arg += 2;
|
||||
fparg_count++;
|
||||
FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
|
||||
break;
|
||||
case FFI_TYPE_DOUBLE:
|
||||
double_tmp = *(double *)*p_argv;
|
||||
if (fparg_count >= NUM_FPR_ARG_REGISTERS)
|
||||
*(double *)next_arg = double_tmp;
|
||||
else
|
||||
*fpr_base++ = double_tmp;
|
||||
next_arg += 2;
|
||||
fparg_count++;
|
||||
FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
|
||||
break;
|
||||
|
||||
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
|
||||
|
||||
case FFI_TYPE_LONGDOUBLE:
|
||||
double_tmp = ((double *)*p_argv)[0];
|
||||
if (fparg_count >= NUM_FPR_ARG_REGISTERS)
|
||||
*(double *)next_arg = double_tmp;
|
||||
else
|
||||
*fpr_base++ = double_tmp;
|
||||
next_arg += 2;
|
||||
fparg_count++;
|
||||
double_tmp = ((double *)*p_argv)[1];
|
||||
if (fparg_count >= NUM_FPR_ARG_REGISTERS)
|
||||
*(double *)next_arg = double_tmp;
|
||||
else
|
||||
*fpr_base++ = double_tmp;
|
||||
next_arg += 2;
|
||||
fparg_count++;
|
||||
FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
|
||||
break;
|
||||
case FFI_TYPE_LONGDOUBLE:
|
||||
double_tmp = ((double *)*p_argv)[0];
|
||||
if (fparg_count >= NUM_FPR_ARG_REGISTERS)
|
||||
*(double *)next_arg = double_tmp;
|
||||
else
|
||||
*fpr_base++ = double_tmp;
|
||||
next_arg += 2;
|
||||
fparg_count++;
|
||||
double_tmp = ((double *)*p_argv)[1];
|
||||
if (fparg_count >= NUM_FPR_ARG_REGISTERS)
|
||||
*(double *)next_arg = double_tmp;
|
||||
else
|
||||
*fpr_base++ = double_tmp;
|
||||
next_arg += 2;
|
||||
fparg_count++;
|
||||
FFI_ASSERT(flags & FLAG_FP_ARGUMENTS);
|
||||
break;
|
||||
#endif
|
||||
case FFI_TYPE_UINT64:
|
||||
case FFI_TYPE_SINT64:
|
||||
*(long long *)next_arg = *(long long *)*p_argv;
|
||||
next_arg+=2;
|
||||
break;
|
||||
case FFI_TYPE_UINT8:
|
||||
gprvalue = *(unsigned char *)*p_argv;
|
||||
goto putgpr;
|
||||
case FFI_TYPE_SINT8:
|
||||
gprvalue = *(signed char *)*p_argv;
|
||||
goto putgpr;
|
||||
case FFI_TYPE_UINT16:
|
||||
gprvalue = *(unsigned short *)*p_argv;
|
||||
goto putgpr;
|
||||
case FFI_TYPE_SINT16:
|
||||
gprvalue = *(signed short *)*p_argv;
|
||||
goto putgpr;
|
||||
case FFI_TYPE_UINT64:
|
||||
case FFI_TYPE_SINT64:
|
||||
*(long long *)next_arg = *(long long *)*p_argv;
|
||||
next_arg+=2;
|
||||
break;
|
||||
case FFI_TYPE_UINT8:
|
||||
gprvalue = *(unsigned char *)*p_argv;
|
||||
goto putgpr;
|
||||
case FFI_TYPE_SINT8:
|
||||
gprvalue = *(signed char *)*p_argv;
|
||||
goto putgpr;
|
||||
case FFI_TYPE_UINT16:
|
||||
gprvalue = *(unsigned short *)*p_argv;
|
||||
goto putgpr;
|
||||
case FFI_TYPE_SINT16:
|
||||
gprvalue = *(signed short *)*p_argv;
|
||||
goto putgpr;
|
||||
|
||||
case FFI_TYPE_STRUCT:
|
||||
dest_cpy = (char *) next_arg;
|
||||
case FFI_TYPE_STRUCT:
|
||||
dest_cpy = (char *) next_arg;
|
||||
|
||||
/* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
|
||||
SI 4 bytes) are aligned as if they were those modes.
|
||||
Structures with 3 byte in size are padded upwards. */
|
||||
size_al = (*ptr)->size;
|
||||
/* If the first member of the struct is a double, then align
|
||||
the struct to double-word.
|
||||
Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
|
||||
if ((*ptr)->elements[0]->type == 3)
|
||||
size_al = ALIGN((*ptr)->size, 8);
|
||||
if (size_al < 3 && ecif->cif->abi == FFI_DARWIN)
|
||||
dest_cpy += 4 - size_al;
|
||||
/* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
|
||||
SI 4 bytes) are aligned as if they were those modes.
|
||||
Structures with 3 byte in size are padded upwards. */
|
||||
size_al = (*ptr)->size;
|
||||
/* If the first member of the struct is a double, then align
|
||||
the struct to double-word.
|
||||
Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
|
||||
if ((*ptr)->elements[0]->type == 3)
|
||||
size_al = ALIGN((*ptr)->size, 8);
|
||||
if (size_al < 3 && ecif->cif->abi == FFI_DARWIN)
|
||||
dest_cpy += 4 - size_al;
|
||||
|
||||
memcpy((char *)dest_cpy, (char *)*p_argv, size_al);
|
||||
next_arg += (size_al + 3) / 4;
|
||||
break;
|
||||
memcpy((char *)dest_cpy, (char *)*p_argv, size_al);
|
||||
next_arg += (size_al + 3) / 4;
|
||||
break;
|
||||
|
||||
case FFI_TYPE_INT:
|
||||
case FFI_TYPE_UINT32:
|
||||
case FFI_TYPE_SINT32:
|
||||
case FFI_TYPE_POINTER:
|
||||
gprvalue = *(unsigned *)*p_argv;
|
||||
putgpr:
|
||||
*next_arg++ = gprvalue;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
case FFI_TYPE_INT:
|
||||
case FFI_TYPE_UINT32:
|
||||
case FFI_TYPE_SINT32:
|
||||
case FFI_TYPE_POINTER:
|
||||
gprvalue = *(unsigned *)*p_argv;
|
||||
putgpr:
|
||||
*next_arg++ = gprvalue;
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
/* Check that we didn't overrun the stack... */
|
||||
//FFI_ASSERT(gpr_base <= stacktop - ASM_NEEDS_REGISTERS);
|
||||
//FFI_ASSERT((unsigned *)fpr_base
|
||||
// <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
|
||||
// <= stacktop - ASM_NEEDS_REGISTERS - NUM_GPR_ARG_REGISTERS);
|
||||
//FFI_ASSERT(flags & FLAG_4_GPR_ARGUMENTS || intarg_count <= 4);
|
||||
}
|
||||
|
||||
|
@ -246,15 +246,15 @@ darwin_adjust_aggregate_sizes (ffi_type *s)
|
|||
p = s->elements[i];
|
||||
darwin_adjust_aggregate_sizes (p);
|
||||
if (i == 0
|
||||
&& (p->type == FFI_TYPE_UINT64
|
||||
|| p->type == FFI_TYPE_SINT64
|
||||
|| p->type == FFI_TYPE_DOUBLE
|
||||
|| p->alignment == 8))
|
||||
align = 8;
|
||||
&& (p->type == FFI_TYPE_UINT64
|
||||
|| p->type == FFI_TYPE_SINT64
|
||||
|| p->type == FFI_TYPE_DOUBLE
|
||||
|| p->alignment == 8))
|
||||
align = 8;
|
||||
else if (p->alignment == 16 || p->alignment < 4)
|
||||
align = p->alignment;
|
||||
align = p->alignment;
|
||||
else
|
||||
align = 4;
|
||||
align = 4;
|
||||
s->size = ALIGN(s->size, align) + p->size;
|
||||
}
|
||||
|
||||
|
@ -287,7 +287,7 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
|
|||
{
|
||||
darwin_adjust_aggregate_sizes (cif->rtype);
|
||||
for (i = 0; i < cif->nargs; i++)
|
||||
darwin_adjust_aggregate_sizes (cif->arg_types[i]);
|
||||
darwin_adjust_aggregate_sizes (cif->arg_types[i]);
|
||||
}
|
||||
|
||||
/* Space for the frame pointer, callee's LR, CR, etc, and for
|
||||
|
@ -348,58 +348,58 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
|
|||
for (ptr = cif->arg_types, i = cif->nargs; i > 0; i--, ptr++)
|
||||
{
|
||||
switch ((*ptr)->type)
|
||||
{
|
||||
case FFI_TYPE_FLOAT:
|
||||
case FFI_TYPE_DOUBLE:
|
||||
fparg_count++;
|
||||
/* If this FP arg is going on the stack, it must be
|
||||
8-byte-aligned. */
|
||||
if (fparg_count > NUM_FPR_ARG_REGISTERS
|
||||
&& intarg_count%2 != 0)
|
||||
intarg_count++;
|
||||
break;
|
||||
{
|
||||
case FFI_TYPE_FLOAT:
|
||||
case FFI_TYPE_DOUBLE:
|
||||
fparg_count++;
|
||||
/* If this FP arg is going on the stack, it must be
|
||||
8-byte-aligned. */
|
||||
if (fparg_count > NUM_FPR_ARG_REGISTERS
|
||||
&& intarg_count%2 != 0)
|
||||
intarg_count++;
|
||||
break;
|
||||
|
||||
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
|
||||
|
||||
case FFI_TYPE_LONGDOUBLE:
|
||||
fparg_count += 2;
|
||||
/* If this FP arg is going on the stack, it must be
|
||||
8-byte-aligned. */
|
||||
if (fparg_count > NUM_FPR_ARG_REGISTERS
|
||||
&& intarg_count%2 != 0)
|
||||
intarg_count++;
|
||||
intarg_count +=2;
|
||||
break;
|
||||
case FFI_TYPE_LONGDOUBLE:
|
||||
fparg_count += 2;
|
||||
/* If this FP arg is going on the stack, it must be
|
||||
8-byte-aligned. */
|
||||
if (fparg_count > NUM_FPR_ARG_REGISTERS
|
||||
&& intarg_count%2 != 0)
|
||||
intarg_count++;
|
||||
intarg_count +=2;
|
||||
break;
|
||||
#endif
|
||||
|
||||
case FFI_TYPE_UINT64:
|
||||
case FFI_TYPE_SINT64:
|
||||
/* 'long long' arguments are passed as two words, but
|
||||
either both words must fit in registers or both go
|
||||
on the stack. If they go on the stack, they must
|
||||
be 8-byte-aligned. */
|
||||
if (intarg_count == NUM_GPR_ARG_REGISTERS-1
|
||||
|| (intarg_count >= NUM_GPR_ARG_REGISTERS && intarg_count%2 != 0))
|
||||
intarg_count++;
|
||||
intarg_count += 2;
|
||||
break;
|
||||
case FFI_TYPE_UINT64:
|
||||
case FFI_TYPE_SINT64:
|
||||
/* 'long long' arguments are passed as two words, but
|
||||
either both words must fit in registers or both go
|
||||
on the stack. If they go on the stack, they must
|
||||
be 8-byte-aligned. */
|
||||
if (intarg_count == NUM_GPR_ARG_REGISTERS-1
|
||||
|| (intarg_count >= NUM_GPR_ARG_REGISTERS && intarg_count%2 != 0))
|
||||
intarg_count++;
|
||||
intarg_count += 2;
|
||||
break;
|
||||
|
||||
case FFI_TYPE_STRUCT:
|
||||
size_al = (*ptr)->size;
|
||||
/* If the first member of the struct is a double, then align
|
||||
the struct to double-word.
|
||||
Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
|
||||
if ((*ptr)->elements[0]->type == 3)
|
||||
size_al = ALIGN((*ptr)->size, 8);
|
||||
intarg_count += (size_al + 3) / 4;
|
||||
break;
|
||||
case FFI_TYPE_STRUCT:
|
||||
size_al = (*ptr)->size;
|
||||
/* If the first member of the struct is a double, then align
|
||||
the struct to double-word.
|
||||
Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
|
||||
if ((*ptr)->elements[0]->type == 3)
|
||||
size_al = ALIGN((*ptr)->size, 8);
|
||||
intarg_count += (size_al + 3) / 4;
|
||||
break;
|
||||
|
||||
default:
|
||||
/* Everything else is passed as a 4-byte word in a GPR, either
|
||||
the object itself or a pointer to it. */
|
||||
intarg_count++;
|
||||
break;
|
||||
}
|
||||
default:
|
||||
/* Everything else is passed as a 4-byte word in a GPR, either
|
||||
the object itself or a pointer to it. */
|
||||
intarg_count++;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
if (fparg_count != 0)
|
||||
|
@ -425,9 +425,9 @@ ffi_status ffi_prep_cif_machdep(ffi_cif *cif)
|
|||
}
|
||||
|
||||
extern void ffi_call_AIX(extended_cif *, unsigned, unsigned, unsigned *,
|
||||
void (*fn)(void), void (*fn2)(void));
|
||||
void (*fn)(void), void (*fn2)(void));
|
||||
extern void ffi_call_DARWIN(extended_cif *, unsigned, unsigned, unsigned *,
|
||||
void (*fn)(void), void (*fn2)(void));
|
||||
void (*fn)(void), void (*fn2)(void));
|
||||
|
||||
void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
|
||||
{
|
||||
|
@ -451,11 +451,11 @@ void ffi_call(ffi_cif *cif, void (*fn)(void), void *rvalue, void **avalue)
|
|||
{
|
||||
case FFI_AIX:
|
||||
ffi_call_AIX(&ecif, -cif->bytes, cif->flags, ecif.rvalue, fn,
|
||||
ffi_prep_args);
|
||||
ffi_prep_args);
|
||||
break;
|
||||
case FFI_DARWIN:
|
||||
ffi_call_DARWIN(&ecif, -cif->bytes, cif->flags, ecif.rvalue, fn,
|
||||
ffi_prep_args);
|
||||
ffi_prep_args);
|
||||
break;
|
||||
default:
|
||||
FFI_ASSERT(0);
|
||||
|
@ -478,61 +478,61 @@ typedef struct aix_fd_struct {
|
|||
and aix_clsoure.S
|
||||
|
||||
SP previous -> +---------------------------------------+ <--- child frame
|
||||
| back chain to caller 4 |
|
||||
+---------------------------------------+ 4
|
||||
| saved CR 4 |
|
||||
+---------------------------------------+ 8
|
||||
| saved LR 4 |
|
||||
+---------------------------------------+ 12
|
||||
| reserved for compilers 4 |
|
||||
+---------------------------------------+ 16
|
||||
| reserved for binders 4 |
|
||||
+---------------------------------------+ 20
|
||||
| saved TOC pointer 4 |
|
||||
+---------------------------------------+ 24
|
||||
| always reserved 8*4=32 (previous GPRs)|
|
||||
| according to the linkage convention |
|
||||
| from AIX |
|
||||
+---------------------------------------+ 56
|
||||
| our FPR area 13*8=104 |
|
||||
| f1 |
|
||||
| . |
|
||||
| f13 |
|
||||
+---------------------------------------+ 160
|
||||
| result area 8 |
|
||||
+---------------------------------------+ 168
|
||||
| alignement to the next multiple of 16 |
|
||||
| back chain to caller 4 |
|
||||
+---------------------------------------+ 4
|
||||
| saved CR 4 |
|
||||
+---------------------------------------+ 8
|
||||
| saved LR 4 |
|
||||
+---------------------------------------+ 12
|
||||
| reserved for compilers 4 |
|
||||
+---------------------------------------+ 16
|
||||
| reserved for binders 4 |
|
||||
+---------------------------------------+ 20
|
||||
| saved TOC pointer 4 |
|
||||
+---------------------------------------+ 24
|
||||
| always reserved 8*4=32 (previous GPRs)|
|
||||
| according to the linkage convention |
|
||||
| from AIX |
|
||||
+---------------------------------------+ 56
|
||||
| our FPR area 13*8=104 |
|
||||
| f1 |
|
||||
| . |
|
||||
| f13 |
|
||||
+---------------------------------------+ 160
|
||||
| result area 8 |
|
||||
+---------------------------------------+ 168
|
||||
| alignment to the next multiple of 16 |
|
||||
SP current --> +---------------------------------------+ 176 <- parent frame
|
||||
| back chain to caller 4 |
|
||||
+---------------------------------------+ 180
|
||||
| saved CR 4 |
|
||||
+---------------------------------------+ 184
|
||||
| saved LR 4 |
|
||||
+---------------------------------------+ 188
|
||||
| reserved for compilers 4 |
|
||||
+---------------------------------------+ 192
|
||||
| reserved for binders 4 |
|
||||
+---------------------------------------+ 196
|
||||
| saved TOC pointer 4 |
|
||||
+---------------------------------------+ 200
|
||||
| always reserved 8*4=32 we store our |
|
||||
| GPRs here |
|
||||
| r3 |
|
||||
| . |
|
||||
| r10 |
|
||||
+---------------------------------------+ 232
|
||||
| overflow part |
|
||||
+---------------------------------------+ xxx
|
||||
| ???? |
|
||||
+---------------------------------------+ xxx
|
||||
| back chain to caller 4 |
|
||||
+---------------------------------------+ 180
|
||||
| saved CR 4 |
|
||||
+---------------------------------------+ 184
|
||||
| saved LR 4 |
|
||||
+---------------------------------------+ 188
|
||||
| reserved for compilers 4 |
|
||||
+---------------------------------------+ 192
|
||||
| reserved for binders 4 |
|
||||
+---------------------------------------+ 196
|
||||
| saved TOC pointer 4 |
|
||||
+---------------------------------------+ 200
|
||||
| always reserved 8*4=32 we store our |
|
||||
| GPRs here |
|
||||
| r3 |
|
||||
| . |
|
||||
| r10 |
|
||||
+---------------------------------------+ 232
|
||||
| overflow part |
|
||||
+---------------------------------------+ xxx
|
||||
| ???? |
|
||||
+---------------------------------------+ xxx
|
||||
|
||||
*/
|
||||
ffi_status
|
||||
ffi_prep_closure_loc (ffi_closure* closure,
|
||||
ffi_cif* cif,
|
||||
void (*fun)(ffi_cif*, void*, void**, void*),
|
||||
void *user_data,
|
||||
void *codeloc)
|
||||
ffi_cif* cif,
|
||||
void (*fun)(ffi_cif*, void*, void**, void*),
|
||||
void *user_data,
|
||||
void *codeloc)
|
||||
{
|
||||
unsigned int *tramp;
|
||||
struct ffi_aix_trampoline_struct *tramp_aix;
|
||||
|
@ -592,12 +592,12 @@ flush_icache(char *addr)
|
|||
{
|
||||
#ifndef _AIX
|
||||
__asm__ volatile (
|
||||
"dcbf 0,%0\n"
|
||||
"\tsync\n"
|
||||
"\ticbi 0,%0\n"
|
||||
"\tsync\n"
|
||||
"\tisync"
|
||||
: : "r"(addr) : "memory");
|
||||
"dcbf 0,%0\n"
|
||||
"\tsync\n"
|
||||
"\ticbi 0,%0\n"
|
||||
"\tsync\n"
|
||||
"\tisync"
|
||||
: : "r"(addr) : "memory");
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -618,7 +618,7 @@ typedef union
|
|||
} ffi_dblfl;
|
||||
|
||||
int ffi_closure_helper_DARWIN (ffi_closure*, void*,
|
||||
unsigned long*, ffi_dblfl*);
|
||||
unsigned long*, ffi_dblfl*);
|
||||
|
||||
/* Basically the trampoline invokes ffi_closure_ASM, and on
|
||||
entry, r11 holds the address of the closure.
|
||||
|
@ -628,7 +628,7 @@ int ffi_closure_helper_DARWIN (ffi_closure*, void*,
|
|||
following helper function to do most of the work. */
|
||||
|
||||
int ffi_closure_helper_DARWIN (ffi_closure* closure, void * rvalue,
|
||||
unsigned long * pgr, ffi_dblfl * pfr)
|
||||
unsigned long * pgr, ffi_dblfl * pfr)
|
||||
{
|
||||
/* rvalue is the pointer to space for return value in closure assembly
|
||||
pgr is the pointer to where r3-r10 are stored in ffi_closure_ASM
|
||||
|
@ -675,121 +675,121 @@ int ffi_closure_helper_DARWIN (ffi_closure* closure, void * rvalue,
|
|||
while (i < avn)
|
||||
{
|
||||
switch (arg_types[i]->type)
|
||||
{
|
||||
case FFI_TYPE_SINT8:
|
||||
case FFI_TYPE_UINT8:
|
||||
avalue[i] = (char *) pgr + 3;
|
||||
ng++;
|
||||
pgr++;
|
||||
break;
|
||||
{
|
||||
case FFI_TYPE_SINT8:
|
||||
case FFI_TYPE_UINT8:
|
||||
avalue[i] = (char *) pgr + 3;
|
||||
ng++;
|
||||
pgr++;
|
||||
break;
|
||||
|
||||
case FFI_TYPE_SINT16:
|
||||
case FFI_TYPE_UINT16:
|
||||
avalue[i] = (char *) pgr + 2;
|
||||
ng++;
|
||||
pgr++;
|
||||
break;
|
||||
case FFI_TYPE_SINT16:
|
||||
case FFI_TYPE_UINT16:
|
||||
avalue[i] = (char *) pgr + 2;
|
||||
ng++;
|
||||
pgr++;
|
||||
break;
|
||||
|
||||
case FFI_TYPE_SINT32:
|
||||
case FFI_TYPE_UINT32:
|
||||
case FFI_TYPE_POINTER:
|
||||
avalue[i] = pgr;
|
||||
ng++;
|
||||
pgr++;
|
||||
break;
|
||||
case FFI_TYPE_SINT32:
|
||||
case FFI_TYPE_UINT32:
|
||||
case FFI_TYPE_POINTER:
|
||||
avalue[i] = pgr;
|
||||
ng++;
|
||||
pgr++;
|
||||
break;
|
||||
|
||||
case FFI_TYPE_STRUCT:
|
||||
/* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
|
||||
SI 4 bytes) are aligned as if they were those modes. */
|
||||
size_al = arg_types[i]->size;
|
||||
/* If the first member of the struct is a double, then align
|
||||
the struct to double-word.
|
||||
Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
|
||||
if (arg_types[i]->elements[0]->type == 3)
|
||||
size_al = ALIGN(arg_types[i]->size, 8);
|
||||
if (size_al < 3 && cif->abi == FFI_DARWIN)
|
||||
avalue[i] = (void*) pgr + 4 - size_al;
|
||||
else
|
||||
avalue[i] = (void*) pgr;
|
||||
ng += (size_al + 3) / 4;
|
||||
pgr += (size_al + 3) / 4;
|
||||
break;
|
||||
case FFI_TYPE_STRUCT:
|
||||
/* Structures that match the basic modes (QI 1 byte, HI 2 bytes,
|
||||
SI 4 bytes) are aligned as if they were those modes. */
|
||||
size_al = arg_types[i]->size;
|
||||
/* If the first member of the struct is a double, then align
|
||||
the struct to double-word.
|
||||
Type 3 is defined in include/ffi.h. #define FFI_TYPE_DOUBLE 3. */
|
||||
if (arg_types[i]->elements[0]->type == 3)
|
||||
size_al = ALIGN(arg_types[i]->size, 8);
|
||||
if (size_al < 3 && cif->abi == FFI_DARWIN)
|
||||
avalue[i] = (void*) pgr + 4 - size_al;
|
||||
else
|
||||
avalue[i] = (void*) pgr;
|
||||
ng += (size_al + 3) / 4;
|
||||
pgr += (size_al + 3) / 4;
|
||||
break;
|
||||
|
||||
case FFI_TYPE_SINT64:
|
||||
case FFI_TYPE_UINT64:
|
||||
/* Long long ints are passed in two gpr's. */
|
||||
avalue[i] = pgr;
|
||||
ng += 2;
|
||||
pgr += 2;
|
||||
break;
|
||||
case FFI_TYPE_SINT64:
|
||||
case FFI_TYPE_UINT64:
|
||||
/* Long long ints are passed in two gpr's. */
|
||||
avalue[i] = pgr;
|
||||
ng += 2;
|
||||
pgr += 2;
|
||||
break;
|
||||
|
||||
case FFI_TYPE_FLOAT:
|
||||
/* A float value consumes a GPR.
|
||||
There are 13 64bit floating point registers. */
|
||||
if (nf < NUM_FPR_ARG_REGISTERS)
|
||||
{
|
||||
temp = pfr->d;
|
||||
pfr->f = (float)temp;
|
||||
avalue[i] = pfr;
|
||||
pfr++;
|
||||
}
|
||||
else
|
||||
{
|
||||
avalue[i] = pgr;
|
||||
}
|
||||
nf++;
|
||||
ng++;
|
||||
pgr++;
|
||||
break;
|
||||
case FFI_TYPE_FLOAT:
|
||||
/* A float value consumes a GPR.
|
||||
There are 13 64bit floating point registers. */
|
||||
if (nf < NUM_FPR_ARG_REGISTERS)
|
||||
{
|
||||
temp = pfr->d;
|
||||
pfr->f = (float)temp;
|
||||
avalue[i] = pfr;
|
||||
pfr++;
|
||||
}
|
||||
else
|
||||
{
|
||||
avalue[i] = pgr;
|
||||
}
|
||||
nf++;
|
||||
ng++;
|
||||
pgr++;
|
||||
break;
|
||||
|
||||
case FFI_TYPE_DOUBLE:
|
||||
/* A double value consumes two GPRs.
|
||||
There are 13 64bit floating point registers. */
|
||||
if (nf < NUM_FPR_ARG_REGISTERS)
|
||||
{
|
||||
avalue[i] = pfr;
|
||||
pfr++;
|
||||
}
|
||||
else
|
||||
{
|
||||
avalue[i] = pgr;
|
||||
}
|
||||
nf++;
|
||||
ng += 2;
|
||||
pgr += 2;
|
||||
break;
|
||||
case FFI_TYPE_DOUBLE:
|
||||
/* A double value consumes two GPRs.
|
||||
There are 13 64bit floating point registers. */
|
||||
if (nf < NUM_FPR_ARG_REGISTERS)
|
||||
{
|
||||
avalue[i] = pfr;
|
||||
pfr++;
|
||||
}
|
||||
else
|
||||
{
|
||||
avalue[i] = pgr;
|
||||
}
|
||||
nf++;
|
||||
ng += 2;
|
||||
pgr += 2;
|
||||
break;
|
||||
|
||||
#if FFI_TYPE_LONGDOUBLE != FFI_TYPE_DOUBLE
|
||||
|
||||
case FFI_TYPE_LONGDOUBLE:
|
||||
/* A long double value consumes four GPRs and two FPRs.
|
||||
There are 13 64bit floating point registers. */
|
||||
if (nf < NUM_FPR_ARG_REGISTERS - 1)
|
||||
{
|
||||
avalue[i] = pfr;
|
||||
pfr += 2;
|
||||
}
|
||||
/* Here we have the situation where one part of the long double
|
||||
is stored in fpr13 and the other part is already on the stack.
|
||||
We use a union to pass the long double to avalue[i]. */
|
||||
else if (nf == NUM_FPR_ARG_REGISTERS - 1)
|
||||
{
|
||||
memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits));
|
||||
memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits));
|
||||
avalue[i] = &temp_ld.ld;
|
||||
}
|
||||
else
|
||||
{
|
||||
avalue[i] = pgr;
|
||||
}
|
||||
nf += 2;
|
||||
ng += 4;
|
||||
pgr += 4;
|
||||
break;
|
||||
case FFI_TYPE_LONGDOUBLE:
|
||||
/* A long double value consumes four GPRs and two FPRs.
|
||||
There are 13 64bit floating point registers. */
|
||||
if (nf < NUM_FPR_ARG_REGISTERS - 1)
|
||||
{
|
||||
avalue[i] = pfr;
|
||||
pfr += 2;
|
||||
}
|
||||
/* Here we have the situation where one part of the long double
|
||||
is stored in fpr13 and the other part is already on the stack.
|
||||
We use a union to pass the long double to avalue[i]. */
|
||||
else if (nf == NUM_FPR_ARG_REGISTERS - 1)
|
||||
{
|
||||
memcpy (&temp_ld.lb[0], pfr, sizeof(ldbits));
|
||||
memcpy (&temp_ld.lb[1], pgr + 2, sizeof(ldbits));
|
||||
avalue[i] = &temp_ld.ld;
|
||||
}
|
||||
else
|
||||
{
|
||||
avalue[i] = pgr;
|
||||
}
|
||||
nf += 2;
|
||||
ng += 4;
|
||||
pgr += 4;
|
||||
break;
|
||||
#endif
|
||||
default:
|
||||
FFI_ASSERT(0);
|
||||
}
|
||||
default:
|
||||
FFI_ASSERT(0);
|
||||
}
|
||||
i++;
|
||||
}
|
||||
|
||||
|
|
File diff suppressed because it is too large
Load Diff
|
@ -1106,7 +1106,7 @@ whichtable(char **pfmt)
|
|||
case '>':
|
||||
case '!': /* Network byte order is big-endian */
|
||||
return bigendian_table;
|
||||
case '=': { /* Host byte order -- different from native in aligment! */
|
||||
case '=': { /* Host byte order -- different from native in alignment! */
|
||||
int n = 1;
|
||||
char *p = (char *) &n;
|
||||
if (*p == 1)
|
||||
|
|
|
@ -442,7 +442,7 @@ _ldict(localobject *self)
|
|||
self->args, self->kw) < 0) {
|
||||
/* we need to get rid of ldict from thread so
|
||||
we create a new one the next time we do an attr
|
||||
acces */
|
||||
access */
|
||||
PyDict_DelItem(tdict, self->key);
|
||||
return NULL;
|
||||
}
|
||||
|
|
|
@ -1554,7 +1554,7 @@ validate_expr_stmt(node *tree)
|
|||
|| strcmp(s, ">>=") == 0
|
||||
|| strcmp(s, "**=") == 0);
|
||||
if (!res)
|
||||
err_string("illegal augmmented assignment operator");
|
||||
err_string("illegal augmented assignment operator");
|
||||
}
|
||||
}
|
||||
else {
|
||||
|
|
|
@ -1102,7 +1102,7 @@ get_code_from_data(ZipImporter *self, int ispackage, int isbytecode,
|
|||
return code;
|
||||
}
|
||||
|
||||
/* Get the code object assoiciated with the module specified by
|
||||
/* Get the code object associated with the module specified by
|
||||
'fullname'. */
|
||||
static PyObject *
|
||||
get_module_code(ZipImporter *self, char *fullname,
|
||||
|
|
|
@ -936,12 +936,12 @@ bytearray_repr(PyByteArrayObject *self)
|
|||
static PyObject *
|
||||
bytearray_str(PyObject *op)
|
||||
{
|
||||
if (Py_BytesWarningFlag) {
|
||||
if (PyErr_WarnEx(PyExc_BytesWarning,
|
||||
"str() on a bytearray instance", 1))
|
||||
return NULL;
|
||||
}
|
||||
return bytearray_repr((PyByteArrayObject*)op);
|
||||
if (Py_BytesWarningFlag) {
|
||||
if (PyErr_WarnEx(PyExc_BytesWarning,
|
||||
"str() on a bytearray instance", 1))
|
||||
return NULL;
|
||||
}
|
||||
return bytearray_repr((PyByteArrayObject*)op);
|
||||
}
|
||||
|
||||
static PyObject *
|
||||
|
@ -1459,7 +1459,7 @@ done:
|
|||
static PyObject *
|
||||
bytearray_maketrans(PyObject *null, PyObject *args)
|
||||
{
|
||||
return _Py_bytes_maketrans(args);
|
||||
return _Py_bytes_maketrans(args);
|
||||
}
|
||||
|
||||
|
||||
|
@ -2626,7 +2626,7 @@ bytearray_extend(PyByteArrayObject *self, PyObject *arg)
|
|||
if (it == NULL)
|
||||
return NULL;
|
||||
|
||||
/* Try to determine the length of the argument. 32 is abitrary. */
|
||||
/* Try to determine the length of the argument. 32 is arbitrary. */
|
||||
buf_size = _PyObject_LengthHint(arg, 32);
|
||||
if (buf_size == -1) {
|
||||
Py_DECREF(it);
|
||||
|
|
|
@ -495,7 +495,7 @@ PyObject *PyBytes_DecodeEscape(const char *s,
|
|||
default:
|
||||
*p++ = '\\';
|
||||
s--;
|
||||
goto non_esc; /* an arbitry number of unescaped
|
||||
goto non_esc; /* an arbitrary number of unescaped
|
||||
UTF-8 bytes may follow. */
|
||||
}
|
||||
}
|
||||
|
|
|
@ -3020,7 +3020,7 @@ ah*bh and al*bl too.
|
|||
* of slices, each with a->ob_size digits, and multiply the slices by a,
|
||||
* one at a time. This gives k_mul balanced inputs to work with, and is
|
||||
* also cache-friendly (we compute one double-width slice of the result
|
||||
* at a time, then move on, never bactracking except for the helpful
|
||||
* at a time, then move on, never backtracking except for the helpful
|
||||
* single-width slice overlap between successive partial sums).
|
||||
*/
|
||||
static PyLongObject *
|
||||
|
|
|
@ -6,7 +6,7 @@
|
|||
*/
|
||||
|
||||
|
||||
/* Defines for Python 2.6 compatability */
|
||||
/* Defines for Python 2.6 compatibility */
|
||||
#if PY_VERSION_HEX < 0x03000000
|
||||
#define PyLong_FromSsize_t _PyLong_FromSsize_t
|
||||
#endif
|
||||
|
|
|
@ -62,7 +62,7 @@
|
|||
* instead showing the user an empty listbox to select something from.
|
||||
*
|
||||
* Finish the code so that we can use other python installations
|
||||
* additionaly to those found in the registry,
|
||||
* additionally to those found in the registry,
|
||||
* and then #define USE_OTHER_PYTHON_VERSIONS
|
||||
*
|
||||
* - install a help-button, which will display something meaningful
|
||||
|
|
|
@ -23,7 +23,7 @@ __version__ = 'SPARK-0.7 (pre-alpha-5)'
|
|||
|
||||
import re
|
||||
|
||||
# Compatability with older pythons.
|
||||
# Compatibility with older pythons.
|
||||
def output(string='', end='\n'):
|
||||
sys.stdout.write(string + end)
|
||||
|
||||
|
|
|
@ -732,7 +732,7 @@ PyErr_WarnEx(PyObject *category, const char *text, Py_ssize_t stack_level)
|
|||
return 0;
|
||||
}
|
||||
|
||||
/* PyErr_Warn is only for backwards compatability and will be removed.
|
||||
/* PyErr_Warn is only for backwards compatibility and will be removed.
|
||||
Use PyErr_WarnEx instead. */
|
||||
|
||||
#undef PyErr_Warn
|
||||
|
|
|
@ -174,7 +174,7 @@ mingw_lib = os.path.join(srcdir, PCBUILD, "libpython%s%s.a" % (major, minor))
|
|||
|
||||
have_mingw = build_mingw_lib(lib_file, def_file, dll_file, mingw_lib)
|
||||
|
||||
# Determine the target architechture
|
||||
# Determine the target architecture
|
||||
dll_path = os.path.join(srcdir, PCBUILD, dll_file)
|
||||
msilib.set_arch_from_file(dll_path)
|
||||
if msilib.pe_type(dll_path) != msilib.pe_type("msisupport.dll"):
|
||||
|
|
|
@ -682,7 +682,7 @@ class Benchmark:
|
|||
other_total_avg_time = other_total_avg_time + other_avg_time
|
||||
if (benchmarks_compatible and
|
||||
test.compatible(other)):
|
||||
# Both benchmark and tests are comparible
|
||||
# Both benchmark and tests are comparable
|
||||
min_diff = ((min_time * self.warp) /
|
||||
(other_min_time * other.warp) - 1.0)
|
||||
avg_diff = ((avg_time * self.warp) /
|
||||
|
@ -696,7 +696,7 @@ class Benchmark:
|
|||
else:
|
||||
avg_diff = '%+5.1f%%' % (avg_diff * PERCENT)
|
||||
else:
|
||||
# Benchmark or tests are not comparible
|
||||
# Benchmark or tests are not comparable
|
||||
min_diff, avg_diff = 'n/a', 'n/a'
|
||||
tests_compatible = 0
|
||||
print('%30s: %5.0fms %5.0fms %7s %5.0fms %5.0fms %7s' % \
|
||||
|
|
2
setup.py
2
setup.py
|
@ -882,7 +882,7 @@ class PyBuildExt(build_ext):
|
|||
|
||||
db_dirs_to_check = tmp
|
||||
|
||||
# Look for a version specific db-X.Y before an ambiguoius dbX
|
||||
# Look for a version specific db-X.Y before an ambiguous dbX
|
||||
# XXX should we -ever- look for a dbX name? Do any
|
||||
# systems really not name their library by version and
|
||||
# symlink to more general names?
|
||||
|
|
Loading…
Reference in New Issue