fortio-namelist 1.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: eec83d1e80ab4d715f85a1e51d57a233995612e323f2729018756cd773b907e2
+  data.tar.gz: 97f524e2c0cfaae551c79fa48154c58e3ec5c1871f7e3544779fa49bc1333714
+SHA512:
+  metadata.gz: cf29f5ab82c904800ced9c0e4a61672e536fc9ba58c9e30b96b0ed4ffbed6b4b2a9b371a3f5ce6ec5c5fbc9f6af7269a9661aeb45f1f46a5c1a3653316d313f5
+  data.tar.gz: 32101d550a483bd675f2b350f022357d4784ded6bdc944cc92449f6e6c9aaa53e1a41ea26b6816284d2b96777ade58fad0f75275964089d1e87d83a2b44a89ee

data/README.md

@@ -0,0 +1,64 @@
+fortio-namelist
+===============
+
+This is a library for reading and writing data in Fortran namelist format. With this library, you can read Fortran namelist format data from Ruby and convert it to Hash objects, and vice versa. Once the namelist format is read as a Hash object, it is easy to modify the contents or convert it to another format such as JSON, YAML, etc. When converting from a Hash object to namelist format, options can be specified to specify the case of variable names and the format of logical values and floating point numbers. The namelist format is often used as a configuration file to control a calculation program using Fortran. This library can be especially useful for batch processing by sequentially changing the settings of a calculation program. It can also improve the appearance of the namelist output from a Fortran program to make it easier to check. Since the namelist format and JSON (or YAML) can be converted to each other, it is also a good idea to use it to create web interfaces that facilitate the configuration of programs.
+
+Installation
+------------
+
+    gem install fortio-namelist
+
+To use the library in your Ruby script, 
+
+```ruby
+require "fortio-namelist"
+```
+
+Description
+-----------
+
+# Reading namelist data 
+
+    FortIO::Namelist.read(input, name: nil)
+
+# Generate namelist format from Hash object
+    FortIO::Namelist.generate(hash, name: "namelist", array_format: 'stream')
+
+# 複数のデータセットを含むHashからnamelist形式を生成する
+    FortIO::Namelist.dump(root, **format_options)
+
+# namelistデータを読み込み、blockで評価して、結果をnamelistに変換する
+    FortIO::Namelist.filter(input, **format_options) { |hash| ... }
+
+# generate, dump, filterが受け付けるオプション
+
+    array_style:    'index'   
+                    'stream'
+
+    logical_format: 'normal'
+                    'short'
+
+    float_format:   'normal'
+                    'd0'
+
+    alignment:      'compact'
+                    'left'
+                    'right'
+                    Integer
+
+    uppercase:      false
+                    true
+    
+    comma:          false
+                    true
+                    
+    slash:          true
+                    false
+                    
+    indent:         ' '*2
+
+
+    
+
+                    
+  

data/Rakefile

@@ -0,0 +1,12 @@
+GEMSPEC = "fortio-namelist.gemspec"
+
+task :install do
+  spec = eval File.read(GEMSPEC)
+  system %{
+    racc lib/fortio-namelist/fortran_namelist.y
+    gem build #{GEMSPEC}; gem install #{spec.full_name}.gem
+  }
+end
+
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new

data/fortio-namelist.gemspec

@@ -0,0 +1,23 @@
+Gem::Specification::new do |s|
+  version = "1.0.0"
+  files = Dir.glob("**/*") - [ 
+                               Dir.glob("fortio-namelist-*.gem"), 
+                               Dir.glob("test/**/*"),
+                               Dir.glob("work/**/*"),
+                             ].flatten
+
+  s.platform    = Gem::Platform::RUBY
+  s.name        = "fortio-namelist"
+  s.summary     = "A library for reading/writing fortran namelist file"
+  s.description = <<-HERE
+    A library for reading/writing fortran namelist file
+  HERE
+  s.version     = version
+  s.licenses    = ['MIT']
+  s.author      = "Hiroki Motoyoshi"
+  s.email       = ""
+  s.homepage    = 'https://github.com/himotoyoshi/fortio-namelist'
+  s.files       = files
+  s.required_ruby_version = ">= 1.8.1"
+end
+

data/lib/fortio-namelist.rb

@@ -0,0 +1,4 @@
+module FortIO
+end
+
+require "fortio-namelist/fortran_namelist"

data/lib/fortio-namelist/fortran_namelist.rb

@@ -0,0 +1,259 @@
+# ----------------------------------------------------------------------------
+#
+#  fortran_namelist.rb
+#
+#  This file is part of simple-fortio library.
+#
+#  Copyright (C) 2005-2021 Hiroki Motoyoshi
+#
+# ----------------------------------------------------------------------------
+
+require_relative "fortran_namelist.tab"
+
+module FortIO::Namelist
+
+  class Parser
+  
+    ParamDef = Struct.new(:ident, :array_spec, :rval)
+
+    class ParamDef
+
+      def set (hash)
+        case hash[ident]
+        when Array
+          case array_spec
+          when nil
+            if rval.is_a?(Array) and rval.size == 1
+              hash[ident][0] = rval.first
+            else
+              hash[ident].clear
+              hash[ident].push(*rval)
+            end              
+          else
+            if array_spec.first.is_a?(Integer) 
+              if rval.size == 1
+                hash[ident][*array_spec] = rval.first
+              else
+                idx = array_spec.first
+                hash[ident][idx..idx+rval.size-1] = *rval
+              end
+            else
+              hash[ident][*array_spec] = 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
+
+  class Reader
+  
+    def initialize (text)
+      @namelist = FortIO::Namelist::Parser.new.parse(text)
+    end
+  
+    def read (name, out={})
+      name = name.downcase
+      raise "no definition of namelist '#{name}'" unless nml = @namelist[name]
+      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
+
+
+  #
+  # class methods of FortIO::Namelist
+  #
+  
+  #
+  # FortIO::Namelist.dump(hash, name: "namelist")
+  #
+  # hash -> namelist converter
+  #
+  
+  def self.format_element (value, logical_format: 'normal', float_format: 'normal', uppercase: false)
+    case value
+    when String
+      if value !~ /'/
+        return "'" + value + "'"
+      else 
+        return '"' + value.gsub(/"/, '""') + '"'
+      end
+    when Float
+      d = uppercase ? "D" : "d"
+      case float_format
+      when 'normal'
+        return ("%g" % value).sub(/e/, d)
+      when 'd0'
+        value = ("%g" % value)
+        return ( value =~ /e/ ) ? value.sub(/e/, d) : value + d + "0"
+      when 'exp'
+        return ("%e" % value).sub(/e/, d)
+      else        
+        raise "invalid float_format"
+      end
+    when Complex
+      format("(%s,%s)",
+             format_element(value.real, float_format: float_format),
+             format_element(value.imag, float_format: float_format))
+    when TrueClass
+      case logical_format
+      when 'normal'
+        return uppercase ? ".TRUE." : ".true."
+      when 'short'
+        return uppercase ? "T" : "t"
+      else
+        raise "invalid logical_format"
+      end
+    when FalseClass
+      case logical_format
+      when 'normal'
+        return uppercase ? ".FALSE." : ".false."
+      when 'short'
+        return uppercase ? "F" : "f"
+      else
+        raise "invalid logical_format"
+      end
+    else
+      return value.to_s
+    end      
+  end
+  
+  def self.generate (hash, 
+                     name: "namelist", 
+                     array_style: "stream",
+                     alignment: "left",
+                     uppercase: false,
+                     comma: false,
+                     slash: true,
+                     indent: '  ',
+                     **format_options)
+    format_options[:uppercase] = uppercase
+    list = []
+    hash.each do |ident, value|
+      case value
+      when Array
+        case array_style
+        when "index"
+          value.each_with_index do |e, i|
+            if e
+              list << ["#{ident}(#{i+1})", format_element(e, **format_options)]
+            end
+          end
+        when "stream"
+          list << [ident, value.map{ |e| format_element(e, **format_options) }.join(", ")]
+        else
+          raise "unknown array style (should be 'index' or 'stream')"
+        end
+      else
+        list << [ident, format_element(value, **format_options)]
+      end
+    end
+    if uppercase 
+      list = list.map{|ident,value| [ident.upcase, value]}
+      name = name.upcase
+    end
+    if comma
+      nl = ",\n"
+    else
+      nl = "\n"
+    end
+    case alignment
+    when "none"
+      body = list.map { |ident, value|
+        format("%s%s = %s", indent, ident, value)
+      }.join(nl)      
+    when "left"
+      ident_maxlen = list.map{|ident,value| ident.length}.max
+      body = list.map { |ident, value|
+        format("%s%-#{ident_maxlen}s = %s", indent, ident, value)
+      }.join(nl)
+    when "right"
+      ident_maxlen = list.map{|ident,value| ident.length}.max
+      body = list.map { |ident, value|
+        format("%s%#{ident_maxlen}s = %s", indent, ident, value)
+      }.join(nl)
+    when Integer
+      body = list.map { |ident, value|
+        format("%s%-#{alignment-2}s = %s", indent, ident, value)
+      }.join(nl)
+    else
+      raise "unknown enum format (should be 'normal' 'left' 'right' 'stream')"            
+    end
+    if slash
+      tail = "/"
+    else
+      tail = "&end"
+    end
+    return ["&#{name}", body, tail, ""].join("\n")
+  end
+
+  def self.dump (root, **format_options)
+    return root.map { |name, hash| generate(hash, name: name, **format_options) }.join
+  end
+
+  #
+  #  FortIO::Namelist.read(input, name: nil) 
+  #
+  def self.read (input, name: nil)
+    case input
+    when String
+      text = input
+    else
+      text = input.read
+    end
+    if name
+      return FortIO::Namelist::Reader.new(text).read(name)
+    else
+      return FortIO::Namelist::Reader.new(text).read_all()
+    end
+  end
+
+  #
+  #  FortIO::Namelist.filter(input) { |hash| MODIFYING HASH }
+  #
+  #  input : namelist string
+  #  return value : namelist string
+  #
+  def self.filter (input, **format_options)
+    config = read(input)
+    yield config
+    return dump(config, **format_options)
+  end
+
+end
+

data/lib/fortio-namelist/fortran_namelist.tab.rb

@@ -0,0 +1,661 @@
+#
+# DO NOT MODIFY!!!!
+# This file is automatically generated by Racc 1.4.16
+# from Racc grammar file "".
+#
+
+require 'racc/parser.rb'
+
+
+require "strscan"
+require "stringio"
+
+module FortIO
+end
+
+module FortIO::Namelist
+
+  class Scanner 
+  
+    def initialize (text)
+      @s = StringScanner.new(text)
+      @in_namelist = nil
+    end
+
+    attr_accessor :in_namelist
+
+    def debug_info
+      lines  = @s.string.split(/\n/)
+      lineno = @s.string[0...@s.pos].split(/\n/).size
+      info = ""
+      if lineno > 1
+        info << format("   %4i: %s\n", lineno-1, lines[lineno-2])
+      end
+      info << format(">> %4i: %s\n", lineno, lines[lineno-1])
+      if lineno <= lines.size - 1
+        info << format("   %4i: %s\n", lineno+1, lines[lineno])
+      end
+      info
+    end
+
+    def yylex
+      while @s.rest?
+        unless @in_namelist
+          case
+          when @s.scan(/\A([\$&])/)              ### {$|&}
+            @in_namelist = "dummy"
+            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+[a-z_]\w*/i)         ### STRING
+            return [
+              :STRING,
+              @s[0]
+            ]
+          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[ \t]+/)
+            while @s.scan(/\A\n[ \t]*/) or @s.scan(/\A\![^\n]*/)
+              ### skip comment
+            end
+            if @s.scan(/\A\&[ \t]*\n[ \t]*\&/)  ### & &
+              return [
+                ',',
+                nil
+              ]
+            elsif @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\&[ \t]*\n[ \t]*\&/)      ### & &
+            next            
+          when @s.scan(/\A[\$&\/=\(\):*]/)        ### {$|&|/|,|=|(|)|:|*}
+            return [
+              @s[0], 
+              nil
+            ]
+          when @s.scan(/\A_\w*/i)                 ### STRING
+            return [
+              :STRING,
+              @s[0]
+            ]
+          when @s.scan(/\A\.t.*?\./i)             ### LOGICAL true
+            return [                 
+              :LOGICAL,
+              true,
+            ]
+          when @s.scan(/\A\.f.*?\./i)             ### LOGICAL false
+            return [
+              :LOGICAL,
+              false,
+            ]
+          when @s.match?(/\At[^\w]/i)             ### LOGICAL true
+            @s.scan(/\At/i)
+            ms = @s[0]
+            if @s.match?(/\A[ \t]*=/)
+              return [
+                :IDENT,
+                ms
+              ]
+            else
+              return [                 
+                :LOGICAL,
+                true,
+              ]
+            end
+          when @s.match?(/\Af[^\w]/i)             ### LOGICAL false
+            @s.scan(/\Af/i)
+            ms = @s[0]
+            if @s.match?(/\A[ \t]*=/)
+              return [
+                :IDENT,
+                ms
+              ]
+            else
+              return [                 
+                :LOGICAL,
+                false,
+              ]
+            end
+          when @s.scan(/\A[a-z]\w*/i)             ### IDENT or LOGICAL
+            return [
+              :IDENT,
+              @s[0]
+            ]
+          when @s.scan(/\A\n/)                    ### newline
+            return [
+              :NL,
+              nil
+            ]
+            next
+          when @s.scan(/\A[ \t]+/)                ### blank
+            next
+          when @s.scan(/\A![^\n]*?\n/)            ### comment
+            next
+          else
+            @s.rest =~ /\A(.*)$/
+            raise "namelist parse error ('#{$1}')\n" + debug_info
+          end
+        end
+      end
+    end
+
+  end
+end
+
+module FortIO
+  module Namelist
+    class Parser < Racc::Parser
+
+module_eval(<<'...end fortran_namelist.y/module_eval...', 'fortran_namelist.y', 115)
+
+  def parse (str)
+    @scan = FortIO::Namelist::Scanner.new(str)
+    @root = {}
+    begin
+      @yydebug = true
+      do_parse
+    rescue Racc::ParseError => err
+      message = ""
+      message << "namelist " << err.message[1..-1] 
+      if @scan.in_namelist and @scan.in_namelist != "dummy"
+        message << " in &#{@scan.in_namelist} ... &end"
+      end
+      message << "\n"
+      message << @scan.debug_info
+      raise RuntimeError, message
+    end
+    return @root
+  end
+
+  def next_token
+    return @scan.yylex
+  end
+
+...end fortran_namelist.y/module_eval...
+##### State transition tables begin ###
+
+racc_action_table = [
+    19,    20,    30,    49,    54,    40,    31,    50,    27,    38,
+    48,    33,    40,    34,    35,    36,    45,    44,    53,     4,
+     5,    24,    23,    46,    38,    45,    33,    25,    34,    35,
+    36,    59,    46,    38,    60,    33,    61,    34,    35,    36,
+    45,    44,    49,     4,     5,    40,    50,    46,    38,    17,
+    33,    16,    34,    35,    36,    45,    44,    65,    66,     7,
+    52,   nil,    46,    38,   nil,    33,    30,    34,    35,    36,
+    31,   nil,    42,    38,   nil,    33,    30,    34,    35,    36,
+    31,   nil,    42,    38,   nil,    33,    30,    34,    35,    36,
+    31,   nil,    42,    38,   nil,    33,    30,    34,    35,    36,
+    31,   nil,    42,    38,   nil,    33,   nil,    34,    35,    36,
+    19,    20,   nil,   nil,     4,     5,    15,    12,    38,   nil,
+    33,   nil,    34,    35,    36,    38,   nil,    58,   nil,    34,
+    35,    36,    38,   nil,    33,   nil,    34,    35,    36,    11,
+   nil,   nil,     4,     5,    15,    12 ]
+
+racc_action_check = [
+    24,    24,    24,    38,    40,    65,    24,    38,    24,    24,
+    33,    24,    25,    24,    24,    24,    64,    64,    40,     0,
+     0,    15,    13,    64,    64,    47,    64,    15,    64,    64,
+    64,    51,    47,    47,    52,    47,    53,    47,    47,    47,
+    28,    28,    59,     2,     2,    54,    59,    28,    28,     7,
+    28,     6,    28,    28,    28,    41,    41,    61,    63,     1,
+    39,   nil,    41,    41,   nil,    41,    27,    41,    41,    41,
+    27,   nil,    27,    27,   nil,    27,    30,    27,    27,    27,
+    30,   nil,    30,    30,   nil,    30,    42,    30,    30,    30,
+    42,   nil,    42,    42,   nil,    42,    60,    42,    42,    42,
+    60,   nil,    60,    60,   nil,    60,   nil,    60,    60,    60,
+    10,    10,   nil,   nil,    10,    10,    10,    10,    44,   nil,
+    44,   nil,    44,    44,    44,    48,   nil,    48,   nil,    48,
+    48,    48,    45,   nil,    45,   nil,    45,    45,    45,     3,
+   nil,   nil,     3,     3,     3,     3 ]
+
+racc_action_pointer = [
+    13,    59,    37,   136,   nil,   nil,    43,    49,   nil,   nil,
+   108,   nil,   nil,    14,   nil,    16,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,   nil,    -2,    -1,   nil,    62,    37,   nil,
+    72,   nil,   nil,    -4,   nil,   nil,   nil,   nil,   -10,    48,
+     0,    52,    82,   nil,   107,   121,   nil,    22,   114,   nil,
+   nil,    27,    29,    23,    32,   nil,   nil,   nil,   nil,    29,
+    92,    53,   nil,    46,    13,    -8,   nil,   nil ]
+
+racc_action_default = [
+    -1,   -44,    -1,   -44,    -6,    -7,   -44,   -44,    -3,    -4,
+   -44,    -9,   -10,   -44,   -14,   -44,    -8,    68,    -5,   -12,
+   -13,   -15,   -16,   -11,   -44,   -44,   -17,   -18,   -19,   -21,
+   -44,   -29,   -30,   -34,   -32,   -33,   -35,   -36,   -44,   -44,
+   -40,   -26,   -44,   -22,   -44,   -28,   -25,   -27,   -44,   -37,
+   -38,   -44,   -44,   -44,   -44,   -23,   -24,   -31,   -34,   -44,
+   -44,   -41,   -42,   -44,   -20,   -44,   -39,   -43 ]
+
+racc_goto_table = [
+    39,    43,    28,    51,    14,    22,     9,    57,    47,    13,
+     1,    21,     8,    18,    43,    10,    13,    55,    56,    26,
+    43,   nil,   nil,   nil,    63,   nil,   nil,   nil,   nil,    62,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,    43,    64,   nil,
+    67 ]
+
+racc_goto_check = [
+    10,    11,     9,    14,     8,     7,     4,    12,     9,     6,
+     1,     8,     1,     4,    11,     5,     6,    11,    11,     7,
+    11,   nil,   nil,   nil,    14,   nil,   nil,   nil,   nil,    10,
+   nil,   nil,   nil,   nil,   nil,   nil,   nil,    11,     9,   nil,
+    10 ]
+
+racc_goto_pointer = [
+   nil,    10,   nil,   nil,     3,    12,     6,    -5,     1,   -22,
+   -25,   -27,   -41,   nil,   -35 ]
+
+racc_goto_default = [
+   nil,   nil,     2,     3,   nil,   nil,     6,   nil,   nil,    41,
+   nil,    29,    32,    37,   nil ]
+
+racc_reduce_table = [
+  0, 0, :racc_error,
+  0, 20, :_reduce_none,
+  1, 20, :_reduce_none,
+  2, 20, :_reduce_none,
+  2, 21, :_reduce_4,
+  3, 21, :_reduce_5,
+  1, 25, :_reduce_none,
+  1, 25, :_reduce_none,
+  2, 22, :_reduce_8,
+  2, 22, :_reduce_none,
+  1, 23, :_reduce_none,
+  2, 23, :_reduce_11,
+  1, 26, :_reduce_none,
+  1, 26, :_reduce_none,
+  1, 24, :_reduce_14,
+  2, 24, :_reduce_15,
+  2, 24, :_reduce_16,
+  3, 27, :_reduce_17,
+  3, 27, :_reduce_18,
+  3, 27, :_reduce_19,
+  6, 27, :_reduce_20,
+  1, 28, :_reduce_21,
+  2, 28, :_reduce_22,
+  3, 28, :_reduce_23,
+  3, 28, :_reduce_24,
+  2, 28, :_reduce_25,
+  2, 28, :_reduce_26,
+  2, 28, :_reduce_27,
+  2, 28, :_reduce_28,
+  1, 28, :_reduce_29,
+  1, 30, :_reduce_30,
+  3, 30, :_reduce_31,
+  1, 31, :_reduce_none,
+  1, 31, :_reduce_none,
+  1, 31, :_reduce_none,
+  1, 31, :_reduce_none,
+  1, 31, :_reduce_none,
+  1, 33, :_reduce_none,
+  1, 33, :_reduce_none,
+  5, 32, :_reduce_39,
+  1, 29, :_reduce_40,
+  3, 29, :_reduce_41,
+  3, 29, :_reduce_42,
+  5, 29, :_reduce_43 ]
+
+racc_reduce_n = 44
+
+racc_shift_n = 68
+
+racc_token_table = {
+  false => 0,
+  :error => 1,
+  :COMMA => 2,
+  :NL => 3,
+  "," => 4,
+  "=" => 5,
+  "&" => 6,
+  "$" => 7,
+  :IDENT => 8,
+  "/" => 9,
+  :NIL => 10,
+  "(" => 11,
+  ")" => 12,
+  :DIGITS => 13,
+  "*" => 14,
+  :STRING => 15,
+  :LOGICAL => 16,
+  :FLOAT => 17,
+  ":" => 18 }
+
+racc_nt_base = 19
+
+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",
+  "NL",
+  "\",\"",
+  "\"=\"",
+  "\"&\"",
+  "\"$\"",
+  "IDENT",
+  "\"/\"",
+  "NIL",
+  "\"(\"",
+  "\")\"",
+  "DIGITS",
+  "\"*\"",
+  "STRING",
+  "LOGICAL",
+  "FLOAT",
+  "\":\"",
+  "$start",
+  "namelist_all",
+  "namelist",
+  "header",
+  "tailer",
+  "paramlist",
+  "prefix",
+  "separator",
+  "paramdef",
+  "rvalues",
+  "array_spec",
+  "abbreb",
+  "constant",
+  "complex",
+  "real" ]
+
+Racc_debug_parser = false
+
+##### State transition tables end #####
+
+# reduce 0 omitted
+
+# reduce 1 omitted
+
+# reduce 2 omitted
+
+# reduce 3 omitted
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 31)
+  def _reduce_4(val, _values, result)
+     @root[val[0]] = []; @scan.in_namelist = nil
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 33)
+  def _reduce_5(val, _values, result)
+     @root[val[0]] = val[1]; @scan.in_namelist = nil
+    result
+  end
+.,.,
+
+# reduce 6 omitted
+
+# reduce 7 omitted
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 39)
+  def _reduce_8(val, _values, result)
+     result = val[1].downcase; @scan.in_namelist = val[1].downcase
+    result
+  end
+.,.,
+
+# reduce 9 omitted
+
+# reduce 10 omitted
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 44)
+  def _reduce_11(val, _values, result)
+     raise Racc::ParseError, "\nparse error (&)" unless val[1] =~ /\Aend\Z/i
+    result
+  end
+.,.,
+
+# reduce 12 omitted
+
+# reduce 13 omitted
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 50)
+  def _reduce_14(val, _values, result)
+     result = [val[0]]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 52)
+  def _reduce_15(val, _values, result)
+     result = val[0] + [val[1]]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 54)
+  def _reduce_16(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 58)
+  def _reduce_17(val, _values, result)
+     result = ParamDef.new(val[0].downcase, nil, "")
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 60)
+  def _reduce_18(val, _values, result)
+     result = ParamDef.new(val[0].downcase, nil, "")
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 62)
+  def _reduce_19(val, _values, result)
+     result = ParamDef.new(val[0].downcase, nil, val[2])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 64)
+  def _reduce_20(val, _values, result)
+     result = ParamDef.new(val[0].downcase, val[2], val[5])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 67)
+  def _reduce_21(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 69)
+  def _reduce_22(val, _values, result)
+     result = val[0] + val[1]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 71)
+  def _reduce_23(val, _values, result)
+     result = val[0] + val[2]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 73)
+  def _reduce_24(val, _values, result)
+     result = val[0] + val[2]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 75)
+  def _reduce_25(val, _values, result)
+     result = val[0] + [nil]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 77)
+  def _reduce_26(val, _values, result)
+     result = [nil] + val[1]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 79)
+  def _reduce_27(val, _values, result)
+     result = [nil] + val[1]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 81)
+  def _reduce_28(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 83)
+  def _reduce_29(val, _values, result)
+     result = val[0]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 86)
+  def _reduce_30(val, _values, result)
+     result = [val[0]]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 88)
+  def _reduce_31(val, _values, result)
+     result = [val[2]] * val[0]
+    result
+  end
+.,.,
+
+# reduce 32 omitted
+
+# reduce 33 omitted
+
+# reduce 34 omitted
+
+# reduce 35 omitted
+
+# reduce 36 omitted
+
+# reduce 37 omitted
+
+# reduce 38 omitted
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 100)
+  def _reduce_39(val, _values, result)
+     result = Complex(val[1],val[3])
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 103)
+  def _reduce_40(val, _values, result)
+     result = [val[0]-1]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 105)
+  def _reduce_41(val, _values, result)
+     result = [(val[0]-1)..(val[2]-1)]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 107)
+  def _reduce_42(val, _values, result)
+     result = [val[0]-1] + val[2]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 109)
+  def _reduce_43(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 Parser
+  end   # module Namelist
+end   # module FortIO
+
+