grammar 0.5 → 0.8

data/lib/grammar/ruby/code.rb

@@ -0,0 +1,1030 @@
+require 'thread'
+
+class Grammar
+class Ruby
+
+# TODO: better list delimiter handling
+
+class Code # :nodoc:
+    instance_methods.each { |m|
+        next if m.to_s[0]==?_
+        next if m.to_s=="object_id"
+        send(:alias_method, "_#{m}", m)
+        undef_method(m)
+    }
+    private_instance_methods.each { |m|
+        next if m.to_s=="initialize"
+        send(:alias_method, "_#{m}", m)
+        undef_method(m)
+    }
+    def self.[](object)
+        case object
+        when NilClass
+            Nil
+        when FalseClass
+            False
+        when TrueClass
+            True
+        when Fixnum,Symbol,Module # last 3 not really immediates
+            Immediate.new(object)
+        else
+            s = object.inspect
+            begin
+                object.eql?(eval(s)) && Primary.new(s)
+            rescue
+            end or
+            Immediate.new(Marshal).load(Primary.new(
+                Marshal.dump(object).inspect))
+        end
+    end
+    def initialize(code)
+        @code = code
+    end
+    def _codes
+        [@code]
+    end
+    def _data
+        nil
+    end
+    def _equal(other)
+        _class.equal?(other._class) && _data==other._data &&
+            !_codes.zip(other._codes) { |a,b|
+                break(true) unless a._equal(b)
+            }
+    end
+    def _classname
+        _class.name.gsub(/.*::/, "")
+    end
+    def _inspect(s="", newline="\n")
+        data = _data
+        codes = _codes
+        s.concat(_classname) << ?\(
+        s.concat(data.inspect) if data
+        if !codes.empty?
+            newline << ?\s
+            if codes.size==1
+                s.concat(", ") if data
+                codes[0]._inspect(s, newline)
+                newline[-1,1] = ""
+            else
+                codes.each { |code|
+                    s << ?\, if data
+                    s.concat(newline)
+                    code._inspect(s, newline)
+                    data = true
+                }
+                newline[-1,1] = ""
+                s.concat(newline)
+            end
+        end
+        s << ?\)
+    end
+    def _lines(text, indent=0, op=nil, maxlen=72)
+        @code._lines(text, indent, op, maxlen)
+    end
+    def _code_self
+        self
+    end
+    def _always
+        @code._always
+    end
+    def _never
+        @code._never
+    end
+    def _immediate
+        false
+    end
+    def _or # :yield:
+        _always ? self :
+        Or.new(yield._ror(operands = [self]))
+    end
+    def _ror(before)
+        before <<
+            (before.last._never ? before.pop._step(self) : self)
+    end
+    def _and # :yield:
+        _never ? self :
+        And.new(yield._rand(operands = [self]))
+    end
+    def _rand(before)
+        before <<
+            (before.last._always ? before.pop._step(self) : self)
+    end
+    def _step(after)
+        Steps.new(after._rstep(_mid([])))
+    end
+    def _rstep(before)
+        before << self
+    end
+    def _mid(before)
+        before << self
+    end
+    def _not
+        Not.new(self)
+    end
+    def _question(yes, no)
+        Conditional.new(self, yes, no)
+    end
+    def _unless(cond, yes)
+        Conditional.new(cond, yes, self)
+    end
+    def _rcond(before)
+        before << self
+    end
+    def _assign(rvalue)
+        Assign.new([self, rvalue])
+    end
+    def _splat
+        Unary.new("*", self)
+    end
+    def _to_block
+        Unary.new("&", self)
+    end
+    def _locals(n=0)
+        @locals ||= (
+            _codes.each { |code|
+                n = code._locals(n)
+            }
+            n
+        )
+    end
+    def _dot(method)
+        Dot.new(self, method)
+    end
+    def _rescue(after, exception=nil, var=nil)
+        Begin.new(self)._rescue(after, exception, var)
+    end
+    def _ensure(after)
+        Begin.new(self)._ensure(after)
+    end
+    def _else(after)
+        Begin.new(self)._else(after)
+    end
+    def _def(name, *args)
+        Def.new(name.to_s, args, self)
+    end
+    def _while(condition)
+        While.new(condition, self)
+    end
+    def _until(condition)
+        Until.new(condition, self)
+    end
+    def method_missing(method, *args, &block)
+        if block
+            call = args.empty? ? _dot(method.to_s) :
+                Method.new(_dot(method.to_s), *args)
+            Blocked.new(call, &block)
+        else
+            case method
+            when :**,:*,:/,:%,:+,:-,:<<,:>>,:&,:|,:^,
+                    :>,:>=,:<,:<=,:<=>,:==,:===,:=~
+                Binary.new(" #{method} ", self, args[0])
+            when :-@,:+@,:~@
+                Unary.new(method.to_s[0..-2], self)
+            when :[]
+                Brackets.new(self, *args)
+            when :[]=
+                Brackets.new(self, *args[0..-2])._assign(args[-1])
+            else
+                if method.to_s[-1] == ?= and args.size==1
+                    Dot.new(self, method.to_s[0..-2])._assign(args[-1])
+                elsif args.empty?
+                    _dot(method.to_s)
+                else
+                    Method.new(_dot(method.to_s), *args)
+                end
+            end
+        end
+    end
+    class Primary < Code
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text.last.concat(@code)
+        end
+        def _codes
+            []
+        end
+        def _data
+            @code
+        end
+        def _always
+            false
+        end
+        def _never
+            false
+        end
+        def _mid(before)
+            before
+        end
+        def _step(after)
+            after
+        end
+        def _locals(n=0)
+            n
+        end
+    end
+    class Command < Code
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text.last.concat(@code)
+        end
+        def _codes
+            []
+        end
+        def _data
+            @code
+        end
+        def _always
+            false
+        end
+        def _never
+            false
+        end
+        def _locals(n=0)
+            n
+        end
+    end
+    class Immediate < Primary
+        def _immediate
+            true
+        end
+        def _data
+            @code
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text.last.concat(@code.inspect)
+        end
+    end
+    class Singleton < Primary
+        def initialize
+        end
+        def _equal(other)
+            __id__.equal?(other.__id__)
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text
+        end
+        def _inspect(s="", newline="\n")
+            s
+        end
+    end
+    True = Class.new(Singleton) {
+        def _immediate; true; end
+        def _inspect(s="", newline="\n")
+            s.concat("True")
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text.last.concat(true.inspect)
+        end
+        def _always; true; end
+        def _ror (before); before << before.pop._step(self); end
+        def _and         ; yield ; end
+        def _rand(before); before; end
+        def _not         ; False ; end
+    }.new
+    FalseTerminator = Class.new(Singleton) {
+        def _inspect(s="", newline="\n")
+            s.concat("FalseTerminator")
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text.last.concat(false.inspect)
+        end
+        def _never; false; end
+        def _always; true; end
+        def _ror (before); before << Always.new(before.pop); end
+        def _and         ; raise("#{inspect} &&"); end
+        def _or          ; raise("#{inspect} ||"); end
+        def _not         ; raise("!#{inspect}"); end
+    }.new
+    False = Class.new(Singleton) {
+        def _immediate; true; end
+        def _inspect(s="", newline="\n")
+            s.concat("False")
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text.last.concat(false.inspect)
+        end
+        def _never; true; end
+        def _rand(before); before << before.pop._step(self); end
+        def _or          ; yield ; end
+        def _ror (before); before; end
+        def _not         ; True  ; end
+    }.new
+    Nil = Class.new(Singleton) {
+        def _immediate; true; end
+        def _inspect(s="", newline="\n")
+            s.concat("Nil")
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text.last.concat(nil.inspect)
+        end
+        def _never; true; end
+        def _rand(before); before << before.pop._step(self); end
+        def _or          ; yield ; end
+        def _ror (before); before; end
+        def _not         ; True  ; end
+    }.new
+    Self = Class.new(Singleton) {
+        def _inspect(s="", newline="\n")
+            s.concat("Self")
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text.last.concat("self")
+        end
+        def _always; true; end
+        @@keywords = Hash.new
+        %w(
+            BEGIN END
+            begin if unless while until for case def class module
+            then elsif else when in do ensure rescue end
+            and or
+            not defined?
+            return yield super undef alias
+            break next retry redo
+            nil false true self
+        ).each { |keyword|
+            @@keywords[keyword] = true
+        }
+        def _dot(method)
+            (@@keywords[method] || /^[A-Za-z]\w*[?!]?$/!~method) ? super :
+                Code::Command.new(method)
+        end
+    }.new
+    Implicit = Class.new(Singleton) {
+        def _inspect(s="", newline="\n")
+            s.concat("Implicit")
+        end
+        def _dot(method)
+            Code::Command.new(method.to_s)
+        end
+    }.new
+    class Always < Code
+        def _always; true; end
+    end
+    class Never < Code
+        def _never; true; end
+    end
+    class Unary < Code
+        def initialize(operator, operand)
+            @operator = operator
+            @operand = operand
+        end
+        def _codes
+            [@operand]
+        end
+        def _data
+            @operator
+        end
+        def _operator
+            @operator
+        end
+        def _always
+            false
+        end
+        def _never
+            false
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text.last.concat(_operator)
+            @operand._lines(text, indent+1, op, maxlen)
+        end
+    end
+    class Not < Unary
+        def initialize(operand)
+            @operand = operand
+        end
+        def _data
+            nil
+        end
+        def _operator
+            "!"
+        end
+        def _always
+            @operand._never
+        end
+        def _never
+            @operand._always
+        end
+        def _not
+            @operand
+        end
+        def _mid(before)
+            @operand._mid(before)
+        end
+        def _step(after)
+            @operand._step(after)
+        end
+    end
+    class Dot < Unary
+        def initialize(receiver, method)
+            @operand = receiver
+            @method = method
+        end
+        def _data
+            @method
+        end
+        def _operator
+            @method
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            @operand._lines(text, indent, op, maxlen)
+        ensure
+            (text.last << ?\.).concat(@method)
+        end
+    end
+    class List < Code
+        def initialize(operands)
+            @operands = operands
+        end
+        def _codes
+            @operands
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            delim = _operator
+            delim0 = _operator0
+            paren = _paren(op)
+            if paren
+                text.last << ?\(
+                indent += 1
+            end
+            if @operands.empty?
+                last = text.last
+                last << ?\) if paren
+                return last
+            end
+            op = (delim==", ") ? nil : delim
+            delim ||= ""
+            len = text[-2]+text.last.size-delim0.size-delim.size
+            n = text.size
+            needdelim0 = text.last.empty?
+            #text << indent << "" unless needdelim0
+            single = true
+            @operands.each_with_index { |operand, i|
+                text << indent << "" unless text.last.empty?
+                if operand._lines(text, indent, op, maxlen)
+                    len += delim.size+delim0.size+text.last.size
+                else
+                    single = nil
+                end
+                text.last.concat(delim) unless i==@operands.size-1
+            }
+            if single && len<=maxlen
+                last = text[n-1]
+                i = n+1
+                while i<text.size
+                    last.concat(delim0) if needdelim0
+                    last.concat(text[i])
+                    needdelim0 = true
+                    i += 2
+                end
+                text.slice!(n, i-n)
+                last << ?\) if paren
+                last
+            else
+                text << (indent-1) << ")" if paren
+                nil
+            end
+        end
+        def _operator
+            ", "
+        end
+        def _operator0
+            ""
+        end
+        def _paren(op)
+            op
+        end
+        def _always
+            false
+        end
+        def _never
+            false
+        end
+    end
+    class Binary < List
+        def initialize(operator, *operands)
+            @operator = operator
+            @operands = operands
+        end
+        def _data
+            @operator
+        end
+        def _operator
+            @operator
+        end
+        def method_missing(method, *args, &block)
+            if method.equal?(@operator) && !block
+                @operands.concat(args)
+                self
+            else
+                super
+            end
+        end
+    end
+    class Assign < List
+        def _operator
+            " = "
+        end
+    end
+    class And < List
+        def self.new(operands)
+            (operands.size==1) ? operands[0] : super
+        end
+        def _operator
+            " && "
+        end
+        def _never
+            @operands.last._never
+        end
+        def _and # :yield:
+            _never ? self :
+            (yield._rand(@operands); self)
+        end
+        def _rand(before)
+            @operands[0] = before.pop._step(@operands[0]) if
+                before.last._always
+            before.concat(@operands)
+        end
+        def _or # :yield:
+            after = yield
+            last = @operands.last
+            (!last._always||after._never) ? Or.new(after._ror(operands = [self])) : 
+            after._unless(
+                (@operands.size==2) ? @operands.first : (@operands.pop;self),
+                last)
+        end
+        def _unless(cond, yes)
+            if @operands.last._equal(yes)
+                @operands.pop
+                cond._or{self}._and{yes}
+            else
+                super
+            end
+        end
+        def _mid(before)
+            @operands.pop._mid(@operands)
+            if @operands.size==1
+                @operands.first._mid(before)
+            else
+                before << self
+            end
+        end
+    end
+    class Or < List
+        def self.new(operands)
+            (operands.size==1) ? operands[0] : super
+        end
+        def _operator
+            " || "
+        end
+        def _always
+            @operands.last._always
+        end
+        def _or # :yield:
+            _always ? self :
+            (yield._ror(@operands); self)
+        end
+        def _ror(before)
+            @operands[0] = before.pop._step(@operands[0]) if
+                before.last._never
+            before.concat(@operands)
+        end
+        def _and # :yield:
+            after = yield
+            last = @operands.last
+            (!last._never||after._always) ? And.new(after._rand(operands = [self])) : 
+            last._unless(
+                (@operands.size==2) ? @operands.first : (@operands.pop;self),
+                after)
+        end
+        def _mid(before)
+            @operands.pop._mid(@operands)
+            if @operands.size==1
+                @operands.first._mid(before)
+            else
+                before << self
+            end
+        end
+    end
+    class Steps < List
+        def self.new(operands)
+            (operands.size==1) ? operands[0] : super
+        end
+        def _operator
+            nil
+        end
+        def _operator0
+            "; "
+        end
+        def _always
+            @operands.last._always
+        end
+        def _never
+            @operands.last._never
+        end
+        def _step(after)
+            @operands.pop._mid(@operands)
+            after._rstep(@operands)
+            self
+        end
+        def _rstep(before)
+            before.concat(@operands)
+        end
+        def _not
+            @operands[-1] = @operands[-1]._not
+        end
+        def _mid(before)
+            @operands.pop._mid(@operands)
+            if @operands.size==1
+                @operands.first._mid(before)
+            else
+                before << self
+            end
+        end
+    end
+    class SharedSteps < Steps
+        def _mid(before)
+            Steps.new(@operands.clone)._mid(before)
+        end
+        def _step(after)
+            Steps.new(@operands.clone)._step(after)
+        end
+        def _not
+            Steps.new(@operands.clone)._not
+        end
+    end
+    class Conditional < List
+        class Question < List
+            def _operator
+                " ? "
+            end
+            def _paren(op)
+                false
+            end
+            def _always
+                @operands.last._always
+            end
+            def _never
+                @operands.last._never
+            end
+            def [](i)
+                @operands[i]
+            end
+            def []=(i, code)
+                @operands[i] = code
+            end
+            def _mid(before)
+                @operands.pop._mid(@operands)
+                if @operands.size==1
+                    # TODO : translate to Or in this case
+                    @operands << True
+                end
+                before << self
+            end
+        end
+        def self.new(cond, yes, no)
+            super([Question.new([cond, yes]), no])
+        end
+        def initialize(operands)
+            @operands = operands
+            always = true
+            never = true
+            @operands.each { |operand|
+                 always &&= operand._always
+                 never &&= operand._never
+                 break if !always && !never
+            }
+            @always = always ? 1 : never ? -1 : 0
+        end
+        def _operator
+            " : "
+        end
+        def _always
+            @always>0
+        end
+        def _never
+            @always<0
+        end
+        def _unless(cond, yes)
+            if @operands.first[1]._equal(yes)
+                @operands.first[0] = cond._or{@operands.first[0]}
+            else
+                @operands.insert(0, operand=Question.new([cond, yes]))
+                @always = 0 if @always>0 && !operand._always
+                @always = 0 if @always<0 && !operand._never
+            end
+            self
+        end
+        def _mid(before)
+            operands = []
+            last = @operands.pop
+            @operands.map { |operand|
+                operand._mid(operands)
+            }
+            @operands = operands
+            n = @operands.size
+            last._mid(@operands)
+            # TODO : remove final else in this case (translate prev to And)
+            @operands << last if @operands.size==n
+            @always = 0
+            before << self
+        end
+        def _or # :yield:
+            last = @operands.pop
+            always = true
+            @operands.each { |operand|
+                always &&= operand._always or break
+            }
+            unless always
+                @operands << last
+                return(super)
+            end
+            last = last._or { yield }
+            always &&= last._always
+            @always = 1 if always
+            last._rcond(@operands)
+            self
+        end
+        def _rcond(before)
+            before.concat(@operands)
+        end
+    end
+    class Local < Code
+        def initialize(n=nil, &block) # :yield: *vars
+            n ||= block.arity
+            names = (0...n.abs).map { "_" }
+            args = names.map { |name| Code::Primary.new(name) }
+            @code = yield(*args)
+            @locals = @code._locals(0)
+            names.each { |name|
+                name.concat(@locals.to_s)
+                @locals += 1
+            }
+        end
+        def _data
+            @locals
+        end
+        def _locals(n=0)
+            (@locals>n) ? @locals : n
+        end
+        def _mid(before)
+            devalued = @code._mid([])
+            if devalued.empty?
+                before
+            else
+                @code = devalued[0]
+                before << self
+            end
+        end
+    end
+    class Blocked < List
+        def initialize(receiver, n=nil, &block) # :yield: *vars
+            @receiver = receiver
+            n ||= block.arity
+            names = (0...n.abs).map { "_" }
+            @operands = names.map { |name| Code::Primary.new(name) }
+            @block = yield(*@operands)
+            @locals = @block._locals(0)
+            @operands[-1] = @operands[-1]._splat if n<0
+            names.each { |name|
+                name.concat(@locals.to_s)
+                @locals += 1
+            }
+            @locals = @receiver._locals(@locals)
+        end
+        def _codes
+            [@receiver].concat(@operands) << @block
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            single = @receiver._lines(text, indent, true, maxlen)
+            text.last << ?\s << ?\{
+            unless @operands.empty?
+                text << (indent+2) << "|"
+                if super(text, indent+3, nil, maxlen) && single && 
+                        text[-4]+text[-3].size+text.last.size+1<=maxlen
+                    last = text.last
+                    text.pop
+                    text.pop
+                    (text.last << ?\s).concat(last)
+                else
+                    single = nil
+                end
+                text.last << ?\|
+            end
+            text << (indent+2) << ""
+            if @block._lines(text, indent+2, nil, maxlen) && single &&
+                    text[-4]+text[-3].size+text.last.size+1<=maxlen
+                last = text.last
+                text.pop
+                text.pop
+                (text.last << ?\s).concat(last).concat(" }")
+            else
+                text << indent << "}"
+                nil
+            end
+        end
+        def _locals(n=0)
+            (@locals>n) ? @locals : n
+        end
+    end
+    class Call < List
+        def initialize(receiver, *args)
+            @receiver = receiver
+            @operands = args
+        end
+        def _codes
+            [@receiver].concat(@operands)
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            single = @receiver._lines(text, indent, op, maxlen)
+            text.last << op
+            if super(text, indent+2, nil, maxlen)
+                single
+            else
+                text << indent << ""
+                nil
+            end
+        end
+    end
+    class Brackets < Call
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            super(text, indent, ?\[, maxlen)
+        ensure
+            text.last << ?\]
+        end
+    end
+    class Method < Call
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            super(text, indent, ?\(, maxlen)
+        ensure
+            text.last << ?\)
+        end
+    end
+    class Rescue < Code
+        def initialize(exception=nil, var=nil)
+            @exception = exception
+            @var = var
+        end
+        def _codes
+            codes = []
+            codes << @exception if @exception
+            codes << @var if @var
+            codes
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text[-2] -= 2 if text.last.empty?
+            (last = text.last).concat("rescue")
+            single = true
+            if @exception
+                last << ?\s
+                single = @exception._lines(text, indent+1, nil, maxlen)
+                last = text.last
+            else
+                single = true
+            end
+            if @var
+                last.concat(" => ")
+                @var._lines(text, indent+1, nil, maxlen) && single
+            else
+                single
+            end
+        end
+        def _always
+            false
+        end
+        def _never
+            false
+        end
+    end
+    class Dedented < Command
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text[-2] -= 2 if text.last.empty?
+            text.last.concat(@code)
+        end
+    end
+    class Begin < List
+        def initialize(body)
+            @footer = 0
+            super([body])
+        end
+        def _operator
+            nil
+        end
+        def _operator0
+            "; "
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text.last.concat("begin ")
+            if super(text, indent+2, nil, maxlen)
+                text.last.concat(" end")
+            else
+                text << indent << "end"
+                nil
+            end
+        end
+        def _rescue(after, exception=nil, var=nil)
+            return(super) if @footer>1
+            @footer = 1
+            @operands << Rescue.new(exception, var) << after
+            self
+        end
+        def _ensure(after)
+            return(super) if @footer>=2
+            @footer = 2
+            @operands << Dedented.new("ensure") << after
+            self
+        end
+        def _else(after)
+            return(super) if @footer>=3
+            @footer = 3
+            @operands << Dedented.new("else") << after
+            self
+        end
+        def _def(name, *args)
+            Def.new(name.to_s, args, Steps.new(@operands))
+        end
+        def _always
+            false
+        end
+        def _never
+            false
+        end
+    end
+    class Def < List
+        def initialize(name, args, body)
+            @name = name
+            @operands = args
+            @body = body
+        end
+        def _codes
+            @operands+[@body]
+        end
+        def _data
+            @name
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            text << indent << "" unless text.last.empty?
+            (last = text.last).concat("def ").concat(@name.to_s)
+            unless @operands.empty?
+                last << ?\(
+                super(text, indent+3, nil, maxlen) or
+                text << indent+2 << ""
+                text.last << ?\)
+            end
+            text << (indent+2) << ""
+            @body._lines(text, indent+2, nil, maxlen)
+            text << indent << "end"
+            nil
+        end
+        def _always
+            false
+        end
+        def _never
+            false
+        end
+    end
+    class While < Code
+        def initialize(condition, body=nil)
+            @condition = condition
+            @body = body && body._mid([])[0]
+        end
+        def _codes
+            codes = [@condition]
+            codes << @body if @body
+            codes
+        end
+        def _header
+            "while"
+        end
+        def _lines(text, indent=0, op=nil, maxlen=72)
+            (last = text.last).concat(_header) << ?\(
+            single = @condition._lines(text, indent+3, nil, maxlen) or
+            text << indent+2 << ""
+            text.last << ?\)
+            if @body
+                text << indent+2 << ""
+                @body._lines(text, indent+2, nil, maxlen)
+                single = nil
+            end
+            if single
+                text.last.concat("; end")
+            else
+                text << indent << "end"
+                nil
+            end
+        end
+        def _always
+            false
+        end
+        def _never
+            false
+        end
+    end
+    class Until < While
+        def _header
+            "until"
+        end
+    end
+end
+end
+end
+
+