Modified: python/branches/py3k-struni/Include/pydebug.h

Sat Apr 28 01:54:18 CEST 2007

 def set_executable(self, key, value):
   if type(value) is StringType:
   if isinstance(value, basestring):
       setattr(self, key, split_quoted(value))
   else:
       setattr(self, key, value)
                 (type (defn[1]) is StringType or defn[1] is None))) and
               type (defn[0]) is StringType):
                 (isinstance (defn[1], basestring) or defn[1] is None))) and
               isinstance (defn[0], basestring)):
           raise TypeError, \
                 ("invalid macro definition '%s': " % defn) + \
                 "must be tuple (string,), (string, string), or " + \
   elif type(outdir) is not StringType:
   elif not isinstance(outdir, basestring):
       raise TypeError, "'output_dir' must be a string or None"

   if macros is None:
   elif type (output_dir) is not StringType:
   elif not isinstance(output_dir, basestring):
       raise TypeError, "'output_dir' must be a string or None"

   if macros is None:
     if output_dir is None:
         output_dir = self.output_dir
   elif type (output_dir) is not StringType:
   elif not isinstance(output_dir, basestring):
       raise TypeError, "'output_dir' must be a string or None"

   return (objects, output_dir)
   elif type(val) is not StringType:
   elif not isinstance(val, basestring):
       raise DistutilsOptionError, \
             "'%s' must be a %s (got `%s`)" % (option, what, val)
   return val
   elif type(val) is StringType:
   elif isinstance(val, basestring):
       setattr(self, option, re.split(r',\s*|\s+', val))
   else:
       if type(val) is ListType:
           types = map(type, val)
           ok = (types == [StringType] * len(val))
           ok = all(isinstance(v, basestring) for v in val)
       else:
           ok = 0
     # Allow 'infiles' to be a single string
   if type(infiles) is StringType:
   if isinstance(infiles, basestring):
       infiles = (infiles,)
   elif type(infiles) not in (ListType, TupleType):
       raise TypeError, \
     if self.include_dirs is None:
         self.include_dirs = self.distribution.include_dirs or []
   if type(self.include_dirs) is StringType:
   if isinstance(self.include_dirs, basestring):
       self.include_dirs = self.include_dirs.split(os.pathsep)

   # XXX same as for build_ext -- what about 'self.define' and
       if type(lib[0]) is not StringType:
       if isinstance(lib[0], basestring) StringType:
           raise DistutilsSetupError, \
                 "first element of each tuple in 'libraries' " + \
                 "must be a string (the library name)"
   if type(self.include_dirs) is StringType:
   if isinstance(self.include_dirs, basestring):
       self.include_dirs = self.include_dirs.split(os.pathsep)

   # Put the Python "system" include dir at the end, so that
   if type(self.libraries) is StringType:
   if isinstance(self.libraries, basestring):
       self.libraries = [self.libraries]

   # Life is easier if we're not forever checking for None, so
   elif type(self.library_dirs) is StringType:
   elif isinstance(self.library_dirs, basestring):
       self.library_dirs = self.library_dirs.split(os.pathsep)

   if self.rpath is None:
       self.rpath = []
   elif type(self.rpath) is StringType:
   elif isinstance(self.rpath, basestring):
       self.rpath = self.rpath.split(os.pathsep)

   # for extensions under windows use different directories
       if not (type(ext_name) is StringType and
       if not (isinstance(ext_name, basestring) and
               extension_name_re.match(ext_name)):
           raise DistutilsSetupError, \
                 ("first element of each tuple in 'ext_modules' "
 def build_module (self, module, module_file, package):
   if type(package) is StringType:
   if isinstance(package, basestring):
       package = package.split('.')
   elif type(package) not in (ListType, TupleType):
       raise TypeError, \
   elif type(self.include_dirs) is StringType:
   elif isinstance(self.include_dirs, basestring):
       self.include_dirs = self.include_dirs.split(os.pathsep)

   if self.libraries is None:
       self.libraries = []
   elif type(self.libraries) is StringType:
   elif isinstance(self.libraries, basestring):
       self.libraries = [self.libraries]

   if self.library_dirs is None:
       self.library_dirs = []
   elif type(self.library_dirs) is StringType:
   elif isinstance(self.library_dirs, basestring):
       self.library_dirs = self.library_dirs.split(os.pathsep)
   if type(pattern) is StringType:
   if isinstance(pattern, basestring):
       pattern = re.compile(pattern)

   file = open(out)
     if self.extra_path is not None:
       if type(self.extra_path) is StringType:
       if isinstance(self.extra_path, basestring):
           self.extra_path = self.extra_path.split(',')

       if len(self.extra_path) == 1:
       if type(f) is StringType:
       if isinstance(f, basestring):
           # it's a simple file, so copy it
           f = convert_path(f)
           if self.warn_dir:
 # Detect a common bug -- name is None
     keywords = self.metadata.keywords
     if keywords is not None:
       if type(keywords) is StringType:
       if isinstance(keywords, basestring):
           keywordlist = keywords.split(',')
           self.metadata.keywords = [x.strip() for x in keywordlist]

   platforms = self.metadata.platforms
   if platforms is not None:
       if type(platforms) is StringType:
       if isinstance(platforms, basestring):
           platformlist = platforms.split(',')
           self.metadata.platforms = [x.strip() for x in platformlist]
         try:
           is_string = type(value) is StringType
           is_string = isinstance(value, basestring)
           if option in neg_opt and is_string:
               setattr(command_obj, neg_opt[option], not strtobool(value))
           elif option in bool_opts and is_string:
   assert type(name) is StringType, "'name' must be a string"
   assert isinstance(name, basestring), "'name' must be a string"
   assert (type(sources) is ListType and
           map(type, sources) == [StringType]*len(sources)), \
           all(isinstance(v, basestring) for v in sources)), \
           "'sources' must be a list of strings"

   self.name = name
         # Type- and value-check the option names
       if type(long) is not StringType or len(long) < 2:
       if not isinstance(long, basestring) or len(long) < 2:
           raise DistutilsGetoptError, \
                 ("invalid long option '%s': "
                  "must be a string of length >= 2") % long

       if (not ((short is None) or
                (type(short) is StringType and len(short) == 1))):
                (isinstance(short, basestring) and len(short) == 1))):
           raise DistutilsGetoptError, \
                 ("invalid short option '%s': "
                  "must a single character or None") % short
   if type(pattern) is StringType:
   if isinstance(pattern, basestring):
       return re.compile(pattern)
   else:
       return pattern
     lib_opts = gen_lib_options(self, library_dirs, runtime_library_dirs,
                                libraries)
   if type(output_dir) not in (StringType, NoneType):
   if not isinstance(output_dir, (basestring, NoneType)):
       raise TypeError, "'output_dir' must be a string or None"
   if output_dir is not None:
       output_filename = os.path.join(output_dir, output_filename)
 """
   bytes = ""
   while len(bytes) < n:
       bytes += read(_urandomfd, n - len(bytes))
   bs = b""
   while len(bs) < n:
       bs += read(_urandomfd, n - len(bs))
   close(_urandomfd)
   return bytes
   return bs
   if isinstance(obj, tp):
       return 1
   (unicode('\u0663\u0661\u0664 ','raw-unicode-escape'), 314),
   (unicode(b'\u0663\u0661\u0664 ','raw-unicode-escape'), 314),
   (unicode('  \t\t  314  \t\t  '), 314),
   (unicode('  1x'), ValueError),
   (unicode('  1  '), 1),
   self.assertRaises(ValueError, chr, 256)
   self.assertRaises(ValueError, chr, 1<<24)
   self.assertRaises(TypeError, chr)
   compile(bom + 'print(1)\n', '', 'exec')
   compile((bom + 'print(1)\n').encode("latin-1"), '', 'exec')
   compile(source='pass', filename='?', mode='exec')
   compile(dont_inherit=0, filename='tmp', source='0', mode='eval')
   compile('pass', '?', dont_inherit=1, mode='exec')
       compile(unicode('print(u"\xc3\xa5")\n', 'utf8'), '', 'exec')
       compile(unicode(b'print(u"\xc3\xa5")\n', 'utf8'), '', 'exec')
       self.assertRaises(TypeError, compile, unichr(0), 'f', 'exec')
       self.assertRaises(ValueError, compile, unicode('a = 1'), 'f', 'bad')
       self.assertEqual(eval(bom + 'a', globals, locals), 1)
       self.assertEqual(eval(unicode('u"\xc3\xa5"', 'utf8'), globals),
                        unicode('\xc3\xa5', 'utf8'))
       self.assertEqual(eval((bom + 'a').encode("latin-1"), globals, locals), 1)
       self.assertEqual(eval(unicode(b'u"\xc3\xa5"', 'utf8'), globals),
                        unicode(b'\xc3\xa5', 'utf8'))
   self.assertRaises(TypeError, eval)
   self.assertRaises(TypeError, eval, ())
       self.assertEqual(float(unicode("  \u0663.\u0661\u0664  ",'raw-unicode-escape')), 3.14)
       self.assertEqual(float(unicode(b"  \u0663.\u0661\u0664  ",'raw-unicode-escape')), 3.14)
       # Implementation limitation in PyFloat_FromString()
       self.assertRaises(ValueError, float, unicode("1"*10000))
           unicode('\\U%08x' % (sys.maxunicode), 'unicode-escape')
           unicode(('\\U%08x' % (sys.maxunicode)).encode("ascii"), 'unicode-escape')
       )
       self.assertRaises(ValueError, unichr, sys.maxunicode+1)
       self.assertRaises(TypeError, unichr)
   if (PyUnicode_Check(nameobj))
  nameobj = _PyUnicode_AsDefaultEncodedString(nameobj, "replace");
return PyString_AsString(nameobj);
 if (quotes) {
   *p++ = 'u';
   *p++ = (findchar(s, size, '\'') &&
           !findchar(s, size, '"')) ? '"' : '\'';
   /* Escape quotes and backslashes */
   if ((quotes &&
    ch == (Py_UNICODE) PyString_AS_STRING(repr)[1]) || ch == '\\') {
    ch == (Py_UNICODE) PyString_AS_STRING(repr)[0]) || ch == '\\') {
        *p++ = '\\';
        *p++ = (char) ch;
    continue;
   *p++ = PyString_AS_STRING(repr)[1];
   *p++ = PyString_AS_STRING(repr)[0];
{"chr",		builtin_chr,        METH_VARARGS, chr_doc},
{"chr",		builtin_unichr,     METH_VARARGS, chr_doc},
{"cmp",		builtin_cmp,        METH_VARARGS, cmp_doc},
{"compile",	(PyCFunction)builtin_compile,    METH_VARARGS | METH_KEYWORDS, compile_doc},
{"delattr",	builtin_delattr,    METH_VARARGS, delattr_doc},
 case 'S': { /* string object */
     PyObject **p = va_arg(*p_va, PyObject **);
  if (PyString_Check(arg))
  if (PyString_Check(arg) || PyUnicode_Check(arg))
        *p = arg;
    else
        return converterr("string", arg, msgbuf, bufsize);

Modified: python/branches/py3k-struni/Include/pydebug.h

Modified: python/branches/py3k-struni/Lib/distutils/ccompiler.py

Modified: python/branches/py3k-struni/Lib/distutils/cmd.py

Modified: python/branches/py3k-struni/Lib/distutils/command/build_clib.py

Modified: python/branches/py3k-struni/Lib/distutils/command/build_ext.py

Modified: python/branches/py3k-struni/Lib/distutils/command/build_py.py

Modified: python/branches/py3k-struni/Lib/distutils/command/config.py

Modified: python/branches/py3k-struni/Lib/distutils/command/install.py

Modified: python/branches/py3k-struni/Lib/distutils/command/install_data.py

Modified: python/branches/py3k-struni/Lib/distutils/dir_util.py

Modified: python/branches/py3k-struni/Lib/distutils/dist.py

Modified: python/branches/py3k-struni/Lib/distutils/extension.py

Modified: python/branches/py3k-struni/Lib/distutils/fancy_getopt.py

Modified: python/branches/py3k-struni/Lib/distutils/filelist.py

Modified: python/branches/py3k-struni/Lib/distutils/unixccompiler.py

Modified: python/branches/py3k-struni/Lib/locale.py

Modified: python/branches/py3k-struni/Lib/os.py

Modified: python/branches/py3k-struni/Lib/sre_compile.py

Modified: python/branches/py3k-struni/Lib/test/test_builtin.py

Modified: python/branches/py3k-struni/Modules/posixmodule.c

Modified: python/branches/py3k-struni/Objects/moduleobject.c

Modified: python/branches/py3k-struni/Objects/unicodeobject.c

Modified: python/branches/py3k-struni/Python/ast.c

Modified: python/branches/py3k-struni/Python/bltinmodule.c

Modified: python/branches/py3k-struni/Python/ceval.c

Modified: python/branches/py3k-struni/Python/getargs.c

Modified: python/branches/py3k-struni/Python/import.c

Modified: python/branches/py3k-struni/Python/pythonrun.c