Changeset 35690

Timestamp:

10/23/09 13:32:55 (4 years ago)

Author:

hoge1e3

Message:

 

Location:

lang/haxe/Tonyu2

Files:

• Parser.hx (modified) (5 diffs)
• Scratch.hx (modified) (2 diffs)
• Test.hx (modified) (2 diffs)
• grm/Program.hx (deleted)
• grm/Statement.hx (added)
• grm/TClass.hx (added)
• grm/TParser.hx (added)
• grm/TypeReference.hx (added)
• make.bat (added)
• parser.n (modified) (previous)
• scratch.n (modified) (previous)

lang/haxe/Tonyu2/Parser.hx

@@ -6 +6 @@
         public function new(mesg:String){this.message=mesg;}
 }
-typedef ParserSub = Parser->Dynamic;
-//public delegate object ParserSub();
+typedef Combinator = Void->Dynamic;
+//public delegate object Combinator();
 //public delegate void VoidSub();
 class Parser {
@@ -55 +55 @@
         }
         public function parse(m:Dynamic):Dynamic {
-                return toClosure(m)(this);
-        }
-        public function toClosure(match:Dynamic):ParserSub {
+                return combinator(m)();
+        }
+
+        public function combinator(match:Dynamic):Combinator {
            if (Reflect.isFunction(match) ) {
-                   //var p:ParserSub=match;
+                   //var p:Combinator=match;
                    return match;
            } else if (Std.is(match ,String)) {
-                  var message:String=match+" expected";
                   var m:String=match;
-                  return function(t:Parser) {
-                        if (startsWith(t.rest,m)) {
-                                t.proceed(m.length);
-                                return m;
-                        }
-                        t.raise(message);
-                        return null;
-                  };
+                  return str(m);
            } else if (Std.is(match , EReg)) {
-                  var message=Std.string(match)+" expected";
                   var r:EReg=match;
-                  return function(t:Parser) {
+                  return reg(r);
+           } else if (Std.is(match,Array)) {
+              var ary:Array<Dynamic>=match;
+              return seq(ary);
+           }
+           throw ("Invalid match: "+match);
+        }
+        public function skipSpace() {
+                if (space.match(rest)) {
+                        proceed(space.matchedPos().len);
+                }
+        }
+
+        public function combinators(seq:Array<Dynamic> ):Array<Combinator> {
+           var res:Array<Combinator>=[];
+           var s;
+           for (s in seq) {
+                  res.push(combinator(s));
+           }
+           return res;
+        } 
+        public function cache(name:String, sub:Combinator ) {
+           trace("Parsing "+name);
+           return sub();
+        }
+        public function parseSeq(s:Array<Dynamic>):Array<Dynamic> {
+                return seq(s)();
+        }                       
+        //# combinator
+        public function reg(r:EReg) {
+                var t=this;
+                var message=Std.string(r)+" expected";
+                return function() {
                         t.skipSpace();
                         if (r.match(t.rest)) {
@@ -84 +108 @@
                         t.raise(message);
                         return null;
-                  };
-           }
-           throw ("Invalid match: "+match);
-        }
-        public function skipSpace() {
-                if (space.match(rest)) {
-                        proceed(space.matchedPos().len);
+                };
+        }
+        public function str(m:String) {
+                var t=this;
+                var message:String=m+" expected";
+                return function () {
+                        if (startsWith(t.rest,m)) {
+                                t.proceed(m.length);
+                                return m;
+                        }
+                        t.raise(message);
+                        return null;
                 }
         }
-
-        public function toClosures(seq:Array<Dynamic> ):Array<ParserSub> {
-           var res:Array<ParserSub>=[];
-           var s;
-           for (s in seq) {
-                  res.push(toClosure(s));
-           }
-           return res;
-        } 
-        public function cache(name:String, sub:ParserSub ) {
-           trace("Parsing "+name);
-           return sub(this);
-        }
-                        //# combinator
-        public function seq(seq:Array<Dynamic>):ParserSub {
-                var cls= toClosures(seq);
-                return function(t:Parser) {
+        public function seq(seq:Array<Dynamic>):Combinator {
+                var cls= combinators(seq);
+                var t:Parser=this;
+                return function() {
                    var res=[];
-                   var r:ParserSub;
+                   var r:Combinator;
                    for (r in cls) {
-                                res.push(r(t));
+                                res.push(r());
                    }
                    return res;
                 };
         }
-        public function parseSeq(s:Array<Dynamic>):Array<Dynamic> {
-                return seq(s)(this);
-        }
-        public function tryThese(_:Array<Dynamic>):ParserSub {                  
-                var subs=toClosures(_); 
-                return function (t:Parser) {
-                   var res=null;
+
+        public function either(_:Array<Dynamic>):Combinator {                   
+                var subs=combinators(_); 
+                var t:Parser=this;
+                return function() {
+                        var res=null;
                    var trID=Std.random(10000);
                    trace("Trying "+trID);
                    var lastError:ParseError =null;
-                   var sub:ParserSub;
+                   var sub:Combinator;
                    for (sub in subs) {
                           var st=t.saveState();
                           lastError=null;
                           try {
-                                 res=sub(t);
+                                 res=sub();
                           } catch (p:ParseError) {
                                 lastError=p;
@@ -145 +160 @@
 
         
-        public function rept0(_:Array<Dynamic>):ParserSub  {
-           return reptN(0,1000,seq(_));
-        }
-
-        public function rept1(_:Array<Dynamic>):ParserSub  {
-           return reptN(1,1000,seq(_));
-        }
-        public function maybe(_:Array<Dynamic>):ParserSub {
-           return function (t:Parser) {
-                 var res: Array<Dynamic> = (t.reptN(0,1,t.seq(_)))(t);
+        public function rept0(_:Dynamic):Combinator  {
+           return reptN(0,1000,combinator(_));
+        }
+
+        public function rept1(_:Dynamic):Combinator  {
+           return reptN(1,1000,combinator(_));
+        }
+        public function maybe(_:Dynamic):Combinator {
+            var t:Parser=this;
+                return function() {
+                 var res: Array<Dynamic> = (t.reptN(0,1,t.combinator(_)))();
                  if (res.length==1) return res[0];
                  return null;
@@ -160 +176 @@
         }
 
-        public function reptN(min:Int , max:Int, sub:ParserSub):ParserSub  {
-           return function(t:Parser) {
+        public function reptN(min:Int , max:Int, sub:Combinator):Combinator  {
+           var t:Parser=this;
+                return function() {
                  var res=[];
                  while (res.length<max) {
                         var suc=true;
-                        var fail=function(t:Parser){suc=false;return null;};
-                        var tres=(t.tryThese([sub, fail]))(t);
+                        var fail=function(){suc=false;return null;};
+                        var tres=(t.either([sub, fail]))();
                         if (suc) {
                                 res.push(tres);

lang/haxe/Tonyu2/Scratch.hx

@@ -4 +4 @@
 */
 typedef IntF=Int->Int;
-class Scratch {
+class Scratch extends Parser {
+   var x:Int;
+   function test(a:Int):Int{return a*2+x;}
         static function startsWith(s:String,head:String):Bool {
             return s.substr(0,head.length)==head;
         }
-   static function main() {
+        function new(str:String){super(str);x=3;}
+    static function main() {
+        new Scratch(" yokan milk? cocoa  ").parse2();
+        }
+    function parse2() {  grm.Test.wai();
+                trace ( parse(rept0([~/^[a-z]+/ ,maybe("?")  ]))  );
+                trace(this);
+        }
+        public function toString():String {
+           return "SCR";
+        }
+        function gomi() {
        var a:Array<Dynamic>=[10,function(x:Int){return x*2;},2];
            a.push(function (t:String) {
@@ -28 +41 @@
            var p=new Parser("abc");
            
-           
            /*
            var f:IntF=function (a:Int){return a*2;};

lang/haxe/Tonyu2/Test.hx

@@ -18 +18 @@
 class Test {
     static function nop(c:Context){}
-    static function pass1(g:Gen) {return funciton(c:Context){g.pass1(c);}}
+    static function pass1(g:Gen) {return function(c:Context){g.pass1(c);}}
     static function elem(t:Parser) {
-           return parse(t.tryThese(const,_var));
+           return t.parse(t.either([const,_var]));
         }
         static function const(t:Parser) {
@@ -44 +44 @@
                            c.out(x[0]);
                            x[1].gen(c);
-                           res=res+cast(x[1],Int);
+                           //res=res+cast(x[1],Int);
                         }
                   }