zomg 1.0.0

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,52 @@
+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
+            "module #{prefix}\n#{ruby_code}\nend"
+          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/scanner.rb

@@ -0,0 +1,367 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by rex 1.0.1
+# from lexical definition file "lib/scanner.rex".
+#
+
+module ZOMG
+module IDL
+class Scanner
+  require 'strscan'
+
+  class ScanError < StandardError ; end
+
+  attr_reader :lineno
+  attr_reader :filename
+
+  def scan_setup ; end
+
+  def action &block
+    yield
+  end
+
+  def scan_str( str )
+    scan_evaluate  str
+    do_parse
+  end
+
+  def load_file( filename )
+    @filename = filename
+    open(filename, "r") do |f|
+      scan_evaluate  f.read
+    end
+  end
+
+  def scan_file( filename )
+    load_file  filename
+    do_parse
+  end
+
+  def next_token
+    @rex_tokens.shift
+  end
+
+  def scan_evaluate( str )
+    scan_setup
+    @rex_tokens = []
+    @lineno  =  1
+    ss = StringScanner.new(str)
+    state = nil
+    until ss.eos?
+      text = ss.peek(1)
+      @lineno  +=  1  if text == "\n"
+      case state
+      when nil
+        case
+        when (text = ss.scan(/[\s\n\r]/))
+          ;
+
+        when (text = ss.scan(/\/\*(.|[\r\n])*?\*\//))
+           @rex_tokens.push action { [:T_COMMENT, text] }
+
+        when (text = ss.scan(/\/\/[^\n]*/))
+           @rex_tokens.push action { [:T_COMMENT, text] }
+
+        when (text = ss.scan(/\#pragma[^\n]*\n/))
+           @rex_tokens.push action { [:T_PRAGMA, text] }
+
+        when (text = ss.scan(/\#[^\n]*\n/))
+           @rex_tokens.push action { [:T_PREPROCESSOR, text] }
+
+        when (text = ss.scan(/\{/))
+           @rex_tokens.push action { [:T_LEFT_CURLY_BRACKET, text] }
+
+        when (text = ss.scan(/\}/))
+           @rex_tokens.push action { [:T_RIGHT_CURLY_BRACKET, text] }
+
+        when (text = ss.scan(/\[/))
+           @rex_tokens.push action { [:T_LEFT_SQUARE_BRACKET, text] }
+
+        when (text = ss.scan(/\]/))
+           @rex_tokens.push action { [:T_RIGHT_SQUARE_BRACKET, text] }
+
+        when (text = ss.scan(/\(/))
+           @rex_tokens.push action { [:T_LEFT_PARANTHESIS, text] }
+
+        when (text = ss.scan(/\)/))
+           @rex_tokens.push action { [:T_RIGHT_PARANTHESIS, text] }
+
+        when (text = ss.scan(/\:\:/))
+           @rex_tokens.push action { [:T_SCOPE, text] }
+
+        when (text = ss.scan(/:/))
+           @rex_tokens.push action { [:T_COLON, text] }
+
+        when (text = ss.scan(/,/))
+           @rex_tokens.push action { [:T_COMMA, text] }
+
+        when (text = ss.scan(/;/))
+           @rex_tokens.push action { [:T_SEMICOLON, text] }
+
+        when (text = ss.scan(/=/))
+           @rex_tokens.push action { [:T_EQUAL, text] }
+
+        when (text = ss.scan(/>>/))
+           @rex_tokens.push action { [:T_SHIFTRIGHT, text] }
+
+        when (text = ss.scan(/<</))
+           @rex_tokens.push action { [:T_SHIFTLEFT, text] }
+
+        when (text = ss.scan(/\+/))
+           @rex_tokens.push action { [:T_PLUS_SIGN, text] }
+
+        when (text = ss.scan(/-/))
+           @rex_tokens.push action { [:T_MINUS_SIGN,text] }
+
+        when (text = ss.scan(/\*/))
+           @rex_tokens.push action { [:T_ASTERISK, text] }
+
+        when (text = ss.scan(/\//))
+           @rex_tokens.push action { [:T_SOLIDUS,text] }
+
+        when (text = ss.scan(/%/))
+           @rex_tokens.push action { [:T_PERCENT_SIGN,text] }
+
+        when (text = ss.scan(/~/))
+           @rex_tokens.push action { [:T_TILDE,text] }
+
+        when (text = ss.scan(/\|/))
+           @rex_tokens.push action { [:T_VERTICAL_LINE,text] };
+
+        when (text = ss.scan(/\^/))
+           @rex_tokens.push action { [:T_CIRCUMFLEX,text] }
+
+        when (text = ss.scan(/&/))
+           @rex_tokens.push action { [:T_AMPERSAND,text] }
+
+        when (text = ss.scan(/</))
+           @rex_tokens.push action { [:T_LESS_THAN_SIGN,text] }
+
+        when (text = ss.scan(/>/))
+           @rex_tokens.push action { [:T_GREATER_THAN_SIGN, text] }
+
+        when (text = ss.scan(/const(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_CONST, text] }
+
+        when (text = ss.scan(/typedef(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_TYPEDEF, text] }
+
+        when (text = ss.scan(/float(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_FLOAT, text] }
+
+        when (text = ss.scan(/double(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_DOUBLE, text] }
+
+        when (text = ss.scan(/char(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_CHAR, text] }
+
+        when (text = ss.scan(/wchar(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_WCHAR, text] }
+
+        when (text = ss.scan(/fixed(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_FIXED, text] }
+
+        when (text = ss.scan(/boolean(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_BOOLEAN, text] }
+
+        when (text = ss.scan(/string(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_STRING, text] }
+
+        when (text = ss.scan(/wstring(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_WSTRING, text] }
+
+        when (text = ss.scan(/void(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_VOID, text] }
+
+        when (text = ss.scan(/unsigned(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_UNSIGNED, text] }
+
+        when (text = ss.scan(/long(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_LONG, text] }
+
+        when (text = ss.scan(/short(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_SHORT, text] }
+
+        when (text = ss.scan(/FALSE/))
+           @rex_tokens.push action { [:T_FALSE, text] }
+
+        when (text = ss.scan(/TRUE/))
+           @rex_tokens.push action { [:T_TRUE, text] }
+
+        when (text = ss.scan(/struct(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_STRUCT, text] }
+
+        when (text = ss.scan(/union(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_UNION, text] }
+
+        when (text = ss.scan(/switch(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_SWITCH, text] }
+
+        when (text = ss.scan(/case(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_CASE, text] }
+
+        when (text = ss.scan(/default(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_DEFAULT, text] }
+
+        when (text = ss.scan(/enum(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_ENUM, text] }
+
+        when (text = ss.scan(/interface(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_INTERFACE, text] }
+
+        when (text = ss.scan(/inout(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_INOUT, text] }
+
+        when (text = ss.scan(/in(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_IN, text] }
+
+        when (text = ss.scan(/out(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_OUT, text] }
+
+        when (text = ss.scan(/abstract(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_ABSTRACT, text] }
+
+        when (text = ss.scan(/valuetype(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_VALUETYPE, text] }
+
+        when (text = ss.scan(/truncatable(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_TRUNCATABLE, text] }
+
+        when (text = ss.scan(/supports(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_SUPPORTS, text] }
+
+        when (text = ss.scan(/custom(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_CUSTOM, text] }
+
+        when (text = ss.scan(/public(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_PUBLIC, text] }
+
+        when (text = ss.scan(/private(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_PRIVATE, text] }
+
+        when (text = ss.scan(/factory(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_FACTORY, text] }
+
+        when (text = ss.scan(/native(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_NATIVE, text] }
+
+        when (text = ss.scan(/ValueBase/))
+           @rex_tokens.push action { [:T_VALUEBASE, text] }
+
+        when (text = ss.scan(/module(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_MODULE, text] }
+
+        when (text = ss.scan(/octet(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_OCTET, text] }
+
+        when (text = ss.scan(/any(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_ANY, text] }
+
+        when (text = ss.scan(/sequence(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_SEQUENCE, text] }
+
+        when (text = ss.scan(/readonly(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_READONLY, text] }
+
+        when (text = ss.scan(/attribute(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_ATTRIBUTE, text] }
+
+        when (text = ss.scan(/exception(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_EXCEPTION, text] }
+
+        when (text = ss.scan(/oneway(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_ONEWAY, text] }
+
+        when (text = ss.scan(/raises(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_RAISES, text] }
+
+        when (text = ss.scan(/context(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_CONTEXT, text] }
+
+        when (text = ss.scan(/Object(?![a-zA-Z0-9_])/))
+           @rex_tokens.push action { [:T_OBJECT, text] }
+
+        when (text = ss.scan(/Principal/))
+           @rex_tokens.push action { [:T_PRINCIPAL, text] }
+
+        when (text = ss.scan(/L"(([^\n\t\"\\]|(\\[ntvbrfa\?'\\"]|\\[0-7]{1,3}|\\[xX][a-fA-F0-9]{1,2}))|')*"/))
+           @rex_tokens.push action { [:T_WIDE_STRING_LITERAL, text] }
+
+        when (text = ss.scan(/L'(([^\n\t\"\\]|(\\[ntvbrfa\?'\\"]|\\[0-7]{1,3}|\\[xX][a-fA-F0-9]{1,2}))|\")'/))
+           @rex_tokens.push action { [:T_WIDE_CHARACTER_LITERAL, text] }
+
+        when (text = ss.scan(/[a-zA-Z_][a-zA-Z0-9_]*/))
+           @rex_tokens.push action { [:T_IDENTIFIER, text] }
+
+        when (text = ss.scan(/[0-9]+\.[0-9]+[eE][\+-]?[0-9]+/))
+           @rex_tokens.push action { [:T_FLOATING_PT_LITERAL, text] }
+
+        when (text = ss.scan(/[0-9]+\.[eE][\+-]?[0-9]+/))
+           @rex_tokens.push action {
+                                  text = text.split('.').join('.0')
+                                  [:T_FLOATING_PT_LITERAL, text]
+                                }
+
+
+        when (text = ss.scan(/[0-9]+[eE][\+-]?[0-9]+/))
+           @rex_tokens.push action { [:T_FLOATING_PT_LITERAL, text] }
+
+        when (text = ss.scan(/[0-9]+\.[0-9]+[dD]/))
+           @rex_tokens.push action { [:T_FIXED_PT_LITERAL, text.gsub(/[Dd]/,'')] }
+
+        when (text = ss.scan(/[0-9]+\.[0-9]+/))
+           @rex_tokens.push action { [:T_FLOATING_PT_LITERAL, text] }
+
+        when (text = ss.scan(/[0-9]+\.[dD]/))
+           @rex_tokens.push action { [:T_FIXED_PT_LITERAL, text.gsub(/[.dD]/,'')] }
+
+        when (text = ss.scan(/[0-9]+\./))
+           @rex_tokens.push action { [:T_FLOATING_PT_LITERAL, "#{text}0"] }
+
+        when (text = ss.scan(/\.[0-9]+[eE][\+-]?[0-9]+/))
+           @rex_tokens.push action { [:T_FLOATING_PT_LITERAL, "0#{text}"] }
+
+        when (text = ss.scan(/\.[0-9]+[dD]/))
+           @rex_tokens.push action {
+                             [:T_FIXED_PT_LITERAL, "0#{text.gsub(/[dD]/, '')}"]
+                                }
+
+
+        when (text = ss.scan(/\.[0-9]+/))
+           @rex_tokens.push action { [:T_FLOATING_PT_LITERAL, "0#{text}"] }
+
+        when (text = ss.scan(/[0-9]+[dD]/))
+           @rex_tokens.push action { [:T_FIXED_PT_LITERAL, text.gsub(/[dD]/,'')] }
+
+        when (text = ss.scan(/0[xX][a-fA-F0-9]*/))
+           @rex_tokens.push action { [:T_INTEGER_LITERAL, text] }
+
+        when (text = ss.scan(/0[0-7]*/))
+           @rex_tokens.push action { [:T_INTEGER_LITERAL, text] }
+
+        when (text = ss.scan(/[1-9][0-9]*/))
+           @rex_tokens.push action { [:T_INTEGER_LITERAL, text] }
+
+        when (text = ss.scan(/'(([^\n\t\"\\]|(\\[ntvbrfa\?'\\"]|\\[0-7]{1,3}|\\[xX][a-fA-F0-9]{1,2}))|\")'/))
+           @rex_tokens.push action { [:T_CHARACTER_LITERAL, text] }
+
+        when (text = ss.scan(/"(([^\n\t\"\\]|(\\[ntvbrfa\?'\\"]|\\[0-7]{1,3}|\\[xX][a-fA-F0-9]{1,2}))|')*"/))
+           @rex_tokens.push action { [:T_STRING_LITERAL, text] }
+
+        when (text = ss.scan(/[^\s\n\r]/))
+           @rex_tokens.push action { [:T_UNKNOWN, text] }
+
+        else
+          text = ss.string[ss.pos .. -1]
+          raise  ScanError, "can not match: '" + text + "'"
+        end  # if
+
+      else
+        raise  ScanError, "undefined state: '" + state.to_s + "'"
+      end  # case state
+    end  # until ss
+  end  # def scan_evaluate
+
+end # class
+end
+end