ArArgumentBuilder.cpp

/*
ActivMedia Robotics Interface for Applications (ARIA)
Copyright (C) 2004,2005 ActivMedia Robotics, LLC


     This program 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 2 of the License, or
     (at your option) any later version.

     This program 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, write to the Free Software
     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA

If you wish to redistribute ARIA under different terms, contact 
ActivMedia Robotics for information about a commercial version of ARIA at 
robots@activmedia.com or 
ActivMedia Robotics, 19 Columbia Drive, Amherst, NH 03031; 800-639-9481

*/

#include "ArExport.h"
#include "ariaOSDef.h"
#include "ArArgumentBuilder.h"
#include "ArLog.h"
#include <stdarg.h>
#include <ctype.h>
#include <math.h>

ArArgumentBuilder::ArArgumentBuilder(size_t argvLen)
{
  myArgc = 0;
  myOrigArgc = 0;
  myArgvLen = argvLen;
  myArgv = new char *[myArgvLen];
  myFirstAdd = true;
}

ArArgumentBuilder::ArArgumentBuilder(const ArArgumentBuilder & builder)
{
  size_t i;
  myFullString = builder.myFullString;
  myExtraString = builder.myExtraString;
  myArgc = builder.getArgc();
  myArgvLen = builder.getArgvLen();
  myOrigArgc = myArgc;
  myArgv = new char *[myArgvLen];
  for (i = 0; i < myArgc; i++)
    myArgv[i] = strdup(builder.getArg(i));
}

ArArgumentBuilder::~ArArgumentBuilder()
{
  size_t i;
  if (myOrigArgc > 0)
  {
    for (i = 0; i < myOrigArgc; ++i)
      delete[] myArgv[i];
  }
  delete[] myArgv;
}


void ArArgumentBuilder::removeArg(size_t which)
{
  size_t i;
  char *temp;

  if (which > myArgc - 1)
  {
    ArLog::log(ArLog::Terse, "ArArgumentBuilder::removeArg: %d is greater than the number of arguments which is %d", which, myArgc);
    return;
  }

  temp = myArgv[which];
  //delete[] myArgv[which]; 
  for (i = which; i < myArgc - 1; i++)
    myArgv[i] = myArgv[i+1];
  myArgc -= 1;
  myArgv[i] = temp;
  // delete the one off the end
}

void ArArgumentBuilder::add(const char *str, ...)
{
  char buf[2048];
  va_list ptr;
  va_start(ptr, str);
  vsprintf(buf, str, ptr);
  internalAdd(buf, -1);
  va_end(ptr);
}

void ArArgumentBuilder::internalAdd(const char *str, int position)
{
  char buf[2048];
  int i;
  int j;
  size_t k;
  bool findingSpace = true;
  int startNonSpace;
  int len;
  bool addAtEnd;
  //size_t startingArgc = getArgc();

  if (position < 0 || (size_t)position > myArgc)
    addAtEnd = true;
  else
    addAtEnd = false;
  
  strncpy(buf, str, sizeof(buf));
  len = strlen(buf);

  // can do whatever you want with the buf now
  // first we advance to non-space
  for (i = 0; i < len; ++i)
  {
    if (!isspace(buf[i]))
      break;
  }
  // see if we're done
  if (i == len)
  {
    ArLog::log(ArLog::Verbose, "All white space add for argument builder.");
    return;
  }


  // walk through the line until we get to the end of the buffer...
  // we keep track of if we're looking for white space or non-white...
  // if we're looking for white space when we find it we have finished
  // one argument, so we toss that into argv, reset pointers and moveon
  for (startNonSpace = i; ; ++i)
  {
    // take out the slash of escaped spaces
    if (buf[i] == '\\' && i + 1 < len && buf[i + 1] == ' ')
    {
      for (j = i; j < len && j != '\0'; j++)
      {
        buf[j] = buf[j + 1];
      }
      --len;
    }
    // if we're not finding space and we see a non space (or the end),
    // set us into finding space mode and denote where it started
    else if (!findingSpace && 
             !(i == len || isspace(buf[i]) || buf[i] == '\0'))
    {
      startNonSpace = i;
      findingSpace = true;
    }
    // if we're finding space, and we see it (or the end), we're at
    // the end of one arg, so toss it into the list
    else if (findingSpace && 
             (i == len || isspace(buf[i]) || buf[i] == '\0'))
    {
      // see if we have room in our argvLen
      if (myArgc + 1 >= myArgvLen)
      {
        ArLog::log(ArLog::Terse, "ArArgumentBuilder::Add: could not add argument since argc (%u) has grown beyond the argv given in the conbufuctor (%u)", myArgc, myArgvLen);
      }
      else
      {
        // if we're adding at the end just put it there, also put it
        // at the end if its too far out
        if (addAtEnd)
        {
          myArgv[myArgc] = new char[i - startNonSpace + 1];
          strncpy(myArgv[myArgc], &buf[startNonSpace], i - startNonSpace);
          myArgv[myArgc][i - startNonSpace] = '\0';
          // add to our full string
          // if its not our first add a space
          if (!myFirstAdd)
            myFullString += " ";
          
          myFullString += myArgv[myArgc];
          myFirstAdd = false;
          
          myArgc++;
          myOrigArgc = myArgc;
        }
        // otherwise stick it where we wanted it if we can or just 
        else
        {
          // first move things down
          for (k = myArgc + 1; k > (size_t)position; k--)
          {
            myArgv[k] = myArgv[k - 1];
          }
          myArgc++;
          myOrigArgc = myArgc;

          myArgv[position] = new char[i - startNonSpace + 1];
          strncpy(myArgv[position], &buf[startNonSpace], i - startNonSpace);
          myArgv[position][i - startNonSpace] = '\0';
          position++;
          // now rebuild the full string
          myFullString = "";
          for (k = 0; k < myArgc; k++)
          {
            myFullString += myArgv[k];
            myFullString += " ";
          }
          myFirstAdd = false;
        }

      }
      findingSpace = false;
    }
    // if we're at the end or its a null, we're at the end of the buf
    if (i == len || buf[i] == '\0')
      break;
  }
}

void ArArgumentBuilder::addPlain(const char *str, int position)
{
  internalAdd(str, position);
}

void ArArgumentBuilder::addStrings(char **argv, int argc,
                                            int position)
{
  addStrings(argc, argv, position);
}

void ArArgumentBuilder::addStrings(int argc, char **argv, 
                                            int position)
{
  int i;
  for (i = 0; i < argc; i++)
    add(argv[i], position + i);
}

size_t ArArgumentBuilder::getArgc(void) const
{
  return myArgc;
}

char** ArArgumentBuilder::getArgv(void) const
{
  return myArgv;
}

const char *ArArgumentBuilder::getFullString(void) const
{
  return myFullString.c_str();
}

const char *ArArgumentBuilder::getExtraString(void) const
{
  return myExtraString.c_str();
}

void ArArgumentBuilder::setExtraString(const char *str)
{
  myExtraString = str;
}

void ArArgumentBuilder::setFullString(const char *str)
{
  myFullString = str;
}

const char* ArArgumentBuilder::getArg(size_t whichArg) const
{
  if (whichArg >= myArgc)
    return NULL;
  else
    return myArgv[whichArg];
}

void ArArgumentBuilder::log(void) const
{
  size_t i;
  ArLog::log(ArLog::Terse, "Num arguments: %d", myArgc);
  for (i = 0; i < myArgc; ++i)
    ArLog::log(ArLog::Terse, "Arg %d: %s", i, myArgv[i]);
}

bool ArArgumentBuilder::isArgBool(size_t whichArg) const
{
  if (whichArg > myArgc || getArg(whichArg) == NULL)
    return false;

  if (strcasecmp(getArg(whichArg), "true") == 0 || 
      strcasecmp(getArg(whichArg), "1") == 0 || 
      strcasecmp(getArg(whichArg), "false") == 0 || 
      strcasecmp(getArg(whichArg), "0") == 0)
    return true;
  else
    return false;
}

bool ArArgumentBuilder::getArgBool(size_t whichArg) const
{
  if (whichArg > myArgc || getArg(whichArg) == NULL)
    return false;

  if (strcasecmp(getArg(whichArg), "true") == 0 || 
      strcasecmp(getArg(whichArg), "1") == 0)
    return true;
  else
    return false;
}

bool ArArgumentBuilder::isArgInt(size_t whichArg) const
{
  const char *str;
  int ret;
  char *endPtr;
  if (whichArg > myArgc || getArg(whichArg) == NULL)
    return false;

  str = getArg(whichArg);
  ret = strtol(str, &endPtr, 10);
  if (endPtr[0] == '\0' && endPtr != str)
    return true;
  else
    return false;
}

int ArArgumentBuilder::getArgInt(size_t whichArg) const
{
  const char *str;
  int ret;
  char *endPtr;
  if (whichArg > myArgc || getArg(whichArg) == NULL)
    return 0;

  str = getArg(whichArg);
  ret = strtol(str, &endPtr, 10);
  if (endPtr[0] == '\0' && endPtr != str)
    return ret;
  else
    return 0;
}

bool ArArgumentBuilder::isArgDouble(size_t whichArg) const
{
  const char *str;
  double ret;
  char *endPtr;
  if (whichArg > myArgc || getArg(whichArg) == NULL)
    return false;

  str = getArg(whichArg);
  if (strcmp(str, "-INF") == 0)
  {
        return true;
  }
  else if (strcmp(str, "INF") == 0)
  {
        return true;
  }
  else
  {
    ret = strtod(str, &endPtr);
    if (endPtr[0] == '\0' && endPtr != str)
      return true;
    else
      return false;
  }

}

double ArArgumentBuilder::getArgDouble(size_t whichArg) const
{
  const char *str;
  double ret;
  char *endPtr;
  if (whichArg > myArgc || getArg(whichArg) == NULL)
    return 0;

  str = getArg(whichArg);
  if (strcmp(str, "-INF") == 0)
  {
        ret = -HUGE_VAL;
        return ret;
  }
  else if (strcmp(str, "INF") == 0)
  {
        ret = HUGE_VAL;
        return ret;
  }
  else
  {  
        ret = strtod(str, &endPtr);
    if (endPtr[0] == '\0' && endPtr != str)
      return ret;
    else
      return 0;
  }
}

void ArArgumentBuilder::compressQuoted(bool stripQuotationMarks)
{
  size_t argLen;
  size_t i;
  std::string myNewArg;

  for (i = 0; i < myArgc; i++)
  {
    argLen = strlen(myArgv[i]);
    if (stripQuotationMarks && argLen >= 2 && 
        myArgv[i][0] == '"' && myArgv[i][argLen - 1] == '"')
    {
      myNewArg = &myArgv[i][1];
      myNewArg[myNewArg.size() - 1] = '\0';
      delete myArgv[i];
      // but replacing ourself with the new arg
      myArgv[i] = strdup(myNewArg.c_str());
      continue;
    }
    // if this arg begins with a quote but doesn't end with one
    if (argLen >= 2 && myArgv[i][0] == '"' && myArgv[i][argLen - 1] != '"')
    {
      // start the new value for this arg, if stripping quotations
      // then start after the quote
      if (stripQuotationMarks)
        myNewArg = &myArgv[i][1];
      else
        myNewArg = myArgv[i];

      bool isEndQuoteFound = false;

      // now while the end char of the next args isn't the end of our
      // start quote we toss things into this arg
      while ((i + 1 < myArgc) && !isEndQuoteFound) {
          
        int nextArgLen = strlen(myArgv[i+1]);

        // Check whether the next arg contains the ending quote...
        if ((nextArgLen > 0) &&
            (myArgv[i+1][nextArgLen - 1] == '"')) 
        {
              isEndQuoteFound = true;
        }
    
        // Concatenate the next arg to this one...
        myNewArg += " ";
        myNewArg += myArgv[i+1];
        // if we are striping quotes off then replace the quote
        if (stripQuotationMarks && myNewArg.size() > 0 && isEndQuoteFound)
          myNewArg[myNewArg.size() - 1] = '\0';
        // removing those next args
        removeArg(i+1);
        // and ourself
        delete myArgv[i];

        // but replacing ourself with the new arg
        myArgv[i] = strdup(myNewArg.c_str());
      }
    }
  }
}

---