Added support for the D programming languge.

It is still a bit rough around some edges, particularly with regard to multi-threading and operator overloading, and there are some documentation bits missing, but it should be fine for basic use.

The test-suite should build and run fine with the current versions of DMD, LDC and Tango (at least) on Linux x86_64 and Mac OS X 10.6.

git-svn-id: https://swig.svn.sourceforge.net/svnroot/swig/trunk@12299 626c5289-ae23-0410-ae9c-e8d60b6d4f22

Examples/test-suite/d/director_classes_runme.2.d

@@ -0,0 +1,169 @@
+/**
+ * This test demonstrates director classes when the types are classes. Shown are
+ * virtual function calls which use classes passed by
+ *  - Value
+ *  - Reference
+ *  - Pointer
+ * as both parameters and return values
+ *
+ * The test also demonstrates directors used with:
+ *  - method overloading
+ *  - default parameters
+ *
+ * Note: Methods with default parameters that call up from C++ cannot call the
+ * overloaded D methods, see DefaultParms method.
+
+ * Expected output if PrintDebug enabled:
+ * ------------ Start ------------
+ * Base - Val(444.555)
+ * Base - Ref(444.555)
+ * Base - Ptr(444.555)
+ * Base - FullyOverloaded(int 10)
+ * Base - FullyOverloaded(bool 1)
+ * Base - SemiOverloaded(int -678)
+ * Base - SemiOverloaded(bool 1)
+ * Base - DefaultParms(10, 2.2)
+ * Base - DefaultParms(10, 1.1)
+ * --------------------------------
+ * Derived - Val(444.555)
+ * Derived - Ref(444.555)
+ * Derived - Ptr(444.555)
+ * Derived - FullyOverloaded(int 10)
+ * Derived - FullyOverloaded(bool 1)
+ * Derived - SemiOverloaded(int -678)
+ * Base - SemiOverloaded(bool 1)
+ * Derived - DefaultParms(10, 2.2)
+ * Derived - DefaultParms(10, 1.1)
+ * --------------------------------
+ * DDerived - Val(444.555)
+ * DDerived - Ref(444.555)
+ * DDerived - Ptr(444.555)
+ * DDerived - FullyOverloaded(int 10)
+ * DDerived - FullyOverloaded(bool true)
+ * DDerived - SemiOverloaded(-678)
+ * Base - SemiOverloaded(bool 1)
+ * DDerived - DefaultParms(10, 2.2)
+ * DDerived - DefaultParms(10, 1.1)
+ * ------------ Finish ------------
+ */
+module director_classes_runme;
+
+import std.exception;
+import std.stdio;
+import std.string;
+import director_classes.director_classes;
+import director_classes.Caller;
+import director_classes.Base;
+import director_classes.Derived;
+import director_classes.DoubleHolder;
+
+void main() {
+  if (PrintDebug) writeln("------------ Start ------------ ");
+
+  auto myCaller = new Caller();
+
+  // Test C++ base class.
+  {
+    scope myBase = new Base(100.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) writeln("--------------------------------");
+
+  // Test vanilla C++ wrapped derived class.
+  {
+    scope myBase = new Derived(200.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) writeln("--------------------------------");
+
+  // Test director / D derived class.
+  {
+    scope myBase = new DDerived(300.0);
+    makeCalls(myCaller, myBase);
+  }
+
+  if (PrintDebug) writeln("------------ Finish ------------ ");
+}
+
+void makeCalls(Caller myCaller, Base myBase) {
+  string myBaseType = myBase.classinfo.name.split(".")[$-1];
+  myCaller.set(myBase);
+
+  DoubleHolder dh = new DoubleHolder(444.555);
+
+  // Class pointer, reference and pass by value tests
+  enforce(myCaller.ValCall(dh).val == dh.val, "[1] failed");
+  enforce(myCaller.RefCall(dh).val == dh.val, "[2] failed");
+  enforce(myCaller.PtrCall(dh).val == dh.val, "[3] failed");
+
+  // Fully overloaded method test (all methods in base class are overloaded)
+  enforce(myCaller.FullyOverloadedCall(10) == myBaseType ~ "::FullyOverloaded(int)", "[4] failed");
+  enforce(myCaller.FullyOverloadedCall(true) == myBaseType ~ "::FullyOverloaded(bool)", "[5] failed");
+
+  // Semi overloaded method test (some methods in base class are overloaded)
+  enforce(myCaller.SemiOverloadedCall(-678) == myBaseType ~ "::SemiOverloaded(int)", "[6] failed");
+  enforce(myCaller.SemiOverloadedCall(true) == "Base" ~ "::SemiOverloaded(bool)", "[7] failed");
+
+  // Default parameters methods test
+  enforce(myCaller.DefaultParmsCall(10, 2.2) == myBaseType ~ "::DefaultParms(int, double)", "[8] failed");
+  if (myBase.classinfo == DDerived.classinfo) { // special handling for D derived classes, there is no other way to do this
+    enforce(myCaller.DefaultParmsCall(10) == myBaseType ~ "::DefaultParms(int, double)", "[9] failed");
+  } else {
+    enforce(myCaller.DefaultParmsCall(10) == myBaseType ~ "::DefaultParms(int)", "[10] failed");
+  }
+
+  myCaller.reset();
+}
+
+public class DDerived : Base {
+  public this(double dd) {
+    super(dd);
+  }
+
+  public override DoubleHolder Val(DoubleHolder x) {
+    if (PrintDebug) writefln("DDerived - Val(%s)", x.val);
+    return x;
+  }
+
+  public override DoubleHolder Ref(DoubleHolder x) {
+    if (PrintDebug) writefln("DDerived - Ref(%s)", x.val);
+    return x;
+  }
+
+  public override DoubleHolder Ptr(DoubleHolder x) {
+    if (PrintDebug) writefln("DDerived - Ptr(%s)", x.val);
+    return x;
+  }
+
+  public override string FullyOverloaded(int x) {
+    if (PrintDebug) writefln("DDerived - FullyOverloaded(int %s)", x);
+    return "DDerived::FullyOverloaded(int)";
+  }
+
+  public override string FullyOverloaded(bool x) {
+    if (PrintDebug) writefln("DDerived - FullyOverloaded(bool %s)", x);
+    return "DDerived::FullyOverloaded(bool)";
+  }
+
+  public override string SemiOverloaded(int x) {
+    string ret = "DDerived::SemiOverloaded(int)";
+    if (PrintDebug) writefln("DDerived - SemiOverloaded(%s)", x);
+    return ret;
+  }
+  alias Base.SemiOverloaded SemiOverloaded; // Alias in SemiOverloaded(bool x).
+
+  public override string DefaultParms(int x, double y) {
+    string ret = "DDerived::DefaultParms(int, double)";
+    if (PrintDebug) writefln("DDerived - DefaultParms(%s, %s)", x, y);
+    return ret;
+  }
+  // This method will never be called from C++ code because the two-parameter
+  // DefaultParams() has a default value for the second parameter there. It is
+  // only here to ensure consistent behavior for calls from C++ and D code.
+  public override string DefaultParms(int x) {
+    if (PrintDebug) writefln("DDerived - DefaultParms(%s)", x);
+    return DefaultParms(x, 1.1/*use C++ default here*/);
+  }
+}