pPEGpy 0.3.2__tar.gz

ppegpy-0.3.2/.gitignore

@@ -0,0 +1,10 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv

ppegpy-0.3.2/.python-version

@@ -0,0 +1 @@
+3.12

ppegpy-0.3.2/DeveloperKit/README.md

@@ -0,0 +1,77 @@
+#   A pPEG Parser Machine Developer Kit
+
+This directory contains Python code samples for the incremental development of a pPEG parser machine, as explained in [pPEG-machine].
+
+Each step has a code file that can be run as a Python script
+
+####  Step 1:   [Machine-1]
+
+    First toy parser for date grammar example
+    No parse tree generation
+    4-instruction parser machine
+    50 LOC grammar and parser code
+    50 LOC parser machine
+
+####  Step 2:     [Machine-2]
+
+    Toy parser for date grammar example
+    now generating a parse tree.
+    4-instruction parser machine,
+    60 LOC parser machine
+
+####  Step 3:     [Machine-3]
+
+    More instructions, date grammar example 
+    7-instruction parser machine,
+    100 LOC parser machine
+
+####  Step 4:     [Machine-4]
+
+    Parser for pPEG boot grammar
+    8-instruction parser machine,
+    170 LOC parser machine
+
+####  Step 5:     [Machine-5]
+
+    Parser for full pPEG grammar, 
+    8-instruction parser machine,
+    parser_code from pPEG ptree,
+    export grammar compile API
+    200 LOC parser machine        
+
+####  Step 6:     [Machine-6]
+
+    Parser for full pPEG grammar, 
+    8-instruction parser machine,
+    parser_code from pPEG ptree,
+    export grammar compile API
+    250 LOC parser machine        
+
+####  Step 7:     [Machine-7]
+
+    Parser for full pPEG grammar, 
+    8-instruction parser machine,
+    parser_code from pPEG ptree,
+    export grammar compile API
+    250 LOC parser machine        
+
+####  Full pPEG implementation:     [Machine-8]
+
+    Full code for pPEG parser machine.
+     50 LOC pPEG grammar source and Json ptree
+    250 LOC parser machine
+    100 LOC compiler
+    100 LOC fault and trace reporting
+    120 LOC extensions
+    700 LOC total
+
+[pPEG-machine]: https://github.com/pcanz/pPEG/blob/master/docs/pPEG-machine.md
+
+[Machine-1]: https://github.com/pcanz/pPEGpy/blob/master/DeveloperKit/machine-1.py
+[Machine-2]: https://github.com/pcanz/pPEGpy/blob/master/DeveloperKit/machine-2.py
+[Machine-3]: https://github.com/pcanz/pPEGpy/blob/master/DeveloperKit/machine-3.py
+[Machine-4]: https://github.com/pcanz/pPEGpy/blob/master/DeveloperKit/machine-4.py
+[Machine-5]: https://github.com/pcanz/pPEGpy/blob/master/DeveloperKit/machine-5.py
+[Machine-6]: https://github.com/pcanz/pPEGpy/blob/master/DeveloperKit/machine-6.py
+[Machine-7]: https://github.com/pcanz/pPEGpy/blob/master/DeveloperKit/machine-7.py
+[Machine-8]: https://github.com/pcanz/pPEGpy/blob/master/pPEG.py

ppegpy-0.3.2/DeveloperKit/machine-1.py

@@ -0,0 +1,114 @@
+"""
+    Step 1: 
+    date grammar, 
+    4-instruction parser machine,
+    no parse tree generation.
+"""
+
+date_grammar = """
+    date  = year '-' month '-' day
+    year  = d d d d
+    month = d d
+    day   = d d
+    d     = '0'/'1'/'2'/'4'/'5'/'6'/'7'/'8'/'9'
+"""
+
+date_ptree = ["Peg",[
+    ["rule", [["id", "date"],
+        ["seq", [["id", "year"], ["sq", "'-'"],
+            ["id", "month"], ["sq", "'-'"], ["id", "day"]]]]],
+    ["rule", [["id", "year"],
+        ["seq", [["id", "d"],["id", "d"],
+            ["id", "d"],["id", "d"]]]]],
+    ["rule", [["id", "month"],
+        ["seq", [["id", "d"], ["id", "d"]]]]],
+    ["rule", [["id", "day"],
+        ["seq", [["id", "d"], ["id", "d"]]]]],
+    ["rule", [["id", "d"],
+        ["alt", [["sq", "'0'"], ["sq", "'1'"], ["sq", "'2'"],
+            ["sq", "'3'"], ["sq", "'4'"], ["sq", "'5'"], ["sq", "'6'"],
+            ["sq", "'7'"], ["sq", "'8'"], ["sq", "'9'"]]]]]
+]]
+
+date_code = {
+    "date":
+        ["seq", [["id", "year"], ["sq", "'-'"],
+            ["id", "month"], ["sq", "'-'"], ["id", "day"]]],
+    "year":
+        ["seq", [["id", "d"],["id", "d"],
+            ["id", "d"],["id", "d"]]],
+    "month":
+        ["seq", [["id", "d"], ["id", "d"]]],
+    "day":
+        ["seq", [["id", "d"], ["id", "d"]]],
+    "d":
+        ["alt", [["sq", "'0'"], ["sq", "'1'"], ["sq", "'2'"],
+            ["sq", "'3'"], ["sq", "'4'"], ["sq", "'5'"], ["sq", "'6'"],
+            ["sq", "'7'"], ["sq", "'8'"], ["sq", "'9'"]]],
+    "$start": ["id", "date"]
+}
+
+class Env():
+    def __init__(self, code, input):
+        self.code = code
+        self.input = input
+        self.pos = 0
+        self.end = len(input)
+
+def parse(code, input):
+    env = Env(code, input)
+    result = eval(code["$start"], env)
+    return (result, env.pos)
+
+def id(exp, env):
+    name = exp[1]
+    expr = env.code[name]
+    return eval(expr, env)
+
+def seq(exp, env):
+    start = env.pos
+    for arg in exp[1]:
+        if not eval(arg, env):
+            env.pos = start
+            return False
+    return True
+
+def alt(exp, env):
+    start = env.pos
+    for arg in exp[1]:
+        if eval(arg, env):
+            return True
+        env.pos = start
+    return False
+
+def sq(exp, env):
+    for c in exp[1][1:-1]:
+        if env.pos >= env.end or c != env.input[env.pos]:
+            return False
+        env.pos += 1
+    return True
+
+instruct = {
+    "id": id,
+    "seq": seq,
+    "alt": alt,
+    "sq": sq
+}
+
+def eval(exp, env):
+    print(exp, exp[0])
+    return instruct[exp[0]](exp, env)
+
+
+
+print( parse(date_code, "2021-03-04") ) # eval exp ...
+
+"""  Impementation Notes:
+
+seq and alt reset the current pos after a failure
+
+sq needs to check for end of input
+
+sq needs to skip the quoted quote marks
+
+"""

ppegpy-0.3.2/DeveloperKit/machine-2.py

@@ -0,0 +1,132 @@
+
+"""
+    Step 2: 
+    date grammar, 
+    4-instruction parser machine,
+    generating a parse tree.
+"""
+
+date_grammar = """
+    date  = year '-' month '-' day
+    year  = d d d d
+    month = d d
+    day   = d d
+    d     = '0'/'1'/'2'/'4'/'5'/'6'/'7'/'8'/'9'
+"""
+
+date_ptree = ["Peg",[
+    ["rule", [["id", "date"],
+        ["seq", [["id", "year"], ["sq", "'-'"],
+            ["id", "month"], ["sq", "'-'"], ["id", "day"]]]]],
+    ["rule", [["id", "year"],
+        ["seq", [["id", "d"],["id", "d"],
+            ["id", "d"],["id", "d"]]]]],
+    ["rule", [["id", "month"],
+        ["seq", [["id", "d"], ["id", "d"]]]]],
+    ["rule", [["id", "day"],
+        ["seq", [["id", "d"], ["id", "d"]]]]],
+    ["rule", [["id", "d"],
+        ["alt", [["sq", "'0'"], ["sq", "'1'"], ["sq", "'2'"],
+            ["sq", "'3'"], ["sq", "'4'"], ["sq", "'5'"], ["sq", "'6'"],
+            ["sq", "'7'"], ["sq", "'8'"], ["sq", "'9'"]]]]]
+]]
+
+date_code = {
+    "date":
+        ["seq", [["id", "year"], ["sq", "'-'"],
+            ["id", "month"], ["sq", "'-'"], ["id", "day"]]],
+    "year":
+        ["seq", [["id", "d"],["id", "d"],
+            ["id", "d"],["id", "d"]]],
+    "month":
+        ["seq", [["id", "d"], ["id", "d"]]],
+    "day":
+        ["seq", [["id", "d"], ["id", "d"]]],
+    "d":
+        ["alt", [["sq", "'0'"], ["sq", "'1'"], ["sq", "'2'"],
+            ["sq", "'3'"], ["sq", "'4'"], ["sq", "'5'"], ["sq", "'6'"],
+            ["sq", "'7'"], ["sq", "'8'"], ["sq", "'9'"]]],
+    "$start": ["id", "date"]
+}
+
+class Env():
+    def __init__(self, code, input):
+        self.code = code
+        self.input = input
+        self.pos = 0
+        self.end = len(input)
+        self.tree = [] # build parse tree
+
+def parse(code, input):
+    env = Env(code, input)
+    result = eval(code["$start"], env)
+    return (result, env.pos, env.tree)
+
+def id(exp, env):
+    name = exp[1]
+    start = env.pos
+    stack = len(env.tree)
+    name = exp[1]
+    expr = env.code[name]
+    result = eval(expr, env)
+    if not result: return False
+    size = len(env.tree)
+    if size-stack > 1:
+        env.tree[stack:] = [[name, env.tree[stack:]]]
+        return True
+    if size == stack:
+        env.tree.append([name, env.input[start:env.pos]])
+        return True
+    return True  # elide redundant rule name
+
+def seq(exp, env):
+    start = env.pos
+    stack = len(env.tree)
+    for arg in exp[1]:
+        if not eval(arg, env):
+            if len(env.tree) > stack:
+                env.tree = env.tree[0:stack]
+            env.pos = start       
+            return False
+    return True
+
+def alt(exp, env):
+    start = env.pos
+    stack = len(env.tree)
+    for arg in exp[1]:
+        if eval(arg, env):
+            return True
+        if len(env.tree) > stack:
+            env.tree = env.tree[0:stack]       
+        env.pos = start
+    return False
+
+def sq(exp, env):
+    for c in exp[1][1:-1]:
+        if env.pos >= env.end or c != env.input[env.pos]:
+            return False
+        env.pos += 1
+    return True
+
+instruct = {
+    "id": id,
+    "seq": seq,
+    "alt": alt,
+    "sq": sq
+}
+
+def eval(exp, env):
+    print(exp, exp[0])
+    return instruct[exp[0]](exp, env)
+
+print( parse(date_code, "2021-03-04") ) # eval exp ...
+
+"""  Impementation Notes:
+
+Add parse tree building in id rule.
+
+Add reset tree in seq and alt
+
+TODO: upper case rule names and anon underscore rule names.
+
+"""

ppegpy-0.3.2/DeveloperKit/machine-3.py

@@ -0,0 +1,149 @@
+"""
+    Step 3: 
+    date grammar, 
+    7-instruction parser machine,
+"""
+
+date_grammar = """
+    date  = year '-' month '-' day
+    year  = [0-9]+
+    month = [0-9]+
+    day   = [0-9]+
+"""
+
+date_code = {
+    "date":
+        ["seq", [["id", "year"], ["sq", "'-'"],
+            ["id", "month"], ["sq", "'-'"], ["id", "day"]]],
+    "year":
+        ["rep", [["chs", "[0-9]"],["sfx", "+"]]],
+    "month":
+        ["rep", [["chs", "[0-9]"],["sfx", "+"]]],
+    "day":
+        ["rep", [["chs", "[0-9]"],["sfx", "+"]]],
+    "$start":
+        ["id", "date"]
+}
+
+class Env():
+    def __init__(self, code, input):
+        self.code = code
+        self.input = input
+        self.pos = 0
+        self.end = len(input)
+        self.tree = [] # build parse tree
+
+def parse(code, input):
+    env = Env(code, input)
+    result = eval(code["$start"], env)
+    return (result, env.pos, env.tree)
+
+def id(exp, env):
+    name = exp[1]
+    start = env.pos
+    stack = len(env.tree)
+    name = exp[1]
+    expr = env.code[name]
+    result = eval(expr, env)
+    if not result: return False
+    size = len(env.tree)
+    if size-stack > 1:
+        env.tree[stack:] = [[name, env.tree[stack:]]]
+        return True
+    if size == stack:
+        env.tree.append([name, env.input[start:env.pos]])
+        return True
+    return True  # elide redundant rule name
+
+def seq(exp, env):
+    start = env.pos
+    stack = len(env.tree)
+    for arg in exp[1]:
+        if not eval(arg, env):
+            if len(env.tree) > stack:
+                env.tree = env.tree[0:stack]       
+            env.pos = start 
+            return False
+    return True
+
+def alt(exp, env):
+    start = env.pos
+    stack = len(env.tree)
+    for arg in exp[1]:
+        if eval(arg, env): return True
+        if len(env.tree) > stack:
+            env.tree = env.tree[0:stack]       
+        env.pos = start
+    return False
+
+def rep(exp, env):
+    [_rep, [expr, [_sfx, sfx]]] = exp
+    min, max = 0, 0  # sfx == "*" 
+    if  sfx == "+": min = 1
+    elif sfx == "?": max = 1
+    count = 0
+    while True:
+        start = env.pos
+        result = eval(expr, env)
+        if result == False: break
+        if env.pos == start: break # no progress
+        count += 1
+        if count == max: break # max 0 means any
+    if count < min: return False
+    return True
+
+def sq(exp, env):
+    for c in exp[1][1:-1]:
+        if env.pos >= env.end or c != env.input[env.pos]:
+            return False
+        env.pos += 1
+    return True
+
+def dq(exp, env):
+    for c in exp[1][1:-1]:
+        if c == " ":
+            while env.pos < env.end and env.input[env.pos] <= " ": env.pos += 1
+            continue
+        if env.pos >= env.end or c != env.input[env.pos]: return False
+        env.pos += 1
+    return True
+
+def chs(exp, env):
+    if env.pos >= env.end: return False
+    str = exp[1]
+    n = len(str)
+    ch = env.input[env.pos]
+    i = 1 # "[...]"
+    while i < n-1:       
+        if i+2 < n-1 and str[i+1] == '-':
+            if ch < str[i] or ch > str[i+2]:
+                i += 3
+                continue
+        elif ch != str[i]: 
+            i += 1
+            continue
+        env.pos += 1
+        return True
+    return False
+
+instruct = {
+    "id": id,
+    "seq": seq,
+    "alt": alt,
+    "rep": rep,
+    "sq": sq,
+    "dq": dq,
+    "chs": chs,
+}
+
+def eval(exp, env):
+    print(exp, exp[0])
+    return instruct[exp[0]](exp, env)
+
+print( parse(date_code, "2021-03-04") ) # eval exp ...
+
+"""  Impementation Notes:
+
+Adds rep, dq, and chs instructions
+
+"""