pegex 0.0.1

data/lib/pegex/pegex/grammar.rb

@@ -0,0 +1,414 @@
+require 'json'
+require 'pegex/grammar'
+
+class Pegex::Pegex;end
+
+class Pegex::Pegex::Grammar < Pegex::Grammar
+  file = '../../pegex-pgx/pegex.pgx'
+
+  def make_tree
+    JSON.load <<'...'
+{
+"+grammar" : "pegex",
+"+toprule" : "grammar",
+"+version" : "0.2.0",
+"ERROR_all_group" : {
+  "+min" : 1,
+  ".ref" : "ERROR_rule_part",
+  ".sep" : {
+     ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))*"
+  }
+},
+"ERROR_any_group" : {
+  "+min" : "2",
+  ".ref" : "ERROR_all_group",
+  ".sep" : {
+     ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))*\\|(?:\\s|\\#.*(?:\\n|\\z))*"
+  }
+},
+"ERROR_bracketed_group" : {
+  ".any" : [
+     {
+        ".all" : [
+           {
+              ".rgx" : "(?!\\.)(?=[^\\w\\(\\)</\\~\\|`\\s]\\()"
+           },
+           {
+              ".err" : "Illegal group rule modifier (can only use .)"
+           }
+        ]
+     },
+     {
+        ".all" : [
+           {
+              ".rgx" : "(\\.?)\\((?:\\s|\\#.*(?:\\n|\\z))*"
+           },
+           {
+              ".ref" : "rule_group"
+           },
+           {
+              ".any" : [
+                 {
+                    ".all" : [
+                       {
+                          "+asr" : 1,
+                          ".ref" : "doc_ending"
+                       },
+                       {
+                          ".err" : "Runaway rule group no ending parens at EOF"
+                       }
+                    ]
+                 },
+                 {
+                    ".all" : [
+                       {
+                          ".rgx" : "(?=(?:\\s|\\#.*(?:\\n|\\z))*\\)[^\\w\\(\\)</\\~\\|`\\s\\*\\+\\?!=\\+\\-\\.:;])"
+                       },
+                       {
+                          ".err" : "Illegal character in group rule quantifier"
+                       }
+                    ]
+                 }
+              ]
+           }
+        ]
+     }
+  ]
+},
+"ERROR_error_message" : {
+  ".any" : [
+     {
+        ".all" : [
+           {
+              ".rgx" : "(?=`[^`\\r\\n]*[\\r\\n][^`]*`)"
+           },
+           {
+              ".err" : "Multi-line error messages not allowed!"
+           }
+        ]
+     },
+     {
+        ".all" : [
+           {
+              ".rgx" : "(?=`[^`]*(?:\\s|\\#.*(?:\\n|\\z))*\\z)"
+           },
+           {
+              ".err" : "Runaway error message no ending grave at EOF"
+           }
+        ]
+     }
+  ]
+},
+"ERROR_meta_definition" : {
+  ".all" : [
+     {
+        ".rgx" : "(?=%\\w+)"
+     },
+     {
+        ".err" : "Illegal meta rule"
+     }
+  ]
+},
+"ERROR_regular_expression" : {
+  ".all" : [
+     {
+        ".rgx" : "(?=/([^/]*)(?:\\s|\\#.*(?:\\n|\\z))*\\z)"
+     },
+     {
+        ".err" : "Runaway regular expression no ending slash at EOF"
+     }
+  ]
+},
+"ERROR_rule_definition" : {
+  ".all" : [
+     {
+        ".ref" : "ERROR_rule_start"
+     },
+     {
+        ".ref" : "ERROR_rule_group"
+     },
+     {
+        ".any" : [
+           {
+              ".ref" : "ending"
+           },
+           {
+              ".err" : "Rule ending syntax error"
+           }
+        ]
+     }
+  ]
+},
+"ERROR_rule_group" : {
+  ".any" : [
+     {
+        ".ref" : "ERROR_any_group"
+     },
+     {
+        ".ref" : "ERROR_all_group"
+     }
+  ]
+},
+"ERROR_rule_item" : {
+  ".any" : [
+     {
+        ".ref" : "rule_item"
+     },
+     {
+        ".ref" : "ERROR_rule_reference"
+     },
+     {
+        ".ref" : "ERROR_regular_expression"
+     },
+     {
+        ".ref" : "ERROR_bracketed_group"
+     },
+     {
+        ".ref" : "ERROR_error_message"
+     }
+  ]
+},
+"ERROR_rule_part" : {
+  "+max" : "2",
+  "+min" : "1",
+  ".ref" : "ERROR_rule_item",
+  ".sep" : {
+     ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))+(%{1,2})(?:\\s|\\#.*(?:\\n|\\z))+"
+  }
+},
+"ERROR_rule_reference" : {
+  ".any" : [
+     {
+        ".all" : [
+           {
+              ".rgx" : "(?=[!=\\+\\-\\.]?<[a-zA-Z]\\w*\\b(?!>))"
+           },
+           {
+              ".err" : "Missing > in rule reference"
+           }
+        ]
+     },
+     {
+        ".all" : [
+           {
+              ".rgx" : "(?=[!=\\+\\-\\.]?[a-zA-Z]\\w*\\b>)"
+           },
+           {
+              ".err" : "Missing < in rule reference"
+           }
+        ]
+     },
+     {
+        ".all" : [
+           {
+              ".rgx" : "(?=[!=\\+\\-\\.]?(?:[a-zA-Z]\\w*\\b|<[a-zA-Z]\\w*\\b>)[^\\w\\(\\)</\\~\\|`\\s\\*\\+\\?!=\\+\\-\\.:;])"
+           },
+           {
+              ".err" : "Illegal character in rule quantifier"
+           }
+        ]
+     },
+     {
+        ".all" : [
+           {
+              ".rgx" : "(?=[!=\\+\\-\\.]?[a-zA-Z]\\w*\\b\\-)"
+           },
+           {
+              ".err" : "Unprotected rule name with numeric quantifier please use <rule>#-# syntax!"
+           }
+        ]
+     },
+     {
+        ".all" : [
+           {
+              "+asr" : -1,
+              ".ref" : "rule_modifier"
+           },
+           {
+              ".rgx" : "(?=[^\\w\\(\\)</\\~\\|`\\s](?:[a-zA-Z]\\w*\\b|<[a-zA-Z]\\w*\\b>)(?:[\\*\\+\\?]|[0-9]+(?:\\-[0-9]+|\\+)?)?(?![\\ \\t]*:))"
+           },
+           {
+              ".err" : "Illegal rule modifier (must be [=!.-+]?)"
+           }
+        ]
+     }
+  ]
+},
+"ERROR_rule_start" : {
+  ".any" : [
+     {
+        ".rgx" : "([a-zA-Z]\\w*\\b)[\\ \\t]*:(?:\\s|\\#.*(?:\\n|\\z))*"
+     },
+     {
+        ".err" : "Rule header syntax error"
+     }
+  ]
+},
+"all_group" : {
+  ".all" : [
+     {
+        ".ref" : "rule_part"
+     },
+     {
+        "+min" : 0,
+        ".all" : [
+           {
+              ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))*"
+           },
+           {
+              ".ref" : "rule_part"
+           }
+        ]
+     }
+  ]
+},
+"any_group" : {
+  ".all" : [
+     {
+        ".ref" : "all_group"
+     },
+     {
+        "+min" : 0,
+        ".all" : [
+           {
+              ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))*\\|(?:\\s|\\#.*(?:\\n|\\z))*"
+           },
+           {
+              ".ref" : "all_group"
+           }
+        ]
+     }
+  ]
+},
+"bracketed_group" : {
+  ".all" : [
+     {
+        ".rgx" : "(\\.?)\\((?:\\s|\\#.*(?:\\n|\\z))*"
+     },
+     {
+        ".ref" : "rule_group"
+     },
+     {
+        ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))*\\)((?:[\\*\\+\\?]|[0-9]+(?:\\-[0-9]+|\\+)?)?)"
+     }
+  ]
+},
+"doc_ending" : {
+  ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))*\\z"
+},
+"ending" : {
+  ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))*?(?:\\n(?:\\s|\\#.*(?:\\n|\\z))*;?(?:\\s|\\#.*(?:\\n|\\z))*|\\#.*(?:\\n|\\z)(?:\\s|\\#.*(?:\\n|\\z))*;?(?:\\s|\\#.*(?:\\n|\\z))*|;(?:\\s|\\#.*(?:\\n|\\z))*|\\z)"
+},
+"error_message" : {
+  ".rgx" : "`([^`\\r\\n]*)`"
+},
+"grammar" : {
+  ".all" : [
+     {
+        ".ref" : "meta_section"
+     },
+     {
+        ".ref" : "rule_section"
+     },
+     {
+        ".any" : [
+           {
+              ".ref" : "doc_ending"
+           },
+           {
+              ".ref" : "ERROR_rule_definition"
+           }
+        ]
+     }
+  ]
+},
+"meta_definition" : {
+  ".rgx" : "%(grammar|extends|include|version)[\\ \\t]+[\\ \\t]*([^;\\n]*?)[\\ \\t]*(?:\\s|\\#.*(?:\\n|\\z))*?(?:\\n(?:\\s|\\#.*(?:\\n|\\z))*;?(?:\\s|\\#.*(?:\\n|\\z))*|\\#.*(?:\\n|\\z)(?:\\s|\\#.*(?:\\n|\\z))*;?(?:\\s|\\#.*(?:\\n|\\z))*|;(?:\\s|\\#.*(?:\\n|\\z))*|\\z)"
+},
+"meta_section" : {
+  "+min" : 0,
+  ".any" : [
+     {
+        ".ref" : "meta_definition"
+     },
+     {
+        ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))+"
+     },
+     {
+        ".ref" : "ERROR_meta_definition"
+     }
+  ]
+},
+"regular_expression" : {
+  ".rgx" : "/([^/]*)/"
+},
+"rule_definition" : {
+  ".all" : [
+     {
+        ".ref" : "rule_start"
+     },
+     {
+        ".ref" : "rule_group"
+     },
+     {
+        ".ref" : "ending"
+     }
+  ]
+},
+"rule_group" : {
+  ".ref" : "any_group"
+},
+"rule_item" : {
+  ".any" : [
+     {
+        ".ref" : "rule_reference"
+     },
+     {
+        ".ref" : "regular_expression"
+     },
+     {
+        ".ref" : "bracketed_group"
+     },
+     {
+        ".ref" : "whitespace_token"
+     },
+     {
+        ".ref" : "error_message"
+     }
+  ]
+},
+"rule_modifier" : {
+  ".rgx" : "[!=\\+\\-\\.]"
+},
+"rule_part" : {
+  "+max" : "2",
+  "+min" : "1",
+  ".ref" : "rule_item",
+  ".sep" : {
+     ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))+(%{1,2})(?:\\s|\\#.*(?:\\n|\\z))+"
+  }
+},
+"rule_reference" : {
+  ".rgx" : "([!=\\+\\-\\.]?)(?:([a-zA-Z]\\w*\\b)|(?:<([a-zA-Z]\\w*\\b)>))((?:[\\*\\+\\?]|[0-9]+(?:\\-[0-9]+|\\+)?)?)(?![\\ \\t]*:)"
+},
+"rule_section" : {
+  "+min" : 0,
+  ".any" : [
+     {
+        ".ref" : "rule_definition"
+     },
+     {
+        ".rgx" : "(?:\\s|\\#.*(?:\\n|\\z))+"
+     }
+  ]
+},
+"rule_start" : {
+  ".rgx" : "([a-zA-Z]\\w*\\b)[\\ \\t]*:(?:\\s|\\#.*(?:\\n|\\z))*"
+},
+"whitespace_token" : {
+  ".rgx" : "(\\~+)"
+}
+}
+...
+  end
+end

data/lib/pegex/receiver.rb

@@ -0,0 +1,7 @@
+class Pegex::Receiver
+  attr_accessor :parser
+
+  def flatten array
+    return array.flatten!
+  end
+end

data/lib/pegex/tree/wrap.rb

@@ -0,0 +1,13 @@
+require 'pegex/tree'
+
+class Pegex::Tree::Wrap < Pegex::Tree
+  def gotrule got
+    return got if @parser.parent['-pass']
+    return $pegex_nil unless got
+    return @parser.rule => got
+  end
+
+  def final got
+    return got || {@parser.rule => []}
+  end
+end

data/lib/pegex/tree.rb

@@ -0,0 +1,17 @@
+require 'pegex/receiver'
+
+class Pegex::Tree < Pegex::Receiver
+  def gotrule got=nil
+    return $pegex_nil if got.nil?
+
+    if self.parser.parent['-wrap']
+      return {self.parser.rule => (got || [])}
+    else
+      return got
+    end
+  end
+
+  def final got=nil
+    return got || []
+  end
+end

data/lib/pegex.rb

@@ -0,0 +1,18 @@
+module Pegex
+  VERSION = '0.0.1'
+end
+
+require 'pegex/parser'
+require 'pegex/grammar'
+
+def pegex grammar_text, receiver=nil
+  unless receiver
+    require 'pegex/tree/wrap'
+    receiver = Pegex::Tree::Wrap.new
+  end
+  receiver = receiver.new if receiver.class == Class
+  return Pegex::Parser.new { |o|
+    o.grammar = Pegex::Grammar.new {|g| g.text = grammar_text}
+    o.receiver = receiver
+  }
+end