bin/cython_freeze

   1 #!/usr/bin/env python
   2 """
   3 Create a C file for embedding one or more Cython source files.
   4 Requires Cython 0.11.2 (or perhaps newer).
   5
   6 See Demos/freeze/README.txt for more details.
   7 """
   8
   9 import optparse
  10
  11 usage= '%prog [-o outfile] [-p] module [module ...]'
  12 description = 'Create a C file for embedding Cython modules.'
  13 p = optparse.OptionParser(usage=usage, description=description)
  14 p.add_option('-o', '--output', metavar='FILE',
  15         help='write output to FILE instead of standard output')
  16 p.add_option('-p', '--pymain', action='store_true', default=False,
  17         help='do not automatically run the first module as __main__')
  18
  19 options, args = p.parse_args()
  20
  21 if len(args) < 1:
  22     p.print_help()
  23     p.exit(1)
  24
  25 if options.output:
  26     import sys
  27     old_stdout = sys.stdout
  28     sys.stdout = open(options.output, 'w')
  29
  30 def format_modname(name):
  31     if name.endswith('.pyx'):
  32         name = name[:-4]
  33     elif name.endswith('.py'):
  34         name = name[:-3]
  35     return name.replace('.','_')
  36
  37 modules = [format_modname(x) for x in args]
  38
  39 print """\
  40 #include <Python.h>
  41 #include <locale.h>
  42 #include <stdio.h>
  43 #include <stdlib.h>
  44
  45 #ifdef __FreeBSD__
  46 #include <floatingpoint.h>
  47 #endif
  48
  49 #if PY_MAJOR_VERSION < 3
  50 # define MODINIT(name)  init ## name
  51 #else
  52 # define MODINIT(name)  PyInit_ ## name
  53 #endif
  54 """
  55
  56 for name in modules:
  57     print "PyMODINIT_FUNC MODINIT(%s) (void);" % name
  58
  59 print """
  60 static struct _inittab inittab[] = {"""
  61
  62 for name in modules:
  63     print '    {"%(name)s", MODINIT(%(name)s)},' % {'name' : name}
  64
  65 print """    {NULL, NULL}
  66 };
  67 """,
  68
  69 if not options.pymain:
  70     print "\nextern int __pyx_module_is_main_%s;" % modules[0]
  71
  72 print """
  73 #if PY_MAJOR_VERSION < 3
  74 int main(int argc, char** argv) {
  75 #elif defined(WIN32) || defined(MS_WINDOWS)
  76 int wmain(int argc, wchar_t **argv) {
  77 #else
  78 static int python_main(int argc, wchar_t **argv) {
  79 #endif
  80 """,
  81 if not options.pymain:
  82     print """\
  83     PyObject *m = NULL;
  84     int r = 0;
  85 """,
  86 print """\
  87     /* 754 requires that FP exceptions run in "no stop" mode by default,
  88      * and until C vendors implement C99's ways to control FP exceptions,
  89      * Python requires non-stop mode.  Alas, some platforms enable FP
  90      * exceptions by default.  Here we disable them.
  91      */
  92 #ifdef __FreeBSD__
  93     fp_except_t m;
  94
  95     m = fpgetmask();
  96     fpsetmask(m & ~FP_X_OFL);
  97 #endif
  98     if (PyImport_ExtendInittab(inittab)) {
  99         fprintf(stderr, "No memory\\n");
 100         exit(1);
 101     }
 102 """,
 103 if options.pymain:
 104     print """\
 105     return Py_Main(argc, argv);
 106 }
 107 """
 108 else:
 109     print """\
 110     Py_SetProgramName(argv[0]);
 111     Py_Initialize();
 112     PySys_SetArgv(argc, argv);
 113     __pyx_module_is_main_%(main)s = 1;
 114     m = PyImport_ImportModule(inittab[0].name);
 115     if (!m) {
 116         r = 1;
 117         PyErr_Print(); /* This exits with the right code if SystemExit. */
 118 #if PY_MAJOR_VERSION < 3
 119         if (Py_FlushLine())
 120             PyErr_Clear();
 121 #endif
 122     }
 123     Py_XDECREF(m);
 124     Py_Finalize();
 125     return r;
 126 }
 127 """ % {'main' : modules[0]},
 128
 129 print r"""
 130 #if PY_MAJOR_VERSION >= 3 && !defined(WIN32) && !defined(MS_WINDOWS)
 131 static wchar_t*
 132 char2wchar(char* arg)
 133 {
 134         wchar_t *res;
 135 #ifdef HAVE_BROKEN_MBSTOWCS
 136         /* Some platforms have a broken implementation of
 137          * mbstowcs which does not count the characters that
 138          * would result from conversion.  Use an upper bound.
 139          */
 140         size_t argsize = strlen(arg);
 141 #else
 142         size_t argsize = mbstowcs(NULL, arg, 0);
 143 #endif
 144         size_t count;
 145         unsigned char *in;
 146         wchar_t *out;
 147 #ifdef HAVE_MBRTOWC
 148         mbstate_t mbs;
 149 #endif
 150         if (argsize != (size_t)-1) {
 151                 res = (wchar_t *)malloc((argsize+1)*sizeof(wchar_t));
 152                 if (!res)
 153                         goto oom;
 154                 count = mbstowcs(res, arg, argsize+1);
 155                 if (count != (size_t)-1) {
 156                         wchar_t *tmp;
 157                         /* Only use the result if it contains no
 158                            surrogate characters. */
 159                         for (tmp = res; *tmp != 0 &&
 160                                      (*tmp < 0xd800 || *tmp > 0xdfff); tmp++)
 161                                 ;
 162                         if (*tmp == 0)
 163                                 return res;
 164                 }
 165                 free(res);
 166         }
 167         /* Conversion failed. Fall back to escaping with surrogateescape. */
 168 #ifdef HAVE_MBRTOWC
 169         /* Try conversion with mbrtwoc (C99), and escape non-decodable bytes. */
 170
 171         /* Overallocate; as multi-byte characters are in the argument, the
 172            actual output could use less memory. */
 173         argsize = strlen(arg) + 1;
 174         res = malloc(argsize*sizeof(wchar_t));
 175         if (!res) goto oom;
 176         in = (unsigned char*)arg;
 177         out = res;
 178         memset(&mbs, 0, sizeof mbs);
 179         while (argsize) {
 180                 size_t converted = mbrtowc(out, (char*)in, argsize, &mbs);
 181                 if (converted == 0)
 182                         /* Reached end of string; null char stored. */
 183                         break;
 184                 if (converted == (size_t)-2) {
 185                         /* Incomplete character. This should never happen,
 186                            since we provide everything that we have -
 187                            unless there is a bug in the C library, or I
 188                            misunderstood how mbrtowc works. */
 189                         fprintf(stderr, "unexpected mbrtowc result -2\n");
 190                         return NULL;
 191                 }
 192                 if (converted == (size_t)-1) {
 193                         /* Conversion error. Escape as UTF-8b, and start over
 194                            in the initial shift state. */
 195                         *out++ = 0xdc00 + *in++;
 196                         argsize--;
 197                         memset(&mbs, 0, sizeof mbs);
 198                         continue;
 199                 }
 200                 if (*out >= 0xd800 && *out <= 0xdfff) {
 201                         /* Surrogate character.  Escape the original
 202                            byte sequence with surrogateescape. */
 203                         argsize -= converted;
 204                         while (converted--)
 205                                 *out++ = 0xdc00 + *in++;
 206                         continue;
 207                 }
 208                 /* successfully converted some bytes */
 209                 in += converted;
 210                 argsize -= converted;
 211                 out++;
 212         }
 213 #else
 214         /* Cannot use C locale for escaping; manually escape as if charset
 215            is ASCII (i.e. escape all bytes > 128. This will still roundtrip
 216            correctly in the locale's charset, which must be an ASCII superset. */
 217         res = malloc((strlen(arg)+1)*sizeof(wchar_t));
 218         if (!res) goto oom;
 219         in = (unsigned char*)arg;
 220         out = res;
 221         while(*in)
 222                 if(*in < 128)
 223                         *out++ = *in++;
 224                 else
 225                         *out++ = 0xdc00 + *in++;
 226         *out = 0;
 227 #endif
 228         return res;
 229 oom:
 230         fprintf(stderr, "out of memory\n");
 231         return NULL;
 232 }
 233
 234 int
 235 main(int argc, char **argv)
 236 {
 237         wchar_t **argv_copy = (wchar_t **)malloc(sizeof(wchar_t*)*argc);
 238         /* We need a second copies, as Python might modify the first one. */
 239         wchar_t **argv_copy2 = (wchar_t **)malloc(sizeof(wchar_t*)*argc);
 240         int i, res;
 241         char *oldloc;
 242         if (!argv_copy || !argv_copy2) {
 243                 fprintf(stderr, "out of memory\n");
 244                 return 1;
 245         }
 246         oldloc = strdup(setlocale(LC_ALL, NULL));
 247         setlocale(LC_ALL, "");
 248         for (i = 0; i < argc; i++) {
 249                 argv_copy2[i] = argv_copy[i] = char2wchar(argv[i]);
 250                 if (!argv_copy[i])
 251                         return 1;
 252         }
 253         setlocale(LC_ALL, oldloc);
 254         free(oldloc);
 255         res = python_main(argc, argv_copy);
 256         for (i = 0; i < argc; i++) {
 257                 free(argv_copy2[i]);
 258         }
 259         free(argv_copy);
 260         free(argv_copy2);
 261         return res;
 262 }
 263 #endif"""