fortio-namelist 1.0.0 → 1.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: eec83d1e80ab4d715f85a1e51d57a233995612e323f2729018756cd773b907e2
-  data.tar.gz: 97f524e2c0cfaae551c79fa48154c58e3ec5c1871f7e3544779fa49bc1333714
+  metadata.gz: c44816ef76988ff0fb717b4d8d67eab2525e96341e01292be61b589ad5863c64
+  data.tar.gz: '0572478dd329fea60bd37dce6095b188f25c7ede6d3fc8bc9424cbf7a56762d5'
 SHA512:
-  metadata.gz: cf29f5ab82c904800ced9c0e4a61672e536fc9ba58c9e30b96b0ed4ffbed6b4b2a9b371a3f5ce6ec5c5fbc9f6af7269a9661aeb45f1f46a5c1a3653316d313f5
-  data.tar.gz: 32101d550a483bd675f2b350f022357d4784ded6bdc944cc92449f6e6c9aaa53e1a41ea26b6816284d2b96777ade58fad0f75275964089d1e87d83a2b44a89ee
+  metadata.gz: 2b6588de0bacd73f1ce582399cea86b97ee820b84cfdcee9ce9531d4292a004294ff1b6495b2e7415f3d57c5b3a36947675c75870a250eb3fc9e3d4e782eb54c
+  data.tar.gz: 34ba922c0b04ef92fa3ed3df09ecf8350233c324675aa8a9a393bb6a641df6c61e19d93f686ca0e4d735c0f0c5a349c505f1ad43aa5edbbd48386eb77696ed6c

data/NOTE.md

@@ -0,0 +1,29 @@
+name
+----
+
+### グループ名のプレフィックス
+
+'&'と'$'が使える。グループの終端を表す'end'のプレフィックスも同様であるが、
+始端と終端のプレフィックスのペアのチェックはしない。
+
+### 文字列の配列
+ 
+    v1 = "a", "b", 'c'  ! 引用符あり文字列の配列
+    v2 = a, b, c        ! 引用符なし文字列の配列
+    v3 = a, 0_b, _c     ! 引用符なし文字列の配列
+
+ただし、引用符あり文字列と引用符なし文字列を混在させることはできない。
+
+    v4 = "a", b, "c"    ! エラー 
+    v5 = "a", 0_b, c    ! エラー
+
+### 論理型リテラル
+
+    v1 = .true.         ! true
+    v2 = .tabc.         ! true
+    v3 = t              ! true
+    
+    v4 = .false.        ! false
+    v5 = .fabc.         ! false
+    v6 = f              ! false
+

data/README.md

@@ -1,7 +1,14 @@
 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.
+This is a library for reading and writing data in Fortran's namelist format. With this library, you can read Fortran's namelist format data from Ruby and convert it to Hash objects, and vice versa. 
+
+Features
+--------
+
+* Flexible parsing enables reading of namelists in various formats.
+* Various options to control the output namelist string in the format of your choice.
+* Able to convert namelist format to JSON or YAML format using Ruby's standard library
 
 Installation
 ------------
@@ -14,51 +21,126 @@ To use the library in your Ruby script,
 require "fortio-namelist"
 ```
 
-Description
+Usage
 -----------
 
-# Reading namelist data 
+### Reading namelist format string
 
-    FortIO::Namelist.read(input, name: nil)
+To create a Hash object with Namelist structure by reading a string in namelist format, use the following method.
 
-# Generate namelist format from Hash object
-    FortIO::Namelist.generate(hash, name: "namelist", array_format: 'stream')
+    FortIO::Namelist.read(input, group: nil)
 
-# 複数のデータセットを含むHashからnamelist形式を生成する
-    FortIO::Namelist.dump(root, **format_options)
+The argument `input` is given as a string, but it also accepts objects with a method `#read` returns a string like an IO object. 
+
+If the keyword argument `group` is omitted, all namelist groups included in `input` will be read. To read only a specific group, give a group name to `group`. To load multiple groups, give an array of group names to `group`.
+
+The Hash object of the return value has a two-level structure as follows.
+
+    {
+      "group1" => {
+         "var11" => value11,
+         "var12" => value12, 
+            :          :
+      }
+      "group2" => {
+         "var21" => value21,
+         "var22" => value22,
+            :          :
+      }
+          :        
+          :
+    }
 
-# namelistデータを読み込み、blockで評価して、結果をnamelistに変換する
-    FortIO::Namelist.filter(input, **format_options) { |hash| ... }
+Group names and variable names are given as String objects. The value is Ruby's String, Integer, Float, Complex, TrueClass, or FalseClass objects, depending on the literal in the namelist. In the case of an array, it will be an Array object with the above objects as elements.
+
+Example:
+
+    require 'fortio-namelist'
+    
+    input = %{
+    &group1
+      var1 = 11
+      var2 = 12
+    /
+    &group2
+      var1 = 12
+      var2 = 22
+    /
+    &group3
+      var1 = 31
+      var2 = 32
+    /
+    }
+
+    ### read all groups
+    root = FortIO::Namelist.read(input)
+    => {"group1"=>{"var1"=>11, "var2"=>12},
+        "group2"=>{"var1"=>12, "var2"=>22},
+        "group3"=>{"var1"=>31, "var2"=>32}}
+    
+    ### read only "group2"
+    root = FortIO::Namelist.read(input, group: "group2")
+    => {"group2"=>{"var1"=>12, "var2"=>22}}
+    
+    ### read only "group1" and "group3"
+    root = FortIO::Namelist.read(input, group: ["group1", "group3"])
+    => {"group1"=>{"var1"=>11, "var2"=>12}, 
+        "group3"=>{"var1"=>31, "var2"=>32}}
 
-# generate, dump, filterが受け付けるオプション
+### Generating namelist format string from Hash object with namelist structure
 
-    array_style:    'index'   
-                    'stream'
+To generate a namelist format string from a Hash object with a namelist structure, use the following method.
 
+    FortIO::Namelist.dump(root, **format_options)
+
+The argument `root` is given as a Hash object. The return value is a string in namelist format. You can finely control the output namelist string with the following keyword arguments (the first one is the default).
+
+    array_style:    'stream'
+                    'index'   
+                    
     logical_format: 'normal'
                     'short'
 
     float_format:   'normal'
                     'd0'
 
-    alignment:      'compact'
-                    'left'
+    alignment:      'left'
                     'right'
+                    'compact'
                     Integer
 
     uppercase:      false
                     true
     
-    comma:          false
-                    true
-                    
-    slash:          true
-                    false
+    separator:      "comma", ","
+                    "nl", "\n"
+
+    group_end:      "slash", "/"
+                    "end"
                     
     indent:         ' '*2
 
+Example:
 
-    
+    require 'fortio-namelist'
 
-                    
-  
+    root = {"group1"=>{"var1"=>11, "var2"=>12},
+            "group2"=>{"var1"=>12, "var2"=>22},
+            "group3"=>{"var1"=>31, "var2"=>32}}
+    
+    puts FortIO::Namelist.dump(root)
+
+This script print a namelist format string to stdout.
+
+    &group1
+      var1 = 11,
+      var2 = 12
+    /
+    &group2
+      var1 = 12,
+      var2 = 22
+    /
+    &group3
+      var1 = 31,
+      var2 = 32
+    /

data/fortio-namelist.gemspec

@@ -1,5 +1,5 @@
 Gem::Specification::new do |s|
-  version = "1.0.0"
+  version = "1.1.0"
   files = Dir.glob("**/*") - [ 
                                Dir.glob("fortio-namelist-*.gem"), 
                                Dir.glob("test/**/*"),
@@ -18,6 +18,6 @@ Gem::Specification::new do |s|
   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"
 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 read (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,15 @@ 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.format_element (value, 
+                           logical_format: 'normal', 
+                           float_format: 'normal', 
+                           uppercase: false)
     case value
     when String
       if value !~ /'/
@@ -154,12 +149,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 +172,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,12 +180,15 @@ 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 "none"
@@ -212,35 +210,48 @@ module FortIO::Namelist
         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.read (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
+    when String
+      groups = [group]
+    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.read(group, root[group])
+    }
   end
 
   #

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

@@ -1,6 +1,6 @@
 #
 # DO NOT MODIFY!!!!
-# This file is automatically generated by Racc 1.4.16
+# This file is automatically generated by Racc 1.5.2
 # from Racc grammar file "".
 #
 
@@ -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,9 +141,9 @@ 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
@@ -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', 122)
 
   def parse (str)
     @scan = FortIO::Namelist::Scanner.new(str)
@@ -223,151 +243,144 @@ 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 ]
+    44,    30,    13,    58,    60,    43,    14,    35,    15,    37,
+    57,    38,    39,    42,    45,    44,    22,    22,    61,    54,
+    43,    24,    35,    42,    37,    44,    38,    39,    42,    45,
+    43,    54,    35,    47,    37,    42,    38,    39,    42,    45,
+    43,    52,    51,    50,    37,    43,    38,    39,    42,    37,
+    43,    38,    39,    42,    54,    53,    38,    39,    42,     4,
+     5,    21,     4,     5,    18,     4,     5,    21,    56,     7,
+    18,     4,     5,    10,    13,    10,    13,    25,    26,    63,
+    64,    65,    47,    69,    70,    47 ]
 
 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 ]
+    25,    25,    25,    47,    52,    25,     6,    25,     7,    25,
+    47,    25,    25,    25,    25,    29,    11,    29,    52,    43,
+    29,    19,    29,    43,    29,    64,    29,    29,    29,    29,
+    64,    63,    64,    26,    64,    63,    64,    64,    64,    64,
+    32,    33,    32,    32,    32,    50,    32,    32,    32,    50,
+    53,    50,    50,    50,    53,    37,    53,    53,    53,     9,
+     9,     9,     0,     0,     9,    23,    23,    23,    46,     1,
+    23,     1,     1,     3,     3,    16,    16,    21,    21,    55,
+    56,    57,    58,    65,    67,    69 ]
 
 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 ]
+    60,    69,   nil,    68,   nil,   nil,     2,     8,   nil,    57,
+   nil,    10,   nil,   nil,   nil,   nil,    70,   nil,   nil,    17,
+   nil,    69,   nil,    63,   nil,    -4,    20,   nil,   nil,    11,
+   nil,   nil,    31,    29,   nil,   nil,   nil,    41,   nil,   nil,
+   nil,   nil,   nil,     6,   nil,   nil,    58,    -9,   nil,   nil,
+    36,   nil,     0,    41,   nil,    67,    72,    68,    69,   nil,
+   nil,   nil,   nil,    18,    21,    71,   nil,    74,   nil,    72,
+   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 ]
+   -46,   -46,    -2,   -13,    -5,    -6,   -46,   -46,    -1,   -46,
+    -8,    -9,   -10,   -11,    -7,    72,   -13,    -4,   -14,   -46,
+   -16,   -46,   -12,   -46,   -15,   -46,   -46,    -3,   -17,   -46,
+   -18,   -19,   -22,   -23,   -24,   -25,   -29,   -35,   -31,   -32,
+   -33,   -34,   -36,   -46,   -38,   -39,   -46,   -42,   -20,   -26,
+   -46,   -28,   -46,   -46,   -35,   -46,   -46,   -46,   -46,   -27,
+   -40,   -41,   -30,   -46,   -46,   -43,   -44,   -46,   -21,   -46,
+   -37,   -45 ]
 
 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 ]
+    46,    31,    55,    49,    17,    48,    19,     2,     8,    20,
+     1,     9,    16,    29,    62,   nil,   nil,   nil,    27,   nil,
+    19,    59,    67,    28,    23,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    66,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+    68,   nil,   nil,    71 ]
 
 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 ]
+    12,    11,    17,    15,     6,    11,     7,     2,     2,    10,
+     1,     4,     5,     8,    16,   nil,   nil,   nil,     6,   nil,
+     7,    15,    17,    10,     4,   nil,   nil,   nil,   nil,   nil,
+   nil,   nil,    12,   nil,   nil,   nil,   nil,   nil,   nil,   nil,
+    11,   nil,   nil,    12 ]
 
 racc_goto_pointer = [
-   nil,    10,   nil,   nil,     3,    12,     6,    -5,     1,   -22,
-   -25,   -27,   -41,   nil,   -35 ]
+   nil,    10,     7,   nil,     8,     3,    -5,    -3,   -12,   nil,
+     0,   -24,   -26,   nil,   nil,   -29,   -39,   -41,   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,    32,    33,    34,    36,    40,    41 ]
 
 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,
+  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_15,
+  1, 25, :_reduce_16,
+  3, 25, :_reduce_17,
+  3, 30, :_reduce_18,
+  3, 30, :_reduce_19,
+  4, 30, :_reduce_20,
+  6, 30, :_reduce_21,
   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
+  1, 33, :_reduce_25,
+  2, 33, :_reduce_26,
+  3, 33, :_reduce_27,
+  2, 33, :_reduce_28,
+  1, 35, :_reduce_29,
+  3, 35, :_reduce_30,
+  1, 36, :_reduce_none,
+  1, 36, :_reduce_none,
+  1, 36, :_reduce_none,
+  1, 36, :_reduce_none,
+  1, 37, :_reduce_none,
+  1, 37, :_reduce_none,
+  5, 38, :_reduce_37,
+  1, 34, :_reduce_38,
+  1, 34, :_reduce_39,
+  3, 34, :_reduce_40,
+  3, 34, :_reduce_41,
+  1, 32, :_reduce_42,
+  3, 32, :_reduce_43,
+  3, 32, :_reduce_44,
+  5, 32, :_reduce_45 ]
+
+racc_reduce_n = 46
+
+racc_shift_n = 72
 
 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 +403,43 @@ 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",
   "rvalues",
   "array_spec",
-  "abbreb",
+  "rlist",
+  "ident_list",
+  "element",
   "constant",
-  "complex",
-  "real" ]
+  "real",
+  "complex" ]
 
 Racc_debug_parser = false
 
@@ -433,174 +451,144 @@ 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)
+module_eval(<<'.,.,', 'fortran_namelist.y', 34)
+  def _reduce_7(val, _values, result)
      result = val[1].downcase; @scan.in_namelist = val[1].downcase
     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)
+module_eval(<<'.,.,', 'fortran_namelist.y', 50)
   def _reduce_15(val, _values, result)
-     result = val[0] + [val[1]]
+     raise Racc::ParseError, "\nparse error (&)" unless val[1] =~ /\Aend\Z/i
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 54)
+module_eval(<<'.,.,', 'fortran_namelist.y', 53)
   def _reduce_16(val, _values, result)
-     result = val[0]
+     result = [val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 58)
+module_eval(<<'.,.,', 'fortran_namelist.y', 55)
   def _reduce_17(val, _values, result)
-     result = ParamDef.new(val[0].downcase, nil, "")
+     result = val[0] + [val[2]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 60)
+module_eval(<<'.,.,', 'fortran_namelist.y', 59)
   def _reduce_18(val, _values, result)
      result = ParamDef.new(val[0].downcase, nil, "")
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 62)
+module_eval(<<'.,.,', 'fortran_namelist.y', 61)
   def _reduce_19(val, _values, result)
      result = ParamDef.new(val[0].downcase, nil, val[2])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 64)
+module_eval(<<'.,.,', 'fortran_namelist.y', 63)
   def _reduce_20(val, _values, result)
-     result = ParamDef.new(val[0].downcase, val[2], val[5])
+     result = ParamDef.new(val[0].downcase, nil, val[3])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 67)
+module_eval(<<'.,.,', 'fortran_namelist.y', 65)
   def _reduce_21(val, _values, result)
-     result = val[0]
+     result = ParamDef.new(val[0].downcase, val[2], val[5])
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 69)
-  def _reduce_22(val, _values, result)
-     result = val[0] + val[1]
-    result
-  end
-.,.,
+# reduce 22 omitted
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 71)
-  def _reduce_23(val, _values, result)
-     result = val[0] + val[2]
-    result
-  end
-.,.,
+# reduce 23 omitted
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 73)
-  def _reduce_24(val, _values, result)
-     result = val[0] + val[2]
-    result
-  end
-.,.,
+# reduce 24 omitted
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 75)
+module_eval(<<'.,.,', 'fortran_namelist.y', 73)
   def _reduce_25(val, _values, result)
-     result = val[0] + [nil]
+     result = [nil, nil]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 77)
+module_eval(<<'.,.,', 'fortran_namelist.y', 75)
   def _reduce_26(val, _values, result)
-     result = [nil] + val[1]
+     result = val[0] + val[1]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 79)
+module_eval(<<'.,.,', 'fortran_namelist.y', 77)
   def _reduce_27(val, _values, result)
-     result = [nil] + val[1]
+     result = val[0] + val[2]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 81)
+module_eval(<<'.,.,', 'fortran_namelist.y', 79)
   def _reduce_28(val, _values, result)
-     result = val[0]
+     result = val[0] + [nil]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 83)
+module_eval(<<'.,.,', 'fortran_namelist.y', 82)
   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)
+module_eval(<<'.,.,', 'fortran_namelist.y', 84)
+  def _reduce_30(val, _values, result)
      result = [val[2]] * val[0]
     result
   end
 .,.,
 
+# reduce 31 omitted
+
 # reduce 32 omitted
 
 # reduce 33 omitted
@@ -611,40 +599,64 @@ module_eval(<<'.,.,', 'fortran_namelist.y', 88)
 
 # reduce 36 omitted
 
-# reduce 37 omitted
+module_eval(<<'.,.,', 'fortran_namelist.y', 98)
+  def _reduce_37(val, _values, result)
+     result = Complex(val[1],val[3])
+    result
+  end
+.,.,
 
-# reduce 38 omitted
+module_eval(<<'.,.,', 'fortran_namelist.y', 101)
+  def _reduce_38(val, _values, result)
+     result = [val[0]]
+    result
+  end
+.,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 100)
+module_eval(<<'.,.,', 'fortran_namelist.y', 103)
   def _reduce_39(val, _values, result)
-     result = Complex(val[1],val[3])
+     result = [val[0]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 103)
+module_eval(<<'.,.,', 'fortran_namelist.y', 105)
   def _reduce_40(val, _values, result)
-     result = [val[0]-1]
+     result = val[0] + [val[2]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 105)
+module_eval(<<'.,.,', 'fortran_namelist.y', 107)
   def _reduce_41(val, _values, result)
-     result = [(val[0]-1)..(val[2]-1)]
+     result = val[0] + [val[2]]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 107)
+module_eval(<<'.,.,', 'fortran_namelist.y', 110)
   def _reduce_42(val, _values, result)
-     result = [val[0]-1] + val[2]
+     result = [val[0]-1]
     result
   end
 .,.,
 
-module_eval(<<'.,.,', 'fortran_namelist.y', 109)
+module_eval(<<'.,.,', 'fortran_namelist.y', 112)
   def _reduce_43(val, _values, result)
+     result = [(val[0]-1)..(val[2]-1)]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 114)
+  def _reduce_44(val, _values, result)
+     result = [val[0]-1] + val[2]
+    result
+  end
+.,.,
+
+module_eval(<<'.,.,', 'fortran_namelist.y', 116)
+  def _reduce_45(val, _values, result)
      result = [(val[0]-1)..(val[2]-1)] + val[4]
     result
   end