Did I find the right examples for you? yes no

All Samples(176)  |  Call(123)  |  Derive(0)  |  Import(53)

src/c/y/Cython-0.20.1/Cython/Compiler/ExprNodes.py   Cython(Download)
import operator
 
from Errors import error, warning, warn_once, InternalError, CompileError
from Errors import hold_errors, release_errors, held_errors, report_error
from Code import UtilityCode, TempitaUtilityCode
    def not_implemented(self, method_name):
        print_call_chain(method_name, "not implemented") ###
        raise InternalError(
            "%s.%s not implemented" %
                (self.__class__.__name__, method_name))
            return
        if sequence_type.is_array or sequence_type.is_ptr:
            raise InternalError("for in carray slice not transformed")
        is_builtin_sequence = sequence_type is list_type or \
                              sequence_type is tuple_type
            else:
                # This is a bug
                raise InternalError("Couldn't find the right signature")
 
    gil_message = "Indexing Python object"
                create_func, set_item_func = 'PyTuple_New', 'PyTuple_SET_ITEM'
            else:
                raise InternalError("sequence packing for unexpected type %s" % self.type)
            arg_count = len(self.args)
            code.putln("%s = %s(%s%s); %s" % (

src/c/y/cython-HEAD/Cython/Compiler/ExprNodes.py   cython(Download)
import operator
 
from Errors import error, warning, warn_once, InternalError, CompileError
from Errors import hold_errors, release_errors, held_errors, report_error
from Code import UtilityCode, TempitaUtilityCode
    def not_implemented(self, method_name):
        print_call_chain(method_name, "not implemented") ###
        raise InternalError(
            "%s.%s not implemented" %
                (self.__class__.__name__, method_name))
            return
        if sequence_type.is_array or sequence_type.is_ptr:
            raise InternalError("for in carray slice not transformed")
        is_builtin_sequence = sequence_type is list_type or \
                              sequence_type is tuple_type
            else:
                # This is a bug
                raise InternalError("Couldn't find the right signature")
 
    gil_message = "Indexing Python object"
                create_func, set_item_func = 'PyTuple_New', 'PyTuple_SET_ITEM'
            else:
                raise InternalError("sequence packing for unexpected type %s" % self.type)
            arg_count = len(self.args)
            code.putln("%s = %s(%s%s); %s" % (

src/c/y/CythonCTypesBackend-HEAD/Cython/Compiler/ExprNodes.py   CythonCTypesBackend(Download)
import operator
 
from Errors import error, warning, warn_once, InternalError, CompileError
from Errors import hold_errors, release_errors, held_errors, report_error
from Code import UtilityCode, TempitaUtilityCode
    def not_implemented(self, method_name):
        print_call_chain(method_name, "not implemented") ###
        raise InternalError(
            "%s.%s not implemented" %
                (self.__class__.__name__, method_name))
    def generate_result_code(self, code):
        sequence_type = self.sequence.type
        if sequence_type.is_array or sequence_type.is_ptr:
            raise InternalError("for in carray slice not transformed")
        is_builtin_sequence = sequence_type is list_type or \
            else:
                # This is a bug
                raise InternalError("Couldn't find the right signature")
 
    gil_message = "Indexing Python object"
            create_func, set_item_func = 'PyTuple_New', 'PyTuple_SET_ITEM'
        else:
            raise InternalError("sequence unpacking for unexpected type %s" % self.type)
        arg_count = len(self.args)
        code.putln("%s = %s(%s%s); %s" % (

src/c/y/Cython-0.20.1/Cython/Compiler/Nodes.py   Cython(Download)
 
import Builtin
from Errors import error, warning, InternalError, CompileError
import Naming
import PyrexTypes
    def analyse_expressions(self, env):
        raise InternalError("analyse_expressions not implemented for %s" % \
            self.__class__.__name__)
 
    def generate_code(self, code):
        raise InternalError("generate_code not implemented for %s" % \
    def generate_execution_code(self, code):
        raise InternalError("generate_execution_code not implemented for %s" % \
            self.__class__.__name__)
 
 
                    if exc_val is None:
                        raise InternalError(
                            "get_constant_c_result_code not implemented for %s" %
                            self.exception_value.__class__.__name__)
                    if not return_type.assignable_from(self.exception_value.type):

src/c/y/cython-HEAD/Cython/Compiler/Nodes.py   cython(Download)
 
import Builtin
from Errors import error, warning, InternalError, CompileError
import Naming
import PyrexTypes
    def analyse_expressions(self, env):
        raise InternalError("analyse_expressions not implemented for %s" % \
            self.__class__.__name__)
 
    def generate_code(self, code):
        raise InternalError("generate_code not implemented for %s" % \
    def generate_execution_code(self, code):
        raise InternalError("generate_execution_code not implemented for %s" % \
            self.__class__.__name__)
 
 
                    if exc_val is None:
                        raise InternalError(
                            "get_constant_c_result_code not implemented for %s" %
                            self.exception_value.__class__.__name__)
                    if not return_type.assignable_from(self.exception_value.type):

src/c/y/CythonCTypesBackend-HEAD/Cython/Compiler/Nodes.py   CythonCTypesBackend(Download)
 
import Builtin
from Errors import error, warning, InternalError, CompileError
import Naming
import PyrexTypes
    def analyse_expressions(self, env):
        raise InternalError("analyse_expressions not implemented for %s" % \
            self.__class__.__name__)
 
    def generate_code(self, code):
        raise InternalError("generate_code not implemented for %s" % \
    def generate_execution_code(self, code):
        raise InternalError("generate_execution_code not implemented for %s" % \
            self.__class__.__name__)
 
 
                        exc_val = self.exception_value.get_constant_c_result_code()
                        if exc_val is None:
                            raise InternalError("get_constant_c_result_code not implemented for %s" %
                                self.exception_value.__class__.__name__)
                        if not return_type.assignable_from(self.exception_value.type):

src/e/s/essig-HEAD/vm/cython/Cython/Compiler/Nodes.py   essig(Download)
import Code
import Builtin
from Errors import error, warning, InternalError
import Naming
import PyrexTypes
    def analyse_expressions(self, env):
        raise InternalError("analyse_expressions not implemented for %s" % \
            self.__class__.__name__)
 
    def generate_code(self, code):
        raise InternalError("generate_code not implemented for %s" % \
    def generate_execution_code(self, code):
        raise InternalError("generate_execution_code not implemented for %s" % \
            self.__class__.__name__)
 
 
                        exc_val = self.exception_value.get_constant_c_result_code()
                        if exc_val is None:
                            raise InternalError("get_constant_c_result_code not implemented for %s" %
                                self.exception_value.__class__.__name__)
                        if not return_type.assignable_from(self.exception_value.type):

src/c/y/Cython-0.20.1/Cython/Compiler/Symtab.py   Cython(Download)
import copy
import re
from Errors import warning, error, InternalError
from StringEncoding import EncodedString
import Options, Naming
            if not (type.is_pyobject and not type.is_extension_type):
                raise InternalError(
                    "Non-cdef global variable is not a generic Python object")
 
        if not cname:
            if entry.scope is not self and entry.scope.is_closure_scope:
                if hasattr(entry.scope, "scope_class"):
                    raise InternalError("lookup() after scope class created.")
                # The actual c fragment for the different scopes differs
                # on the outside and inside, so we make a new entry

src/c/y/cython-HEAD/Cython/Compiler/Symtab.py   cython(Download)
import copy
import re
from Errors import warning, error, InternalError
from StringEncoding import EncodedString
import Options, Naming
            if not (type.is_pyobject and not type.is_extension_type):
                raise InternalError(
                    "Non-cdef global variable is not a generic Python object")
 
        if not cname:
            if entry.scope is not self and entry.scope.is_closure_scope:
                if hasattr(entry.scope, "scope_class"):
                    raise InternalError("lookup() after scope class created.")
                # The actual c fragment for the different scopes differs
                # on the outside and inside, so we make a new entry

src/p/y/pylibs-HEAD/Cython/Compiler/Nodes.py   pylibs(Download)
import Code
import Builtin
from Errors import error, warning, InternalError
import Naming
import PyrexTypes
    def analyse_expressions(self, env):
        raise InternalError("analyse_expressions not implemented for %s" % \
            self.__class__.__name__)
 
    def generate_code(self, code):
        raise InternalError("generate_code not implemented for %s" % \
    def generate_execution_code(self, code):
        raise InternalError("generate_execution_code not implemented for %s" % \
            self.__class__.__name__)
 
 
                        exc_val = self.exception_value.get_constant_c_result_code()
                        if exc_val is None:
                            raise InternalError("get_constant_c_result_code not implemented for %s" %
                                self.exception_value.__class__.__name__)
                        if not return_type.assignable_from(self.exception_value.type):

  1 | 2 | 3 | 4  Next