aaronp-zomg 1.0.2.20080827232412

data/lib/zomg.rb

@@ -0,0 +1,22 @@
+require 'ruby2ruby'
+require 'zomg/version'
+require 'zomg/idl'
+
+%w{
+  node
+  attribute
+  binary
+  constant
+  interface
+  interface_header
+  member
+  operation
+  parameter
+  typedef
+  union
+}.each { |node_type|
+  require "zomg/idl/nodes/#{node_type}"
+}
+require 'zomg/idl/scanner'
+require 'zomg/idl/lexer'
+require 'zomg/idl/parser'

data/lib/zomg/idl.rb

@@ -0,0 +1,14 @@
+require 'zomg/idl/visitable'
+require 'zomg/idl/visitors/sexp'
+require 'zomg/idl/visitors/ruby_sexp'
+require 'zomg/idl/visitors/duhr'
+
+module ZOMG
+  module IDL
+    class << self
+      def parse(contents)
+        ZOMG::IDL::Parser.parse(contents)
+      end
+    end
+  end
+end

data/lib/zomg/idl/nodes/attribute.rb

@@ -0,0 +1,15 @@
+module ZOMG
+  module IDL
+    module Nodes
+      class Attribute < Node
+        alias :names :children
+        attr_accessor :type, :readonly
+        def initialize(type, names, readonly = false)
+          super(names)
+          @type = type
+          @readonly = readonly
+        end
+      end
+    end
+  end
+end

data/lib/zomg/idl/nodes/binary.rb

@@ -0,0 +1,19 @@
+module ZOMG
+  module IDL
+    module Nodes
+      class Binary < Node
+        attr_accessor :left
+        alias :right :children
+        def initialize(left, right)
+          @left = left
+          super(right)
+        end
+      end
+      %w{ MultiplyExpr PlusExpr ModulusExpr ShiftLeftExpr MinusExpr
+        DivideExpr OrExpr AmpersandExpr
+      }.each do |type|
+        const_set(type.to_sym, Class.new(Binary))
+      end
+    end
+  end
+end

data/lib/zomg/idl/nodes/constant.rb

@@ -0,0 +1,15 @@
+module ZOMG
+  module IDL
+    module Nodes
+      class Constant < Node
+        attr_accessor :type, :name
+        alias :value :children
+        def initialize(type, name, value)
+          @type = type
+          @name = name
+          super(value)
+        end
+      end
+    end
+  end
+end

data/lib/zomg/idl/nodes/interface.rb

@@ -0,0 +1,13 @@
+module ZOMG
+  module IDL
+    module Nodes
+      class Interface < Node
+        attr_accessor :header
+        def initialize(header, body)
+          super(body)
+          @header = header
+        end
+      end
+    end
+  end
+end

data/lib/zomg/idl/nodes/interface_header.rb

@@ -0,0 +1,14 @@
+module ZOMG
+  module IDL
+    module Nodes
+      class InterfaceHeader < Node
+        attr_accessor :abstract, :name
+        def initialize(abstract, name, inheritance_spec = [])
+          @abstract = abstract
+          @name = name
+          super(inheritance_spec)
+        end
+      end
+    end
+  end
+end

data/lib/zomg/idl/nodes/member.rb

@@ -0,0 +1,14 @@
+module ZOMG
+  module IDL
+    module Nodes
+      class Member < Node
+        attr_accessor :type
+        alias :declarators :children
+        def initialize(type, declarators)
+          @type = type
+          super(declarators)
+        end
+      end
+    end
+  end
+end

data/lib/zomg/idl/nodes/node.rb

@@ -0,0 +1,54 @@
+module ZOMG
+  module IDL
+    module Nodes
+      class Node
+        include Visitable
+        include Visitors
+
+        attr_accessor :children, :name
+        def initialize(children = [], options = {})
+          @children = children
+          options.each { |k,v| send(:"#{k}=", v) }
+        end
+
+        def to_i
+          children.to_i
+        end
+
+        def duhr
+          Duhr.new(self)
+        end
+
+        def to_sexp
+          Sexp.new.accept(self)
+        end
+
+        def to_ruby_sexp
+          RubySexp.new.accept(self)
+        end
+
+        def to_ruby(prefix = nil)
+          r2r = Ruby2Ruby.new
+          ruby_code = r2r.process(to_ruby_sexp)
+          if prefix
+            modules = prefix.split(/::/).map { |m| "module #{m}\n" }
+            ends = modules.map { |m| "end" }.join("\n")
+            "#{modules}#{ruby_code}\n#{ends}"
+          else
+            ruby_code
+          end
+        end
+      end
+      %w{ Boolean Char Double Float Long Octet Short UnsignedLong
+        UnsignedShort ElementSpec CaseLabel DefaultLabel IntegerLiteral
+        Sequence ArraySize Void In Out InOut CharacterLiteral
+        UnsignedLongLong LongLong Any ForwardDeclaration WChar
+        FloatingPointLiteral BooleanLiteral Context StringLiteral
+        WideStringLiteral WideCharacterLiteral UnaryMinus Object
+        UnaryPlus WString String Case Enum Exception ValueBoxDcl
+        Struct ScopedName Module ArrayDeclarator SimpleDeclarator
+        Specification
+      }.each { |type| const_set(type.to_sym, Class.new(Node)) }
+    end
+  end
+end

data/lib/zomg/idl/nodes/operation.rb

@@ -0,0 +1,17 @@
+module ZOMG
+  module IDL
+    module Nodes
+      class Operation < Node
+        attr_accessor :attribute, :returns, :name, :raises, :context
+        def initialize(attribute, returns, name, params, raises, context)
+          super(params)
+          @attribute = attribute
+          @returns = returns
+          @name = name
+          @raises = raises
+          @context = context
+        end
+      end
+    end
+  end
+end

data/lib/zomg/idl/nodes/parameter.rb

@@ -0,0 +1,18 @@
+module ZOMG
+  module IDL
+    module Nodes
+      class Parameter < Node
+        attr_accessor :attribute, :type, :declarator
+        def initialize(attribute, type, declarator)
+          @attribute  = attribute
+          @type       = type
+          @declarator = declarator
+        end
+
+        def name
+          declarator.name
+        end
+      end
+    end
+  end
+end

data/lib/zomg/idl/nodes/typedef.rb

@@ -0,0 +1,13 @@
+module ZOMG
+  module IDL
+    module Nodes
+      class Typedef < Node
+        attr_accessor :type_spec
+        def initialize(type_spec, declarators)
+          @type_spec = type_spec
+          super(declarators)
+        end
+      end
+    end
+  end
+end

data/lib/zomg/idl/nodes/union.rb

@@ -0,0 +1,14 @@
+module ZOMG
+  module IDL
+    module Nodes
+      class Union < Node
+        attr_accessor :name, :switch_type
+        def initialize(name, switch_type, switch_body)
+          @name = name
+          @switch_type = switch_type
+          super(switch_body)
+        end
+      end
+    end
+  end
+end

data/lib/zomg/idl/parser.rb

@@ -0,0 +1,54 @@
+module ZOMG
+  module IDL
+    class Parser < Lexer
+      class << self
+        def parse_file(filename)
+          new.parse_file(filename)
+        end
+
+        def parse(string)
+          new.parse(string)
+        end
+      end
+
+      def initialize
+        @scanner = Scanner.new
+        @yydebug = false
+      end
+
+      # Parse an IDL string
+      def parse(contents)
+        @scanner.scan_evaluate(contents)
+        do_parse
+      end
+
+      def parse_file(filename)
+        contents = File.read(filename)
+        if contents =~ /^\s*#/
+          dir = File.dirname(File.expand_path(filename))
+          contents = IO.popen("gcc -E -I #{dir} -I . -", 'w+') { |io|
+            io.write(contents)
+            io.close_write
+            io.read
+          }
+        end
+        parse(contents)
+      end
+
+      def next_token
+        token = @scanner.next_token
+        return [false, false] unless token
+        token = next_token() if token[0] == :T_COMMENT
+        token = next_token() if token[0] == :T_PREPROCESSOR
+        token = next_token() if token[0] == :T_PRAGMA
+        token
+      end
+
+      def on_error(error_token_id, error_value, value_stack)
+        puts token_to_str(error_token_id)
+        puts error_value
+        p value_stack.last
+      end
+    end
+  end
+end

data/lib/zomg/idl/visitable.rb

@@ -0,0 +1,15 @@
+module ZOMG
+  module IDL
+    module Visitable
+      # Based off the visitor pattern from RubyGarden
+      def accept(visitor, &block)
+        klass = self.class
+        method_name = :"visit_#{klass.name.split(/::/).last}"
+        unless visitor.respond_to?(method_name)
+          raise "No visitor for #{self.class}"
+        end
+        visitor.send(method_name, self, &block)
+      end
+    end
+  end
+end

data/lib/zomg/idl/visitors/duhr.rb

@@ -0,0 +1,24 @@
+module ZOMG
+  module IDL
+    module Visitors
+      # Stupid path navigation
+      class Duhr
+        attr_accessor :tree
+        def initialize(tree)
+          @tree = tree
+        end
+
+        def to_sexp; @tree.to_sexp; end
+
+        def [](i)
+          Duhr.new(@tree[i])
+        end
+
+        def method_missing(sym, *args)
+          klass = ZOMG::IDL::Nodes.const_get(sym)
+          Duhr.new(tree.children.find_all { |child| child.is_a?(klass) })
+        end
+      end
+    end
+  end
+end

data/lib/zomg/idl/visitors/ruby_sexp.rb

@@ -0,0 +1,204 @@
+module ZOMG
+  module IDL
+    module Visitors
+      class RubySexp
+        def visit_Specification(o)
+          [:block] + o.children.map { |c| c.accept(self) }
+        end
+
+        def visit_Module(o)
+          [ :module,
+            classify(o.name),
+            [:scope, [:block] +
+              o.children.map { |c| c.accept(self) }.compact
+          ]
+          ]
+        end
+
+        def visit_Interface(o)
+          header = o.header.accept(self)
+          header = header ? [:block, header] : [:block]
+          o.children.each { |c|
+            list = c.accept(self)
+            if list
+              if list.first.is_a?(Symbol)
+                header << list
+              else
+                header += list
+              end
+            end
+          }
+          [ :module,
+            classify(o.header.name),
+            [:scope,
+              header
+            ]
+          ]
+        end
+
+        def visit_InterfaceHeader(o)
+          if o.children.length > 0
+            [:fcall, :include,
+              [:array] + o.children.map { |c|
+                [:const, classify(c.accept(self))]
+            } ]
+          else
+            nil
+          end
+        end
+
+        def visit_Exception(o)
+          attributes = o.children.length > 0 ?
+            [:scope, [:fcall,
+              :attr_accessor,
+              [:array] +
+                o.children.map { |c|
+                  c.accept(self)
+                }.flatten.map { |att| [:lit, att] }
+            ]] : [:scope]
+
+          [:class, classify(o.name), [:const, :Exception], attributes]
+        end
+
+        def visit_Attribute(o)
+          attributes = []
+          o.children.each { |name|
+            name = name.accept(self)
+
+            # Reader
+            attributes <<
+              [:defn, :"get#{name.to_s.capitalize}",
+                [:scope, [:block, [:args],
+                  [:fcall, :raise, [:array,
+                    [:call, [:const, :NotImplementedError], :new]]
+                  ]
+                ]]
+              ]
+            unless o.readonly
+              attributes <<
+                [:defn, :"set#{name.to_s.capitalize}",
+                  [:scope, [:block, [:args, :_],
+                    [:fcall, :raise, [:array,
+                      [:call, [:const, :NotImplementedError], :new]]
+                    ]
+                  ]]
+                ]
+            end
+          }
+          attributes
+        end
+
+        def visit_ScopedName(o)
+          o.name.to_sym
+        end
+
+        def visit_Operation(o)
+          [ :defn,
+            o.name.to_sym,
+            [:scope,
+              [:block,
+                [:args] + o.children.map { |c| paramify(c.accept(self)) },
+                [:fcall, :raise, [:array,
+                  [:call, [:const, :NotImplementedError], :new]]
+                ]
+              ]
+            ]
+          ]
+        end
+
+        def visit_Parameter(o)
+          o.declarator.accept(self)
+        end
+
+        def visit_Constant(o)
+          [:cdecl, o.name.upcase.to_sym, o.value.accept(self)]
+        end
+
+        def visit_Enum(o)
+          [ :cdecl,
+            o.name.to_sym,
+            [:hash] + o.children.inject([]) { |m,c| 
+              m += [[:lit, c.to_sym], [:lit, c.to_sym]]
+            }
+          ]
+        end
+
+        def visit_IntegerLiteral(o)
+          [:lit, o.to_i]
+        end
+
+        def visit_ValueBoxDcl(o)
+        end
+
+        def visit_Struct(o)
+          [ :cdecl,
+            classify(o.name),
+            [ :call, [:const, :Struct],
+              :new,
+              [:array] + o.children.map { |c|
+                c.accept(self)
+              }.flatten.map { |lit| [:lit, lit] }
+            ]
+          ]
+        end
+
+        def visit_Union(o)
+          [ :cdecl,
+            o.name.to_sym,
+            [ :call, [:const, :Struct],
+              :new,
+              [:array] + o.children.map { |c|
+                val = c.accept(self)
+                val && [:lit, val]
+              }.compact
+            ]
+          ]
+        end
+
+        def visit_CaseLabel(o)
+        end
+
+        def visit_Case(o)
+          o.children.last.accept(self)
+        end
+
+        def visit_ElementSpec(o)
+          o.children[1].accept(self)
+        end
+
+        def visit_Member(o)
+          o.children.map { |c| c.accept(self) }
+        end
+
+        def visit_SimpleDeclarator(o)
+          o.name.to_sym
+        end
+
+        def visit_ArrayDeclarator(o)
+          o.name.to_sym
+        end
+
+        def visit_Typedef(o)
+        end
+
+        def visit_ForwardDeclaration(o)
+        end
+
+        def accept(target)
+          target.accept(self)
+        end
+
+        private
+        def classify(string)
+          s = string.to_s
+          :"#{s.slice(0,1).upcase}#{s[1..-1]}"
+        end
+
+        def paramify(string)
+          s = string.to_s
+          :"#{s.slice(0,1).downcase}#{s[1..-1]}"
+        end
+      end
+    end
+  end
+end