/*
*
* 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 .
*
* Copyright 2010 Roeland Merks.
*
*/
#include
#include
#include
#include
#include
#include "warning.h"
#include "parse.h"
#include "output.h"
#include
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
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
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=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);
}
/* finis */