DeSR Dependency Parser

ixe/conf/conf.cpp

/*
**  IXE C++ Library
**  ixe/conf/conf.cpp
**  ----------------------------------------------------------------------
**  Copyright (c) 2000  Ideare SpA.
**  Copyright (c) 2000  Giuseppe Attardi (attardi@di.unipi.it).
**  ----------------------------------------------------------------------
**
**  This file is part of DeSR.
**
**  DeSR is free software; you can redistribute it and/or modify it
**  under the terms of the GNU General Public License, version 3,
**  as published by the Free Software Foundation.
**
**  DeSR 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 this program.  If not, see <http://www.gnu.org/licenses/>.
**  ----------------------------------------------------------------------
*/

// Settings
#include "conf/conf.h"

// standard
#include <cctype>
#include <cstring>
#include <iostream>

// local
#include "include/config.h"     // ConfigFileDefault
#include "io/mappedFile.h"
#include "Common/util.h"
#include "conf/conf_bool.h"     // so we can declare verbosity

using namespace std;
using namespace IXE::io;

namespace IXE {

int     Configuration::current_config_file_line_no = 0;

conf<bool>      VerboseConfig("VerboseConfig", false);

//=============================================================================
//=============================================================================

Configuration::Map& Configuration::variables()
{
  static Map    m;
  return m;
}

void Configuration::insert(Configuration::Item* var)
{
  variables()[var->name()] = var;
}

//=============================================================================

void Configuration::load(char const* file_name)
{
  try {
    mappedFile conf_file(file_name);

    register int line_no = 0;
    register mappedFile::const_iterator c = conf_file.begin(), nl = c;

    while (c != conf_file.end() && nl != conf_file.end()) {
      if (!(nl = ::strchr(c, '\n')))
        //
        // We can't find a "line," i.e., a sequence of
        // characters terminated by a newline, so stop.
        //
        break;
      ++line_no;
      //
      // See if the line is entirely whitespace optionally followed
      // by a comment starting with '#': if so, skip it.  If we don't
      // end up skipping it, leading whitespace will have been skipped.
      //
      while (c != nl && isspace((unsigned char)*c))
        ++c;
      if (c == nl || *c == '#')
        c = nl + 1;
      else if (c != nl) {
        //
        // The line has something on it worth parsing further
        // parseLine advances c and line_no
        parseLine(c, line_no);
      }
    }
  } catch (MmapError&) {
    if (!::strcmp(file_name, ConfigFileDefault))
      //
      // The configuration file couldn't be opened; however,
      // the file name is the default, so assume that none is
      // being used and simply return.
      //
      error() << "could not read configuration from \""
      << file_name << '"' << endl;
  }
}

void Configuration::load(istream& is, Map* vars, char const* close)
{
  int line_no = 0;
  string line;
  while (getline(is, line)) {
    ++line_no;
    if (line == close)          // stop at close tag
      return;
    // combine multiple lines
    while (line[line.size() - 1] == '\\') {
      line[line.size() - 1] = '\n';
      string cont;
      if (getline(is, cont))
        line += cont;
    }
    char const* c = line.c_str();
    char const* end = c + line.size();
    // skip leading whitespace
    while (c != end && isspace((unsigned char)*c))
      ++c;
    // skip comments
    if (*c != '#') {
      // The line has something on it worth parsing further
      // parseLine advances c and line_no
      parseLine(c, line_no, vars);
    }
  }
}

static int count_lines(char const* start, char const* end)
{
  int count = 0;
  while ((start = ::strchr(start, '\n')) && start < end) {
    start++;
    count++;
  }
  return count;
}

static inline void SKIP_EOL(char const*& x)
{
  if (x[0] == '\r') {
    ++x;
    if (x[0] == '\n') ++x;
  } else if (x[0] == '\n') {
    ++x;
    if (x[0] == '\r') ++x;
  }
}

// FIXME: include Mac \n\r sequence.
#define EOL(x)  ((x)[0] == '\n' || (x)[0] == '\r' && (x)[1] == '\n')
#define SKIP_EOL(x) {if ((x)[0] == '\r') ++(x); ++(x);}
char  const* next_token_line(char const*& ptr, const char* sep, char esc)
{
  // skip all letters that are included in the separator string
  // as well as newline preceded by esc character
  while (*ptr) {
    if (*ptr == esc) {
      ++ptr;
      if (EOL(ptr+1)) {
        SKIP_EOL(ptr);
      } else if (*ptr)
        ++ptr;
    } else if (EOL(ptr))
      return 0;
    else if (strchr(sep, *ptr))
      ++ptr;
    else
      break;
  }

  if (*ptr) {
    // so this is where the next piece of string starts
    char const* start = ptr++;

    // scan through the string to find where it ends, it ends on a
    // null byte or a character that exists in the separator string
    while (*ptr && !EOL(ptr)) {
      if (*ptr == esc) {
        ++ptr;
        if (*ptr)
          ++ptr;
      } else if (strchr(sep, *ptr))
        break;
      else
        ++ptr;
    }
    if (ptr == start)           // no tokens on this line
      return 0;
    return start;               // return the position where the string starts
  }

  // we ended up on a null byte, there are no more strings to find!
  return 0;
}

//=============================================================================

void Configuration::parseLine(char const*& line, int& line_no, Map* params)
{
  current_config_file_line_no = line_no;
  char const* varstart = next_token_line(line, " \r\t"); // just the variable name
  char var[256];
  int len = line - varstart;
  ::strncpy(var, varstart, len);
  var[len] = '\0';
  Map vars = (params == 0) ? variables() : *params;
  Map::const_iterator const v = vars.find(var);
  if (v == vars.end()) {
    if (VerboseConfig)
      warning() << '"' << line << "\" in config. file unrecognized; ignored\n";
  } else {
    //
    // Remove leading whitespace from value and then parse each line
    // in a series, where \ is a continuation mark
    //
    while (*line && line[0] != '\n' && isspace((unsigned char)*line))
      ++line;
    char const* start = line;
    if (line[0] != '\n')
      v->second->parseValue(line);
    line_no += count_lines(start, line);
    // skip to next line
    char const* endline = ::strpbrk(line, "\n\r");
    if (endline) {
      line = endline;
      SKIP_EOL(line);
    }
  }
}

//=============================================================================

void Configuration::reset()
{
  TRANSFORM_EACH(Configuration::Map, Configuration::variables(), v)
    v->second->reset();
}

//=============================================================================

ostream& Configuration::msg(ostream& o, char const* label)
{
  if (current_config_file_line_no) {
    o << "config file line " << current_config_file_line_no;
    current_config_file_line_no = 0;
  }
  return o << ": " << label << ": ";
}

} // namespace IXE

 

Copyright © 2005-2007 G. Attardi. Generated on 13 Aug 2009 by doxygen 1.5.7.1.