ridl 2.2.4

data/lib/ridl/expression.rb

@@ -0,0 +1,276 @@
+#--------------------------------------------------------------------
+# expression.rb - IDL Expression classes
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the RIDL LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+require 'ridl/node'
+
+module IDL
+  class Expression
+    attr_reader :idltype
+    attr_reader :value
+    def typename; @idltype.typename; end
+
+    def is_template?
+      false
+    end
+
+    def instantiate(_context)
+      self
+    end
+
+    class Value < Expression
+      def initialize(type, val)
+        @idltype = type
+        @value = @idltype.narrow(val)
+      end
+    end
+
+    class ScopedName < Expression
+      attr_reader :node
+      def initialize(node)
+        if $DEBUG
+          unless IDL::AST::Const === node || (IDL::AST::TemplateParam === node && node.idltype.is_a?(IDL::Type::Const))
+            raise RuntimeError,
+              "#{node.scoped_name} must be constant: #{node.class.name}."
+          end
+        end
+        @node = node
+        @idltype = node.idltype
+        @value = @idltype.narrow(node.value) unless node.is_template?
+      end
+      def is_template?
+        @node.is_template?
+      end
+      def instantiate(_context)
+        if self.is_template?
+          cp = IDL::AST::TemplateParam.concrete_param(_context, @node)
+          cp.is_a?(Expression) ? cp : ScopedName.new(cp)
+        else
+          self
+        end
+      end
+      def is_node?(node_class)
+        @node.is_a?(node_class)
+      end
+      def resolved_node
+        @node
+      end
+    end
+
+    class Enumerator < Expression
+      attr_reader :node
+      def initialize(node)
+        if $DEBUG
+          if not IDL::AST::Enumerator === node
+            raise RuntimeError,
+              "#{node.scoped_name} must be enumerator: #{node.class.name}."
+          end
+        end
+        @node = node
+        @idltype = node.idltype
+        @value = node.value
+      end
+    end
+
+    class Operation < Expression
+      NUMBER_OF_OPERANDS = nil
+
+      attr_reader :operands
+      def initialize(*_operands)
+        n = self.class::NUMBER_OF_OPERANDS
+
+        if _operands.size != n
+          raise RuntimeError,
+            format("%s must receive %d operand%s.",
+            self.typename, n, if (n>1) then "s" else "" end)
+        end
+
+        unless _operands.any? { |o| o.is_template? }
+          @idltype = self.class.suite_type(*(_operands.collect{|o| o.idltype.resolved_type}))
+          @value = calculate(*(_operands.collect{|o| o.value}))
+        else
+          @idltype = nil
+          @value = nil
+        end
+        @operands = _operands
+        self.set_type
+      end
+
+      def is_template?
+        @operands.any? { |o| o.is_template? }
+      end
+
+      def instantiate(_context)
+        self.is_template? ? self.class.new(*@operands.collect { |o| o.instantiate(_context) }) : self
+      end
+
+      def Operation.suite_type(*types)
+        types.each do |t|
+          if not self::Applicable.include? t.class
+            raise RuntimeError,
+              "#{self.name} cannot be applicable for #{t.typename}"
+          end
+        end
+
+        ret = nil
+        types = types.collect {|t| t.class }
+        self::Applicable.each do |t|
+          if types.include? t
+            ret = t
+            break
+          end
+        end
+        ret
+      end
+      def set_type
+      end
+
+      class Unary < Operation
+        NUMBER_OF_OPERANDS = 1
+        Applicable = nil
+      end #of class Unary
+
+      class Integer2 < Operation
+        NUMBER_OF_OPERANDS = 2
+        Applicable = [
+          IDL::Type::LongLong, IDL::Type::ULongLong,
+          IDL::Type::Long, IDL::Type::ULong,
+          IDL::Type::Short, IDL::Type::UShort,
+          IDL::Type::Octet
+        ]
+
+        def Integer2.suite_sign(_t, _v)
+          [ [IDL::Type::LongLong, IDL::Type::ULongLong],
+            [IDL::Type::Long,     IDL::Type::ULong],
+            [IDL::Type::Short,    IDL::Type::UShort]
+          ].each do |t|
+            next unless t.include? _t
+            return (if _v < 0 then t[0] else t[1] end)
+          end
+        end
+
+        def set_type
+          if Integer2::Applicable.include? @idltype
+            @idltype = self.class.suite_sign(@idltype, @value)
+          end
+        end
+      end
+
+      class Boolean2 < Integer2
+        Applicable = [
+          IDL::Type::Boolean
+        ] + Integer2::Applicable
+
+        def Boolean2.checktype(t1, t2)
+          superclass.checktype(*types)
+
+          t = IDL::Type::Boolean
+          if (t1 == t && t2 != t) or (t1 != t && t2 == t)
+            raise RuntimeError,
+              "#{self.name} about #{t1.typename} and #{t2.typename} is illegal."
+          end
+        end
+      end
+
+      class Float2 < Integer2
+        Applicable = [
+          IDL::Type::LongDouble, IDL::Type::Double, IDL::Type::Float,
+          IDL::Type::Fixed
+        ] + Integer2::Applicable
+
+        def Float2.checktype(t1, t2)
+          superclass.checktype(*types)
+
+          # it's expected that Double, LongDouble is a Float.
+          s1,s2 = IDL::Type::Float, IDL::Type::Fixed
+          if (t1 === s1 && t2 === s2) or (t1 === s2 && t2 === s1)
+            raise RuntimeError,
+              "#{self.name} about #{t1.typename} and #{t2.typename} is illegal."
+          end
+        end
+      end
+
+      class UnaryPlus < Unary
+        Applicable = Float2::Applicable
+        def calculate(op)
+          op
+        end
+      end
+      class UnaryMinus < Unary
+        Applicable = Float2::Applicable
+        def calculate(op)
+          -op
+        end
+        def set_type
+          @idltype = Integer2.suite_sign(@idltype, @value)
+        end
+      end
+      class UnaryNot < Unary
+        Applicable = Integer2::Applicable
+        def calculate(op)
+          if @idltype.is_unsigned?()
+            (2**@idltype.bits-1)-op
+          else
+            ~op
+          end
+        end
+      end
+
+      class Or < Boolean2
+        def calculate(lop,rop); lop | rop; end
+      end
+      class And < Boolean2
+        def calculate(lop,rop); lop & rop; end
+      end
+      class Xor < Boolean2
+        def calculate(lop,rop); lop ^ rop; end
+      end
+
+      class Shift < Integer2
+      protected
+        def check_rop(rop)
+          if not (0...64) === rop
+            raise RuntimeError,
+              "right operand for shift must be in the range 0 <= right operand < 64: #{rop}."
+          end
+        end
+      end
+      class LShift < Shift
+        def calculate(lop,rop)
+          check_rop(rop)
+          lop << rop
+        end
+      end
+      class RShift < Shift
+        def calculate(lop,rop)
+          check_rop(rop)
+          lop >> rop
+        end
+      end
+
+      class Add < Float2
+        def calculate(lop,rop); lop + rop; end
+      end
+      class Minus < Float2
+        def calculate(lop,rop); lop - rop; end
+      end
+      class Mult < Float2
+        def calculate(lop,rop); lop * rop; end
+      end
+      class Div < Float2
+        def calculate(lop,rop); lop / rop; end
+      end
+      class Mod < Integer2
+        def calculate(lop,rop); lop % rop; end
+      end
+    end #of class Operation
+  end #of class Expression
+end

data/lib/ridl/genfile.rb

@@ -0,0 +1,220 @@
+#--------------------------------------------------------------------
+# genfile.rb - Generator file class implementation.
+#
+# Author: Martin Corino
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the RIDL LICENSE which is
+# included with this program.
+#
+# Copyright (c) Remedy IT Expertise BV
+# Chamber of commerce Rotterdam nr.276339, The Netherlands
+#--------------------------------------------------------------------
+require 'tempfile'
+require 'fileutils'
+
+module IDL
+
+  class GenFile
+
+    @@stack = []
+    @@cur_trans = nil
+
+    def self.transaction(&block)
+      @@cur_trans = []
+      @@stack << @@cur_trans
+      begin
+        block.call if block_given?
+        @@cur_trans.each {|fgen| fgen.save }
+        @@cur_trans.clear
+      ensure
+        self.rollback # after successful transaction should be nothing left
+        @@stack.pop
+        @@cur_trans = @@stack.last
+      end
+    end
+
+    def self.rollback
+      if @@cur_trans
+        @@cur_trans.each {|fgen| fgen.remove }
+        @@cur_trans.clear
+      end
+    end
+
+    class Content
+      def initialize(sections = {})
+        # copy content map transforming all keys to symbols
+        @sections = sections.inject({}) {|m,(k,v)| m[k.to_sym] = v; m }
+      end
+
+      def sections
+        @sections.keys
+      end
+
+      def has_section?(sectionid)
+        @sections.has_key?((sectionid || '').to_sym)
+      end
+
+      def [](sectionid)
+        @sections[(sectionid || '').to_sym]
+      end
+
+      def each(&block)
+        @sections.each(&block)
+      end
+    end
+
+    REGEN_MARKER_DEFAULT = '@@{__RIDL_REGEN_MARKER__}'
+
+    attr_reader :path, :fullpath, :name, :ext, :content
+
+    def initialize(path, opts = {})
+      if path
+        @path = path
+        @fullpath = File.expand_path(path)
+        @name = File.basename(path)
+        @ext = File.extname(path).sub(/^\./,'')
+      else
+        @path = @fullpath = @name = @ext = ''
+      end
+      @options = {
+        :regenerate => false,
+        :regen_marker_prefix => '//',
+        :regen_marker_postfix => nil,
+        :regen_marker => REGEN_MARKER_DEFAULT,
+        :regen_keep_header => false,
+        :output_file => nil
+      }.merge(opts)
+      if @options[:regenerate] && File.exists?(@fullpath)
+        parse_regeneration_content
+      else
+        @content = Content.new
+      end
+      @fout = @options[:output_file] || Tempfile.new(@name)
+      @@cur_trans << self
+    end
+
+    def <<(txt)
+      @fout << txt if @fout
+      self
+    end
+
+    def regen_start_marker(sectionid)
+      "#{@options[:regen_marker_prefix]}#{@options[:regen_marker]} - BEGIN : #{sectionid}#{@options[:regen_marker_postfix]}"
+    end
+
+    def regen_end_marker(sectionid)
+      "#{@options[:regen_marker_prefix]}#{@options[:regen_marker]} - END : #{sectionid}#{@options[:regen_marker_postfix]}"
+    end
+
+    def regen_header_end_marker(sectionid)
+      "#{@options[:regen_marker_prefix]}#{@options[:regen_marker]} - HEADER_END : #{sectionid}#{@options[:regen_marker_postfix]}"
+    end
+
+    def write_regen_section(sectionid, default_content, indent = '', options = {})
+      self << indent << regen_start_marker(sectionid) << "\n" unless options[:header]
+      if content.has_section?(sectionid)
+        self << content[sectionid].join unless content[sectionid].empty?
+      else
+        default_content = (Array === default_content) ? default_content : default_content.to_s.split("\n")
+        self << (default_content.collect {|l| (s = indent.dup) << l << "\n"; s }.join) unless default_content.empty?
+      end
+      if options[:header]
+        self << indent << regen_header_end_marker(sectionid) << "\n"
+      else
+        self << indent << regen_end_marker(sectionid) << "\n" unless options[:footer]
+      end
+    end
+
+    def save
+      return if @options[:output_file]
+      if @fout
+        fgen = @fout
+        @fout = nil
+        fgen.close(false) # close but do NOT unlink
+        if File.exists?(@fullpath)
+          # create temporary backup
+          ftmp = Tempfile.new(@name)
+          ftmp_name = ftmp.path.dup
+          ftmp.close(true) # close AND unlink
+          FileUtils::mv(@fullpath, ftmp_name) # backup existing file
+          # replace original
+          begin
+            # rename newly generated file
+            FileUtils::mv(fgen.path, @fullpath)
+            # preserve file mode
+            FileUtils::chmod(File.lstat(ftmp_name).mode, @fullpath)
+          rescue
+            IDL.log(0, %Q{ERROR: FAILED updating #{@path}: #{$!}})
+            # restore backup
+            FileUtils::mv(ftmp_name, @fullpath)
+            raise
+          end
+          # remove backup
+          File.unlink(ftmp_name)
+        else
+          # just rename newly generated file
+          FileUtils::mv(fgen.path, @fullpath)
+          # set default mode for new files
+          FileUtils::chmod(0666 - File.umask, @fullpath)
+        end
+      end
+    end
+
+    def remove
+      return if @options[:output_file]
+      if @fout
+        begin
+          @fout.close(true)
+        rescue
+          IDL.log(0, %Q{ERROR: FAILED to clean up temp file #{@fout.path}: #{$!}})
+        end
+        @fout = nil
+      end
+    end
+
+  private
+
+    def parse_regeneration_content
+      markers_sel = %w{BEGIN END}
+      _keep_header = (@options[:regen_keep_header] == true)
+      markers_sel << 'HEADER_END' if _keep_header
+      regen_marker_re = /#{@options[:regen_marker]}\s+[-]\s+(#{markers_sel.join('|')})\s+:\s+(.+)/
+      sections = {}
+      section = []
+      in_section = _keep_header ? ['HEADER', 0] : nil
+      linenr = 0
+      File.open(@fullpath) do |fio|
+        fio.each do |line|
+          linenr += 1
+          if regen_marker_re =~ line
+            case $1
+            when 'BEGIN'
+              raise RuntimeError, "ERROR: Found unterminated regeneration section starting at #{@path}:#{in_section.last}." if in_section
+              in_section = [$2, linenr]
+              section = []
+            when 'END'
+              raise RuntimeError, "ERROR: Found unmatched regeneration end at #{@path}:#{linenr}." unless in_section && ($2 == in_section.first)
+              sections[$2] = section
+              in_section = nil
+              section = []
+            when 'HEADER_END'
+              raise RuntimeError, "ERROR: Found illegal header end marker at #{@path}:#{linenr}." unless _keep_header && in_section &&
+                                                                                                         ('HEADER' == in_section.first ) && (0 == in_section.last)
+              sections[$2] = section
+              in_section = nil
+              section = []
+            else
+              raise RuntimeError, "ERROR: Found invalid regeneration marker at #{@path}:#{linenr}."
+            end
+          elsif in_section
+            section << line
+          end
+        end
+      end
+      sections[in_section.first] = section if in_section
+      @content = Content.new(sections)
+    end
+
+  end
+end