python-3.6.zip added from Github

README.cosmo contains the necessary links.

third_party/python/Programs/README

@@ -0,0 +1 @@
+Source files for binary executables (as opposed to shared modules)

third_party/python/Programs/_freeze_importlib.c

@@ -0,0 +1,155 @@
+/* This is built as a stand-alone executable by the Makefile, and helps turn
+   Lib/importlib/_bootstrap.py into a frozen module in Python/importlib.h
+*/
+
+#include <Python.h>
+#include <marshal.h>
+
+#include <stdio.h>
+#include <sys/types.h>
+#include <sys/stat.h>
+#ifndef MS_WINDOWS
+#include <unistd.h>
+#endif
+
+/* To avoid a circular dependency on frozen.o, we create our own structure
+   of frozen modules instead, left deliberately blank so as to avoid
+   unintentional import of a stale version of _frozen_importlib. */
+
+static const struct _frozen _PyImport_FrozenModules[] = {
+    {0, 0, 0} /* sentinel */
+};
+
+#ifndef MS_WINDOWS
+/* On Windows, this links with the regular pythonXY.dll, so this variable comes
+   from frozen.obj. In the Makefile, frozen.o is not linked into this executable,
+   so we define the variable here. */
+const struct _frozen *PyImport_FrozenModules;
+#endif
+
+const char header[] = "/* Auto-generated by Programs/_freeze_importlib.c */";
+
+int
+main(int argc, char *argv[])
+{
+    char *inpath, *outpath, *code_name;
+    FILE *infile = NULL, *outfile = NULL;
+    struct _Py_stat_struct status;
+    size_t text_size, data_size, n;
+    char *text = NULL;
+    unsigned char *data;
+    PyObject *code = NULL, *marshalled = NULL;
+    int is_bootstrap = 1;
+
+    PyImport_FrozenModules = _PyImport_FrozenModules;
+
+    if (argc != 3) {
+        fprintf(stderr, "need to specify input and output paths\n");
+        return 2;
+    }
+    inpath = argv[1];
+    outpath = argv[2];
+    infile = fopen(inpath, "rb");
+    if (infile == NULL) {
+        fprintf(stderr, "cannot open '%s' for reading\n", inpath);
+        goto error;
+    }
+    if (_Py_fstat_noraise(fileno(infile), &status)) {
+        fprintf(stderr, "cannot fstat '%s'\n", inpath);
+        goto error;
+    }
+    text_size = (size_t)status.st_size;
+    text = (char *) malloc(text_size + 1);
+    if (text == NULL) {
+        fprintf(stderr, "could not allocate %ld bytes\n", (long) text_size);
+        goto error;
+    }
+    n = fread(text, 1, text_size, infile);
+    fclose(infile);
+    infile = NULL;
+    if (n < text_size) {
+        fprintf(stderr, "read too short: got %ld instead of %ld bytes\n",
+                (long) n, (long) text_size);
+        goto error;
+    }
+    text[text_size] = '\0';
+
+    Py_NoUserSiteDirectory++;
+    Py_NoSiteFlag++;
+    Py_IgnoreEnvironmentFlag++;
+    Py_FrozenFlag++;
+
+    Py_SetProgramName(L"./_freeze_importlib");
+    /* Don't install importlib, since it could execute outdated bytecode. */
+    _Py_InitializeEx_Private(1, 0);
+
+    if (strstr(inpath, "_external") != NULL) {
+        is_bootstrap = 0;
+    }
+
+    code_name = is_bootstrap ?
+        "<frozen importlib._bootstrap>" :
+        "<frozen importlib._bootstrap_external>";
+    code = Py_CompileStringExFlags(text, code_name, Py_file_input, NULL, 0);
+    if (code == NULL)
+        goto error;
+    free(text);
+    text = NULL;
+
+    marshalled = PyMarshal_WriteObjectToString(code, Py_MARSHAL_VERSION);
+    Py_CLEAR(code);
+    if (marshalled == NULL)
+        goto error;
+
+    assert(PyBytes_CheckExact(marshalled));
+    data = (unsigned char *) PyBytes_AS_STRING(marshalled);
+    data_size = PyBytes_GET_SIZE(marshalled);
+
+    /* Open the file in text mode. The hg checkout should be using the eol extension,
+       which in turn should cause the EOL style match the C library's text mode */
+    outfile = fopen(outpath, "w");
+    if (outfile == NULL) {
+        fprintf(stderr, "cannot open '%s' for writing\n", outpath);
+        goto error;
+    }
+    fprintf(outfile, "%s\n", header);
+    if (is_bootstrap)
+        fprintf(outfile, "const unsigned char _Py_M__importlib[] = {\n");
+    else
+        fprintf(outfile,
+                "const unsigned char _Py_M__importlib_external[] = {\n");
+    for (n = 0; n < data_size; n += 16) {
+        size_t i, end = Py_MIN(n + 16, data_size);
+        fprintf(outfile, "    ");
+        for (i = n; i < end; i++) {
+            fprintf(outfile, "%d,", (unsigned int) data[i]);
+        }
+        fprintf(outfile, "\n");
+    }
+    fprintf(outfile, "};\n");
+
+    Py_CLEAR(marshalled);
+
+    Py_Finalize();
+    if (outfile) {
+        if (ferror(outfile)) {
+            fprintf(stderr, "error when writing to '%s'\n", outpath);
+            goto error;
+        }
+        fclose(outfile);
+    }
+    return 0;
+
+error:
+    PyErr_Print();
+    Py_Finalize();
+    if (infile)
+        fclose(infile);
+    if (outfile)
+        fclose(outfile);
+    if (text)
+        free(text);
+    if (marshalled)
+        Py_DECREF(marshalled);
+    return 1;
+}

third_party/python/Programs/_testembed.c

@@ -0,0 +1,198 @@
+#include <Python.h>
+#include "pythread.h"
+#include <stdio.h>
+
+/*********************************************************
+ * Embedded interpreter tests that need a custom exe
+ *
+ * Executed via 'EmbeddingTests' in Lib/test/test_capi.py
+ *********************************************************/
+
+static void _testembed_Py_Initialize(void)
+{
+    /* HACK: the "./" at front avoids a search along the PATH in
+       Modules/getpath.c */
+    Py_SetProgramName(L"./_testembed");
+    Py_Initialize();
+}
+
+
+/*****************************************************
+ * Test repeated initialisation and subinterpreters
+ *****************************************************/
+
+static void print_subinterp(void)
+{
+    /* Just output some debug stuff */
+    PyThreadState *ts = PyThreadState_Get();
+    printf("interp %p, thread state %p: ", ts->interp, ts);
+    fflush(stdout);
+    PyRun_SimpleString(
+        "import sys;"
+        "print('id(modules) =', id(sys.modules));"
+        "sys.stdout.flush()"
+    );
+}
+
+static int test_repeated_init_and_subinterpreters(void)
+{
+    PyThreadState *mainstate, *substate;
+#ifdef WITH_THREAD
+    PyGILState_STATE gilstate;
+#endif
+    int i, j;
+
+    for (i=0; i<15; i++) {
+        printf("--- Pass %d ---\n", i);
+        _testembed_Py_Initialize();
+        mainstate = PyThreadState_Get();
+
+#ifdef WITH_THREAD
+        PyEval_InitThreads();
+        PyEval_ReleaseThread(mainstate);
+
+        gilstate = PyGILState_Ensure();
+#endif
+        print_subinterp();
+        PyThreadState_Swap(NULL);
+
+        for (j=0; j<3; j++) {
+            substate = Py_NewInterpreter();
+            print_subinterp();
+            Py_EndInterpreter(substate);
+        }
+
+        PyThreadState_Swap(mainstate);
+        print_subinterp();
+#ifdef WITH_THREAD
+        PyGILState_Release(gilstate);
+#endif
+
+        PyEval_RestoreThread(mainstate);
+        Py_Finalize();
+    }
+    return 0;
+}
+
+/*****************************************************
+ * Test forcing a particular IO encoding
+ *****************************************************/
+
+static void check_stdio_details(const char *encoding, const char * errors)
+{
+    /* Output info for the test case to check */
+    if (encoding) {
+        printf("Expected encoding: %s\n", encoding);
+    } else {
+        printf("Expected encoding: default\n");
+    }
+    if (errors) {
+        printf("Expected errors: %s\n", errors);
+    } else {
+        printf("Expected errors: default\n");
+    }
+    fflush(stdout);
+    /* Force the given IO encoding */
+    Py_SetStandardStreamEncoding(encoding, errors);
+    _testembed_Py_Initialize();
+    PyRun_SimpleString(
+        "import sys;"
+        "print('stdin: {0.encoding}:{0.errors}'.format(sys.stdin));"
+        "print('stdout: {0.encoding}:{0.errors}'.format(sys.stdout));"
+        "print('stderr: {0.encoding}:{0.errors}'.format(sys.stderr));"
+        "sys.stdout.flush()"
+    );
+    Py_Finalize();
+}
+
+static int test_forced_io_encoding(void)
+{
+    /* Check various combinations */
+    printf("--- Use defaults ---\n");
+    check_stdio_details(NULL, NULL);
+    printf("--- Set errors only ---\n");
+    check_stdio_details(NULL, "ignore");
+    printf("--- Set encoding only ---\n");
+    check_stdio_details("latin-1", NULL);
+    printf("--- Set encoding and errors ---\n");
+    check_stdio_details("latin-1", "replace");
+
+    /* Check calling after initialization fails */
+    Py_Initialize();
+
+    if (Py_SetStandardStreamEncoding(NULL, NULL) == 0) {
+        printf("Unexpected success calling Py_SetStandardStreamEncoding");
+    }
+    Py_Finalize();
+    return 0;
+}
+
+
+/*********************************************************
+ * Test parts of the C-API that work before initialization
+ *********************************************************/
+
+static int test_pre_initialization_api(void)
+{
+    /* Leading "./" ensures getpath.c can still find the standard library */
+    wchar_t *program = Py_DecodeLocale("./spam", NULL);
+    if (program == NULL) {
+        fprintf(stderr, "Fatal error: cannot decode program name\n");
+        return 1;
+    }
+    Py_SetProgramName(program);
+
+    Py_Initialize();
+    Py_Finalize();
+
+    PyMem_RawFree(program);
+    return 0;
+}
+
+
+/* *********************************************************
+ * List of test cases and the function that implements it.
+ *
+ * Names are compared case-sensitively with the first
+ * argument. If no match is found, or no first argument was
+ * provided, the names of all test cases are printed and
+ * the exit code will be -1.
+ *
+ * The int returned from test functions is used as the exit
+ * code, and test_capi treats all non-zero exit codes as a
+ * failed test.
+ *********************************************************/
+struct TestCase
+{
+    const char *name;
+    int (*func)(void);
+};
+
+static struct TestCase TestCases[] = {
+    { "forced_io_encoding", test_forced_io_encoding },
+    { "repeated_init_and_subinterpreters", test_repeated_init_and_subinterpreters },
+    { "pre_initialization_api", test_pre_initialization_api },
+    { NULL, NULL }
+};
+
+int main(int argc, char *argv[])
+{
+    if (argc > 1) {
+        for (struct TestCase *tc = TestCases; tc && tc->name; tc++) {
+            if (strcmp(argv[1], tc->name) == 0)
+                return (*tc->func)();
+        }
+    }
+
+    /* No match found, or no test name provided, so display usage */
+    printf("Python " PY_VERSION " _testembed executable for embedded interpreter tests\n"
+           "Normally executed via 'EmbeddingTests' in Lib/test/test_capi.py\n\n"
+           "Usage: %s TESTNAME\n\nAll available tests:\n", argv[0]);
+    for (struct TestCase *tc = TestCases; tc && tc->name; tc++) {
+        printf("  %s\n", tc->name);
+    }
+
+    /* Non-zero exit code will cause test_capi.py tests to fail.
+       This is intentional. */
+    return -1;
+}

third_party/python/Programs/python.c

@@ -0,0 +1,82 @@
+/* Minimal main program -- everything is loaded from the library */
+
+#include "Python.h"
+#include <locale.h>
+
+#ifdef __FreeBSD__
+#include <fenv.h>
+#endif
+
+#ifdef MS_WINDOWS
+int
+wmain(int argc, wchar_t **argv)
+{
+    return Py_Main(argc, argv);
+}
+#else
+
+int
+main(int argc, char **argv)
+{
+    wchar_t **argv_copy;
+    /* We need a second copy, as Python might modify the first one. */
+    wchar_t **argv_copy2;
+    int i, res;
+    char *oldloc;
+
+    /* Force malloc() allocator to bootstrap Python */
+    (void)_PyMem_SetupAllocators("malloc");
+
+    argv_copy = (wchar_t **)PyMem_RawMalloc(sizeof(wchar_t*) * (argc+1));
+    argv_copy2 = (wchar_t **)PyMem_RawMalloc(sizeof(wchar_t*) * (argc+1));
+    if (!argv_copy || !argv_copy2) {
+        fprintf(stderr, "out of memory\n");
+        return 1;
+    }
+
+    /* 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.
+     */
+#ifdef __FreeBSD__
+    fedisableexcept(FE_OVERFLOW);
+#endif
+
+    oldloc = _PyMem_RawStrdup(setlocale(LC_ALL, NULL));
+    if (!oldloc) {
+        fprintf(stderr, "out of memory\n");
+        return 1;
+    }
+
+    setlocale(LC_ALL, "");
+    for (i = 0; i < argc; i++) {
+        argv_copy[i] = Py_DecodeLocale(argv[i], NULL);
+        if (!argv_copy[i]) {
+            PyMem_RawFree(oldloc);
+            fprintf(stderr, "Fatal Python error: "
+                            "unable to decode the command line argument #%i\n",
+                            i + 1);
+            return 1;
+        }
+        argv_copy2[i] = argv_copy[i];
+    }
+    argv_copy2[argc] = argv_copy[argc] = NULL;
+
+    setlocale(LC_ALL, oldloc);
+    PyMem_RawFree(oldloc);
+
+    res = Py_Main(argc, argv_copy);
+
+    /* Force again malloc() allocator to release memory blocks allocated
+       before Py_Main() */
+    (void)_PyMem_SetupAllocators("malloc");
+
+    for (i = 0; i < argc; i++) {
+        PyMem_RawFree(argv_copy2[i]);
+    }
+    PyMem_RawFree(argv_copy);
+    PyMem_RawFree(argv_copy2);
+    return res;
+}
+#endif