Refactor 'moduleobject.c'.

fangerer · fangerer · commit 0d83127811e0 · 2018-06-21T13:33:15.000+02:00
diff --git a/graalpython/com.oracle.graal.python.cext/src/moduleobject.c b/graalpython/com.oracle.graal.python.cext/src/moduleobject.c
@@ -46,24 +46,23 @@ int PyModule_AddFunctions(PyObject* mod, PyMethodDef* methods) {
         return -1;
     }
     int idx = 0;
-    void* mod_w = to_java(mod);
     PyMethodDef def = methods[idx];
     while (def.ml_name != NULL) {
-        truffle_invoke(PY_TRUFFLE_CEXT,
+        polyglot_invoke(PY_TRUFFLE_CEXT,
                        "AddFunction",
-                       mod_w,
-                       truffle_read_string((const char*)(def.ml_name)),
-                       truffle_address_to_function(def.ml_meth),
-                       truffle_address_to_function(get_method_flags_cwrapper(def.ml_flags)),
+                       native_to_java(mod),
+                       polyglot_from_string((const char*)(def.ml_name), SRC_CS),
+                       def.ml_meth,
+                       get_method_flags_cwrapper(def.ml_flags),
                        get_method_flags_wrapper(def.ml_flags),
-                       truffle_read_string((const char*)(def.ml_doc ? def.ml_doc : "")));
+                       polyglot_from_string((const char*)(def.ml_doc ? def.ml_doc : ""), SRC_CS));
         def = methods[++idx];
     }
     return 0;
 }
 
 int PyModule_SetDocString(PyObject* m, const char* doc) {
-    truffle_invoke(PY_TRUFFLE_CEXT, "PyModule_SetDocString", to_java(m), truffle_read_string(doc));
+    UPCALL_CEXT_VOID("PyModule_SetDocString", native_to_java(m), polyglot_from_string(doc, SRC_CS));
     return 0;
 }
 
@@ -75,7 +74,7 @@ PyObject* _PyModule_CreateInitialized(PyModuleDef* moduledef, int apiversion) {
         return NULL;
     }
 
-    PyObject* mod = to_sulong(truffle_invoke(PY_TRUFFLE_CEXT, "_PyModule_CreateInitialized_PyModule_New", truffle_read_string(moduledef->m_name)));
+    PyModuleObject* mod = polyglot_as_PyModuleObject(UPCALL_CEXT_O("_PyModule_CreateInitialized_PyModule_New", polyglot_from_string(moduledef->m_name, SRC_CS)));
 
     if (moduledef->m_size > 0) {
         void* md_state = PyMem_MALLOC(moduledef->m_size);
@@ -84,32 +83,32 @@ PyObject* _PyModule_CreateInitialized(PyModuleDef* moduledef, int apiversion) {
             return NULL;
         }
         memset(md_state, 0, moduledef->m_size);
-        truffle_write(to_java(mod), "md_state", md_state);
+        mod->md_state = md_state;
     }
 
     if (moduledef->m_methods != NULL) {
-        if (PyModule_AddFunctions(mod, moduledef->m_methods) != 0) {
+        if (PyModule_AddFunctions((PyObject*) mod, moduledef->m_methods) != 0) {
             return NULL;
         }
     }
 
     if (moduledef->m_doc != NULL) {
-        if (PyModule_SetDocString(mod, moduledef->m_doc) != 0) {
+        if (PyModule_SetDocString((PyObject*) mod, moduledef->m_doc) != 0) {
             return NULL;
         }
     }
 
-    truffle_write(to_java(mod), "md_def", moduledef);
-    return mod;
+    mod->md_def = moduledef;
+    return (PyObject*) mod;
 }
 
 int PyModule_AddObject(PyObject* m, const char* k, PyObject* v) {
-    truffle_invoke(PY_TRUFFLE_CEXT, "PyModule_AddObject", to_java(m), truffle_read_string(k), to_java(v));
+    UPCALL_CEXT_VOID("PyModule_AddObject", native_to_java(m), polyglot_from_string(k, SRC_CS), native_to_java(v));
     return 0;
 }
 
 int PyModule_AddIntConstant(PyObject* m, const char* k, long constant) {
-    truffle_invoke(PY_TRUFFLE_CEXT, "PyModule_AddObject", to_java(m), truffle_read_string(k), constant);
+    UPCALL_CEXT_VOID("PyModule_AddObject", native_to_java(m), polyglot_from_string(k, SRC_CS), PyLong_FromLong(constant));
     return 0;
 }
 
@@ -122,5 +121,5 @@ PyObject* PyModule_GetDict(PyObject* o) {
         PyErr_BadInternalCall();
         return NULL;
     }
-    return ((PyModuleObject*)polyglot_as_PyModuleObject(o))->md_dict;
+    return (polyglot_as_PyModuleObject(o))->md_dict;
 }
diff --git a/graalpython/com.oracle.graal.python.cext/src/object.c b/graalpython/com.oracle.graal.python.cext/src/object.c
@@ -222,7 +222,8 @@ int PyType_Ready(PyTypeObject* cls) {
 #define ADD_SLOT_CONV(name, clanding, meth, flags) ADD_METHOD_OR_SLOT(name, clanding, meth, flags, name)
 #define ADD_METHOD_OR_SLOT(name, clanding, meth, flags, doc)                                \
     if (meth) {                                                                             \
-        UPCALL_CEXT_VOID("AddFunction",                                                     \
+        polyglot_invoke(PY_TRUFFLE_CEXT,                                                    \
+                       "AddFunction",                                                       \
                        javacls,                                                             \
                        polyglot_from_string((name), SRC_CS),                                \
                        (meth),                                                              \
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/NativeMemberNames.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/NativeMemberNames.java
@@ -70,6 +70,8 @@ public abstract class NativeMemberNames {
     public static final String UNICODE_STATE_COMPACT = "compact";
     public static final String UNICODE_STATE_ASCII = "ascii";
     public static final String UNICODE_STATE_READY = "ready";
+    public static final String MD_STATE = "md_state";
+    public static final String MD_DEF = "md_def";
     public static final String MD_DICT = "md_dict";
     public static final String BUF_DELEGATE = "buf_delegate";
     public static final String NB_ADD = "nb_add";
@@ -109,6 +111,8 @@ public static boolean isValid(String key) {
             case UNICODE_STATE_COMPACT:
             case UNICODE_STATE_ASCII:
             case UNICODE_STATE_READY:
+            case MD_STATE:
+            case MD_DEF:
             case MD_DICT:
             case NB_ADD:
             case NB_INDEX:
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/NativeWrappers.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/NativeWrappers.java
@@ -40,9 +40,13 @@
 
 import com.oracle.graal.python.builtins.objects.PythonAbstractObject;
 import com.oracle.graal.python.builtins.objects.cext.CArrayWrappers.CStringWrapper;
+import com.oracle.graal.python.builtins.objects.common.DynamicObjectStorage.PythonObjectDictStorage;
 import com.oracle.graal.python.builtins.objects.type.PythonClass;
 import com.oracle.truffle.api.interop.ForeignAccess;
 import com.oracle.truffle.api.interop.TruffleObject;
+import com.oracle.truffle.api.object.Layout;
+import com.oracle.truffle.api.object.ObjectType;
+import com.oracle.truffle.api.object.Shape;
 
 public abstract class NativeWrappers {
     public abstract static class PythonNativeWrapper implements TruffleObject {
@@ -65,6 +69,10 @@ public boolean isNative() {
             return nativePointer != null;
         }
 
+        static boolean isInstance(TruffleObject o) {
+            return o instanceof PythonNativeWrapper;
+        }
+
         @Override
         public ForeignAccess getForeignAccess() {
             return PythonObjectNativeWrapperMRForeign.ACCESS;
@@ -76,7 +84,11 @@ public ForeignAccess getForeignAccess() {
      * correct shape of the corresponding native type {@code struct _object}.
      */
     public static class PythonObjectNativeWrapper extends PythonNativeWrapper {
+        private static final Layout OBJECT_LAYOUT = Layout.newLayout().build();
+        private static final Shape SHAPE = OBJECT_LAYOUT.createShape(new ObjectType());
+
         private final PythonAbstractObject pythonObject;
+        private PythonObjectDictStorage nativeMemberStore;
 
         public PythonObjectNativeWrapper(PythonAbstractObject object) {
             this.pythonObject = object;
@@ -105,6 +117,17 @@ public Object getDelegate() {
             return pythonObject;
         }
 
+        public PythonObjectDictStorage createNativeMemberStore() {
+            if (nativeMemberStore == null) {
+                nativeMemberStore = new PythonObjectDictStorage(SHAPE.newInstance());
+            }
+            return nativeMemberStore;
+        }
+
+        public PythonObjectDictStorage getNativeMemberStore() {
+            return nativeMemberStore;
+        }
+
         @Override
         public String toString() {
             return String.format("PythonObjectNativeWrapper(%s, isNative=%s)", pythonObject, isNative());
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/PythonObjectNativeWrapperMR.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/builtins/objects/cext/PythonObjectNativeWrapperMR.java
@@ -55,6 +55,9 @@
 import com.oracle.graal.python.builtins.objects.cext.PythonObjectNativeWrapperMRFactory.ToPyObjectNodeGen;
 import com.oracle.graal.python.builtins.objects.cext.PythonObjectNativeWrapperMRFactory.WriteNativeMemberNodeGen;
 import com.oracle.graal.python.builtins.objects.cext.UnicodeObjectNodes.UnicodeAsWideCharNode;
+import com.oracle.graal.python.builtins.objects.common.HashingStorageNodes;
+import com.oracle.graal.python.builtins.objects.common.HashingStorageNodes.GetItemNode;
+import com.oracle.graal.python.builtins.objects.common.HashingStorageNodes.SetItemNode;
 import com.oracle.graal.python.builtins.objects.dict.PDict;
 import com.oracle.graal.python.builtins.objects.memoryview.PBuffer;
 import com.oracle.graal.python.builtins.objects.object.PythonObject;
@@ -92,23 +95,27 @@
 import com.oracle.truffle.api.nodes.Node;
 import com.oracle.truffle.api.nodes.UnexpectedResultException;
 
-@MessageResolution(receiverType = PythonObjectNativeWrapper.class)
+@MessageResolution(receiverType = PythonNativeWrapper.class)
 public class PythonObjectNativeWrapperMR {
     protected static String GP_OBJECT = "gp_object";
 
     @Resolve(message = "READ")
     abstract static class ReadNode extends Node {
         @Child private ReadNativeMemberNode readNativeMemberNode;
 
-        public Object access(Object object, Object key) {
+        public Object access(PythonNativeWrapper object, String key) {
+            // special key for the debugger
             if (key.equals(GP_OBJECT)) {
-                return ((PythonNativeWrapper) object).getDelegate();
+                return object.getDelegate();
             }
-            if (readNativeMemberNode == null) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                readNativeMemberNode = insert(ReadNativeMemberNode.create());
+            if (NativeMemberNames.isValid(key)) {
+                if (readNativeMemberNode == null) {
+                    CompilerDirectives.transferToInterpreterAndInvalidate();
+                    readNativeMemberNode = insert(ReadNativeMemberNode.create());
+                }
+                return readNativeMemberNode.execute(object.getDelegate(), key);
             }
-            return readNativeMemberNode.execute(((PythonNativeWrapper) object).getDelegate(), key);
+            throw UnknownIdentifierException.raise(key.toString());
         }
     }
 
@@ -117,10 +124,11 @@ public Object access(Object object, Object key) {
     abstract static class ReadNativeMemberNode extends PBaseNode {
         @Child GetClassNode getClass = GetClassNode.create();
         @Child private ToSulongNode toSulongNode;
+        @Child private HashingStorageNodes.GetItemNode getItemNode;
 
         @CompilationFinal long wcharSize = -1;
 
-        abstract Object execute(Object receiver, Object key);
+        abstract Object execute(Object receiver, String key);
 
         @Specialization(guards = "eq(OB_BASE, key)")
         Object doObBase(Object o, @SuppressWarnings("unused") String key) {
@@ -132,11 +140,6 @@ Object doObBase(PString o, @SuppressWarnings("unused") String key) {
             return getToSulongNode().execute(o);
         }
 
-        @Specialization(guards = "eq(_BASE, key)")
-        Object doObBase(String o, @SuppressWarnings("unused") String key) {
-            return getToSulongNode().execute(o);
-        }
-
         @Specialization(guards = "eq(OB_REFCNT, key)")
         int doObRefcnt(@SuppressWarnings("unused") Object o, @SuppressWarnings("unused") String key) {
             return 0;
@@ -187,7 +190,7 @@ Object doTpName(PythonClass object, @SuppressWarnings("unused") String key) {
         Object doTpBase(PythonClass object, @SuppressWarnings("unused") String key) {
             PythonClass superClass = object.getSuperClass();
             if (superClass != null) {
-                return PythonObjectNativeWrapper.wrap(superClass);
+                return getToSulongNode().execute(superClass);
             }
             return getToSulongNode().execute(object);
         }
@@ -275,16 +278,16 @@ Object doObItem(PSequence object, @SuppressWarnings("unused") String key) {
         }
 
         @Specialization(guards = "eq(UNICODE_WSTR, key)")
-        Object doWstr(String object, @SuppressWarnings("unused") String key,
+        Object doWstr(PString object, @SuppressWarnings("unused") String key,
                         @Cached("create(0)") UnicodeAsWideCharNode asWideCharNode) {
-            return new PySequenceArrayWrapper(asWideCharNode.execute(object, sizeofWchar(), object.length()));
+            return new PySequenceArrayWrapper(asWideCharNode.execute(object, sizeofWchar(), object.len()));
         }
 
         @Specialization(guards = "eq(UNICODE_WSTR_LENGTH, key)")
-        long doWstrLength(String object, @SuppressWarnings("unused") String key,
+        long doWstrLength(PString object, @SuppressWarnings("unused") String key,
                         @Cached("create(0)") UnicodeAsWideCharNode asWideCharNode) {
             long sizeofWchar = sizeofWchar();
-            PBytes result = asWideCharNode.execute(object, sizeofWchar, object.length());
+            PBytes result = asWideCharNode.execute(object, sizeofWchar, object.len());
             return result.len() / sizeofWchar;
         }
 
@@ -306,8 +309,16 @@ Object doObSval(PBuffer object, @SuppressWarnings("unused") String key) {
         }
 
         @Fallback
-        Object doGeneric(@SuppressWarnings("unused") Object receiver, Object key) {
-            throw UnknownIdentifierException.raise(key.toString());
+        Object doGeneric(Object object, String key) {
+            // This is the preliminary generic case: There are native members we know that they
+            // exist but we do currently not represent them. So, store them into a dynamic object
+            // such that native code at least reads the value that was written before.
+            if (object instanceof PythonAbstractObject) {
+                PythonObjectNativeWrapper nativeWrapper = ((PythonAbstractObject) object).getNativeWrapper();
+                assert nativeWrapper != null;
+                return getGetItemNode().execute(nativeWrapper.getNativeMemberStore(), key);
+            }
+            throw UnknownIdentifierException.raise(key);
         }
 
         protected boolean eq(String expected, String actual) {
@@ -318,6 +329,14 @@ public static ReadNativeMemberNode create() {
             return ReadNativeMemberNodeGen.create();
         }
 
+        private HashingStorageNodes.GetItemNode getGetItemNode() {
+            if (getItemNode == null) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                getItemNode = insert(GetItemNode.create());
+            }
+            return getItemNode;
+        }
+
         private ToSulongNode getToSulongNode() {
             if (toSulongNode == null) {
                 CompilerDirectives.transferToInterpreterAndInvalidate();
@@ -343,21 +362,25 @@ private long sizeofWchar() {
 
     @Resolve(message = "WRITE")
     abstract static class WriteNode extends Node {
-        @Child private WriteNativeMemberNode readNativeMemberNode;
+        @Child private WriteNativeMemberNode writeNativeMemberNode;
 
-        public Object access(Object object, Object key, Object value) {
-            if (readNativeMemberNode == null) {
-                CompilerDirectives.transferToInterpreterAndInvalidate();
-                readNativeMemberNode = insert(WriteNativeMemberNode.create());
+        public Object access(PythonNativeWrapper object, String key, Object value) {
+            if (NativeMemberNames.isValid(key)) {
+                if (writeNativeMemberNode == null) {
+                    CompilerDirectives.transferToInterpreterAndInvalidate();
+                    writeNativeMemberNode = insert(WriteNativeMemberNode.create());
+                }
+                return writeNativeMemberNode.execute(object.getDelegate(), key, value);
             }
-            return readNativeMemberNode.execute(((PythonNativeWrapper) object).getDelegate(), key, value);
+            throw UnknownIdentifierException.raise(key);
         }
     }
 
     @ImportStatic({NativeMemberNames.class, PGuards.class})
     abstract static class WriteNativeMemberNode extends Node {
+        @Child private HashingStorageNodes.SetItemNode setItemNode;
 
-        abstract Object execute(Object receiver, Object key, Object value);
+        abstract Object execute(Object receiver, String key, Object value);
 
         @Specialization(guards = "eq(OB_TYPE, key)")
         Object doObType(PythonObject object, @SuppressWarnings("unused") String key, @SuppressWarnings("unused") PythonClass value) {
@@ -399,15 +422,31 @@ Object doTpSubclasses(PythonClass object, @SuppressWarnings("unused") String key
         }
 
         @Fallback
-        Object doGeneric(Object object, Object key, @SuppressWarnings("unused") Object value) {
-            CompilerDirectives.transferToInterpreter();
-            throw new AssertionError("Cannot modify member '" + key + "' of " + object);
+        Object doGeneric(Object object, String key, Object value) {
+            // This is the preliminary generic case: There are native members we know that they
+            // exist but we do currently not represent them. So, store them into a dynamic object
+            // such that native code at least reads the value that was written before.
+            if (object instanceof PythonAbstractObject) {
+                PythonObjectNativeWrapper nativeWrapper = ((PythonAbstractObject) object).getNativeWrapper();
+                assert nativeWrapper != null;
+                getSetItemNode().execute(null, nativeWrapper.createNativeMemberStore(), key, value);
+                return value;
+            }
+            throw UnknownIdentifierException.raise(key);
         }
 
         protected boolean eq(String expected, String actual) {
             return expected.equals(actual);
         }
 
+        private HashingStorageNodes.SetItemNode getSetItemNode() {
+            if (setItemNode == null) {
+                CompilerDirectives.transferToInterpreterAndInvalidate();
+                setItemNode = insert(SetItemNode.create());
+            }
+            return setItemNode;
+        }
+
         public static WriteNativeMemberNode create() {
             return WriteNativeMemberNodeGen.create();
         }
@@ -470,7 +509,7 @@ public int access(Object object, Object fieldName) {
     @Resolve(message = "HAS_KEYS")
     abstract static class HasKeysNode extends Node {
         public Object access(Object obj) {
-            return obj instanceof PythonObjectNativeWrapper;
+            return obj instanceof PythonNativeWrapper;
         }
     }
 
@@ -479,7 +518,7 @@ abstract static class PForeignKeysNode extends Node {
         @Child Node objKeys = Message.KEYS.createNode();
 
         public Object access(Object object) {
-            if (object instanceof PythonObjectNativeWrapper) {
+            if (object instanceof PythonNativeWrapper) {
                 return PythonLanguage.getContext().getEnv().asGuestValue(new String[]{GP_OBJECT});
             } else {
                 throw UnsupportedMessageException.raise(Message.KEYS);
@@ -503,7 +542,7 @@ Object access(PythonNativeWrapper obj) {
     abstract static class IsPointerNode extends Node {
         @Child private Node isPointerNode;
 
-        Object access(PythonObjectNativeWrapper obj) {
+        Object access(PythonNativeWrapper obj) {
             return obj.isNative() && (!(obj.getNativePointer() instanceof TruffleObject) || ForeignAccess.sendIsPointer(getIsPointerNode(), (TruffleObject) obj.getNativePointer()));
         }
 
diff --git a/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/SpecialAttributeNames.java b/graalpython/com.oracle.graal.python/src/com/oracle/graal/python/nodes/SpecialAttributeNames.java
diff --git a/graalpython/lib-graalpython/python_cext.py b/graalpython/lib-graalpython/python_cext.py

Original file line number	Diff line number	Diff line change
`@@ -46,24 +46,23 @@ int PyModule_AddFunctions(PyObject* mod, PyMethodDef* methods) {`
`46`	`46`	`return -1;`
`47`	`47`	`}`
`48`	`48`	`int idx = 0;`
`49`		`- void* mod_w = to_java(mod);`
`50`	`49`	`PyMethodDef def = methods[idx];`
`51`	`50`	`while (def.ml_name != NULL) {`
`52`		`- truffle_invoke(PY_TRUFFLE_CEXT,`
	`51`	`+ polyglot_invoke(PY_TRUFFLE_CEXT,`
`53`	`52`	`"AddFunction",`
`54`		`- mod_w,`
`55`		`- truffle_read_string((const char*)(def.ml_name)),`
`56`		`- truffle_address_to_function(def.ml_meth),`
`57`		`- truffle_address_to_function(get_method_flags_cwrapper(def.ml_flags)),`
	`53`	`+ native_to_java(mod),`
	`54`	`+ polyglot_from_string((const char*)(def.ml_name), SRC_CS),`
	`55`	`+ def.ml_meth,`
	`56`	`+ get_method_flags_cwrapper(def.ml_flags),`
`58`	`57`	`get_method_flags_wrapper(def.ml_flags),`
`59`		`- truffle_read_string((const char*)(def.ml_doc ? def.ml_doc : "")));`
	`58`	`+ polyglot_from_string((const char*)(def.ml_doc ? def.ml_doc : ""), SRC_CS));`
`60`	`59`	`def = methods[++idx];`
`61`	`60`	`}`
`62`	`61`	`return 0;`
`63`	`62`	`}`
`64`	`63`
`65`	`64`	`int PyModule_SetDocString(PyObject* m, const char* doc) {`
`66`		`- truffle_invoke(PY_TRUFFLE_CEXT, "PyModule_SetDocString", to_java(m), truffle_read_string(doc));`
	`65`	`+ UPCALL_CEXT_VOID("PyModule_SetDocString", native_to_java(m), polyglot_from_string(doc, SRC_CS));`
`67`	`66`	`return 0;`
`68`	`67`	`}`
`69`	`68`
`@@ -75,7 +74,7 @@ PyObject* _PyModule_CreateInitialized(PyModuleDef* moduledef, int apiversion) {`
`75`	`74`	`return NULL;`
`76`	`75`	`}`
`77`	`76`
`78`		`- PyObject* mod = to_sulong(truffle_invoke(PY_TRUFFLE_CEXT, "_PyModule_CreateInitialized_PyModule_New", truffle_read_string(moduledef->m_name)));`
	`77`	`+ PyModuleObject* mod = polyglot_as_PyModuleObject(UPCALL_CEXT_O("_PyModule_CreateInitialized_PyModule_New", polyglot_from_string(moduledef->m_name, SRC_CS)));`
`79`	`78`
`80`	`79`	`if (moduledef->m_size > 0) {`
`81`	`80`	`void* md_state = PyMem_MALLOC(moduledef->m_size);`
`@@ -84,32 +83,32 @@ PyObject* _PyModule_CreateInitialized(PyModuleDef* moduledef, int apiversion) {`
`84`	`83`	`return NULL;`
`85`	`84`	`}`
`86`	`85`	`memset(md_state, 0, moduledef->m_size);`
`87`		`- truffle_write(to_java(mod), "md_state", md_state);`
	`86`	`+ mod->md_state = md_state;`
`88`	`87`	`}`
`89`	`88`
`90`	`89`	`if (moduledef->m_methods != NULL) {`
`91`		`- if (PyModule_AddFunctions(mod, moduledef->m_methods) != 0) {`
	`90`	`+ if (PyModule_AddFunctions((PyObject*) mod, moduledef->m_methods) != 0) {`
`92`	`91`	`return NULL;`
`93`	`92`	`}`
`94`	`93`	`}`
`95`	`94`
`96`	`95`	`if (moduledef->m_doc != NULL) {`
`97`		`- if (PyModule_SetDocString(mod, moduledef->m_doc) != 0) {`
	`96`	`+ if (PyModule_SetDocString((PyObject*) mod, moduledef->m_doc) != 0) {`
`98`	`97`	`return NULL;`
`99`	`98`	`}`
`100`	`99`	`}`
`101`	`100`
`102`		`- truffle_write(to_java(mod), "md_def", moduledef);`
`103`		`- return mod;`
	`101`	`+ mod->md_def = moduledef;`
	`102`	`+ return (PyObject*) mod;`
`104`	`103`	`}`
`105`	`104`
`106`	`105`	`int PyModule_AddObject(PyObject* m, const char* k, PyObject* v) {`
`107`		`- truffle_invoke(PY_TRUFFLE_CEXT, "PyModule_AddObject", to_java(m), truffle_read_string(k), to_java(v));`
	`106`	`+ UPCALL_CEXT_VOID("PyModule_AddObject", native_to_java(m), polyglot_from_string(k, SRC_CS), native_to_java(v));`
`108`	`107`	`return 0;`
`109`	`108`	`}`
`110`	`109`
`111`	`110`	`int PyModule_AddIntConstant(PyObject* m, const char* k, long constant) {`
`112`		`- truffle_invoke(PY_TRUFFLE_CEXT, "PyModule_AddObject", to_java(m), truffle_read_string(k), constant);`
	`111`	`+ UPCALL_CEXT_VOID("PyModule_AddObject", native_to_java(m), polyglot_from_string(k, SRC_CS), PyLong_FromLong(constant));`
`113`	`112`	`return 0;`
`114`	`113`	`}`
`115`	`114`
`@@ -122,5 +121,5 @@ PyObject* PyModule_GetDict(PyObject* o) {`
`122`	`121`	`PyErr_BadInternalCall();`
`123`	`122`	`return NULL;`
`124`	`123`	`}`
`125`		`- return ((PyModuleObject*)polyglot_as_PyModuleObject(o))->md_dict;`
	`124`	`+ return (polyglot_as_PyModuleObject(o))->md_dict;`
`126`	`125`	`}`