source: trunk/gsinstaller/unInstall.cpp@ 1498

#include "unInstall.h"

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

bool installManager::openLog(string filename, bool write)
{ string command;
    stringArray params;

    if (this->logfile.rdbuf()->is_open())
    {   this->closeLog();
  }
  this->logfileName = filename;
  this->logfile.open(filename.c_str(), ios::out | ios::in);
  if (write == false)
  { while ((command = this->readCommand(params)) != "")
    { if (command[0] == '[' && command[command.length()-1] == ']')
        { this->setModule(command.substr(1, command.length() - 2));
        }
        else
        { unInstallCommand action(command, params);
            this->storeCommand(action);
        }
    }
  }
  this->setModule("default");
  return true;
}

bool installManager::reopenLog()
{ if (this->logfile.rdbuf()->is_open())
  { this->logfile.close();
  }
  else
  { this->logfile.close();
    }
  
  this->logfile.open(this->logfileName.c_str(), ios::out | ios::in);
  return true;
}

void installManager::setModule(string moduleName)
{   this->currentModule = moduleName;
}

bool installManager::storeCommand(unInstallCommand &command)
{ this->modules[this->currentModule].push_back(command);
    return true;
}

bool installManager::writeCommand(unInstallCommand &command)
{ if (!this->writeString(command.command))
    { return false;
  }
    for (unsigned int p = 0; p < command.parameters.size(); p ++)
  { if (!this->writeSeparator())
    { return false;
    }
    if (!this->writeString(command.parameters[p]))
    { return false;
    }
  }
  if (!this->writeString("\n"))
  { return false;
  }
  return true;
}

bool installManager::writeString(char *buffer)
{ string s(buffer);
    return this->writeString(s);
}

bool installManager::writeString(string str)
{ bool quote;

    // TODO: check for space characters in str and quote if necessary
  quote = str.find_first_of(' ') < str.length();

    if (quote)
  { this->logfile << "\"";
  }
    this->logfile << str;
  if (quote)
  { this->logfile << "\"";
  }
  return true;
}

bool installManager::writeSeparator()
{   this->logfile << " ";
    return true;
}

string installManager::readString()
{   string reply = "";
    char c;

  if (this->logfile.eof())
    {   return reply;
  }

  this->logfile >> c;
  while (c <= ' ' && !this->logfile.eof())
  { this->logfile.get();
  }

  if (this->logfile.eof())
  { return reply;
  }

  if (c == '\"')
  { do
    {   c = this->logfile.get();
        if (c != '\"')
      { reply += c;
      }
    }
    while (c != '\"' && !this->logfile.eof());
  }
  else
  { while (c > ' ')
    { reply += c;
        if (this->logfile.eof())
      { break;
      }
        c = this->logfile.get();
    }
    if (!this->logfile.eof())
    {   this->logfile.putback(c);
    }
    //this->logfile >> reply;
  }
  return reply;
}

string installManager::readCommand(stringArray &array)
{   string reply = "";
  char c;

  array.clear();

  if (this->logfile.eof())
  { return reply;
  }

    reply = this->readString();
  if (reply == "")
  { return reply;
  }

  while(!this->logfile.eof() &&
            (c = this->logfile.get()) != '\n')
  { this->logfile.putback(c);
    array.add(this->readString());
  }
  if (!this->logfile.eof())
  { this->logfile.putback(c);
  }

  return reply;
}

string installManager::popCommand(stringArray &array)
{ string command;

  if (this->modules[this->currentModule].size() == 0)
  { command = "";
  }
  else
  { unsigned int last;

      last = this->modules[this->currentModule].size() - 1;
    command = this->modules[this->currentModule][last].commandName();
    array       = this->modules[this->currentModule][last].parameterList();
    this->modules[this->currentModule].erase(this->modules[this->currentModule].begin() + last);
  }
  return command;
}

bool installManager::closeLog()
{ if (this->logfile.rdbuf()->is_open() == false)
  { return false;
  }

    unInstallCommandMap::iterator here = this->modules.begin();
    unInstallCommandMap::iterator end  = this->modules.end();

  while (here != end)
  { this->writeString("[" + (*here).first + "]\n");

    unInstallCommandList::iterator  ahere = (*here).second.begin();
    unInstallCommandList::iterator  aend  = (*here).second.end();
    while (ahere != aend)
        { this->writeCommand(*ahere);
        ahere ++;
    }
    here ++;
  }
    this->logfile.close();
  return true;
}

bool installManager::isEmpty()
{ unInstallCommandMap::iterator here = this->modules.begin();
    unInstallCommandMap::iterator end  = this->modules.end();

  while (here != end)
  { this->writeString("[" + (*here).first + "]\n");

    unInstallCommandList::iterator  ahere = (*here).second.begin();
    unInstallCommandList::iterator  aend  = (*here).second.end();
    if (ahere != aend)
    {   return false;
    }
    here ++;
  }
  return true;
}

installManager::~installManager()
{   if (this->logfile.rdbuf()->is_open())
    {   this->closeLog();
  }
}

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;
}