carray 1.1.4 → 1.1.5

data/ext/fortio/lib/fortio/fortran_format.y

@@ -0,0 +1,215 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/io/fortran_format.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_format.y -> fortan_format.tab.rb
+#
+
+class FortranFormatParser
+
+rule
+
+  format :       
+               format_string    { 
+	                                if val[0].size == 1 and val[0].first.is_a?(Group)
+		                                result = val[0].first
+		                              else
+	                                  result = Group.new(1,val[0]) 
+	                                end
+	                              }
+
+  format_string : 
+                 format_spec    { result = [val[0]] }
+               | format_string format_spec 
+                                { result = val[0] + [val[1]] }
+
+  format_spec : 
+                 hollerith      { result = val[0] }
+               | unrepeatable   { result = val[0] }
+               | repeatable     { result = val[0] }
+               | DIGITS repeatable 
+                                { val[1].count = val[0]; result = val[1] }
+
+  hollerith    : H              { result = NodeH.new(*val[0]) }
+
+  unrepeatable : 
+                 STRING         { result = NodeS.new(val[0]) }
+               | P              { result = NodeP.new(val[0]) }
+               | Sp             { result = NodeSp.new(val[0]) }
+               | B              { result = NodeB.new(val[0]) }
+               | T              { result = NodeT.new(val[0]) }
+               | TR             { result = NodeTR.new(val[0]) }
+               | TL             { result = NodeTL.new(val[0]) }
+               | '$'            { result = Continue.new }
+
+  repeatable : 
+                 '(' format_string ')' 
+                                { result = Group.new(1,val[1]) }
+               | fixed_point
+               | floating_point
+               | '/'            { result = Flush.new(1) }
+
+  fixed_point : 
+                 X              { result = NodeX.new(1) }
+               | A              { result = NodeA.new(1, val[0]) }
+               | I              { result = NodeI.new(1, *val[0]) }
+               | L              { result = NodeL.new(1, *val[0]) }
+               | F              { result = NodeF.new(1, *val[0]) }
+
+  floating_point : 
+                 E              { result = NodeE.new(1, *val[0]) }
+               | ES             { result = NodeES.new(1, *val[0]) }
+               | D              { result = NodeE.new(1, *val[0]) }
+               | G              { result = NodeG.new(1, *val[0]) }  
+               | floating_point EXP 
+                                { result = val[0]; result.exp = val[1] }
+
+end
+
+---- inner
+
+  def parse (str)
+    @scan  = FortranFormatScanner.new(str)
+    @scale = 0
+    @continue = false
+    do_parse
+  end
+
+  def next_token
+    return @scan.yylex
+  end
+
+---- header
+
+require "strscan"
+
+class FortranFormatScanner 
+  
+  def initialize (text)
+    @s = StringScanner.new(text)
+  end
+
+  def yylex
+    while @s.rest?
+      case
+      when @s.scan(/\A(ES|[FEDG])(\d+)\.(\d+)/i) ### {F|E|D|G|ES}w.d
+        return [
+          @s[1].upcase.to_sym, 
+          [
+            @s[2].to_i, 
+            @s[3].to_i
+          ]
+        ]
+      when @s.scan(/\AE(\d+)/i)               ### Ed (for exponential)
+        return [
+          :EXP,
+          @s[1].to_i
+        ]
+      when @s.scan(/\AI(\d+)(\.(\d+))?/i)     ### Iw(.d)
+        return [
+          :I, 
+          [
+            @s[1].to_i, 
+            @s[3] ? @s[3].to_i : nil
+          ]
+        ]
+      when @s.scan(/\AL(\d+)?/i)              ### L(w)
+        return [
+          :L, 
+          @s[1] ? @s[1].to_i : nil
+        ]
+      when @s.scan(/\AA(\d+)?/i)              ### A(w)
+        return [
+          :A, 
+          @s[1] ? @s[1].to_i : nil
+        ]
+      when @s.scan(/\AX/i)                    ### X
+        return [
+          :X,
+          nil
+        ]
+      when @s.scan(/\ATL(\d+)?/i)             ### TLw
+        return [
+          :TL,
+          @s[1] ? @s[1].to_i : 1
+        ]
+      when @s.scan(/\ATR(\d+)?/i)             ### TRw
+        return [
+          :TR,
+          @s[1] ? @s[1].to_i : 1
+        ]
+      when @s.scan(/\AT(\d+)?/i)              ### Tw
+        return [
+          :T,
+          @s[1] ? @s[1].to_i : 1
+        ]
+      when @s.scan(/\A([+-]?\d+)P/i)          ### {+|-|}P
+        return [
+          :P,
+          @s[1].to_i
+        ]
+      when @s.scan(/\AS[PS]?/i)               ### S,SP,SS
+        return [
+          :Sp,
+          @s[0] =~ /SP/i ? true : false
+        ]
+      when @s.scan(/\AB[NZ]/i)                ### BN,BZ
+        return [
+          :B,
+          @s[0] =~ /BZ/i ? true : false
+        ]
+      when @s.match?(/\A(\d+)?H/i)            ### Hollerith 
+        count  = @s[1] ? @s[1].to_i : 1
+        if @s.scan(/\A(\d+)?H(.{#{count}})/)
+          return [
+            :H,
+            [count, @s[2]]
+          ]
+	      else
+					raise "invalid horeris descriptor"
+        end
+      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(\d+)/)                 ### digits
+        return [
+          :DIGITS, 
+          @s[1].to_i
+        ]
+      when @s.scan(/\A([\(\)\/\$\:])/)        ### {(|)|/|$}
+        return [
+          @s[1], 
+          nil
+        ]
+      when @s.scan(/:/)
+	      raise("format descriptor ':' is not supported.")
+      when @s.scan(/\A,/)                     ### blank
+        next
+      when @s.scan(/\A\s+/)                   ### blank
+        next
+      else
+        raise "FortranFormat parse error\n\t#{@s.string}\n\t#{' '*@s.pos}^"
+      end
+    end
+  end
+
+end
+
+---- footer
+

data/ext/fortio/lib/fortio/fortran_namelist.rb

@@ -0,0 +1,151 @@
+# ----------------------------------------------------------------------------
+#
+#  carray/io/fortran_namelist.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
+#
+# ----------------------------------------------------------------------------
+
+require "carray"
+require "fortio/fortran_namelist.tab"
+
+class FortranNamelistReader
+  
+  def initialize (text)
+    @namelist = FortranNamelistParser.new.parse(text)
+  end
+  
+  def read (name, out={})
+    name = name.downcase
+    unless nml = @namelist[name]
+      raise "no definition of namelist '#{name}'"
+    end
+    nml.each do |paramdef|
+      paramdef.set(out)
+    end
+    return out
+  end
+
+  def read_all 
+    all = {}
+    @namelist.each do |name, nml|
+      all[name] = {}
+      read(name, all[name])
+    end
+    return all
+  end
+
+  attr_reader :namelist
+  
+end
+
+def fortran_namelist (name, out)
+  list = out.map{ |ident, value|
+    case value
+    when CArray
+      ident = "#{ident}(" + value.dim.map{|d| "1:#{d}" }.join(",") + ")"
+      value = value.flatten.to_a.join(",")
+    when Array
+      value = value.flatten.join(",")
+    when String
+      if value !~ /'/
+        value = "'" + value + "'"
+      else 
+        value = '"' + value.gsub(/"/, '""') + '"'
+      end
+    when Float
+      value = value.to_s.sub(/e/, "d")
+    end
+    " #{ident} = #{value}" 
+  }
+  return ["&#{name}", list.join(",\n") + "  /"].join("\n")
+end
+
+def fortran_namelist_read (io, name=nil, out={})
+  case io
+  when String
+    text = io
+  else
+    text = io.read
+  end
+  if name
+    return FortranNamelistReader.new(text).read(name, out)
+  else
+    return FortranNamelistReader.new(text).read_all()
+  end
+end
+
+def fortran_namelist_write (io, name, out)
+  io << fortran_namelist(name, out)
+  return io
+end
+
+class FortranNamelistParser
+  
+  ParamDef = Struct.new(:ident, :array_spec, :rval)
+  class ParamDef
+    def set (hash)
+      case hash[ident]
+      when CArray
+        hash[ident].attach { |ca|
+          if array_spec
+            crv = rval.to_ca
+            if crv.search(nil)
+              mask = crv.ne(nil)
+              ca[*array_spec][0...crv.size][mask] = crv[mask]
+            elsif ca[*array_spec].is_a?(CArray)
+              ca[*array_spec][0...crv.size] = crv              
+            else 
+              ca[*array_spec] = rval.first
+            end
+          else
+            if rval.is_a?(Array) and rval.size == 1
+              ca[0] = rval.first
+            else
+              ca[0...rval.size] = rval
+            end
+          end
+        }
+      when Array
+        if array_spec
+          if array_spec.first.is_a?(Integer) and rval.size == 1
+            hash[ident][*array_spec] = rval.first
+          else
+            hash[ident][*array_spec] = rval.first
+          end
+        else
+          if rval.is_a?(Array) and rval.size == 1
+            hash[ident][0] = rval.first
+          else
+            hash[ident].clear
+            hash[ident].push(*rval)
+          end
+        end        
+      else
+        if array_spec
+          hash[ident] = []
+          set(hash)
+        else
+          if rval.is_a?(Array) and rval.size == 1
+            hash[ident] = rval.first
+          else
+            hash[ident] = rval
+          end
+        end
+      end
+    end
+    def inspect
+      if array_spec
+        return "#{ident}(#{array_spec.inspect}) = #{rval.inspect}"
+      else
+        return "#{ident} = #{rval}"
+      end
+    end
+  end
+
+end
+

data/ext/fortio/lib/fortio/fortran_namelist.tab.rb

@@ -0,0 +1,470 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.6
+# from Racc grammer file "".
+#
+
+require 'racc/parser.rb'
+
+
+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
+
+class FortranNamelistParser < Racc::Parser
+
+module_eval(<<'...end fortran_namelist.y/module_eval...', 'fortran_namelist.y', 94)
+
+  def parse (str)
+    @scan = FortranNamelistScanner.new(str)
+    @root = {}
+    do_parse
+    return @root
+  end
+
+  def next_token
+    return @scan.yylex
+  end
+
+...end fortran_namelist.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+    38,    28,    41,    36,    24,    25,    11,    22,    36,    24,
+    25,    35,    22,    39,    24,    25,    35,    22,    28,    24,
+    25,     1,    32,     2,    22,    18,    24,    25,    19,    11,
+    20,    21,    14,    22,    29,    24,    25,    15,     1,    34,
+     2,    13,    11,    40,     8,     7,    29,    45,    46,    47,
+     6,    29,    33 ]
+
+racc_action_check = [
+    29,    46,    34,    48,    34,    34,    18,    46,    23,    46,
+    46,    48,    48,    29,    48,    48,    23,    23,    14,    23,
+    23,     4,    19,     4,    14,    12,    14,    14,    12,    12,
+    12,    12,    11,    36,    15,    36,    36,    11,     0,    22,
+     0,     8,     5,    30,     3,     2,    38,    39,    40,    45,
+     1,    47,    20 ]
+
+racc_action_pointer = [
+    33,    44,    39,    44,    16,    36,   nil,   nil,    41,   nil,
+   nil,    28,    23,   nil,    12,    22,   nil,   nil,     0,    16,
+    46,   nil,    26,     5,   nil,   nil,   nil,   nil,   nil,    -3,
+    33,   nil,   nil,   nil,   -10,   nil,    21,   nil,    34,    35,
+    44,   nil,   nil,   nil,   nil,    46,    -5,    39,     0,   nil ]
+
+racc_action_default = [
+   -31,   -31,   -31,   -31,    -1,   -31,    -4,    -5,   -31,    -2,
+   -11,   -31,   -31,    50,   -31,   -31,    -3,   -12,   -14,    -7,
+    -6,    -8,   -25,   -15,   -24,   -26,   -17,   -22,   -21,   -27,
+   -31,   -13,    -9,   -10,   -31,   -19,   -31,   -18,   -31,   -31,
+   -31,   -25,   -23,   -20,   -29,   -28,   -31,   -31,   -16,   -30 ]
+
+racc_goto_table = [
+    23,    30,    37,    10,     3,    16,    12,    42,     9,   nil,
+    17,   nil,   nil,   nil,   nil,    43,    31,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,    44,   nil,   nil,    37,   nil,   nil,
+   nil,   nil,    48,    49 ]
+
+racc_goto_check = [
+     7,     8,     9,     6,     1,     5,     4,    10,     1,   nil,
+     6,   nil,   nil,   nil,   nil,     9,     6,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,     8,   nil,   nil,     9,   nil,   nil,
+   nil,   nil,     7,     8 ]
+
+racc_goto_pointer = [
+   nil,     4,   nil,   nil,     1,    -7,    -2,   -14,   -14,   -21,
+   -27 ]
+
+racc_goto_default = [
+   nil,   nil,     4,     5,   nil,   nil,   nil,   nil,   nil,    26,
+    27 ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  1, 18, :_reduce_none,
+  2, 18, :_reduce_none,
+  3, 19, :_reduce_3,
+  2, 20, :_reduce_4,
+  2, 20, :_reduce_5,
+  1, 22, :_reduce_none,
+  1, 22, :_reduce_none,
+  1, 22, :_reduce_none,
+  2, 22, :_reduce_9,
+  2, 22, :_reduce_10,
+  1, 21, :_reduce_11,
+  2, 21, :_reduce_12,
+  3, 21, :_reduce_13,
+  2, 21, :_reduce_14,
+  3, 23, :_reduce_15,
+  6, 23, :_reduce_16,
+  1, 24, :_reduce_17,
+  2, 24, :_reduce_18,
+  2, 24, :_reduce_19,
+  3, 24, :_reduce_20,
+  1, 24, :_reduce_21,
+  1, 26, :_reduce_22,
+  3, 26, :_reduce_23,
+  1, 27, :_reduce_none,
+  1, 27, :_reduce_none,
+  1, 27, :_reduce_none,
+  1, 25, :_reduce_27,
+  3, 25, :_reduce_28,
+  3, 25, :_reduce_29,
+  5, 25, :_reduce_30 ]
+
+racc_reduce_n = 31
+
+racc_shift_n = 50
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :COMMA => 2,
+  "," => 3,
+  "=" => 4,
+  "&" => 5,
+  :IDENT => 6,
+  "$" => 7,
+  "/" => 8,
+  "(" => 9,
+  ")" => 10,
+  :NIL => 11,
+  :DIGITS => 12,
+  "*" => 13,
+  :STRING => 14,
+  :FLOAT => 15,
+  ":" => 16 }
+
+racc_nt_base = 17
+
+racc_use_result_var = true
+
+Racc_arg = [
+  racc_action_table,
+  racc_action_check,
+  racc_action_default,
+  racc_action_pointer,
+  racc_goto_table,
+  racc_goto_check,
+  racc_goto_default,
+  racc_goto_pointer,
+  racc_nt_base,
+  racc_reduce_table,
+  racc_token_table,
+  racc_shift_n,
+  racc_reduce_n,
+  racc_use_result_var ]
+
+Racc_token_to_s_table = [
+  "$end",
+  "error",
+  "COMMA",
+  "\",\"",
+  "\"=\"",
+  "\"&\"",
+  "IDENT",
+  "\"$\"",
+  "\"/\"",
+  "\"(\"",
+  "\")\"",
+  "NIL",
+  "DIGITS",
+  "\"*\"",
+  "STRING",
+  "FLOAT",
+  "\":\"",
+  "$start",
+  "namelist_all",
+  "namelist",
+  "header",
+  "paramlist",
+  "tailer",
+  "paramdef",
+  "rvalues",
+  "array_spec",
+  "abbreb",
+  "constant" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+# reduce 1 omitted
+
+# reduce 2 omitted
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 32)
+  def _reduce_3(val, _values, result)
+     @root[val[0]] = val[1]; @scan.in_namelist = false 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 35)
+  def _reduce_4(val, _values, result)
+     result = val[1].downcase 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 36)
+  def _reduce_5(val, _values, result)
+     result = val[1].downcase 
+    result
+  end
+.,.,
+
+# reduce 6 omitted
+
+# reduce 7 omitted
+
+# reduce 8 omitted
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 42)
+  def _reduce_9(val, _values, result)
+     on_error unless val[1] =~ /\Aend\Z/i 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 43)
+  def _reduce_10(val, _values, result)
+     on_error unless val[1] =~ /\Aend\Z/i 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 46)
+  def _reduce_11(val, _values, result)
+     result = [val[0]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 48)
+  def _reduce_12(val, _values, result)
+     result = val[0] + [val[1]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 50)
+  def _reduce_13(val, _values, result)
+     result = val[0] + [val[2]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 52)
+  def _reduce_14(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 56)
+  def _reduce_15(val, _values, result)
+     result = ParamDef.new(val[0].downcase.intern, nil, val[2]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 58)
+  def _reduce_16(val, _values, result)
+     result = ParamDef.new(val[0].downcase.intern, val[2], val[5]) 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 61)
+  def _reduce_17(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 63)
+  def _reduce_18(val, _values, result)
+     result = val[0] + val[1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 65)
+  def _reduce_19(val, _values, result)
+     result = val[0] + [nil] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 67)
+  def _reduce_20(val, _values, result)
+     result = val[0] + val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 69)
+  def _reduce_21(val, _values, result)
+     result = val[0] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 72)
+  def _reduce_22(val, _values, result)
+     result = [val[0]] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 74)
+  def _reduce_23(val, _values, result)
+     result = [val[2]] * val[0] 
+    result
+  end
+.,.,
+
+# reduce 24 omitted
+
+# reduce 25 omitted
+
+# reduce 26 omitted
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 82)
+  def _reduce_27(val, _values, result)
+     result = [val[0]-1] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 84)
+  def _reduce_28(val, _values, result)
+     result = [(val[0]-1)..(val[2]-1)] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 86)
+  def _reduce_29(val, _values, result)
+     result = [val[0]-1] + val[2] 
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 88)
+  def _reduce_30(val, _values, result)
+     result = [(val[0]-1)..(val[2]-1)] + val[4] 
+    result
+  end
+.,.,
+
+def _reduce_none(val, _values, result)
+  val[0]
+end
+
+end   # class FortranNamelistParser
+
+