grammar 0.5 → 0.8

data/benchmark/json.benchmark.rb

@@ -0,0 +1,355 @@
+#!/usr/bin/env ruby
+
+require 'benchmark'
+require 'timeout'
+require 'rubygems'
+
+class JSON_Generator
+    attr_accessor(:array, :object)
+    def initialize
+        @string1 = '1'
+        @string2 = '2'
+        @array1 = ['abc : 123', {}, false]
+        @array2 = [1.234e-5, {@string2 => nil}, '']
+        @object1 = {@string1 => '\\\n\t', @string2 => true}
+        @object2 = {@string2 => -789, @string2 => []}
+    end
+    def grow
+        @array1,
+        @array2,
+        @object1,
+        @object2 =
+        @array1.reverse << @object2,
+        @array2.reverse.concat(@array1),
+        @object1.merge({@string1 => @array2}),
+        @object2.merge(@object1)
+        @array2
+    end
+end
+
+def filesize(filename)
+    text = IO.read(filename)
+    text.gsub!(/\#[^\{].*/, '')
+    text.gsub!(/\/\*.*?\*\//, '')
+    text.gsub!(/^\s+/, '')
+    text.gsub!(/\t/, ' ')
+    text.gsub!(/\ +/, ' ')
+    text.gsub!(/\ \n/, "\n")
+    text.gsub!(/\s([\{])\s?/) { $1 }
+    text.gsub!(/([\(])\s?/) { $1 }
+    text.gsub!(/\s([\&\+\-]+|\W\=)\s/) { $1 }
+    text.gsub!(/\s?([\|\<\>\=\,\;]+)\s?/) { $1 }
+    text.gsub!(/\s?([\)])/) { $1 }
+    text.gsub!(/\s?([\}])\ ?/) { $1 }
+    #puts
+    #print text
+    text.size
+end
+
+def benchmark(label='', filename=nil)
+    constants = {}
+    self.class.constants.each { |constant| constants[constant] = true }
+    load_path = $LOAD_PATH.clone
+    loaded_features = $LOADED_FEATURES.clone
+    !ARGV[0] or Regexp.new(ARGV[0])=~label or return
+    make = yield
+    limit = (ARGV[1]||1).to_f
+    max_tries = 4
+    unless label.empty?
+        STDERR.print(label)
+        if filename
+            STDERR.print(" ".concat(filesize(filename).to_s))
+        else
+            STDERR.print(" -")
+        end
+    end
+    bandwidth = nil
+    generator = JSON_Generator.new
+    tree0 = nil
+    s = nil
+    tree = nil
+    tries = 0
+    done = false
+    begin
+        GC.start
+        tms = Benchmark.measure {
+            if tries>0
+                tries += 1
+            else
+                tree0 = generator.grow
+            end
+            s = tree0.inspect
+            s.gsub!(/=>/, ':')
+            s.gsub!(/nil/, 'null')
+        }
+        if !make
+            return if tms.utime+tms.stime>limit
+            next
+        end
+        #puts s
+        run = make[s]
+        GC.start
+        GC.start
+        tms = Benchmark.measure { tree = run[] }
+        GC.start
+        raise("#{tree.inspect}!=#{tree0.inspect}") if tree!=tree0
+        tree = nil
+        t = tms.utime+tms.stime
+        bandwidth = s.length/t
+        s = nil
+        GC.start
+        if tries.zero?
+            if t>limit
+                tries = 1
+            else
+                next #if t<(limit/3)
+            end
+        end
+        if bandwidth>=1e9
+            bandwidth /= 1e9
+            suffix = "G"
+        elsif bandwidth>=1e6
+            bandwidth /= 1e6
+            suffix = "M"
+        elsif bandwidth>=1e3
+            bandwidth /= 1e3
+            suffix = "K"
+        else
+            suffix = ""
+        end
+        bandwidth = ("%.3g" % bandwidth).concat(suffix).concat("/s")
+        STDERR.print(" ", bandwidth)
+    end until tries>=max_tries
+    STDERR.print("\n")
+    return bandwidth
+rescue => error
+    p error
+ensure
+    #Gem.clear_paths
+    #Gem.loaded_specs.clear
+    self.class.constants.each { |constant|
+        next if constants[constant]
+        #puts("removing #{constant}")
+        self.class.send(:remove_const, constant)
+    }
+    $LOAD_PATH.replace(load_path)
+    $LOADED_FEATURES.replace(loaded_features)
+end
+
+require 'strscan'
+require 'stringio'
+
+json_pure = '/var/lib/gems/1.8/gems/json-1.1.2/lib/json/pure/parser.rb'
+json_ext = '/var/lib/gems/1.8/gems/json-1.1.2/ext/json/ext/parser/parser.rl'
+
+benchmark('') {}
+
+benchmark('json/ext', json_ext) {
+    gem 'json'
+    require 'json/ext'
+    lambda { |s|
+        JSON::Ext::Parser.new(s).method(:parse)
+    }
+}
+
+benchmark('Grammar/Ruby2CExt', 'json.grammar.rb') {
+    $LOAD_PATH << '../lib'
+    require '../lib/grammar'
+    grammar = Grammar.new.instance_eval(IO.read('json.grammar.rb'))
+    Kernel.module_eval { alias_method(:_warn, :warn) }
+    Kernel.module_eval { def warn(*);end }
+    require 'grammar/ruby2cext'
+    Kernel.module_eval { alias_method(:warn, :_warn) }
+    grammar_ruby2cext = Grammar::Ruby2CExt.compile(grammar)
+    lambda { |s|
+        i = StringIO.new(s).method(:getc)
+        out = []
+        lambda {
+            grammar_ruby2cext[out, i]
+            out[0]
+        }
+    }
+}
+
+benchmark('hand/RE', 'json.re.rb') {
+    load 'json.re.rb'
+    re = JSON.new
+    lambda { |s|
+        i = StringScanner.new(s)
+        lambda {
+            re.parse(i)
+        }
+    }
+}
+
+benchmark('hand/LL1', 'json.ll1.rb') {
+    load 'json.ll1.rb'
+    ll1 = JSON.new
+    lambda { |s|
+        i = StringIO.new(s)
+        lambda {
+            ll1.parse(i)
+        }
+    }
+}
+
+benchmark('Grammar/Ruby', 'json.grammar.rb') {
+    $LOAD_PATH << '../lib'
+    require '../lib/grammar'
+    grammar = Grammar.new.instance_eval(IO.read('json.grammar.rb'))
+    require 'grammar/ruby'
+    grammar_ruby = Grammar::Ruby.compile(grammar)
+    lambda { |s|
+        i = StringIO.new(s).method(:getc)
+        out = []
+        lambda {
+            grammar_ruby[out, i]
+            out[0]
+        }
+    }
+}
+
+benchmark('RACC/ext', 'json.y') {
+    system('racc json.y -o json.racc.rb')
+    load 'json.racc.rb'
+    Racc::Parser.instance_eval {
+        remove_const(:Racc_Main_Parsing_Routine)
+        remove_const(:Racc_YY_Parse_Method     )
+        remove_const(:Racc_Runtime_Type        )
+        const_set(:Racc_Main_Parsing_Routine, :_racc_do_parse_c)
+        const_set(:Racc_YY_Parse_Method     , :_racc_yyparse_c )
+        const_set(:Racc_Runtime_Type        , 'c')
+    }
+    racc = JSON.new
+    lambda { |s|
+        i = StringScanner.new(s)
+        lambda {
+            racc.parse(i)
+        }
+    }
+}
+
+benchmark('json/pure', json_pure) {
+    gem 'json'
+    require 'json/pure'
+    lambda { |s|
+        JSON::Pure::Parser.new(s).method(:parse)
+    }
+}
+
+benchmark('Grammar/RubyCall', 'json.grammar.rb') {
+    $LOAD_PATH << '../lib'
+    require '../lib/grammar'
+    grammar = Grammar.new.instance_eval(IO.read('json.grammar.rb'))
+    require 'grammar/rubycall'
+    grammar_ruby = Grammar::RubyCall.compile(grammar)
+    lambda { |s|
+        i = StringIO.new(s).method(:getc)
+        out = []
+        lambda {
+            grammar_ruby[out, i]
+            out[0]
+        }
+    }
+}
+
+benchmark('Grammar/0.5', 'json.grammar0_5.rb') {
+    gem 'grammar'
+    require 'grammar'
+    require 'duck'
+    require 'json.grammar0_5'
+    gem 'cursor'
+    require 'cursor/io'
+    grammar0_5 = JSON.new
+    lambda { |s|
+        i = Cursor::IO.new(StringIO.new(s))
+        lambda {
+            grammar0_5.scan(i, out=[])
+            out[0]
+        }
+    }
+}
+
+benchmark('RACC/ruby', 'json.y') {
+    system('racc json.y -o json.racc.rb')
+    load 'json.racc.rb'
+    Racc::Parser.instance_eval {
+        remove_const(:Racc_Main_Parsing_Routine)
+        remove_const(:Racc_YY_Parse_Method     )
+        remove_const(:Racc_Runtime_Type        )
+        const_set(:Racc_Main_Parsing_Routine, :_racc_do_parse_rb)
+        const_set(:Racc_YY_Parse_Method     , :_racc_yyparse_rb )
+        const_set(:Racc_Runtime_Type        , 'ruby')
+    }
+    racc = JSON.new
+    lambda { |s|
+        i = StringScanner.new(s)
+        lambda {
+            racc.parse(i)
+        }
+    }
+}
+
+benchmark('Treetop', 'json.treetop') {
+    gem 'treetop'
+    require 'treetop'
+    Treetop.load('json.treetop')
+    treetop = JSONParser.new
+    lambda { |s|
+        lambda {
+            treetop.parse(s).obj
+        }
+    }
+}
+
+benchmark('GhostWheel', 'json.ghostwheel') {
+    gem 'ghostwheel'
+    require 'ghost_wheel'
+    ghostwheel = GhostWheel.build_parser(IO.read("json.ghostwheel"))
+    lambda { |s|
+        lambda {
+            ghostwheel.parse(s)
+        }
+    }
+}
+
+benchmark('Grammar/Ruby0', 'json.grammar.rb') {
+    $LOAD_PATH << '../lib'
+    require '../lib/grammar'
+    grammar = Grammar.new.instance_eval(IO.read('json.grammar.rb'))
+    require 'grammar/ruby0'
+    grammar_ruby0 = Grammar::Ruby0.compile(grammar)
+    lambda { |s|
+        i = StringIO.new(s).method(:getc)
+        out = []
+        lambda {
+            grammar_ruby0[out, i]
+            out[0]
+        }
+    }
+}
+
+benchmark('Peggy', 'json.peggy.rb') {
+    gem 'peggy'
+    require 'parser'
+    require 'builder'
+    require 'json.peggy'
+    peggy = JSON.new
+    lambda { |s|
+        peggy.source_text = s
+        lambda {
+            peggy.parse?(:value)
+            peggy.to_ruby
+        }
+    }
+}
+
+benchmark('json/ext', json_ext) {
+    gem 'json'
+    require 'json/ext'
+    lambda { |s|
+        JSON::Ext::Parser.new(s).method(:parse)
+    }
+}
+
+

data/benchmark/json.grammar.rb

@@ -0,0 +1,56 @@
+Common { |e|
+    ws = (E(?\s) | E(?\t) | E(?\n) | E(?\r)).discard.repeat0
+
+    digit = E(?0..?9)
+    digits = digit.repeat1
+    exp = ((E(?e)|E(?E)) + (E(?+)|E(?-)|NULL)) + digits
+    int0 = E(?0) | E(?1..?9) + digit.repeat0
+    number = ((E(?-) + int0 | int0) + (
+        (E(?.) + digits + (exp|NULL) | exp) + Output { |s| s.to_f } |
+        Output { |s| s.to_i }
+    )).group("")
+
+    hex = digit | E(?a..?f) | E(?A..?F)
+    char = E(?\\).discard + (
+            E(?\") |
+            E(?\\) |
+            E(?\/) |
+            E(?b).discard { e[?\b] } |
+            E(?f).discard { e[?\f] } |
+            E(?n).discard { e[?\n] } |
+            E(?r).discard { e[?\r] } |
+            E(?t).discard { e[?\t] } |
+            E(?u).discard + (hex+hex+hex+hex).group("") { |s|
+                s.to_i(e[16])
+            }
+        ) |
+        ANY
+    string = E(?\").discard + char.repeat0(E(?\").discard).group("")
+    
+    ws + Recurse { |value|
+        elements = Recurse { |elements|
+            value + ws + (E(?,).discard + ws + elements | NULL)
+        }
+        array = E(?[).discard + ws + (elements + ws|NULL).group([]) +
+            E(?]).discard
+        
+        pair = string + ws + E(?:).discard + ws + value
+        members = Recurse { |members|
+            pair + ws + (E(?,).discard + ws + members | NULL)
+        }
+        object = E(?{).discard + ws + (members|NULL).redirect([]) { |buf|
+            e << e.send_splat(e[Hash], :[], buf)
+        } + E(?}).discard
+
+        string |
+        object |
+        array |
+        Chain("true").discard { e[true] } |
+        Chain("false").discard { e[false] } |
+        Chain("null").discard { e[nil] } |
+        number 
+
+    } + ws + EOF
+}
+
+

data/benchmark/json.grammar0_5.rb

@@ -0,0 +1,57 @@
+class JSON < Grammar
+
+    E = Element
+
+    def initialize
+
+        ws = (E[?\s]|E[?\t]|E[?\n]|E[?\r]).discard.list0
+    
+        digit = E[(?0..?9).duck!(:==,:===)]
+        digits = digit.list1
+        exp = (E[?e]|E[?E]) + (E[?+]|E[?-]|NULL) + digits
+        int0 = E[?0] | E[(?1..?9).duck!(:==,:===)] + digit.list0
+        number = ((E[?-] + int0 | int0).group(String) +
+                  (E[?.] + digits + (exp|NULL) | exp | NULL).group(String)).
+                 filter(Array) { |n| n[1].empty? ? [n[0].to_i] : [n.to_s.to_f] }
+
+        hex = digit | E[(?a..?f).duck!(:==,:===)] | E[(?A..?F).duck!(:==,:===)]
+        char = E[?\\].discard + (
+                E[?\"].filter { "\"" } |
+                E[?\\].filter { "\\" } |
+                E[?\/].filter { "\/" } |
+                E[?b].filter { "\b" } |
+                E[?f].filter { "\f" } |
+                E[?n].filter { "\n" } |
+                E[?r].filter { "\r" } |
+                E[?t].filter { "\t" } |
+                E[?u].discard + (hex+hex+hex+hex).filter { |s| "" << s.to_i(16) }
+            ) |
+            ANY
+        string = E[?\"].discard + char.list0(E[?\"].discard).group(String)
+        
+        super(ws + Grammar.new { |value|
+            elements = (value + ws).list1(nil, E[?,].discard + ws)
+            array = E[?[].discard + ws + (elements + ws|NULL).group(Array) +
+                    E[?]].discard
+            
+            pair = string + ws + E[?:].discard + ws + value
+            members = (pair + ws).list1(nil, E[?,].discard + ws)
+            object = E[?{].discard + ws + (members|NULL).filter(Array) { |a|
+                [Hash[*a]]
+            } + E[?}].discard 
+
+            string |
+            object |
+            array |
+            (E[?t]+E[?r]+E[?u]+E[?e]).filter { [true] } |
+            (E[?f]+E[?a]+E[?l]+E[?s]+E[?e]).filter { [false] } |
+            (E[?n]+E[?u]+E[?l]+E[?l]).filter { [nil] } |
+            number
+            
+        } + ws + EOF)
+
+    end
+
+end
+
+