csquare-cast 0.2.2

data/lib/cast/parse.rb

@@ -0,0 +1,255 @@
+######################################################################
+#
+# C.default_parser and the parse_* methods.
+#
+# Yeah, this could be so much faster.
+#
+######################################################################
+
+module C
+  @@default_parser = Parser.new
+  def self.default_parser
+    @@default_parser
+  end
+  def self.default_parser=(val)
+    @@default_parser = val
+  end
+
+  class Node
+    #
+    # Return true if `str' is parsed to something `==' to this Node.
+    # str is first converted to a String using #to_s, then given to
+    # self.class.parse (along with the optional `parser').
+    #
+    def match?(str, parser=nil)
+      node = self.class.parse(str.to_s, parser) rescue (return false)
+      self == node
+    end
+    #
+    # Same as #match?.
+    #
+    def =~(*args)
+      match?(*args)
+    end
+    private
+  end
+  class NodeList
+    #
+    # As defined in Node.
+    #
+    def match?(arr, parser=nil)
+      arr = arr.to_a
+      return false if arr.length != self.length
+      each_with_index do |node, i|
+        node.match?(arr[i], parser) or return false
+      end
+      return true
+    end
+  end
+
+  def self.parse(s, parser=nil)
+    TranslationUnit.parse(s, parser)
+  end
+
+  class TranslationUnit
+    def self.parse(s, parser=nil)
+      parser ||= C.default_parser
+      parser.parse(s)
+    end
+  end
+
+  class Declaration
+    def self.parse(s, parser=nil)
+      parser ||= C.default_parser
+      ents = parser.parse(s).entities
+      if ents.length == 1 &&          # int i; int j;
+          ents[0].is_a?(Declaration)  # void f() {}
+        return ents[0].detach
+      else
+        raise ParseError, "invalid Declaration"
+      end
+    end
+  end
+
+  class Parameter
+    def self.parse(s, parser=nil)
+      parser ||= C.default_parser
+      ents = parser.parse("void f(#{s}) {}").entities
+      if ents.length == 1              &&  # ) {} void (
+          ents[0].is_a?(FunctionDef)   &&  # ); void(
+          ents[0].type.params          &&  #
+          ents[0].type.params.length <= 1  # x,y
+        param = ents[0].type.params[0]
+        if param.nil?
+          return Parameter.new(Void.new)
+        else
+          return param.detach
+        end
+      else
+        raise ParseError, "invalid Parameter"
+      end
+    end
+  end
+
+  class Declarator
+    def self.parse(s, parser=nil)
+      parser ||= C.default_parser
+      # if there's a ':', declare in a struct so we can populate num_bits
+      if s =~ /:/
+        ents = parser.parse("struct {int #{s};};").entities
+        if ents.length == 1 &&                              # i:1;}; struct {int i
+            ents[0].type.members.length == 1 &&             # i:1; int j
+            ents[0].type.members[0].declarators.length == 1 # i:1,j
+          return ents[0].type.members[0].declarators[0].detach
+        end
+      else
+        ents = parser.parse("int #{s};").entities
+        if ents.length == 1 &&               # f; int f;
+            ents[0].declarators.length == 1  # i,j
+          return ents[0].declarators[0].detach
+        end
+      end
+      raise ParseError, "invalid Declarator"
+    end
+  end
+
+  class FunctionDef
+    def self.parse(s, parser=nil)
+      parser ||= C.default_parser
+      ents = parser.parse(s).entities
+      if ents.length == 1 &&          # void f(); void g();
+          ents[0].is_a?(FunctionDef)  # int i;
+        return ents[0].detach
+      else
+        raise ParseError, "invalid FunctionDef"
+      end
+    end
+  end
+
+  class Enumerator
+    def self.parse(s, parser=nil)
+      parser ||= C.default_parser
+      ents = parser.parse("enum {#{s}};").entities
+      if ents.length == 1            &&     # } enum {
+          ents[0].is_a?(Declaration) &&     # } f() {
+          ents[0].type.members.length == 1  # X, Y
+        return ents[0].type.members[0].detach
+      else
+        raise ParseError, "invalid Enumerator"
+      end
+    end
+  end
+
+  class MemberInit
+    def self.parse(s, parser=nil)
+      parser ||= C.default_parser
+      ents = parser.parse("int f() {struct s x = {#{s}};}").entities
+      if ents.length == 1                              &&  # } int f() {
+          ents[0].def.stmts.length == 1                &&  # }} f() {{
+          ents[0].def.stmts[0].declarators.length == 1 &&  # 1}, y
+          ents[0].def.stmts[0].declarators[0].init.member_inits.length == 1 # 1, 2
+        return ents[0].def.stmts[0].declarators[0].init.member_inits[0].detach
+      else
+        raise ParseError, "invalid MemberInit"
+      end
+    end
+  end
+
+  class Member
+    def self.parse(s, parser=nil)
+      parser ||= C.default_parser
+      ents = parser.parse("int f() {struct s x = {.#{s} = 1};}").entities
+      if ents.length == 1                              &&  # a = 1};} int f() {struct s x = {a
+          ents[0].def.stmts.length == 1                &&  # a = 1}; struct s y = {.a
+          #ents[0].def.stmts[0].length == 1            &&  # a = 1}, x = {.a
+          ents[0].def.stmts[0].declarators.length == 1 &&  # a = 1}, x = {.a
+          ents[0].def.stmts[0].declarators[0].init.member_inits.length == 1 &&        # x = 1, y
+          ents[0].def.stmts[0].declarators[0].init.member_inits[0].member   &&        # 1
+          ents[0].def.stmts[0].declarators[0].init.member_inits[0].member.length == 1 # a .b
+        return ents[0].def.stmts[0].declarators[0].init.member_inits[0].member[0].detach
+      else
+        raise ParseError, "invalid Member"
+      end
+    end
+  end
+
+  class Statement
+    def self.parse(s, parser=nil)
+      parser ||= C.default_parser
+      ents = parser.parse("void f() {#{s}}").entities
+      if ents.length == 1               &&      # } void f() {
+          ents[0].def.stmts.length == 1 &&      # ;;
+          ents[0].def.stmts[0].is_a?(self)      # int i;
+        return ents[0].def.stmts[0].detach
+      else
+        raise ParseError, "invalid #{self}"
+      end
+    end
+  end
+
+  class Label
+    def self.parse(s, parser=nil)
+      parser ||= C.default_parser
+      ents = parser.parse("void f() {switch (0) #{s};}").entities
+      if ents.length == 1                              &&  # } void f() {
+          ents[0].def.stmts.length == 1                &&  # ;
+          ents[0].def.stmts[0].stmt                    &&  #
+          ents[0].def.stmts[0].stmt.labels.length == 1 &&  # x
+          ents[0].def.stmts[0].stmt.labels[0].is_a?(self)
+        return ents[0].def.stmts[0].stmt.labels[0].detach
+      else
+        raise ParseError, "invalid #{self}"
+      end
+    end
+  end
+
+  class Expression
+    def self.parse(s, parser=nil)
+      parser ||= C.default_parser
+      if s =~ /\A(\s*(\/\*.*?\*\/)?)*\{/
+        # starts with a brace -- must be a CompoundLiteral.  in this
+        # case, use a Declarator since only those can handle typeless
+        # CompoundLiterals.
+        ents = parser.parse("int i = #{s};").entities
+        if ents.length == 1                 &&  # 1; int i = 1
+            ents[0].declarators.length == 1 &&  # 1, j = 2
+            ents[0].declarators[0].init.is_a?(self)
+          return ents[0].declarators[0].init.detach
+        else
+          raise ParseError, "invalid #{self}"
+        end
+      else
+        ents = parser.parse("void f() {#{s};}").entities
+        if ents.length == 1                                 &&  # } void f() {
+            ents[0].def.stmts.length == 1                   &&  # ;
+            ents[0].def.stmts[0].is_a?(ExpressionStatement) &&  # int i
+            ents[0].def.stmts[0].expr.is_a?(self)
+          return ents[0].def.stmts[0].expr.detach
+        else
+          raise ParseError, "invalid #{self}"
+        end
+      end
+    end
+  end
+
+  class Type
+    def self.parse(s, parser=nil)
+      parser ||= C.default_parser
+      ents = parser.parse("void f() {(#{s})x;}").entities
+      if ents.length == 1                        &&  # 1);} void f() {(int
+          ents[0].def.stmts.length == 1          &&  # 1); (int
+          ents[0].def.stmts[0].expr.type.is_a?(self)
+        return ents[0].def.stmts[0].expr.type.detach
+      else
+        raise ParseError, "invalid #{self}"
+      end
+    end
+  end
+
+  # Make sure we didn't miss any
+  CORE_C_NODE_CLASSES.each do |c|
+    c.methods.include? 'parse' or
+      c.methods.include? :parse or
+      raise "#{c}#parse not defined"
+  end
+end

data/lib/cast/preprocessor.rb

@@ -0,0 +1,78 @@
+require 'open3'
+require 'rbconfig'
+
+##############################################################################
+#
+# A wrapper around the C preprocessor: RbConfig::CONFIG["CPP"]
+#
+##############################################################################
+
+module C
+  class Preprocessor
+    INCLUDE_REGEX = /(?:[^ ]|\\ )+\.h/i
+    COMPILER = RbConfig::CONFIG["CC"]
+
+    class Error < StandardError
+    end
+
+    class << self
+      attr_accessor :command
+    end
+
+    attr_accessor :pwd, :include_path, :macros
+
+    def initialize
+      @include_path = []
+      @macros = {}
+    end
+    def preprocess(text, line_markers = false)
+      args = %w{-E}
+      args << "-P" unless line_markers
+      run args, text
+=begin
+      if clean_gnu_artifacts
+        output.gsub!(/\b__asm\((?:"[^"]*"|[^)"]*)*\)/, '')
+        output.gsub!(/\b__attribute__\(\((?:[^()]|\([^()]+\))+\)\)/, '')
+        output.gsub!(/ __inline /, ' ')
+      end
+=end
+    end
+    def get_all_includes(text)
+      args = %w{-E -M}
+      split_includes run(args, text)
+    end
+    def get_system_includes(text)
+      get_all_includes(text) - get_project_includes(text)
+    end
+    def get_project_includes(text)
+      args = %w{-E -MM}
+      split_includes run(args, text)
+    end
+    def preprocess_file(file_name)
+      preprocess(File.read(file_name))
+    end
+
+    private  # -------------------------------------------------------
+
+    def run(args, input)
+      options = {:stdin_data => input}
+      options[:chdir] = pwd if pwd
+      output, error, result = Open3.capture3(COMPILER, *args, *include_args, *macro_args, '-', options)
+      raise Error, error unless result.success?
+      output
+    end
+    def include_args
+      include_path.map do |path|
+        "-I#{path}"
+      end
+    end
+    def macro_args
+      macros.map do |key, val|
+        "-D#{key}#{val.nil? ? '' : "=#{val}"}"
+      end
+    end
+    def split_includes(text)
+      text.scan(INCLUDE_REGEX)
+    end
+  end
+end

data/lib/cast/tempfile.rb

@@ -0,0 +1,186 @@
+######################################################################
+#
+# Alternative to the standard ruby tempfile library, which lets you
+# specify a filename suffix.
+#
+######################################################################
+
+require 'delegate'
+require 'tmpdir'
+require 'thread'
+
+# A class for managing temporary files.  This library is written to be
+# thread safe.
+module C
+  class Tempfile < DelegateClass(File)
+    MAX_TRY = 10
+    @@cleanlist = []
+
+    # Creates a temporary file of mode 0600 in the temporary directory
+    # whose name is basename.pid.n.suffix and opens with mode "w+".  A
+    # Tempfile object works just like a File object.
+    #
+    # If tmpdir is omitted, the temporary directory is determined by
+    # Dir::tmpdir provided by 'tmpdir.rb'.
+    # When $SAFE > 0 and the given tmpdir is tainted, it uses
+    # /tmp. (Note that ENV values are tainted by default)
+    def initialize(basename, tmpdir=Dir::tmpdir, suffix=nil)
+      if $SAFE > 0 and tmpdir.tainted?
+        tmpdir = '/tmp'
+      end
+
+      lock = nil
+      tmpname = nil
+      n = failure = 0
+
+      Thread.exclusive do
+        begin
+          begin
+            tmpname = File.join(tmpdir, make_tmpname(basename, n, suffix))
+            lock = tmpname + '.lock'
+            n += 1
+          end while @@cleanlist.include?(tmpname) or
+          File.exist?(lock) or File.exist?(tmpname)
+
+          Dir.mkdir(lock)
+        rescue
+          failure += 1
+          retry if failure < MAX_TRY
+          raise "cannot generate tempfile `%s'" % tmpname
+        end
+      end
+
+      @data = [tmpname]
+      @clean_proc = Tempfile.callback(@data)
+      ObjectSpace.define_finalizer(self, @clean_proc)
+
+      @tmpfile = File.open(tmpname, File::RDWR|File::CREAT|File::EXCL, 0600)
+      @tmpname = tmpname
+      @@cleanlist << @tmpname
+      @data[1] = @tmpfile
+      @data[2] = @@cleanlist
+
+      super(@tmpfile)
+
+      # Now we have all the File/IO methods defined, you must not
+      # carelessly put bare puts(), etc. after this.
+
+      Dir.rmdir(lock)
+    end
+
+    def make_tmpname(basename, n, suffix)
+      sprintf('%s%d.%d%s', basename, $$, n, suffix)
+    end
+    private :make_tmpname
+
+    # Opens or reopens the file with mode "r+".
+    def open
+      @tmpfile.close if @tmpfile
+      @tmpfile = File.open(@tmpname, 'r+')
+      @data[1] = @tmpfile
+      __setobj__(@tmpfile)
+    end
+
+    def _close	# :nodoc:
+      @tmpfile.close if @tmpfile
+      @data[1] = @tmpfile = nil
+    end    
+    protected :_close
+
+    # Closes the file.  If the optional flag is true, unlinks the file
+    # after closing.
+    #
+    # If you don't explicitly unlink the temporary file, the removal
+    # will be delayed until the object is finalized.
+    def close(unlink_now=false)
+      if unlink_now
+        close!
+      else
+        _close
+      end
+    end
+
+    # Closes and unlinks the file.
+    def close!
+      _close
+      @clean_proc.call
+      ObjectSpace.undefine_finalizer(self)
+    end
+
+    # Unlinks the file.  On UNIX-like systems, it is often a good idea
+    # to unlink a temporary file immediately after creating and opening
+    # it, because it leaves other programs zero chance to access the
+    # file.
+    def unlink
+      # keep this order for thread safeness
+      begin
+        File.unlink(@tmpname) if File.exist?(@tmpname)
+        @@cleanlist.delete(@tmpname)
+        @data = @tmpname = nil
+        ObjectSpace.undefine_finalizer(self)
+      rescue Errno::EACCES
+        # may not be able to unlink on Windows; just ignore
+      end
+    end
+    alias delete unlink
+
+    # Returns the full path name of the temporary file.
+    def path
+      @tmpname
+    end
+
+    # Returns the size of the temporary file.  As a side effect, the IO
+    # buffer is flushed before determining the size.
+    def size
+      if @tmpfile
+        @tmpfile.flush
+        @tmpfile.stat.size
+      else
+        0
+      end
+    end
+    alias length size
+
+    class << self
+      def callback(data)	# :nodoc:
+        pid = $$
+        lambda{
+          if pid == $$ 
+            path, tmpfile, cleanlist = *data
+
+            print "removing ", path, "..." if $DEBUG
+
+            tmpfile.close if tmpfile
+
+            # keep this order for thread safeness
+            File.unlink(path) if File.exist?(path)
+            cleanlist.delete(path) if cleanlist
+
+            print "done\n" if $DEBUG
+          end
+        }
+      end
+
+      # If no block is given, this is a synonym for new().
+      #
+      # If a block is given, it will be passed tempfile as an argument,
+      # and the tempfile will automatically be closed when the block
+      # terminates.  In this case, open() returns nil.
+      def open(*args)
+        tempfile = new(*args)
+
+        if block_given?
+          begin
+            yield(tempfile)
+          ensure
+            tempfile.close
+          end
+
+          nil
+        else
+          tempfile
+        end
+      end
+    end
+  end
+end