third_party/cython/src/Cython/Compiler/Builtin.py

   1 #
   2 #   Builtin Definitions
   3 #
   4
   5 from Symtab import BuiltinScope, StructOrUnionScope
   6 from Code import UtilityCode
   7 from TypeSlots import Signature
   8 import PyrexTypes
   9 import Options
  10
  11
  12 # C-level implementations of builtin types, functions and methods
  13
  14 iter_next_utility_code = UtilityCode.load("IterNext", "ObjectHandling.c")
  15 getattr_utility_code = UtilityCode.load("GetAttr", "ObjectHandling.c")
  16 getattr3_utility_code = UtilityCode.load("GetAttr3", "Builtins.c")
  17 pyexec_utility_code = UtilityCode.load("PyExec", "Builtins.c")
  18 pyexec_globals_utility_code = UtilityCode.load("PyExecGlobals", "Builtins.c")
  19 globals_utility_code = UtilityCode.load("Globals", "Builtins.c")
  20
  21 py_set_utility_code = UtilityCode.load("pyset_compat", "Builtins.c")
  22
  23 builtin_utility_code = {
  24     'set'       : py_set_utility_code,
  25     'frozenset' : py_set_utility_code,
  26 }
  27
  28
  29 # mapping from builtins to their C-level equivalents
  30
  31 class _BuiltinOverride(object):
  32     def __init__(self, py_name, args, ret_type, cname, py_equiv="*",
  33                  utility_code=None, sig=None, func_type=None,
  34                  is_strict_signature=False, builtin_return_type=None):
  35         self.py_name, self.cname, self.py_equiv = py_name, cname, py_equiv
  36         self.args, self.ret_type = args, ret_type
  37         self.func_type, self.sig = func_type, sig
  38         self.builtin_return_type = builtin_return_type
  39         self.is_strict_signature = is_strict_signature
  40         self.utility_code = utility_code
  41
  42     def build_func_type(self, sig=None, self_arg=None):
  43         if sig is None:
  44             sig = Signature(self.args, self.ret_type)
  45             sig.exception_check = False  # not needed for the current builtins
  46         func_type = sig.function_type(self_arg)
  47         if self.is_strict_signature:
  48             func_type.is_strict_signature = True
  49         if self.builtin_return_type:
  50             func_type.return_type = builtin_types[self.builtin_return_type]
  51         return func_type
  52
  53
  54 class BuiltinAttribute(object):
  55     def __init__(self, py_name, cname=None, field_type=None, field_type_name=None):
  56         self.py_name = py_name
  57         self.cname = cname or py_name
  58         self.field_type_name = field_type_name # can't do the lookup before the type is declared!
  59         self.field_type = field_type
  60
  61     def declare_in_type(self, self_type):
  62         if self.field_type_name is not None:
  63             # lazy type lookup
  64             field_type = builtin_scope.lookup(self.field_type_name).type
  65         else:
  66             field_type = self.field_type or PyrexTypes.py_object_type
  67         entry = self_type.scope.declare(self.py_name, self.cname, field_type, None, 'private')
  68         entry.is_variable = True
  69
  70
  71 class BuiltinFunction(_BuiltinOverride):
  72     def declare_in_scope(self, scope):
  73         func_type, sig = self.func_type, self.sig
  74         if func_type is None:
  75             func_type = self.build_func_type(sig)
  76         scope.declare_builtin_cfunction(self.py_name, func_type, self.cname,
  77                                         self.py_equiv, self.utility_code)
  78
  79
  80 class BuiltinMethod(_BuiltinOverride):
  81     def declare_in_type(self, self_type):
  82         method_type, sig = self.func_type, self.sig
  83         if method_type is None:
  84             # override 'self' type (first argument)
  85             self_arg = PyrexTypes.CFuncTypeArg("", self_type, None)
  86             self_arg.not_none = True
  87             self_arg.accept_builtin_subtypes = True
  88             method_type = self.build_func_type(sig, self_arg)
  89         self_type.scope.declare_builtin_cfunction(
  90             self.py_name, method_type, self.cname, utility_code=self.utility_code)
  91
  92
  93 builtin_function_table = [
  94     # name,        args,   return,  C API func,           py equiv = "*"
  95     BuiltinFunction('abs',        "d",    "d",     "fabs",
  96                     is_strict_signature = True),
  97     BuiltinFunction('abs',        "f",    "f",     "fabsf",
  98                     is_strict_signature = True),
  99     BuiltinFunction('abs',        None,    None,   "__Pyx_abs_int",
 100                     utility_code = UtilityCode.load("abs_int", "Builtins.c"),
 101                     func_type = PyrexTypes.CFuncType(
 102                         PyrexTypes.c_uint_type, [
 103                             PyrexTypes.CFuncTypeArg("arg", PyrexTypes.c_int_type, None)
 104                             ],
 105                         is_strict_signature = True)),
 106     BuiltinFunction('abs',        None,    None,   "__Pyx_abs_long",
 107                     utility_code = UtilityCode.load("abs_long", "Builtins.c"),
 108                     func_type = PyrexTypes.CFuncType(
 109                         PyrexTypes.c_ulong_type, [
 110                             PyrexTypes.CFuncTypeArg("arg", PyrexTypes.c_long_type, None)
 111                             ],
 112                         is_strict_signature = True)),
 113     BuiltinFunction('abs',        None,    None,   "__Pyx_abs_longlong",
 114                     utility_code = UtilityCode.load("abs_longlong", "Builtins.c"),
 115                     func_type = PyrexTypes.CFuncType(
 116                         PyrexTypes.c_ulonglong_type, [
 117                             PyrexTypes.CFuncTypeArg("arg", PyrexTypes.c_longlong_type, None)
 118                         ],
 119                         is_strict_signature = True)),
 120     BuiltinFunction('abs',        "O",    "O",     "PyNumber_Absolute"),
 121     BuiltinFunction('callable',   "O",    "b",     "__Pyx_PyCallable_Check",
 122                     utility_code = UtilityCode.load("CallableCheck", "ObjectHandling.c")),
 123     #('chr',       "",     "",      ""),
 124     #('cmp', "",   "",     "",      ""), # int PyObject_Cmp(PyObject *o1, PyObject *o2, int *result)
 125     #('compile',   "",     "",      ""), # PyObject* Py_CompileString(    char *str, char *filename, int start)
 126     BuiltinFunction('delattr',    "OO",   "r",     "PyObject_DelAttr"),
 127     BuiltinFunction('dir',        "O",    "O",     "PyObject_Dir"),
 128     BuiltinFunction('divmod',     "OO",   "O",     "PyNumber_Divmod"),
 129     BuiltinFunction('exec',       "O",    "O",     "__Pyx_PyExecGlobals",
 130                     utility_code = pyexec_globals_utility_code),
 131     BuiltinFunction('exec',       "OO",   "O",     "__Pyx_PyExec2",
 132                     utility_code = pyexec_utility_code),
 133     BuiltinFunction('exec',       "OOO",  "O",     "__Pyx_PyExec3",
 134                     utility_code = pyexec_utility_code),
 135     #('eval',      "",     "",      ""),
 136     #('execfile',  "",     "",      ""),
 137     #('filter',    "",     "",      ""),
 138     BuiltinFunction('getattr3',   "OOO",  "O",     "__Pyx_GetAttr3",     "getattr",
 139                     utility_code=getattr3_utility_code),  # Pyrex legacy
 140     BuiltinFunction('getattr',    "OOO",  "O",     "__Pyx_GetAttr3",
 141                     utility_code=getattr3_utility_code),
 142     BuiltinFunction('getattr',    "OO",   "O",     "__Pyx_GetAttr",
 143                     utility_code=getattr_utility_code),
 144     BuiltinFunction('hasattr',    "OO",   "b",     "PyObject_HasAttr"),
 145     BuiltinFunction('hash',       "O",    "h",     "PyObject_Hash"),
 146     #('hex',       "",     "",      ""),
 147     #('id',        "",     "",      ""),
 148     #('input',     "",     "",      ""),
 149     BuiltinFunction('intern',     "O",    "O",     "__Pyx_Intern",
 150                     utility_code = UtilityCode.load("Intern", "Builtins.c")),
 151     BuiltinFunction('isinstance', "OO",   "b",     "PyObject_IsInstance"),
 152     BuiltinFunction('issubclass', "OO",   "b",     "PyObject_IsSubclass"),
 153     BuiltinFunction('iter',       "OO",   "O",     "PyCallIter_New"),
 154     BuiltinFunction('iter',       "O",    "O",     "PyObject_GetIter"),
 155     BuiltinFunction('len',        "O",    "z",     "PyObject_Length"),
 156     BuiltinFunction('locals',     "",     "O",     "__pyx_locals"),
 157     #('map',       "",     "",      ""),
 158     #('max',       "",     "",      ""),
 159     #('min',       "",     "",      ""),
 160     BuiltinFunction('next',       "O",    "O",     "__Pyx_PyIter_Next",
 161                     utility_code = iter_next_utility_code),   # not available in Py2 => implemented here
 162     BuiltinFunction('next',      "OO",    "O",     "__Pyx_PyIter_Next2",
 163                     utility_code = iter_next_utility_code),  # not available in Py2 => implemented here
 164     #('oct',       "",     "",      ""),
 165     #('open',       "ss",   "O",     "PyFile_FromString"),   # not in Py3
 166     #('ord',       "",     "",      ""),
 167     BuiltinFunction('pow',        "OOO",  "O",     "PyNumber_Power"),
 168     BuiltinFunction('pow',        "OO",   "O",     "__Pyx_PyNumber_Power2",
 169                     utility_code = UtilityCode.load("pow2", "Builtins.c")),
 170     #('range',     "",     "",      ""),
 171     #('raw_input', "",     "",      ""),
 172     #('reduce',    "",     "",      ""),
 173     BuiltinFunction('reload',     "O",    "O",     "PyImport_ReloadModule"),
 174     BuiltinFunction('repr',       "O",    "O",     "PyObject_Repr", builtin_return_type='str'),
 175     #('round',     "",     "",      ""),
 176     BuiltinFunction('setattr',    "OOO",  "r",     "PyObject_SetAttr"),
 177     #('sum',       "",     "",      ""),
 178     #('type',       "O",    "O",     "PyObject_Type"),
 179     #('unichr',    "",     "",      ""),
 180     #('unicode',   "",     "",      ""),
 181     #('vars',      "",     "",      ""),
 182     #('zip',       "",     "",      ""),
 183     #  Can't do these easily until we have builtin type entries.
 184     #('typecheck',  "OO",   "i",     "PyObject_TypeCheck", False),
 185     #('issubtype',  "OO",   "i",     "PyType_IsSubtype",   False),
 186
 187     # Put in namespace append optimization.
 188     BuiltinFunction('__Pyx_PyObject_Append', "OO",  "O",     "__Pyx_PyObject_Append"),
 189 ]
 190
 191 if not Options.old_style_globals:
 192     builtin_function_table.append(
 193         BuiltinFunction('globals',    "",     "O",     "__Pyx_Globals",
 194                         utility_code=globals_utility_code))
 195
 196 # Builtin types
 197 #  bool
 198 #  buffer
 199 #  classmethod
 200 #  dict
 201 #  enumerate
 202 #  file
 203 #  float
 204 #  int
 205 #  list
 206 #  long
 207 #  object
 208 #  property
 209 #  slice
 210 #  staticmethod
 211 #  super
 212 #  str
 213 #  tuple
 214 #  type
 215 #  xrange
 216
 217 builtin_types_table = [
 218
 219     ("type",    "PyType_Type",     []),
 220
 221 # This conflicts with the C++ bool type, and unfortunately
 222 # C++ is too liberal about PyObject* <-> bool conversions,
 223 # resulting in unintuitive runtime behavior and segfaults.
 224 #    ("bool",    "PyBool_Type",     []),
 225
 226     ("int",     "PyInt_Type",      []),
 227     ("long",    "PyLong_Type",     []),
 228     ("float",   "PyFloat_Type",    []),
 229
 230     ("complex", "PyComplex_Type",  [BuiltinAttribute('cval', field_type_name = 'Py_complex'),
 231                                     BuiltinAttribute('real', 'cval.real', field_type = PyrexTypes.c_double_type),
 232                                     BuiltinAttribute('imag', 'cval.imag', field_type = PyrexTypes.c_double_type),
 233                                     ]),
 234
 235     ("basestring", "PyBaseString_Type", [
 236                                     BuiltinMethod("join",  "TO",   "T", "__Pyx_PyBaseString_Join",
 237                                                   utility_code=UtilityCode.load("StringJoin", "StringTools.c")),
 238                                     ]),
 239     ("bytearray", "PyByteArray_Type", [
 240                                     ]),
 241     ("bytes",   "PyBytes_Type",    [BuiltinMethod("__contains__",  "TO",   "b", "PySequence_Contains"),
 242                                     BuiltinMethod("join",  "TO",   "O", "__Pyx_PyBytes_Join",
 243                                                   utility_code=UtilityCode.load("StringJoin", "StringTools.c")),
 244                                     ]),
 245     ("str",     "PyString_Type",   [BuiltinMethod("__contains__",  "TO",   "b", "PySequence_Contains"),
 246                                     BuiltinMethod("join",  "TO",   "O", "__Pyx_PyString_Join",
 247                                                   builtin_return_type='basestring',
 248                                                   utility_code=UtilityCode.load("StringJoin", "StringTools.c")),
 249                                     ]),
 250     ("unicode", "PyUnicode_Type",  [BuiltinMethod("__contains__",  "TO",   "b", "PyUnicode_Contains"),
 251                                     BuiltinMethod("join",  "TO",   "T", "PyUnicode_Join"),
 252                                     ]),
 253
 254     ("tuple",   "PyTuple_Type",    [BuiltinMethod("__contains__",  "TO",   "b", "PySequence_Contains"),
 255                                     ]),
 256
 257     ("list",    "PyList_Type",     [BuiltinMethod("__contains__",  "TO",   "b", "PySequence_Contains"),
 258                                     BuiltinMethod("insert",  "TzO",  "r", "PyList_Insert"),
 259                                     BuiltinMethod("reverse", "T",    "r", "PyList_Reverse"),
 260                                     BuiltinMethod("append",  "TO",   "r", "__Pyx_PyList_Append",
 261                                                   utility_code=UtilityCode.load("ListAppend", "Optimize.c")),
 262                                     BuiltinMethod("extend",  "TO",   "r", "__Pyx_PyList_Extend",
 263                                                   utility_code=UtilityCode.load("ListExtend", "Optimize.c")),
 264                                     ]),
 265
 266     ("dict",    "PyDict_Type",     [BuiltinMethod("__contains__",  "TO",   "b", "PyDict_Contains"),
 267                                     BuiltinMethod("has_key",       "TO",   "b", "PyDict_Contains"),
 268                                     BuiltinMethod("items",  "T",   "O", "__Pyx_PyDict_Items",
 269                                                   utility_code=UtilityCode.load("py_dict_items", "Builtins.c")),
 270                                     BuiltinMethod("keys",   "T",   "O", "__Pyx_PyDict_Keys",
 271                                                   utility_code=UtilityCode.load("py_dict_keys", "Builtins.c")),
 272                                     BuiltinMethod("values", "T",   "O", "__Pyx_PyDict_Values",
 273                                                   utility_code=UtilityCode.load("py_dict_values", "Builtins.c")),
 274                                     BuiltinMethod("iteritems",  "T",   "O", "__Pyx_PyDict_IterItems",
 275                                                   utility_code=UtilityCode.load("py_dict_iteritems", "Builtins.c")),
 276                                     BuiltinMethod("iterkeys",   "T",   "O", "__Pyx_PyDict_IterKeys",
 277                                                   utility_code=UtilityCode.load("py_dict_iterkeys", "Builtins.c")),
 278                                     BuiltinMethod("itervalues", "T",   "O", "__Pyx_PyDict_IterValues",
 279                                                   utility_code=UtilityCode.load("py_dict_itervalues", "Builtins.c")),
 280                                     BuiltinMethod("viewitems",  "T",   "O", "__Pyx_PyDict_ViewItems",
 281                                                   utility_code=UtilityCode.load("py_dict_viewitems", "Builtins.c")),
 282                                     BuiltinMethod("viewkeys",   "T",   "O", "__Pyx_PyDict_ViewKeys",
 283                                                   utility_code=UtilityCode.load("py_dict_viewkeys", "Builtins.c")),
 284                                     BuiltinMethod("viewvalues", "T",   "O", "__Pyx_PyDict_ViewValues",
 285                                                   utility_code=UtilityCode.load("py_dict_viewvalues", "Builtins.c")),
 286                                     BuiltinMethod("clear",  "T",   "r", "__Pyx_PyDict_Clear",
 287                                                   utility_code=UtilityCode.load("py_dict_clear", "Optimize.c")),
 288                                     BuiltinMethod("copy",   "T",   "T", "PyDict_Copy")]),
 289
 290     ("slice",   "PySlice_Type",    [BuiltinAttribute('start'),
 291                                     BuiltinAttribute('stop'),
 292                                     BuiltinAttribute('step'),
 293                                     ]),
 294 #    ("file",    "PyFile_Type",     []),  # not in Py3
 295
 296     ("set",       "PySet_Type",    [BuiltinMethod("__contains__",  "TO",   "b", "PySequence_Contains"),
 297                                     BuiltinMethod("clear",   "T",  "r", "PySet_Clear",
 298                                                   utility_code = py_set_utility_code),
 299                                     # discard() and remove() have a special treatment for unhashable values
 300 #                                    BuiltinMethod("discard", "TO", "r", "PySet_Discard",
 301 #                                                  utility_code = py_set_utility_code),
 302                                     BuiltinMethod("add",     "TO", "r", "PySet_Add",
 303                                                   utility_code = py_set_utility_code),
 304                                     BuiltinMethod("pop",     "T",  "O", "PySet_Pop",
 305                                                   utility_code = py_set_utility_code)]),
 306     ("frozenset", "PyFrozenSet_Type", []),
 307 ]
 308
 309
 310 types_that_construct_their_instance = set([
 311     # some builtin types do not always return an instance of
 312     # themselves - these do:
 313     'type', 'bool', 'long', 'float', 'complex',
 314     'bytes', 'unicode', 'bytearray',
 315     'tuple', 'list', 'dict', 'set', 'frozenset'
 316     # 'str',             # only in Py3.x
 317     # 'file',            # only in Py2.x
 318 ])
 319
 320
 321 builtin_structs_table = [
 322     ('Py_buffer', 'Py_buffer',
 323      [("buf",        PyrexTypes.c_void_ptr_type),
 324       ("obj",        PyrexTypes.py_object_type),
 325       ("len",        PyrexTypes.c_py_ssize_t_type),
 326       ("itemsize",   PyrexTypes.c_py_ssize_t_type),
 327       ("readonly",   PyrexTypes.c_bint_type),
 328       ("ndim",       PyrexTypes.c_int_type),
 329       ("format",     PyrexTypes.c_char_ptr_type),
 330       ("shape",      PyrexTypes.c_py_ssize_t_ptr_type),
 331       ("strides",    PyrexTypes.c_py_ssize_t_ptr_type),
 332       ("suboffsets", PyrexTypes.c_py_ssize_t_ptr_type),
 333       ("smalltable", PyrexTypes.CArrayType(PyrexTypes.c_py_ssize_t_type, 2)),
 334       ("internal",   PyrexTypes.c_void_ptr_type),
 335       ]),
 336     ('Py_complex', 'Py_complex',
 337      [('real', PyrexTypes.c_double_type),
 338       ('imag', PyrexTypes.c_double_type),
 339       ])
 340 ]
 341
 342 # set up builtin scope
 343
 344 builtin_scope = BuiltinScope()
 345
 346 def init_builtin_funcs():
 347     for bf in builtin_function_table:
 348         bf.declare_in_scope(builtin_scope)
 349
 350 builtin_types = {}
 351
 352 def init_builtin_types():
 353     global builtin_types
 354     for name, cname, methods in builtin_types_table:
 355         utility = builtin_utility_code.get(name)
 356         if name == 'frozenset':
 357             objstruct_cname = 'PySetObject'
 358         elif name == 'bool':
 359             objstruct_cname = None
 360         else:
 361             objstruct_cname = 'Py%sObject' % name.capitalize()
 362         the_type = builtin_scope.declare_builtin_type(name, cname, utility, objstruct_cname)
 363         builtin_types[name] = the_type
 364         for method in methods:
 365             method.declare_in_type(the_type)
 366
 367 def init_builtin_structs():
 368     for name, cname, attribute_types in builtin_structs_table:
 369         scope = StructOrUnionScope(name)
 370         for attribute_name, attribute_type in attribute_types:
 371             scope.declare_var(attribute_name, attribute_type, None,
 372                               attribute_name, allow_pyobject=True)
 373         builtin_scope.declare_struct_or_union(
 374             name, "struct", scope, 1, None, cname = cname)
 375
 376
 377 def init_builtins():
 378     init_builtin_structs()
 379     init_builtin_types()
 380     init_builtin_funcs()
 381     builtin_scope.declare_var(
 382         '__debug__', PyrexTypes.c_const_type(PyrexTypes.c_bint_type),
 383         pos=None, cname='(!Py_OptimizeFlag)', is_cdef=True)
 384     global list_type, tuple_type, dict_type, set_type, frozenset_type
 385     global bytes_type, str_type, unicode_type, basestring_type, slice_type
 386     global float_type, bool_type, type_type, complex_type, bytearray_type
 387     type_type  = builtin_scope.lookup('type').type
 388     list_type  = builtin_scope.lookup('list').type
 389     tuple_type = builtin_scope.lookup('tuple').type
 390     dict_type  = builtin_scope.lookup('dict').type
 391     set_type   = builtin_scope.lookup('set').type
 392     frozenset_type = builtin_scope.lookup('frozenset').type
 393     slice_type   = builtin_scope.lookup('slice').type
 394     bytes_type = builtin_scope.lookup('bytes').type
 395     str_type   = builtin_scope.lookup('str').type
 396     unicode_type = builtin_scope.lookup('unicode').type
 397     basestring_type = builtin_scope.lookup('basestring').type
 398     bytearray_type = builtin_scope.lookup('bytearray').type
 399     float_type = builtin_scope.lookup('float').type
 400     bool_type  = builtin_scope.lookup('bool').type
 401     complex_type  = builtin_scope.lookup('complex').type
 402
 403
 404 init_builtins()