options.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 <stdio.h>
#include <string>
#include <iostream>

#include <archon/math/vector.H>
#include <archon/util/parse_values.H>
#include <archon/util/text.H>
#include <archon/util/options.H>
#include <archon/util/stream.H>
#include <archon/util/color.H>

using namespace std;

namespace Archon
{
  using namespace Math;

  namespace Utilities
  {
    template<>
    bool Options::Parser<bool>::parse(const char *s) throw(ParseException)
    {
      return Utilities::ParseValues::parseBoolean(true, s);
    }

    template<>
    string Options::Parser<bool>::format(bool v)
    {
      return v ? "yes" : "no";
    }

    template<>
    int Options::Parser<int>::parse(const char *s) throw(ParseException)
    {
      return Utilities::ParseValues::parseInteger(true, s);
    }

    template<>
    string Options::Parser<int>::format(int v)
    {
      return Text::toString(v);
    }

    template<>
    double Options::Parser<double>::parse(const char *s) throw(ParseException)
    {
      return Utilities::ParseValues::parseDouble(s);
    }

    template<>
    string Options::Parser<double>::format(double v)
    {
      return Text::toString(v);
    }

    template<>
    string Options::Parser<string>::parse(const char *s) throw(ParseException)
    {
      return s;
    }

    template<>
    string Options::Parser<string>::format(string v)
    {
      return v;
    }


    template<>
    Options::IntByInt Options::Parser<Options::IntByInt>::parse(const char *s)
      throw(ParseException)
    {
      try
      {
        IntByInt r;
        int i=0;
        while(s[i] && s[i] != 'x' && s[i] != 'X') ++i;
        r.x = ParseValues::parseInteger(false, s, s+i);
        if(s[i])
          r.y = ParseValues::parseInteger(false, s+i+1);
        else r.y = r.x;
        return r;
      }
      catch(ParseException &e)
      {
        ARCHON_THROW1(ParseException,
                      "Invalid resolution '" + string(s) + "'");
      }
    }

    template<>
    string Options::Parser<Options::IntByInt>::format(IntByInt v)
    {
      char buf[100];
      sprintf(buf, "%dx%d", v.x, v.y);
      return buf;
    }


    template<>
    Vector3 Options::Parser<Vector3>::parse(const char *s)
      throw(ParseException)
    {
      try
      {
        Vector3 v;
        int i=0;
        while(s[i] && s[i] != ',') ++i;
        if(!s[i]) ARCHON_THROW1(ParseException,
                                "Invalid vector '" + string(s) + "'");
        v[0] = ParseValues::parseDouble(s, s+i);
        ++i;
        int j=i;
        while(s[i] && s[i] != ',') ++i;
        if(!s[i]) ARCHON_THROW1(ParseException,
                                "Invalid vector '" + string(s) + "'");
        v[1] = ParseValues::parseDouble(s+j, s+i);
        ++i;
        v[2] = ParseValues::parseDouble(s+i);
        return v;
      }
      catch(ParseException &e)
      {
        ARCHON_THROW1(ParseException,
                      "Invalid vector '" + string(s) + "'");
      }
    }

    template<>
    string Options::Parser<Vector3>::format(Vector3 v)
    {
      char buf[100];
      sprintf(buf, "%g,%g,%g", v[0], v[1], v[2]);
      return buf;
    }


    template<>
    ColorRGBA Options::Parser<ColorRGBA>::parse(const char *s)
      throw(ParseException)
    {
      try
      {
        ColorRGBA c;
        int j, i=0;
        while(s[i] && s[i] != ',') ++i;
        c[0] = ParseValues::parseDouble(s, s+i);
        if(!s[i]) ARCHON_THROW1(ParseException,
                                "Invalid color '" + string(s) + "'");
        ++i;
        j=i;
        while(s[i] && s[i] != ',') ++i;
        c[1] = ParseValues::parseDouble(s+j, s+i);
        if(!s[i]) ARCHON_THROW1(ParseException,
                                "Invalid color '" + string(s) + "'");
        ++i;
        j=i;
        while(s[i] && s[i] != ',') ++i;
        c[2] = ParseValues::parseDouble(s+j, s+i);
        if(!s[i]) c[3] = 1;
        else
        {
          ++i;
          c[3] = ParseValues::parseDouble(s+i);
        }
        return c;
      }
      catch(ParseException &e)
      {
        ARCHON_THROW1(ParseException,
                      "Invalid color '" + string(s) + "'");
      }
    }

    template<>
    string Options::Parser<ColorRGBA>::format(ColorRGBA c)
    {
      char buf[200];
      sprintf(buf, "%g,%g,%g,%g", c[0], c[1], c[2], c[3]);
      return buf;
    }


    void Options::verify(string shortName, string longName)
      throw(DefinitionException)
    {
      if(!shortName.size() && !longName.size())
        ARCHON_THROW1(DefinitionException,
                      "You may not omit both the short "
                      "and the long name");
      if(shortName.size() > 1)
        ARCHON_THROW1(DefinitionException,
                      "Illegal length of short name \"" +
                      shortName + "\"");

      if(shortName.size())
        for(unsigned i=0; i<defs.size(); ++i)
          if(shortName == defs[i]->shortName)
            ARCHON_THROW1(DefinitionException,
                          "Redefinition of short name \"" +
                          shortName + "\"");
      if(longName.size())
        for(unsigned i=0; i<defs.size(); ++i)
          if(longName == defs[i]->longName)
            ARCHON_THROW1(DefinitionException,
                          "Redefinition of long name \"" +
                          longName + "\"");
    }

    Options::Options(bool treatNegativeNumbersAsOptions, Logger *l):
      treatNegativeNumbersAsOptions(treatNegativeNumbersAsOptions),
      logger(l)
    {
      if(!logger) logger = Logger::get();
    }

    Options::~Options()
    {{ // The extra scope is needed to work around gcc3.2 bug #8287
      for(unsigned i=0; i<defs.size(); ++i) delete defs[i];
    }}

    Options::ArgType Options::examineArg(string arg)
    {
      return
        !arg.size() || arg[0] != '-' ? argType_normal :
        arg.size() > 1 && arg[1] == '-' ? argType_longOption :
        !treatNegativeNumbersAsOptions &&
        arg.size() > 1 && isdigit(arg[1]) ? argType_normal :
        argType_shortOption;
    }

    bool Options::processCommandLine(int &argc, const char *argv[],
                                     bool switchesOnly)
    {
      bool error = false;
      unsigned j = 1;
      for(unsigned i=1; i<static_cast<unsigned>(argc); ++i)
      {
        string arg = argv[j] = argv[i];
        ArgType argType = examineArg(arg);

        // Skip non-switch arguments
        if(argType == argType_normal)
        {
          ++j;
          continue;
        }

        // Lookup the switch
        const Def *d = 0;
        if(argType == argType_shortOption)
        {
          for(unsigned k=0; k<defs.size(); ++k)
            if(defs[k]->shortName.size() &&
               defs[k]->shortName == arg.substr(1))
            {
              d = defs[k];
              break;
            }
        }
        else
        {
          for(unsigned k=0; k<defs.size(); ++k)
            if(defs[k]->longName.size() &&
               defs[k]->longName == arg.substr(2))
            {
              d = defs[k];
              break;
            }
        }

        if(!d)
        {
          if(switchesOnly) ++j;
          else
          {
            logger->log("Commandline error: Unrecogninzed option '" +
                        arg + "'");
            error = true;
          }
          continue;
        }

        // Check for switch arguments
        const char *optionArg = 0;
        if(d->wantArg != wantArg_never)
        {
          if(i+1<static_cast<unsigned>(argc) && examineArg(argv[i+1]) == argType_normal)
            optionArg = argv[++i];
          else if(d->wantArg == wantArg_always)
          {
            if(switchesOnly) ++j;
            else
            {
              logger->log("Commandline error: Missing mandatory argument for option '" +
                          arg + "'");
              error = true;
            }
            continue;
          }
        }

        // Evaluate switch
        if((!switchesOnly || d->switchOnly)) try
        {
          d->execute(this, optionArg);
        }
        catch(ParseException &e)
        {
          logger->log("Commandline error: " + e.getMessage());
          error = true;
        }
        else
        {
          ++j;
          if(optionArg) argv[j++] = optionArg;
        }
      }

      argc = j;

      return error;
    }

    namespace
    {
      struct LineReader
      {
        Ref<Stream::Reader> subReader;
        string buffer;

        LineReader(Ref<Stream::Reader> r): subReader(r) {}

        string readLine()
          throw(Stream::ReadException, UnexpectedException)
        {
          string::size_type i = 0;

          for(;;)
          {
            string::size_type j = buffer.find('\n', i);
            if(j != string::npos)
            {
              i = j+1;
              break;
            }

            i = buffer.size();

            char b[1024];
            int n = subReader->read(b, sizeof(b));
            if(!n) break;
            buffer.append(b, n);
          }

          string l(buffer, 0, i);
          buffer.erase(0, i);
          return l;
        }
      };

      void stripLeadSpace(string &s)
      {
        string::size_type i = 0;
        while(i<s.size() && isspace(s[i])) ++i;
        s.erase(0, i);
      }

      struct EatException: virtual Utilities::Exception
      {
        EatException(string l, string m): Utilities::Exception(l, m) {}
      };

      string eatQuoteWord(string &_s) throw(EatException)
      {
        string s = _s;
        stripLeadSpace(s);
        if(s.empty()) return "";
        string t;
        string::size_type i = 0;
        while(i<s.size())
        {
          if(isspace(s[i])) break;
          if(s[i] == '"')
          {
            ++i;
            for(;;)
            {
              if(i == s.size())
                ARCHON_THROW1(EatException,
                              "Unterminated double-quoted part");

              if(s[i] == '"')
              {
                ++i;
                break;
              }

              if(s[i] == '\\')
              {
                ++i;
                if(i == s.size())
                  ARCHON_THROW1(EatException,
                                "Unterminated escape sequence '\\'");
                switch(s[i])
                {
                case 'n':  t += "\n"; break;
                case 't':  t += "\t"; break;
                case 'v':  t += "\v"; break;
                case 'b':  t += "\b"; break;
                case 'r':  t += "\r"; break;
                case 'f':  t += "\f"; break;
                case 'a':  t += "\a"; break;
                case '\\': t += "\\"; break;
                case '"':  t += "\""; break;

                case 'x':
                  {
                    if(i+2 >= s.size())
                      ARCHON_THROW1(EatException,
                                    "Unterminated escape sequence '\\x'");

                    ++i;
                    int c = static_cast<unsigned char>(s[i]);
                    ++i;
                    int d = static_cast<unsigned char>(s[i]);

                    if(!isxdigit(c) || !isxdigit(d))
                      ARCHON_THROW1(EatException,
                                    "Invalid escape sequence '\\x" +
                                    s.substr(i, 2) + "'");

                    if(isdigit(c)) c -= '0';
                    else if(isupper(c)) c -= 'A';
                    else  c -= 'a';

                    if(isdigit(d)) d -= '0';
                    else if(isupper(d)) d -= 'A';
                    else  d -= 'a';

                    t += static_cast<char>(static_cast<unsigned char>(16*c+d));
                  }
                  break;

                default:
                      ARCHON_THROW1(EatException,
                                    "Unrecognized escape sequence '\\" +
                                    s.substr(i) + "'");
                }

                ++i;
              }
              else
              {
                t += s[i];
                ++i;
              }
            }
          }
          else
          {
            t += s[i];
            ++i;
          }
        }

        _s = s.substr(i);
        return t;
      }

      string printQuoteWord(string s)
      {
        bool quote = s.empty();
        for(string::size_type i=0; i<s.size(); ++i)
        {
          int c = s[i];
          if(!isgraph(c) || c == '"')
          {
            quote = true;
            break;
          }
        }
        return quote ? Text::escapeNonprintable(s) : s;
      }
    }

    bool Options::processConfigFile(string path) throw(FileAccessException)
    {
      Ref<Stream::Reader> r;
      try
      {
        r = Stream::makeFileReader(path);
      }
      catch(Stream::FileOpenException &e)
      {
        ARCHON_THROW1(FileAccessException, e.getMessage());
      }

      bool error = false;
      LineReader lineReader(r);
      unsigned long n = 0;
      for(;;)
      {
        string l = lineReader.readLine();
        if(l.empty()) break;
        ++n;
        stripLeadSpace(l);
        if(l.empty() || l[0] == '#') continue;
        try
        {
          string name = eatQuoteWord(l);
          if(name.empty())
          {
            logger->log(path + ":" + Text::toString(n) +
                        ": Empty option name");
            error = true;
            continue;
          }
          stripLeadSpace(l);
          const char *optionArg = 0;
          string value;
          if(!l.empty())
          {
            for(;;)
            {
              string v = eatQuoteWord(l);
              if(v.empty()) break;
              if(!value.empty()) value += " ";
              value += v;
            }
            optionArg = value.c_str();
          }

          const Def *d = 0;
          for(unsigned i=0; i<defs.size(); ++i)
            if(defs[i]->longName.size() &&
               defs[i]->longName == name)
            {
              d = defs[i];
              break;
            }

          if(!d)
          {
            logger->log(path + ":" + Text::toString(n) +
                        ": Unrecogninzed option '" + name + "'");
            error = true;
            continue;
          }

          if(d->wantArg == wantArg_never && optionArg)
          {
            logger->log(path + ":" + Text::toString(n) +
                        ": Option '" + name + "' accepts no value");
            error = true;
            continue;
          }

          if(d->wantArg == wantArg_always && !optionArg)
          {
            logger->log(path + ":" + Text::toString(n) +
                        ": Option '" + name + "' requires a value");
            error = true;
            continue;
          }

          try
          {
            d->execute(this, optionArg);
          }
          catch(ParseException &e)
          {
            logger->log(path + ":" + Text::toString(n) +
                        ": " + e.getMessage());
            error = true;
          }
        }
        catch(EatException &e)
        {
          logger->log(path + ":" + Text::toString(n) + ": " + e.getMessage());
          error = true;
        }
      }
      return error;
    }

    void Options::saveConfigFile(string path) throw(FileAccessException)
    {
      Ref<Stream::Writer> w;
      try
      {
        w = Stream::makeFileWriter(path);
      }
      catch(Stream::FileOpenException &e)
      {
        ARCHON_THROW1(FileAccessException, e.getMessage());
      }
      bool first = true;
      for(unsigned i=0; i<defs.size(); ++i)
      {
        const Def *d = defs[i];
        if(d->switchOnly || d->longName.empty() ||
           !dynamic_cast<const DefVarBase *>(d) &&
           d->wantArg != wantArg_never) continue;
        if(!first) w->writeAll("\n");
        first = false;
        w->writeAll("# " + d->description + "\n");
        string s;
        if(d->wantArg != wantArg_never)
        {
          s += printQuoteWord(d->longName);
          if(const DefVarBase *_d = dynamic_cast<const DefVarBase *>(d))
            s += " " + printQuoteWord(_d->getValue());
        }
        else
        {
          if(const DefVarBase *_d = dynamic_cast<const DefVarBase *>(d))
            if(!_d->isDefaultSet()) s += "#";
          s += printQuoteWord(d->longName);
        }
        w->writeAll(s + "\n");
      }
    }

    string Options::list(unsigned width)
    {
      const string::size_type maxValueLength = 12; // Must be at least 5
      vector<double> columnWidthFractions;
      columnWidthFractions.push_back(0.25);
      columnWidthFractions.push_back(0.25);
      columnWidthFractions.push_back(0.5);
      Text::Table<string> table(defs.size(), columnWidthFractions);
      for(unsigned i=0; i<defs.size(); ++i)
      {
        const Def *d = defs[i];
        if(d->shortName.size()) table(i, 0) = "-" + d->shortName;
        if(d->longName.size() && d->shortName.size()) table(i, 0) += ", ";
        if(d->longName.size()) table(i, 0) += "--" + d->longName;
        if(const DefVarBase *_d = dynamic_cast<const DefVarBase *>(d))
        {
          string s = _d->getValue();
          string t = printQuoteWord(s);
          if(t.size() > maxValueLength)
          {
            if(s.size()+3 >= maxValueLength)
              s = s.substr(s.size()+3-maxValueLength);
            for(;;)
            {
              t = "..." + printQuoteWord(s);
              if(t.size() <= maxValueLength) break;
              s.erase(0, 1);
            }
          }
          table(i, 1) = t;
        }
        table(i, 2) = d->description;
      }

      return Text::format(table, width);
    }
  }
}

---