grammar 0.5 → 0.8

data/samples/tcl.rb

@@ -1,163 +0,0 @@
-#!/bin/env ruby
-
-require 'rubygems'
-require 'cursor/io'
-require 'cursor/indexed'
-require 'grammar'
-require 'duck'
-require 'set'
-
-class Tcl
-
-def initialize
-
-    @variables = {}
-    @procs = {}
-
-    space = Grammar::Element[Set[?\ ,?\t].duck!(:==,:include?)].discard
-    newline = Grammar::Element[?\n]
-    command_separator = newline|Grammar::Element[?;]
-    hex = Grammar::Element[(
-        Set[]+(?0..?9)+(?a..?f)+(?A..?F)
-    ).duck!(:==,:include?)]
-    octal = Grammar::Element[(?0..?7).duck!(:==,:===)]
-    alphanum = Grammar::Element[(
-        Set[?_]+(?0..?9)+(?a..?z)+(?A..?Z)
-    ).duck!(:==,:include?)]
-
-    backslashed = Grammar::Element[?\\].discard+(
-        Grammar::Element[?a].filter { "\a" } |
-        Grammar::Element[?b].filter { "\b" } |
-        Grammar::Element[?f].filter { "\f" } |
-        Grammar::Element[?n].filter { "\n" } |
-        Grammar::Element[?r].filter { "\r" } |
-        Grammar::Element[?t].filter { "\t" } |
-        Grammar::Element[?v].filter { "\v" } |
-        Grammar::Element[?x].discard+hex.list1.filter { |n|
-            eval(%Q("\\x#{n}"))
-        } |
-        Grammar::Element[?u].discard+hex.list1 { |n| # don't know what to do with unicode
-            eval(%Q("\\x#{n}"))
-        } |
-        octal.list1.filter { |n|
-            eval(%Q("\\#{n}"))
-        } |
-        (newline.discard+space.list0).filter { " " } |
-        Grammar::ANY
-    )
-    
-    braced_element = Grammar.new { |braced_element|
-        Grammar::Element[?\{]+braced_element.list0(Grammar::Element[?\}]) |
-        Grammar::Element[?\\].discard+(
-            (newline.discard+space.list0).filter { " " } |
-            Grammar::NULL.filter { "\\" }
-        ) |
-        newline |
-        Grammar::ANY
-    }
-    braced = Grammar::Element[?\{].discard+braced_element.list0(Grammar::Element[?\}].discard)
-    
-    element = Grammar.new
-    
-    varname = (
-        alphanum |
-        Grammar::Element[?\:]*(2..+1.0/0)
-    ).list1
-    index = Grammar::Element[?\(]+element.list1(Grammar::Element[?\)])
-    variable = (Grammar::Element[?\$].discard + (
-        varname.group(String) + index.group(String).optional |
-        braced.group(String)
-    )).filter { |var| @variables[var.to_s.to_sym].to_s }
-    
-    quoted = Grammar::Element[?\"].discard+element.list1(Grammar::Element[?\"].discard)
-    comment = (Grammar::Element[?\#]+Grammar::ANY.list0(newline)).discard
-    
-    commander = lambda { |terminator|
-        word_terminator = space.list1|+command_separator|+terminator
-        word = ((braced|quoted)+word_terminator|element.list1(word_terminator)).
-            group(String).filter {|x,t| t.concat(x)}
-        command = space.list0 + (
-            comment |
-            word.list0(command_separator.discard|+terminator).
-                filter(Array) { |com,ret|
-                    com.empty? ? ret : ret.replace(send(*com).to_s)
-                }
-        )
-        command.list0(terminator.discard)
-    }
-    
-    bracketed = Grammar::Element[?[].discard+commander[Grammar::Element[?]]]
-    
-    @interpreter = commander[Grammar::EOF]
-
-    element << (backslashed | bracketed | variable | newline | Grammar::ANY)
-
-end
-
-def interpret(cursor)
-    @interpreter.scan(cursor,"",false)
-end
-
-def method_missing(name,*args)
-    vars,body = *@procs[name]
-    return "<#{name}#{args.inspect}>" if !body
-    variables = @variables
-    @variables = {}
-    vars.zip(args).each { |var,val| @variables[var.to_sym] = val }
-    ret = interpret(body.to_cursor)
-    @variables = variables
-    ret
-end
-
-def proc(name,args,body)
-    @procs[name.to_sym] = [args,body]
-    ""
-end
-
-def set(name,value)
-    @variables[name.to_sym] = value
-end
-
-def if(condition,body)
-    # should really use expr to get condition
-    unless %w(0 false no off).include?(condition.to_s)
-        interpret(body.to_cursor)
-    end
-    # need to handle elsif and else
-    ""
-end
-
-def sum(*values)
-    values.inject(0) { |sum, v| sum + eval(v) }
-end
-
-def product(*values)
-    values.inject(1) { |sum, v| sum * eval(v) }
-end
-
-def subtract(a,b)
-    eval(a)-eval(b)
-end
-
-def divide(a,b)
-    eval(a)/eval(b)
-end
-
-def puts(str)
-    $stdout.print(str,"\n")
-    ""
-end
-
-def concat(*args)
-    args.inject("") { |concatenated, arg| concatenated.concat(arg) }
-end
-
-end
-
-if $0==__FILE__
-    result = Tcl.new.interpret($stdin.to_cursor)
-    p result
-    result
-end
-
-

data/samples/test.infix

@@ -1,4 +0,0 @@
-"one\n" *
-(2+3.0  /4e0*(5E+0+6.0e-0)-07)+
-(" eight\t"*nine)
-

data/test/test_grammar.rb

@@ -1,274 +0,0 @@
-#!/bin/env ruby
-
-require 'rubygems'
-require 'test/unit'
-require 'test/unit/collector'
-require 'cursor/indexed'
-require 'grammar'
-
-module Test   
-  module Unit
-    class AutoRunner
-      alias_method(:_options_,:options)
-      def options
-        @options = _options_
-        @options.on('-i', '--iterations=NUMBER', Float,
-               "Randomly run tests for a number of iterations.") do |iterations|
-            $random_iterations = iterations
-          end
-        @options.on('-s', '--seed=NUMBER', Integer,
-               "Random seed.") do |seed|
-            $random_seed = seed.nonzero?
-          end
-        @options
-      end
-      alias_method(:_run_,:run)
-      def run
-        $output_level = @output_level
-        $random_seed ||= (srand;srand)
-        srand($random_seed)
-        _run_
-      end
-    end
-    module Collector
-      alias_method(:_add_suite_,:add_suite)
-      def add_suite(destination, suite)
-        _add_suite_(destination, suite)
-        if $random_iterations
-          (class << suite.tests;self;end).class_eval {
-            def each
-              n = size
-              ($random_iterations*n).to_i.times {
-                yield(slice(rand(n)))
-              }
-            end
-          }
-        end
-        destination
-      end
-    end
-    class TestSuite
-      def run(result, &progress_block)
-        yield(STARTED, name)
-        catch(:stop_suite) {
-          @tests.each { |test|
-            catch(:invalid_test) {
-              test.run(result, &progress_block)
-            }
-          }
-        }
-        yield(FINISHED, name)
-      end
-    end
-    class RandomTestCase < TestCase
-      def self.suite
-        suite = super
-        puts("random_seed: #{$random_seed}") if !suite.tests.empty? and $output_level>=UI::NORMAL
-        suite
-      end
-      undef_method(:default_test) # so that RandomTestCase is empty
-      def teardown
-        if not passed?
-          puts("\nrandom_seed: #{$random_seed}")
-          throw(:stop_suite)
-        end
-      end
-    end
-  end
-end
-
-
-class Grammar
-
-class Test < ::Test::Unit::RandomTestCase
-
-class Grammars
-    include ::Test::Unit::Assertions
-    def initialize
-        @grammar = []
-        @match = []
-        @parsed = []
-        @mismatch = []
-        @partial_match = []
-    end
-    def get
-        i = rand(@grammar.size.nonzero? || throw(:invalid_test))
-        return @grammar[i],@match[i],@parsed[i],@mismatch[i],@partial_match[i]
-    end
-    def add(grammar,match,parsed,mismatch=nil,partial_match=nil)
-        puts("#{grammar.inspect} #{match.inspect} #{parsed.inspect} #{mismatch.inspect} #{partial_match.inspect}") if
-            $output_level>=::Test::Unit::UI::VERBOSE
-        match.size.times { |i|
-            assert_equal(parsed[i],grammar.scan(match[i].to_cursor))
-        }
-        if mismatch
-            assert_raise(Grammar::Error){p grammar.scan(mismatch.to_cursor)}
-            assert_equal(false,grammar.scan(mismatch.to_cursor,[],true))
-        end
-        if partial_match
-            assert_raise(Grammar::Error){grammar.scan(partial_match.to_cursor)}
-        end
-        @grammar << grammar
-        @match << match
-        @parsed << parsed
-        @mismatch << mismatch
-        @partial_match << partial_match
-        nil
-    end
-end
-
-def self.suite
-    suite = super
-    self.plant
-    suite
-end
-
-def self.plant
-    @@grammars = Grammars.new
-end
-
-def test_Sequence
-    partial = rand(2)==1
-    value = ["a","bc"][rand(2)]
-    match = value.dup
-    if partial
-        match = [match,match[0,1+rand(value.size)]]
-    else
-        match = [match]
-    end
-    parsed = match.map{|s|s.unpack("C*")}
-    @@grammars.add(Grammar::Sequence.new(value,partial),match,parsed,"")
-end
-
-def test_Element
-    value = [?a,?b][rand(2)]
-    match = ["" << value]
-    parsed = [[value]]
-    @@grammars.add(Grammar::Element.new(value),match,parsed,"")
-end
-
-def test_NULL
-    @@grammars.add(Grammar::NULL,[""],[[]])
-end
-
-def test_or
-    grammar1,match1,parsed1,mismatch1,partial1 = @@grammars.get
-    grammar2,match2,parsed2,mismatch2,partial2 = @@grammars.get
-    i = rand(match1.size)
-    match1 = match1[i]
-    parsed1 = parsed1[i]
-    i = rand(match2.size)
-    match2 = match2[i]
-    parsed2 = parsed2[i]
-    begin
-        # match2 shouldn't match grammar1
-        grammar1.scan(match2.to_cursor,[],true) and throw(:invalid_test)
-    rescue Grammar::Error
-        throw(:invalid_test) # partial match
-    end
-    @@grammars.add(
-        grammar1|grammar2,
-        [match1,match2],
-        [parsed1,parsed2],
-        mismatch1==mismatch2 ? mismatch1 : nil,
-        partial1==partial2 ? partial1 : nil
-    )
-end
-
-def test_plus
-    grammar1,match1,parsed1,mismatch1,partial1 = @@grammars.get
-    grammar2,match2,parsed2,mismatch2,partial2 = @@grammars.get
-    i = rand(match1.size)
-    match1 = match1[i]
-    parsed1 = parsed1[i]
-    i = rand(match2.size)
-    match2 = match2[i]
-    parsed2 = parsed2[i]
-    # grammar1 shouldn't eat into match2
-    begin
-        grammar1.scan((match1+match2).to_cursor)==parsed1 or
-        throw(:invalid_test)
-    rescue Grammar::Error
-        throw(:invalid_test)
-    end
-    @@grammars.add(
-        grammar1+grammar2,
-        [match1+match2],
-        [parsed1+parsed2],
-        mismatch1,
-        partial1 || (mismatch2 && match1+mismatch2)
-    )
-end
-
-def test_Grammar
-    grammar1,match1,parsed1,mismatch1,partial1 = @@grammars.get
-    grammar2,match2,parsed2,mismatch2,partial2 = @@grammars.get
-    i = rand(match1.size)
-    match1 = match1[i]
-    parsed1 = parsed1[i]
-    i = rand(match2.size)
-    match2 = match2[i]
-    parsed2 = parsed2[i]
-    !match1.empty? or throw(:invalid_test)
-    begin
-        (grammar1.scan((match1+match1).to_cursor)==parsed1 and
-        grammar1.scan((match1+match2).to_cursor)==parsed1 and
-        grammar2.scan((match2+match2).to_cursor)==parsed2) or
-        throw(:invalid_test)
-        grammar1.scan(match2.to_cursor,[],true) and throw(:invalid_test)
-    rescue Grammar::Error
-        throw(:invalid_test)
-    end
-    grammar = Grammar.new
-    grammar << grammar1+(grammar|Grammar::NULL)+grammar2
-    @@grammars.add(
-        grammar,
-        [match1+match2,match1+match1+match1+match2+match2+match2],
-        [parsed1+parsed2,parsed1+parsed1+parsed1+parsed2+parsed2+parsed2],
-        mismatch1,
-        partial1
-    )
-end
-
-def test_times
-    grammar1,match1,parsed1,mismatch1,partial1 = @@grammars.get
-    begin
-        grammar1.scan("".to_cursor,[],true) and throw(:invalid_test)
-    rescue Grammar::Error
-        throw(:invalid_test)
-    end
-    min = rand(2)
-    diff = rand(4)
-    match = ""
-    parsed = []
-    match0 = nil
-    parsed0 = nil
-    (min+rand(diff+1)).times {
-        i = rand(match1.size)
-        match.concat(match1[i])
-        parsed.concat(parsed1[i])
-        if match0
-            begin
-                grammar1.scan((match0+match1[i]).to_cursor)==parsed0 or
-                throw(:invalid_test)
-            rescue Grammar::Error
-                throw(:invalid_test)
-            end
-        end
-        match0 = match1[i]
-        parsed0 = parsed1[i]
-    }
-    diff = 1.0/0.0 if diff==3
-    multiplier = (diff.zero? && rand(2).zero?) ? min : (min..(min+diff))
-    @@grammars.add(
-        grammar1*multiplier,
-        [match],
-        [parsed],
-        min.zero? ? nil : mismatch1,
-        min.zero? ? nil : (partial1 || (min>1 && match1[rand(match1.size)]))
-    )
-end
-
-end
-end
-