def cythonize_one(pyx_file, c_file, fingerprint, quiet, options=None):
from Cython.Compiler.Main import compile, default_options
from Cython.Compiler.Errors import CompileError, PyrexError
if fingerprint:
if not os.path.exists(options.cache):
try:
os.mkdir(options.cache)
except:
if not os.path.exists(options.cache):
raise
# Cython-generated c files are highly compressible.
# (E.g. a compression ratio of about 10 for Sage).
fingerprint_file = os.path.join(
options.cache, fingerprint + '-' + os.path.basename(c_file) + '.gz')
if os.path.exists(fingerprint_file):
if not quiet:
print("Found compiled %s in cache" % pyx_file)
os.utime(fingerprint_file, None)
open(c_file, 'wb').write(gzip.open(fingerprint_file).read())
return
if not quiet:
print("Cythonizing %s" % pyx_file)
if options is None:
options = CompilationOptions(default_options)
options.output_file = c_file
any_failures = 0
try:
result = compile([pyx_file], options)
if result.num_errors > 0:
any_failures = 1
except (EnvironmentError, PyrexError), e:
sys.stderr.write('%s\n' % e)
any_failures = 1
def cythonize(source, includes=(),
output_h=os.curdir):
name, ext = os.path.splitext(source)
output_c = name + '.c'
#
from Cython.Compiler.Main import \
CompilationOptions, default_options, \
compile, \
PyrexError
#
options = CompilationOptions(default_options)
options.output_file = output_c
options.include_path = includes
#
from Cython.Compiler import Options
Options.generate_cleanup_code = 3
#
any_failures = 0
try:
result = compile(source, options)
if result.num_errors > 0:
any_failures = 1
except (EnvironmentError, PyrexError), e:
sys.stderr.write(str(e) + '\n')
any_failures = 1
def run_cython(cython_file, c_file):
assert have_cython
msg('Cythonizing %s -> %s', cython_file, c_file)
options = CythonCompilationOptions(cython_default_options)
options.output_file = c_file
try:
result = cython_compile([cython_file], options)
except (EnvironmentError, PyrexError), e:
error_msg(str(e))
def cythonize(source,
includes=(),
destdir_c=None,
destdir_h=None,
wdir=None):
from Cython.Compiler.Main import \
CompilationOptions, default_options, \
compile, \
PyrexError
from Cython.Compiler import Options
cwd = os.getcwd()
try:
name, ext = os.path.splitext(source)
outputs_c = [name+'.c']
outputs_h = [name+'.h', name+'_api.h']
# change working directory
if wdir:
os.chdir(wdir)
# run Cython on source
options = CompilationOptions(default_options)
options.output_file = outputs_c[0]
options.include_path = list(includes)
Options.generate_cleanup_code = 3
any_failures = 0
try:
result = compile(source, options)
if result.num_errors > 0:
any_failures = 1
except (EnvironmentError, PyrexError):
e = sys.exc_info()[1]
sys.stderr.write(str(e) + '\n')
any_failures = 1
if any_failures:
for output in outputs_c + outputs_h:
try:
os.remove(output)
except OSError:
pass
return 1
# move ouputs
for destdir, outputs in (
(destdir_c, outputs_c),
(destdir_h, outputs_h)):
if destdir is None: continue
for output in outputs:
dest = os.path.join(
destdir, os.path.basename(output))
try:
os.remove(dest)
except OSError:
pass
os.rename(output, dest)
#
return 0
#
finally:
os.chdir(cwd)
def cythonize(source,
includes=(),
destdir_c=None,
destdir_h=None,
wdir=None):
from Cython.Compiler.Main import \
CompilationOptions, default_options, \
compile, \
PyrexError
from Cython.Compiler import Options
cwd = os.getcwd()
try:
name, ext = os.path.splitext(source)
outputs_c = [name+'.c']
outputs_h = [name+'.h', name+'_api.h']
# change working directory
if wdir:
os.chdir(wdir)
# run Cython on source
options = CompilationOptions(default_options)
options.output_file = outputs_c[0]
options.include_path = list(includes)
Options.generate_cleanup_code = 3
any_failures = 0
try:
result = compile(source, options)
if result.num_errors > 0:
any_failures = 1
except (EnvironmentError, PyrexError):
e = sys.exc_info()[1]
sys.stderr.write(str(e) + '\n')
any_failures = 1
if any_failures:
for output in outputs_c + outputs_h:
try:
os.remove(output)
except OSError:
pass
return 1
# move ouputs
for destdir, outputs in (
(destdir_c, outputs_c),
(destdir_h, outputs_h)):
if destdir is None: continue
for output in outputs:
dest = os.path.join(
destdir, os.path.basename(output))
try:
os.remove(dest)
except OSError:
pass
os.rename(output, dest)
#
return 0
#
finally:
os.chdir(cwd)
def run_cython(cython_file, c_file):
assert have_cython
msg('Cythonizing %s -> %s', cython_file, c_file)
options = CythonCompilationOptions(cython_default_options)
options.output_file = c_file
try:
result = cython_compile([cython_file], options)
except (EnvironmentError, PyrexError), e:
error_msg(str(e))
def gen_mpyrandom(ext, build_dir):
from Cython.Compiler.Main import compile_single, CompilationOptions, default_options
target = join(build_dir, 'mpyrandom.c')
src = join('micpy', 'random', 'mpyrandom.pyx')
header = join('micpy', 'random', 'mpyrandom.pxd')
if newer(src, target) or newer(header, target):
# create target file
options = CompilationOptions(default_options)
options.output_file = target
result = compile_single(src, options)
return target
def cythonize_one(pyx_file,
c_file,
fingerprint,
quiet,
options=None,
raise_on_failure=True):
from Cython.Compiler.Main import compile, default_options
from Cython.Compiler.Errors import CompileError, PyrexError
if fingerprint:
if not os.path.exists(options.cache):
try:
os.mkdir(options.cache)
except:
if not os.path.exists(options.cache):
raise
# Cython-generated c files are highly compressible.
# (E.g. a compression ratio of about 10 for Sage).
fingerprint_file = join_path(
options.cache,
"%s-%s%s" % (os.path.basename(c_file), fingerprint, gzip_ext))
if os.path.exists(fingerprint_file):
if not quiet:
print("Found compiled %s in cache" % pyx_file)
os.utime(fingerprint_file, None)
g = gzip_open(fingerprint_file, 'rb')
try:
f = open(c_file, 'wb')
try:
shutil.copyfileobj(g, f)
finally:
f.close()
finally:
g.close()
return
if not quiet:
print("Cythonizing %s" % pyx_file)
if options is None:
options = CompilationOptions(default_options)
options.output_file = c_file
any_failures = 0
try:
result = compile([pyx_file], options)
if result.num_errors > 0:
any_failures = 1
except (EnvironmentError, PyrexError), e:
sys.stderr.write('%s\n' % e)
any_failures = 1
# XXX
import traceback
traceback.print_exc()
def cythonize(source, output=None, includes=(), workdir=None):
import cyautodoc
from Cython.Compiler import Options
from Cython.Compiler.Main import (
CompilationOptions,
default_options,
compile,
PyrexError,
)
cwd = os.getcwd()
try:
# compute output filenames
if output is None:
name, _ = os.path.splitext(source)
output = name + '.c'
else:
name, _ = os.path.splitext(output)
outputs_c = [output]
outputs_h = [name + '.h', name + '_api.h']
# run Cython on source
options = CompilationOptions(default_options)
lang_level = Options.directive_types.get('language_level', int)
options.language_level = lang_level(3)
options.output_file = output
options.include_path = list(includes)
options.working_path = workdir or ""
Options.generate_cleanup_code = 3
any_failures = 0
try:
if options.working_path:
os.chdir(options.working_path)
result = compile(source, options)
if result.num_errors > 0:
any_failures = 1
except (EnvironmentError, PyrexError) as e:
sys.stderr.write(str(e) + '\n')
any_failures = 1
if any_failures:
for out in outputs_c + outputs_h:
try:
os.remove(out)
except OSError:
pass
return 1
return 0
#
finally:
os.chdir(cwd)
def cythonize_one(pyx_file, c_file, options=None):
from Cython.Compiler.Main import compile, default_options
from Cython.Compiler.Errors import CompileError, PyrexError
if options is None:
options = CompilationOptions(default_options)
options.output_file = c_file
any_failures = 0
try:
result = compile([pyx_file], options)
if result.num_errors > 0:
any_failures = 1
except (EnvironmentError, PyrexError), e:
sys.stderr.write(str(e) + '\n')
any_failures = 1
def cythonize_one(pyx_file, c_file, options=None):
from Cython.Compiler.Main import compile, default_options
from Cython.Compiler.Errors import CompileError, PyrexError
if options is None:
options = CompilationOptions(default_options)
options.output_file = c_file
any_failures = 0
try:
result = compile([pyx_file], options)
if result.num_errors > 0:
any_failures = 1
except (EnvironmentError, PyrexError), e:
sys.stderr.write(str(e) + '\n')
any_failures = 1
def cythonize_one(pyx_file, c_file, fingerprint, quiet, options=None, raise_on_failure=True):
from Cython.Compiler.Main import compile, default_options
from Cython.Compiler.Errors import CompileError, PyrexError
if fingerprint:
if not os.path.exists(options.cache):
try:
os.mkdir(options.cache)
except:
if not os.path.exists(options.cache):
raise
# Cython-generated c files are highly compressible.
# (E.g. a compression ratio of about 10 for Sage).
fingerprint_file = join_path(
options.cache, "%s-%s%s" % (os.path.basename(c_file), fingerprint, gzip_ext))
if os.path.exists(fingerprint_file):
if not quiet:
print("Found compiled %s in cache" % pyx_file)
os.utime(fingerprint_file, None)
g = gzip_open(fingerprint_file, 'rb')
try:
f = open(c_file, 'wb')
try:
shutil.copyfileobj(g, f)
finally:
f.close()
finally:
g.close()
return
if not quiet:
print("Cythonizing %s" % pyx_file)
if options is None:
options = CompilationOptions(default_options)
options.output_file = c_file
any_failures = 0
try:
result = compile([pyx_file], options)
if result.num_errors > 0:
any_failures = 1
except (EnvironmentError, PyrexError), e:
sys.stderr.write('%s\n' % e)
any_failures = 1
# XXX
import traceback
traceback.print_exc()
def cythonize():
try:
from Cython.Compiler.Main import CompilationOptions, default_options, \
compile, PyrexError
from Cython.Compiler import Options
import subprocess
for code in cythoncodes:
source = code[0] + '.pyx'
options = CompilationOptions(default_options)
options.output_file = code[0] + '.c'
options.include_path = code[1]
Options.generate_cleanup_code = 3
any_failures = False
try:
result = compile(source, options)
if result.num_errors > 0:
any_failures = True
if not any_failures:
callist = [
cythcompiler, '-shared', '-fwrapv', '-Wall',
'-fno-strict-aliasing'
]
for x in CFLAGS:
callist.append(x)
for x in code[1]:
callist.append('-L' + x)
callist.append('-o')
callist.append('_' + code[0] + '.so')
callist.append(code[0] + '.c')
subprocess.call(callist)
except (EnvironmentError, PyrexError):
e = sys.exc_info()[1]
sys.stderr.write(str(e) + '\n')
any_failures = True
if any_failures:
try:
os.remove(code[0] + '.c')
except OSError:
pass
except:
raise ValueError
def cythonize():
try:
from Cython.Compiler.Main import CompilationOptions, default_options, \
compile, PyrexError
from Cython.Compiler import Options
import subprocess
for code in cythoncodes:
source = code[0] + '.pyx'
options = CompilationOptions(default_options)
options.output_file = code[0] + '.c'
options.include_path = code[1]
Options.generate_cleanup_code = 3
any_failures = False
try:
result = compile(source, options)
if result.num_errors > 0:
any_failures = True
if not any_failures:
callist = [cythcompiler,'-shared','-fwrapv','-Wall','-fno-strict-aliasing']
for x in CFLAGS:
callist.append(x)
for x in code[1]:
callist.append('-L' + x)
callist.append('-o')
callist.append('_' + code[0] + '.so')
callist.append(code[0] + '.c')
subprocess.call(callist)
except (EnvironmentError, PyrexError):
e = sys.exc_info()[1]
sys.stderr.write(str(e) + '\n')
any_failures = True
if any_failures:
try: os.remove(code[0] + '.c')
except OSError: pass
except:
raise ValueError
def cythonize(source, includes=(), output_h=os.curdir):
name, ext = os.path.splitext(source)
output_c = name + '.c'
#
from Cython.Compiler.Main import \
CompilationOptions, default_options, \
compile, \
PyrexError
#
options = CompilationOptions(default_options)
options.output_file = output_c
options.include_path = includes
#
from Cython.Compiler import Options
Options.generate_cleanup_code = 3
#
any_failures = 0
try:
result = compile(source, options)
if result.num_errors > 0:
any_failures = 1
except (EnvironmentError, PyrexError), e:
sys.stderr.write(str(e) + '\n')
any_failures = 1
def godopy_cython():
source, outfile_path = sys.argv[1:]
pyinit_src_symbol = 'PyInit_' + os.path.basename(outfile_path[:-4])
pyinit_dst_symbol = 'PyInit_' + strip_internal_path(outfile_path).replace(
os.sep, '__')[:-4]
tempfile = outfile_path.replace('.cpp', '.temp.cpp')
tempheaderfile = outfile_path.replace('.cpp', '.temp.h')
header_path = outfile_path.replace('.cpp', '.hpp')
from Cython.Compiler import Options
from Cython.Compiler.Main import compile, default_options, CompilationOptions
directives = {'c_string_encoding': 'utf-8'}
options = CompilationOptions(default_options,
compiler_directives=directives)
Options.fast_fail = True
options.output_file = tempfile
options.cplus = 1
options.language_level = 3
result = compile(source, options)
if result.num_errors > 0:
raise SystemExit('Cython compilation finished with errors')
def clean_line(line):
if pyinit_src_symbol in line:
line = line.replace(pyinit_src_symbol, pyinit_dst_symbol)
# Undefined by #define NO_IMPORT_ARRAY
if '_import_array()' in line:
line = line.replace('_import_array()', '0')
# Fix variable declarations with GDCALLINGCONV, GDCALLINGCONV is valid only for functions
if line.lstrip().startswith('GDCALLINGCONV_'):
line = re.sub(r'^(\s+)(GDCALLINGCONV_VOID_PTR)(\s\w+;)$',
r'\1void *\3', line)
line = re.sub(r'^(\s+)(GDCALLINGCONV_VOID)(\s\w+;)$', r'\1void\3',
line)
line = re.sub(r'^(\s+)(GDCALLINGCONV_BOOL)(\s\w+;)$', r'\1bool\3',
line)
# Remove "tp_print" deprecation warnings
if line.strip(
) == '#if PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000':
line = line.replace(
'PY_VERSION_HEX >= 0x030800b4 && PY_VERSION_HEX < 0x03090000',
'PY_VERSION_HEX < 0x030800b1')
# FIXME: undeclared identifier, looks like a bug in Cython
if line.strip() == '__Pyx_CppExn2PyErr();':
line = ''
return line
with open(outfile_path, 'w', encoding='utf-8') as outfile:
with open(tempfile, 'r', encoding='utf-8') as fp:
for line in fp:
outfile.write(clean_line(line))
os.unlink(tempfile)
if os.path.exists(tempheaderfile):
with open(header_path, 'w', encoding='utf-8') as outheaderfile:
with open(tempheaderfile, 'r', encoding='utf-8') as fp:
for line in fp:
outheaderfile.write(clean_line(line))
os.unlink(tempheaderfile)
def parse_command_line(args):
from Cython.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 ("-+", "--cplus"):
options.cplus = 1
elif option.startswith("--embed"):
ix = option.find('=')
if ix == -1:
Options.embed = "main"
else:
Options.embed = option[ix+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 ("-w", "--working"):
options.working_path = pop_arg()
elif option in ("-o", "--output-file"):
options.output_file = pop_arg()
elif option in ("-r", "--recursive"):
options.recursive = 1
elif option in ("-t", "--timestamps"):
options.timestamps = 1
elif option in ("-f", "--force"):
options.timestamps = 0
elif option in ("-v", "--verbose"):
options.verbose += 1
elif option in ("-p", "--embed-positions"):
Options.embed_pos_in_docstring = 1
elif option in ("-z", "--pre-import"):
Options.pre_import = pop_arg()
elif option == "--cleanup":
Options.generate_cleanup_code = int(pop_arg())
elif option in ("-D", "--no-docstrings"):
Options.docstrings = False
elif option in ("-a", "--annotate"):
Options.annotate = True
elif option == "--convert-range":
Options.convert_range = True
elif option == "--line-directives":
options.emit_linenums = True
elif option == "--no-c-in-traceback":
options.c_line_in_traceback = False
elif option == "--gdb":
options.gdb_debug = True
options.output_dir = os.curdir
elif option == '-2':
options.language_level = 2
elif option == '-3':
options.language_level = 3
elif option == "--fast-fail":
Options.fast_fail = True
elif option in ('-Werror', '--warning-errors'):
Options.warning_errors = True
elif option == "--disable-function-redefinition":
Options.disable_function_redefinition = True
elif option == "--directive" or option.startswith('-X'):
if option.startswith('-X') and option[2:].strip():
x_args = option[2:]
else:
x_args = pop_arg()
try:
options.compiler_directives = Options.parse_directive_list(
x_args, relaxed_bool=True,
current_settings=options.compiler_directives)
except ValueError, e:
sys.stderr.write("Error in compiler directive: %s\n" % e.args[0])
sys.exit(1)
elif option.startswith('--debug'):
option = option[2:].replace('-', '_')
import DebugFlags
if option in dir(DebugFlags):
setattr(DebugFlags, option, True)
else:
sys.stderr.write("Unknown debug flag: %s\n" % option)
bad_usage()
elif option in ('-h', '--help'):
sys.stdout.write(usage)
sys.exit(0)
else:
sys.stderr.write("Unknown compiler flag: %s\n" % option)
sys.exit(1)
else:
arg = pop_arg()
if arg.endswith(".pyx"):
sources.append(arg)
elif arg.endswith(".py"):
# maybe do some other stuff, but this should work for now
sources.append(arg)
else:
sys.stderr.write(
"cython: %s: Unknown filename suffix\n" % arg)
def parse_command_line(args):
from Cython.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 ("-w", "--working"):
options.working_path = pop_arg()
elif option in ("-o", "--output-file"):
options.output_file = pop_arg()
elif option in ("-r", "--recursive"):
options.recursive = 1
elif option in ("-t", "--timestamps"):
options.timestamps = 1
elif option in ("-f", "--force"):
options.timestamps = 0
elif option in ("-v", "--verbose"):
options.verbose += 1
elif option in ("-p", "--embed-positions"):
Options.embed_pos_in_docstring = 1
elif option in ("-z", "--pre-import"):
Options.pre_import = pop_arg()
elif option == "--incref-local-binop":
Options.incref_local_binop = 1
elif option == "--cleanup":
Options.generate_cleanup_code = int(pop_arg())
elif option in ("-D", "--no-docstrings"):
Options.docstrings = False
elif option in ("-a", "--annotate"):
Options.annotate = True
elif option == "--convert-range":
Options.convert_range = True
elif option == "--line-directives":
options.emit_linenums = True
elif option in ("-X", "--directive"):
try:
options.pragma_overrides = Options.parse_option_list(pop_arg())
except ValueError, e:
sys.stderr.write("Error in compiler directive: %s\n" % e.message)
sys.exit(1)
else:
bad_usage()
else:
arg = pop_arg()
if arg.endswith(".pyx"):
sources.append(arg)
elif arg.endswith(".py"):
# maybe do some other stuff, but this should work for now
sources.append(arg)
elif arg.endswith(".o"):
options.objects.append(arg)
else:
sys.stderr.write(
"cython: %s: Unknown filename suffix\n" % arg)
def parse_command_line(args):
from Cython.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 ("-+", "--cplus"):
options.cplus = 1
elif option == "--embed":
Options.embed = "main"
elif option.startswith("--embed="):
Options.embed = option[8:]
elif option.startswith("-I"):
options.include_path.append(get_param(option))
elif option == "--include-dir":
options.include_path.append(pop_arg())
elif option in ("-w", "--working"):
options.working_path = pop_arg()
elif option in ("-o", "--output-file"):
options.output_file = pop_arg()
elif option in ("-t", "--timestamps"):
options.timestamps = 1
elif option in ("-f", "--force"):
options.timestamps = 0
elif option in ("-v", "--verbose"):
options.verbose += 1
elif option in ("-p", "--embed-positions"):
Options.embed_pos_in_docstring = 1
elif option in ("-z", "--pre-import"):
Options.pre_import = pop_arg()
elif option == "--cleanup":
Options.generate_cleanup_code = int(pop_arg())
elif option in ("-D", "--no-docstrings"):
Options.docstrings = False
elif option in ("-a", "--annotate"):
Options.annotate = True
elif option == "--convert-range":
Options.convert_range = True
elif option == "--line-directives":
options.emit_linenums = True
elif option == "--no-c-in-traceback":
options.c_line_in_traceback = False
elif option == "--gdb":
options.gdb_debug = True
options.output_dir = os.curdir
elif option == "--gdb-outdir":
options.gdb_debug = True
options.output_dir = pop_arg()
elif option == "--lenient":
Options.error_on_unknown_names = False
Options.error_on_uninitialized = False
elif option == '-2':
options.language_level = 2
elif option == '-3':
options.language_level = 3
elif option == "--capi-reexport-cincludes":
options.capi_reexport_cincludes = True
elif option == "--fast-fail":
Options.fast_fail = True
elif option in ('-Werror', '--warning-errors'):
Options.warning_errors = True
elif option in ('-Wextra', '--warning-extra'):
options.compiler_directives.update(Options.extra_warnings)
elif option == "--old-style-globals":
Options.old_style_globals = True
elif option == "--directive" or option.startswith('-X'):
if option.startswith('-X') and option[2:].strip():
x_args = option[2:]
else:
x_args = pop_arg()
try:
options.compiler_directives = Options.parse_directive_list(
x_args, relaxed_bool=True,
current_settings=options.compiler_directives)
except ValueError as e:
sys.stderr.write("Error in compiler directive: %s\n" % e.args[0])
sys.exit(1)
elif option.startswith('--debug'):
option = option[2:].replace('-', '_')
from . import DebugFlags
if option in dir(DebugFlags):
setattr(DebugFlags, option, True)
else:
sys.stderr.write("Unknown debug flag: %s\n" % option)
bad_usage()
elif option in ('-h', '--help'):
sys.stdout.write(usage)
sys.exit(0)
else:
sys.stderr.write("Unknown compiler flag: %s\n" % option)
sys.exit(1)
else:
sources.append(pop_arg())
if options.use_listing_file and len(sources) > 1:
sys.stderr.write(
"cython: Only one source file allowed when using -o\n")
sys.exit(1)
if len(sources) == 0 and not options.show_version:
bad_usage()
if Options.embed and len(sources) > 1:
sys.stderr.write(
"cython: Only one source file allowed when using -embed\n")
sys.exit(1)
return options, sources
def parse_command_line(args):
def parse_add_transform(transforms, param):
def import_symbol(fqn):
modsplitpt = fqn.rfind(".")
if modsplitpt == -1: bad_usage()
modulename = fqn[:modsplitpt]
symbolname = fqn[modsplitpt+1:]
module = __import__(modulename, globals(), locals(), [symbolname])
return getattr(module, symbolname)
stagename, factoryname = param.split(":")
if not stagename in Transform.PHASES:
bad_usage()
factory = import_symbol(factoryname)
transform = factory()
transforms[stagename].append(transform)
from Cython.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()
elif option in ("-p", "--embed-positions"):
Options.embed_pos_in_docstring = 1
elif option in ("-z", "--pre-import"):
Options.pre_import = pop_arg()
elif option == "--incref-local-binop":
Options.incref_local_binop = 1
elif option == "--cleanup":
Options.generate_cleanup_code = int(pop_arg())
elif option in ("-D", "--no-docstrings"):
Options.docstrings = False
elif option in ("-a", "--annotate"):
Options.annotate = True
elif option == "--convert-range":
Options.convert_range = True
elif option.startswith("-T"):
parse_add_transform(options.transforms, get_param(option))
# Note: this can occur multiple times, each time appends
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, \
"cython: %s: Unknown filename suffix" % arg
if options.objects and len(sources) > 1:
print >>sys.stderr, \
"cython: Only one source file allowed together with .o files"
if options.use_listing_file and len(sources) > 1:
print >>sys.stderr, \
"cython: Only one source file allowed when using -o"
sys.exit(1)
if len(sources) == 0 and not options.show_version:
bad_usage()
return options, sources
