wip

std/lua/lib/lpeg/Lpeg.hx

@@ -32,6 +32,41 @@ extern class Lpeg {
      **/
     public static function setmaxstack(max:Int) : Void;
 
-    public static function locale(arg:Table<String,Pattern>) : Table<String,Pattern>;
+    public static function locale(arg:Table<String,Pattern>) : Predef;
 
 }
+
+typedef Predef = {
+    a : Pattern,
+    c : Pattern,
+    d : Pattern,
+    g : Pattern,
+    l : Pattern,
+    p : Pattern,
+    s : Pattern,
+    u : Pattern,
+    w : Pattern,
+    x : Pattern,
+
+    A : Pattern,
+    C : Pattern,
+    D : Pattern,
+    G : Pattern,
+    L : Pattern,
+    P : Pattern,
+    S : Pattern,
+    U : Pattern,
+    W : Pattern,
+    X : Pattern,
+
+    alpha : Pattern,
+    cntrl : Pattern,
+    digit : Pattern,
+    graph : Pattern,
+    lower : Pattern,
+    punct : Pattern,
+    space : Pattern,
+    upper : Pattern,
+    alnum : Pattern,
+    xdigit : Pattern
+}

std/lua/lib/lpeg/Pattern.hx

@@ -1,5 +1,4 @@
 package lua.lib.lpeg;
-import haxe.Constraints.Function;
 import lua.lib.lpeg.Pattern.PatternMetatable as M;
 
 import haxe.extern.Rest;
@@ -46,15 +45,27 @@ abstract Pattern(PatternImpl){
     @:op(A >> B)
     public static inline function divf(p : Pattern, f:Function) : Pattern  return M.__div(p, f);
 
+    @:op(A >> B)
+    public static inline function divi(p : Pattern, i:Int) : Pattern  return M.__div(p, i);
+
     public inline function len() : Pattern { return untyped __lua_length__(this);}
 
     inline public static function P(p:PatternArgument) : Pattern  return PatternImpl.P(p);
     inline public static function R(arg:String) : Pattern return PatternImpl.R(arg);
     inline public static function Cf(p:Pattern, f : Function) : Pattern return PatternImpl.Cf(p, f);
+    inline public static function Ct(p:Pattern) : Table<Dynamic, String> return PatternImpl.Ct(p);
+    inline public static function Cc(val:Dynamic) : Pattern return PatternImpl.Cc(val);
+    inline public static function Ca(p:Pattern) : Pattern {
+        return Cf(Cc([]) + p, (acc:Array<String>, v : Dynamic)-> {
+            acc.push(v);
+            return acc;
+        });
+    }
 }
 
 
 
+
 @:luaRequire("lpeg")
 extern class PatternImpl {
     /**
@@ -78,6 +89,9 @@ extern class PatternImpl {
     public static function P(p:PatternArgument) : Pattern;
     public static function R(args:Rest<String>) : Pattern;
     public static function Cf(p:Pattern, f : Function) : Pattern;
-    public function match(subject:String, ?init:Int) : Int;
+    public static function Cc(val:Rest<Dynamic>) : Pattern;
+
+    public static function Ct(p:Pattern) : Table<String,String>;
+    public function match(subject:String, ?init:Int) : Dynamic;
 }
 

std/lua/lib/lpeg/Predef.hx

@@ -1,3 +0,0 @@
-extern class Predef {
-    var a : Pattern;
-}

std/lua/lib/lpeg/Rehx.hx

@@ -1,49 +1,63 @@
 package lua.lib.lpeg;
 import lua.lib.lpeg.Pattern;
+import lua.lib.lpeg.Pattern.*;
+import lua.lib.lpeg.Re;
+import lua.lib.lpeg.Re.S;
 
 class Rehx {
     public static function compile(str : String, ?def : Dynamic) : Pattern {
         return null;
     }
-
-    static var I =  Pattern.P((s:String,i:Int)-> lua.Lua.print(i, s.substring(0,i)));
-
-    static function getDef(id:Dynamic, defs : Table<String, String>){
-        if (defs[id] != null) {
-            return defs[id];
-        } else {
-            throw ('undefined name: ${id}');
-            return null;
-        }
+    public static function match(subject : String, pattern : Pattern, ?index : Int) : String {
+        return Re.match(subject, pattern, index);
     }
-
-    static function patError(s:String, i:Int){
-        var sub = if (s.length <  (i + 20)){
-            s.substring(i);
-        } else {
-            s.substring(i, i+20) + "...";
-        }
-        throw('pattern error near $sub');
+    public static function find(subject : String, pattern : Pattern, ?index : Int) : Int {
+        return Re.find(subject, pattern, index);
     }
-
-    static function mult(p : Pattern, n : Int){
-        var np = Pattern.P(true);
-        while (n >= 1){
-            if (n%2 >=1) np = np + p;
-            p = p + p;
-            n = Std.int(n/2);
-        }
-        return np;
+    public static function gsub(subject : String, pattern : Pattern, replace : String) : String {
+        return Re.gsub(subject, pattern, replace);
     }
-
-    static function equalCap(s:String, i:Int, c:String) : Int {
-        if (lua.Lua.type(c)  != "string") return null;
-        var e = c.length + i;
-        if (s.substring(i, e-1) == c) {
-            return e;
-        } else return null;
-
+    public static function updatelocale() : Void {
+        return Re.updatelocale();
     }
 
-
+    var  exp = P([
+        "__name__" => "Exp",
+        "Exp" => S + ( V("Grammar") | Cf(V("Seq") + ("/" + S + V("Seq")) * 0, mt.__add) ),
+        "Seq" => Cf(Cc(P("")) * V("Prefix")^0 , mt.__mul) * (seq_follow.length + patt_error),
+        "Prefix" => "&" * S * V("Prefix") / mt.__len
+            + "!" * S * V("Prefix") / mt.__unm
+            + V("Suffix"),
+        "Suffix" => Cf(V("Primary") * S *
+          ( ( P("+") * Cc(1, mt.__pow)
+            + P("*") * Cc(0, mt.__pow)
+            + P("?") * Cc(-1, mt.__pow)
+            + "^" * ( Cg(num * m.Cc(mult))
+                    + Cg(C(S("+-") * R("09")^1) * Cc(mt.__pow))
+                    )
+            + "->" * S * ( Cg((String + num) * Cc(mt.__div))
+                         + P("{}") * Cc(nil, Ct)
+                         + Cg(Def / getdef * Cc(mt.__div))
+                         )
+            + "=>" * S * Cg(Def / getdef * Cc(Cmt))
+            ) * S
+          )^0, function (a,b,f) return f(a,b) ),
+        "Primary" => "(" * V("Exp") * ")"
+            + String / P
+            + Class
+            + defined
+            + "{:" * (name * ":" + Cc(null)) * V("Exp") * ":}" /
+                     function (n, p) return Cg(p, n)
+            + "=" * name / function (n) return Cmt(Cb(n), equalcap)
+            + P("{}") / Cp
+            + "{~" * m.V("Exp") * "~}" / Cs
+            + "{|" * m.V("Exp") * "|}" / Ct
+            + "{" * m.V("Exp") * "}" / C
+            + P(".") * Cc(any)
+            + (name * -arrow + "<" * name * ">") * Cb("G") / NT,
+        "Definition" => name * arrow * V("Exp"),
+        "Grammar" => Cg(Cc(true), "G") *
+            Cf(V("Definition") / firstdef * Cg(V("Definition"))^0,
+              adddef) / P
+    ]);
 }