Beispiel #1
0
 def typeof_global(self, inst, target, gvar):
     if (gvar.name in ('range', 'xrange') and
                 gvar.value in RANGE_ITER_OBJECTS):
         gvty = self.context.get_global_type(gvar.value)
         self.typevars[target.name].lock(gvty)
         self.assumed_immutables.add(inst)
     if gvar.name == 'slice' and gvar.value is slice:
         gvty = self.context.get_global_type(gvar.value)
         self.typevars[target.name].lock(gvty)
         self.assumed_immutables.add(inst)
     elif gvar.name == 'len' and gvar.value is len:
         gvty = self.context.get_global_type(gvar.value)
         self.typevars[target.name].lock(gvty)
         self.assumed_immutables.add(inst)
     elif gvar.name in ('True', 'False'):
         assert gvar.value in (True, False)
         self.typevars[target.name].lock(types.boolean)
         self.assumed_immutables.add(inst)
     elif isinstance(gvar.value, (int, float)):
         gvty = self.context.get_number_type(gvar.value)
         self.typevars[target.name].lock(gvty)
         self.assumed_immutables.add(inst)
     elif numpy_support.is_arrayscalar(gvar.value):
         gvty = numpy_support.map_arrayscalar_type(gvar.value)
         self.typevars[target.name].lock(gvty)
         self.assumed_immutables.add(inst)
     elif numpy_support.is_array(gvar.value):
         ary = gvar.value
         dtype = numpy_support.from_dtype(ary.dtype)
         # force C contiguous
         gvty = types.Array(dtype, ary.ndim, 'C')
         self.typevars[target.name].lock(gvty)
         self.assumed_immutables.add(inst)
     elif ctypes_utils.is_ctypes_funcptr(gvar.value):
         cfnptr = gvar.value
         fnty = ctypes_utils.make_function_type(cfnptr)
         self.typevars[target.name].lock(fnty)
         self.assumed_immutables.add(inst)
     elif cffi_support.SUPPORTED and cffi_support.is_cffi_func(gvar.value):
         fnty = cffi_support.make_function_type(gvar.value)
         self.typevars[target.name].lock(fnty)
         self.assumed_immutables.add(inst)
     else:
         try:
             gvty = self.context.get_global_type(gvar.value)
         except KeyError:
             raise TypingError("Untyped global name '%s'" % gvar.name,
                               loc=inst.loc)
         self.assumed_immutables.add(inst)
         self.typevars[target.name].lock(gvty)
Beispiel #2
0
 def typeof_global(self, inst, target, gvar):
     if (gvar.name in ('range', 'xrange')
             and gvar.value in RANGE_ITER_OBJECTS):
         gvty = self.context.get_global_type(gvar.value)
         self.typevars[target.name].lock(gvty)
         self.assumed_immutables.add(inst)
     if gvar.name == 'slice' and gvar.value is slice:
         gvty = self.context.get_global_type(gvar.value)
         self.typevars[target.name].lock(gvty)
         self.assumed_immutables.add(inst)
     elif gvar.name == 'len' and gvar.value is len:
         gvty = self.context.get_global_type(gvar.value)
         self.typevars[target.name].lock(gvty)
         self.assumed_immutables.add(inst)
     elif gvar.name in ('True', 'False'):
         assert gvar.value in (True, False)
         self.typevars[target.name].lock(types.boolean)
         self.assumed_immutables.add(inst)
     elif isinstance(gvar.value, (int, float)):
         gvty = self.context.get_number_type(gvar.value)
         self.typevars[target.name].lock(gvty)
         self.assumed_immutables.add(inst)
     elif numpy_support.is_arrayscalar(gvar.value):
         gvty = numpy_support.map_arrayscalar_type(gvar.value)
         self.typevars[target.name].lock(gvty)
         self.assumed_immutables.add(inst)
     elif numpy_support.is_array(gvar.value):
         ary = gvar.value
         dtype = numpy_support.from_dtype(ary.dtype)
         # force C contiguous
         gvty = types.Array(dtype, ary.ndim, 'C')
         self.typevars[target.name].lock(gvty)
         self.assumed_immutables.add(inst)
     elif ctypes_utils.is_ctypes_funcptr(gvar.value):
         cfnptr = gvar.value
         fnty = ctypes_utils.make_function_type(cfnptr)
         self.typevars[target.name].lock(fnty)
         self.assumed_immutables.add(inst)
     elif cffi_support.SUPPORTED and cffi_support.is_cffi_func(gvar.value):
         fnty = cffi_support.make_function_type(gvar.value)
         self.typevars[target.name].lock(fnty)
         self.assumed_immutables.add(inst)
     else:
         try:
             gvty = self.context.get_global_type(gvar.value)
         except KeyError:
             raise TypingError("Untyped global name '%s'" % gvar.name,
                               loc=inst.loc)
         self.assumed_immutables.add(inst)
         self.typevars[target.name].lock(gvty)
Beispiel #3
0
    def typeof_global(self, inst, target, gvar):
        try:
            # Is it a supported value type?
            typ = self.resolve_value_type(inst, gvar.value)
        except TypingError:
            # Fallback on other cases below
            pass
        else:
            self.typevars[target.name].lock(typ)
            self.assumed_immutables.add(inst)
            return

        if (gvar.name in ('range', 'xrange') and
                    gvar.value in RANGE_ITER_OBJECTS):
            gvty = self.context.get_global_type(gvar.value)
            self.typevars[target.name].lock(gvty)
            self.assumed_immutables.add(inst)

        elif gvar.name == 'slice' and gvar.value is slice:
            gvty = self.context.get_global_type(gvar.value)
            self.typevars[target.name].lock(gvty)
            self.assumed_immutables.add(inst)

        elif gvar.name == 'len' and gvar.value is len:
            gvty = self.context.get_global_type(gvar.value)
            self.typevars[target.name].lock(gvty)
            self.assumed_immutables.add(inst)

        elif numpy_support.is_arrayscalar(gvar.value):
            gvty = numpy_support.map_arrayscalar_type(gvar.value)
            self.typevars[target.name].lock(gvty)
            self.assumed_immutables.add(inst)

        elif numpy_support.is_array(gvar.value):
            ary = gvar.value
            dtype = numpy_support.from_dtype(ary.dtype)
            # force C contiguous
            gvty = types.Array(dtype, ary.ndim, 'C')
            self.typevars[target.name].lock(gvty)
            self.assumed_immutables.add(inst)

        elif ctypes_utils.is_ctypes_funcptr(gvar.value):
            cfnptr = gvar.value
            fnty = ctypes_utils.make_function_type(cfnptr)
            self.typevars[target.name].lock(fnty)
            self.assumed_immutables.add(inst)

        elif cffi_support.SUPPORTED and cffi_support.is_cffi_func(gvar.value):
            fnty = cffi_support.make_function_type(gvar.value)
            self.typevars[target.name].lock(fnty)
            self.assumed_immutables.add(inst)

        elif (cffi_support.SUPPORTED and
                isinstance(gvar.value, cffi_support.ExternCFunction)):
            fnty = gvar.value
            self.typevars[target.name].lock(fnty)
            self.assumed_immutables.add(inst)

        elif type(gvar.value) is type and issubclass(gvar.value,
                                                     BaseException):
            self.typevars[target.name].lock(types.exception_type)
            self.assumed_immutables.add(inst)

        else:
            try:
                gvty = self.context.get_global_type(gvar.value)
            except KeyError:
                raise TypingError("Untyped global name '%s'" % gvar.name,
                                  loc=inst.loc)
            self.assumed_immutables.add(inst)
            self.typevars[target.name].lock(gvty)