coderunner 0.12.19 → 0.13.0

data/VERSION

@@ -1 +1 @@
-0.12.19
+0.13.0

data/coderunner.gemspec

@@ -5,11 +5,11 @@
 
 Gem::Specification.new do |s|
   s.name = "coderunner"
-  s.version = "0.12.19"
+  s.version = "0.13.0"
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
   s.authors = ["Edmund Highcock"]
-  s.date = "2013-08-07"
+  s.date = "2013-08-09"
   s.description = "CodeRunner is a framework for the automated running and analysis of simulations. It automatically generates any necessary input files, organises the output data and analyses it. Because it is a modular system, it can easily be customised to work with any system and any simulation code. One of its greatest strengths is that it is independent of any one simulation code; thus it can easily plot and compare the data from different codes."
   s.email = "edmundhighcock@sourceforge.net"
   s.executables = ["coderunner"]
@@ -39,6 +39,7 @@ Gem::Specification.new do |s|
     "lib/coderunner/class_methods.rb",
     "lib/coderunner/feedback.rb",
     "lib/coderunner/fortran_namelist.rb",
+    "lib/coderunner/fortran_namelist_c.rb",
     "lib/coderunner/graphs_and_films.rb",
     "lib/coderunner/heuristic_run_methods.rb",
     "lib/coderunner/instance_methods.rb",
@@ -69,8 +70,13 @@ Gem::Specification.new do |s|
     "lib/cubecalccrmod/default_modlets/empty_defaults.rb",
     "lib/cubecalccrmod/defaults_files/cubecalc_defaults.rb",
     "lib/cubecalccrmod/defaults_files/sleep_defaults.rb",
+    "lib/cubecalccrmod/deleted_variables.rb",
     "lib/cubecalccrmod/empty.rb",
+    "lib/cubecalccrmod/namelists.rb",
     "lib/cubecalccrmod/sleep.rb",
+    "lib/cubecalccrmod/with_namelist.rb",
+    "test/cubecalc.in",
+    "test/cubecalc_namelist.cc",
     "test/fortran_namelist.in",
     "test/helper.rb",
     "test/old_test.rb",

data/lib/coderunner.rb

@@ -110,6 +110,8 @@ eprint '.' unless $has_put_startup_message_for_code_runner
 #eprint '.' unless $has_put_startup_message_for_code_runner
 load CodeRunner::SCRIPT_FOLDER + "/fortran_namelist.rb"
 eprint '.' unless $has_put_startup_message_for_code_runner
+load CodeRunner::SCRIPT_FOLDER + "/fortran_namelist_c.rb"
+eprint '.' unless $has_put_startup_message_for_code_runner
 
 CodeRunner::CODE_RUNNER_VERSION = Version.new(Gem.loaded_specs['coderunner'].version.to_s) rescue "test"
 

data/lib/coderunner/fortran_namelist.rb

@@ -37,7 +37,11 @@ class Run
 	# 		folder = File.dirname(__FILE__)
 
 
-		@namelists = eval(File.read(folder + '/namelists.rb'), binding, folder + '/namelists.rb')
+		namelist_file = folder + '/namelists.rb'
+		unless FileTest.exist?(namelist_file)
+			File.open(namelist_file, 'w'){|file| file.puts '{}'}
+		end
+		@namelists = eval(File.read(folder + '/namelists.rb'), binding, folder + '/namelists.rb') 
 
 		@variables_with_help = (@namelists.inject({}) do |hash, (namelist, namelist_hash)|
 			namelist_hash[:variables].each{|var, var_hash| hash[var] = var_hash[:help] if var_hash[:help]}
@@ -543,7 +547,7 @@ def self.parse_input_file(input_file, strict=true)
 	namelist_hash = {}
 	regex = Regexp.new("#{rcp.matching_regex.to_s}\\s*(?:\\!(?<comment>.*))?\\n")
 	#ep input_file
-	text.scan(/(?:^\s*\!\s*(?<namelist_comment>[^\n]+))?\n^\&(?<namelist>\S+).*?^\//m) do 
+	text.scan(/(?:(?:^|\A)\s*\!\s*(?<namelist_comment>[^\n]+)\n)?(?:^|\A)\&(?<namelist>\S+).*?^\//m) do 
 		namelist = $~[:namelist].to_sym
 		hash = namelist_hash[namelist] = {}
 		#p $~
@@ -553,7 +557,7 @@ def self.parse_input_file(input_file, strict=true)
 			hash[var] =  val
 		end
 	end
-# 	pp namelist_hash
+ 	pp 'inputfile', namelist_hash
 	namelist_hash
 end
 
@@ -1017,13 +1021,15 @@ end
 
 # Given the folder where the source code resides, return a single string containing all the code
 
+@fortran_namelist_source_file_match = /((\.f9[05])|(\.fpp))$/
+
 def self.get_aggregated_source_code_text(source_code_folder)
 	#p 'source_code_folder', source_code_folder
 	string = ""
 	(rcp.source_code_subfolders.map{|f| '/' + f} + [""]).map{|f| source_code_folder + f}.each do |folder|
 		Dir.chdir(folder) do 
 			Dir.entries.each do |file|
-				next unless file =~ /((\.f9[05])|(\.fpp))$/
+				next unless file =~ rcp.fortran_namelist_source_file_match
 				next if file =~ /ingen/
 				ep file
 				text = File.read(file) + "\n"
@@ -1035,12 +1041,9 @@ def self.get_aggregated_source_code_text(source_code_folder)
 	string
 end
 
-# Find unknown input variables in the source code and add them to the database of namelists
-# Delete input variables which are no longer present in the source code
-                                         
-def self.synchronise_variables(source_code_folder = ARGV[2])
-	source = get_aggregated_source_code_text(source_code_folder)
-# 	ep source.size
+# Find all input namelists and variables by scanning the source code
+#
+def self.get_namelists_and_variables_from_source_code(source)
 	nms = {}
 	all_variables_in_source = {}
 	namelist_declarations = {}
@@ -1066,6 +1069,54 @@ def self.synchronise_variables(source_code_folder = ARGV[2])
 		nms[namelist].uniq!
 		all_variables_in_source[namelist].uniq!
 	end
+	return [nms, all_variables_in_source, namelist_declarations]
+end
+
+# Try to get a sample value of the 
+def self.get_sample_value(source, var)
+			ep var
+			values_text = source.scan(Regexp.new("\\W#{var}\\s*=\\s*.+")).join("\n") 
+			ep values_text
+			values = scan_text_for_variables(values_text).map{|(v,val)| val} 
+			values.uniq!
+# 			ep values if var == :nbeta
+			values.delete_if{|val| val.kind_of? String} if values.find{|val| val.kind_of? Numeric}
+			values.delete_if{|val| val.kind_of? String and not String::FORTRAN_BOOLS.include? val} if values.find{|val| val.kind_of? String and String::FORTRAN_BOOLS.include? val}
+# 			values.sort!
+# 			ep var
+# 			ep values
+			sample_val = values[0]
+			if not values[0] or ( values[0].kind_of? String and not String::FORTRAN_BOOLS.include? values[0])
+				p source.scan(Regexp.new("^\s*(?<type>integer|float|character|logical|real|double|complex)(?:&[\\n\\r]|.)*\\W#{var}\\W", Regexp::IGNORECASE)).uniq
+				p var unless $~
+
+				case $~[:type]
+				when /logical/
+					sample_val = '.false.'
+				when /int/
+					sample_val = 0
+				when 'real', 'float', 'double'
+					sample_val = 0.0
+				when /character/
+					sample_val = ""
+				when /complex/
+					sample_val = Complex(0.0, 0.0)
+				end
+# 				type = Feedback.get_choice("Found the following possible values for '#{var}' in namelist '#{namelist}': #{values.inspect} but cannot determine its type. Please choose its type", ['Float', 'Integer', 'String', 'Unknown' ])
+# 				ep type
+				n +=1
+				
+			end
+			return sample_val
+end
+
+# Find unknown input variables in the source code and add them to the database of namelists
+# Delete input variables which are no longer present in the source code
+                                         
+def self.synchronise_variables(source_code_folder = ARGV[2])
+	source = get_aggregated_source_code_text(source_code_folder)
+	nms, all_variables_in_source, namelist_declarations = get_namelists_and_variables_from_source_code(source)
+# 	ep source.size
 	variables_to_delete = {}	
 	#pp 'namelists', rcp.namelists
 	rcp.namelists.each do |namelist, namelist_hash|
@@ -1094,53 +1145,22 @@ def self.synchronise_variables(source_code_folder = ARGV[2])
 		end
 	end
 
+	raise "No namelists found" if nms.size == 0
 	eputs nms.keys.zip(nms.values.map{|vs| vs.size})
-	eputs "Namelists to be added to. (Press Enter)"; STDIN.gets
+	eputs "Namelists to be added to. (Press Enter)"; STDIN.gets unless ENV['CR_NON_INTERACTIVE']
 	n = 0
   ep nms
 # 	ep nms.values.sum
 	nms.values.sum.each do |var|
 		eputs var if variable_exists? var
 	end
-	eputs "Conflicting Variables. (Press Enter)";; STDIN.gets
+	eputs "Conflicting Variables. (Press Enter)";; STDIN.gets unless ENV['CR_NON_INTERACTIVE']
 	nms.each do |namelist, vars|
 		ep namelist
 		ep vars
 		vars.each do |var|
 # 			next unless var == :w_antenna
-			ep var
-			values_text = source.scan(Regexp.new("\\W#{var}\\s*=\\s*.+")).join("\n") 
-			ep values_text
-			values = scan_text_for_variables(values_text).map{|(v,val)| val} 
-			values.uniq!
-# 			ep values if var == :nbeta
-			values.delete_if{|val| val.kind_of? String} if values.find{|val| val.kind_of? Numeric}
-			values.delete_if{|val| val.kind_of? String and not String::FORTRAN_BOOLS.include? val} if values.find{|val| val.kind_of? String and String::FORTRAN_BOOLS.include? val}
-# 			values.sort!
-# 			ep var
-# 			ep values
-			sample_val = values[0]
-			if not values[0] or ( values[0].kind_of? String and not String::FORTRAN_BOOLS.include? values[0])
-				p source.scan(Regexp.new("^\s*(?<type>integer|float|character|logical|real|double|complex)(?:&[\\n\\r]|.)*\\W#{var}\\W", Regexp::IGNORECASE)).uniq
-				p var unless $~
-
-				case $~[:type]
-				when /logical/
-					sample_val = '.false.'
-				when /int/
-					sample_val = 0
-				when 'real', 'float', 'double'
-					sample_val = 0.0
-				when /character/
-					sample_val = ""
-				when /complex/
-					sample_val = Complex(0.0, 0.0)
-				end
-# 				type = Feedback.get_choice("Found the following possible values for '#{var}' in namelist '#{namelist}': #{values.inspect} but cannot determine its type. Please choose its type", ['Float', 'Integer', 'String', 'Unknown' ])
-# 				ep type
-				n +=1
-				
-			end
+			sample_val = get_sample_value(source, var)
 			p namelist, var, sample_val
 			add_code_variable_to_namelist(namelist, var, sample_val)
 		end

data/lib/coderunner/fortran_namelist_c.rb

@@ -0,0 +1,53 @@
+class CodeRunner::Run
+class FortranNamelistC < FortranNamelist
+	# Given the folder where the source code resides, return a single string containing all the code
+
+	@fortran_namelist_source_file_match = /(\.c|\.cpp|\.cu|\.cc)$/
+
+	@fortran_namelist_variable_match_regex = /^[^\/]*?fnr_get_(?<type>\w+)\(\&?[\w\s]+\s*,\s*["'](?<namelist>\w+)[\d()]*?['"]\s*,\s*['"](?<variable>\w+)['"],[^)]+\)\)\s*[\w\[\]\d]+\s*=\s*(?<default>\S+)\s*;/
+		#
+	# Find all input namelists and variables by scanning the source code
+	#
+	def self.get_namelists_and_variables_from_source_code(source)
+		nms = {}
+		all_variables_in_source = {}
+		namelist_declarations = {}
+		#source.scan(/^\s*namelist\s*\/(?<namelist>\w+)\/(?<variables>(?:(?:&\s*[\n\r]+)|[^!\n\r])*)/) do 
+		#source.scan(Regexp.new("#{/^\s*namelist\s*\/\s*(?<namelist>\w+)\s*\//}(?<variables>#{FORTRAN_SINGLE_LINE})")) do 
+		source.scan(rcp.fortran_namelist_variable_match_regex) do
+			#p $~
+			namelist = $~[:namelist].to_s.downcase.to_sym
+			#variables = $~[:variables].gsub(/!.*/, '')
+			#eputs namelist, variables
+			#namelist_declarations[namelist] = variables
+			#gets # if namelist == :collisions_knobs
+
+			#next if [:stuff, :ingen_knobs].include? namelist
+			nms[namelist] ||= []
+			all_variables_in_source[namelist] ||= []
+	# 		puts variables
+			#variables.scan(/\w+/) do 
+				var =  $~[:variable].to_sym
+	# 			(p variables, namelist; exit) if var == :following or var == :sou
+				all_variables_in_source[namelist].push var
+				next if known_code_variable?(namelist, var)
+				nms[namelist].push var
+			#end
+			nms[namelist].uniq!
+			all_variables_in_source[namelist].uniq!
+		end
+		return [nms, all_variables_in_source, namelist_declarations]
+	end
+	def self.get_sample_value(source, var)
+		sample_val = nil
+		source.scan(rcp.fortran_namelist_variable_match_regex) do
+			
+			next unless var == $~[:variable].to_sym
+			sample_val = eval($~[:default])
+		end
+		raise "Couldn't get a sample value for #{var.inspect}" unless sample_val
+		return sample_val
+	end
+
+end
+end

data/lib/cubecalccrmod/cubecalc.rb

@@ -1,13 +1,13 @@
 class CodeRunner
-	class Cubecalc < Run
+	class Cubecalc < Run::FortranNamelistC
 		
 # @code = 'cubecalc'
 
-@variables = [:calculate_sides, :width, :height, :depth, :area]
+@variables = [:calculate_sides, :width, :height, :depth]
 
 @naming_pars = [:width]
 
-@results = [:volume, :sides]
+@results = [:volume, :sides, :area]
 
 # e.g. number of iterations
 

data/lib/cubecalccrmod/deleted_variables.rb

@@ -0,0 +1,30 @@
+{:edges_1=>
+  {:should_include=>"true",
+   :description=>nil,
+   :help=>nil,
+   :code_name=>:edges_1,
+   :must_pass=>
+    [{:test=>"kind_of? Numeric",
+      :explanation=>
+       "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}],
+   :type=>:Float},
+ :edges_2=>
+  {:should_include=>"true",
+   :description=>nil,
+   :help=>nil,
+   :code_name=>:edges_2,
+   :must_pass=>
+    [{:test=>"kind_of? Numeric",
+      :explanation=>
+       "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}],
+   :type=>:Float},
+ :edges_3=>
+  {:should_include=>"true",
+   :description=>nil,
+   :help=>nil,
+   :code_name=>:edges_3,
+   :must_pass=>
+    [{:test=>"kind_of? Numeric",
+      :explanation=>
+       "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}],
+   :type=>:Float}}

data/lib/cubecalccrmod/namelists.rb

@@ -0,0 +1,52 @@
+{:cubecalc=>
+  {:description=>"",
+   :should_include=>"true",
+   :variables=>
+    {:calculate_sides=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :code_name=>:calculate_sides,
+       :must_pass=>
+        [{:test=>"kind_of? Integer",
+          :explanation=>"This variable must be an integer."}],
+       :type=>:Integer},
+     :must_sleep=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :code_name=>:must_sleep,
+       :must_pass=>
+        [{:test=>"kind_of? Integer",
+          :explanation=>"This variable must be an integer."}],
+       :type=>:Integer},
+     :width=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :code_name=>:width,
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}],
+       :type=>:Float},
+     :depth=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :code_name=>:depth,
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}],
+       :type=>:Float},
+     :height=>
+      {:should_include=>"true",
+       :description=>nil,
+       :help=>nil,
+       :code_name=>:height,
+       :must_pass=>
+        [{:test=>"kind_of? Numeric",
+          :explanation=>
+           "This variable must be a floating point number (an integer is also acceptable: it will be converted into a floating point number)."}],
+       :type=>:Float}}}}

data/lib/cubecalccrmod/with_namelist.rb

@@ -0,0 +1,43 @@
+class CodeRunner
+	class Cubecalc
+		class WithNamelist < Cubecalc
+			@source_code_subfolders = []
+			setup_namelists(rcp.code_module_folder)
+
+			def parameter_string
+				'input_file.in'
+			end
+
+			def generate_input_file
+				File.open('input_file.in', 'w'){|file| file.puts input_file_text}
+			end
+
+			def input_file_header
+				<<EOF
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+!
+!  Input file for the test program cubecalc_namelist
+!
+!
+!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!
+
+! #@defaults_file_description
+
+EOF
+			end
+
+			def self.defaults_file_header
+				<<EOF
+#############################################################
+#
+# Defaults for the test program cubecalc_namelist
+#
+#############################################################
+
+@defaults_file_description = "Basic defaults"
+EOF
+			end
+		end
+	end
+end
+

data/test/cubecalc.in

@@ -0,0 +1,7 @@
+&cubecalc
+  calculate_sides = 1
+  must_sleep = 1
+  width = 2.7
+  depth = 3.9
+  height = 8.2
+/

data/test/cubecalc_namelist.cc

@@ -0,0 +1,759 @@
+
+#include <stdio.h>
+#include <iostream>
+#include <cstdlib>
+#include <fstream>
+#include <cstring>
+#include <ctime>
+#include <regex.h>
+using namespace std;
+
+/* Fortran Namelist Reader for C
+ * Written by Edmund Highcock
+ * edmundhighcock@sourceforge.net
+ *
+ * This is free software released 
+ * under the GPL v3 */
+
+
+
+int FNR_DEBUG=0;
+
+void fnr_error_message(char * message, int exit)
+{
+	printf("%s\n", message);
+	if (exit) abort();
+}
+
+void fnr_debug_write(char * message)
+{
+	if (FNR_DEBUG) printf("%s\n", message);
+}
+
+struct fnr_struct
+{
+	int n_namelists;
+	char ** namelist_names;
+	int * namelist_sizes;
+	char *** variable_names;
+	char *** variable_values;
+	/*void * template_ptr;*/
+	/*int check_template;*/
+};
+
+int fnr_file_size(FILE * fp)
+{
+		/*Get file size*/
+		int sz;
+		if (FNR_DEBUG) printf("Seeking end\n");
+		fseek(fp, 0L, SEEK_END);
+		if (FNR_DEBUG) printf("Sought end\n");
+		sz = ftell(fp);
+
+		/*Seek back to the beginning:*/
+		fseek(fp, 0L, SEEK_SET);
+		return sz;
+}
+void fnr_read_file(char * fname, char ** text_ptr)
+{
+	/*FILE * fp=fopen("my_file.txt", "r");*/
+
+  	FILE * fp=fopen(fname, "r");
+	
+	if (FNR_DEBUG) printf("Opened file\n");
+	  
+			int sz = fnr_file_size(fp); /* File size*/
+
+		if (FNR_DEBUG) printf("Size was %d\n", sz);
+
+		*text_ptr = (char *)malloc((sz+1)*sizeof(char));
+
+		char *text = *text_ptr;
+		
+
+    int i=0;
+    while(!feof(fp)) {
+			/*printf("I is %d\n", i);*/
+			text[i++] = fgetc(fp);
+			/*printf("reading");*/
+		}
+    text[i-1]='\0';
+		fclose(fp);
+	if (FNR_DEBUG) printf("Read file into memory\n");
+}
+int fnr_count_matches(char * text, regex_t regex){
+
+	int reti;
+	if (FNR_DEBUG) printf("Marker A4\n");
+
+	int location = 0;
+	int text_length = strlen(text);
+	int nmatches=0;
+	if (FNR_DEBUG) printf("Marker D1\n");
+
+	size_t nmatch = 1;
+	regmatch_t  length_match[1];
+	while (location < text_length - 1){
+		if (FNR_DEBUG) printf("Location %d\n", location);
+		reti = regexec(&regex, &text[location], nmatch, length_match, 0);
+		if (!reti)
+		{
+			/*printf("First letter %s", &text[location + length_match[0].rm_so + 4]);*/
+			location = location +  length_match[0].rm_eo ;
+			nmatches += 1;
+		}
+		if (reti) break;
+	}
+	if (FNR_DEBUG) printf("Matches was %d\n", nmatches);
+	return nmatches;
+}
+
+
+int fnr_count_namelists(char * text)
+{
+
+	if (FNR_DEBUG) printf("void fnr_count_namelists; string is %s\n", text);
+	regex_t regex;
+	int reti;
+	int nmatches;
+ 
+
+/* Compile regular expression */
+	/*reti = regcomp(&regex, "&[_[:alnum:]]\\+\\?\n", 0);*/
+	/*reti = regcomp(&regex, "&[_[:alnum:]]+[[:blank:]]", REG_EXTENDED);*/
+	reti = regcomp(&regex, "^&[_[:alnum:]]+[\n\r[:blank:]]", REG_EXTENDED|REG_NEWLINE);
+	if( reti ){ fprintf(stderr, "Could not compile regex\n"); exit(1); }
+	nmatches = fnr_count_matches(text, regex);
+  regfree(&regex);
+	if (FNR_DEBUG) printf("Marker A6\n");
+	return nmatches;
+
+}
+
+int fnr_count_variables(char * text)
+{
+
+	if (FNR_DEBUG) printf("void fnr_count_variables; string is %s\n", text);
+	regex_t regex;
+	int reti;
+	int nmatches;
+ 
+
+/* Compile regular expression */
+	reti = regcomp(&regex, "^[[:space:]]*[_[:alnum:]()]+([[:blank:]]|=)", REG_EXTENDED|REG_NEWLINE);
+	if( reti ){ fprintf(stderr, "Could not compile regex\n"); exit(1); }
+	nmatches = fnr_count_matches(text, regex);
+  regfree(&regex);
+	if (FNR_DEBUG) printf("Marker A8\n");
+	return nmatches;
+
+}
+
+void fnr_match_namelists(char * text, char ** namelist_names, char ** namelist_texts)
+{
+
+	if (FNR_DEBUG) printf("void fnr_match_namelists\n");
+	regex_t regex;
+	int reti;
+	int location = 0;
+	int text_length = strlen(text);
+	//	int nmatches=0;
+	size_t nmatch = 3;
+	regmatch_t  length_match[3];
+	int name_size, ntext_size;
+ 
+
+/* Compile regular expression */
+//	reti = regcomp(&regex, "^&([_[:alnum:]]+)([[:blank:]\n\r](!.*/.*(\r|\n)|[^/]|(\r|\n))+)^/", REG_EXTENDED|REG_NEWLINE);
+	//reti = regcomp(&regex, "[\n\r][[:blank:]]*&([_[:alnum:]]+)([[:blank:]\n\r](!.*[\r\n]|[^/]|[\r\n])+)^/", REG_EXTENDED|REG_NEWLINE);
+	//reti = regcomp(&regex, "^[[:blank:]]*&([_[:alnum:]]+)([[:blank:]\n\r](!.*|[^/\r\n]|[\r\n]+([^/\n\r]|[\n\r][^/]))+)[\r\n]/", REG_EXTENDED|REG_NEWLINE);
+	/*reti = regcomp(&regex, "^[[:blank:]]*&([_[:alnum:]]+)([[:blank:]\n\r]([^\n\r]/|(\n|\r\n)[^/\n\r]|[^\n\r/])+)(\n|\r\n)/", REG_EXTENDED|REG_NEWLINE);*/
+	reti = regcomp(&regex, "^[[:blank:]]*&([_[:alnum:]]+)([[:blank:]\n\r]([^\n\r]/|(\n|\r\n)|[^\n\r/])+)^/", REG_EXTENDED|REG_NEWLINE);
+	/*reti = regcomp(&regex, "^[[:blank:]]*&([_[:alnum:]]+)([[:blank:]\n\r]([^\n\r]/|[^/])+)(\n|\r\n)/", REG_EXTENDED|REG_NEWLINE);*/
+//	reti = regcomp(&regex, "[\n\r][[:blank:]]*&([_[:alnum:]]+)([[:blank:]\n\r](.|[\r\n])+)^/", REG_EXTENDED|REG_NEWLINE);
+	/*reti = regcomp(&regex, "&[_[:alnum:]]\\+\\?\n", 0);*/
+	if( reti ){ fprintf(stderr, "Could not compile regex for matching namelist names and texts\n"); exit(1); }
+  int i = 0;
+
+	while (location < text_length - 1){
+		if (FNR_DEBUG) printf("Location %d\n", location);
+		reti = regexec(&regex, &text[location], nmatch, length_match, 0);
+		char ** ntexts = namelist_texts;
+		char ** nnames = namelist_names;
+		if (!reti)
+		{
+
+			/*Assign namelist name*/
+			name_size = length_match[1].rm_eo - length_match[1].rm_so + 1;
+			nnames[i] = (char *)malloc(name_size*sizeof(char));
+			strncpy(nnames[i], &text[location+length_match[1].rm_so], name_size-1);
+			nnames[i][name_size - 1 ] = '\0';
+
+			/*Assign namelist text*/
+			ntext_size = length_match[2].rm_eo - length_match[2].rm_so + 1;
+			ntexts[i] = (char *)malloc(ntext_size*sizeof(char));
+			strncpy(ntexts[i], &text[location+length_match[2].rm_so], ntext_size-1);
+			ntexts[i][ntext_size - 1] = '\0';
+
+			/*variable_text_size = length_match[2].rm_eo - length_match[2].rm_so;*/
+
+			if (FNR_DEBUG) printf("begin %d, end %d, Size %d, Name %s\n", length_match[1].rm_so, length_match[1].rm_eo, name_size, nnames[i]);
+			if (FNR_DEBUG) printf("begin %d, end %d, Size %d, Name %s\n", length_match[2].rm_so, length_match[2].rm_eo, ntext_size, ntexts[i]);
+			/*nmatches++;*/
+			i++;
+
+			location = location +  length_match[0].rm_eo;
+		}
+		if (reti) {
+			if (FNR_DEBUG) printf("Finished matching namelists\n");
+			break;
+		}
+	}
+	/*printf("F*/
+
+	regfree(&regex);
+}
+
+void fnr_match_variables(char * text, char ** variable_names, char ** variable_values)
+{
+
+	if (FNR_DEBUG) printf("void fnr_match_variables\n");
+	regex_t regex;
+	int reti;
+	int location = 0;
+	int text_length = strlen(text);
+	//	int nmatches=0;
+	size_t nmatch = 6;
+	regmatch_t  length_match[6];
+	int name_size, value_size;
+ 
+
+/* Compile regular expression */
+	/*reti = regcomp(&regex, "(^|\n)[[:space:]]*([_[:alnum:]]+)([[:blank:]]|=)[[:space:]]*=[[:space:]]*(\"([^\"]|\\\\|\\\")+\"|'([[^']|\\\\|\\')+'|[[:alnum:].+-]+)([[:blank:]\r\n]|!)", REG_EXTENDED|REG_NEWLINE);*/
+	reti = regcomp(&regex, "(^|\n|\r)[[:space:]]*([_[:alnum:]()]+)([[:blank:]]+=|=)[[:blank:]]*(\"([^\"]|\\\\|\\\")+\"|'([^']|\\\\|\\')+'|[[:alnum:].+-]+)([[:blank:]\r\n]|!)", REG_EXTENDED|REG_NEWLINE);
+	if( reti ){ fprintf(stderr, "Could not compile regex for matching namelist names and texts\n"); exit(1); }
+  int i = 0;
+
+	if (FNR_DEBUG) printf ("Finished making regex; MARKER D1\n");
+	if (FNR_DEBUG) printf ("location, %d, text_length, %d, text %s\n", location, text_length, text);
+	while (location < text_length - 1){
+		if (FNR_DEBUG) printf("Location %d\n", location);
+		reti = regexec(&regex, &text[location], nmatch, length_match, 0);
+		char ** vnames = variable_names;
+		char ** vvalues = variable_values;
+		if (!reti)
+		{
+
+			/*Assign variable name*/
+			int a = 2;
+			int b = 4;
+			name_size = length_match[a].rm_eo - length_match[a].rm_so + 1;
+			vnames[i] = (char *)malloc(name_size*sizeof(char));
+			strncpy(vnames[i], &text[location+length_match[a].rm_so], name_size-1);
+			vnames[i][name_size - 1 ] = '\0';
+
+			/*Assign variable value*/
+			value_size = length_match[b].rm_eo - length_match[b].rm_so + 1;
+			vvalues[i] = (char *)malloc(value_size*sizeof(char));
+			strncpy(vvalues[i], &text[location+length_match[b].rm_so], value_size-1);
+			vvalues[i][value_size - 1] = '\0';
+
+			/*variable_text_size = length_match[2].rm_eo - length_match[2].rm_so;*/
+
+			if (FNR_DEBUG) printf("begin %d, end %d, Size %d, Name %s\n", length_match[2].rm_so, length_match[2].rm_eo, name_size, vnames[i]);
+			if (FNR_DEBUG) printf("begin %d, end %d, Size %d, Name %s\n", length_match[3].rm_so, length_match[3].rm_eo, value_size, vvalues[i]);
+			/*nmatches++;*/
+			i++;
+
+			location = location +  length_match[0].rm_eo;
+		}
+		if (reti) {
+			if (FNR_DEBUG) printf("Finished matching variables\n");
+			break;
+		}
+	}
+	regfree(&regex);
+}
+
+struct fnr_struct fnr_read_namelist_string(char * file_string)
+{
+	struct fnr_struct namelist_struct;
+	char  ** namelist_texts;
+	if (FNR_DEBUG) printf("The string to be read is %s\n\n", file_string);
+	/*fnr_match_namelists(file_string, namelist_struct.namelist_names, &namelist_texts);*/
+
+	/* Count the namelists and allocate the namelists arrays accordingly */
+	namelist_struct.n_namelists = fnr_count_namelists(file_string);
+
+	namelist_struct.namelist_names  =  (char **)malloc(namelist_struct.n_namelists*sizeof(char *));
+	namelist_struct.namelist_sizes  =   (int *)malloc(namelist_struct.n_namelists*sizeof(int));
+	namelist_struct.variable_names  = (char ***)malloc(namelist_struct.n_namelists*sizeof(char **));
+	namelist_struct.variable_values = (char ***)malloc(namelist_struct.n_namelists*sizeof(char **));
+	namelist_texts                  =  (char **)malloc(namelist_struct.n_namelists*sizeof(char *));
+
+	/* Match all the namelists, put their names into namelist names and
+	 * their content into namelist_texts*/
+	fnr_match_namelists(file_string, namelist_struct.namelist_names, namelist_texts);
+	int i;
+	int nvars;
+	for (i=0; i < namelist_struct.n_namelists; i++)
+	{
+		if (FNR_DEBUG) printf("Analysing namelist %d, called %s\n", i, namelist_struct.namelist_names[i]);
+		nvars = namelist_struct.namelist_sizes[i] = fnr_count_variables(namelist_texts[i]);
+		namelist_struct.variable_names[i] = (char **)malloc(nvars*sizeof(char *));
+		namelist_struct.variable_values[i] = (char **)malloc(nvars*sizeof(char *));
+		fnr_match_variables(namelist_texts[i], namelist_struct.variable_names[i], namelist_struct.variable_values[i]); 
+		free(namelist_texts[i]);
+
+	}
+
+
+	free(namelist_texts);
+
+	return namelist_struct;
+};
+struct fnr_struct fnr_read_namelist_file(char * file_name)
+{
+	char * file_string;
+	/*printf("Marker A1\n");*/
+	printf("Reading file %s\n", file_name);
+	if (FNR_DEBUG) printf("Reading file\n");
+	fnr_read_file(file_name, &file_string);
+	if (FNR_DEBUG) printf("The string read was: \n%s\n", file_string);
+	struct fnr_struct namelist_struct = fnr_read_namelist_string(file_string);
+	return namelist_struct;
+}
+
+void fnr_free(struct fnr_struct * namelist_struct){
+	int i,j;
+	for (i=0; i < namelist_struct->n_namelists; i++)
+	{
+		for (j=0; j < namelist_struct->namelist_sizes[i];j++){
+			free(namelist_struct->variable_names[i][j]);
+			free(namelist_struct->variable_values[i][j]);
+		}
+		free(namelist_struct->variable_names[i]);
+		free(namelist_struct->variable_values[i]);
+		free(namelist_struct->namelist_names[i]);
+	}
+	free(namelist_struct->namelist_sizes);
+	free(namelist_struct->namelist_names);
+	free(namelist_struct->variable_names);
+	free(namelist_struct->variable_values);
+}
+
+
+int FNR_NAMELIST_NOT_FOUND=1;
+int FNR_VARIABLE_NOT_FOUND=2;
+int FNR_VARIABLE_SSCANF_ERROR=3;
+int FNR_NAMELIST_NOT_IN_TEMPLATE=4;
+int FNR_VARIABLE_NOT_IN_TEMPLATE=5;
+
+int fnr_abort_on_error;
+int fnr_abort_if_missing;
+
+/* Defaults */
+/*fnr_abort_on_error=1;*/
+/*fnr_abort_if_missing=0;*/
+
+void fnr_check_rvalue(const char * namelist, const char * variable, int rvalue)
+{
+	if (FNR_DEBUG) printf("rvalue, %d, fnr_abort_if_missing, %d\n", rvalue, fnr_abort_if_missing);
+	if (!rvalue) return;
+	if (fnr_abort_on_error && rvalue == FNR_VARIABLE_SSCANF_ERROR) 
+	{
+		printf("Error in namelist %s, variable %s\n", namelist, variable);
+		abort();
+	}
+	if (fnr_abort_if_missing && rvalue == FNR_NAMELIST_NOT_FOUND) 
+	{
+		printf("Missing  namelist %s\n",  namelist);
+		abort();
+	}
+	if (fnr_abort_if_missing && rvalue == FNR_VARIABLE_NOT_FOUND) 
+	{
+		printf("Missing variable %s in namelist %s\n", variable, namelist);
+		abort();
+	}
+	if (rvalue == FNR_NAMELIST_NOT_IN_TEMPLATE)
+	{
+		printf("Namelist %s is not in template (i.e. it is not a valid namelist).\n", namelist);
+		abort();
+	}
+	if (rvalue == FNR_VARIABLE_NOT_IN_TEMPLATE)
+	{
+		printf("Variable %s in namelist %s is not in template (i.e. it is not a valid variable).\n", variable, namelist);
+		abort();
+	}
+
+	if (FNR_DEBUG) printf("Marker E8\n");
+
+}
+
+int fnr_get_string_no_test(struct fnr_struct * namelist_struct, const char * namelist, const char * variable, char ** value)
+	/*{*/
+	/*int check_template = 0;*/
+	/*struct fnr_struct * dummy;*/
+	/*return fnr_get_string(namelist_struct, namelist, variable, value, check_template, dummy);*/
+	/*}*/
+
+	/*int fnr_get_string(struct fnr_struct * namelist_struct, const char * namelist, const char * variable, char ** value, const int check_template, const struct fnr_struct * namelist_template)*/
+{
+	int i,j;
+	int found_namelist = 0;
+	int found_variable = 0;
+	int rvalue = 0;
+	for (i=0;i<namelist_struct->n_namelists; i++)
+	{
+ 	 if (!strcmp(namelist_struct->namelist_names[i], namelist) )
+	 {
+		 found_namelist = 1;	
+		 break;
+	 }
+	}
+	if (!found_namelist){
+	 	rvalue =  FNR_NAMELIST_NOT_FOUND;
+	}
+	if (found_namelist)
+	{
+	if (FNR_DEBUG) printf("Found namelist %s, size: %d\n", namelist_struct->namelist_names[i], namelist_struct->namelist_sizes[i]);
+		for (j=namelist_struct->namelist_sizes[i]-1;j>-1;j--) 
+			/* Must take the last specification of the variable*/
+		{
+			if (FNR_DEBUG) printf("Marker C2; %d  %s\n", j, namelist_struct->variable_names[i][j]);
+		 if (!strcmp(namelist_struct->variable_names[i][j], variable))
+		 {
+			 found_variable = 1;	
+			 break;
+		 }
+		}
+		if (!found_variable) rvalue = FNR_VARIABLE_NOT_FOUND;
+		if (FNR_DEBUG) printf("Marker C3\n");
+		if (found_variable)
+		{
+			if (FNR_DEBUG) printf("Found variable %s\n", variable);
+			char * v = namelist_struct->variable_values[i][j];
+			if (FNR_DEBUG) printf("Found value %s\n", v);
+			const char * dq = "\"";
+			const char * sq = "'";
+			if (v[0] == dq[0] || v[0] == sq[0])
+			{
+				if (FNR_DEBUG) printf("Value was a string \n");
+				*value = (char *)malloc((strlen(v)-1)*sizeof(char));
+				char * val = *value;
+				if (FNR_DEBUG) printf("Allocated \n");
+				strncpy(val, &v[1], strlen(v)-2);
+				if (FNR_DEBUG) printf("Copied: %s \n", val);
+				val[strlen(v)-2] = '\0';
+				if (FNR_DEBUG) printf("Terminated: %s \n", val);
+			}
+			else 
+			{
+				if (FNR_DEBUG) printf("MARKER D4.5; Length of string %d\n", strlen(variable));
+				*value = (char *)malloc((strlen(v)+1)*sizeof(char));
+				strcpy(*value, v);
+				if (FNR_DEBUG) printf("MARKER D4.6; copied value %s to output: %s\n", *value, v);
+			}
+		}
+	}
+	if (!found_namelist || !found_variable){
+				if (FNR_DEBUG) printf("MARKER D4; Length of string %d\n", strlen(variable));
+				*value = (char *)malloc((strlen(variable)+1)*sizeof(char));
+				/*char empty_string = "";*/
+				if (FNR_DEBUG) printf("Length of variable was %d\n", strlen(variable));
+				if (FNR_DEBUG) printf("MARKER D5\n");
+				strcpy(*value, variable);
+				if (FNR_DEBUG) printf("MARKER D5.3\n");
+				/**value[strlen(variable)] = '\0";*/
+				if (FNR_DEBUG) printf("MARKER D5.5\n");
+	}
+	return rvalue;
+}
+
+int fnr_get_string(struct fnr_struct * namelist_struct, const char * namelist, const char * variable, char ** value)
+{
+  if (FNR_DEBUG) printf("Getting string no test, namelist %s, variable %s\n", namelist, variable);
+	int rvalue = fnr_get_string_no_test(namelist_struct, namelist, variable, value);
+	fnr_check_rvalue(namelist, variable, rvalue);
+	if (FNR_DEBUG) printf("Checked rvalue for %s\n", variable);
+	return rvalue;
+}
+
+int fnr_get_int(struct fnr_struct * namelist_struct, const char * namelist, const char * variable, int * value)
+{
+	char * str_value;
+	int scfrvalue=0;
+	int rvalue;
+	rvalue = fnr_get_string(namelist_struct, namelist, variable, &str_value);
+	if (FNR_DEBUG) printf("Got string for int\n");
+	/*if (rvalue) return rvalue;*/
+	if (FNR_DEBUG) printf("Size of value is %d\n", strlen(str_value));
+	if (FNR_DEBUG) printf("Str value was %s\n", str_value);
+	if (!rvalue) scfrvalue = sscanf(str_value, "%d", value);
+	if (FNR_DEBUG) printf("rvalue was %d\n, int is %d\n", rvalue, *value);
+	if (!rvalue && !scfrvalue) rvalue = FNR_VARIABLE_SSCANF_ERROR;
+	/*else rvalue = 0;*/
+	fnr_check_rvalue(namelist, variable, rvalue);
+	return rvalue;
+}
+
+int fnr_get_bool(struct fnr_struct * namelist_struct, const char * namelist, const char * variable, int * value)
+{
+	char * str_value;
+	//	int scfrvalue=0;
+	int rvalue;
+	rvalue = fnr_get_string(namelist_struct, namelist, variable, &str_value);
+	/*if (rvalue) return rvalue;*/
+	if (FNR_DEBUG) printf("Str value was %s\n", str_value);
+	if (!rvalue) {
+
+		regex_t regex_true, regex_false;
+		int reti;
+	 
+
+	/* Compile regular expression */
+		reti = regcomp(&regex_true, "^(t|\\.true\\.)$", REG_ICASE|REG_EXTENDED);
+		if( reti ){ fprintf(stderr, "Could not compile regex_true\n"); exit(1); }
+		reti = regcomp(&regex_false, "^(f|\\.false\\.)$", REG_ICASE|REG_EXTENDED);
+		if( reti ){ fprintf(stderr, "Could not compile regex_false\n"); exit(1); }
+		reti = regexec(&regex_true, str_value, 0, NULL, 0);
+		if (!reti) *value = 1;
+		else 
+		{
+			if (FNR_DEBUG) printf("Not True\n");
+			reti = regexec(&regex_false, str_value, 0, NULL, 0);
+			if (!reti) *value = 0;
+			else rvalue=FNR_VARIABLE_SSCANF_ERROR;
+		}
+		regfree(&regex_true);
+		regfree(&regex_false);
+		if (FNR_DEBUG) printf("Marker A6\n");
+	}
+	if (FNR_DEBUG) printf("rvalue was %d\n, int is %d\n", rvalue, *value);
+	fnr_check_rvalue(namelist, variable, rvalue);
+	return rvalue;
+}
+
+int fnr_get_float(struct fnr_struct * namelist_struct, const char * namelist, const char * variable, float * value)
+{
+	char * str_value;
+	int rvalue;
+	int scfrvalue=0;
+	rvalue = fnr_get_string(namelist_struct, namelist, variable, &str_value);
+	/*if (rvalue) return rvalue;*/
+	if (FNR_DEBUG) printf("Str value was %s\n", str_value);
+	if (!rvalue) scfrvalue = sscanf(str_value, "%f", value);
+	if (FNR_DEBUG) printf("rvalue was %d\n, float is %f\n", rvalue, *value);
+	if (!rvalue && !scfrvalue) rvalue = FNR_VARIABLE_SSCANF_ERROR;
+	/*else rvalue = 0;*/
+	fnr_check_rvalue(namelist, variable, rvalue);
+	if (FNR_DEBUG) printf("Marker E9\n");
+	return rvalue;
+}
+
+
+int fnr_get_double(struct fnr_struct * namelist_struct, const char * namelist, const char * variable, double * value)
+{
+	char * str_value;
+	int rvalue;
+	int scfrvalue=0;
+	rvalue = fnr_get_string(namelist_struct, namelist, variable, &str_value);
+	/*if (rvalue) return rvalue;*/
+	if (FNR_DEBUG) printf("Marker E1\n");
+	if (FNR_DEBUG) printf("Str value was %s\n, rvalue %d", str_value, rvalue);
+	if (!rvalue) scfrvalue = sscanf(str_value, "%lf", value);
+	if (FNR_DEBUG) printf("scrvalue was %d\n, double is %f\n", rvalue, *value);
+	if (!rvalue && !scfrvalue) rvalue = FNR_VARIABLE_SSCANF_ERROR;
+	/*else rvalue = 0;*/
+	fnr_check_rvalue(namelist, variable, rvalue);
+	return rvalue;
+}
+
+void fnr_check_namelist_against_template(struct fnr_struct * namelist_struct, struct fnr_struct * template_struct)
+{
+	int i,j;
+	for (i=0; i < namelist_struct->n_namelists; i++)
+	{
+		for (j=0; j < namelist_struct->namelist_sizes[i];j++)
+		{
+			char * dummy;
+		  int template_rvalue	= fnr_get_string_no_test(template_struct, namelist_struct->namelist_names[i], namelist_struct->variable_names[i][j], &dummy);
+			if (FNR_DEBUG) printf("Template return value was %d\n", template_rvalue);
+			/*int old_abort = fnr_abort_if_missing;*/
+			/*fnr_abort_if_missing = 0;*/
+			int rvalue = template_rvalue;
+			if (template_rvalue == FNR_NAMELIST_NOT_FOUND) rvalue = FNR_NAMELIST_NOT_IN_TEMPLATE;
+			if (template_rvalue == FNR_VARIABLE_NOT_FOUND) rvalue = FNR_VARIABLE_NOT_IN_TEMPLATE;
+			fnr_check_rvalue(namelist_struct->namelist_names[i], namelist_struct->variable_names[i][j], rvalue);
+		}
+	}
+}
+
+
+const char * FNR_TEMPLATE_STRING =  "\n\
+\n\
+&my_namelist\n\
+	beta = \"This is some help for beta\"\n\
+/\n\
+\n\
+&my_namelist1\n\
+  !asd\n\
+	beta = 2.7 ! adadfsa\n\
+ asdf = \"xxxsdfa\"\n\
+\n\
+/\n\
+";
+
+
+// int main (int argc, char ** argv) {
+// 	if (argc < 2) fnr_error_message("Please pass the first test input file as the first parameter.", 1);
+// 
+// 	int noah = 1;
+// 
+// 	if (noah)
+// 	{
+// 		struct fnr_struct namelist_struct = fnr_read_namelist_file(argv[1]);
+// 		int Nx;
+// 		fnr_abort_on_error = 1;
+// 		fnr_abort_if_missing = 1;
+// 
+// 		if(fnr_get_int(&namelist_struct, "kt_grids_box_parameters", "nx", &Nx)) *&Nx=128;
+// 		printf("Nx was %d\n", Nx);
+// 		return(0);
+// 	}
+// 
+// 	if (argc < 3) fnr_error_message("Please pass the second test input file as the second parameter.", 1);
+// 	if (FNR_DEBUG) printf("Read namelist template???\n");
+// 
+// 	if (!strcmp(argv[1], "help_variable"))
+// 	{
+// 		if (argc < 4) fnr_error_message("Please pass the namelist as the second parameter and the variable as the third.", 1);
+// 		struct fnr_struct template_struct_help = fnr_read_namelist_string(FNR_TEMPLATE_STRING);
+// 		if (FNR_DEBUG) printf("Read namelist template successful\n");
+// 		fnr_abort_on_error = 1;
+// 		fnr_abort_if_missing = 1;
+// 		char * help;
+// 		if (fnr_get_string(&template_struct_help, argv[2], argv[3], &help))
+// 			printf("No help available");
+// 		else
+// 			printf("%s\n", help);
+// 		exit(0);
+// 	}
+// 
+// 	struct fnr_struct namelist_struct = fnr_read_namelist_file(argv[1]);
+// 	/*namelist_struct.check_template = 0;*/
+// 
+// 	fnr_abort_on_error = 1;
+// 	fnr_abort_if_missing = 1;
+// 
+// 	/* String */
+// 	/* fnr_get returns 0 if successful */
+// 	char * collision_model;
+// 	if (fnr_get_string(&namelist_struct, "collisions_knobs", "collision_model", &collision_model))
+// 		collision_model = "default";
+// 	printf("Collison model was %s\n", collision_model);
+// 
+// 	/* Integer */
+// 	int nx;
+// 	if (fnr_get_int(&namelist_struct, "kt_grids_box_parameters", "nx", &nx)) nx = 0;
+// 	printf("nx was %d\n", nx);
+// 
+// 	/* Float */
+// 	float g_exb;
+// 	if (fnr_get_float(&namelist_struct, "dist_fn_knobs", "g_exb", &g_exb)) g_exb = 4.0;
+// 	printf("g_exb was %f\n", g_exb);
+// 
+// 	/* Double */
+// 	double phiinit;
+// 	if (fnr_get_double(&namelist_struct, "init_g_knobs", "phiinit", &phiinit)) phiinit = 0.0;
+// 	printf("phiinit was %f\n", phiinit);
+// 
+// 	/*Bool*/
+// 	int write_phi_over_time;
+// 	if (fnr_get_bool(&namelist_struct, "gs2_diagnostics_knobs", "write_phi_over_time", &write_phi_over_time)) write_phi_over_time = 0;
+// 	printf("write_phi_over_time was %d\n", write_phi_over_time);
+// 
+// 
+// 	/*Fails*/
+// 	/*if (fnr_get_double(&namelist_struct, "init_g_knobs", "hiinit", &phiinit)) phiinit = 0.0;*/
+// 	/*printf("phiinit was %f\n", phiinit);*/
+// 
+// 	printf("Success!\n");
+// 
+// 
+// 	struct fnr_struct namelist_struct_with_template = fnr_read_namelist_file(argv[2]);
+// 	if (FNR_DEBUG) printf("Finished reading second namelist\n\n");
+// 	struct fnr_struct template_struct = fnr_read_namelist_string(FNR_TEMPLATE_STRING);
+// 
+// 	fnr_abort_on_error = 1;
+// 	fnr_abort_if_missing = 0;
+// 
+// 	double beta = 1.2;
+// 	if (fnr_get_double(&namelist_struct_with_template, "my_namelist1", "beta", &beta)) beta = 0.5; 
+// 	printf("beta was %e\n", beta);
+// 
+// 	fnr_check_namelist_against_template(&namelist_struct_with_template, &template_struct);
+// 
+// 	fnr_free(&namelist_struct);
+// 	fnr_free(&namelist_struct_with_template);
+// 	fnr_free(&template_struct);
+// }
+// 
+// 
+// 
+// 
+// 
+
+int main(int argc, char* argv[]){
+	string line;
+	cout << "Starting..." << endl;
+	
+	
+	char* input_file_name = argv[1]; //Get the input file name from the command line
+	cout << input_file_name << endl;
+	
+	struct fnr_struct namelist_file;
+
+	namelist_file = fnr_read_namelist_file(input_file_name);
+
+	int calculate_sides; //Should the program calculate the area of the sides of the cube? 
+
+	if (fnr_get_int(&namelist_file, "cubecalc", "calculate_sides", &calculate_sides)) calculate_sides = 0;
+	cout << calculate_sides << endl;
+
+	int must_sleep;
+	if (fnr_get_int(&namelist_file, "cubecalc", "must_sleep", &must_sleep)) must_sleep = 0;
+	
+	if (must_sleep){ //It has been told to sleep for a time
+		bool cont = true;
+		time_t start_t;
+		time(&start_t);
+		while (cont){
+			time_t new_t;
+			time(&new_t);
+			cont = (new_t < (start_t + must_sleep * 1.0));
+		}
+	}
+	
+	float* edges = new float[3];
+	if (fnr_get_float(&namelist_file, "cubecalc", "width", &edges[0])) edges[0] = 1.0;
+	if (fnr_get_float(&namelist_file, "cubecalc", "depth", &edges[1])) edges[1] = 1.0;
+	if (fnr_get_float(&namelist_file, "cubecalc", "height", &edges[2])) edges[2] = 1.0;
+	printf("edges[0] %f\n", edges[0]);
+	
+	
+	FILE* output = fopen("results.txt", "w"); //Write the volume to the output file
+	fprintf(output, "Volume was %f", edges[0] * edges[1] * edges[2]);
+	fclose(output);
+	
+	if (calculate_sides == 1){ //If it has been told to calculate the sides
+		cout << "calculating sides" << endl;
+		FILE* sides = fopen("sides.txt", "w");
+		for(int i=0; i<3; i++){
+			cout << "Side " << i << ": " << edges[(i%3)] * edges[((i+1)%3)] << endl;
+			fprintf(sides, "The area of side %d is %f\n", i, edges[i%3] * edges[(i+1)%3]);
+		}
+		fclose(sides);
+	}
+}
+	

data/test/test_coderunner.rb

@@ -21,6 +21,7 @@ $coderunner_command = "#{$ruby_command}  -I lib/ lib/coderunner.rb"
 	#raise "Couldn't build test program using #{string}" unless system string
 #end
 
+if true
 class TestSubmission  < Test::Unit::TestCase
 	def setup
 		string = $cpp_command + ' ../cubecalc.cc -o cubecalc'
@@ -349,6 +350,7 @@ EOF
 	end # if ENV['LATEX']
 		
 end # class TestCodeRunner
+end # if false/true
 
 #class TestFortranNamelist < Test::Unit::TestCase
 	##require 'gs2crmod'
@@ -359,3 +361,33 @@ end # class TestCodeRunner
 		#end
 	#end
 #end
+#
+#
+ENV['CR_NON_INTERACTIVE'] = 'true'
+class TestFortranNamelistC < Test::Unit::TestCase
+	def setup
+	end
+	def test_synchronise_variables
+		#FileUtils.rm('lib/cubecalccrmod/namelists.rb')
+		CodeRunner.setup_run_class('cubecalc', modlet: 'with_namelist')
+		assert_equal(File.read('test/cubecalc_namelist.cc').size+1, CodeRunner::Cubecalc::WithNamelist.get_aggregated_source_code_text('test').size)
+		CodeRunner::Cubecalc::WithNamelist.synchronise_variables('test')
+	end
+	def tfolder
+		'test/submit_with_namelist'
+	end
+	def test_submit
+		CodeRunner.setup_run_class('cubecalc', modlet: 'with_namelist')
+		assert_system("#$cpp_command test/cubecalc_namelist.cc -o test/cubecalc_namelist")
+		CodeRunner::Cubecalc::WithNamelist.make_new_defaults_file('cubecalctest', 'test/cubecalc.in')
+		FileUtils.mv('cubecalctest_defaults.rb', CodeRunner::Cubecalc::WithNamelist.rcp.user_defaults_location + '/cubecalctest_defaults.rb')
+		FileUtils.makedirs(tfolder)
+		CodeRunner.submit(C: 'cubecalc', m: 'with_namelist', Y: tfolder, X: Dir.pwd + '/test/cubecalc_namelist', D: 'cubecalctest')
+		CodeRunner.status(Y: tfolder)
+		runner = CodeRunner.fetch_runner(Y: tfolder)
+		assert_equal(86.35, runner.run_list[1].volume.round(2))
+		FileUtils.rm_r(tfolder)
+		FileUtils.rm(CodeRunner::Cubecalc::WithNamelist.rcp.user_defaults_location + '/cubecalctest_defaults.rb')
+		FileUtils.rm('test/cubecalc_namelist')
+	end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: coderunner
 version: !ruby/object:Gem::Version
-  version: 0.12.19
+  version: 0.13.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-08-07 00:00:00.000000000 Z
+date: 2013-08-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: graphkit
@@ -206,6 +206,7 @@ files:
 - lib/coderunner/class_methods.rb
 - lib/coderunner/feedback.rb
 - lib/coderunner/fortran_namelist.rb
+- lib/coderunner/fortran_namelist_c.rb
 - lib/coderunner/graphs_and_films.rb
 - lib/coderunner/heuristic_run_methods.rb
 - lib/coderunner/instance_methods.rb
@@ -236,8 +237,13 @@ files:
 - lib/cubecalccrmod/default_modlets/empty_defaults.rb
 - lib/cubecalccrmod/defaults_files/cubecalc_defaults.rb
 - lib/cubecalccrmod/defaults_files/sleep_defaults.rb
+- lib/cubecalccrmod/deleted_variables.rb
 - lib/cubecalccrmod/empty.rb
+- lib/cubecalccrmod/namelists.rb
 - lib/cubecalccrmod/sleep.rb
+- lib/cubecalccrmod/with_namelist.rb
+- test/cubecalc.in
+- test/cubecalc_namelist.cc
 - test/fortran_namelist.in
 - test/helper.rb
 - test/old_test.rb