fortio-namelist 1.0.0 → 1.4.0

data/lib/fortio-namelist/fortran_namelist.y

@@ -14,91 +14,104 @@
 
 class FortIO::Namelist::Parser
 
-prechigh
-  nonassoc COMMA
-  nonassoc NL
-  left ','
-  left '='
-preclow
-
 rule
 
-  namelist_all : 
-               | namelist
-               | namelist namelist_all
-
   namelist : 
-                 header tailer 
+                 namelist group
+               | group
+
+  group : 
+                 group_header separator varlist separator group_end
+                           { @root[val[0]] = val[2]; @scan.in_namelist = nil }
+               | group_header separator group_end
                            { @root[val[0]] = []; @scan.in_namelist = nil }
-               | header paramlist tailer 
-                           { @root[val[0]] = val[1]; @scan.in_namelist = nil }
 
-  prefix :       '&' 
+  group_prefix : 
+                 '&' 
                | '$'
 
-  header :     
-                 prefix IDENT { result = val[1].downcase; @scan.in_namelist = val[1].downcase }
-               | header NL
+  group_header :     
+                 group_prefix IDENT 
+                           { result = val[1].downcase.intern; @scan.in_namelist = val[1].downcase.intern }
+
+  separator :
+                 COMMA
+               | COMMA nls
+               | nls COMMA
+               | nls
+               | blank
+
+  nls : 
+                 NL
+               | nls NL
+
+  blank : 
 
-  tailer :
+  group_end :    
                  '/'
-               | prefix IDENT { raise Racc::ParseError, "\nparse error (&)" unless val[1] =~ /\Aend\Z/i }
-
-  separator:     COMMA
-               | NL  
-
-  paramlist:
-                 paramdef  { result = [val[0]] }
-               | paramlist paramdef
-                           { result = val[0] + [val[1]] }
-               | paramlist separator
-                           { result = val[0] }
-
-  paramdef:  
-                 IDENT '=' separator
-                           { result = ParamDef.new(val[0].downcase, nil, "") }
-               | IDENT '=' NIL
-                           { result = ParamDef.new(val[0].downcase, nil, "") }
-               | IDENT '=' rvalues 
-                           { result = ParamDef.new(val[0].downcase, nil, val[2]) }
-               | IDENT '(' array_spec ')' '=' rvalues  
-                           { result = ParamDef.new(val[0].downcase, val[2], val[5]) }
-
-  rvalues :      
-                abbreb    { result = val[0] }
-               | rvalues abbreb      
+               | group_prefix IDENT 
+                           { raise Racc::ParseError, "\nparse error (&)" unless val[1] =~ /\Aend\Z/i }
+
+  varlist : 
+                 vardef    { result = [val[0]] }
+               | varlist separator vardef
+                           { result = val[0] + [val[2]] }
+
+  vardef :  
+                 IDENT equal COMMA
+                           { result = ParamDef.new(val[0].downcase.intern, nil, "") }
+               | IDENT equal rvalues 
+                           { result = ParamDef.new(val[0].downcase.intern, nil, val[2]) }
+               | IDENT '(' array_spec ')' equal rvalues  
+                           { result = ParamDef.new(val[0].downcase.intern, val[2], val[5]) }
+
+  equal : 
+                 '='
+               | '=' nls
+               | nls '=' 
+               | nls '=' nls
+
+  rvalues : 
+                rlist
+               | ident_list
+
+  rlist : 
+                 element
+               | NIL       { result = [nil, nil] }
+               | rlist element
                            { result = val[0] + val[1] }
-               | rvalues ',' abbreb
+               | rlist ',' element
                            { result = val[0] + val[2] }
-               | rvalues NL abbreb
-                           { result = val[0] + val[2] }
-               | rvalues NIL
+               | rlist NIL
                            { result = val[0] + [nil] }
-               | NIL rvalues 
-                           { result = [nil] + val[1] }
-               | ',' rvalues 
-                           { result = [nil] + val[1] }
-               | rvalues NL 
-                           { result = val[0] }
-               | IDENT
-                           { result = val[0] }
-
-  abbreb :
-                 constant { result = [val[0]] }
+
+  element :
+                 constant  { result = [val[0]] }
                | DIGITS '*' constant
-                          { result = [val[2]] * val[0] }
+                           { result = [val[2]] * val[0] }
 
   constant :
                  STRING
                | LOGICAL
-               | DIGITS
-               | FLOAT
+               | real
                | complex
 
-  real :         DIGITS
+  real :
+                 DIGITS
                | FLOAT
 
-  complex :      '(' real ',' real ')' { result = Complex(val[1],val[3]) }
+  complex :
+                '(' real ',' real ')' 
+                           { result = Complex(val[1],val[3]) }
+  
+  ident_list : 
+                 IDENT     { result = [val[0]] }
+               | STRINGLIKE
+                           { result = [val[0]] }
+               | ident_list ',' IDENT 
+                           { result = val[0] + [val[2]]}
+               | ident_list ',' STRINGLIKE
+                           { result = val[0] + [val[2]]}
 
   array_spec :
                  DIGITS    { result = [val[0]-1] }
@@ -184,6 +197,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.
@@ -199,9 +227,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
@@ -229,6 +257,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, 
@@ -252,17 +285,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,

data/spec/array_spec.rb

@@ -0,0 +1,160 @@
+require "fortio-namelist"
+require "rspec-power_assert"
+
+describe "FortIO::Namelist" do
+  
+  example "array stream" do 
+    input = %{
+&example
+  v1 = 1,2,3,4,5,
+  v2 = 6,7,8,9,10,
+/
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+    is_asserted_by { nml[:example].is_a? Hash  }
+    is_asserted_by { nml[:example][:v1] == [1,2,3,4,5]  }
+    is_asserted_by { nml[:example][:v2] == [6,7,8,9,10]  }
+  end
+
+  example "array sequence" do 
+    input = %{
+&example v1 = 1,2,3,4,5, v2 = 6,7,8,9,10, /
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+    is_asserted_by { nml[:example].is_a? Hash  }
+    is_asserted_by { nml[:example][:v1] == [1,2,3,4,5]  }
+    is_asserted_by { nml[:example][:v2] == [6,7,8,9,10]  }
+  end
+
+  example "array index" do 
+    input = %{
+&example
+  v1(1) = 1
+  v1(2) = 2
+  v1(3) = 3
+  v1(4) = 4
+  v1(5) = 5
+  v2(1:2) = 6,7
+  v2(3:5) = 8,9,10,
+/
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+    is_asserted_by { nml[:example].is_a? Hash  }
+    is_asserted_by { nml[:example][:v1] == [1,2,3,4,5]  }
+    is_asserted_by { nml[:example][:v2] == [6,7,8,9,10]  }
+  end
+
+  example "array partial" do 
+    input = %{
+&example
+  v1(2) = 2
+  v1(5) = 5
+  v2(3:5) = 8,9,10,
+/
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+    is_asserted_by { nml[:example].is_a? Hash  }
+    is_asserted_by { nml[:example][:v1] == [nil,2,nil,nil,5]  }
+    is_asserted_by { nml[:example][:v2] == [nil,nil,8,9,10]  }
+  end
+
+  example "array extend" do 
+    input = %{
+&example
+  v1(2) = 2,3,4,5
+/
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+    is_asserted_by { nml[:example].is_a? Hash  }
+    is_asserted_by { nml[:example][:v1] == [nil,2,3,4,5]  }
+  end
+
+  example "array reputation" do 
+    input = %{
+&example
+  v1(1:5) = 2,4*2
+  v2(2) = 4*2
+  v3 = 5*.true.
+  v4 = 5 * f
+/
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+    is_asserted_by { nml[:example].is_a? Hash  }
+    is_asserted_by { nml[:example][:v1] == [2,2,2,2,2]  }
+    is_asserted_by { nml[:example][:v2] == [nil,2,2,2,2]  }
+    is_asserted_by { nml[:example][:v3] == [true]*5  }
+    is_asserted_by { nml[:example][:v4] == [false]*5  }
+  end
+
+  example "array of string" do 
+    input = %{
+&example
+  v1 = "a",'b',"c"
+/
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+    is_asserted_by { nml[:example].is_a? Hash  }
+    is_asserted_by { nml[:example][:v1] == ["a","b","c"]  }
+  end
+
+  example "array of identifier" do 
+    input = %{
+&example
+  v1 = a, b, c
+/
+    }
+    expect { FortIO::Namelist.parse(input) }.to raise_error(RuntimeError)
+  end
+
+  example "array of identifier 2" do 
+    input = %{
+&example
+  v1 = a, 0_b, _c
+/
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+    is_asserted_by { nml[:example].is_a? Hash  }
+    is_asserted_by { nml[:example][:v1] == ["a","0_b","_c"]  }
+  end
+
+  example "don't permit to mix identifier and string in array stream" do 
+    input = %{
+&example
+  v1 = "a", b, "c"
+/
+    }
+    expect { FortIO::Namelist.parse(input) }.to raise_error(RuntimeError)
+  end
+
+  example "don't permit to mix identifier and string in array stream 2" do 
+    input = %{
+&example
+  v1 = a, "b", c
+/
+    }
+    expect { FortIO::Namelist.parse(input) }.to raise_error(RuntimeError)
+  end
+
+  example "empty element" do 
+    input = %{
+&example
+  v1 = , , 3, , 5,
+  v2 = , , 3, , 5
+/
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+    is_asserted_by { nml[:example].is_a? Hash  }
+    is_asserted_by { nml[:example][:v1] == [nil, nil, 3, nil, 5]  }
+    is_asserted_by { nml[:example][:v2] == [nil, nil, 3, nil, 5]  }
+  end
+
+end

data/spec/dump_spec.rb

@@ -0,0 +1,51 @@
+require "fortio-namelist"
+require "rspec-power_assert"
+
+describe "FortIO::Namelist" do
+  
+  example "dumping float" do 
+    root = {example: {v1: 1.234567890123456, v2: 0.123456789012345, v3: 1.234567890123456e10}}
+    output = FortIO::Namelist.dump(root)
+
+    answer = <<HERE
+&example
+  v1 = 1.234567890123456,
+  v2 = 0.123456789012345,
+  v3 = 12345678901.23456
+/
+HERE
+
+    is_asserted_by { output == answer  }
+  end
+
+  example "dumping float 'd0'" do 
+    root = {example: {v1: 1.234567890123456, v2: 0.123456789012345, v3: 1.234567890123456e10}}
+    output = FortIO::Namelist.dump(root, float_format: 'd0')
+
+    answer = <<HERE
+&example
+  v1 = 1.234567890123456d0,
+  v2 = 0.123456789012345d0,
+  v3 = 12345678901.23456d0
+/
+HERE
+
+    is_asserted_by { output == answer  }
+  end
+
+  example "dumping float 'exp'" do 
+    root = {example: {v1: 1.234567890123456, v2: 0.123456789012345, v3: 1.234567890123456e10}}
+    output = FortIO::Namelist.dump(root, float_format: 'exp')
+
+    answer = <<HERE
+&example
+  v1 = 1.234567890123456d+00,
+  v2 = 1.23456789012345d-01,
+  v3 = 1.234567890123456d+10
+/
+HERE
+
+    is_asserted_by { output == answer  }
+  end
+
+end

data/spec/empty_spec.rb

@@ -0,0 +1,66 @@
+require "fortio-namelist"
+require "rspec-power_assert"
+
+describe "FortIO::Namelist" do
+  
+  example "namelist prefix &" do 
+    input = %{
+&example
+&end
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+    is_asserted_by { nml[:example].is_a? Hash  }
+    is_asserted_by { nml[:example].empty?  }
+  end
+
+  example "namelist prefix $" do 
+    input = %{
+$example
+$end
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+  end
+
+  example "end with /" do 
+    input = %{
+&example
+/
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+  end
+
+  example "only comment" do 
+    input = %{
+&example
+  ! this is comment
+/
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+  end
+
+
+  example "only newlines" do 
+    input = %{
+&example
+
+
+/
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+  end
+
+  example "one line" do 
+    input = %{
+&example /
+    }
+    nml = FortIO::Namelist.parse(input)
+    is_asserted_by { nml.has_key? :example  }
+  end
+  
+  
+end