wasm 3.13 build

Author: pmp-p

src_c/static.c

@@ -24,7 +24,7 @@
 #undef WITH_THREAD
 #endif
 
-#if defined(BUILD_STATIC)
+#if 1 // defined(BUILD_STATIC)
 #undef import_pygame_base
 #undef import_pygame_rect
 #undef import_pygame_surface
@@ -33,56 +33,84 @@
 #undef import_pygame_bufferproxy
 #undef import_pygame_rwobject
 #undef import_pygame_event
+#undef import_pygame_imageext
+#undef import_pygame_image
+#undef import_pygame_font
 
 void
 import_pygame_base(void)
 {
+    puts("import_pygame_base");
 }
 
 void
 import_pygame_rect(void)
 {
+    puts("import_pygame_rect");
 }
 
 void
 import_pygame_surface(void)
 {
+    puts("import_pygame_surface");
+}
+
+
+void
+import_pygame_window(void)
+{
+    puts("import_pygame_window");
 }
 
 void
 import_pygame_geometry(void)
 {
+    puts("import_pygame_geometry");
 }
 
 void
 import_pygame_color(void)
 {
+puts("import_pygame_color");
+}
+
+void
+import_pygame_font(void)
+{
+    puts("import_pygame_font");
 }
 
+void
+import_pygame_freetype(void)
+{
+    puts("import_pygame_freetype");
+}
+
+
 void
 import_pygame_bufferproxy(void)
 {
+    puts("import_pygame_bufferproxy");
 }
 
 void
 import_pygame_rwobject(void)
 {
+    puts("import_pygame_rwobject");
 }
 
 void
 import_pygame_event(void)
 {
+    puts("import_pygame_event");
 }
 
 void
 import_pygame_joystick(void)
 {
+    puts("import_pygame_joystick");
 }
 
-void
-import_pygame_window(void)
-{
-}
 
 PyMODINIT_FUNC
 PyInit_base(void);
@@ -198,24 +226,28 @@ void
 load_submodule(const char *parent, PyObject *mod, const char *alias)
 {
     char fqn[1024];
-    snprintf(fqn, sizeof(fqn), "%s.%s", parent, alias);
-
-    PyObject *modules = PyImport_GetModuleDict();
-
-    PyObject *pmod = PyDict_GetItemString(modules, parent);
-
     if (!mod) {
-        snprintf(fqn, sizeof(fqn), "ERROR: %s.%s", parent, alias);
+        snprintf(fqn, sizeof(fqn), "ERROR: PyInit_%s failed for %s.%s", alias, parent, alias);
         puts(fqn);
         PyErr_Print();
         PyErr_Clear();
     }
     else {
-        PyDict_SetItemString(modules, fqn, mod);
-        PyDict_SetItemString(PyModule_GetDict(mod), "__name__",
-                             PyUnicode_FromString(fqn));
-        PyModule_AddObjectRef(pmod, alias, mod);
-        Py_XDECREF(mod);
+        snprintf(fqn, sizeof(fqn), "%s.%s", parent, alias);
+        puts(fqn);
+        PyObject *modules = PyImport_GetModuleDict();
+
+        PyObject *pmod = PyDict_GetItemString(modules, parent);
+        if (!pmod) {
+            snprintf(fqn, sizeof(fqn), "ERROR: Parent %s not found for %s.%s", parent, parent, alias);
+            puts(fqn);
+        } else {
+            PyDict_SetItemString(modules, fqn, mod);
+            PyDict_SetItemString(PyModule_GetDict(mod), "__name__",
+                                 PyUnicode_FromString(fqn));
+            PyModule_AddObjectRef(pmod, alias, mod);
+            Py_XDECREF(mod);
+        }
     }
 }
 
@@ -225,6 +257,7 @@ load_submodule_mphase(const char *parent, PyObject *mdef, PyObject *spec,
 {
     char fqn[1024];
     snprintf(fqn, sizeof(fqn), "%s.%s", parent, alias);
+puts(fqn);
     PyObject *modules = PyImport_GetModuleDict();
 
     Py_DECREF(PyObject_GetAttrString(spec, "name"));
@@ -255,7 +288,10 @@ load_submodule_mphase(const char *parent, PyObject *mdef, PyObject *spec,
 static PyObject *
 mod_pygame_import_cython(PyObject *self, PyObject *spec)
 {
+#if 1 //PY_VERSION_HEX <= 0x030C0000
+
     load_submodule_mphase("pygame._sdl2", PyInit_sdl2(), spec, "sdl2");
+
     load_submodule_mphase("pygame._sdl2", PyInit_mixer(), spec, "mixer");
 #if defined(CONTROLLER_NOPYX)
     load_submodule("pygame._sdl2", PyInit_controller(), "controller");
@@ -265,7 +301,7 @@ mod_pygame_import_cython(PyObject *self, PyObject *spec)
 #endif
     load_submodule_mphase("pygame._sdl2", PyInit_audio(), spec, "audio");
     load_submodule_mphase("pygame._sdl2", PyInit_video(), spec, "video");
-
+#endif
     Py_RETURN_NONE;
 }
 
@@ -288,47 +324,74 @@ PyInit_pygame_static()
     SDL_SetHint("SDL_EMSCRIPTEN_KEYBOARD_ELEMENT", "1");
 
     load_submodule("pygame", PyInit_base(), "base");
+
+    //
     load_submodule("pygame", PyInit_constants(), "constants");
-    load_submodule("pygame", PyInit_surflock(), "surflock");
-    load_submodule("pygame", PyInit_rwobject(), "rwobject");
+    //
     load_submodule("pygame", PyInit_pg_math(), "math");
-    load_submodule("pygame", PyInit_display(), "display");
-    load_submodule("pygame", PyInit_surface(), "surface");
-    load_submodule("pygame", PyInit_system(), "system");
-    load_submodule("pygame", PyInit_key(), "key");
 
+    // base, pygame.colordict
+    load_submodule("pygame", PyInit_color(), "color");
+
+    // base
     load_submodule("pygame", PyInit_rect(), "rect");
+
+    // base, rect
     load_submodule("pygame", PyInit_geometry(), "geometry");
-    load_submodule("pygame", PyInit_gfxdraw(), "gfxdraw");
-    load_submodule("pygame", PyInit_pg_time(), "time");
-    load_submodule("pygame", PyInit__freetype(), "_freetype");
 
-    load_submodule("pygame", PyInit_imageext(), "imageext");
+    load_submodule("pygame", PyInit_bufferproxy(), "bufferproxy");
+    load_submodule("pygame", PyInit_surflock(), "surflock");
 
+    // base, color, rect, bufferproxy, surflock
+    load_submodule("pygame", PyInit_surface(), "surface");
+
+    load_submodule("pygame", PyInit_rwobject(), "rwobject");
+
+    // base, color, rect, bufferproxy, surflock, surface, rwobject
+    load_submodule("pygame", PyInit_imageext(), "imageext");
+    // base, color, rect, bufferproxy, surflock, surface, rwobject
     load_submodule("pygame", PyInit_image(), "image");
+
+    load_submodule("pygame", PyInit__freetype(), "_freetype");
     load_submodule("pygame", PyInit_font(), "font");
     load_submodule("pygame", PyInit_pixelcopy(), "pixelcopy");
     load_submodule("pygame", PyInit_newbuffer(), "newbuffer");
 
-    load_submodule("pygame", PyInit_color(), "color");
-    load_submodule("pygame", PyInit_bufferproxy(), "bufferproxy");
+    // base
+    load_submodule("pygame", PyInit_joystick(), "joystick");
+    // base, joystick
+    load_submodule("pygame", PyInit_event(), "event");
+
+    // base, rect, event
+    load_submodule("pygame", PyInit_key(), "key");
+    // base, event
+    load_submodule("pygame", PyInit_pg_time(), "time");
+
 
     load_submodule("pygame", PyInit_transform(), "transform");
     load_submodule("pygame", PyInit_draw(), "draw");
 
     load_submodule("pygame", PyInit_mask(), "mask");
     load_submodule("pygame", PyInit_mouse(), "mouse");
-    load_submodule("pygame", PyInit_event(), "event");
-    load_submodule("pygame", PyInit_joystick(), "joystick");
+
 
     load_submodule("pygame", PyInit_pg_mixer(), "mixer");
     load_submodule("pygame.mixer", PyInit_mixer_music(), "music");
 
+    // base, color, rect, bufferproxy, surflock, surface
     load_submodule("pygame", PyInit_window(), "window");
+
+    // base, color, rect, surflock, surface, window
+    load_submodule("pygame", PyInit_display(), "display");
     load_submodule("pygame", PyInit__render(), "_render");
 
     load_submodule("pygame", PyInit_pixelarray(), "pixelarray");
 
+    // base, color, rect, bufferproxy, surflock, surface
+    load_submodule("pygame", PyInit_gfxdraw(), "gfxdraw");
+
+    //load_submodule("pygame", PyInit_system(), "system");
+
     return PyModule_Create(&mod_pygame_static);
 }
 

src_c/surface.c

@@ -4595,7 +4595,7 @@ pgSurface_Blit(pgSurfaceObject *dstobj, pgSurfaceObject *srcobj,
 }
 
 static PyMethodDef _surface_methods[] = {{NULL, NULL, 0, NULL}};
-
+#if !defined(BUILD_STATIC)
 int
 exec_surface(PyObject *module)
 {
@@ -4688,3 +4688,61 @@ MODINIT_DEFINE(surface)
 
     return PyModuleDef_Init(&_module);
 }
+#else
+MODINIT_DEFINE(surface)
+{
+    PyObject *module;
+
+    static struct PyModuleDef _module = {PyModuleDef_HEAD_INIT,
+                                         "surface",
+                                         DOC_SURFACE,
+                                         -1,
+                                         _surface_methods,
+                                         NULL,
+                                         NULL,
+                                         NULL,
+                                         NULL};
+
+    module = PyModule_Create(&_module);
+    if (module == NULL) {
+        return NULL;
+    }
+
+    _IMPORT_PYGAME_MODULE(surflock);
+    if (PyErr_Occurred()) {
+        return NULL;
+    }
+
+    /* type preparation */
+    if (PyType_Ready(&pgSurface_Type) < 0) {
+        return NULL;
+    }
+
+    PyObject *apiobj;
+    static void *c_api[PYGAMEAPI_SURFACE_NUMSLOTS];
+
+    if (PyModule_AddObjectRef(module, "SurfaceType", (PyObject *)&pgSurface_Type)) {
+        return NULL;
+    }
+
+    if (PyModule_AddObjectRef(module, "Surface", (PyObject *)&pgSurface_Type)) {
+        return NULL;
+    }
+
+    /* export the c api */
+    c_api[0] = &pgSurface_Type;
+    c_api[1] = pgSurface_New2;
+    c_api[2] = pgSurface_Blit;
+    c_api[3] = pgSurface_SetSurface;
+    apiobj = encapsulate_api(c_api, "surface");
+    if (PyModule_Add(module, PYGAMEAPI_LOCAL_ENTRY, apiobj) < 0) {
+        return NULL;
+    }
+
+    if (PyModule_AddObjectRef(module, "_dict", pgSurface_Type.tp_dict)) {
+        return NULL;
+    }
+
+    return module;
+}
+#endif