X-Git-Url: http://git.megacz.com/?p=sbp.git;a=blobdiff_plain;f=tests%2Fregression.tc;h=025f56e2e7a23e21054ffbb89a4053902f403b5d;hp=040bf84e8c0a37616da178ad0c4e6df8536b3051;hb=628b3a8eaafdbe8507e841076051bff42aadf5ee;hpb=0a0227b9180534d2a431f3d6e08a398bde2244c4

diff --git a/tests/regression.tc b/tests/regression.tc
index 040bf84..025f56e 100644
--- a/tests/regression.tc
+++ b/tests/regression.tc
@@ -2,9 +2,9 @@
 //    input  "x";
 //    output "a1:{x}";
 //
-//    s ::= a        => a1
-//    a ::= s        => s1
-//    a ::= ^"x"
+//    s   = a1:: a
+//    a   = s1:: s
+//    a   = ^"x"
 //}
 //
 //testcase {
@@ -14,20 +14,36 @@
 //    output "s2:{s0 x}";
 //
 //
-//    s ::= s s      => s2
-//    s ::= ^"x"
-//    s ::= ()       => s0
+//    s   = s2:: s s
+//    s   = ^"x"
+//    s   = s0:: ()
+//}
+
+testcase {
+    input "aaaaa";
+    s = A
+    A = "a" s &~ "a" A
+      | "a" A &~ "a" s
+}
+
+//testcase {
+//    input  "a";
+//    output "yes:{}";
+//    s = A
+//    A = "a" s &~ "a" A
+//      | "a" A &~ "a" s
+//      | ()
 //}
 
 testcase {
     input "ab c";
     output "1:{{a b} {c}}";
 
-    s   ::= ids
-    ids ::= id (" " ids &~ id [~]*) => "1"
-          | id (    ids &~ id [~]*) => "2"
+    s     = ids
+    ids   = "1":: id (" " ids &~ id !((~[])*))
+          | "2":: id (    ids &~ id !((~[])*))
           | id
-    id  ::= [a-z]++
+    id    = [a-z]++
 }
 
 testcase {
@@ -36,98 +52,88 @@ testcase {
     output "2:{{a} 1:{{b} {c}}}";
     output "1:{{a b} {c}}";
 
-    s   ::= ids
-    ids ::= id " " ids => "1"
-          | id     ids => "2"
+    s     = ids
+    ids   = "1":: id " " ids
+          | "2":: id     ids
           | id
-    id  ::= [a-z]+
+    id    = [a-z]+
 }
 
 testcase {
     input "aaabbbccc";
-    output "";
-
-    s   ::= ab & dc
-    ab  ::= a b
-    dc  ::= d c
-    a   ::= "a" a     | ()
-    b   ::= "b" b "c" | ()
-    c   ::= "c" c     | ()
-    d   ::= "a" d "b" | ()
+    output "ab";
+
+    s     = ab & dc
+    ab    = ab:: a b
+    dc    = dc:: d c
+    a     = "a" a     | ()
+    b     = "b" b "c" | ()
+    c     = "c" c     | ()
+    d     = "a" d "b" | ()
 }
 
 testcase {
     input "aaabbbbccc";
 
-    s   ::= ab & dc
-    ab !::= a b
-    dc !::= d c
-    a   ::= "a" a     | ()
-    b   ::= "b" b "c" | ()
-    c   ::= "c" c     | ()
-    d   ::= "a" d "b" | ()
+    s     = ab & dc
+    ab    = ab:: a b
+    dc    = dc:: d c
+    a     = "a" a     | ()
+    b     = "b" b "c" | ()
+    c     = "c" c     | ()
+    d     = "a" d "b" | ()
 }
 
 testcase {
-    input "12111211";
-    output "ac:{{2 1 2 1}}";
-    //output "a:{{2 1 2 1}}";
-    //output "c:{{c:{1 1} c:{1 1}}}";
+    input "aabb";
+    output "xbx:{{a} abab:{a b} {b}}";
 
-    s ::= ab => "ab"
-        | ac => "ac"
-        | bc => "bc"
-        //| a  =>  "a"
-        //| b  =>  "b"
-        //| c  =>  "c"
-    ab ::= a & b
-    ac ::= a & c
-    bc ::= b & c
-    a ::= ("1" x)*
-    b ::= (x "2" => "b")*
-    c ::= (x "2" x "1" => "c")*
-    x ::= [123]
+    x     = ~[]
+    s     = xbx:: x* b x*
+    b     = abab:: [ab][ab]
+         &~ ( "aa" | "bb" )
 }
 
 testcase {
-    input  "xbambambam";
+    input  "qxbambambam";
     output "bam:{a bam:{a bam:{a x}}}";
 
-    s ::= a s ^"bam"
-    s ::= ^"x"
-    a ::= ()       => "a"
+    s   = "q" z
+    z   = a z ^"bam"
+        | ^"x"
+    a   = a:: ()
 }
 
 testcase {
     input  "baaaa";
     output "s2:{b0 a:{a:{epsilon}}}";
     output "b:{a:{a:{epsilon}} epsilon}";
-    s ::= b t        => "s2"
+    s   = s2:: b t
         | ^"b" t b
-    t ::= ^"a" t "a"
-        | ()         => "epsilon"
-    b ::= "b"        => "b0"
-        | ()         => "epsilon"
+    t   = ^"a" t "a"
+        | epsilon:: ()
+    b   = b0:: "b"
+        | epsilon:: ()
 }
 
 testcase {
     input  "qaq";
     output "q:{a:{s1:{epsilon}}}";
 
-    s ::= ^"q" x "q"
-    x ::= ^"a" a
-    x ::= ()        => "epsilon"
-    a ::= x         => "s1"
+    s   = ^"q" x "q"
+    x   = ^"a" a
+        | epsilon:: ()
+    a   = s1:: x
 }
 
 testcase {
     input "baa";
     output "s1:{a2:{a2:{a0 b0} b0}}";
 
-    s ::= "b" a     => "s1"
-    a ::= "a" a b   => "a2"
-        | ()        => "a0"
-    b ::= ()        => "b0"
+    s   = s1:: "b" a
+    a   = a2:: "a" a b
+        | a0:: ()
+    b   = b0:: ()
 }
 
 testcase {
@@ -144,50 +150,50 @@ testcase {
     output "s3:{epsilon a0 epsilon a0}";
     output "s3:{epsilon a0 a0 epsilon}";
 
-    s ::= "a" s a a a => "s3"
-        | ()          => "epsilon"
-    a ::= "a"         => "a0"
-        | ()          => "epsilon"
+    s   = s3:: "a" s a a a
+        | epsilon:: ()
+    a   = a0:: "a"
+        | epsilon:: ()
 }
 
 testcase {
     input "aa";
     output "poo:{poo:{poox poox} poox}";
     output "poo:{poox poo:{poox poox}}";
-    s ::= s s "a"  => "poo"
-    s ::= ()       => "poox"
+    s   = poo::  s s "a"
+        | poox:: ()
 }
 
 testcase {
     input "baa";
     output "s:{aa:{aa:{a b} b}}";
-    s ::= "b" a      => "s"
-    a ::= "a" a b    => "aa"
-    a ::= ()         => "a"
-    b ::= ()         => "b"
+    s   = s:: "b" a
+    a   = aa:: "a" a b
+        | a:: ()
+    b   = b:: ()
 }
 
 testcase {
     input "aaab";
     output "sx:{b aa:{aa:{b b} b}}";
-    s ::= b d "a" "b"  => "sx"
-    s ::= "a" d "a" d  => "sy"
-    d ::= "a" a b      => "aa"
-    a ::= "a" b b      => "aa"
-    a ::= ()           => "a"
-    b ::= ()           => "b"
+    s   = sx:: b d "a" "b"
+        | sy:: "a" d "a" d
+    d   = aa:: "a" a b
+    a   = aa:: "a" b b
+        | a::  ()
+    b   = b::  ()
 }
 
 testcase {
     input "a+(b*c)";
     output "+:{{a} *:{{b} {c}}}";
 
-    s   ::= R
-    R   ::= id
-          | R ^"*" R
-          | R ^"+" R
-          | "(" R ")"
-    id  ::= [a-z]++
+    s     = r
+    r     = id
+          | r ^"*" r
+          | r ^"+" r
+          | "(" r ")"
+    id    = [a-z]++
 }
 
 testcase {
@@ -197,55 +203,61 @@ testcase {
     output "plus:{stringify:{{a}} times:{minus:{stringify:{{b}} stringify:{{d}}} stringify:{{c}}}}";
     output "times:{minus:{plus:{stringify:{{a}} stringify:{{b}}} stringify:{{d}}} stringify:{{c}}}";
     output "minus:{plus:{stringify:{{a}} stringify:{{b}}} times:{stringify:{{d}} stringify:{{c}}}}";
-    s  ::= S
-    w  ::= " "
-    L  ::= id
-    S  ::= L "=" Q  => "assign"
-         | Q
-    Q  ::= id
-         | L "=" Q       => "assign"
-         | Q "-" Q       => "minus"
-         | Q "+" Q       => "plus"
-         | Q "*" Q       => "times"
-         | "(" Q ")"
-    id   ::= idl++       => "stringify"
-    idl  ::= [a-d]
+    w    = " "
+    l    = id
+    s    = assign:: l "=" q
+         | q
+    q    = id
+         | assign:: l "=" q
+         | minus:: q "-" q
+         | plus:: q "+" q
+         | times:: q "*" q
+         | "(" q ")"
+    id     = stringify:: idl++
+    idl    = [a-d]
 }
 
-testcase {
-    input "a*b*c";
-    output "times:{stringify:{{a}} times:{stringify:{{b}} stringify:{{c}}}}";
-    s  ::= S
-    w  ::= " "
-    L  ::= id
-    S  ::= L "=" R  => "assign"
-         | R
-    R  ::= L
-         | L "=" R       => "assign"
-         | R "+" R       => "plus"
-         | (R) "*" R       => "times"
-         | "(" R ")"
-         | R R           => "times"
-    id   ::= idl++       => "stringify"
-    idl  ::= [a-d]
-}
+//testcase {
+//    input "a*b*c";
+//    output "times:{stringify:{{a}} times:{stringify:{{b}} stringify:{{c}}}}";
+//    w    = " "
+//    l    = id
+//    s    = l "=" r  => "assign"
+//         | r
+//    r    = l
+//         | l "=" r       => "assign"
+//         | r "+" r       => "plus"
+//         | (r) "*" r       => "times"
+//         | "(" r ")"
+//         | r r           => "times"
+//    id     = idl++       => "stringify"
+//    idl    = [a-d]
+//}
 
 testcase {
     input "a+b*c";
     output "plus:{stringify:{{a}} times:{stringify:{{b}} stringify:{{c}}}}";
-    s  ::= S
-    w  ::= " "
-    L  ::= id
-    S  ::= L "=" R  => "assign"
-         | R
-    R  ::= L
-         | L "=" R       => "assign"
-         | R "+" R       => "plus"
-         > R "*" R       => "times"
-         | "(" R ")"
-         | R R           => "times"
-    id   ::= idl++       => "stringify"
-    idl  ::= [a-d]
+    w    = " "
+    l    = id
+    s    = assign:: l "=" r
+         | r
+    r    = l
+         | assign:: l "=" r
+         | plus:: r "+" r
+         > times:: r "*" r
+         | "(" r ")"
+         | times:: r r
+    id     = stringify:: idl++
+    idl    = [a-d]
+}
+
+testcase {
+  input "aa bb";
+  output "{q:{{a a}} q:{{b b}}}";
+
+  s    = q */ ws
+  ws   = " "*
+  q    = q:: [a-z]++
 }
 
 testcase {
@@ -253,53 +265,128 @@ testcase {
     input "
 
 
+
  while x>0
-   while y>0
-    foo()
-     bar()
+    while y>0
+       foo()
+          bar()
+
 
  while x>0
-   while y>0
-    foo()
-   bar()
+    while y>0
+          foo()
+        bar()
+
 
 
 ";
-    output "smt:{while:{>:{{x} {0}} while:{>:{{y} {0}} sbb:{{f o o} {b a r}}}}}";
-    output "smt:{while:{>:{{x} {0}} sbb:{while:{>:{{y} {0}} {f o o}} {b a r}}}}";
+  output "smt:{while:{>:{{x} {0}} while:{>:{{y} {0}} sbb:{{f o o} {b a r}}}} while:{>:{{x} {0}} sbb:{while:{>:{{y} {0}} {f o o}} {b a r}}}}";
 
-indent  !::= ww
-outdent !::= " "  outdent " "
-           | " "  [~]*    "\n"
+indent    = ww
+outdent   = " "  outdent " "
+          | " "  ((~[])*)  "\n"
 
-any      !::= [~]*
-s         ::= !any "\n\n" !ww Statement !ww "\n\n" !any => smt
-ww        ::= sp*
-sp        ::= " "
+w          = " " | "\n" | "\r"
+ws         = w*
+ww         = sp*
+sp         = " "
+any        = (~[])*
 
-block     ::= "\n" !indent  BlockBody
-           &~ "\n" outdent [~\ ] [~]*
+s          = smt:: !ws statement !ws statement !ws
 
-BlockBody ::= Statement
-            > Statement BlockBody => "sbb"
+block       =        !"\n" !indent  blockBody
+           &~        !"\n" (" " !outdent " ") !(~[\ ]) !((~[])*)
 
-Statement ::= Call
-            | ^"while" Expr block
+blockBody   =       statement
+            > sbb:: statement ws blockBody
 
-Expr      ::= ident
-            | Call
-            | Expr ^">" Expr
+statement   = call
+            | ^"while" expr block /ws
+
+expr        = ident
+            | call
+            | expr ^">" expr   /ws
             | num
 
-Call      ::= Expr "()"
+call        = expr "()"        /ws
+
+num         = [0-9]++
 
-num       ::= [0-9]++
+ident       = [a-z]++ &~ keyword
+keyword     = "if" | "then" | "else" | "while"
 
-ident     ::= [a-z]++ &~ keyword
-keyword   ::= "if" | "then" | "else" | "while"
 
-w         ::= " " | "\n" | "\r"
-ws        ::= w*
 
+}
+
+
+
+testcase {
+    input "abc                         ";
 
+    s     = s2:: q " "*
+    q     = a3:: [a-z] [a-z] [a-z]
+         &~ !(~[]) "b" !((~[])*)
 }
+
+testcase {
+    input "abc                         ";
+    output "s:{a b c}";
+
+    s     = s:: [a-z] [a-z] [a-z] " "*
+}
+
+testcase {
+
+    input "a+2";
+    output "Plus:{left:{Foo} right:{{2}}}";
+
+    s       = Expr
+    Expr    = [0-9]++
+            | Plus:: (left::Expra) "+" (right::Expr)
+    Expra   = Foo:: ("a" | "b")
+
+}
+
+testcase {
+    input "aaaaa";
+    output "top:{a q:{{a a a}} a}";
+
+    s = top:: z (q::"a"*) z
+    z = a:: "a"
+}
+
+testcase {
+    input  "if (x) if (y) z else q";
+    output "if:{ident:{{x}} else:{if:{ident:{{y}} then:{ident:{{z}}}} ident:{{q}}}}";
+
+    s      = Expr
+    Expr   = if::     "if" "(" Expr ")" IfBody     /ws
+           | ident::  [a-z]++
+    IfBody = else::   Expr            "else"  Expr /ws
+           | then::   Expr &~   ((~[])* "else" !Expr /ws)
+    ws     = [ ]**
+}
+
+
+testcase {
+    input "12111211";
+    output "ac:{{2 1 2 1}}";
+    //output "a:{{2 1 2 1}}";
+    //output "c:{{c:{1 1} c:{1 1}}}";
+
+    s   = ab:: ab
+        | ac:: ac
+        | bc:: bc
+        //| a  =>  "a"
+        //| b  =>  "b"
+        //| c  =>  "c"
+    ab   = a & b
+    ac   = a & c
+    bc   = b & c
+    a   = ("1" x)*
+    b   = ("b":: x "2")*
+    c   = ("c":: x "2" x "1")*
+    x   = [123]
+}
+