carray 1.1.4 → 1.1.5

data/ext/fortio/lib/fortio/fortran_namelist.y

@@ -0,0 +1,213 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/io/fortran_namelist.y
+#
+#  This file is part of Ruby/CArray extension library.
+#  You can redistribute it and/or modify it under the terms of
+#  the Ruby Licence.
+#
+#  Copyright (C) 2005 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+
+#
+#  racc fortran_namelist.y -> fortan_namelist.tab.rb
+#
+
+class FortranNamelistParser
+
+prechigh
+  left COMMA
+  left ','
+  left '='
+preclow
+
+rule
+
+  namelist_all : 
+                 namelist
+               | namelist namelist_all
+
+  namelist : 
+                 header paramlist tailer 
+                           { @root[val[0]] = val[1]; @scan.in_namelist = false }
+
+  header : 
+                 '&' IDENT { result = val[1].downcase }
+               | '$' IDENT { result = val[1].downcase }
+
+  tailer :
+                 '$'
+               | '&'
+               | '/'
+               | '&' IDENT { on_error unless val[1] =~ /\Aend\Z/i }
+               | '$' IDENT { on_error unless val[1] =~ /\Aend\Z/i }
+
+  paramlist:
+                 paramdef  { result = [val[0]] }
+               | paramlist paramdef
+                           { result = val[0] + [val[1]] }
+               | paramlist COMMA paramdef
+                           { result = val[0] + [val[2]] }
+               | paramlist COMMA
+                           { result = val[0] }
+
+  paramdef:  
+                 IDENT '=' rvalues 
+                           { result = ParamDef.new(val[0].downcase.intern, nil, val[2]) }
+               | IDENT '(' array_spec ')' '=' rvalues  
+                           { result = ParamDef.new(val[0].downcase.intern, val[2], val[5]) }
+
+  rvalues :      
+                 abbreb    { result = val[0] }
+               | rvalues abbreb      
+                           { result = val[0] + val[1] }
+               | rvalues NIL
+                           { result = val[0] + [nil] }
+               | rvalues ',' abbreb
+                           { result = val[0] + val[2] }
+               | IDENT
+                           { result = val[0] }
+
+  abbreb :
+                 constant { result = [val[0]] }
+               | DIGITS '*' constant
+                          { result = [val[2]] * val[0] }
+
+  constant :
+                 STRING
+               | DIGITS
+               | FLOAT
+
+  array_spec :
+                 DIGITS    { result = [val[0]-1] }
+               | DIGITS ':' DIGITS     
+                           { result = [(val[0]-1)..(val[2]-1)] }
+               | DIGITS ',' array_spec 
+                           { result = [val[0]-1] + val[2] }
+               | DIGITS ':' DIGITS ',' array_spec
+                           { result = [(val[0]-1)..(val[2]-1)] + val[4] }
+
+end
+
+---- inner
+
+  def parse (str)
+    @scan = FortranNamelistScanner.new(str)
+    @root = {}
+    do_parse
+    return @root
+  end
+
+  def next_token
+    return @scan.yylex
+  end
+
+---- header
+
+require "strscan"
+require "stringio"
+
+class FortranNamelistScanner 
+  
+  def initialize (text)
+    @s = StringScanner.new(text)
+    @in_namelist = false
+  end
+
+  attr_accessor :in_namelist
+
+  def yylex
+    while @s.rest?
+      unless @in_namelist
+        case
+        when @s.scan(/\A([\$&])/)              ### {$|&}
+          @in_namelist = true
+          return [
+            @s[0], 
+            nil
+          ]
+        when @s.scan(/\A[^\$&]/)
+          next
+        end       
+      else
+        case
+        when @s.scan(/\A[+-]?(\d+)\.(\d+)?([ED][+-]?(\d+))?/i) ### float
+          return [                              ### 1.2E+3, 1.E+3, 1.2E3
+            :FLOAT,                             ### 1.2, 1.
+            @s[0].sub(/D/i,'e').sub(/\.e/,".0e").to_f
+          ]
+        when @s.scan(/\A[+-]?\.(\d+)([ED][+-]?(\d+))?/i)       ### float
+          return [                              ### .2E+3, -.2E+3, .2E3
+            :FLOAT,                             ### .2, -.2
+            @s[0].sub(/D/i,'e').sub(/\./, '0.').to_f
+          ]
+        when @s.scan(/\A[+-]?(\d+)[ED][+-]?(\d+)/i)            ### float
+          return [                              ### 12E+3, 12E3, 0E0
+            :FLOAT, 
+            @s[0].sub(/D/i,'e').to_f
+          ]
+        when @s.scan(/\A[\-\+]?\d+/)            ### digits
+          return [
+            :DIGITS, 
+            Integer(@s[0])
+          ]
+        when @s.scan(/\A'((?:''|[^'])*)'/)      ### 'quoted string'
+          return [
+            :STRING, 
+            @s[1].gsub(/''/, "'")
+          ]
+        when @s.scan(/\A"((?:""|[^"])*)"/)      ### 'double-quoted string'
+          return [
+            :STRING, 
+            @s[1].gsub(/""/, '"')
+          ]
+        when @s.scan(/\A,/)                     ### ,
+          @s.scan(/\A\s+/)
+          while @s.scan(/\A\n\s*/) or @s.scan(/\A\![^\n]*/)
+            ### skip comment
+          end
+          if @s.match?(/\A[a-z]\w*/i) or @s.match?(/\A[\&\$\/\!]/)
+            return [
+              :COMMA, 
+              nil
+            ]
+          elsif @s.match?(/\A,/)
+            return [
+              :NIL,
+              nil
+            ]
+          else
+            return [
+              ',',
+              nil
+            ]
+          end
+        when @s.scan(/\A[\$&\/=\(\):*]/)        ### {$|&|/|,|=|(|)|:|*}
+          return [
+            @s[0], 
+            nil
+          ]
+        when @s.scan(/\A[a-z]\w*/i)             ### IDENT
+          return [
+            :IDENT,
+            @s[0]
+          ]
+        when @s.scan(/\A\s+/)                   ### blank
+          next
+        when @s.scan(/\A![^\n]*?\n/)             ### comment
+          next
+        when @s.scan(/\A\n/)                    ### newline
+          next
+        else
+          @s.rest =~ /\A(.*)$/
+          raise "FortranFormat parse error\n\t#{$1}\n\t^"
+        end
+      end
+    end
+  end
+
+end
+
+---- footer
+

data/ext/fortio/lib/fortio/fortran_sequential.rb

@@ -0,0 +1,345 @@
+# ----------------------------------------------------------------------------
+#
+#  fortio/fortran_sequential.rb
+#
+#  This file is part of Ruby/CArray extension library.
+#  You can redistribute it and/or modify it under the terms of
+#  the Ruby Licence.
+#
+#  Copyright (C) 2005 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+#
+#
+# Format
+#
+#   real*4    : native endian => "f", "F"
+#               little endian => "e"
+#               big endian    => "g"
+#
+#   real*8    : native endian => "d", "D"
+#               little endian => "E"
+#               big endian    => "G"
+#
+#   integer*2 : native endian => "s"
+#               little endian => "v"
+#               big endian    => "n"
+#
+#   integer*4 : native endian => "l"
+#               little endian => "V"
+#               big endian    => "N"
+#
+#   character : "a"
+#
+
+require "stringio"
+require "carray"
+
+class FortranSequential
+
+  if "ab".unpack("v").pack("s") == "ab"
+    ENDIAN = "little"
+  else
+    ENDIAN = "big"
+  end
+
+  FMT_VAX = {
+    "f" => "e", "F" => "e", "e" => "e", "g" => "g",
+    "d" => "E", "D" => "E", "E" => "E", "G" => "G",
+    "s" => "v",             "v" => "v", "n" => "n",
+    "l" => "V",             "V" => "V", "N" => "N",
+    "a" => "a"
+  }
+
+  FMT_NET = {
+    "f" => "g", "F" => "g", "e" => "e", "g" => "g",
+    "d" => "G", "D" => "G", "E" => "E", "G" => "G",
+    "s" => "n",             "v" => "v", "n" => "n",
+    "l" => "N",             "V" => "V", "N" => "N",
+    "a" => "a"
+  }
+  
+  def self.open (file, mode="r", opt={:endian=>nil})
+    io = Kernel::open(file, mode)
+    if mode =~ /r/
+      fs = FortranSequentialReader.new(io, opt)
+    else
+      fs = FortranSequentialWriter.new(io, opt)
+    end
+    if block_given?
+      begin
+        yield(fs)
+      ensure
+        fs.close
+      end
+    else
+      return fs
+    end
+  end
+
+  def get_pack_fmt (endian)
+    case endian 
+    when "big"
+      return FMT_NET
+    when "little"
+      return FMT_VAX
+    else
+      raise "unknown endian '#{endian}'"
+    end
+  end
+
+  class Record
+
+    def initialize (data="", endian="little", fmt=nil)
+      @io = StringIO.new(data)
+      @fmt = fmt
+      @endian = endian
+    end
+
+    def to_s
+      return @io.string
+    end
+
+    def empty?
+      return @io.eof?
+    end
+
+    def rest?
+      return (not @io.eof?)
+    end
+
+    def read (*fmts)
+      out = []
+      while not fmts.empty?
+        case fmt = fmts.shift
+        when String
+          list = []
+          specs = fmt.scan(/(?:\d+)(?:a\[\d+\]|\w)/)
+          while not specs.empty?
+            case specs.shift
+            when /(\d+)?a\[(\d+)\]/
+              ($1||1).to_i.times do 
+                list.push(*@io.read($2.to_i).unpack("a#{$2}"))
+              end
+            when /(\d+)?a/
+              ($1||1).to_i.times do 
+                list.push(*@io.read(1).unpack("a"))
+              end
+            when /(\d+)?([dDEG])/
+              ($1||1).to_i.times do 
+                list.push(*@io.read(8).unpack(@fmt[$2]))
+              end
+            when /(\d+)?([lNVefFg])/
+              ($1||1).to_i.times do 
+                list.push(*@io.read(4).unpack(@fmt[$2]))
+              end
+            when /(\d+)?([nsv])/
+              ($1||1).to_i.times do 
+                list.push(*@io.read(2).unpack(@fmt[$2]))
+              end
+            else
+              raise "invalid format for FortranSequential::Record#read"
+            end
+          end
+          if list.size == 1
+            out.push(list.first)
+          else
+            out.push(list)
+          end
+        when Integer
+          n, tmpl = fmt, fmts.shift
+          n.times do 
+            out.push(tmpl.template.load_binary(@io))
+          end
+        when CArray
+          tmpl = fmt
+          if ENDIAN == @endian
+            out.push(tmpl.template.load_binary(@io))
+          else
+            out.push(tmpl.template.load_binary(@io).swap_bytes!)
+          end
+        when CA::Struct
+          if ENDIAN == @endian
+            out.push(CScalar.new(fmt.class).load_binary(@io)[0])
+          else
+            out.push(CScalar.new(fmt.class).load_binary(@io).swap_bytes![0])
+          end
+        when Class
+          if fmt < CA::Struct
+            if ENDIAN == @endian
+              out.push(CScalar.new(fmt).load_binary(@io)[0])
+            else
+              out.push(CScalar.new(fmt).load_binary(@io).swap_bytes![0])
+            end
+          else
+            raise "invlaid argument (format string or CArray)"
+          end
+        else
+          raise "invlaid argument (format string or CArray)"
+        end 
+      end
+      if out.size == 1
+        return out.first
+      else
+        return out
+      end
+    end
+
+    def write (*fmts)
+      while fmt = fmts.shift
+        if fmt.is_a?(String)
+          argv = fmts.shift
+          unless argv.is_a?(Array)
+            raise "argv should be array"
+          end
+          argv = argv.clone
+        end
+        case fmt
+        when String
+          specs = fmt.scan(/(?:\d+)(?:a\[\d+\]|\w)/)
+          while not specs.empty?
+            case specs.shift
+            when /(\d+)?a\[(\d+)\]/
+              ($1||1).to_i.times do 
+                @io.write [argv.shift].pack("a#{$2}")
+              end
+            when /(\d+)?([adDEGefFglNVnsv])/ 
+              ($1||1).to_i.times do 
+                @io.write [argv.shift].pack(@fmt[$2])
+              end
+            else
+              raise "invalid format for FortranSequential::Record#write"
+            end
+          end
+        when CArray
+          if ENDIAN == @endian
+            fmt.dump_binary(@io)
+          else
+            fmt.swap_bytes.dump_binary(@io)
+          end
+        when CA::Struct
+          if RUBY_VERSION.to_f >= 1.9
+            if ENDIAN == @endian
+              @io.write fmt.encode.force_encoding("ASCII-8BIT")
+            else
+              @io.write fmt.swap_bytes.encode.force_encoding("ASCII-8BIT")
+            end
+          else
+            if ENDIAN == @endian
+              @io.write fmt.encode
+            else
+              @io.write fmt.swap_bytes.encode
+            end
+          end
+        else
+          raise "invlaid argument (format string or CArray)"
+        end 
+      end
+    end
+
+  end
+
+  def eof?
+    return @io.eof?
+  end
+  
+end
+
+class FortranSequentialReader < FortranSequential
+
+  def initialize (io, opt={:endian=>nil})
+    @io = io
+    @endian = opt[:endian] || ENDIAN
+    @fmt = get_pack_fmt(@endian)
+  end
+  
+  def record (n=nil)
+    if n 
+      @io.rewind
+      skip(n)
+    end
+    data = read
+    if data
+      rec = FortranSequential::Record.new(data, @endian, @fmt)
+      if block_given?
+        return yield(rec)
+      else
+        return rec
+      end
+    else
+      return nil
+    end
+  end
+  
+  def skip (n=1)
+    n.times do 
+      unless @io.eof?
+        length = @io.read(4).unpack(@fmt["l"]).first
+        @io.pos += length
+        if length != @io.read(4).unpack(@fmt["l"]).first
+          raise "invalid record length (should be #{length})"
+        end
+      end
+    end
+  end
+  
+  def read (*dummy)
+    if @io.eof?
+      return nil
+    else
+      length = @io.read(4).unpack(@fmt["l"]).first
+      data = @io.read(length)
+      if data.length != length
+        raise "record too short (record length should be #{length})"
+      end
+      if length != @io.read(4).unpack(@fmt["l"]).first
+        raise "mismatched record length (should be #{length})"
+      end
+      return data
+    end
+  end
+  
+  def close
+    @io.close
+  end
+  
+end
+
+class FortranSequentialWriter < FortranSequential
+
+  def initialize (io, opt={:endian=>nil})
+    @io = io
+    @endian = opt[:endian] || ENDIAN
+    @fmt = get_pack_fmt(@endian)
+  end
+  
+  def record
+    rec = FortranSequential::Record.new("", @endian, @fmt)
+    if block_given?
+      return yield(rec)
+    else
+      return rec
+    end
+  end
+  
+  def write (data)
+    if data.respond_to?(:to_s)
+      data = data.to_s
+    end
+    if RUBY_VERSION.to_f >= 1.9
+      data = data.force_encoding("ASCII-8BIT")
+    end
+    @io.write [data.length].pack(@fmt["l"])
+    @io.write data
+    @io.write [data.length].pack(@fmt["l"])
+  end
+  
+  def close
+    @io.close
+  end
+  
+end
+
+def fortran_sequential_open (file, mode="r", opt={:endian=>nil}, &block)
+  return FortranSequential.open(file, mode, opt, &block)
+end