root/lang/haxe/Tonyu2/Parser.hx @ 35690

//using System;
//using System.Collections.Generic;

class ParseError  {
    var message:String;
        public function new(mesg:String){this.message=mesg;}
}
typedef Combinator = Void->Dynamic;
//public delegate object Combinator();
//public delegate void VoidSub();
class Parser {
        var input:String;
        var context:Dynamic;
        var p:Int;
        var maxErrorPos:Int;
        static var space = ~/^\s*/;
        public function new(input:String) {
          this.input=input;
          p=0;
        }
        public var rest(getRest,null):String;
        function getRest():String {
                return input.substr(p);
        }
        public function  proceed(by:Int):Int {return p+=by;}
        public var eos(isEOS,null):Bool;
        function isEOS():Bool {
           return p>=rest.length;
        }
        var lastError:String;
        public function raise(message:String) {
           if (maxErrorPos<p) {
                   maxErrorPos=p;
                   lastError = traceStr(message);
                }         
                throw new ParseError(traceStr(message));
        }
        public function raiseSyntaxError() {
                throw ("���@�G���[: "+maxErrorPos+" - "+p+" - "+lastError);
        }
        public function traceStr(message:String):String {
           return " at "+p+"  /  "+message ;
        }
        /*public void trace(string message) {
           System.Diagnostics.Debug.WriteLine(message);
        }*/
        public function saveState():Int {
           return p;
        }
        public function restoreState(st:Int) {
           p=st;
        }
        static function startsWith(s:String,head:String):Bool {
            return s.substr(0,head.length)==head;
        }
        public function parse(m:Dynamic):Dynamic {
                return combinator(m)();
        }

        public function combinator(match:Dynamic):Combinator {
           if (Reflect.isFunction(match) ) {
                   //var p:Combinator=match;
                   return match;
           } else if (Std.is(match ,String)) {
                  var m:String=match;
                  return str(m);
           } else if (Std.is(match , EReg)) {
                  var r:EReg=match;
                  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)) {
                                if (r.matchedPos().pos>0) throw ("Invalid regex; it must start with ^ :"+r);
                                t.proceed(r.matched(0).length);
                                return r.matched(0);
                        }
                        t.raise(message);
                        return null;
                };
        }
        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 seq(seq:Array<Dynamic>):Combinator {
                var cls= combinators(seq);
                var t:Parser=this;
                return function() {
                   var res=[];
                   var r:Combinator;
                   for (r in cls) {
                                res.push(r());
                   }
                   return res;
                };
        }

        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:Combinator;
                   for (sub in subs) {
                          var st=t.saveState();
                          lastError=null;
                          try {
                                 res=sub();
                          } catch (p:ParseError) {
                                lastError=p;
                                t.restoreState(st);
                          }
                          if (lastError==null) {trace("Trial "+trID+" OK res="+res); return res;}
                   }
                   throw lastError;
           };
        }

        
        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;
           };
        }

        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(){suc=false;return null;};
                        var tres=(t.either([sub, fail]))();
                        if (suc) {
                                res.push(tres);
                        } else {
                                break;
                        }
                 }
                 if (res.length<min) {
                        t.raise("only "+res.length+" time for ("+min+" - "+max+")");
                }
                 trace("repeated "+res.length+"("+min+" - "+max+")  OK, proceed");
                 //#if ($cnt!=@res) {die("Why $cnt ".scalar(@res));}
                 return res;
           };
        }
        
}