Spaces:
Runtime error
Runtime error
| //////////////////// MainFunction //////////////////// | |
| int %(main_method)s(int argc, char** argv) { | |
| int %(wmain_method)s(int argc, wchar_t **argv) { | |
| static int __Pyx_main(int argc, wchar_t **argv) { | |
| /* 754 requires that FP exceptions run in "no stop" mode by default, | |
| * and until C vendors implement C99's ways to control FP exceptions, | |
| * Python requires non-stop mode. Alas, some platforms enable FP | |
| * exceptions by default. Here we disable them. | |
| */ | |
| fp_except_t m; | |
| m = fpgetmask(); | |
| fpsetmask(m & ~FP_X_OFL); | |
| if (argc && argv) | |
| Py_SetProgramName(argv[0]); | |
| Py_Initialize(); | |
| if (argc && argv) | |
| PySys_SetArgv(argc, argv); | |
| { /* init module '%(module_name)s' as '__main__' */ | |
| PyObject* m = NULL; | |
| %(module_is_main)s = 1; | |
| init%(module_name)s(); | |
| m = PyInit_%(module_name)s(); | |
| if (!PyModule_Check(m)) { | |
| PyModuleDef *mdef = (PyModuleDef *) m; | |
| PyObject *modname = PyUnicode_FromString("__main__"); | |
| m = NULL; | |
| if (modname) { | |
| // FIXME: not currently calling PyModule_FromDefAndSpec() here because we do not have a module spec! | |
| // FIXME: not currently setting __file__, __path__, __spec__, ... | |
| m = PyModule_NewObject(modname); | |
| Py_DECREF(modname); | |
| if (m) PyModule_ExecDef(m, mdef); | |
| } | |
| } | |
| m = PyInit_%(module_name)s(); | |
| if (PyErr_Occurred()) { | |
| PyErr_Print(); /* This exits with the right code if SystemExit. */ | |
| if (Py_FlushLine()) PyErr_Clear(); | |
| return 1; | |
| } | |
| Py_XDECREF(m); | |
| } | |
| Py_Finalize(); | |
| if (Py_FinalizeEx() < 0) | |
| return 2; | |
| return 0; | |
| } | |
| static wchar_t* | |
| __Pyx_char2wchar(char* arg) | |
| { | |
| wchar_t *res; | |
| /* Some platforms have a broken implementation of | |
| * mbstowcs which does not count the characters that | |
| * would result from conversion. Use an upper bound. | |
| */ | |
| size_t argsize = strlen(arg); | |
| size_t argsize = mbstowcs(NULL, arg, 0); | |
| size_t count; | |
| unsigned char *in; | |
| wchar_t *out; | |
| mbstate_t mbs; | |
| if (argsize != (size_t)-1) { | |
| res = (wchar_t *)malloc((argsize+1)*sizeof(wchar_t)); | |
| if (!res) | |
| goto oom; | |
| count = mbstowcs(res, arg, argsize+1); | |
| if (count != (size_t)-1) { | |
| wchar_t *tmp; | |
| /* Only use the result if it contains no | |
| surrogate characters. */ | |
| for (tmp = res; *tmp != 0 && | |
| (*tmp < 0xd800 || *tmp > 0xdfff); tmp++) | |
| ; | |
| if (*tmp == 0) | |
| return res; | |
| } | |
| free(res); | |
| } | |
| /* Conversion failed. Fall back to escaping with surrogateescape. */ | |
| /* Try conversion with mbrtwoc (C99), and escape non-decodable bytes. */ | |
| /* Overallocate; as multi-byte characters are in the argument, the | |
| actual output could use less memory. */ | |
| argsize = strlen(arg) + 1; | |
| res = (wchar_t *)malloc(argsize*sizeof(wchar_t)); | |
| if (!res) goto oom; | |
| in = (unsigned char*)arg; | |
| out = res; | |
| memset(&mbs, 0, sizeof mbs); | |
| while (argsize) { | |
| size_t converted = mbrtowc(out, (char*)in, argsize, &mbs); | |
| if (converted == 0) | |
| /* Reached end of string; null char stored. */ | |
| break; | |
| if (converted == (size_t)-2) { | |
| /* Incomplete character. This should never happen, | |
| since we provide everything that we have - | |
| unless there is a bug in the C library, or I | |
| misunderstood how mbrtowc works. */ | |
| fprintf(stderr, "unexpected mbrtowc result -2\\n"); | |
| free(res); | |
| return NULL; | |
| } | |
| if (converted == (size_t)-1) { | |
| /* Conversion error. Escape as UTF-8b, and start over | |
| in the initial shift state. */ | |
| *out++ = 0xdc00 + *in++; | |
| argsize--; | |
| memset(&mbs, 0, sizeof mbs); | |
| continue; | |
| } | |
| if (*out >= 0xd800 && *out <= 0xdfff) { | |
| /* Surrogate character. Escape the original | |
| byte sequence with surrogateescape. */ | |
| argsize -= converted; | |
| while (converted--) | |
| *out++ = 0xdc00 + *in++; | |
| continue; | |
| } | |
| /* successfully converted some bytes */ | |
| in += converted; | |
| argsize -= converted; | |
| out++; | |
| } | |
| /* Cannot use C locale for escaping; manually escape as if charset | |
| is ASCII (i.e. escape all bytes > 128. This will still roundtrip | |
| correctly in the locale's charset, which must be an ASCII superset. */ | |
| res = (wchar_t *)malloc((strlen(arg)+1)*sizeof(wchar_t)); | |
| if (!res) goto oom; | |
| in = (unsigned char*)arg; | |
| out = res; | |
| while(*in) | |
| if(*in < 128) | |
| *out++ = *in++; | |
| else | |
| *out++ = 0xdc00 + *in++; | |
| *out = 0; | |
| return res; | |
| oom: | |
| fprintf(stderr, "out of memory\\n"); | |
| return NULL; | |
| } | |
| int | |
| %(main_method)s(int argc, char **argv) | |
| { | |
| if (!argc) { | |
| return __Pyx_main(0, NULL); | |
| } | |
| else { | |
| int i, res; | |
| wchar_t **argv_copy = (wchar_t **)malloc(sizeof(wchar_t*)*argc); | |
| /* We need a second copy, as Python might modify the first one. */ | |
| wchar_t **argv_copy2 = (wchar_t **)malloc(sizeof(wchar_t*)*argc); | |
| char *oldloc = strdup(setlocale(LC_ALL, NULL)); | |
| if (!argv_copy || !argv_copy2 || !oldloc) { | |
| fprintf(stderr, "out of memory\\n"); | |
| free(argv_copy); | |
| free(argv_copy2); | |
| free(oldloc); | |
| return 1; | |
| } | |
| res = 0; | |
| setlocale(LC_ALL, ""); | |
| for (i = 0; i < argc; i++) { | |
| argv_copy2[i] = argv_copy[i] = __Pyx_char2wchar(argv[i]); | |
| if (!argv_copy[i]) res = 1; /* failure, but continue to simplify cleanup */ | |
| } | |
| setlocale(LC_ALL, oldloc); | |
| free(oldloc); | |
| if (res == 0) | |
| res = __Pyx_main(argc, argv_copy); | |
| for (i = 0; i < argc; i++) { | |
| free(argv_copy2[i]); | |
| PyMem_RawFree(argv_copy2[i]); | |
| } | |
| free(argv_copy); | |
| free(argv_copy2); | |
| return res; | |
| } | |
| } | |