source: trunk/gsinstaller/unInstall.cpp@ 1397

#include "unInstall.h"

#include <stdio.h>
#include <stdarg.h>
#include "File.h"

unInstaller::unInstaller(string &fileName)
{ if (fileName != "")
    {   this->readFile(fileName);
  }
}

unInstaller::unInstaller(const char *fileName)
{   string filename = fileName;

    if (fileName != "")
  { this->readFile(filename);
  }
}

bool unInstaller::readFile(string &fileName)
{ FILE *f;
    File  finfo(fileName.c_str());
  string    currentGroup;
  char   *line, *eol;

    f = fopen(fileName.c_str(), "rb");
  if (f == NULL)
  { return false;
  }

  char *buffer = new char[finfo.getFileSize()];
    if (buffer == NULL)
  { return false;
  }

  if (fread(buffer, 1, finfo.getFileSize(), f) < finfo.getFileSize())
  { return false;
  }
  fclose(f);

  //parse file into lines and send to the line fn
  line  = buffer;
  while ((eol = strchr(line, '\x0a')) != NULL)  // use 0a for the eol to remove
                                                // dependency on dos 0d,0a eol
  { *eol = '\0';

    this->getLine(line, currentGroup);

    line = eol + 1;
  }
  this->getLine(line, currentGroup);

  delete buffer;
  return true;
}

bool unInstaller::getLine(char *line, string &group)
{ char *eol;    // we (potentially) need to clean up the end of
              // line, and we won't use the eol from the main
              // getManifest fn. as for the last line it'd be
              // null.

    // clean up the start of the line
    while (*line <= ' ' && *line != '\0')
    { line ++;
  }

  // it's a blank line - don't bother!
  if (line == '\0')
  { return true;
  }

  // clean up the end of line
  eol   = line + strlen(line) - 1;
  while (*eol <= ' ' && eol >= line)
  { *eol = '\0';
    eol --;
  }

  // if it's a new group, read in the group name
  if (*line == '[' && *eol == ']')
  { string newgroup(line, 1, eol - line - 1);
    group = newgroup;
    return true;
  }
  // otherwise it should be a command
  else
  { char *equals = strchr(line, '=');

    // if it has no equals it's invalid; ignore it
    if (equals == NULL)
    {   return true;
    }
    else
        {   unInstallCommand command;

        string cmd(line, 0, equals-line);
        command.command = cmd;

      stringArray params = stringArray::words(equals+1);
      command.parameters    = params;

      this->_map[group].push_back(command);
    }
  }
  return true;
}

bool unInstaller::saveToFile(string fileName)
{   unInstallCommandMap::iterator here  = this->_map.begin();
  unInstallCommandMap::iterator end  = this->_map.end();
  string group = "";

  FILE *f;
  f = fopen(fileName.c_str(), "wb");
  if (f == NULL)
  { return false;
  }

  while (here != end)
  { // if we've changed groups, note the start of the new one
    fprintf(f, "[%s]\n", (*here).first.c_str());

    // write the group line-by-line
    unInstallCommandList::iterator groupHere    = (*here).second.begin();
    unInstallCommandList::iterator groupEnd     = (*here).second.end();
    while (groupHere != groupEnd)
    { fprintf(f, "%s=", (*groupHere).command.c_str());

      fprintf(f, "%s", (*groupHere).parameters[0].c_str());
        for (unsigned int p = 1; p < (*groupHere).parameters.size(); p ++)
      { fprintf(f, " %s", (*groupHere).parameters[p].c_str());
      }
        groupEnd ++;
    }
    here ++;
  }
  fclose(f);
  return true;
}

void unInstaller::unInstall(string &listName)
{   if (listName == uninstall_ALL)
    {   unInstallCommandMap::reverse_iterator here  = this->_map.rbegin();
    unInstallCommandMap::reverse_iterator end   = this->_map.rend();

    while (here != end)
    { this->unInstallGroup((*here).second);
        here ++;
    }
    this->_map.empty();
  }
  else
  { this->unInstallGroup(this->_map[listName]);
    this->_map.erase(listName);
  }
}

void unInstaller::unInstallGroup(unInstallCommandList &list)
{ for (int i = list.size() - 1; i >= 0; i --)
    {   // execute uninstall
    this->execCommand(list[i].command, list[i].parameters);
  }
}

bool unInstaller::execCommand(string &name, stringArray &params)
{ // undo the command
    return true;
}

bool unInstaller::record(string group, string cmd, string parameter)
{ unInstallCommand command;

    command.command = cmd;
  command.parameters.add(parameter);

  this->_map[group].push_back(command);
  return true;
}

bool unInstaller::record(string group, string cmd, int count, ...)
{ va_list list;

    va_start(list, count);
    unInstallCommand command;

    command.command = cmd;
  command.parameters.add(*va_arg(list, string *));
  va_end(list);

  this->_map[group].push_back(command);

  return true;
}