Changeset 122

Timestamp:

01/19/06 02:43:39 (3 years ago)

Author:

Don Clugston

Message:

meta: added some compile-time name demangling to qualifiedname. Includes what I believe is the correct algorithm for demangling template names.

Files:

• trunk/meta/qualifiedname.d (modified) (1 diff)
• trunk/meta/qualtest.d (modified) (6 diffs)

trunk/meta/qualifiedname.d

@@ -28 +28 @@
-   .. (typeof(&outer!(A)).mangleof.length - pointerendlength-1)];
-}
+
+// =======================================================
+//  Now some functions to pull the qualified name apart
+// =======================================================
+private import meta.conv;
+private import meta.ctype;
+
+
+template demangleIsTemplate(char [] str)
+{
+   static if (str.length>2) {
+      static if (str[0]=='_' && str[1]=='_' && str[2]=='T') {
+          const bool demangleIsTemplate = true;
+        } else {
+           const bool demangleIsTemplate = false;
+        }
+   } else {
+          const bool demangleIsTemplate = true;
+   }
+}
+
+// It could be a template
+template demanglesubstring(char [] str)
+{
+
+  static if (demangleIsTemplate!(str)) {
+     const char [] demanglesubstring = convertToDotName!(str[3..(str.length)]) ~ 
+     "!("
+      ~ demangleTemplateParamList!(getDotNameTail!(str[3..(str.length)]))
+~ ")";
+  } else 
+  const char [] demanglesubstring = str;
+}
+
+template demangleTemplateParamList(char [] str, char[] commastr = "")
+{
+  static if (str[0]=='Z') {
+     const char [] demangleTemplateParamList = "";
+  } else static if (str[0]=='T') {
+     const char [] demangleTemplateParamList =  commastr ~ demangleType!(str[1..(str.length)]) ~ .demangleTemplateParamList!(getTypeTail!(str[1..(str.length)]), ", ");
+  } else static assert(0);
+}
+
+
+
+// (length)head tail
+// Gets the part of the string.
+template demanglegethead(char [] str)
+{
+  static if (str.length<=10 || !isdigit!( (str[1]) ) ) {
+     const char [] demanglegethead = str[
+     1..(str[0]-'0' + 1)];
+  } else static if (str.length<=100 || !isdigit!( (str[2]) )) {
+     const char [] demanglegethead = str[2..((str[0]-'0')*10 + str[1]-'0'+ 2)];
+  } else {
+     const char [] demanglegethead = 
+        str[3..((str[0]-'0')*100 + (str[1]-'0')*10 + str[0]-'0' + 3)];
+  }
+}
+
+template demanglegettail(char [] str)
+{
+   static if (str.length<=10 || !isdigit!( (str[1]) ) ) {
+     const char [] demanglegettail = str[(str[0]-'0'+1) .. str.length];
+  } else static if (str.length<=100 || !isdigit!( (str[2]) )) {
+     const char [] demanglegettail = str[((str[0]-'0')*10 + str[1]-'0'+2)..str.length];
+  } else {
+     const char [] demanglegettail = 
+        str[((str[0]-'0')*100 + (str[1]-'0')*10 + str[0]-'0' + 3)..str.length];
+  }
+}
+
+
+template convertToDotName(char [] str, char [] dotchar="")
+{
+    static if(str.length == 0) {
+        const char [] convertToDotName="";
+    } else static if (isdigit!((str[0]))) {
+        const char [] convertToDotName = dotchar ~ demanglesubstring!(demanglegethead!(str)) ~ .convertToDotName!(demanglegettail!(str), ".");
+  }
+  else const char [] convertToDotName="";
+}
+
+template getDotNameTail(char [] str)
+{
+    static if(str.length == 0) {
+        const char [] getDotNameTail="";
+    } else static if (isdigit!((str[0]))) {
+        const char [] getDotNameTail = .getDotNameTail!(demanglegettail!(str));
+  } else const char [] getDotNameTail = str;
+}
+
+// qualifiednameof!() can return one of two things:
+// (a) a type; (class, struct, typedef, enum) OR
+// (b) a static entity (function, variable, module, template).
+
+
+// Given a fully qualifed name, which is a type (ie, str[0] == 'T')
+// returns a text string describing the type
+template demangleClassifyType(char [] str)
+{
+  static if (str[1] == 'C') 
+        const char [] demangleClassifyType = "class  ";
+  else static if (str[1]=='S')
+        const char [] demangleClassifyType = "struct ";
+  else static if (str[1]=='T')
+        const char [] demangleClassifyType = "typedef";
+  else static if (str[1]=='E')
+        const char [] demangleClassifyType = "enum   ";
+  else const char [] demangleClassifyType = "unknown[ " ~ str ~ " ]";
+}
+
+template demangleSimpleType(char [] str)
+{
+  static if (str[0]=='i') const char [] demangleSimpleType="int";
+  else static if (str[0]=='e') const char [] demangleSimpleType="real";
+  else static if (str[0]=='v') const char [] demangleSimpleType="void";
+  else static if (str[0]=='k') const char [] demangleSimpleType="uint";
+//  else static if (str[0]=='j') const char [] demangleSimpleType="?k?";
+  else const char [] demangleSimpleType=" ?[" ~ str ~ "] ";
+}
+
+template getParamListTail(char [] str)
+{
+ static if (str[0]=='Z') {
+   const char [] getParamListTail=getTypeTail!(str[1..(str.length)]);
+ } else {
+    const char [] getParamListTail = getTypeTail!(str);
+ }
+}
+
+// where str[0] is a type, returns the part of str which was not consumed
+template getTypeTail(char [] str)
+{
+  static if(str[0]=='C' || str[0]=='S' || str[0]=='T' || str[0]=='E') {
+     const char [] getTypeTail = getDotNameTail!(str[1..(str.length)]);
+  } else static if (str[0]=='P') {
+   const char [] getTypeTail = .getTypeTail!(str[1..(str.length)]);
+  } else static if (str[0]=='F') {
+  const char [] getTypeTail = getParamListTail!(str[1..(str.length)]); 
+  } else const char [] getTypeTail = str[1..(str.length)];
+}
+
+template demangleReturnValue(char [] str)
+{
+  static if (str.length<2) {
+   const char[] demangleReturnValue = "(no return)";
+  } else
+  static if (str[0]=='Z') const char[] demangleReturnValue = demangleType!(str[1..(str.length)]);
+  else const char [] demangleReturnValue = .demangleReturnValue!(getTypeTail!(str));
+}
+
+template demangleParamList(char [] str, char[] commastr = "")
+{
+  static if (str[0]=='Z') {
+     const char [] demangleParamList = "";
+  } else {
+     const char [] demangleParamList = commastr ~ demangleType!(str) ~ .demangleParamList!(getTypeTail!(str), ",");
+  }
+}
+
+template demangleType(char [] str)
+{
+  static if (str[0] == 'C') 
+        const char [] demangleType = "class " ~ convertToDotName!(str[1..(str.length)]);
+  else static if (str[0]=='S')
+        const char [] demangleType = "struct " ~ convertToDotName!(str[1..(str.length)]);
+  else static if (str[0]=='T')
+        const char [] demangleType = "typedef " ~ convertToDotName!(str[1..(str.length)]);
+  else static if (str[0]=='E')
+        const char [] demangleType = "enum " ~ convertToDotName!(str[1..(str.length)]);
+  else static if (str[0]=='F')
+        const char [] demangleType = demangleReturnValue!(str[1..(str.length)]) ~ " function ("
+        ~ demangleParamList!(str[1..(str.length)]) ~ ")";
+  else static if (str[0]=='P')
+        const char [] demangleType = "*" ~ .demangleType!(str[1..(str.length)]);
+  else const char [] demangleType = demangleSimpleType!(str);
+}
+
+
+template demangleStatic(char [] str)
+{
+   static if (str[0]=='_' && str[1]=='D') {
+      const char [] demangleStatic = 
+      demangleType!(
+      getDotNameTail!(str[2..(str.length)])) ~ "  "
+       ~ convertToDotName!(str[2..(str.length)]);
+   } else static if (isdigit!( (str[0]) ) ) {
+     const char [] demangleStatic = convertToDotName!(str);
+   } else const char [] demangleStatic = " No type info: " ~ str;
+}
+
+template demangle(char [] str)
+{
+  static if (str[0] == 'T') {
+    const char [] demangle =  demangleType!(str[1..(str.length)]);
+  } else static if (str[0]=='S') {
+      const char [] demangle = demangleStatic!(demanglegethead!(str[1..(str.length)])); 
+      /+
+      // It seems this is always the full length
+       ~ "--"
+    ~ demanglegettail!(qualifiednameof!(A)[1..(qualifiednameof!(A).length)]);
+    +/
+   } else {
+     pragma(msg, "Unknown type " ~ str);     
+     static assert(0);
+   }
+}

trunk/meta/qualtest.d

@@ -1 +1 @@
-import meta.qualifiedname;
-import meta.conv;
-import meta.strhacks;
-import meta.ctype;
-
-
-ConvertToDotName(char [] str, char [] dotchar=""
+describe(alias A
-{
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-}
-
-
+
+
+
-
-class HeresAClass
@@ -40 +23 @@
-HeresAClass anInstance;
-
-
+, B
-{
-  int something;
-}
-
-template describe(alias A)
-{
-  static if (qualifiednameof!(A)[0] == 'T') {
-     static if (qualifiednameof!(A)[1] == 'C') {
-     const char [] describe = "Class:   " ~ ConvertToDotName!(qualifiednameof!(A)[2..(qualifiednameof!(A).length)]);
-     } else static if (qualifiednameof!(A)[1] == 'S') {
-     const char [] describe = "Struct:  " ~ ConvertToDotName!(qualifiednameof!(A)[2..(qualifiednameof!(A).length)]);
-     } else static if (qualifiednameof!(A)[1] == 'T') {
-     const char [] describe = "Typedef: " ~ ConvertToDotName!(qualifiednameof!(A)[2..(qualifiednameof!(A).length)]);
-     } else static if (qualifiednameof!(A)[1] == 'E') {
-     const char [] describe = "Enum:    " ~ ConvertToDotName!(qualifiednameof!(A)[2..(qualifiednameof!(A).length)]);
-     } else {
-          const char [] describe = "?Unknown: " ~ qualifiednameof!(A)[1..(qualifiednameof!(A).length)];
-          }
-
-  } else { // starts with 'S'...
-    static if (qualifiednameof!(A)[3]=='_') {
-    const char [] describe = "D external: " ~ ConvertToDotName!(qualifiednameof!(A)[5..(qualifiednameof!(A).length)]);
-    } else {
-      const char [] describe = "Special: " ~ ConvertToDotName!(qualifiednameof!(A)[1..(qualifiednameof!(A).length)]); // ~ " -- " ~ (A.mangleof);
-      }
-   }
-}
-
@@ -72 +31 @@
-extern (C) real aCFunction(int a, real b) { return b; }
-
+typedef real function(int, char []) FuncTypedef;
-typedef HeresAClass TypedefClass;
+
+real function (void function(int) f) FuncFuncPtr;
+typedef typeof(ThisIsATemplate!(real, int)) TemplateTypedef;
-
-enum   HeresAnEnum { Val1, Val2, Val3 };
@@ -84 +47 @@
-pragma(msg, describe!(HeresAnEnum));
-pragma(msg, describe!(anInstance.AndAnInnerStruct));
+pragma(msg, describe!(FuncTypedef));
+pragma(msg, describe!(TemplateTypedef));
-
-With D linkage, the type is at the end of the nam
+Some items With D linkag
-
-pragma(msg, describe!(aStaticFunction));
@@ -92 +57 @@
-pragma(msg, describe!(anInstance));
-pragma(msg, describe!(someExternalInt));
+pragma(msg, describe!(FuncFuncPtr));
-
-pragma(msg, \n "* Special cases" \n);
@@ -98 +64 @@
-pragma(msg, describe!(aWindowsFunction));
-pragma(msg, describe!(ThisIsATemplate));
-
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+