Parameters.cc

#include <fstream>
#include <sstream>
#include <algorithm>
#include <stdarg.h>
#include <time.h>
#include <cstring>
#include <sys/types.h>
#include <sys/stat.h>

#ifndef WIN32
#include <unistd.h>
#endif

#include "Parameters.h"
#include "Serializer.h"

namespace AMDiS {

  const char Parameters::comment='%';
  const std::string Parameters::separators=",; ";
  Parameters* Parameters::singlett = NULL;
  const char* Parameters::param_call_fct = NULL;
  const char* Parameters::param_call_file = NULL;
  int Parameters::param_call_line = 0;


  int Parameters::getGlobalParameter(int info, const std::string& key, 
				     const char *format, ...)
  {
    FUNCNAME("Parameters::getGlobalParameter()");

    std::vector<struct Parameters::param>::iterator i;
    param tParam(key);
    const char* funcName2 = param_call_fct ? param_call_fct : funcName;
    va_list arg;

    Parameters::initIntern();

    if (Parameters::singlett->paramInfo) {
      if (Parameters::singlett->paramInfo > 1)
	info = max(info, Parameters::singlett->paramInfo - 1);
    } else {
      info = 0;
    }

    if (0 == Parameters::singlett->allParam.size()) {
      if (0 == Parameters::singlett->filename.size()) {
	INFO(info, 1)("no parameters defined\n");
	return 0;
      } else {
	Parameters::singlett->read(Parameters::singlett->filename,key);
      }
    }

    i = std::find(Parameters::singlett->allParam.begin(),
		  Parameters::singlett->allParam.end(), tParam);

    if (i == Parameters::singlett->allParam.end()) {
      if (funcName != funcName2) {
	INFO(info, 1)("initialization of parameter `%s'\n", key.data());
	INFO(info, 1)("fails on line %d of file %s\n", param_call_line,
		     param_call_file);
      } else {
	INFO(info, 1)("initialization of parameter `%s' fails\n", key.data());
      }
   
      return 0;
    }

    va_start(arg, format);
    int count = 0;
  
    INFO(info, 2)("parameter `%s' initialized with: ", key.data());

    std::string s = (*i).parameters;
 
    for (const char *p = format; *p; p++) {
      if (*p != '%')  
	continue;

      const char *word = Parameters::singlett->getNextWord(&s);
      if (!*word) {
	PRINT_INFO(info, 2)("\n");
	if (0 < (*i).funcName.size()) {
	  INFO(info, 4)("parameter initialized by %s()\n", (*i).funcName.data());
	  INFO(info, 4)("on line %d of file \"%s\"\n", 
			(*i).lineNo, (*i).filename.data());
	} else if (0 < (*i).filename.size()) {
	  INFO(info, 4)("parameter initialized on line %2d of init file \"%s\"\n",
			(*i).lineNo, (*i).filename.data());
	} else {
	  INFO(info, 4)("location of initialization unknown\n");
	}
	va_end(arg);
	return count;
      }
      count++;

      switch(*++p) {
      case 'S':
	{
	  char *Sval = va_arg(arg, char *);
	  *Sval = static_cast<char>(atoi(word));
	  INFO(info, 2)("%d ", *Sval);
	}
	break;
      case 'U':
	{
	  unsigned char *Uval = va_arg(arg, unsigned char *);
	  *Uval = static_cast<unsigned char>(atoi(word));
	  INFO(info, 2)("%d ", *Uval);
	}
	break;
      case 'c':
	{
	  char *cval = va_arg(arg, char *); 
	  *cval = *word;
	  INFO(info, 2)("%c ", *cval);
	}
	break;
      case 's':
	{
	  char *sval = va_arg(arg, char *);
	  strcpy(sval, word);
	  INFO(info, 2)("%s ", sval);
	}
	break;
      case 'd':
	{
	  int *ival = va_arg(arg, int *);
	  *ival = atoi(word);
	  INFO(info, 2)("%d ", *ival);
	}
	break;
      case 'e':
      case 'f':
      case 'g':
	{
	  double *rval = va_arg(arg, double *);
	  *rval = atof(word);
	  INFO(info, 2)("%g ", *rval);
	}
	break;
      case 'v':	
	{
	  WorldVector<double> *vecVal = va_arg(arg, WorldVector<double> *);
	  std::string sstr = std::string(word);
	  int ind = 0;
	  int found = sstr.find_first_of(",; ");
	  std::string seperator;
	  seperator = sstr[found];
	  
	  while (found != static_cast<int>(std::string::npos) && 
		 ind < static_cast<int>(vecVal->size())) {
	    if (found > 0) {
	      (*vecVal)[ind] = atof(sstr.substr(0, found).c_str());
	      ind++;
	    }
	    sstr = sstr.substr(found + 1);
	    found = sstr.find_first_of(seperator);
	  }
	  if (sstr.length() > 0 && ind < static_cast<int>(vecVal->size()))
	    (*vecVal)[ind] = atof(sstr.c_str());	
	}
	break;
      case 'E': // list of double values, example parameter: {a,b,c,d,e}
      case 'F':
      case 'G':
	{
	  std::vector<double> *vecVal = va_arg(arg, std::vector<double> *);
	  std::string sstr = std::string(word);

       std::string brackets1 = "[{(", brackets2 = "]})";
	  int bracketIdx1 = sstr.find_first_of(brackets1);
       int bracket = brackets1.find_first_of(sstr[bracketIdx1]);
       int bracketIdx2 = sstr.find_first_of(brackets2[bracket]);
       TEST_EXIT(bracket>=0 && bracketIdx1>=0 && bracketIdx2>=0 && bracketIdx1<bracketIdx2)
		("no enclosing brackets found in '%s' \n",key.data());
       sstr = sstr.substr(bracketIdx1+1, bracketIdx2-bracketIdx1);

	  int found = sstr.find_first_of(separators);
	  std::string seperator;
	  seperator = sstr[found];
	  
	  while (found != static_cast<int>(std::string::npos)) {
	    if (found > 0) {
	      vecVal->push_back(atof(sstr.substr(0, found).c_str()));
	    }
	    sstr = sstr.substr(found + 1);
	    found = sstr.find_first_of(seperator);
	  }
	  if (sstr.length() > 0)
	    vecVal->push_back(atof(sstr.c_str()));
       if(vecVal->size()==0)
         WARNING("no values in parameter vector!\n");
	}
	break;
      case 'D': // list of int values, example parameter: {a,b,c,d,e}
	{
	  std::vector<int> *vecVal = va_arg(arg, std::vector<int> *);
	  std::string sstr = std::string(word);

       std::string brackets1 = "[{(", brackets2 = "]})";
	  int bracketIdx1 = sstr.find_first_of(brackets1);
       int bracket = brackets1.find_first_of(sstr[bracketIdx1]);
       int bracketIdx2 = sstr.find_first_of(brackets2[bracket]);
       TEST_EXIT(bracket>=0 && bracketIdx1>=0 && bracketIdx2>=0 && bracketIdx1<bracketIdx2)
		("no enclosing brackets found in '%s' \n",key.data());
       sstr = sstr.substr(bracketIdx1+1, bracketIdx2-bracketIdx1);

	  int found = sstr.find_first_of(separators);
	  std::string seperator;
	  seperator = sstr[found];
	  
	  while (found != static_cast<int>(std::string::npos)) {
	    if (found > 0) {
	      vecVal->push_back(atoi(sstr.substr(0, found).c_str()));
	    }
	    sstr = sstr.substr(found + 1);
	    found = sstr.find_first_of(seperator);
	  }
	  if (sstr.length() > 0)
	    vecVal->push_back(atoi(sstr.c_str()));
       if(vecVal->size()==0)
         WARNING("no values in parameter vector!\n");
	}
	break;
      case '*':
	break;
      default: 
	INFO(info, 2)("\n");
	INFO(info, 2)
	  ("unknow format specifier `%%%c', skipping initialization of %s\n",
	   *p, key.data());
      }
    }

    INFO(info, 2)("\n");

    if ((*i).funcName.size() > 0) {
      INFO(info, 4)("parameter initialized by %s()\n", (*i).funcName.data());
      INFO(info, 4)("on line %d of file \"%s\"\n", (*i).lineNo,
		   (*i).filename.data());
    } else if ((*i).filename.size() > 0) {
      INFO(info, 4)
	("parameter initialized on line %2d of init file \"%s\"\n",
	 (*i).lineNo, (*i).filename.data());
    } else {
      INFO(info, 4)("location of initialization unknown\n");
    }
    
    va_end(arg);

    return count;
  }


  int Parameters::getGlobalParameter(int flag, const std::string& key, 
				     std::string* param)
  {
    static char tempParam[255];
    TEST_EXIT(param)("no parameter\n");
    strcpy(tempParam, param->c_str());
    int result = getGlobalParameter(flag, key, "%s", tempParam);
    param->assign(tempParam);
    return result;
  }


  void Parameters::read(const std::string& aFilename, 
			const std::string& maxKey)
  {
    FUNCNAME("Parameters::read()");

    char line[256];
    int nLine = 0;
    std::string key, parameter;
    std::string actfile;

    if (aFilename.size() == 0)
      return;

    singlett->inputFile.open(aFilename.c_str(), std::ios::in);
    if (!inputFile.is_open()) {
      ERROR("init-file can't be opened\n");
      return;
    }

    INFO(paramInfo, 2)("reading from file %s\n", aFilename.data());
    actfile = getActFile(aFilename);
    
    while (!inputFile.eof()) {
      inputFile.getline(line, 255);
      nLine++;

      key = getKey(line, nLine, aFilename);
      
      if (key == "")
	continue;

      parameter = getPar(key, line, &nLine, aFilename);
      if (parameter == "")  
	continue;
      
      addParam(key, parameter, actfile, nLine, funcName);
    }

    singlett->inputFile.close();
  }


  const std::string& Parameters::getActFile(const std::string& aFilename)
  {
    FUNCNAME("Parameters::getActFile()");

    std::list< std::string >::iterator i;
    for (i = filenames.begin(); i != filenames.end(); i++)
      if (aFilename==*i) 
	break;
  
    if (i != filenames.end()) {
      return(const_cast<const std::string&>(*i));
    } else {
      filenames.push_back(aFilename);
      return(const_cast<const std::string&>(aFilename));
    }
  }


  void Parameters::swap(int i, int j)
  {
    param tmp(allParam[i]);
    allParam[i] = allParam[j];
    allParam[j] = tmp;
  }


  void Parameters::qsort(int left, int right)
  {
    if (left >= right) 
      return;

    swap(left, (left + right) / 2);
    int last = left;
    for (int i = left + 1; i <= right; i++)
      if (allParam[i].key.compare(allParam[left].key) < 0)
	swap(++last, i);

    swap(left, last);
    qsort(left, last - 1);
    qsort(last + 1, right);
  }


  const std::string Parameters::getKey(const std::string& s, int nLine, 
					 const std::string& aFilename)
  {
    FUNCNAME("Parameters::getKey()");

    std::string fn, key = "";
    char c;
    int i, epos;
    std::string h = " \t\r\f";
    int pos = s.find_first_not_of(" \t\f\r"); //skip Blank
  
    if (pos < 0)
      return key;

    if (s[pos] == comment || s[pos] == '\0' || s[pos] == '\n')
      return(key);

    if (s[pos] == '#') {
      if (static_cast<int>(s.find("#include")) == pos) {
	/****************************************************************************/
	/*  another init file has to be included                                    */
	/****************************************************************************/

	pos += strlen("#include");
	pos = s.find_first_not_of(" \t\f\r");

	i = 0;
	switch (c = s[pos++]) {
	case '<':
	  c = '>';
	case '\"':
	  h += c;
	  epos = s.find_first_not_of(h, pos);
	  fn = s.substr(pos,epos-1);
       
	  if (s[epos] != c) {
	    ERROR("aFilename of include not terminated by %c\n", c);
	    ERROR("skipping line %d of file %s\n", nLine, aFilename.c_str());
	    return("");
	  }
	  break;
	default:
	  ERROR("no aFilename of include file found\n");
	  ERROR("skipping line %d of file %s\n", nLine, aFilename.c_str());
	  return("");
	}

	read(fn);
	return("");
      } else {
	ERROR("# must not be the first character on a line; except #include\n");
	return("");
      }
    }

    /****************************************************************************/
    /*  now get the key                                                         */
    /****************************************************************************/
    i = 0;
    epos=s.find_first_of(":#",pos+1);
    if (s[epos] == '#') {
      ERROR("key must not contain '%c'.\n", '#');
      ERROR("Skipping line %d of file %s\n", nLine, aFilename.c_str());
      return("");
    }
  
    key = s.substr(pos,epos);

    if (s[epos] != ':') {
      ERROR("key was not terminated by ':'.\n");
      ERROR("Skipping line %d of file %s\n", nLine, aFilename.c_str());
      return("");
    }
    
    if (key.size() == 0) {
      ERROR("use of ':' without key.\n");
      ERROR("Skipping line %d of file %s\n", nLine, aFilename.c_str());
      return("");
    }

    return key;
  }

  const std::string Parameters::getPar(const std::string& key, 
				       const std::string& si, int *nl, 
				       const std::string& fn)
  {
    FUNCNAME("Parameters::getPar()");

    int ol = *nl;
    std::string inp;
    std::string s = si;
    std::string parameter="";

    int pos = s.find(':');
    pos = s.find_first_not_of(" \r\f\t",pos+1);
  
    int i = pos;
    while(i < static_cast<int>(s.length()) && 
	  s[i] != '#' && s[i] != '%' && s[i] != '\n') {
      if (s[i] == '\\'  && i+1 < static_cast<int>(s.length()) &&  s[i + 1] == '\n') {
	s = s.substr(0, i);
	(*nl)++;
	inputFile >> inp;
	s+=inp;
	if (inputFile.eof()) {
	  ERROR("EOF reached while reading parameters of key %s\n", key.c_str());
	  if (ol == *nl-1) 
	    ERROR("Skipping line %d of file %s\n", *nl, fn.c_str());
	  else     
	    ERROR("Skipping lines %d-%d of file %s\n", ol, *nl, fn.c_str());
	    
	  return("");
	}
      } else {
	if (isBlankChar(static_cast<char>(s[i]))) {
	  parameter+= ' ';
	  i=pos=s.find_first_not_of(" \r\t\f", i);
	  if (i == static_cast<int>(std::string::npos)) {
	    i = parameter.length()-1;
	    break;
	  }
	} else {
	  parameter += s.substr(i++,1);
	}
      }
    }

    i = parameter.find_last_not_of(" \r\t\f");
    parameter.resize(i + 1);

    if (i == 0 && isBlankChar(parameter[0])) {
      ERROR("no parameter of key %s.\n", key.c_str());
      if (ol == *nl) 
	ERROR("Skipping line %d of file %s\n", *nl, fn.c_str());
      else   
	ERROR("Skipping lines %d-%d of file %s\n", ol, *nl, fn.c_str());

      return("");
    }

    return parameter;
  }

  void Parameters::addParam(const std::string& key, 
			    const std::string& parameter,
			    const std::string& actfile, 
			    int  nLine, 
			    const std::string& fname)
  {
    FUNCNAME("Parameters::addParam()");

    unsigned size_k, size_p;
    int scmp = 0;
    param newPar;

    size_k = key.size()+1;
    size_p = parameter.size()+1;

    std::vector<param>::iterator it;
    for (it = allParam.begin(); it != allParam.end(); it++)
      if ((scmp = key.compare((*it).key)) >=0)  
	break;  

    if (it != allParam.end() && scmp == 0) {
      /****************************************************************************/
      /*  key does already exist: save new parameters                             */
      /****************************************************************************/
      (*it).parameters = parameter;
      (*it).filename = actfile;
      (*it).funcName = fname;
      (*it).lineNo = nLine;
      
      return;
    }

    newPar.key = key;
    newPar.parameters = parameter;
    newPar.filename = actfile;
    newPar.funcName.assign(fname);
    newPar.lineNo = nLine;
    allParam.insert(it, newPar);
  }



  void Parameters::initIntern()
  {
    if (singlett == NULL)
      singlett = new Parameters;
  }

  void Parameters::printParameters()
  {
    FUNCNAME("Parameters::printParameters()");

    initIntern();

    std::vector<param>::iterator it;
    for (it = singlett->allParam.begin(); it != singlett->allParam.end(); it++) {
      MSG("%s:  %s\n", (*it).key.data(), (*it).parameters.data());
      if (0 < (*it).funcName.size()) {
	MSG("initialized by %s() on line %3d of file \"%s\"\n", 
	    (*it).funcName.data(), (*it).lineNo, (*it).filename.data());
      }	else if (0 < (*it).filename.size()) {
	MSG("initialized on line %2d of file \"%s\"\n",
	    (*it).lineNo, (*it).filename.data());
      } else {
	MSG("can not locate initialization location\n");
      }
    }
  }


  void Parameters::init(int p, std::string fn, const char *flags)
  {
    FUNCNAME("Parameters::init()");
  
    std::ostringstream tmp_file;
    std::ofstream cpp_flags;
    std::ofstream call_cpp;
    std::string file;
    std::ofstream outFile;
    std::string lfn = fn;
    std::string::size_type fpos= lfn.find('/');

    if (fpos == std::string::npos)
      fpos = 0;
    else
      ++fpos;
    
    lfn.insert(fpos,".#");

#ifdef WIN32
    int val(0);
#else
    struct stat buf;

    int val = lstat(lfn.c_str(), &buf);
    if (val == 0)
      if (buf.st_mode&S_IFLNK && buf.st_size > 0)
	ERROR_EXIT("Unsaved version of init file exists\n");

#endif
    initIntern();
    if (0 == fn.size()) {
      Global::init();
      return;
    }

    if (NULL == flags) {
      singlett->read(fn);
    } else {
      singlett->inputFile.open(fn.data(), std::ios::in);
      if (!(singlett->inputFile.rdstate())) {
	ERROR("can not read from file %s\n", fn.data());
	return;
      }
      singlett->inputFile.close();

      ERROR("no cpp available; reading file %s without help of cpp\n", fn.c_str());
      init(p, fn);
      
      return;
    } 

    val = 10; // default for level of information
    getGlobalParameter(0, "level of information", "%d", &val);
    singlett->msgInfo=val;

    val = 1; // default for WAIT
    getGlobalParameter(0, "WAIT", "%d", &val);
    singlett->msgWait=val;

    val = 1; // default for parameter information
    getGlobalParameter(0, "parameter information", "%d", &val);
    singlett->paramInfo = val;

    if (!singlett->msgInfo)  
      singlett->paramInfo = 0;
  
    if (p && singlett->msgInfo) 
      printParameters();
  
    Global::init();
  } 

  void Parameters::readArgv(int argc, char **argv)
  {
    FUNCNAME("Parameters::readArgv()");

    for (int i = 0; i < argc; i++)
      if (strcmp("-rs", argv[i]) == 0)
	ADD_PARAMETER(0, "argv->rs", argv[i + 1]);
  }

  int Parameters::initFuncName(const char * call_fct, const char * call_file, 
			       int call_line)
  {
    param_call_fct = call_fct;
    param_call_file = call_file;
    param_call_line = call_line;

    return 1;
  }

  int Parameters::binSearch(const std::string& key, int n_keys)
  {
    int left = 0;
    int right = n_keys - 1;
  
    while (left <= right) {
      int mid = (left + right) / 2;
      int cond = allParam[mid].key.compare(key);
      if (cond  < 0) {
	left = mid + 1;
      } else if (cond > 0) {
	right = mid - 1;
      }	else {
	return mid;
      }
    }

    return -1;
  }


 
  void Parameters::addGlobalParameter(int p, const std::string key, 
				      const std::string par, const char *fname, 
				      const char *file, int line)
  {
    FUNCNAME("Parameters::addGlobalParameter()");

    initIntern();

    if (key.size() == 0 || par.size() == 0)
      return;

    std::string file_str;
    if(file != NULL)
      file_str = std::string(file);
    std::string fname_str;
    if(fname != NULL)
      fname_str = std::string(fname);
    singlett->addParam(key, par, file_str, line, fname_str);

    int val = 10; // defualt for level of information
    getGlobalParameter(0, "level of information", "%d", &val);
    singlett->msgInfo = val;

    val = 1; // default for WAIT
    getGlobalParameter(0, "WAIT", "%d", &val);
    singlett->msgWait = val;

    val = 1; // default for parameter information
    getGlobalParameter(0, "parameter information", "%d", &val);
    singlett->paramInfo = val;

    if (!singlett->msgInfo)  
      singlett->paramInfo = 0;
  
    if (p && singlett->msgInfo) 
      printParameters();  
  }  



  const char *Parameters::getNextWord(std::string *s) const
  {
    static char Val[512];
  
    int wb1 = s->find_first_not_of(" "); 
    if (wb1 == static_cast<int>(std::string::npos))
      return NULL;    

    int wb2 = s->find_first_of(" ");
    if (wb2 == static_cast<int>(std::string::npos))
      wb2 = s->length();
    
    s->copy(Val, wb2 - wb1, wb1);

    Val[wb2 - wb1] = '\0';

    return Val;
  }

  void Parameters::save(const std::string file, int info)
  {
    std::ofstream fp;
    std::vector<param>::iterator it;

    initIntern();

    fp.open(file.data(), std::ios::out);
    if (0 != fp.rdstate())
      return;

    for (it = singlett->allParam.begin(); it !=singlett->allParam.end(); it++) {
      fp << (*it).key <<  ":  " << (*it).parameters << std::endl;

      if (info) {
	if (((*it).funcName.size()) > 0) {
	  fp << "%initialized by " << (*it).funcName << "() on line " <<
	    (*it).lineNo << " of file \"" << (*it).filename << "\"" << std::endl;
	} else if ((*it).filename.size() > 0) {
	  fp << "%initialized on line "<< (*it).lineNo << 
	    " of file \""<< (*it).filename << "\""<< std::endl;
	}
      }
    }
    fp.close();
  }

  void Parameters::clear() 
  {
    if (singlett != NULL)
      delete singlett;
  }

  void Parameters::serialize(std::ostream &out)
  {
    SerUtil::serialize(out, paramInfo);
    SerUtil::serialize(out, msgInfo);
    SerUtil::serialize(out, msgWait);
    int size = static_cast<int>(allParam.size());
    SerUtil::serialize(out, size);
    for (int i = 0; i < size; i++)
      allParam[i].serialize(out);
  }

  void Parameters::deserialize(std::istream &in)
  {
    SerUtil::deserialize(in, paramInfo);
    SerUtil::deserialize(in, msgInfo);
    SerUtil::deserialize(in, msgWait);
    int size;
    SerUtil::deserialize(in, size);
    allParam.resize(size);
    for (int i = 0; i < size; i++)
      allParam[i].deserialize(in);
  }

  int Parameters::param::operator==(const param& aParam) const
  { 
    return key == aParam.key;
  }

  void Parameters::param::serialize(std::ostream &out)
  {
    out << key << std::endl;
    out << parameters << std::endl;
    out << filename << std::endl;
    out << funcName << std::endl;
    SerUtil::serialize(out, lineNo);
  }
  
  void Parameters::param::deserialize(std::istream &in)
  {
    in >> key; in.get();
    in >> parameters; in.get();
    in >> filename; in.get();
    in >> funcName; in.get();
    SerUtil::deserialize(in, lineNo);
  }

}