Changeset 267

Timestamp:

03/21/08 20:44:22 (9 months ago)

Author:

BCS

Message:

updated dparse.d
added some debugging code
a bunch of formatting and commenting
added a "special actions" system (more on that later)

Files:

• trunk/dparser/dparse.d (modified) (33 diffs)

trunk/dparser/dparse.d

@@ -81 +81 @@
-private import glue.templates;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-
-
@@ -103 +91 @@
-abstract class PObject
-{
+    ///
-    abstract bool fail();
-
-
-
+
+
+
+
+
+
+
+
-class PObjectVectorBase : PObject
-{
+    char[] BaseName(){return typeof(this).stringof;}
-    abstract char[] string();
-}
@@ -117 +112 @@
-class PObjectVector(uint i) : PObjectVectorBase
-{
+    char[] BaseName(){return typeof(this).stringof;}
-    alias Tupleof!(i,PObject) type;
-    type data;
@@ -128 +124 @@
-    this(PObject[i] d)
-    {
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-    }
-
@@ -143 +149 @@
-            default: throw new Error("Out of bound");
-        }
+    }
+
+    /// Get the j'th item
+    PObject GetT(uint j)()
+    {
+        static if(j<data.length)
+            return data[j];
+        else
+            static assert(false);
-    }
-
@@ -167 +182 @@
-}
-
+/************************************************
+    Common base type for BoxObject types
+*/
-class PObjectBoxBase : PObject
-{
+    char[] BaseName(){return typeof(this).stringof;}
-    abstract char[] string();
-}
@@ -176 +195 @@
-class PObjectBox(T,bool str = true) : PObjectBoxBase
-{
+    char[] BaseName(){return typeof(this).stringof~"!("~T.stringof~")";}
-    T t;
-
+    ///
-    T Get() { return t; }
-
+    ///
-    this(T ti){t=ti;}
-
-    bool fail() { return false; }
-
+    ///
-    char[] string()
-    {
@@ -190 +213 @@
-            static if(is(T == char[]))
-                return t;
+            else static if(is(ToString(t)))
+                return ToString(t);
-            else
-ToString(t)
+"<<"~T.stringof~">>"
-        }
-        else
@@ -203 +228 @@
-class PObjectList(T) : PObject
-{
+    char[] BaseName(){return typeof(this).stringof;}
-    debug(TypeReport) pragma(msg, ">>T-"__FILE__~":"~itoa!(__LINE__)~": "~typeof(this).stringof~"!("~T.stringof~")");
-
@@ -232 +258 @@
-    uint Count(){return at;}
-
+    ///
-    T[] get()
-    {
@@ -254 +281 @@
-}
-
+/************************************************
+    List Object that build to the left
+*/
-class PObjectListLeft(T) : PObjectList!(T)
-{
+    char[] BaseName(){return typeof(this).stringof;}
-    debug(TypeReport) pragma(msg, ">>T-"__FILE__~":"~itoa!(__LINE__)~": "~typeof(this).stringof~"!("~T.stringof~")");
-
@@ -306 +337 @@
-class PObjectSet : PObjectList!(PObject)
-{
+    char[] BaseName(){return typeof(this).stringof;}
-    /// Discard some PObjects
-    void Back(uint b)
@@ -312 +344 @@
-    }
-}
+
+
+
+/************************************************
+    Uniform term to prevent needing to know the
+    exact type at compile time.
+*/
+interface PInterfaceLeftFactor(T) { PObject InsertLeft(T,PObject); }
+
+/************************************************
+    PObject that uses T.Action!(str) to process a
+    left side term with a Right side term
+*/
+class PObjectLeftFactorT(T, int i, char[] str) : PObjectVector!(i), PInterfaceLeftFactor!(T)
+{
+    this(PObject[i] d){super(d);}
+
+    PObject InsertLeft(T that, PObject L)
+    {
+        PObject[i+1] args;
+
+        args[1..$] = Get;
+        args[0] = L;
+
+        return that.Action!(str)(args);
+    }
+}
+
+
-/************************************************
-    default fail object
@@ -317 +378 @@
-class PObjectFail : PObject
-{
+    char[] BaseName(){return typeof(this).stringof;}
-    char[][] msg;
-
@@ -339 +401 @@
-}
-
+/************************************************
+    default Pass object
+*/
+class PObjectPass : PObject
+{
+    char[] BaseName(){return typeof(this).stringof;}
+    this() { }
+    bool fail() { return false; }
+}
+
+/************************************************
+    default Filler object, returns fail state as instructed
+*/
-class PObjectFill : PObject
-{
+    char[] BaseName(){return typeof(this).stringof;}
-    bool b;
-    this(bool _b){b=_b;}
@@ -353 +429 @@
-    uint pos();
-    void pos(uint);
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-/******************************
@@ -447 +552 @@
-static const char[] test = ReduceWhite("hello");
-
+/*********************************
+    Extract # from "$(C,#,NAME)"
+*/
+int ExtractCount(char[] str)
+{
+    int ret = int.min;
+
+    if(str.length > 4 && '0' <= str[0] && str[0] <= '9')
+    {
+        ret = str[0] - '0';
+        for(int i = 1; i<str.length; i++)
+        {
+            if('0' <= str[i] && str[i] <= '9')
+            {
+                ret *= 10;
+                ret += str[i] - '0';
+            }
+            else
+                break;
+        }
+    }
+
+    return ret;
+}
+
+/*********************************
+    Extract NAME from "$(C,#,NAME)"
+*/
+char[] ExtractAct(char[] str)
+{
+    int c, i;
+    for(i=0; i < str.length && c < 2; i++)
+        c += (str[i] == ',');
+
+    str = str[i..$];
+    i=0;
+    while(i < str.length && str[i] != ')') i++;
+
+    return str[0..i];
+}
+
+/******************************************************************************
+******* Special Action Code
+******************************************************************************/
+
+/// Pack up stuff in a computed type of PObjectLeftFactorT Object
+PObject L_Action(T, char[] str ) (T, PObject[ExtractCount(str[4..$])] i)
+{
+    static const int c = ExtractCount(str[4..$]);
+    static const char[] n = ExtractAct(str);
+    static if(false) pragma(msg, str~" == $(L,"~c.stringof~","~n~")");
+
+    return new PObjectLeftFactorT!(T, c, n)(i);
+}
+
+/// Left Process a Leftmost term and right side terms list.
+PObject T_Action(T,char[] str) (T that, PObject[1+ExtractCount(str[4..$])] i)
+{
+    static const int num = ExtractCount(str[4..$]);
+    static const char[] act = ExtractAct(str);
+    static if(false) pragma(msg, str~" == $(T,"~num.stringof~","~act~")");
+
+    PObject[num] args = i[0..num];
+    auto ret = that.Action!(act)(args);
+
+    auto listO = cast(PObjectList!(PObject)) i[num]; 
+    auto list = listO.get;
+
+    foreach(obj; list)
+    {
+        auto Tobj = cast(PInterfaceLeftFactor!(T))obj;
+        ret = Tobj.InsertLeft(that,ret);
+    }
+    return ret;
+}
+
+template SpecialAction(T,char[] str)
+{
+    static if(str.length > 3 && str[0..2] == "$(")
+    {
+        static if(str[2] == 'T')
+            alias T_Action!(T,str) SpecialAction;
+        else static if(str[2] == 'L')
+            alias L_Action!(T,str) SpecialAction;
+        else
+            static assert (false, "unknown special action: "~str);
+    }
+    else
+        static assert (false, "unknown special action: "~str);
+}
+
+/******************************************************************************
+******* Parser
+******************************************************************************/
+
+
-/************************************************
-    Parse an Identifier name (ID ::= "[A-Za-z][A-Za-z0-9]*")
@@ -473 +674 @@
-alias Parse_ID!("   \t!hello world") Parse_ID_test2;
-static assert(!Parse_ID_test2.Match,"Parse_ID failed: ");
+}
+
+
+/************************************************
+    Parse an Sepcial action name name
+    '$([^)]*)' |
+    '$[A-Z][A-Za-z0-9_]*' |
+    '$'
+*/
+template Parse_SpecialAct (char[] str)
+{
+    private const char[] without = DropWhiteF(str);
+    //pragma(msg,">>"__FILE__":"~__LINE__.stringof[0..$-1]~": '"~without~\');
+
+    static if(without.length == 0 || without[0] != '$')
+    {
+        pragma(msg,">>"__FILE__":"~__LINE__.stringof[0..$-1]~": unknown Special '"~without~\');
+        const bool Match = false;
+    }
+    else
+    {
+        static if(
+            without.length == 1 ||
+            without[1] == ' ' ||
+            without[1] == '\t' ||
+            without[1] == '\n' ||
+            without[1] == '\r'
+            )
+        {
+            const bool Match = true;
+            const char[] Text = without[0..1];
+        }
+        else static if(without[1] == '(')
+        {
+            const bool Match = true;
+            const char[] Text = FindChar!(')')(without);
+        }
+        else static if(without.length > 2 && 'A' <= without[1] && without[1] <= 'Z')
+        {
+            const bool Match = true;
+            const char[] Text = without[0..2] ~ GetID(without[2..$]);
+        }
+        else
+        {
+            pragma(msg,">>"__FILE__":"~__LINE__.stringof[0..$-1]~": unknown Special '"~without~\');
+            const bool Match = false;
+            const char[] Text = "";
+        }
+
+        const char[] Remaining = without[Text.length .. $];
+        const char[] Used = str[0 .. $-Remaining.length];
+    }
+}
+struct UnittetParse_Parse_SpecialAct{
+    // Tests
+    static assert(Parse_SpecialAct!("$Ltree ").Match);
+    static assert(Parse_SpecialAct!("$(Ltree) ").Match);
+    static assert(Parse_SpecialAct!("$ ").Match);
+
+    //static assert(!Parse_SpecialAct!("$a ").Match);
+    //static assert(!Parse_SpecialAct!("a ").Match);
-}
-
@@ -536 +798 @@
-        static const bool Match = false;
-}
-{
-
-
-static assert(Parse_Item_test1.Match)
-static assert(Parse_Item_test1.Text == "hello"
-static assert(Parse_Item_test1.Used == " hello",       Parse_Item_test1.Used
-static assert(Parse_Item_test1.Remaining == " world"
-static assert(Parse_Item_test1.Type == ItemType.single
-
-
-static assert(Parse_Item_test2.Match)
-static assert(Parse_Item_test2.Text == "hello"
-static assert(Parse_Item_test2.Used == " hello +",       Parse_Item_test1.Used
-static assert(Parse_Item_test2.Remaining == "world"
-static assert(Parse_Item_test2.Type == ItemType.plus
-
-
-static assert(Parse_Item_test3.Match)
-static assert(Parse_Item_test3.Text == "hello"
-static assert(Parse_Item_test3.Used == " hello*",       Parse_Item_test1.Used
-static assert(Parse_Item_test3.Remaining == " +world"
-static assert(Parse_Item_test3.Type == ItemType.star
-
-
-static assert(Parse_Item_test4.Match)
-static assert(Parse_Item_test4.Text == "hello"
-static assert(Parse_Item_test4.Used == " hello?",       Parse_Item_test1.Used
-static assert(Parse_Item_test4.Remaining == "*+world"
-static assert(Parse_Item_test4.Type == ItemType.optional
-
-
-static assert(!Parse_Item_test5.Match)
-
+
+
+
+   alias Parse_Item!(" hello world") Parse_Item_test1
+   static assert(Parse_Item_test1.Match
+   static assert(Parse_Item_test1.Text == "hello"
+   static assert(Parse_Item_test1.Used == " hello",       Parse_Item_test1.Used
+   static assert(Parse_Item_test1.Remaining == " world"
+
+
+   alias Parse_Item!(" hello +world") Parse_Item_test2
+   static assert(Parse_Item_test2.Match
+   static assert(Parse_Item_test2.Text == "hello"
+   static assert(Parse_Item_test2.Used == " hello +",       Parse_Item_test1.Used
+   static assert(Parse_Item_test2.Remaining == "world"
+
+
+   alias Parse_Item!(" hello* +world") Parse_Item_test3
+   static assert(Parse_Item_test3.Match
+   static assert(Parse_Item_test3.Text == "hello"
+   static assert(Parse_Item_test3.Used == " hello*",       Parse_Item_test1.Used
+   static assert(Parse_Item_test3.Remaining == " +world"
+
+
+   alias Parse_Item!(" hello?*+world") Parse_Item_test4
+   static assert(Parse_Item_test4.Match
+   static assert(Parse_Item_test4.Text == "hello"
+   static assert(Parse_Item_test4.Used == " hello?",       Parse_Item_test1.Used
+   static assert(Parse_Item_test4.Remaining == "*+world"
+
+
+   alias Parse_Item!(" \t?*+world") Parse_Item_test5
+
-}
-
@@ -598 +860 @@
-        static const bool Match = false;
-}
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-/************************************************
@@ -615 +880 @@
-struct Parse_Case(char[] str)
-{
-
+
+
+
+
+
+
+
+
+
+
+
+
-    static if(act.Match)
-    {
@@ -633 +909 @@
-    else
-        static const bool Match = false;
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -707 +985 @@
-    }
-}
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -768 +1047 @@
-    }
-}
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -828 +1108 @@
-}
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-}
-
@@ -894 +1175 @@
-debug(dParse_runtime) int counter = 0;
-
-
+
+
+
-
-PObject Rule(ParserBase,rule)(ParserBase parserBase, IParser p)
@@ -901 +1184 @@
-    {
-        int ind = counter++;
-
-
-
-
-
-
-
+
+
+
+
-
-    static const char[] nameIs = rule.Name;
@@ -922 +1202 @@
-    caseLoop: foreach(ci,casev;rule.Disjuncts)
-    {
-Is
+.Name
-
-            // dump all checkpoints
@@ -955 +1235 @@
-            foreach(index, cl; casev.Clauses)
-            {
+                debug(dParse_runtime) p.mark();
+
-                static if(/*ci == 0 &&*/ index == 0 && nameIs == cl.Text)
-                    pragma(msg, "Directly recursive rule: "~nameIs)
@@ -969 +1251 @@
-                }
-
-
-
-                static if(cl.Type == ItemType.single || cl.Type == ItemType.plus)
-                {
-                    // for cases where empty match is not allowed
-                        // get one
-Is
+.Name
-                    auto tmpStore1 = parserBase.Terminal!(cl.Text)(p);
-
+
+
+
-
-                        // test it
@@ -985 +1267 @@
-                        {
-                            store = backups.Pop();  // get checkpoint
+                            debug(dParse_runtime) writef(">>>>>Poped %d\n", store.tag);
-                            p.pos = store.pos;      // move input steram back
-                            action = store.rule;    // set point to return to
@@ -1014 +1297 @@
-                static if(cl.Type != ItemType.single)
-                {
+                    debug(dParse_runtime)
+                    {
+                        writef("ReAttemping clause %s (%d)...\n", cl.Text, index);
+                        store.tag = tager++;
+                        writef("=======saved  %d @ ", store.tag);
+                        p.mark();
+                    }
-                    store.pos = p.pos;
-                    store.rule = CaseLable!(index).Revert;
-                    store.count = (cast(PObjectSet)temps[index]).Count();
-
-
+
+
+
+
-                    auto tmpStore2 = parserBase.Terminal!(cl.Text)(p);
-
+
+
+
-
-                    if(!tmpStore2.fail())
-                    {
-                        backups.Push(store);
-
-                        (cast(PObjectSet)temps[index]).Add(tmpStore2);
-
@@ -1044 +1337 @@
-        }
-        debug(dparse_verbose) pragma(msg,"\tdoing Action \""~casev.Action~\");
-
-
+
+
+
+
+
+
+
+
-    }
-
-    debug(dParse_runtime) writef("Return (%d)failed\n", ind);
-    return new PObjectFail("Failed while looking for "~nameIs~\n);//    debug(dparse_verbose) pragma(msg, ">>"__FILE__":"~itoa!(__LINE__)~": is this right?");
-Is
+.Name
-}
-