parse_values.C

/*
 * This file is part of the "Archon" framework.
 * (http://files3d.sourceforge.net)
 *
 * Copyright © 2002 by Kristian Spangsege and Brian Kristiansen.
 *
 * Permission to use, copy, modify, and distribute this software and
 * its documentation under the terms of the GNU General Public License is
 * hereby granted. No representations are made about the suitability of
 * this software for any purpose. It is provided "as is" without express
 * or implied warranty. See the GNU General Public License
 * (http://www.gnu.org/copyleft/gpl.html) for more details.
 *
 * The characters in this file are ISO8859-1 encoded.
 *
 * The documentation in this file is in "Doxygen" style
 * (http://www.doxygen.org).
 */

#include <ctype.h>
#include <string.h>
#include <math.h>

#include <archon/util/parse_values.H>

namespace Archon
{
  namespace Utilities
  {
    namespace ParseValues
    {
      static bool keywordCompare(const char *s, const char *stop,
                                 const char *lowercaseKeyword)
      {
        while(s<stop && *lowercaseKeyword && *reinterpret_cast<const unsigned char *>(lowercaseKeyword) == tolower(*reinterpret_cast<const unsigned char *>(s)))
          ++s, ++lowercaseKeyword;
        return s==stop && !*lowercaseKeyword;
      }

      bool parseBoolean(bool versatile, const char *s, const char *stop) throw(ParseException)
      {
        if(!stop) stop = s + strlen(s);
        if(s == stop) ARCHON_THROW1(ParseException, "No boolean value");
        if(keywordCompare(s, stop, "true"))  return true;
        if(keywordCompare(s, stop, "false")) return false;
        if(versatile)
        {
          if(keywordCompare(s, stop, "y"))   return true;
          if(keywordCompare(s, stop, "n"))   return false;
          if(keywordCompare(s, stop, "yes")) return true;
          if(keywordCompare(s, stop, "no"))  return false;
          if(keywordCompare(s, stop, "on"))  return true;
          if(keywordCompare(s, stop, "off")) return false;
          try { return parseInteger(false, s, stop); }
          catch(ParseException &) {}
        }
        ARCHON_THROW1(ParseException,
                      "\"" + string(s, stop-s) +
                      "\" is an invalid boolean value");
      }

      int parseInteger(bool acceptSign, const char *s, const char *stop) throw(ParseException)
      {
        if(!stop) stop = s + strlen(s);
        if(s == stop) ARCHON_THROW1(ParseException,
                                    "No integer value");

        bool neg = false;

        if(acceptSign)
        {
          if(*s == '+') ++s;
          else if(*s == '-') ++s, neg = true;
        }

        int val = 0;
        while(s < stop && *s >= '0' && *s <= '9')
        {
          val *= 10;
          val += *s - '0';
          ++s;
        }

        if(s != stop)
          ARCHON_THROW1(ParseException,
                        "\"" + string(s, stop-s) + "\" is an invalid " +
                        (acceptSign ? "integer value" :
                         "unsigned integer value"));

        return neg ? -val : val;
      }

      double parseDouble(const char *s, const char *stop) throw(ParseException)
      {
        if(!stop) stop = s + strlen(s);
        if(s == stop) ARCHON_THROW1(ParseException,
                                    "No double value");

        bool neg = false;
        if(*s == '+') ++s;
        else if(*s == '-') ++s, neg = true;

        double val = 0;
        bool ok = false;

        // Integer digits
        while(s < stop && *s >= '0' && *s <= '9')
        {
          val *= 10;
          val += *s - '0';
          ok = true;
          ++s;
        }

        // Fractional digits
        if(s < stop && *s == '.')
        {
          ++s;
          double frac = 1;
          while(s < stop && *s >= '0' && *s <= '9')
          {
            frac /= 10;
            val += (*s - '0')*frac;
            ok = true;
            ++s;
          }
        }

        if(!ok) ARCHON_THROW1(ParseException,
                              "\"" + string(s, stop-s) +
                              "\" is an invalid double value");

        // Exponetial digits
        if(s < stop && (*s == 'e' || *s == 'E'))
          val *= pow(10.0, parseInteger(true, ++s, stop));
        else
          if(s != stop) ARCHON_THROW1(ParseException,
                                      "\"" + string(s, stop-s) +
                                      "\" is an invalid double value");

        return neg ? -val : val;
      }

      string parseString(const char *s, const char *stop) throw(ParseException)
      {
        if(!stop) stop = s + strlen(s);
        if(s == stop) ARCHON_THROW1(ParseException,
                                    "No string value");
      
        return string(s, stop-s);
      }
    }
  }
}

---