Changeset 59

Timestamp:

06/02/06 13:32:07 (2 years ago)

Author:

Gregor

Message:

bcd.gen/bcd/gen/bcdgen.d: It is now possible to derive D classes from C++ classes.

Files:

• trunk/bcd.gen/Makefile (modified) (1 diff)
• trunk/bcd.gen/bcd/bind.cc (copied) (copied from trunk/bindings/bcd/bind.cc)
• trunk/bcd.gen/bcd/bind.h (copied) (copied from trunk/bindings/bcd/bind.h)
• trunk/bcd.gen/bcd/gen/bcdgen.d (modified) (31 diffs)

trunk/bcd.gen/Makefile

@@ -5 +5 @@
-bcdgen: bcd/gen/bcdgen.d bcd/gen/libxml2.d
-    $(DMD) -g bcd/gen/bcdgen.d bcd/gen/libxml2.d -ofbcdgen -L-lxml2
-
-fltk2exa: test/fltk2.d bcd/bind.d
-    sh test/fltk2.sh ${DMD}
-
-libxml2exa: test/libxml2.d
-    sh test/libxml2.sh ${DMD}
-
-vorbisexa: test/vorbis.d
-    sh test/vorbis.sh ${DMD}
-
-gtk2exa: test/gtk2.d
-    sh test/gtk2.sh ${DMD}

trunk/bcd.gen/bcd/gen/bcdgen.d

@@ -40 +40 @@
-
-// some global variables (yay)
+private {
-/** The full path to the current file */
-char[] curFile;
@@ -52 +53 @@
-/** The C++ functions/variables to explicitly ignore */
-char[][] ignoreSyms;
+}
-/** The D output */
-char[] dhead;
@@ -57 +59 @@
-/** The C[++] output */
-char[] cout;
+private {
+/** The class currently being processed */
-char[] curClass;
+/** Was a constructor made for the current class? */
+bool hasConstructor;
+/** Was an accessable constructor made for the current class? */
+bool hasPublicConstructor;
-/** Should we output C instead of C++ */
-bool outputC;
@@ -64 +72 @@
-/** Should we generate consts for enums? */
-bool outputEnumConst;
+/** Should we output reflections? */
+bool outputReflections;
-/** Other BCD requirements */
-char[][char[]] reqDependencies;
@@ -69 +79 @@
-xmlNode *gccxml = null;
-
+/** Class currently being reflected into D */
+char[] curReflection;
+/** The base of the class currently being reflected (in C++) */
+char[] curReflectionCBase;
+/** The base of the class currently being reflected (in D) */
+char[] curReflectionDBase;
+/** The initializer for the current reflection */
+char[] curReflectionInit;
+/** The C++ code for the class currently being reflected */
+char[] reflectionCode;
+/** The C++ code to go after we close the class */
+char[] reflectionPostCode;
+/** The functions that have already been reflected */
+bool[char[]] reflectedFunctions;
+
-char[][char[]] files;
+}
-
-
@@ -88 +114 @@
-        writefln("  -R<include directory>=<BCD/D namespace>");
-        writefln("    Depend upon other BCD namespaces.");
+        writefln("  -r");
+        writefln("    Reflect C++ classes such that D classes can derive from");
+        writefln("    them.");
-        writefln("  -E");
-        writefln("    Generate const int's for unnamed enum values");
@@ -156 +185 @@
-            outputEnumConst = true;
-            
+        } else if (args[i] == "-r") {
+            outputReflections = true;
+
-        } else {
-            writefln("Argument %s not recognized.", args[i]);
@@ -419 +451 @@
- * Parse the members of a node
- */
-
+, bool reflection = false
-{
-    char *members = xmlGetProp(node, "members");
@@ -429 +461 @@
-    // parse each member in the memberList
-    foreach (m; memberList) {
-
+, reflection
-    }
-}
@@ -481 +513 @@
- * Parse a GCC_XML node for a specified ID
- */
-
+, bool reflection = false
-{
-    xmlNode *curNode = null;
@@ -492 +524 @@
-            char *id = xmlGetProp(curNode, "id");
-            if (parseFor != toStringFree(id)) continue;
+
+            if (nname == "Constructor") {
+                // this may be private or otherwise unparsable, but we do have one
+                hasConstructor = true;
+            }
-            
-            // types that can be nameless:
@@ -515 +552 @@
-            
-            if (nname == "Variable" || nname == "Field") {
-
+ && !reflection
-            } else if (nname == "Method") {
-
+, reflection
-            } else if (nname == "OperatorMethod") {
-
+, reflection
-            } else if (nname == "Function") {
-
+ && !reflection
-            } else if (nname == "Constructor") {
-
+, reflection
-            } else if (nname == "Destructor") {
-                // this code is automatic :)
-            } else if (nname == "Typedef") {
-
+ && !reflection
-            } else if (nname == "Enumeration") {
-
+ && !reflection
-            } else {
-                writefln("I don't know how to parse %s!", nname);
@@ -601 +638 @@
-    char[] mangled = toStringFree(getMangled(node));
-    char[] demangled = toStringFree(getDemangled(node));
+    char* isabstract = xmlGetProp(node, "abstract");
+    if (isabstract) free(isabstract);
+    curClass = demangled;
+    hasConstructor = false;
+    hasPublicConstructor = false;
-    
-    parseMembers(node, true, true);
@@ -626 +668 @@
-    dtail ~= "}\n";
-    
+    dtail ~= "this(ifloat ignore, void *x) {\n";
+    dtail ~= "super(ignore);\n";
+    dtail ~= "__C_data = x;\n";
+    dtail ~= "}\n";
+    
-    cout ~= "void _BCD_delete_" ~ mangled ~ "(" ~ demangled ~ " *This) {\n";
-    cout ~= "delete This;\n";
@@ -637 +684 @@
-    dtail ~= "}\n";
-    
-    curClass = demangled;
-    
-    parseMembers(node, true, false);
+    
+    // if the constructor is implicit, replicate it here
+    if (!hasConstructor && !isabstract) {
+        dhead ~= "extern (C) void *_BCD_new_" ~ mangled ~ "();\n";
+        dtail ~= "this() {\n";
+        dtail ~= "super(cast(ifloat) 0);\n";
+        dtail ~= "__C_data = _BCD_new_" ~ mangled ~ "();\n";
+        dtail ~= "}\n";
+        cout ~= demangled ~ " *_BCD_new_" ~ mangled ~ "() {\n";
+        cout ~= "return new " ~ demangled ~ "();\n";
+        cout ~= "}\n";
+    }
+    
-    dtail ~= "}\n";
+    
+    // now make the reflected class
+    if (!outputReflections) return;
+    if (isabstract) return; // not for abstract classes yet
+    curReflectionCBase = demangled;
+    curReflectionDBase = safeName(name);
+    curReflection = curReflectionDBase ~ "_R";
+    curReflectionInit = "_BCD_RI_" ~ mangled;
+    
+    dhead ~= "extern (C) void " ~ curReflectionInit ~ "(void *cd, void *dd);\n";
+    
+    dtail ~= "class " ~ curReflection ~ " : " ~ curReflectionDBase ~ " {\n";
+    
+    dhead ~= "extern (C) void _BCD_delete_" ~ mangled ~ "__" ~ curReflection ~ "(void *This);\n";
+
+    dtail ~= "~this() {\n";
+    dtail ~= "if (__C_data) _BCD_delete_" ~ mangled ~ "__" ~ curReflection ~ "(__C_data);\n";
+    dtail ~= "__C_data = null;\n";
+    dtail ~= "}\n";
+    
+    reflectionPostCode = "";
+    
+    reflectionCode = "}\n"; // close the extern "C"
+    reflectionCode ~= "class " ~ curReflection ~ " : " ~ curReflectionCBase ~ " {\n";
+    reflectionCode ~= "public:\n";
+    reflectionCode ~= "void *__D_data;\n";
+
+    hasConstructor = false;
+    hasPublicConstructor = false;
+    parseBaseReflections(node);
+    
+    reflectionCode ~= "};\n";
+    reflectionCode ~= "extern \"C\" {\n";
+    
+    cout ~= reflectionCode ~ reflectionPostCode;
+    
+    reflectionCode = "";
+    reflectedFunctions = null;
+    
+    cout ~= "void _BCD_delete_" ~ mangled ~ "__" ~ curReflection ~ "(" ~ curReflection ~ " *This) {\n";
+    cout ~= "delete This;\n";
+    cout ~= "}\n";
+    
+    // if the constructor is implicit, make it here
+    if (!hasConstructor) {
+        dhead ~= "extern (C) void *_BCD_new_" ~ mangled ~ "__" ~ curReflection ~ "();\n";
+        dtail ~= "this() {\n";
+        dtail ~= "super(cast(ifloat) 0);\n";
+        dtail ~= "__C_data = _BCD_new_" ~ mangled ~ "__" ~ curReflection ~ "();\n";
+        dtail ~= "}\n";
+        cout ~= curReflection ~ " *_BCD_new_" ~ mangled ~ "__" ~ curReflection ~ "() {\n";
+        cout ~= "return new " ~ curReflection ~ "();\n";
+        cout ~= "}\n";
+    } else if (!hasPublicConstructor) {
+        dtail ~= "this() { super(cast(ireal) 0); }\n";
+    }
+    
+    dtail ~= "}\n";
+    
+    // then make the initializer
+    cout ~= "void _BCD_RI_" ~ mangled ~ "(" ~ curReflection ~ " *cd, void *dd) {\n";
+    cout ~= "cd->__D_data = dd;\n";
+    cout ~= "}\n";
+}
+
+/**
+ * Recursively and reflectively parse a class' bases
+ */
+void parseBaseReflections(xmlNode *node)
+{
+    xmlNode *curNode = null;
+    for (curNode = node.children; curNode; curNode = curNode.next) {
+        if (curNode.type == xmlElementType.XML_ELEMENT_NODE) {
+            if (toString(curNode.name) == "Base") {
+                
+                // find the base class
+                char[] type = toStringFree(xmlGetProp(curNode, "type"));
+                xmlNode *curBCNode = null;
+                for (curBCNode = gccxml.children; curBCNode; curBCNode = curBCNode.next) {
+                    if (curBCNode.type == xmlElementType.XML_ELEMENT_NODE) {
+                        if (type == toStringFree(xmlGetProp(curBCNode, "id"))) {
+                            // parse this one too
+                            parseBaseReflections(curBCNode);
+                        }
+                    }
+                }
+                
+            }
+        }
+    }
+    
+    // then parse this level
+    parseMembers(node, true, false, true);
-}
-
@@ -753 +904 @@
-void parse_Arguments(xmlNode *node, inout char[] Dargs, inout char[] Deargs,
-                     inout char[] Cargs, inout char[] Dcall,
-
+ bool reflection = false,
-                     int *argc = null)
-{
@@ -772 +923 @@
-                    Dargs ~= ", ";
-                }
-
-
-
+
+
+
+
+
+
+
-                    // this becomes a void * in D's view
-                    if (Deargs != "") {
-                        Deargs ~= ", ";
-                    }
- ~ aname
+
-                } else {
-                    if (Deargs != "") {
-                        Deargs ~= ", ";
-                    }
- ~ " " ~ aname
+
-                }
-                
@@ -795 +950 @@
-                    Dcall ~= ", ";
-                }
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                }
-                
@@ -806 +971 @@
-                        Ccall ~= ", ";
-                    }
-
+
+
+
+
+
-                } else {
-                    if (Ccall != "") {
@@ -890 +1059 @@
-}
-
+void parse_Function_reflection(xmlNode *node, char[] name, char[] cname,
+                               char[] mangled, ParsedType type,
+                               char[] Dargs, char[] Deargs, char[] Cargs, char[] Dcall, char[] Ccall)
+{
+    // tie to the particular class being reflected
+    mangled ~= "__" ~ curReflection;
+
+    // make sure it's not already reflected
+    char[] fid = name ~ "(" ~ Deargs ~ ")";
+    if (fid in reflectedFunctions) return;
+    reflectedFunctions[fid] = true;
+    
+    // make sure it's virtual
+    char* isvirtual = xmlGetProp(node, "virtual");
+    if (isvirtual) free(isvirtual);
+    else return;
+    
+    // the C++ interface to the reflection
+    cout ~= "int _BCD_R_" ~ mangled ~ "_CHECK(void *);\n";
+    
+    if (Cargs != "")
+        cout ~= type.CType ~ " _BCD_R_" ~ mangled ~ "(void *, " ~ Cargs ~ ");\n";
+    else
+        cout ~= type.CType ~ " _BCD_R_" ~ mangled ~ "(void *);\n";
+    
+    reflectionCode ~= type.CType ~ " " ~ name ~ "(" ~ Cargs ~ ") {\n";
+    
+    reflectionCode ~= "if (_BCD_R_" ~ mangled ~ "_CHECK(__D_data))\n";
+    if (type.CType != "void") reflectionCode ~= "return ";
+    
+    reflectionCode ~= "_BCD_R_" ~ mangled ~ "(__D_data";
+    if (Ccall != "") reflectionCode ~= ", ";
+    reflectionCode ~= Ccall ~ ");\n";
+    
+    reflectionCode ~= "else\n";
+    if (type.CType != "void") reflectionCode ~= "return ";
+    reflectionCode ~= curReflectionCBase ~ "::" ~ cname ~ "(" ~ Ccall ~ ");\n";
+    reflectionCode ~= "}\n";
+    
+    // and the D interface
+    dhead ~= "extern (C) int _BCD_R_" ~ mangled ~ "_CHECK(" ~ curReflection ~ " x) {\n";
+    dhead ~= "union dp {\n";
+    dhead ~= type.DType ~ " delegate(" ~ Deargs ~ ") d;\n";
+    dhead ~= "struct { void *o; void *f; }\n";
+    dhead ~= "}\n";
+    dhead ~= "dp d; d.d = &x." ~ name ~ ";\n";
+    dhead ~= "return cast(int) (d.f != &" ~ curReflectionDBase ~ "." ~ name ~ ");\n";
+    dhead ~= "}\n";
+    
+    dhead ~= "extern (C) " ~ type.DType ~ " _BCD_R_" ~ mangled ~ "(" ~ curReflection ~ " __D_class, " ~
+    Dargs ~ ") {\n";
+    if (type.DType != "void") dhead ~= "return ";
+    dhead ~= "__D_class." ~ name ~ "(" ~ Dcall ~ ");\n";
+    dhead ~= "}\n";
+}
+
-/**
- * Parse a Method node
- */
-
+, bool reflection
-{
-    char[] name = getNName(node);
@@ -899 +1124 @@
-    ParsedType type = parseType(toStringFree(xmlGetProp(node, "returns")));
-    char[] Dargs;
-
-
-
+
+
+
+
+
+
-    char[] Ccall;
-    
-
-
-
+
+
+
+
+
+
+
-}
-
@@ -912 +1144 @@
- * Parse an OperatorMethod node
- */
-
+, bool reflection
-{
-    char[] name = toStringFree(xmlGetProp(node, "name"));;
@@ -918 +1150 @@
-    ParsedType type = parseType(toStringFree(xmlGetProp(node, "returns")));
-    char[] Dargs;
-
-
-
+
+
+
+
+
+
-    char[] Ccall;
-    int argc;
-    
-
+reflection, 
-    
-    // get the D name
@@ -1069 +1304 @@
-    if (dname == "") return;
-    
-
-
+
+
+
+
+
+
-}
-
@@ -1102 +1341 @@
- * Parse a Constructor node
- */
-
+, bool reflection
-{
-    if (outputC) return; // no constructors in C
@@ -1108 +1347 @@
-    char[] name = getNName(node);
-    char[] mangled = toStringFree(getMangled(node));
+    if (reflection) mangled ~= "_R";
-    
-    while (find(mangled, "*INTERNAL*") != -1) {
@@ -1114 +1354 @@
-    
-    char[] Dargs;
-
+
+
-    char[] Cargs;
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-    char[] Ccall;
-    
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-    
-    dhead ~= "extern (C) void *_BCD_new_" ~ mangled ~ "(" ~ Deargs ~ ");\n";
@@ -1131 +1387 @@
-    dtail ~= "super(cast(ifloat) 0);\n";
-    dtail ~= "__C_data = _BCD_new_" ~ mangled ~ "(" ~ Dcall ~ ");\n";
+    if (reflection) {
+        dtail ~= curReflectionInit ~ "(__C_data, cast(void *) this);\n";
+    }
-    dtail ~= "}\n";
-    
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -1377 +1649 @@
-                        pt.DType ~= " *";
-                        pt.isClassPtr = true;
+                        
+                        // if this is a const, our const will be on the wrong side!
+                        if (pt.CType.length >= 7 &&
+                            pt.CType[pt.CType.length - 7 .. pt.CType.length] == "* const") {
+                            pt.CType[pt.CType.length - 7 .. pt.CType.length] = "const *";
+                        }
+                        
-                        parsedCache[type] = pt;
-                    } else {
@@ -1419 +1698 @@
-                    
-                        // 1) cut off the *
-
+
+
-                        
-                        // 2) add the &
@@ -1493 +1773 @@
-                    // this is just a const
-                    ParsedType pt = parseType(toStringFree(xmlGetProp(curNode, "type")));
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
-                        pt.CType[0..6] != "const ")
-
+
+
+
-                    parsedCache[type] = pt;
-