Changeset 98

Timestamp:

01/02/06 05:01:50 (3 years ago)

Author:

Don Clugston

Message:

Dynamic library: added a clean interface for dynamically loading classes. Currently requires that an interface be used; only 0-2 constructor parameters are included at present (it is trivial to add more).
Fold in changes for DMD 0.142 (many fewer hacks required in 'meta' library).

Files:

• trunk/ddl/DynamicLibrary.d (modified) (1 diff)
• trunk/ddl/Mangle.d (modified) (1 diff)
• trunk/meta/conv.d (modified) (6 diffs)
• trunk/meta/strhacks.d (modified) (4 diffs)
• trunk/meta/string.d (modified) (1 diff)
• trunk/test/linktest1.d (modified) (2 diffs)
• trunk/test/testclassinterface.d (added)
• trunk/test/testmodule.d (modified) (2 diffs)

trunk/ddl/DynamicLibrary.d

@@ -68 +68 @@
-    public bit isCModule(){
-        return true;
-
-
-
-
-
+
+
+
-    
-    template getDExport(T, char [] name) {
-        static if(T.mangleof[0] == 'P'){
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-        }
-    }
-    
-template getCtor(Tfn, char[] classname){
-   typeof(Tfn) getCtor(){ 
-   //TODO: hack up the mangleof of Tfn, to replace the return type as the correct type.
-typeof(Tfn))getExportAddress( "_D" ~  mangleText!(classname) ~ "_ctor" ~ Tfn.mangleof ~  mangleText!(classname)); 
+/// Load the ClassInfo corresponding to classname.
+template getClassInfo(char[] classname){
+ClassInfo getClassInfo(){
+ClassInfo)getExport("__Class_" ~  mangleSymbolName!(classname)).address;
-        }
-    }
+    /**   TInterface function(P1)  getCtor!(TInterface, classname, P1);
+     *
+     *  Returns a function which constructs a class, using the given parameters.
+     *  For example:
+     *  ------------
+     *  auto newFoo = getCtor("FooModule.Foo", char [], real);
+     *  auto newFooI = getCtor("FooModule.Foo", int);
+     *  x = newFooI(58);
+     *  y = newFoo("Avogadro's Number", 6.022e23);
+     * -----------------
+     *  is equivalent to:
+     * -----------------
+     *  x = new FooModule.Foo(58);
+     *  y = new FooModule.Foo("Avogadro's Number", 6.022e23);
+     * -----------------
+     */
+    // TODO: might be better to return a delegate?
+    template getCtor(TInterface, char [] classname) {
+        TInterface function() getCtor() {
+            static ClassInfo typeClass;
+            typeClass = getClassInfo!(classname)();
+            static Object function (Object) rawCtor;
+            rawCtor = cast(Object function (Object)) getExport(
+                "_D" ~ mangleSymbolName!(classname) ~ mangleSymbolName!("_ctor") 
+                ~ "F"
+                ~ "ZC" ~ mangleSymbolName!(classname)).address;     
+            static TInterface internalCtor() {
+                  auto a = _d_newclass(typeClass);
+                  rawCtor(a);
+                  return cast(TInterface)a;
+           }
+        
+           return &internalCtor;
+       }
+    }
-    
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}

trunk/ddl/Mangle.d

@@ -38 +38 @@
-import meta.strhacks;
-
-
+
+
+
+
+
-{
-  static if (text.length<1)  {
-strlen!(latestword)
-Text
-Text = itoa!(strlen!(latestword)
+latestword.length
+SymbolName
+SymbolName = itoa!(latestword.length
-  } else static if (text[0]=='.') {
-Text
-strlen!(latestword)) ~ latestword ~ .mangleText!(slice!(text, 1, strlen!(text))
+SymbolName
+latestword.length) ~ latestword ~ .mangleSymbolName!(text[1..(text.length)]
-  } else
-Text = .mangleText!( slice!(text, 1, strlen!(text)), concat!(latestword,slice!(text, 0, 1)
+SymbolName = .mangleSymbolName!( text[1..(text.length)], concat!(latestword,text[0..(1)]
-} 

trunk/meta/conv.d

@@ -4 +4 @@
-  * so most of these functions have unique names.
-  * Compile with -version=testmeta to run unit tests.
+  * Author: Don Clugston. License: Public domain.
-  */
-  
@@ -19 +20 @@
-template itoa(long n)
-{
-
-
-
+
+
+
+
+
+
+
-}
-
-template toHexString(ulong n)
-{
-
-
+
+
+
+
+
-}
-
@@ -37 +45 @@
-  static if (s.length==indx) const long atoi=sofar;
-  else static if (indx==0 && s[indx]=='-') const long atoi = -.atoi!(s, 0, 1);
-getcharat!(s, indx)
-(getcharat!(s, indx)-'0')
+cast(char) s[indx]
+s[indx]-'0'
-}
-
-/*******************************************************
-digits
+characters in s[]
- */
-template countleadingdigits(char [] s, int indx=0)
-{
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -67 +101 @@
-template fcvt(real x)
-{
-
-
-
+
+
+
+
+
+
+
-}
-
@@ -91 +129 @@
-
-version(testmeta) {
-
+private 
- 
- static assert( streq!(itoa!(5638), "5638"));
@@ -100 +138 @@
- static assert( countleadingdigits!("325827wip")==6);
- static assert( countleadingdigits!("abc")==0);
+ static assert( sigfigs!("1.2500")==5);
+ static assert( sigfigs!("-380.0")==4);
+ static assert( sigfigs!("0")==1);
+ static assert( sigfigs!("-1.20e49")==3);
-}

trunk/meta/strhacks.d

@@ -1 @@
-1
+2
- *
- * Most of these are only required when they are used as a template value parameter.
@@ -8 +8 @@
-{
-  const int strlen = str.length;
-}
-
-///  = str[from..to]
-template slice(char [] str, int from, int to)
-{
-  const char [] slice = str[from..to];
-}
-
-// = str[n]
-template getcharat(char [] str, int n)
-{
-  const char getcharat = str[n];
-}
-
-/// = str[from..$]
-template sliceheadoff(char [] str, int from)
-{
-  const char [] sliceheadoff = str[from..str.length];
-}
-
-template slicetailoff(char [] str, int charstochopoff)
-{
-  const char [] slicetailoff = str[0..str.length-charstochopoff];
-}
-
@@ -44 +21 @@
-  else static if (str1[0]!=str2[0]) const bool streq=false;
-  else static if (str1.length==1) const bool streq=true;
-lice!(str1, 1, strlen!(str1)), slice!(str2, 1, strlen!(str2))
+tr1[1..(str1.length)], str2[1..(str2.length)]
-}
-
@@ -72 +49 @@
- static assert(!streq!("abc", "axc") );
- static assert(!streq!("abc", "abcd") );
-
+
+
-}
+
+//-----------------------------------------------------------------
+// Workarounds required for DMD 0.141, fixed for DMD 0.142
+
+///  = str[from..to]
+template slice(char [] str, int from, int to)
+{
+  const char [] slice = str[from..to];
+}
+
+/// = str[from..$]
+template sliceheadoff(char [] str, int from)
+{
+  const char [] sliceheadoff = str[from..str.length];
+}
+
+template slicetailoff(char [] str, int charstochopoff)
+{
+  const char [] slicetailoff = str[0..str.length-charstochopoff];
+}
+
+// Actually this is still buggy in DMD 0.142, you need to cast(char).
+// = str[n]
+template getcharat(char [] str, int n)
+{
+  const char getcharat = str[n];
+}
+
+//-----------------------------------------------------------------

trunk/meta/string.d

@@ -8 +8 @@
-{
-  static if (str.length==0) const char[] chomp=str;
-len!(str)-
-licetailoff!(str, 1)
+.length - 
+tr[0..(str.length-1)]
-  else const char [] chomp = str;
-}

trunk/test/linktest1.d

@@ -13 +13 @@
-    - tests those exported handles
-*/
+
+private import test.testclassinterface;
+
+template getCtorName(char [] fullclassname)
+{
+ const char [] getCtorName = "_D" ~ mangleSymbolName!(fullclassname) 
+    ~ mangleSymbolName!("_ctor") ~ "FZC" ~ mangleSymbolName!(fullclassname);
+}
+
+template getCtorName(char [] fullclassname, P1)
+{
+ const char [] getCtorName = "_D" ~ mangleSymbolName!(fullclassname) 
+    ~ mangleSymbolName!("_ctor") ~ "F" ~P1.mangleof ~ "ZC" ~ mangleSymbolName!(fullclassname);
+}
+
-void main(){
-    Stdout.println("Starting.");
@@ -29 +44 @@
-    Stdout.println("add: 42+69 = %d",addFun(42,69));
-    helloWorld();
+
+    // Create a class using two different constructors. We need to specify
+    // the interface we'll be using (in this case, ITestClass).
+   
+    // Constructor with no parameters
+    auto newTestClass = testLibrary.getCtor!(ITestClass, "test.testmodule.TestClass")();
+    auto a = newTestClass();  
+
+    // Constructor with one parameter
+    auto newTestClass1 = testLibrary.getCtor!(ITestClass, "test.testmodule.TestClass", int)();
+    auto b = newTestClass1(31415);
+
+    // Call a member function of the interface
+    a.callable();
+    b.callable();
-    
-    Stdout.println("Done.");

trunk/test/testmodule.d

@@ -26 +26 @@
-
-private import std.stdio;
+import test.testclassinterface;
-
-
+
+
-    uint a;
-    
-    public this(){
-        a = 1;
-
+ with no parameters
-        test();
+    }
+    public this(int w)
+    {
+      a=w;
+      printf("TestClass created with parameter %d\n", w);
+      test();
+      
+    }
+    public void callable() {
+      writefln("In externally callable function, A=", a);
-    }
-    
@@ -41 +53 @@
-    
-    static this(){
-
+i
-    }
-}