source: trunk/gsinstaller/unInstall.cpp@ 2490

#include "unInstall.h"

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

bool installManager::logExists()
{
    HANDLE fHandle;

    fHandle = CreateFile(this->logfileName.c_str(), GENERIC_READ | GENERIC_WRITE,
                         FILE_SHARE_WRITE, NULL, OPEN_EXISTING,
                         FILE_ATTRIBUTE_NORMAL, NULL);
    if (fHandle == INVALID_HANDLE_VALUE)
    {   return false;
    }
    CloseHandle(fHandle);
    return true;
}

bool installManager::ensureLog()
{
    if (this->logExists() == false)
    {   HANDLE fHandle;

    unInstallCommand command("InstallRoot");
    command.addParameter(this->logfileName);

    if (this->modules["default"].begin()->command != "InstallRoot")
    {   this->modules["default"].insert(this->modules["default"].begin(), command);
    }
        fHandle = CreateFile(this->logfileName.c_str(), GENERIC_READ | GENERIC_WRITE,
                         FILE_SHARE_WRITE, NULL, CREATE_NEW,
                             FILE_ATTRIBUTE_NORMAL, NULL);
        if (fHandle != INVALID_HANDLE_VALUE)
        {   
            CloseHandle(fHandle);
            return true;
        }
        return false;
    }
    else
    {   if (this->modules["default"].begin()->command == "InstallRoot")
        {   this->logfileName = this->modules["default"].begin()->parameters[0];
      }
    }
    return true;
}

bool installManager::setLogFile(string filename)
{   this->logfileName = filename;
    this->setModule("default");
    return true;
}

bool installManager::readLog()
{   string command;
    stringArray params;

    // don't try to open an non-existing log; this has serious
    // repercussions with bad old VC++
    if (!this->logExists())
    {   this->setModule("default");
        this->changed = false;
        return true;
    }

    // open the log file 
    this->logfile.open(this->logfileName.c_str(), ios::in);
#ifndef __BORLANDC__
    if (this->logfile.is_open())
#else
    if (this->logfile.rdbuf()->is_open())
#endif
    {
        // Get the commands into this object from the existing log file
        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);
            }
        }

        // close the logfile
        this->logfile.close();

        // and clear the status bits, 'cos VC++ doesn't clear them when
        // we reopen the file later.
        this->logfile.clear();
    }
    this->changed = false;
  
  // set to the default module
  this->setModule("default");
  return true;
}

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

bool installManager::storeCommand(unInstallCommand &command)
{ this->modules[this->currentModule].push_back(command);
    this->changed = true; // set the "changed" flag
    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::recordLog()
{   // just return if there are no changes to record
    if (this->changed == false)
    { return true;
    }

  // if the file didn't open, then this is almost certainly being compiled
  // with Microsoft Visual C++ which has a library which fails to open the
  // file if it doesn't already exist.  Do a createfile and hope for success.
  // TODO: add proper error handling here
    this->ensureLog();
    this->logfile.open(this->logfileName.c_str(), ios::out);
#ifndef __BORLANDC__
    if (!this->logfile.is_open())
#else
    if (!this->logfile.rdbuf()->is_open())
#endif
    {   MessageBox(0, "Unable to open log file", this->logfileName.c_str(), MB_OK);
    }

    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();

    this->changed = false;

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

string installManager::installRoot()
{   if (this->modules["default"].begin()->command != "InstallRoot")
        return "";
    return this->modules["default"].begin()->parameters[0];
}

installManager::~installManager()
{   this->recordLog();
}