Official Pyrex version 0.9.4.1

Cython/Compiler/CmdLine.py

+#
+#   Pyrex - Command Line Parsing
+#
+
+import sys
+
+usage = """\
+Usage: pyrexc [options] sourcefile...
+Options:
+  -v, --version                  Display version number of pyrex compiler
+  -l, --create-listing           Write error messages to a listing file
+  -I, --include-dir <directory>  Search for include files in named directory
+  -o, --output-file <filename>   Specify name of generated C file
+The following experimental options are supported only on MacOSX:
+  -C, --compile    Compile generated .c file to .o file
+  -X, --link       Link .o file to produce extension module (implies -C)
+  -+, --cplus      Use C++ compiler for compiling and linking
+  Additional .o files to link may be supplied when using -X."""
+
+def bad_usage():
+    print >>sys.stderr, usage
+    sys.exit(1)
+
+def parse_command_line(args):
+    from Pyrex.Compiler.Main import \
+        CompilationOptions, default_options
+
+    def pop_arg():
+        if args:
+            return args.pop(0)
+        else:
+            bad_usage()
+    
+    def get_param(option):
+        tail = option[2:]
+        if tail:
+            return tail
+        else:
+            return pop_arg()
+
+    options = CompilationOptions(default_options)
+    sources = []
+    while args:
+        if args[0].startswith("-"):
+            option = pop_arg()
+            if option in ("-v", "--version"):
+                options.show_version = 1
+            elif option in ("-l", "--create-listing"):
+                options.use_listing_file = 1
+            elif option in ("-C", "--compile"):
+                options.c_only = 0
+            elif option in ("-X", "--link"):
+                options.c_only = 0
+                options.obj_only = 0
+            elif option in ("-+", "--cplus"):
+                options.cplus = 1
+            elif option.startswith("-I"):
+                options.include_path.append(get_param(option))
+            elif option == "--include-dir":
+                options.include_path.append(pop_arg())
+            elif option in ("-o", "--output-file"):
+                options.output_file = pop_arg()
+            else:
+                bad_usage()
+        else:
+            arg = pop_arg()
+            if arg.endswith(".pyx"):
+                sources.append(arg)
+            elif arg.endswith(".o"):
+                options.objects.append(arg)
+            else:
+                print >>sys.stderr, \
+                    "pyrexc: %s: Unknown filename suffix" % arg
+    if options.objects and len(sources) > 1:
+        print >>sys.stderr, \
+            "pyrexc: Only one source file allowed together with .o files"
+    if options.use_listing_file and len(sources) > 1:
+        print >>sys.stderr, \
+            "pyrexc: Only one source file allowed when using -o"
+        sys.exit(1)
+    return options, sources
+

Cython/Compiler/Code.py

+#
+#   Pyrex - Code output module
+#
+
+import Naming
+from Pyrex.Utils import open_new_file
+from PyrexTypes import py_object_type, typecast
+
+class CCodeWriter:
+    # f                file            output file
+    # level            int             indentation level
+    # bol              bool            beginning of line?
+    # marker           string          comment to emit before next line
+    # return_label     string          function return point label
+    # error_label      string          error catch point label
+    # continue_label   string          loop continue point label
+    # break_label      string          loop break point label
+    # label_counter    integer         counter for naming labels
+    # in_try_finally   boolean         inside try of try...finally
+    # filename_table   {string : int}  for finding filename table indexes
+    # filename_list    [string]        filenames in filename table order
+    
+    in_try_finally = 0
+    
+    def __init__(self, outfile_name):
+        self.f = open_new_file(outfile_name)
+        self.level = 0
+        self.bol = 1
+        self.marker = None
+        self.label_counter = 1
+        self.error_label = None
+        self.filename_table = {}
+        self.filename_list = []
+    
+    def putln(self, code = ""):
+        if self.marker and self.bol:
+            self.emit_marker()
+        if code:
+            self.put(code)
+        self.f.write("\n");
+        self.bol = 1
+    
+    def emit_marker(self):
+        self.f.write("\n");
+        self.indent()
+        self.f.write("/* %s */\n" % self.marker)
+        self.marker = None
+
+    def put(self, code):
+        dl = code.count("{") - code.count("}")
+        if dl < 0:
+            self.level += dl
+        if self.bol:
+            self.indent()
+        self.f.write(code)
+        self.bol = 0
+        if dl > 0:
+            self.level += dl
+    
+    def increase_indent(self):
+        self.level = self.level + 1
+    
+    def decrease_indent(self):
+        self.level = self.level - 1
+    
+    def begin_block(self):
+        self.putln("{")
+        self.increase_indent()
+    
+    def end_block(self):
+        self.decrease_indent()
+        self.putln("}")
+    
+    def indent(self):
+        self.f.write("  " * self.level)
+    
+    def mark_pos(self, pos):
+        file, line, col = pos
+        self.marker = '"%s":%s' % (file, line)
+
+    def init_labels(self):
+        self.label_counter = 0
+        self.return_label = self.new_label()
+        self.new_error_label()
+        self.continue_label = None
+        self.break_label = None
+    
+    def new_label(self):
+        n = self.label_counter
+        self.label_counter = n + 1
+        return "%s%d" % (Naming.label_prefix, n)
+    
+    def new_error_label(self):
+        old_err_lbl = self.error_label
+        self.error_label = self.new_label()
+        return old_err_lbl
+    
+    def get_loop_labels(self):
+        return (
+            self.continue_label,
+            self.break_label)
+    
+    def set_loop_labels(self, labels):
+        (self.continue_label,
+         self.break_label) = labels
+    
+    def new_loop_labels(self):
+        old_labels = self.get_loop_labels()
+        self.set_loop_labels(
+            (self.new_label(), 
+             self.new_label()))
+        return old_labels
+    
+    def get_all_labels(self):
+        return (
+            self.continue_label,
+            self.break_label,
+            self.return_label,
+            self.error_label)
+
+    def set_all_labels(self, labels):
+        (self.continue_label,
+         self.break_label,
+         self.return_label,
+         self.error_label) = labels
+
+    def all_new_labels(self):
+        old_labels = self.get_all_labels()
+        new_labels = []
+        for old_label in old_labels:
+            if old_label:
+                new_labels.append(self.new_label())
+            else:
+                new_labels.append(old_label)
+        self.set_all_labels(new_labels)
+        return old_labels
+
+    def put_label(self, lbl):
+        self.putln("%s:;" % lbl)
+    
+    def put_var_declarations(self, entries, static = 0, dll_linkage = None,
+            definition = True):
+        for entry in entries:
+            if not entry.in_cinclude:
+                self.put_var_declaration(entry, static, dll_linkage, definition)
+    
+    def put_var_declaration(self, entry, static = 0, dll_linkage = None,
+            definition = True):
+        #print "Code.put_var_declaration:", entry.name, "definition =", definition
+        visibility = entry.visibility
+        if visibility == 'private' and not definition:
+            return
+        if visibility == 'extern':
+            storage_class = Naming.extern_c_macro
+        elif visibility == 'public':
+            if definition:
+                storage_class = ""
+            else:
+                storage_class = Naming.extern_c_macro
+        elif visibility == 'private':
+            if static:
+                storage_class = "static"
+            else:
+                storage_class = ""
+        if storage_class:
+            self.put("%s " % storage_class)
+        #if visibility == 'extern' or visibility == 'public' and not definition:
+        #	self.put("%s " % Naming.extern_c_macro)
+        #elif static and visibility <> 'public':
+        #	self.put("static ")
+        if visibility <> 'public':
+            dll_linkage = None
+        self.put(entry.type.declaration_code(entry.cname,
+            dll_linkage = dll_linkage))
+        if entry.init is not None:
+            self.put(" = %s" % entry.type.literal_code(entry.init))
+        self.putln(";")
+    
+    def entry_as_pyobject(self, entry):
+        type = entry.type
+        if (not entry.is_self_arg and not entry.type.is_complete()) \
+            or (entry.type.is_extension_type and entry.type.base_type):
+            return "(PyObject *)" + entry.cname
+        else:
+            return entry.cname
+    
+    def as_pyobject(self, cname, type):
+        return typecast(py_object_type, type, cname)
+        #if type.is_extension_type and type.base_type:
+        #	return "(PyObject *)" + cname
+        #else:
+        #	return cname
+    
+    def put_incref(self, cname, type):
+        self.putln("Py_INCREF(%s);" % self.as_pyobject(cname, type))
+    
+    def put_decref(self, cname, type):
+        self.putln("Py_DECREF(%s);" % self.as_pyobject(cname, type))
+    
+    def put_var_incref(self, entry):
+        if entry.type.is_pyobject:
+            self.putln("Py_INCREF(%s);" % self.entry_as_pyobject(entry))
+    
+    def put_decref_clear(self, cname, type):
+        self.putln("Py_DECREF(%s); %s = 0;" % (
+            typecast(py_object_type, type, cname), cname))
+            #self.as_pyobject(cname, type), cname))
+    
+    def put_xdecref(self, cname, type):
+        self.putln("Py_XDECREF(%s);" % self.as_pyobject(cname, type))
+    
+    def put_xdecref_clear(self, cname, type):
+        self.putln("Py_XDECREF(%s); %s = 0;" % (
+            self.as_pyobject(cname, type), cname))
+
+    def put_var_decref(self, entry):
+        if entry.type.is_pyobject:
+            self.putln("Py_DECREF(%s);" % self.entry_as_pyobject(entry))
+    
+    def put_var_decref_clear(self, entry):
+        if entry.type.is_pyobject:
+            self.putln("Py_DECREF(%s); %s = 0;" % (
+                self.entry_as_pyobject(entry), entry.cname))
+    
+    def put_var_xdecref(self, entry):
+        if entry.type.is_pyobject:
+            self.putln("Py_XDECREF(%s);" % self.entry_as_pyobject(entry))
+    
+    def put_var_xdecref_clear(self, entry):
+        if entry.type.is_pyobject:
+            self.putln("Py_XDECREF(%s); %s = 0;" % (
+                self.entry_as_pyobject(entry), entry.cname))
+    
+    def put_var_decrefs(self, entries):
+        for entry in entries:
+            if entry.xdecref_cleanup:
+                self.put_var_xdecref(entry)
+            else:
+                self.put_var_decref(entry)
+    
+    def put_var_xdecrefs(self, entries):
+        for entry in entries:
+            self.put_var_xdecref(entry)
+    
+    def put_var_xdecrefs_clear(self, entries):
+        for entry in entries:
+            self.put_var_xdecref_clear(entry)
+    
+    def put_init_to_py_none(self, cname, type):
+        py_none = typecast(type, py_object_type, "Py_None")
+        self.putln("%s = %s; Py_INCREF(Py_None);" % (cname, py_none))
+    
+    def put_init_var_to_py_none(self, entry, template = "%s"):
+        code = template % entry.cname
+        #if entry.type.is_extension_type:
+        #	code = "((PyObject*)%s)" % code
+        self.put_init_to_py_none(code, entry.type)
+
+    def put_pymethoddef(self, entry, term):
+        if entry.doc:
+            doc_code = entry.doc_cname
+        else:
+            doc_code = 0
+        self.putln(
+            '{"%s", (PyCFunction)%s, METH_VARARGS|METH_KEYWORDS, %s}%s' % (
+                entry.name, 
+                entry.func_cname, 
+                doc_code,
+                term))
+    
+    def error_goto(self, pos):
+        return "{%s = %s[%s]; %s = %s; goto %s;}" % (
+            Naming.filename_cname,
+            Naming.filetable_cname,
+            self.lookup_filename(pos[0]),
+            Naming.lineno_cname,
+            pos[1],
+            self.error_label)
+    
+    def lookup_filename(self, filename):
+        try:
+            index = self.filename_table[filename]
+        except KeyError:
+            index = len(self.filename_list)
+            self.filename_list.append(filename)
+            self.filename_table[filename] = index
+        return index
+
+
+class PyrexCodeWriter:
+    # f                file      output file
+    # level            int       indentation level
+
+    def __init__(self, outfile_name):
+        self.f = open_new_file(outfile_name)
+        self.level = 0
+    
+    def putln(self, code):
+        self.f.write("%s%s\n" % (" " * self.level, code))
+    
+    def indent(self):
+        self.level += 1
+    
+    def dedent(self):
+        self.level -= 1
+

Cython/Compiler/DebugFlags.py

+debug_disposal_code = 0
+debug_temp_alloc = 0
+debug_coercion = 0
+

Cython/Compiler/Errors.py

+#
+#   Pyrex - Errors
+#
+
+import sys
+from Pyrex.Utils import open_new_file
+
+
+class PyrexError(Exception):
+    pass
+
+
+class CompileError(PyrexError):
+    
+    def __init__(self, position = None, message = ""):
+        self.position = position
+        self.message = message
+        if position:
+            pos_str = "%s:%d:%d: " % position
+        else:
+            pos_str = ""
+        Exception.__init__(self, pos_str + message)
+
+
+class InternalError(Exception):
+    # If this is ever raised, there is a bug in the compiler.
+    
+    def __init__(self, message):
+        Exception.__init__(self, "Internal compiler error: %s"
+            % message)
+            
+
+listing_file = None
+num_errors = 0
+echo_file = None
+
+def open_listing_file(path, echo_to_stderr = 1):
+    # Begin a new error listing. If path is None, no file
+    # is opened, the error counter is just reset.
+    global listing_file, num_errors, echo_file
+    if path is not None:
+        listing_file = open_new_file(path)
+    else:
+        listing_file = None
+    if echo_to_stderr:
+        echo_file = sys.stderr
+    else:
+        echo_file = None
+    num_errors = 0
+
+def close_listing_file():
+    global listing_file
+    if listing_file:
+        listing_file.close()
+        listing_file = None
+
+def error(position, message):
+    #print "Errors.error:", repr(position), repr(message) ###
+    global num_errors
+    err = CompileError(position, message)
+    line = "%s\n" % err
+    if listing_file:
+        listing_file.write(line)
+    if echo_file:
+        echo_file.write(line)
+    num_errors = num_errors + 1
+    return err

Cython/Compiler/Lexicon.py

+#
+#   Pyrex Scanner - Lexical Definitions
+#
+#   Changing anything in this file will cause Lexicon.pickle
+#   to be rebuilt next time pyrexc is run.
+#
+
+string_prefixes = "cCrR"
+
+def make_lexicon():
+    from Pyrex.Plex import \
+        Str, Any, AnyBut, AnyChar, Rep, Rep1, Opt, Bol, Eol, Eof, \
+        TEXT, IGNORE, State, Lexicon
+    from Scanning import Method
+
+    letter = Any("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_")
+    digit = Any("0123456789")
+    octdigit = Any("01234567")
+    hexdigit = Any("0123456789ABCDEFabcdef")
+    indentation = Bol + Rep(Any(" \t"))
+    
+    decimal = Rep1(digit)
+    dot = Str(".")
+    exponent = Any("Ee") + Opt(Any("+-")) + decimal
+    decimal_fract = (decimal + dot + Opt(decimal)) | (dot + decimal)
+    
+    name = letter + Rep(letter | digit)
+    intconst = decimal | (Str("0x") + Rep1(hexdigit))
+    longconst = intconst + Str("L")
+    fltconst = (decimal_fract + Opt(exponent)) | (decimal + exponent)
+    imagconst = (intconst | fltconst) + Any("jJ")
+    
+    sq_string = (
+        Str("'") + 
+        Rep(AnyBut("\\\n'") | (Str("\\") + AnyChar)) + 
+        Str("'")
+    )
+    
+    dq_string = (
+        Str('"') + 
+        Rep(AnyBut('\\\n"') | (Str("\\") + AnyChar)) + 
+        Str('"')
+    )
+    
+    non_sq = AnyBut("'") | (Str('\\') + AnyChar)
+    tsq_string = (
+        Str("'''")
+        + Rep(non_sq | (Str("'") + non_sq) | (Str("''") + non_sq)) 
+        + Str("'''")
+    )
+    
+    non_dq = AnyBut('"') | (Str('\\') + AnyChar)
+    tdq_string = (
+        Str('"""')
+        + Rep(non_dq | (Str('"') + non_dq) | (Str('""') + non_dq)) 
+        + Str('"""')
+    )
+    stringlit = Opt(Any(string_prefixes)) + (sq_string | dq_string | tsq_string| tdq_string)
+    
+    beginstring = Opt(Any(string_prefixes)) + (Str("'") | Str('"') | Str("'''") | Str('"""'))
+    two_oct = octdigit + octdigit
+    three_oct = octdigit + octdigit + octdigit
+    two_hex = hexdigit + hexdigit
+    escapeseq = Str("\\") + (two_oct | three_oct | two_hex | AnyChar)
+    
+    bra = Any("([{")
+    ket = Any(")]}")
+    punct = Any(":,;+-*/|&<>=.%`~^?")
+    diphthong = Str("==", "<>", "!=", "<=", ">=", "<<", ">>", "**")
+    spaces = Rep1(Any(" \t\f"))
+    comment = Str("#") + Rep(AnyBut("\n"))
+    escaped_newline = Str("\\\n")
+    lineterm = Eol + Opt(Str("\n"))
+    
+    return Lexicon([
+        (name, 'IDENT'),
+        (intconst, 'INT'),
+        (longconst, 'LONG'),
+        (fltconst, 'FLOAT'),
+        (imagconst, 'IMAG'),
+        (punct | diphthong, TEXT),
+        
+        (bra, Method('open_bracket_action')),
+        (ket, Method('close_bracket_action')),
+        (lineterm, Method('newline_action')),
+    
+        #(stringlit, 'STRING'),
+        (beginstring, Method('begin_string_action')),
+        
+        (comment, IGNORE),
+        (spaces, IGNORE),
+        (escaped_newline, IGNORE),
+        
+        State('INDENT', [
+            (Opt(spaces) + Opt(comment) + lineterm, IGNORE),
+            (indentation, Method('indentation_action')),
+            (Eof, Method('eof_action'))
+        ]),
+        
+        State('SQ_STRING', [
+            (escapeseq, 'ESCAPE'),
+            (Rep1(AnyBut("'\"\n\\")), 'CHARS'),
+            (Str('"'), 'CHARS'),
+            (Str("\n"), Method('unclosed_string_action')),
+            (Str("'"), Method('end_string_action')),
+            (Eof, 'EOF')
+        ]),
+        
+        State('DQ_STRING', [
+            (escapeseq, 'ESCAPE'),
+            (Rep1(AnyBut('"\n\\')), 'CHARS'),
+            (Str("'"), 'CHARS'),
+            (Str("\n"), Method('unclosed_string_action')),
+            (Str('"'), Method('end_string_action')),
+            (Eof, 'EOF')
+        ]),
+        
+        State('TSQ_STRING', [
+            (escapeseq, 'ESCAPE'),
+            (Rep1(AnyBut("'\"\n\\")), 'CHARS'),
+            (Any("'\""), 'CHARS'),
+            (Str("\n"), 'NEWLINE'),
+            (Str("'''"), Method('end_string_action')),
+            (Eof, 'EOF')
+        ]),
+        
+        State('TDQ_STRING', [
+            (escapeseq, 'ESCAPE'),
+            (Rep1(AnyBut('"\'\n\\')), 'CHARS'),
+            (Any("'\""), 'CHARS'),
+            (Str("\n"), 'NEWLINE'),
+            (Str('"""'), Method('end_string_action')),
+            (Eof, 'EOF')
+        ]),
+        
+        (Eof, Method('eof_action'))
+        ],
+        
+        # FIXME: Plex 1.9 needs different args here from Plex 1.1.4
+        #debug_flags = scanner_debug_flags,
+        #debug_file = scanner_dump_file
+        )
+

Cython/Compiler/Naming.py

+#
+#   Pyrex - C naming conventions
+#
+#
+#   Prefixes for generating C names.
+#   Collected here to facilitate ensuring uniqueness.
+#
+
+pyrex_prefix    = "__pyx_"
+
+arg_prefix        = pyrex_prefix + "arg_"
+funcdoc_prefix    = pyrex_prefix + "doc_"
+enum_prefix       = pyrex_prefix + "e_"
+func_prefix       = pyrex_prefix + "f_"
+gstab_prefix      = pyrex_prefix + "getsets_"
+prop_get_prefix   = pyrex_prefix + "getprop_"
+const_prefix      = pyrex_prefix + "k"
+label_prefix      = pyrex_prefix + "L"
+pymethdef_prefix  = pyrex_prefix + "mdef_"
+methtab_prefix    = pyrex_prefix + "methods_"
+memtab_prefix     = pyrex_prefix + "members_"
+interned_prefix   = pyrex_prefix + "n_"
+objstruct_prefix  = pyrex_prefix + "obj_"
+typeptr_prefix    = pyrex_prefix + "ptype_"
+prop_set_prefix   = pyrex_prefix + "setprop_"
+type_prefix       = pyrex_prefix + "t_"
+typeobj_prefix    = pyrex_prefix + "type_"
+var_prefix        = pyrex_prefix + "v_"
+vtable_prefix     = pyrex_prefix + "vtable_"
+vtabptr_prefix    = pyrex_prefix + "vtabptr_"
+vtabstruct_prefix = pyrex_prefix + "vtabstruct_"
+
+args_cname       = pyrex_prefix + "args"
+kwdlist_cname    = pyrex_prefix + "argnames"
+obj_base_cname   = pyrex_prefix + "base"
+builtins_cname   = pyrex_prefix + "b"
+moddict_cname    = pyrex_prefix + "d"
+dummy_cname      = pyrex_prefix + "dummy"
+filename_cname   = pyrex_prefix + "filename"
+filetable_cname  = pyrex_prefix + "f"
+filenames_cname  = pyrex_prefix + "filenames"
+fileinit_cname   = pyrex_prefix + "init_filenames"
+intern_tab_cname = pyrex_prefix + "intern_tab"
+kwds_cname       = pyrex_prefix + "kwds"
+lineno_cname     = pyrex_prefix + "lineno"
+module_cname     = pyrex_prefix + "m"
+moddoc_cname     = pyrex_prefix + "mdoc"
+methtable_cname  = pyrex_prefix + "methods"
+retval_cname     = pyrex_prefix + "r"
+self_cname       = pyrex_prefix + "self"
+stringtab_cname  = pyrex_prefix + "string_tab"
+vtabslot_cname   = pyrex_prefix + "vtab"
+
+extern_c_macro  = pyrex_prefix.upper() + "EXTERN_C"

Cython/Compiler/Options.py

+#
+#  Pyrex - Compilation-wide options
+#
+
+intern_names = 1   #  Intern global variable and attribute names

Cython/Compiler/Version.py

+version = '0.9.4.1'

Cython/Debugging.py

+###############################################
+#
+#   Odds and ends for debugging
+#
+###############################################
+
+def print_call_chain(*args):
+    import sys
+    print " ".join(map(str, args))
+    f = sys._getframe(2)
+    while f:
+        name = f.f_code.co_name
+        s = f.f_locals.get('self', None)
+        if s:
+            c = getattr(s, "__class__", None)
+            if c:
+                name = "%s.%s" % (c.__name__, name)
+        print "Called from:", name, f.f_lineno
+        f = f.f_back
+    print "-" * 70

Cython/Distutils/__init__.py

+# July 2002, Graham Fawcett
+
+#
+
+# this hack was inspired by the way Thomas Heller got py2exe
+
+# to appear as a distutil command
+
+#
+
+# we replace distutils.command.build_ext with our own version
+
+# and keep the old one under the module name _build_ext,
+
+# so that *our* build_ext can make use of it.
+
+
+
+from build_ext import build_ext
+
+
+

Cython/Distutils/build_ext.py

+# Subclasses disutils.command.build_ext,
+# replacing it with a Pyrex version that compiles pyx->c
+# before calling the original build_ext command.
+# July 2002, Graham Fawcett
+# Modified by Darrell Gallion <dgallion1@yahoo.com>
+# to allow inclusion of .c files along with .pyx files.
+# Pyrex is (c) Greg Ewing.
+
+import distutils.command.build_ext
+#import Pyrex.Compiler.Main
+from Pyrex.Compiler.Main import CompilationOptions, default_options, compile
+from Pyrex.Compiler.Errors import PyrexError
+from distutils.dep_util import newer
+import os
+import sys
+
+def replace_suffix(path, new_suffix):
+    return os.path.splitext(path)[0] + new_suffix
+
+class build_ext (distutils.command.build_ext.build_ext):
+
+    description = "compile Pyrex scripts, then build C/C++ extensions (compile/link to build directory)"
+
+    def finalize_options (self):
+        distutils.command.build_ext.build_ext.finalize_options(self)
+
+        # The following hack should no longer be needed.
+        if 0:
+            # compiling with mingw32 gets an "initializer not a constant" error
+            # doesn't appear to happen with MSVC!
+            # so if we are compiling with mingw32,
+            # switch to C++ mode, to avoid the problem
+            if self.compiler == 'mingw32':
+                self.swig_cpp = 1
+
+    def swig_sources (self, sources, extension = None):
+        if not self.extensions:
+            return
+
+        # collect the names of the source (.pyx) files
+        pyx_sources = []
+        pyx_sources = [source for source in sources if source.endswith('.pyx')]
+        other_sources = [source for source in sources if not source.endswith('.pyx')]
+
+        #suffix = self.swig_cpp and '.cpp' or '.c'
+        suffix = '.c'
+        for pyx in pyx_sources:
+            # should I raise an exception if it doesn't exist?
+            if os.path.exists(pyx):
+                source = pyx
+                target = replace_suffix(source, suffix)
+                if newer(source, target) or self.force:
+                    self.pyrex_compile(source)
+
+        return [replace_suffix(src, suffix) for src in pyx_sources] + other_sources
+
+    def pyrex_compile(self, source):
+        options = CompilationOptions(default_options,
+            include_path = self.include_dirs)
+        result = compile(source, options)
+        if result.num_errors <> 0:
+            sys.exit(1)
+

Cython/Mac/DarwinSystem.py

+#
+#   Pyrex - Darwin system interface
+#
+
+verbose = 0
+gcc_pendantic = True
+gcc_warnings_are_errors = False
+
+import os
+from Pyrex.Utils import replace_suffix
+from Pyrex.Compiler.Errors import PyrexError
+
+py_include_dirs = [
+    "/Library/Frameworks/Python.framework/Headers"
+]
+
+compilers = ["gcc", "g++"]
+compiler_options = \
+    "-g -c -fno-strict-aliasing -Wno-long-double -no-cpp-precomp " \
+    "-mno-fused-madd -fno-common -dynamic " \
+    .split()
+if gcc_pendantic:
+    compiler_options.extend(["-pedantic", "-Wno-long-long"])
+if gcc_warnings_are_errors:
+    compiler_options.append("-Werror")
+
+linkers = ["gcc", "g++"]
+linker_options = \
+    "-Wl,-F.,-w -bundle -framework Python" \
+    .split()
+
+class CCompilerError(PyrexError):
+    pass
+
+def c_compile(c_file, verbose_flag = 0, cplus = 0, obj_suffix = ".o"):
+    #  Compile the given C source file to produce
+    #  an object file. Returns the pathname of the
+    #  resulting file.
+    c_file = os.path.join(os.getcwd(), c_file)
+    o_file = replace_suffix(c_file, obj_suffix)
+    include_options = []
+    for dir in py_include_dirs:
+        include_options.append("-I%s" % dir)
+    compiler = compilers[bool(cplus)]
+    args = [compiler] + compiler_options + include_options + [c_file, "-o", o_file]
+    if verbose_flag or verbose:
+        print " ".join(args)
+    status = os.spawnvp(os.P_WAIT, compiler, args)
+    if status <> 0:
+        raise CCompilerError("C compiler returned status %s" % status)
+    return o_file
+
+def c_link(obj_file, verbose_flag = 0, extra_objects = [], cplus = 0):
+    return c_link_list([obj_file] + extra_objects, verbose_flag, cplus)
+
+def c_link_list(obj_files, verbose_flag = 0, cplus = 0):
+    #  Link the given object files into a dynamically
+    #  loadable extension file. Returns the pathname
+    #  of the resulting file.
+    out_file = replace_suffix(obj_files[0], ".so")
+    linker = linkers[bool(cplus)]
+    args = [linker] + linker_options + obj_files + ["-o", out_file]
+    if verbose_flag or verbose:
+        print " ".join(args)
+    status = os.spawnvp(os.P_WAIT, linker, args)
+    if status <> 0:
+        raise CCompilerError("Linker returned status %s" % status)
+    return out_file

Cython/Mac/MPW_Misc_Suite.py

+"""Suite Misc Suite: Suite that adds additional features to the Application.
+Level 1, version 1
+
+Generated from MPW:MPW Shell
+AETE/AEUT resource version 1/0, language 0, script 0
+"""
+
+import aetools
+import MacOS
+
+_code = 'misc'
+
+class MPW_Misc_Suite:
+
+    def DoScript(self, _object, _attributes={}, **_arguments):
+        """DoScript: Execute an MPW command, any command that could be executed from the command line can be sent as a script.
+        Required argument: The script to execute
+        Keyword argument _attributes: AppleEvent attribute dictionary
+        """
+        _code = 'misc'
+        _subcode = 'dosc'
+
+        if _arguments: raise TypeError, 'No optional args expected'
+        _arguments['----'] = _object
+
+
+        _reply, _arguments, _attributes = self.send(_code, _subcode,
+                _arguments, _attributes)
+        if _arguments.has_key('errn'):
+            raise aetools.Error, aetools.decodeerror(_arguments)
+        # XXXX Optionally decode result
+        if _arguments.has_key('----'):
+            return _arguments['----']
+
+
+#
+# Indices of types declared in this module
+#
+_classdeclarations = {
+}
+
+_propdeclarations = {
+}
+
+_compdeclarations = {
+}
+
+_enumdeclarations = {
+}

Cython/Mac/MacSystem.py

+#
+#   Pyrex -- Mac system interface
+#
+
+import os, sys, string
+import aetools
+from aetools import TalkTo
+from StdSuites.Standard_Suite import Standard_Suite_Events as Standard_Suite
+from Pyrex.Utils import replace_suffix
+from Pyrex.Compiler.Errors import PyrexError
+
+c_compiler = "MWCPPC"
+c_optimizations = "off"
+#c_linker = "PPCLink"
+c_linker = "MWLinkPPC"
+shared_lib_suffix = ".slb"
+
+#py_home = "Python2.2:Home:"
+py_home = sys.exec_prefix
+
+py_include_dirs = (
+    py_home + "Include:",
+    py_home + "Mac:Include:"
+)
+
+pythoncore = py_home + "PythonCore"
+
+mwlibdir = "MPW:Interfaces&Libraries:Libraries:MWPPCLibraries:"
+
+libraries = (
+    #mwlibdir + "'MSL C.PPC.Lib'",
+    #mwlibdir + "'MSL RuntimePPC.Lib'",
+    mwlibdir + "'MSL ShLibRuntime.Lib'",
+    mwlibdir + "InterfaceLib",
+    #mwlibdir + "MathLib",
+    )
+
+class CCompilerError(PyrexError):
+    pass
+
+#---------------- ToolServer ---------------------------
+
+from TS_Misc_Suite import TS_Misc_Suite
+
+class ToolServer(Standard_Suite, TS_Misc_Suite, TalkTo):
+    pass
+
+def send_toolserver_command(cmd):
+    ts = ToolServer('MPSX', start = 1)
+    return ts.DoScript(cmd)
+
+def do_toolserver_command(command):
+    try:
+        result = send_toolserver_command(command)
+    except aetools.Error, e:
+        raise CCompilerError("Apple Event error: %s" % e)
+    errn, stat, stdout, stderr = result
+    if errn:
+        raise CCompilerError("ToolServer error: %s" % errn)
+    stdout = string.replace(stdout, "\r", "\n")
+    stderr = string.replace(stderr, "\r", "\n")
+    if stdout:
+        #print "<<< Begin ToolServer StdOut >>>"
+        sys.stderr.write(stdout)
+        #print "<<< End ToolServer StdOut >>>"
+    if stderr:
+        #print "<<< Begin ToolServer StdErr >>>"
+        sys.stderr.write(stderr)
+        #print "<<< End ToolServer StdErr >>>"
+    return stat
+
+#-------------------------------------------------------
+
+def c_compile(c_file):
+    #  Compile the given C source file to produce
+    #  an object file. Returns the pathname of the
+    #  resulting file.
+    c_file = os.path.join(os.getcwd(), c_file)
+    #print "c_compile: c_file =", repr(c_file) ###
+    c_file_dir = os.path.dirname(c_file)
+    o_file = replace_suffix(c_file, ".o")
+    include_options = ["-i %s" % c_file_dir]
+    for dir in py_include_dirs:
+        include_options.append("-i %s" % dir)
+    command = "%s -opt %s -nomapcr -w off -r %s %s -o %s" % (
+        c_compiler, 
+        c_optimizations,
+        string.join(include_options),
+        c_file, 
+        o_file, 
+        #e_file
+        )
+    #print "...command =", repr(command) ###
+    stat = do_toolserver_command(command)
+    if stat:
+        raise CCompilerError("C compiler returned status %s" % stat)
+    return o_file
+
+def c_link(obj_file):
+    return c_link_list([obj_file])
+
+def c_link_list(obj_files):
+    #  Link the given object files into a dynamically
+    #  loadable extension file. Returns the pathname
+    #  of the resulting file.
+    out_file = replace_suffix(obj_files[0], shared_lib_suffix)
+    command = "%s -xm s -export all %s %s %s -o %s" % (
+        c_linker, 
+        string.join(obj_files), 
+        pythoncore,
+        string.join(libraries),
+        out_file)
+    stat = do_toolserver_command(command)
+    if stat:
+        raise CCompilerError("Linker returned status %s" % stat)
+    return out_file
+
+def test_c_compile(link = 0):
+    objs = []
+    for arg in sys.argv[1:]:
+        if arg.endswith(".c"):
+            try:
+                obj = c_compile(arg)
+            except PyrexError, e:
+                #print "Caught a PyrexError:" ###
+                #print repr(e) ###
+                print "%s.%s:" % (e.__class__.__module__,
+                    e.__class__.__name__), e
+                sys.exit(1)
+        else:
+            obj = arg
+        objs.append(obj)
+    if link:
+        c_link_list(objs)
+

Cython/Mac/MacUtils.py

+#
+#   Pyrex -- Misc Mac-specific things
+#
+
+import os, MacOS, macfs
+
+def open_new_file(path):
+    # On the Mac, try to preserve Finder position
+    # of previously existing file.
+    fsspec = macfs.FSSpec(path)
+    try:
+        old_finfo = fsspec.GetFInfo()
+    except MacOS.Error, e:
+        #print "MacUtils.open_new_file:", e ###
+        old_finfo = None
+    try:
+        os.unlink(path)
+    except OSError:
+        pass
+    file = open(path, "w")
+    new_finfo = fsspec.GetFInfo()
+    if old_finfo:
+        #print "MacUtils.open_new_file:", path ###
+        #print "...old file info =", old_finfo.Creator, old_finfo.Type, old_finfo.Location ###
+        #print "...new file info =", new_finfo.Creator, new_finfo.Type, new_finfo.Location ###
+        new_finfo.Location = old_finfo.Location
+        new_finfo.Flags = old_finfo.Flags
+    # Make darn sure the type and creator are right. There seems
+    # to be a bug in MacPython 2.2 that screws them up sometimes.
+    new_finfo.Creator = "R*ch"
+    new_finfo.Type = "TEXT"
+    fsspec.SetFInfo(new_finfo)
+    return file
+

Cython/Mac/PS_Misc_Suite.py

+"Apple Event suite for pyserver."
+
+import aetools
+import MacOS
+
+_code = 'misc'
+
+class PS_Misc_Suite:
+
+    def DoScript(self, _object, _attributes={}, **_arguments):
+        """DoScript: Execute a Python file, optionally with command line args.
+        Required argument: filename.py or [filename.py, arg, ...]
+        Keyword argument _attributes: AppleEvent attribute dictionary
+        """
+        _code = 'misc'
+        _subcode = 'dosc'
+
+        if _arguments: raise TypeError, 'No optional args expected'
+        _arguments['----'] = _object
+
+
+        _reply, _arguments, _attributes = self.send(_code, _subcode,
+                _arguments, _attributes)
+        if _arguments.has_key('errn'):
+            raise aetools.Error, aetools.decodeerror(_arguments)
+        # XXXX Optionally decode result
+        if _arguments.has_key('----'):
+            return _arguments['----']
+
+
+#
+# Indices of types declared in this module
+#
+_classdeclarations = {
+}
+
+_propdeclarations = {
+}
+
+_compdeclarations = {
+}
+
+_enumdeclarations = {
+}

Cython/Plex/Timing.py

+#
+#   Get time in platform-dependent way
+#
+
+import os
+from sys import platform, exit, stderr
+
+if platform == 'mac':
+  import MacOS
+  def time():
+    return MacOS.GetTicks() / 60.0
+  timekind = "real"
+elif hasattr(os, 'times'):
+  def time():
+    t = os.times()
+    return t[0] + t[1]
+  timekind = "cpu"
+else:
+  stderr.write(
+    "Don't know how to get time on platform %s\n" % repr(platform))
+  exit(1)
+