diff --git a/src/parse.cpp b/src/parse.cpp
new file mode 100644
--- /dev/null
+++ b/src/parse.cpp
@@ -0,0 +1,397 @@
+/*
+ *
+ *  This file is part of the Virtual Leaf.
+ *
+ *  The Virtual Leaf is free software: you can redistribute it and/or modify
+ *  it under the terms of the GNU General Public License as published by
+ *  the Free Software Foundation, either version 3 of the License, or
+ *  (at your option) any later version.
+ *
+ *  The Virtual Leaf is distributed in the hope that it will be useful,
+ *  but WITHOUT ANY WARRANTY; without even the implied warranty of
+ *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ *  GNU General Public License for more details.
+ *
+ *  You should have received a copy of the GNU General Public License
+ *  along with the Virtual Leaf.  If not, see <http://www.gnu.org/licenses/>.
+ *
+ *  Copyright 2010 Roeland Merks.
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <string.h>
+#include "warning.h"
+#include "parse.h"
+#include "output.h"
+#include <string>
+
+static const std::string _module_id("$Id$");
+
+using namespace MyWarning;
+
+char *ParsePar(FILE *fp, char *parameter, bool wrapflag) 
+{
+  char *line,*token;
+  char *value;
+  
+  line=SearchToken(fp,parameter, wrapflag);
+  if (line==NULL) {
+    warning("Warning: Token %s not found.",parameter);
+    value=0;
+    return value;
+  }
+  
+  /* parse the line on = sign */
+  token=strtok(line,"=");
+  if (token==NULL) {
+	error("Parse error: no '=' sign found next to token %s, in line: \n %s.",
+		  parameter,line);
+   }
+
+  // warning("Reading value for token %s...",token);
+  fprintf(stderr, "[%s = ",token);
+  
+  token=strtok(NULL,"=");
+  if (token==NULL)
+	error("\nParse error: no value found after '=' sign, in line: \n %s",
+		  line);
+
+  value=strdup(token);
+  free(line);
+  
+  return value;
+      
+}
+
+
+int igetpar(FILE *fp,char *parameter, bool wrapflag) {
+  
+  // overloaded compatibility function. Doesn't need default parameter
+  // default = 0
+  
+  return igetpar(fp, parameter, 0, wrapflag);
+}
+
+int igetpar(FILE *fp,char *parameter, int default_val, bool wrapflag) 
+{
+  char *token;
+  int value;
+  
+  /* Get token representing the value */
+  token=ParsePar(fp,parameter, wrapflag);
+
+  if (token==0) {
+    /* default value */
+    warning("No token %s found. Using default value %d.\n", parameter, default_val);
+    return default_val;
+  }
+  /* read it */
+  sscanf(token,"%d",&value);
+  fprintf(stderr, "%d]\n",value);
+  
+  free(token);
+
+  return value;
+  
+}
+
+float fgetpar(FILE *fp,char *parameter, bool wrapflag) {
+   
+  // overloaded compatibility function. Doesn't need default parameter
+  // default = 0
+  
+  return fgetpar(fp, parameter, 0., wrapflag);
+
+}
+
+float fgetpar(FILE *fp, char *parameter, double default_val, bool wrapflag) 
+{
+  char *token;
+  float value;
+
+  /* Get token representing the value */
+  token=ParsePar(fp,parameter, wrapflag);
+
+  if (token==0) {
+    /* default value */
+    warning("No token %s found. Using default value %f.\n", parameter, default_val);
+    return default_val;
+  }
+
+  /* read it */
+  sscanf(token,"%e",&value);
+
+  fprintf(stderr,"%e]\n",value);
+  
+  free(token);
+
+  return value;
+  
+}
+
+
+double *dgetparlist(FILE *fp,char *parameter, int n, bool wrapflag) 
+{
+  /* Get a list of n comma separated doubles */
+  char *token;
+  double *value;
+  char *number;
+  int i;
+
+  value=(double *)malloc(n*sizeof(double));
+  
+  /* Get token representing the value */
+  token=ParsePar(fp,parameter, wrapflag);
+  
+  if (token==0) {
+    error("No token %s found.\n", parameter);
+  }
+  /* parse it */
+  number=strtok(token,","); /* make a pointer to "token" */
+  
+  i=0;
+  while (number!=NULL) {
+    
+    if (i>=n) {
+      error("\nToo many values found for parameterlist '%s' (%d expected).",parameter,n);
+    }
+    
+    sscanf(number,"%le",&value[i]);
+    fprintf(stderr,"[%f]",value[i]);
+    
+    /* next value */
+    number=strtok(NULL,",");
+    i++;
+  }
+  
+  fprintf(stderr,"]\n");
+  
+  if (i<n) {
+    warning("Too few values found for parameterlist '%s' (%d expected).", parameter,n);
+    warning("Padding with 0.");
+    for (int j=i;j<n;j++) 
+      value[j]=0.;
+    
+    fprintf(stderr, "Full array is ");
+    for (int i=0;i<n;i++) {
+      fprintf(stderr," %lf ",value[i]);
+    }
+    fprintf(stderr, "\n");
+  }
+  
+  return value;
+  
+}
+
+char *sgetpar(FILE *fp,char *parameter, bool wrapflag) 
+{
+  return sgetpar(fp, parameter, " ", wrapflag);
+}
+
+char *sgetpar(FILE *fp, char *parameter, const char *default_val, bool wrapflag) {
+
+  char *token;
+  char *value;
+  int pos;
+    
+  /* Get token representing the value */
+  token=ParsePar(fp,parameter, wrapflag);
+
+  if (token==0) {
+    /* default value */
+    warning("No token %s found. Using default value '%s'.\n", parameter, default_val);
+    value=strdup(default_val);
+    return value;
+  }
+  
+  /* strip leading spaces and duplicate string */
+  pos=strspn(token," \t\n");
+  value=(char *)malloc((strlen(&token[pos])+1)*sizeof(char));
+  sprintf(value,"%s",&token[pos]);
+  free(token);
+
+  fprintf(stderr,"%s]\n",value);
+
+  return value;
+  
+}
+
+char *bool_str(bool bool_var) {
+  
+  /* Return string "true" if bool_var=true */
+  /* Return string "false" if bool_var=false */
+  
+  static char t[5] = "true";
+  static char f[6] = "false";
+
+  if (bool_var) {
+    return t;
+  } else {
+    return f;
+  }
+  
+}
+
+bool bgetpar(FILE *fp, char *parameter,  bool wrapflag) {
+  
+  // overloaded compatibility function. Doesn't need default parameter
+  // default = false
+
+  return bgetpar(fp, parameter, 0, wrapflag);
+
+}
+
+bool bgetpar(FILE *fp, char *parameter, int default_val, bool wrapflag) {
+
+  /* Get boolean parameter. */
+  /* if "true" or "yes", return 1 */
+  /* if "false" or "no", return 0 */
+  /* else complain */
+
+  char *token;
+  int value=0;
+  int pos;
+    
+  /* Get token representing the value */
+  token=ParsePar(fp,parameter, wrapflag);
+
+  if (token==0) {
+    /* default value */
+    warning("No token %s found. Using default value %s.\n", parameter, bool_str(default_val));
+    return default_val;
+  }
+
+    
+  /* strip leading spaces */
+  pos=strspn(token," \t\n");
+  
+  if (!strcmp(&token[pos],"yes") || !strcmp(&token[pos],"true") || !strcmp(&token[pos],"1"))
+    value=1;
+  else 
+    if (!strcmp(&token[pos],"no") || !strcmp(&token[pos],"false") || !strcmp(&token[pos],"0"))
+      value=0;
+  else
+    error("Keyword '%s' not recognized. Try yes/no or true/false.\n",&token[pos]);
+
+  fprintf(stderr, "%s]\n",bool_str(value));
+
+  return value;
+
+}
+
+
+char *SearchToken(FILE *fp, char *token,bool wrapflag) 
+{
+  /* This function returns the next line of FILE *fp that contains
+     the string stored in the null terminated string token */
+
+  /* remember to free the memory allocated for line */
+  
+  unsigned int len;
+  char *line;
+  int wrapped=false;
+  long initial_position;
+  
+  /*  rewind(fp); */
+
+  char *tokenplusspace = (char *)malloc( (strlen(token)+3)*sizeof(char));
+  strcpy(tokenplusspace, token);
+  strcat(tokenplusspace," ");
+  
+  initial_position=ftell(fp);
+  if (ferror(fp)) /* error occured */
+    {
+      error("%s",strerror(errno));
+    }
+
+ 
+  if (feof(fp)) {
+    warning("End of file\n");
+  }
+  
+  
+  while (!(wrapped && ftell(fp)>=initial_position)) {
+
+    /* As long as the search was not wrapped and we are not
+     * back to where we were, continue searching */
+		
+    /* Read a line, and check whether an EOF was found */
+    if ((line=ReadLine(fp))==NULL) {
+      /* Yes? wrapflag on? => Wrap. */
+      if (wrapflag) {
+	wrapped=true;
+	fseek(fp,0L,SEEK_SET);
+	continue;
+      } else 
+	break;
+    }
+
+    /* strip leading spaces */
+    int pos=strspn(line," \t\n");
+
+    if (line[pos]=='#') {
+     
+      continue;
+    } 
+    
+    len=strlen(line);
+    if (strlen(tokenplusspace)<=len) {
+
+      /* only if the line is longer than the token, it might be found */
+      // if (strstr(line,tokenplusspace)!=NULL) /* FOUND */
+      if (strstr(line,tokenplusspace)==(&line[pos])) /* FOUND */
+	{
+	  free(tokenplusspace);
+	  return line;
+	}
+    }
+    
+
+    free(line);
+    
+  }
+  free(tokenplusspace);
+  return NULL; /* Token Not Found in the file */
+}
+
+int TokenInLineP(char *line,char *token) 
+{
+  if (strstr(token, line)!=NULL)
+    return true;
+  else
+    return false;
+}
+
+
+void SkipLine(FILE *fp) {
+  
+  /* Just skips a line in FILE *fp */
+  char *tmpstring;
+  tmpstring=ReadLine(fp);
+  free(tmpstring);
+  
+}
+
+void SkipToken(FILE *fp,char *token, bool wrapflag)
+{
+  /* A very simple function:
+	 call SearchToken() and get rid of the memory returned by
+     it.
+	 Also, return an error if the desired token was not found in the file.
+  */
+  char *tmppointer;
+
+  tmppointer=SearchToken(fp,token, wrapflag);
+
+  if (tmppointer==NULL) {
+	error("Token `%s' not found by function SkipToken.\n",token);
+  }
+
+  free(tmppointer);
+      
+}
+