Changeset 160

Timestamp:

03/09/06 08:25:20 (2 years ago)

Author:

Don Clugston

Message:

Many accumulated changes to 'meta'. The most interesting is the one in feqtest, which tests floating point numbers for equality to the number of decimal places given in a string.

Files:

• trunk/meta/conv.d (modified) (5 diffs)
• trunk/meta/ctype.d (modified) (1 diff)
• trunk/meta/demangle.d (modified) (6 diffs)
• trunk/meta/demo/calcpi.d (modified) (2 diffs)
• trunk/meta/demo/tabledemo.d (modified) (2 diffs)
• trunk/meta/feqtest.d (added)
• trunk/meta/math.d (modified) (1 diff)
• trunk/meta/nameof.d (moved) (moved from trunk/meta/qualifiedname.d) (6 diffs)
• trunk/meta/qualtest.d (modified) (3 diffs)
• trunk/meta/strhacks.d (modified) (3 diffs)
• trunk/meta/string.d (modified) (5 diffs)

trunk/meta/conv.d

@@ -6 +6 @@
-  * Author: Don Clugston. License: Public domain.
-  */
+/*
+Normally, a function which processes the first part of a string
+would return the part which was not consumed (the 'tail').
+This doesn't work very well for D templates, so for such functions,
+we supply a seperate metafunction with the suffix 'Consumed' which returns
+the  number of characters consumed. (This is the same as the index of the first
+character in the string which was not consumed).
+This results in some code duplication, but seems to results in a much cleaner design.
+*/
-  
-module meta.conv;
@@ -20 +29 @@
-template itoa(long n)
-{
- {
-.
-} else static if (n<10L) {
+
+
+else static if (n<10L)
-        const char [] itoa = decimaldigit!(n);
-} else {
+else
-        const char [] itoa = itoa!(n/10L) ~ decimaldigit!(n%10L);
-    }
-}
-
-template toHexString(ulong n)
-{
- {
+
-        const char [] toHexString = hexdigit!(n);
-} else {
+else
-        const char [] toHexString = toHexString!(n >> 4) ~ hexdigit!(n&0xF);
-    }
-}
-
@@ -41 +48 @@
- *  long atoi!(char [] s);
- */
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -52 +63 @@
- *  the number of characters in s[] which would be 'consumed' by atoi!().
- */
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-// Given a number x, where 0<= x <1,
-// returns the first 'maxdigs' digits after the decimal point.
-template afterdec(real x, int maxdigs=real.dig)
-{
-
+  
-  else const char [] afterdec = decimaldigit!(cast(int)(x*10)) ~ afterdec!(x*10-cast(int)(x*10), maxdigs-1);
-}
@@ -138 +235 @@
-
-version(testmeta) {
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-
- static assert( atoi!("3580abc")==3580);
- static assert( atoi!("-0326")==-326);
-
-
-
-
-
-
-
-
+
+
+

trunk/meta/ctype.d

@@ +1 @@
+/*
+ * Written by Don Clugston
+ * Placed into the Public Domain
+ */
-/**
- * Simple ASCII character classification functions. Compile-time equivalents of std.ctype
+ * All these functions return false if presented with a non-ASCII character.
- */
-module meta.ctype;

trunk/meta/demangle.d

@@ -20 +20 @@
-{
-  static if (str[0] == 'T') {
-
+
+
+
-  } else {
-    const char [] extractQualifiedNameFromAliasParameter = extractQualifiedNameFromStatic!(demanglegethead!(str[1..$]), onlyWantLastPart); 
@@ -69 +71 @@
-      static if (getDotNameTail!(str[2..$])[0]=='F') {
-          // it's a function (not a function pointer)
-
+
+
+
+
+
-          getDotNameTail!(str[2..$]), 
-          convertToDotName!(str[2..$])
-          );
-
-
-demangleReturnValue!(str[1..(str.length)]) ~ " name ("
-(str.length)
+}
+
+const char [] demangleStatic = demangleReturnValue!(str[2..$]) ~ getDotNameTail!(str[2..$])
+$
-        */
-      } else {
@@ -162 +168 @@
-    static if(str.length == 0) {
-        const char [] convertToDotName="";
-
+ || (str.length>=4 && str[0..4]=="main") 
-       static if (onlyWantLastPart && demanglegettail!(str).length > 0) {
-         static if (isdigit!((demanglegettail!(str)[0]))) {
@@ -175 +181 @@
-            ~ .convertToDotName!(demanglegettail!(str), onlyWantLastPart, ".");
-       }
-
-
+
+
+
+
-}
-
@@ -184 +192 @@
-        const char [] getDotNameTail="";
-    } else static if (isdigit!((str[0]))) {
-
-
+
+
+
+
+
+
-}
-
-template demanglegethead(char [] str)
-{
-
+
+
+
-     const char [] demanglegethead = str[1..(str[0]-'0' + 1)];
-  } else static if (str.length<=100 || !isdigit!( (str[2]) )) {
@@ -202 +216 @@
-template demanglegettail(char [] str)
-{
-
+
+
+
-     const char [] demanglegettail = str[(str[0]-'0'+1) .. $];
-  } else static if (str.length<=100 || !isdigit!( (str[2]) )) {

trunk/meta/demo/calcpi.d

@@ -7 +7 @@
-import meta.math;
-import meta.conv;
-
-import std.math;
-
-/** real evaluateSeries!(real x, real metafunction!(real y, int n) term)
@@ -26 +24 @@
-     const real evaluateSeries = sumsofar;
-  } else {
-.
+
-  }
-}

trunk/meta/demo/tabledemo.d

@@ -3 +3 @@
-// Create a constant array of long or ulong-sized items. Needs to be cast back to
-// long[] or ulong[].
-
+AsChar
-{
-  static if ( entry!(0).sizeof == dchar.sizeof) {
-      // int or uint sized items
-      static if (n==0) {
-
+AsChar
-      } else {
- = generateArray
+AsChar = generateArrayAsChar
-      }
-  } else static if ( entry!(0).sizeof == 2*dchar.sizeof) {
-      // long or ulong sized items
-      static if (n==0) {
-
+AsChar
-                ~ cast(dchar)entry!(n) ~ cast(dchar)(entry!(n)>>>32);
-      } else {
- = generateArray
+AsChar = generateArrayAsChar
-            ~ cast(dchar)entry!(n)  ~ cast(dchar)(entry!(n)>>32);
-      }
@@ -24 +24 @@
-}
-
+template generateArray(alias entry, int n)
+{
+  const typeof(entry!(0)) [] generateArray = cast(typeof(entry!(0)) [])generateArrayAsChar!(entry, n);
+}
+
+// The ubiquitous factorial function
+//
-// Returns correct value for n=0 (factorial!(0)=1).
-template factorial(int n)
-{
-long
-long factorial = n * .
+int
+int factorial = n * 
-}
-
+// Make an array of all the factorials from 0 to 13 (14!> ulong.max)
+const smallfactorials = generateArray!(factorial, 13);
-
+
+/+
-// Make an array of all the factorials from 0 to 20 (21!> ulong.max)
-const ulong [] smallfactorials;
-
-static this()
-{
-long []) generateArray
+int []) generateArrayAsChar
-}
-
+
-import std.stdio;
-
-int
+void
-{
-  for (int i=0; i<smallfactorials.length; ++i) {
-     writefln(i, "  ", smallfactorials[i]);
-  }
- return 0;
-}
-
-/+
-// ---------- array literals version -----------
-
-template generateArray(alias entry, int n)
-{
-    static if (n==0) {
-        const typeof(entry!(0)) [] generateArray = [ entry!(n) ];
-    } else {
-        const typeof(entry!(0)) [] generateArray = generateArray!(entry, n-1) ~ [ entry!(n) ];
-    }
-}
-
-const smallfactorials = generateArray!(factorial, 20);
-+/

trunk/meta/math.d

@@ -13 +13 @@
-{
-  const bool isnan = (x!<>=0);
+}
+
+template isPositiveZero(real x)
+{
+    static if (x==0 && 1.0L/x > 0) 
+        const bool isPositiveZero = true;
+    else 
+        const bool isPositiveZero = false;
+}
+
+template isNegativeZero(real x)
+{
+    static if (x==0 && 1.0L/x < 0) 
+        const bool isNegativeZero = true;
+    else 
+        const bool isNegativeZero = false;
+}
+
+version(testmeta) {
+
+static assert( isPositiveZero!(0.0L));
+static assert( !isPositiveZero!(-0.0L));
+static assert( !isPositiveZero!(real.nan));
+static assert( isNegativeZero!(-0.0L));
+static assert( !isNegativeZero!(0.0L));
-}
-

trunk/meta/nameof.d

@@ -6 +6 @@
-// with a method that it does not use the identifier in any way.
-
-qualifiedname
+nameof
-private import meta.demangle;
-
@@ -18 +18 @@
-    }
-    
-
-
+
+
+
-    template outer(alias B)
-    {
@@ -28 +29 @@
-// If the identifier is "MyIdentifier" and this module is "QualModule"
-// The return value will be:
-P
+
-//   "C"     -- because the first parameter is a class
-//    "10QualModule"  -- the name of this module
@@ -51 +52 @@
-
-    // Get the number of chars at the start relating to the pointer
-P
+
-    // And the number of chars at the end
-    const int pointerendlength = "Z5innerZv".length;
+}
+
+template rawmanglednameof(alias A)
+{
+  const char [] rawmanglednameof  =
+  typeof(outer!(A)).mangleof;
-}
-
@@ -63 +70 @@
-{
-  const char [] manglednameof  =
-&
+
-}
-
@@ -71 +78 @@
-// Returns the unqualified name, as a single text string.
-// eg. "myfunc"
-basic
+symbol
-{
-basic
+symbol
-}
-

trunk/meta/qualtest.d

@@ -1 @@
-
+
+
+
-
-
@@ -5 +7 @@
-{
-  const char [] describe =
- ~
-   \n "Basic    : " ~ basic
-
-
+
+~   \n "Symbol   : " ~ symbol
+
+//
-}
-
@@ -100 +102 @@
-}
-
-pragma(msg, "\n-------\n  Local symbols are not yet supported, but there is hope...\n-------");
-
-
+
+
+
+
-{
+
-  class LocalClass {
+    class InnerClass {}
-    void LocalFunc() {}
-  }
-  pragma(msg, describe!(LocalClass.LocalFunc));
-
+
+
+
+
+
+
+
+
+
+
-
-  int LocalVar;
-  mixin getname!(LocalVar);
-  pragma(msg, describe!(getname));
+//  writefln(getname.mangleof);
-  
-}
+
+void main()
+{
+fmain();
+ // fmain(3, 4);
+}

trunk/meta/strhacks.d

@@ -1 @@
-3
+1 - 0.144.
- *
- * Most of these are only required when they are used as a template value parameter.
- */
+ 
-module meta.strhacks;
+version(none) {
-
-// return true if str1 == str2/
-template streq(char [] str1, char[] str2)
-{
-  static if (str1.length!=str2.length) const bool streq=false;
-  else static if (str1[0]!=str2[0]) const bool streq=false;
-  else static if (str1.length==1) const bool streq=true;
-  else const bool streq = .streq!(str1[1..(str1.length)], str2[1..(str2.length)]);
-}
-
-/// converts a single char to a char[]
-template makechar(int c)
-{
-  const char [] makechar=x"000102030405060708090a0b0c0d0e0f
-                           101112131415161718191a1b1c1d1e1f
-                           202122232425262728292a1b2c2d2e2f
-                           303132333435363738393a3b3c3d3e3f
-                           404142434445464748494a4b4c4d4e4f
-                           505152535455565758595a5b5c5d5e5f
-                           606162636465666768696a6b6c6d6e6f
-                           707172737475767778797a7b7c7d7e7f
-                           808182838485868788898a8b8c8d8e8f
-                           909192939495969798999a9b9c9d9e9f
-                           a0a1a2a3a4a5a6a7a8a9aaabacadaeaf
-                           b0b1b2b3b4b5b6b7b8b9babbbcbdbebf
-                           c0c1c2c3c4c5c6c7c8c9cacbcccdcecf
-                           d0d1d2d3d4d5d6d7d8d9dadbdcdddedf
-                           e0e1e2e3e4e5e6e7e8e9eaebecedeeef
-                           f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"[c..c+1];
-}
-
-version(testmeta) {
- static assert( streq!("abc", "abc"));
- static assert(!streq!("abc", "axc") );
- static assert(!streq!("abc", "abcd") );
-// static assert(streq!("abcdef", "abc" ~ "def")); // this crashes DMD 0.142
- static assert(streq!("abcdef", concat!("abc", "def")));
-}
-
-//-----------------------------------------------------------------
@@ -60 +25 @@
-
-//-----------------------------------------------------------------
-almost work in DMD 0.143 (need to add parentheses)
+fixed in DMD 0.144
-
-///  = str[from..to]
@@ -85 +50 @@
-  const char getcharat = str[n];
-}
+//-----------------------------------------------------------------
+//   Workarounds fixed in DMD 0.145
-
+// return true if str1 == str2
+template streq(char [] str1, char[] str2)
+{
+  static if (str1.length!=str2.length) const bool streq=false;
+  else static if (str1[0]!=str2[0]) const bool streq=false;
+  else static if (str1.length==1) const bool streq=true;
+  else const bool streq = .streq!(str1[1..(str1.length)], str2[1..(str2.length)]);
+}
+
+
+version(testmeta) {
+ static assert( streq!("abc", "abc"));
+ static assert(!streq!("abc", "axc") );
+ static assert(!streq!("abc", "abcd") );
+// static assert(streq!("abcdef", "abc" ~ "def")); // this crashes DMD 0.142
+ static assert(streq!("abcdef", concat!("abc", "def")));
+}
+
+/// converts a single char to a char[]
+template makechar(int c)
+{
+  const char [] makechar=x"000102030405060708090a0b0c0d0e0f
+                           101112131415161718191a1b1c1d1e1f
+                           202122232425262728292a1b2c2d2e2f
+                           303132333435363738393a3b3c3d3e3f
+                           404142434445464748494a4b4c4d4e4f
+                           505152535455565758595a5b5c5d5e5f
+                           606162636465666768696a6b6c6d6e6f
+                           707172737475767778797a7b7c7d7e7f
+                           808182838485868788898a8b8c8d8e8f
+                           909192939495969798999a9b9c9d9e9f
+                           a0a1a2a3a4a5a6a7a8a9aaabacadaeaf
+                           b0b1b2b3b4b5b6b7b8b9babbbcbdbebf
+                           c0c1c2c3c4c5c6c7c8c9cacbcccdcecf
+                           d0d1d2d3d4d5d6d7d8d9dadbdcdddedf
+                           e0e1e2e3e4e5e6e7e8e9eaebecedeeef
+                           f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"[c..c+1];
+}
+
+}

trunk/meta/string.d

@@ -9 +9 @@
-  static if (str.length==0) const char[] chomp=str;
-  else static if (str[str.length - 1]==delimiter) 
-.chomp!( str[0..(str.length-1)
+chomp!( str[0..$-1
-  else const char [] chomp = str;
-}
@@ -22 +22 @@
-  static if (str.length==n) const int find = -1;
-  else static if( c==str[n]) const int find = n;
-.
+
-}
-
@@ -34 +34 @@
-  static if (str.length==n) const int rfind = -1;
-  else static if( c==str[str.length - n - 1]) const int rfind = str.length - n - 1;
-.
+
-}
-
@@ -44 +44 @@
-   static if (n==0) const char [] repeat="";
-   else static if (n==1) const char [] repeat = str;
-.
+
-}
-
@@ -53 +53 @@
- static assert( -1 == rfind!("not in here either", 'z'));
- static assert( 4 == rfind!("but this is ok", 't'));
-streq!(repeat!("abc", 4), "abcabcabcabc")
+repeat!("abc", 4) == "abcabcabcabc"
-}