fortio-namelist 1.0.0 → 1.4.0

data/fortio-namelist.gemspec

@@ -1,5 +1,5 @@
 Gem::Specification::new do |s|
-  version = "1.0.0"
+  version = "1.4.0"
   files = Dir.glob("**/*") - [ 
                                Dir.glob("fortio-namelist-*.gem"), 
                                Dir.glob("test/**/*"),
@@ -10,14 +10,17 @@ Gem::Specification::new do |s|
   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
+  This is a Ruby library for reading and writing Fortran's namelist. 
+  This library allows you to read a namelist string as a Hash object, 
+  or dump a Hash object to a namelist string.
   HERE
   s.version     = version
-  s.licenses    = ['MIT']
+  s.license     = '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"
+  s.required_ruby_version = ">= 2.4.0"
+  s.add_development_dependency "racc", "~> 1.5"
 end
 

data/lib/fortio-namelist/fortran_namelist.rb

@@ -72,24 +72,16 @@ module FortIO::Namelist
       @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]
+    def parse (group, out={})
+      group = group.downcase
+      raise "no definition of namelist group '#{group}'" \
+                                        unless nml = @namelist[group]
       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
@@ -100,12 +92,19 @@ module FortIO::Namelist
   #
   
   #
-  # FortIO::Namelist.dump(hash, name: "namelist")
+  # FortIO::Namelist.dump(hash, group: "namelist")
   #
   # hash -> namelist converter
   #
   
-  def self.format_element (value, logical_format: 'normal', float_format: 'normal', uppercase: false)
+  def self.float_to_string (value, d:)
+    return value.to_s.sub(/e/, d)
+  end
+  
+  def self.format_element (value, 
+                           logical_format: 'normal', 
+                           float_format: 'normal', 
+                           uppercase: false)
     case value
     when String
       if value !~ /'/
@@ -117,12 +116,13 @@ module FortIO::Namelist
       d = uppercase ? "D" : "d"
       case float_format
       when 'normal'
-        return ("%g" % value).sub(/e/, d)
+        float_to_string(value, d: d)
       when 'd0'
-        value = ("%g" % value)
-        return ( value =~ /e/ ) ? value.sub(/e/, d) : value + d + "0"
+        value = float_to_string(value, d: d)
+        return ( value =~ /#{d}/ ) ? value : value + d + "0"
       when 'exp'
-        return ("%e" % value).sub(/e/, d)
+        num,exp = ("%.16e" % value).split(/e/)
+        return ("%.16g" % num) + d + exp
       else        
         raise "invalid float_format"
       end
@@ -154,12 +154,12 @@ module FortIO::Namelist
   end
   
   def self.generate (hash, 
-                     name: "namelist", 
+                     group: "group", 
                      array_style: "stream",
                      alignment: "left",
                      uppercase: false,
-                     comma: false,
-                     slash: true,
+                     separator: "comma",
+                     group_end: "/",
                      indent: '  ',
                      **format_options)
     format_options[:uppercase] = uppercase
@@ -177,7 +177,7 @@ module FortIO::Namelist
         when "stream"
           list << [ident, value.map{ |e| format_element(e, **format_options) }.join(", ")]
         else
-          raise "unknown array style (should be 'index' or 'stream')"
+          raise "invalid keyword argument `array_style` (should be 'index', 'stream')"  
         end
       else
         list << [ident, format_element(value, **format_options)]
@@ -185,62 +185,105 @@ module FortIO::Namelist
     end
     if uppercase 
       list = list.map{|ident,value| [ident.upcase, value]}
-      name = name.upcase
+      group = group.upcase
     end
-    if comma
+    case separator
+    when "comma", ","
       nl = ",\n"
-    else
+    when "nl", "\n"
       nl = "\n"
+    else
+      raise "invalid keyword argument `separator` (should be 'comma', ',', 'nl', '\n')"
     end
     case alignment
+    when /\Astream(:(\d+))?/
+      maxlen = $2 ? $2.to_i : 79 - indent.size
+      elements = list.map { |ident, value|
+        format("%s = %s", ident, value)
+      }
+      body = ""
+      line = []
+      len  = indent.size
+      elements.each do |e|
+        if len + e.length >= maxlen
+          body += indent + line.join(", ") + nl
+          line = []
+          len  = indent.size
+        end
+        line << e
+        len += e.length + 2
+      end
+      body += indent + line.join(", ") + nl unless line.empty?
+      body = body.chomp
     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
+    when /\Aleft(:(\d+))?/
+      if $2
+        ident_maxlen = $2.to_i - indent.size
+      else
+        ident_maxlen = list.map{|ident,value| ident.length}.max
+      end
       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
+    when /\Aright(:(\d+))?/
+      if $2
+        ident_maxlen = $2.to_i - indent.size
+      else
+        ident_maxlen = list.map{|ident,value| ident.length}.max
+      end
       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')"            
+      raise "invalid keyword argument `alignment` (should be 'normal' 'left' 'right' 'stream')"  
     end
-    if slash
+    case group_end
+    when "slash", "/"
       tail = "/"
-    else
+    when "end"
       tail = "&end"
+    else
+      raise "invalid keyword argument `group_end` (should be 'slash', '/', 'end')"
     end
-    return ["&#{name}", body, tail, ""].join("\n")
+    return ["&#{group}", body, tail, ""].join("\n")
   end
 
   def self.dump (root, **format_options)
-    return root.map { |name, hash| generate(hash, name: name, **format_options) }.join
+    return root.map { |group, hash| generate(hash, group: group, **format_options) }.join
   end
 
   #
   #  FortIO::Namelist.read(input, name: nil) 
   #
-  def self.read (input, name: nil)
+  def self.parse (input, group: nil)
     case input
     when String
       text = input
     else
       text = input.read
     end
-    if name
-      return FortIO::Namelist::Reader.new(text).read(name)
+    reader = FortIO::Namelist::Reader.new(text)
+    case group
+    when Array
+      groups = group.map{|s| s.intern }
+    when String, Symbol
+      groups = [group].map{|s| s.intern }
+    when nil
+      groups = reader.namelist.keys
     else
-      return FortIO::Namelist::Reader.new(text).read_all()
+      raise "invalid keyword arugment `group` '#{group.inspect}'"
     end
+    return groups.each_with_object({}) { |group, root|
+      root[group] = {}
+      reader.parse(group, root[group])
+    }    
+  end
+  
+  def self.read (input, group: nil)
+    parse(input, group: group)
   end
 
   #
@@ -250,7 +293,7 @@ module FortIO::Namelist
   #  return value : namelist string
   #
   def self.filter (input, **format_options)
-    config = read(input)
+    config = parse(input)
     yield config
     return dump(config, **format_options)
   end

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

@@ -53,6 +53,21 @@ module FortIO::Namelist
           end       
         else
           case
+          when @s.scan(/\A\(/)
+            return [
+              '(',
+              nil
+            ]
+          when @s.scan(/\A\)/)
+            return [
+              ')',
+              nil
+            ]
+          when @s.scan(/\A\:/)
+            return [
+              ':',
+              nil
+            ]
           when @s.scan(/\A[+-]?(\d+)\.(\d+)?([ED][+-]?(\d+))?/i) ### float
             return [                              ### 1.2E+3, 1.E+3, 1.2E3
               :FLOAT,                             ### 1.2, 1.
@@ -68,9 +83,9 @@ module FortIO::Namelist
               :FLOAT, 
               @s[0].sub(/D/i,'e').to_f
             ]
-          when @s.scan(/\A\d+[a-z_]\w*/i)         ### STRING
+          when @s.scan(/\A\d+[a-z_]\w*/i)         ### STRING-Like
             return [
-              :STRING,
+              :STRINGLIKE,
               @s[0]
             ]
           when @s.scan(/\A[\-\+]?\d+/)            ### digits
@@ -98,6 +113,11 @@ module FortIO::Namelist
                 ',',
                 nil
               ]
+            elsif @s.match?(/\A[a-z]\w*\s*,/i) 
+              return [
+                ',', 
+                nil
+              ]
             elsif @s.match?(/\A[a-z]\w*/i) or @s.match?(/\A[\&\$\/\!]/)
               return [
                 :COMMA, 
@@ -121,17 +141,17 @@ module FortIO::Namelist
               @s[0], 
               nil
             ]
-          when @s.scan(/\A_\w*/i)                 ### STRING
+          when @s.scan(/\A_\w*/i)                 ### STRING-Like
             return [
-              :STRING,
+              :STRINGLIKE,
               @s[0]
             ]
-          when @s.scan(/\A\.t.*?\./i)             ### LOGICAL true
+          when @s.scan(/\A\.t[\w\d_]*\.?/i)             ### LOGICAL true
             return [                 
               :LOGICAL,
               true,
             ]
-          when @s.scan(/\A\.f.*?\./i)             ### LOGICAL false
+          when @s.scan(/\A\.f[\w\d_]*\.?/i)             ### LOGICAL false
             return [
               :LOGICAL,
               false,
@@ -194,7 +214,7 @@ module FortIO
   module Namelist
     class Parser < Racc::Parser
 
-module_eval(<<'...end fortran_namelist.y/module_eval...', 'fortran_namelist.y', 115)
+module_eval(<<'...end fortran_namelist.y/module_eval...', 'fortran_namelist.y', 128)
 
   def parse (str)
     @scan = FortIO::Namelist::Scanner.new(str)
@@ -223,151 +243,151 @@ module_eval(<<'...end fortran_namelist.y/module_eval...', 'fortran_namelist.y',
 ##### 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 ]
+    65,    51,    63,    14,    48,     4,     5,    21,    47,    62,
+    18,    39,    15,    41,    66,    42,    43,    46,    49,    48,
+    34,    13,    13,    47,    26,    30,    39,    24,    41,    47,
+    42,    43,    46,    49,    41,    51,    42,    43,    46,    47,
+     4,     5,    56,    55,    41,    47,    42,    43,    46,    13,
+    59,    13,    42,    43,    46,     4,     5,    21,    59,    13,
+    18,    29,    46,    30,    59,    24,    23,    24,    46,    33,
+     7,    57,     4,     5,    10,    13,    10,    13,    58,    61,
+    24,    24,    68,    70,    51,    74,    75 ]
 
 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 ]
+    57,    74,    51,     6,    69,    25,    25,    25,    69,    51,
+    25,    69,     7,    69,    57,    69,    69,    69,    69,    28,
+    28,    61,    10,    28,    19,    61,    28,    22,    28,    55,
+    28,    28,    28,    28,    55,    29,    55,    55,    55,    36,
+     0,     0,    36,    36,    36,    58,    36,    36,    36,    30,
+    58,    33,    58,    58,    58,     9,     9,     9,    47,    21,
+     9,    21,    47,    21,    68,    27,    11,    11,    68,    27,
+     1,    37,     1,     1,    16,    16,     3,     3,    41,    50,
+    52,    53,    60,    62,    63,    70,    72 ]
 
 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 ]
+    38,    70,   nil,    71,   nil,   nil,    -1,    12,   nil,    53,
+    16,    61,   nil,   nil,   nil,   nil,    69,   nil,   nil,    20,
+   nil,    53,    21,   nil,   nil,     3,   nil,    59,    15,    22,
+    43,   nil,   nil,    45,   nil,   nil,    31,    59,   nil,   nil,
+   nil,    64,   nil,   nil,   nil,   nil,   nil,    45,   nil,   nil,
+    70,   -10,    74,    75,   nil,    21,   nil,    -4,    37,   nil,
+    70,    15,    70,    71,   nil,   nil,   nil,   nil,    51,     0,
+    73,   nil,    77,   nil,   -12,   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 ]
+   -51,   -51,    -2,   -15,    -5,    -6,   -51,   -51,    -1,   -51,
+    -8,   -11,   -12,   -13,    -7,    77,   -15,    -4,   -16,   -51,
+   -18,   -51,    -9,   -10,   -14,   -51,   -17,   -51,   -51,   -51,
+   -23,    -3,   -19,   -25,   -20,   -21,   -27,   -28,   -29,   -30,
+   -34,   -40,   -36,   -37,   -38,   -39,   -41,   -51,   -43,   -44,
+   -51,   -47,   -24,   -26,   -31,   -51,   -33,   -51,   -51,   -40,
+   -51,   -51,   -51,   -51,   -32,   -45,   -46,   -35,   -51,   -51,
+   -48,   -49,   -51,   -22,   -51,   -42,   -50 ]
 
 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 ]
+    22,    50,    35,    60,    28,    20,    54,     2,     8,     9,
+    17,    27,    19,     1,    16,    67,   nil,   nil,   nil,   nil,
+    52,    32,    25,    53,    72,    64,    31,   nil,    19,   nil,
+   nil,   nil,   nil,   nil,   nil,    71,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,    73,    69,   nil,    76,   nil,   nil,   nil,
+   nil,    27 ]
 
 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 ]
+     8,    13,    12,    18,    11,    10,    16,     2,     2,     4,
+     6,     8,     7,     1,     5,    17,   nil,   nil,   nil,   nil,
+     8,    10,     4,     8,    18,    16,     6,   nil,     7,   nil,
+   nil,   nil,   nil,   nil,   nil,    13,   nil,   nil,   nil,   nil,
+   nil,   nil,   nil,    12,    11,   nil,    13,   nil,   nil,   nil,
+   nil,     8 ]
 
 racc_goto_pointer = [
-   nil,    10,   nil,   nil,     3,    12,     6,    -5,     1,   -22,
-   -25,   -27,   -41,   nil,   -35 ]
+   nil,    13,     7,   nil,     6,     5,     1,     3,   -10,   nil,
+    -4,   -17,   -26,   -28,   nil,   nil,   -30,   -43,   -44,   nil ]
 
 racc_goto_default = [
-   nil,   nil,     2,     3,   nil,   nil,     6,   nil,   nil,    41,
-   nil,    29,    32,    37,   nil ]
+   nil,   nil,   nil,     3,   nil,   nil,   nil,     6,    11,    12,
+   nil,   nil,   nil,   nil,    36,    37,    38,    40,    44,    45 ]
 
 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,
+  2, 21, :_reduce_none,
+  1, 21, :_reduce_none,
+  5, 22, :_reduce_3,
+  3, 22, :_reduce_4,
+  1, 27, :_reduce_none,
+  1, 27, :_reduce_none,
+  2, 23, :_reduce_7,
+  1, 24, :_reduce_none,
+  2, 24, :_reduce_none,
+  2, 24, :_reduce_none,
+  1, 24, :_reduce_none,
+  1, 24, :_reduce_none,
+  1, 28, :_reduce_none,
+  2, 28, :_reduce_none,
+  0, 29, :_reduce_none,
   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,
+  2, 26, :_reduce_17,
+  1, 25, :_reduce_18,
+  3, 25, :_reduce_19,
+  3, 30, :_reduce_20,
+  3, 30, :_reduce_21,
+  6, 30, :_reduce_22,
   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
+  2, 31, :_reduce_none,
+  2, 31, :_reduce_none,
+  3, 31, :_reduce_none,
+  1, 32, :_reduce_none,
+  1, 32, :_reduce_none,
+  1, 34, :_reduce_none,
+  1, 34, :_reduce_30,
+  2, 34, :_reduce_31,
+  3, 34, :_reduce_32,
+  2, 34, :_reduce_33,
+  1, 36, :_reduce_34,
+  3, 36, :_reduce_35,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 38, :_reduce_none,
+  1, 38, :_reduce_none,
+  5, 39, :_reduce_42,
+  1, 35, :_reduce_43,
+  1, 35, :_reduce_44,
+  3, 35, :_reduce_45,
+  3, 35, :_reduce_46,
+  1, 33, :_reduce_47,
+  3, 33, :_reduce_48,
+  3, 33, :_reduce_49,
+  5, 33, :_reduce_50 ]
+
+racc_reduce_n = 51
+
+racc_shift_n = 77
 
 racc_token_table = {
   false => 0,
   :error => 1,
-  :COMMA => 2,
-  :NL => 3,
-  "," => 4,
-  "=" => 5,
-  "&" => 6,
-  "$" => 7,
-  :IDENT => 8,
-  "/" => 9,
-  :NIL => 10,
-  "(" => 11,
-  ")" => 12,
+  "&" => 2,
+  "$" => 3,
+  :IDENT => 4,
+  :COMMA => 5,
+  :NL => 6,
+  "/" => 7,
+  "(" => 8,
+  ")" => 9,
+  "=" => 10,
+  :NIL => 11,
+  "," => 12,
   :DIGITS => 13,
   "*" => 14,
   :STRING => 15,
   :LOGICAL => 16,
   :FLOAT => 17,
-  ":" => 18 }
+  :STRINGLIKE => 18,
+  ":" => 19 }
 
-racc_nt_base = 19
+racc_nt_base = 20
 
 racc_use_result_var = true
 
@@ -390,38 +410,44 @@ Racc_arg = [
 Racc_token_to_s_table = [
   "$end",
   "error",
-  "COMMA",
-  "NL",
-  "\",\"",
-  "\"=\"",
   "\"&\"",
   "\"$\"",
   "IDENT",
+  "COMMA",
+  "NL",
   "\"/\"",
-  "NIL",
   "\"(\"",
   "\")\"",
+  "\"=\"",
+  "NIL",
+  "\",\"",
   "DIGITS",
   "\"*\"",
   "STRING",
   "LOGICAL",
   "FLOAT",
+  "STRINGLIKE",
   "\":\"",
   "$start",
-  "namelist_all",
   "namelist",
-  "header",
-  "tailer",
-  "paramlist",
-  "prefix",
+  "group",
+  "group_header",
   "separator",
-  "paramdef",
+  "varlist",
+  "group_end",
+  "group_prefix",
+  "nls",
+  "blank",
+  "vardef",
+  "equal",
   "rvalues",
   "array_spec",
-  "abbreb",
+  "rlist",
+  "ident_list",
+  "element",
   "constant",
-  "complex",
-  "real" ]
+  "real",
+  "complex" ]
 
 Racc_debug_parser = false
 
@@ -433,218 +459,217 @@ Racc_debug_parser = false
 
 # 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
+module_eval(<<'.,.,', 'fortran_namelist.y', 24)
+  def _reduce_3(val, _values, result)
+     @root[val[0]] = val[2]; @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
+module_eval(<<'.,.,', 'fortran_namelist.y', 26)
+  def _reduce_4(val, _values, result)
+     @root[val[0]] = []; @scan.in_namelist = nil
     result
   end
 .,.,
 
-# reduce 6 omitted
+# reduce 5 omitted
 
-# reduce 7 omitted
+# reduce 6 omitted
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 39)
-  def _reduce_8(val, _values, result)
-     result = val[1].downcase; @scan.in_namelist = val[1].downcase
+module_eval(<<'.,.,', 'fortran_namelist.y', 34)
+  def _reduce_7(val, _values, result)
+     result = val[1].downcase.intern; @scan.in_namelist = val[1].downcase.intern
     result
   end
 .,.,
 
+# reduce 8 omitted
+
 # 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 11 omitted
 
 # reduce 12 omitted
 
 # reduce 13 omitted
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 50)
-  def _reduce_14(val, _values, result)
-     result = [val[0]]
-    result
-  end
-.,.,
+# reduce 14 omitted
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 52)
-  def _reduce_15(val, _values, result)
-     result = val[0] + [val[1]]
-    result
-  end
-.,.,
+# reduce 15 omitted
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 54)
-  def _reduce_16(val, _values, result)
-     result = val[0]
-    result
-  end
-.,.,
+# reduce 16 omitted
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 58)
+module_eval(<<'.,.,', 'fortran_namelist.y', 52)
   def _reduce_17(val, _values, result)
-     result = ParamDef.new(val[0].downcase, nil, "")
+     raise Racc::ParseError, "\nparse error (&)" unless val[1] =~ /\Aend\Z/i
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 60)
+module_eval(<<'.,.,', 'fortran_namelist.y', 55)
   def _reduce_18(val, _values, result)
-     result = ParamDef.new(val[0].downcase, nil, "")
+     result = [val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 62)
+module_eval(<<'.,.,', 'fortran_namelist.y', 57)
   def _reduce_19(val, _values, result)
-     result = ParamDef.new(val[0].downcase, nil, val[2])
+     result = val[0] + [val[2]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 64)
+module_eval(<<'.,.,', 'fortran_namelist.y', 61)
   def _reduce_20(val, _values, result)
-     result = ParamDef.new(val[0].downcase, val[2], val[5])
+     result = ParamDef.new(val[0].downcase.intern, nil, "")
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 67)
+module_eval(<<'.,.,', 'fortran_namelist.y', 63)
   def _reduce_21(val, _values, result)
-     result = val[0]
+     result = ParamDef.new(val[0].downcase.intern, nil, val[2])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 69)
+module_eval(<<'.,.,', 'fortran_namelist.y', 65)
   def _reduce_22(val, _values, result)
-     result = val[0] + val[1]
+     result = ParamDef.new(val[0].downcase.intern, val[2], val[5])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 71)
-  def _reduce_23(val, _values, result)
-     result = val[0] + val[2]
+# reduce 23 omitted
+
+# reduce 24 omitted
+
+# reduce 25 omitted
+
+# reduce 26 omitted
+
+# reduce 27 omitted
+
+# reduce 28 omitted
+
+# reduce 29 omitted
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 79)
+  def _reduce_30(val, _values, result)
+     result = [nil, nil]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 73)
-  def _reduce_24(val, _values, result)
+module_eval(<<'.,.,', 'fortran_namelist.y', 81)
+  def _reduce_31(val, _values, result)
+     result = val[0] + val[1]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 83)
+  def _reduce_32(val, _values, result)
      result = val[0] + val[2]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 75)
-  def _reduce_25(val, _values, result)
+module_eval(<<'.,.,', 'fortran_namelist.y', 85)
+  def _reduce_33(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]
+module_eval(<<'.,.,', 'fortran_namelist.y', 88)
+  def _reduce_34(val, _values, result)
+     result = [val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 79)
-  def _reduce_27(val, _values, result)
-     result = [nil] + val[1]
+module_eval(<<'.,.,', 'fortran_namelist.y', 90)
+  def _reduce_35(val, _values, result)
+     result = [val[2]] * val[0]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 81)
-  def _reduce_28(val, _values, result)
-     result = val[0]
+# reduce 36 omitted
+
+# reduce 37 omitted
+
+# reduce 38 omitted
+
+# reduce 39 omitted
+
+# reduce 40 omitted
+
+# reduce 41 omitted
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 104)
+  def _reduce_42(val, _values, result)
+     result = Complex(val[1],val[3])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 83)
-  def _reduce_29(val, _values, result)
-     result = val[0]
+module_eval(<<'.,.,', 'fortran_namelist.y', 107)
+  def _reduce_43(val, _values, result)
+     result = [val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 86)
-  def _reduce_30(val, _values, result)
+module_eval(<<'.,.,', 'fortran_namelist.y', 109)
+  def _reduce_44(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]
+module_eval(<<'.,.,', 'fortran_namelist.y', 111)
+  def _reduce_45(val, _values, result)
+     result = val[0] + [val[2]]
     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])
+module_eval(<<'.,.,', 'fortran_namelist.y', 113)
+  def _reduce_46(val, _values, result)
+     result = val[0] + [val[2]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 103)
-  def _reduce_40(val, _values, result)
+module_eval(<<'.,.,', 'fortran_namelist.y', 116)
+  def _reduce_47(val, _values, result)
      result = [val[0]-1]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 105)
-  def _reduce_41(val, _values, result)
+module_eval(<<'.,.,', 'fortran_namelist.y', 118)
+  def _reduce_48(val, _values, result)
      result = [(val[0]-1)..(val[2]-1)]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 107)
-  def _reduce_42(val, _values, result)
+module_eval(<<'.,.,', 'fortran_namelist.y', 120)
+  def _reduce_49(val, _values, result)
      result = [val[0]-1] + val[2]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 109)
-  def _reduce_43(val, _values, result)
+module_eval(<<'.,.,', 'fortran_namelist.y', 122)
+  def _reduce_50(val, _values, result)
      result = [(val[0]-1)..(val[2]-1)] + val[4]
     result
   end