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

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

class ParseError  {
    var message:String;
        public function new(mesg:String){this.message=mesg;}
}
typedef ParserSub = Parser->Dynamic;
//public delegate object ParserSub();
//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 toClosure(m)(this);
        }
        public function toClosure(match:Dynamic):ParserSub {
           if (Reflect.isFunction(match) ) {
                   //var p:ParserSub=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;
                  };
           } else if (Std.is(match , EReg)) {
                  var message=Std.string(match)+" expected";
                  var r:EReg=match;
                  return function(t:Parser) {
                        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;
                  };
           }
           throw ("Invalid match: "+match);
        }
        public function skipSpace() {
                if (space.match(rest)) {
                        proceed(space.matchedPos().len);
                }
        }

        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) {
                   var res=[];
                   var r:ParserSub;
                   for (r in cls) {
                                res.push(r(t));
                   }
                   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;
                   var trID=Std.random(10000);
                   trace("Trying "+trID);
                   var lastError:ParseError =null;
                   var sub:ParserSub;
                   for (sub in subs) {
                          var st=t.saveState();
                          lastError=null;
                          try {
                                 res=sub(t);
                          } catch (p:ParseError) {
                                lastError=p;
                                t.restoreState(st);
                          }
                          if (lastError==null) {trace("Trial "+trID+" OK res="+res); return res;}
                   }
                   throw lastError;
           };
        }

        
        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);
                 if (res.length==1) return res[0];
                 return null;
           };
        }

        public function reptN(min:Int , max:Int, sub:ParserSub):ParserSub  {
           return function(t:Parser) {
                 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);
                        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;
           };
        }
        
}