ridl 2.2.5 → 2.5.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 6b4f57fea70c3afc0799ca7d925b19f567476cf0
-  data.tar.gz: 935963ed742a214a0dc67a2b72df6454e8716e10
+  metadata.gz: 487ad002804614ca82ead17a468922b304642d64
+  data.tar.gz: 419cd1417bbdd7498f589c245bf26ce50bb60b10
 SHA512:
-  metadata.gz: 1484766696c20592f73ea92c88d6e8ba4dde89dc8c9220403fb6aa0ffe948c60e66cb29fe18f3f6241bd48d0cb8a196bf87ac4cc9b0eefb762c2a404eec8aed6
-  data.tar.gz: 1818e868e7f680f256b1b74f36ef9ee572f9c4ca1c4e4dadcf05814f40a05a8baf0e6ba9610b3c038dfaea527633bbeceac6c912ba88f309495ff01bac963f68
+  metadata.gz: faf5353bc1a577cccf62034414744a012de908d8373bf38102edb5b6de39e970f223c140374278a2e7c86b6b00453351f9b123d20c4a93541a2c10cf35615e78
+  data.tar.gz: 6b3660bc7debee36367f8118c8114d49e6d05b7a9100902f567a59f8eb6d864adda462f838110b5fa5eec9b37143219933a023ddba2bc5617ca8e328a6b03d80

data/lib/ridl/backend.rb

@@ -51,7 +51,7 @@ module IDL
       rescue LoadError => ex
         IDL.error "ERROR: Cannot load RIDL backend [:#{be_name}]"
         IDL.error ex.inspect
-        IDL.error(ex.backtrace.join("\n")) if $VERBOSE
+        IDL.error(ex.backtrace.join("\n")) if IDL.verbose_level>0
         exit 1
       end
     end
@@ -62,8 +62,9 @@ module IDL
       @@backends[cfg.backend.name] = cfg.backend
     end
 
-    def self.stop_processing
-      raise ProcessStop, caller(1).first
+    # stop processing of current input and skip to next or exit RIDL
+    def self.stop_processing(msg='')
+      raise ProcessStop, msg, caller(1).first
     end
 
     def initialize(be_name, root, ttl, cpr, ver)
@@ -100,11 +101,9 @@ module IDL
     end
 
     def process_input(parser, params)
-      # process input top-down; return true and stop processing when input handled
-      unless _process_input(parser, params)
-        return @base_backends.any? {|be| be.process_input(parser, params) }
-      end
-      true
+      # process input top-down
+      _process_input(parser, params)
+      @base_backends.each {|be| be.process_input(parser, params) }
     end
 
     @@null_be = nil

data/lib/ridl/delegate.rb

@@ -59,6 +59,9 @@ class Delegator
           begin
             @root, @includes = Marshal.load(f)
             @cur = @root
+          rescue Exception => ex
+            IDL.error("RIDL - failed to load ORB pidlc [#{ex}]\n You probably need to rebuild the bootstrap file (compile orb.idl to orb.pidlc).")
+            exit(1)
           ensure
             f.close
           end
@@ -68,6 +71,8 @@ class Delegator
       return if @root
     end
     @root = @cur = IDL::AST::Module.new(nil, nil, {}) # global root
+    @last = nil
+    @last_pos = nil
   end
   def post_parse
     if @preprocess
@@ -75,6 +80,16 @@ class Delegator
     end
   end
 
+  private
+
+  def set_last(node = nil)
+    @last = node
+    @last_pos = @scanner.position.dup if node
+    node
+  end
+
+  public
+
   def visit_nodes(walker)
     walker.visit_nodes(self)
   end
@@ -199,21 +214,23 @@ class Delegator
     @includes.has_key?(s)
   end
 
-  def enter_include(s)
-    params = { :filename => s }
+  def enter_include(s, fullpath)
+    params = { :filename => s, :fullpath => fullpath }
     params[:defined] = true
     params[:preprocessed] = @preprocess
     @cur = @cur.define(IDL::AST::Include, "$INC:"+s, params)
     @includes[s] = @cur
+    set_last
     @cur
   end
 
   def leave_include()
+    set_last
     @cur = @cur.enclosure
   end
 
   def declare_include(s)
-    params = { :filename => s }
+    params = { :filename => s, :fullpath => @includes[s].fullpath }
     params[:defined] = false
     params[:preprocessed] = @includes[s].is_preprocessed?
     @cur.define(IDL::AST::Include, "$INC:"+s, params)
@@ -259,18 +276,26 @@ class Delegator
     type.node.set_repo_id(tid.to_s)
   end
 
-  def define_annotation(annid, annbody)
-    IDL.log(3, "parsed Annotation #{annid}(#{annbody})")
-    @annotation_stack << IDL::AST::Annotation.new(annid, annbody)
+  def define_annotation(annid, annpos, anncomment, annbody)
+    IDL.log(3, "parsed #{anncomment ? 'commented ' : ''}Annotation #{annid}(#{annbody}) @ #{annpos}")
+    if anncomment && @last && (@last_pos.line == annpos.line) && (@last_pos.name == annpos.name)
+      IDL.log(3, 'adding annotation to last node')
+      @last.annotations << IDL::AST::Annotation.new(annid, annbody)
+    else
+      IDL.log(3, 'appending annotation cached stack')
+      @annotation_stack << IDL::AST::Annotation.new(annid, annbody)
+    end
   end
 
   def define_module(name)
     @cur = @cur.define(IDL::AST::Module, name)
     @cur.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur
   end
   def end_module(node)
+    set_last(@cur)
     @cur = @cur.enclosure # must equals to argument mod
   end
 
@@ -285,6 +310,7 @@ class Delegator
     @cur = @cur.define(IDL::AST::TemplateModule, names[0])
     @cur.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur
   end
   alias :end_template_module :end_module
@@ -298,20 +324,23 @@ class Delegator
     params = { :type => type }
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.define(IDL::AST::TemplateParam, name, params)
+    set_last(@cur.define(IDL::AST::TemplateParam, name, params))
+    @cur
   end
 
   def instantiate_template_module(name, parameters)
     tmp = @template_module_name
     @template_module_name = nil # reset
     template_type = parse_scopedname(*tmp)
-    mod_inst = @cur.define(IDL::AST::Module, name)
-    mod_inst.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
-    @annotation_stack.clear
     unless template_type.node.is_a?(IDL::AST::TemplateModule)
       raise RuntimeError, "invalid module template specification: #{template_type.node.typename} #{template_type.node.scoped_lm_name}"
     end
-    template_type.node.instantiate(mod_inst, parameters)
+    params = { :template => template_type.node, :template_params => parameters }
+    mod_inst = @cur.define(IDL::AST::Module, name, params)
+    mod_inst.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
+    @annotation_stack.clear
+    set_last(mod_inst.template.instantiate(mod_inst))
+    @cur
   end
 
   def declare_template_reference(name, type, tpl_params)
@@ -320,7 +349,8 @@ class Delegator
     params[:tpl_params] = tpl_params || []
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.define(IDL::AST::TemplateModuleReference, name, params)
+    set_last(@cur.define(IDL::AST::TemplateModuleReference, name, params))
+    @cur
   end
 
   def declare_interface(name, attrib=nil)
@@ -332,6 +362,8 @@ class Delegator
     raise RuntimeError,
        "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
     @cur.define(IDL::AST::Interface, name, params)
+    set_last
+    @cur
   end
 
   def define_interface(name, attrib, inherits = [])
@@ -343,9 +375,11 @@ class Delegator
     params[:inherits] = inherits
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur = @cur.define(IDL::AST::Interface, name, params)
   end
   def end_interface(node)
+    set_last(@cur)
     @cur = @cur.enclosure # must equals to argument mod
   end
 
@@ -357,10 +391,12 @@ class Delegator
     params[:supports] = supports || []
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur = @cur.define(IDL::AST::Home, name, params)
   end
 
   def end_home(node)
+    set_last(@cur)
     @cur = @cur.enclosure
   end
 
@@ -369,6 +405,7 @@ class Delegator
     params[:forward] = true
     raise RuntimeError,
        "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+    set_last
     @cur.define(IDL::AST::Component, name, params)
   end
 
@@ -378,10 +415,12 @@ class Delegator
     params[:supports] = supports || []
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur = @cur.define(IDL::AST::Component, name, params)
   end
 
   def end_component(node)
+    set_last(@cur)
     @cur = @cur.enclosure
   end
 
@@ -390,10 +429,12 @@ class Delegator
     params[:base] = base
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur = @cur.define(IDL::AST::Connector, name, params)
   end
 
   def end_connector(node)
+    set_last(@cur)
     @cur = @cur.enclosure
   end
 
@@ -401,10 +442,12 @@ class Delegator
     params = {}
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur = @cur.define(IDL::AST::Porttype, name, params)
   end
 
   def end_porttype(node)
+    set_last(@cur)
     @cur = @cur.enclosure
   end
 
@@ -415,7 +458,8 @@ class Delegator
     params[:multiple] = multiple
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.define(IDL::AST::Port, name, params)
+    set_last(@cur.define(IDL::AST::Port, name, params))
+    @cur
   end
 
   def declare_eventtype(name, attrib=nil)
@@ -424,6 +468,7 @@ class Delegator
     params[:forward] = true
     raise RuntimeError,
        "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+    set_last
     @cur.define(IDL::AST::Eventtype, name, params)
     @cur
   end
@@ -436,6 +481,7 @@ class Delegator
     params[:inherits] = inherits
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur = @cur.define(IDL::AST::Eventtype, name, params)
     @cur
   end
@@ -446,6 +492,7 @@ class Delegator
     params[:forward] = true
     raise RuntimeError,
        "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+    set_last
     @cur.define(IDL::AST::Valuetype, name, params)
     @cur
   end
@@ -458,12 +505,14 @@ class Delegator
     params[:inherits] = inherits
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur = @cur.define(IDL::AST::Valuetype, name, params)
     @cur
   end
 
   def end_valuetype(node)
     node.defined = true
+    set_last(@cur)
     ret = IDL::Type::ScopedName.new(@cur)
     @cur = @cur.enclosure # must equals to argument mod
     ret
@@ -476,7 +525,7 @@ class Delegator
     params[:visibility] = (public_ ? :public : :private)
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.define(IDL::AST::StateMember, name, params)
+    set_last(@cur.define(IDL::AST::StateMember, name, params))
     @cur
   end
 
@@ -484,7 +533,7 @@ class Delegator
     params = { :type => type }
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.define(IDL::AST::Valuebox, name, params)
+    set_last(@cur.define(IDL::AST::Valuebox, name, params))
     @cur
   end
 
@@ -494,7 +543,7 @@ class Delegator
     params[:raises] = raises_
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.define(IDL::AST::Initializer, name, params)
+    set_last(@cur.define(IDL::AST::Initializer, name, params))
     @cur
   end
 
@@ -504,7 +553,7 @@ class Delegator
     params[:raises] = raises_
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.define(IDL::AST::Finder, name, params)
+    set_last(@cur.define(IDL::AST::Finder, name, params))
     @cur
   end
 
@@ -597,7 +646,7 @@ class Delegator
     params = { :type => _type, :expression => _expression }
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    node = @cur.define(IDL::AST::Const, _name, params)
+    set_last(@cur.define(IDL::AST::Const, _name, params))
     @cur
   end
 
@@ -607,6 +656,7 @@ class Delegator
     params[:type]   = _type
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur = @cur.define(IDL::AST::Operation, _name, params)
   end
   def declare_op_parameter(_attribute, _type, _name)
@@ -615,7 +665,8 @@ class Delegator
     params[:type] = _type
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.define(IDL::AST::Parameter, _name, params)
+    set_last(@cur.define(IDL::AST::Parameter, _name, params))
+    @cur
   end
   def declare_op_footer(_raises, _context)
     @cur.raises = _raises || []
@@ -623,6 +674,7 @@ class Delegator
     if not @cur.context.nil?
       raise RuntimeError, "context phrase's not supported"
     end
+    set_last(@cur)
     @cur = @cur.enclosure
   end
 
@@ -632,13 +684,14 @@ class Delegator
     params[:readonly] = _readonly
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.define(IDL::AST::Attribute, _name, params)
+    set_last(@cur.define(IDL::AST::Attribute, _name, params))
   end
 
   def declare_struct(_name)
     params = { :forward => true }
     raise RuntimeError,
        "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+    set_last
     @cur.define(IDL::AST::Struct, _name, params)
     @cur
   end
@@ -646,6 +699,7 @@ class Delegator
     params = { :forward => false }
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur = @cur.define(IDL::AST::Struct, _name, params)
   end
   def declare_member(_type, _name)
@@ -653,10 +707,12 @@ class Delegator
     params[:type] = _type
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.define(IDL::AST::Member, _name, params)
+    set_last(@cur.define(IDL::AST::Member, _name, params))
+    @cur
   end
   def end_struct(node)
     node.defined = true
+    set_last(@cur)
     ret = IDL::Type::ScopedName.new(@cur)
     @cur = @cur.enclosure
     ret
@@ -665,9 +721,11 @@ class Delegator
     params = { :forward => false }
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur = @cur.define(IDL::AST::Exception, _name, params)
   end
   def end_exception(node)
+    set_last(@cur)
     ret = IDL::Type::ScopedName.new(@cur)
     @cur = @cur.enclosure
     ret
@@ -677,6 +735,7 @@ class Delegator
     params = { :forward => true }
     raise RuntimeError,
        "annotations with forward declaration of #{name} not allowed" unless @annotation_stack.empty?
+    set_last
     @cur.define(IDL::AST::Union, _name, params)
     @cur
   end
@@ -684,10 +743,13 @@ class Delegator
     params = { :forward => false }
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur = @cur.define(IDL::AST::Union, _name, params)
   end
   def define_union_switchtype(union_node, switchtype)
     union_node.set_switchtype(switchtype)
+    union_node.annotations.concat(@annotation_stack) unless @annotation_stack.empty?
+    @annotation_stack.clear
     union_node
   end
   def define_case(_labels, _type, _name)
@@ -696,11 +758,13 @@ class Delegator
     params[:labels] = _labels
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.define(IDL::AST::UnionMember, _name, params)
+    set_last(@cur.define(IDL::AST::UnionMember, _name, params))
+    @cur
   end
   def end_union(node)
     node.validate_labels
     node.defined = true
+    set_last(@cur)
     ret = IDL::Type::ScopedName.new(@cur)
     @cur = @cur.enclosure
     ret
@@ -710,6 +774,7 @@ class Delegator
     params = {}
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
+    set_last
     @cur = @cur.define(IDL::AST::Enum, _name, params)
   end
   def declare_enumerator(_name)
@@ -720,10 +785,11 @@ class Delegator
     }
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.enclosure.define(IDL::AST::Enumerator, _name, params)
+    set_last(@cur.enclosure.define(IDL::AST::Enumerator, _name, params))
     @cur
   end
   def end_enum(node)
+    set_last(@cur)
     ret = IDL::Type::ScopedName.new(@cur)
     @cur = @cur.enclosure
     ret
@@ -734,7 +800,8 @@ class Delegator
     params[:type] = _type
     params[:annotations] = @annotation_stack.dup unless @annotation_stack.empty?
     @annotation_stack.clear
-    @cur.define(IDL::AST::Typedef, _name, params)
+    set_last(@cur.define(IDL::AST::Typedef, _name, params))
+    @cur
   end
 end # Delegator
 end # IDL