pratt_parser 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 2be786fcdd7e3a6860fd2218ae404036a6de85e1
+  data.tar.gz: b0684865ee6fcbb04ef26544819e43598e2dfa3a
+SHA512:
+  metadata.gz: 6d7a691fa927a0e0095827cf1abebdf4ac8102a12774b6b60a93693eef495beabe79ef4b6f4885d99ccecf5928957684f7eb1fdc377b032300eec099a8943cc9
+  data.tar.gz: 3d8549f09a0d0b74b45238f390b0124fe5e7cbcaf6e9e25a13513f45701212945044add373e623e8064b005bdb6f2cc313ebfc65dd9700db824b20dec28fcde5

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/LICENSE.md

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2015 F Thomas May
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,21 @@
+Pratt Parser
+============
+
+A Pratt Parser.  Construct it with a Lexer that returns tokens that
+define the language to be parsed and combines terms.
+
+Pratt parsers are like recursive descent parsers but instead of having
+to code a function for each production you just code up some token
+objects which define their own prededence and associativity.  So it's
+simple to add new tokens without having to rewrite a bunch of
+recursive descent functions.
+
+Pratt parsers are also more efficient than recursive descent parsers
+since they don't need to recurse all the way down to the bottom level
+to figure out what to do.
+
+http://javascript.crockford.com/tdop/tdop.html
+
+http://effbot.org/zone/simple-top-down-parsing.htm
+
+http://journal.stuffwithstuff.com/2011/03/19/pratt-parsers-expression-parsing-made-easy/

data/Rakefile

@@ -0,0 +1,11 @@
+task :gem do
+  sh "gem build pratt_parser.gemspec"
+end
+
+task :install => :gem do
+  sh "gem install pratt_parser"
+end
+
+task :clean do
+  sh "rm *.gem"
+end

data/lib/pratt_parser.rb

@@ -0,0 +1,84 @@
+# A Pratt parser.  Similar to a recursive decent parser but instead of
+# coding a function for each production, the syntax is coded in a set
+# of token objects that are yielded by the lexer.  New operators and
+# statements can be slipped in to the language with the proper
+# precedence by adding new token objects to the lexer without altering
+# the code for existing tokens.  Pretty cool.
+#
+# lexer is an enumerator with an each method that returns token objects
+# with three methods:
+# lbp: return the operator precedence.  Higher numbers bind more tightly.
+# nud(parser): called when the token is the first token in an expression,
+#   including a recursive call to expresssion (i.e., subexpression).  For
+#   Example, this would be called for a unary operator, a literal, or for
+#   the "if" in the construct "if <cond> then <expr>".
+#   It is the token's responsibility to call parser.expression, parser.expect,
+#   and/or parser.if? to handle the remainder of the expression, if any.
+# led(parser, left): called when the token is preceeded by a subexpression,
+#   left.  The token may be postfix or infix.
+#   It is the token's responsibility to call parser.expression, parser.expect,
+#   and/or parser.if? to handle the remainder of the expression, if any,
+#   and combine it with left.
+# Only lbp is mandatory.  nud and led will be called only when necessary, if
+# ever.
+# nud and lcd can call parser.expression(rbp) to recursively parse the
+# right expression.  rbp should be the token's lbp for left-associativity,
+# lbp-1 for right.
+#
+# PrattParser.new(lexer).eval will return the result of the parse.
+#
+# Syntax errors aren't handled at the moment and will cause ridiculous
+# exceptions to be raised such as NoMethodError.
+
+# http://javascript.crockford.com/tdop/tdop.html
+# http://effbot.org/zone/simple-top-down-parsing.htm
+# http://journal.stuffwithstuff.com/2011/03/19/pratt-parsers-expression-parsing-made-easy/
+
+class PrattParser
+  def initialize(lexer)
+    @lexer = Enumerator.new do |y|
+      lexer.each do |token|
+        y << token
+      end
+      y << EndToken.new
+    end
+
+    @token = nil
+  end
+
+  def eval
+    @token = @lexer.next
+    expression(0)
+  end
+
+  def expression(rbp)
+    t = @token
+    @token = @lexer.next
+    left = t.nud(self)
+    while rbp < @token.lbp
+      t = @token
+      @token = @lexer.next
+      left = t.led(self, left)
+    end
+    left
+  end
+
+  def expect(expected_token_class)
+    if @token.class != expected_token_class
+      raise "Expected #{expected_token_class}, got #{@token.class}"
+    end
+    @token = @lexer.next
+  end
+
+  def if?(token_class)
+    if @token.class == token_class
+      @token = @lexer.next
+    end
+  end
+
+  class EndToken
+    def lbp
+      0
+    end
+  end
+end

data/pratt_parser.gemspec

@@ -0,0 +1,14 @@
+Gem::Specification.new do |gem|
+  gem.description      = "A Pratt parser.  Create token objects to define your language."
+  gem.summary          = "A Pratt parser."
+  gem.authors          = ["Tom May"]
+  gem.email            = ["tom@tommay.net"]
+  gem.homepage         = "https://github.com/tommay/pratt_parser"
+  gem.files            = `git ls-files | egrep -v '^example'`.split("\n")
+  gem.test_files       = `git ls-files -- spec/*`.split("\n")
+  gem.name             = "pratt_parser"
+  gem.require_paths    = ["lib"]
+  gem.version          = "0.0.0"
+  gem.license          = "MIT"
+#  gem.required_ruby_version = '>= 2.1.0'
+end

metadata

@@ -0,0 +1,50 @@
+--- !ruby/object:Gem::Specification
+name: pratt_parser
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Tom May
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-02-26 00:00:00.000000000 Z
+dependencies: []
+description: A Pratt parser.  Create token objects to define your language.
+email:
+- tom@tommay.net
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- LICENSE.md
+- README.md
+- Rakefile
+- lib/pratt_parser.rb
+- pratt_parser.gemspec
+homepage: https://github.com/tommay/pratt_parser
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.5
+signing_key: 
+specification_version: 4
+summary: A Pratt parser.
+test_files: []