[Python-checkins] cpython (2.7): #11565: Fix several typos. Patch by Piotr Kasprzyk. (original) (raw)

Wed Mar 16 11:35:26 CET 2011

 set in case no error occurrs.  Otherwise, -1 is returned and
 set in case no error occurs.  Otherwise, -1 is returned and
 an exception set.

  */
   0 is returned on success.  buffer and buffer_len are only
 set in case no error occurrs. Otherwise, -1 is returned and
 set in case no error occurs. Otherwise, -1 is returned and
 an exception set.

  */
/* MacOSX 10.4 (the first release to suppport 64-bit code
/* MacOSX 10.4 (the first release to support 64-bit code
 * at all) only supports 64-bit in the UNIX layer.
 * Therefore surpress the toolbox-glue in 64-bit mode.
 */
   existing method through subclassing is the prefered means
   existing method through subclassing is the preferred means
   of changing method dispatch behavior.
   """
     2) build a table of freqencies of this frequency (meta-frequency?),
     2) build a table of frequencies of this frequency (meta-frequency?),
        e.g.  'x occurred 5 times in 10 rows, 6 times in 1000 rows,
        7 times in 2 rows'
     3) use the mode of the meta-frequency to determine the /expected/
       # Too many in itializers should be caught
       # Too many initializers should be caught
       self.assertRaises(IndexError, int_array, *range(alen*2))

   CharArray = ARRAY(c_char, 3)
   # But explicitely creating an X structure calls __new__ and __init__, of course.
   # But explicitly creating an X structure calls __new__ and __init__, of course.
   x = X()
   self.assertEqual((x.a, x.b), (9, 12))
   self.assertEqual(x.new_was_called, True)
       # the array module doesn't suppport all format codes
       # the array module doesn't support all format codes
       # (no 'q' or 'Q')
       try:
           array(t._type_)
       # This one should succeeed...
       # This one should succeed...
       self.assertEqual(0, IsWindow(0))

       # ValueError: Procedure probably called with too many arguments (8 bytes in excess)
       # relace spaces from expanded tabs back into tab characters
       # replace spaces from expanded tabs back into tab characters
       # (we'll replace them with markup after we do differencing)
       line = line.replace(' ','\t')
       return line.replace('\0',' ').rstrip('\n')
 def move_file (self, src, dst, level=1):
   """Move a file respectin dry-run flag."""
   """Move a file respecting dry-run flag."""
   return file_util.move_file(src, dst, dry_run = self.dry_run)
   # let's run the command again (should spit warnings but suceed)
   # let's run the command again (should spit warnings but succeed)
   cmd.all = 1
   cmd.ensure_finalized()
   cmd.run()
   # make sure build_py is reinitinialized, like a fresh run
   # make sure build_py is reinitialized, like a fresh run
   build_py = dist.get_command_obj('build_py')
   build_py.finalized = False
   build_py.ensure_finalized()
       # If REPORT_ONLY_FIRST_FAILURE is set, then supress
       # If REPORT_ONLY_FIRST_FAILURE is set, then suppress
       # reporting after the first failure.
       quiet = (self.optionflags & REPORT_ONLY_FIRST_FAILURE and
                failures > 0)
        The DocTestCase provides a debug method that raises
      UnexpectedException errors if there is an unexepcted
      UnexpectedException errors if there is an unexpected
      exception:

        >>> test = DocTestParser().get_doctest('>>> raise KeyError\n42',
       # lines, but whatever!)  Can't think of a clean soltution,
       # lines, but whatever!)  Can't think of a clean solution,
       # so we hack away
       block_suffix = ""
       if not newdata[-1]:
 text	a Text instance (a widget)
 Return string in form: '"DD-Mmm-YYYY HH:MM:SS +HHMM"'.  The
   """Gets  the options  manitained  by  the  Tix
   """Gets  the options  maintained  by  the  Tix
   scheme mechanism. Available options include:

       active_bg       active_fg      bg
   # specifiyng a state spec
   # specifying a state spec
   self.assertEqual(ttk._format_elemcreate('image', False, 'test',
       ('', 'a')), ("test {} a", ()))
   # state spec with multiple states
   # _format_optdict the responsability to format it
   # _format_optdict the responsibility to format it
   if "values" in kw:
       kw["values"] = _format_optdict({'v': kw["values"]})[1]
   bg -- colorstring or color-tupel, new backgroundcolor
   bg -- colorstring or color-tuple, new backgroundcolor
   If no arguments are given, return current (canvaswidth, canvasheight)

   Do not alter the drawing window. To observe hidden parts of
   ##  if undo is done during crating a polygon, the last vertex
   ##  will be deleted. if the polygon is entirel deleted,
   ##  creatigPoly will be set to False.
   ##  if undo is done during creating a polygon, the last vertex
   ##  will be deleted. if the polygon is entirely deleted,
   ##  creatingPoly will be set to False.
   ##  Polygons created before the last one will not be affected by undo()
   if self._creatingPoly:
       if len(self._poly) > 0:
       # already in the prefered format, do nothing
       # already in the preferred format, do nothing
       return
 def parse_graminit_h(self, filename):
   """Parse the .h file writen by pgen.  (Internal)
   """Parse the .h file written by pgen.  (Internal)

   This file is a sequence of #define statements defining the
   nonterminals of the grammar as numbers.  We build two tables
 def parse_graminit_c(self, filename):
   """Parse the .c file writen by pgen.  (Internal)
   """Parse the .c file written by pgen.  (Internal)

   The file looks as follows.  The first two lines are always this:
       min: optinal minumum number of times to match, default 0
       max: optional maximum number of times tro match, default HUGE
       min: optional minimum number of times to match, default 0
       max: optional maximum number of times to match, default HUGE
       name: optional name assigned to this match

   [*] Thus, if content is [[a, b, c], [d, e], [f, g, h]] this is
       # verify statments that end with semi-colons
       # verify statements that end with semi-colons
       x = 1; pass; del x;
   foo()
       # verify statments that end with semi-colons
       # verify statements that end with semi-colons
       x = 1; pass; del x;
   foo()
 The index of the memo object to push is given by the newline-teriminated
 The index of the memo object to push is given by the newline-terminated
 decimal string following.  BINGET and LONG_BINGET are space-optimized
 versions.
 """),
       # XXX How can I supress shell errors from being written
       # XXX How can I suppress shell errors from being written
       #     to stderr ?
   except os.error,why:
       #print 'Command %s failed: %s' % (cmd,why)
           # translate errno using _sys_errlist (or simliar), but
           # translate errno using _sys_errlist (or similar), but
           # how can this be done from Python?
           raise WindowsError(*e.args)
       finally:
 # XXX: This causes test_pyclbr.py to fail, but only because the
 #      introspection-based is_method() code in the test can't
   # that they are by allowing intern() to succeeed.
   # that they are by allowing intern() to succeed.
   class S(str):
       def __hash__(self):
           return 123
 def test_pendingcalls_non_threaded(self):
   #again, just using the main thread, likely they will all be dispathced at
   #again, just using the main thread, likely they will all be dispatched at
   #once.  It is ok to ask for too many, because we loop until we find a slot.
   #the loop can be interrupted to dispatch.
   #there are only 32 dispatch slots, so we go for twice that!
     # Because we have a redundant spelling when DST begins, there is
   # (unforunately) an hour when DST ends that can't be spelled at all in
   # (unfortunately) an hour when DST ends that can't be spelled at all in
   # local time.  When DST ends, the clock jumps from 1:59 back to 1:00
   # again.  The hour 1:MM DST has no spelling then:  1:MM is taken to be
   # standard time.  1:MM DST == 0:MM EST, but 0:MM is taken to be
               #Exception raised where there shoudn't have been one.
               #Exception raised where there shouldn't have been one.
               self.fail('Exception "'+exception.__class__.__name__ + '" raised on line '+line)

   return
       self.fail("Carlo Verre __setattr__ suceeded!")
       self.fail("Carlo Verre __setattr__ succeeded!")
   try:
       object.__delattr__(str, "lower")
   except TypeError:
 >>> def f(x):
 >>> doctest.DocTestRunner(verbose=True, optionflags=flags).run(test)
 ... # doctest: +ELLIPSIS
 >>> doctest.testfile('test_doctest.txt', globs=globs, verbose=True)
 Trying:
 >>> doctest.testfile('test_doctest.txt', report=False)
   # it still has to accept the normal python syntac
   # it still has to accept the normal python syntax
   import locale
   if not locale.localeconv()['decimal_point'] == ',':
       return
   # distingishes -0.0 and 0.0.
   # distinguishes -0.0 and 0.0.
   self.assertEqual((a, copysign(1.0, a)), (b, copysign(1.0, b)))
       # verify statments that end with semi-colons
       # verify statements that end with semi-colons
       x = 1; pass; del x;
   foo()
       # Note: str and unicode sublclasses are not tested because they get handled
       # Note: str and unicode subclasses are not tested because they get handled
       # by marshal's routines for objects supporting the buffer API.
       subtyp = type('subtyp', (typ,), {})
       self.assertRaises(ValueError, marshal.dumps, subtyp())
     # the following tests have been commented out since they don't
     # really belong here:  the implementation of ** for floats is
   # independent of the implemention of math.pow
   # independent of the implementation of math.pow
   #self.assertEqual(1**NAN, 1)
   #self.assertEqual(1**INF, 1)
   #self.assertEqual(1**NINF, 1)
     # Pickle expects the class to be on the module level. Here we use a
     # little hack to allow the PickleTestMemIO class to derive from
   # self.ioclass without having to define all combinations explictly on
   # self.ioclass without having to define all combinations explicitly on
   # the module-level.
   import __main__
   PickleTestMemIO.__module__ = '__main__'
       # Test differnt tag
       # Test different tag
       m1 = mmap.mmap(-1, len(data1), tagname="foo")
       m1[:] = data1
       m2 = mmap.mmap(-1, len(data2), tagname="boo")
   # Removed temporaily, due to API shear, this does not
   # Removed temporarily, due to API shear, this does not
   # work with threading._Event objects. is_set == isSet
   self.assertEqual(event.is_set(), False)
     util.Finalize(None, conn.send, args=('STOP',), exitpriority=-100)
   # call mutliprocessing's cleanup function then exit process without
   # call multiprocessing's cleanup function then exit process without
   # garbage collecting locals
   util._exit_function()
   conn.close()
   # delete all modules concerning the tested hiearchy
   # delete all modules concerning the tested hierarchy
   if self.pkgname:
       modules = [name for name in sys.modules
                  if self.pkgname in name.split('.')]
       # to the reseting to the original locale.
       # to the resetting to the original locale.
       except locale.Error:
           pass
   # Make sure we don't trample on the locale setting once we leave the
 >>> def test():
 ...     try:
       # before forking instead of reseting it, the test case will
       # before forking instead of resetting it, the test case will
       # deadlock when it shouldn't.
       condition = w._block
       orig_acquire = condition.acquire
   # When used through 'run', some other spurios counts are produced, like
   # When used through 'run', some other spurious counts are produced, like
   # the settrace of threading, which we ignore, just making sure that the
   # counts fo traced_func_loop were right.
   #
 def test_warn_explicit_type_errors(self):
   # warn_explicit() shoud error out gracefully if it is given objects
   # warn_explicit() should error out gracefully if it is given objects
   # of the wrong types.
   # lineno is expected to be an integer.
   self.assertRaises(TypeError, self.module.warn_explicit,
     program.runTests()
   # If initialising raises a type error it should be retried
   # If initializing raises a type error it should be retried
   # without the new keyword arguments
   self.assertEqual(FakeRunner.initArgs, {})
   self.assertEqual(FakeRunner.test, 'test')
   # implemenetation specific.  minidom handles those cases
   # implementation specific.  minidom handles those cases
   # directly in the cloneNode() methods.
   raise xml.dom.NotSupportedErr("Cannot clone node %s" % repr(node))
  an exception occurrs in the callback, and print the traceback not
  an exception occurs in the callback, and print the traceback not
  only on the console, but also to OutputDebugString() or something
  like that.
          BTW, the same problem occurrs when they are pushed as parameters
          BTW, the same problem occurs when they are pushed as parameters
       */
   } else if (dict) {
       /* Hm, shouldn't we use PyCData_AtAddress() or something like that instead? */
     0   buf                   positon
     0   buf                   position

   */
   memset(self->buf + self->string_size, '\0',
      string if possible and be succesful. */
      string if possible and be successful. */
   if (_PyString_Resize(&buf, outlen) < 0)
       /* Oopsy, not so succesful after all. */
       /* Oopsy, not so successful after all. */
       return NULL;
      string if possible and be succesful. */
      string if possible and be successful. */
   if (_PyString_Resize(&buf, outlen) < 0)
       /* Oopsy, not so succesful after all. */
       /* Oopsy, not so successful after all. */
       goto finally;
 return 0;  /* Failure */
* cannot remain set to -1 if mktime succedded. */
* cannot remain set to -1 if mktime succeeded. */
         /* used by trees.c: */
   /* The object has been implicitely tracked by tp_alloc */
   /* The object has been implicitly tracked by tp_alloc */
   if (type == &PyDict_Type)
       _PyObject_GC_UNTRACK(d);
  significant byte.  Leading 0 bytes are insignficant if the number
  significant byte.  Leading 0 bytes are insignificant if the number
  is positive, and leading 0xff bytes if negative. */
     then.  But we're already deleting self.  Double dealloction is
     then.  But we're already deleting self.  Double deallocation is
     a subtle disaster.

  Q. Why the bizarre (net-zero) manipulation of
 tempname = tempnam(NULL, NULL);
 // We use a static CRT while the Python version we load uses
              a try: finally: block uninterruptable. */
              a try: finally: block uninterruptible. */
           goto fast_next_opcode;
       }
       _Py_Ticker = _Py_CheckInterval;
* Because these lists can mutute even when the GIL is held, we
* Because these lists can mutate even when the GIL is held, we
* need to grab head_mutex for the duration.
*/
           # for dynamic libraries on the entiry path.
           # This way a staticly linked custom sqlite gets picked up
           # for dynamic libraries on the entire path.
           # This way a statically linked custom sqlite gets picked up
           # before the dynamic library in /usr/lib.
           sqlite_extra_link_args = ('-Wl,-search_paths_first',)
       else:

[Python-checkins] cpython (2.7): #11565: Fix several typos. Patch by Piotr Kasprzyk. (original) (raw)

The shared cache is only available in SQLite versions 3.3.3 or later

endif

if defined(LP64)

For use with .match()

header injection attack.

!%@#! oneliners have no suite node, we have to fake one up

- $varname is accepted.

- %varname% is accepted.

- varnames can be made out of letters, digits and the characters '_-'

XXX With COMMAND.COM you can use any characters in a variable name,

XXX except '^|<>='.

distinguish between this and a geniune method function like m().

distinguish between this and a genuine method function like m().

The pyclbr.py module gets this right as it parses the text.

message: "No module named _multiprocessing". _multiprocessing is not compiled

without thread support.

A dispatch table all 8 combinations of providing

sep, end, and file

I use this machinery so that I'm not just passing default

arguments

Just commented them out.

Can't really tell why keep failing in windows and sparc.

fail in one of the tests, sometimes in other. I have a linux, and

the tests go ok.

If anybody has one of the problematic enviroments, please help!

NodeList -- lightest possible NodeList implementation

remain empty (immutable)

StringTypes -- tuple of defined string types

Return succes

Return success

Tokenizing ANSI C (partly)