carray 1.3.3 → 1.4.0

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

@@ -1,213 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  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

@@ -1,345 +0,0 @@
-# ----------------------------------------------------------------------------
-#
-#  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