libs/EDoc/utils.cpp

Go to the documentation of this file.

/*******************************************************************************

   Copyright (C) 2007 by Brendon Costa

   This library is free software; you can redistribute it and/or modify 
   it under the terms of the "LGPL Like" License defined in the file COPYING 
   that should have been distributed along with this source.

   This library 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.  

   You should have received a copy of the "LGPL Like" License 
   along with this library; see the file COPYING. if not, it can be 
   obtained from the EDoc++ website: 
   http://edoc.sourceforge.net/license.html

*******************************************************************************/

//==============================================================================
/** \mainpage EDoc++ library documentation.
 * 
 * \section introduction Introduction
 * 
 * The EDoc++ library provides much of the code used to process EDoc++ data
 * files and to gather information about exception propogation from those data
 * files. The edoc and edc-arch applications both make use of this library. The
 * main purpose is to be able to load *.edc files, and then calculate the
 * complete list of propogating exceptions from the information provided
 * therein.
 *
 * \subsection introduction_main_objects MainObjects
 *
 * Following is a list of types that correspond directly to some logical
 * structure in the parsed source code:
 *
 *    - EDoc::CatchBlock
 *    - EDoc::CodeBlock
 *    - EDoc::Exception
 *    - EDoc::File
 *    - EDoc::Function
 *    - EDoc::FunctionType
 *    - EDoc::Location (Identifies a location in the source code file/line)
 *    - EDoc::PropogatingException
 *    - EDoc::TranslationUnit
 *    - EDoc::TryBlock
 *    - EDoc::Type
 *    .
 *
 *
 * \section overview Overview
 *
 * Following is the general procedure followed by users of this library:
 *
 * -# For each .edc file, create a EDoc::PersistenceIFace instance usually by 
 *    using EDoc::Persistence::ReadOpen().
 * -# For each .edc file, load its contents into a EDoc::Dictionary instance,
 *    using EDoc::Dictionary::Read().
 * -# Merge all the EDoc::Dictionary instances into a single EDoc::Dictionary
 *    instance. This is equivilant of linking multiple translation units into a
 *    single binary.
 * -# Calculate the complete list of exceptions for all functions. This is
 *    usually done by calling:
 *    EDoc::Dictionary::CalculatePropogatingExceptions().
 * .
 *
 * Finally after all this, a user is free to analyse the objects as they 
 * see fit. The edoc application performs any number of
 * checks over the resulting data to check for invalid usage of exceptions, and
 * also uses the data to produce doxygen documentation.
 *
 *
 * \todo @@@Brendon Describe the memory management structure in the library and
 * particular ownership of memory by Dictionary objects. Including String
 * identified objects, Dictionary specific objects, and the validation routines
 * and configure option.
 *
 * \todo @@@Brendon Describe the notification framework for indication of
 * warnings/errors while processing data.
 *
 * \todo @@@Brendon Describe the format of the data files and loadin/saving
 * procedures. Including Managed/Unmanaged files, the different formats and 
 * the use of the IndexedDictionary for multi-stage loading/saving.
 *
 * \todo @@@Brendon Describe the logging framework.
 *
 * \todo @@@Brendon Describe the format of the data files and loadin/saving
 * procedures.
 *
 * \todo @@@Brendon Describe the error handling strategy. Also when implement
 * new feature for safety guarentee, implement EDoc++ using this to demonstrate
 * and test it.
 */

#include "config.h"

#include "EDoc/utils.h"
#include "EDoc/exceptions.h"

#include <string>
#include <vector>
#include <iostream>


#ifdef HAVE_STDLIB_H
   #include <stdlib.h>
#endif

#ifdef HAVE_STRING_H
   #include <string.h>
#endif

#ifdef HAVE_SYS_SELECT_H
   #include <sys/select.h>
#endif

#ifdef HAVE_SYS_WAIT_H
   #include <sys/wait.h>
#endif

#ifdef HAVE_SYS_STAT_H
   #include <sys/stat.h>
#endif

#ifdef HAVE_UNISTD_H
   #include <unistd.h>
#endif

#ifdef HAVE_ERRNO_H
   #include <errno.h>
#endif
   
// mkstemp
//#include <stdlib.h>
//#include <stdio.h>

namespace EDoc
{
   //===========================================================================
   std::list<std::string> open_temp_files;
   //===========================================================================
   bool PushBack(const std::string& name, 
      std::vector<std::string>& list)
   {
      bool already_contains = false;
      for (size_t j = 0; j < list.size(); j++)
      {
         if (list[j] == name)
         {
            already_contains = true;
         }
      }

      if (!already_contains)
      {
         list.push_back(name);
      }

      return !already_contains;
   }
   //===========================================================================
   std::string GetFileExtension(std::string name)
   {
      size_t pos = name.rfind('.');
      if (pos == std::string::npos)
      {
         return "";
      }

      return name.substr(pos + 1);
   }
   //===========================================================================
   std::pair<std::string, std::string> SplitFileExtension(std::string name)
   {
      size_t pos = name.rfind('.');
      if (pos == std::string::npos)
      {
         return std::pair<std::string, std::string>(name, "");
      }

      return std::pair<std::string, std::string>(name.substr(0, pos), 
         name.substr(pos + 1));
   }
   //===========================================================================
   std::string CreateTempFilename(std::string base)
   {
      const char* path = "/tmp/";

      char* b = new char[strlen(path) + base.size() + 6 + 1];
      strcpy(b, path);
      strcat(b, base.c_str());
      strcat(b, "XXXXXX");

      int fd = mkstemp(b);
      if (fd == -1)
      {
         delete [] b;
         EDOC_THROW_EXCEPTION(BugException, "", "");
      }
      close(fd);

      std::string f(b);
      delete [] b;
      b = NULL;
      return f;
   }
   //===========================================================================
   std::vector<std::string> Split(std::string str, char sep)
   {
      std::vector<std::string> ret;

      size_t last = 0;
      while (last != std::string::npos)
      {
         size_t index = str.find_first_of(sep, last);
         if (index != std::string::npos)
         {
            ret.push_back(str.substr(last, index - last));
            last = index + 1;
         }
         else
         {
            ret.push_back(str.substr(last));
            last = index;
         }
      }

      return ret;
   }
   //===========================================================================
   int RunProgram(std::string command_in)
   {
      // @@@Brendon Update to throw proper exceptions for errors.
      
      int pid = fork();
      switch (pid)
      {
         case -1:
         {
            std::cerr << "ERROR failed fork." << std::endl;
            EDOC_THROW_EXCEPTION(BugException, "", "");
            break;
         }
         case 0:
         {
            // Child.
            std::vector<std::string> sep = Split(command_in, ' ');
            size_t len = sep.size();
            char** argv = new char*[len + 1];
            for (size_t i = 0; i < len; i++)
            {
               argv[i] = new char[sep[i].size() + 1];
               strcpy(argv[i], sep[i].c_str());
               EDOC_Debug("argv: " << i << ", value: " << argv[i]);
               //argv[i] = (char*)sep[i].c_str();
            }
            argv[len] = NULL;

            EDOC_Debug("Executing command: " << command_in);
            EDOC_Debug("argv0: \"" << argv[0] << "\"");

            //if (execvp(command_in.c_str(), argv) == -1)
            if (execvp(argv[0], argv) == -1)
            {
               std::cerr << "ERROR: Failed exec. Reason: " << strerror(errno) 
                         << std::endl;
               exit(1);
            }
         }
         default:
         {
            // Parent.
            int status = 0;
            if (waitpid(pid, &status, 0) == -1)
            {
               EDOC_THROW_EXCEPTION(BugException, "", "");
            }
            return status;
         }
      }
      return 0;
   }
   //===========================================================================
   int RunProgramRedirect(std::string& out, std::string& err, std::string command_in)
   {
      // @@@Brendon Update to throw proper exceptions for errors.
      
      // First create the redirection pipes.
      static const size_t READ = 0;
      static const size_t WRITE = 1;
      
      int out_pipe[2];
      int err_pipe[2];
      int result = 0;
      
      out = "";
      err = "";
      
      result = pipe(out_pipe);
      if(result == -1)
      {
         std::cerr << "ERROR failed to create pipe. Reason: " << strerror(errno) << std::endl;
         EDOC_THROW_EXCEPTION(BugException, "", "");
      }

      result = pipe(err_pipe);
      if(result == -1)
      {
         // @@@Brendon Cleanup the out_pipe descriptors.
         std::cerr << "ERROR failed to create pipe. Reason: " << strerror(errno) << std::endl;
         EDOC_THROW_EXCEPTION(BugException, "", "");
      }
      
      int pid = fork();
      switch (pid)
      {
         case -1:
         {
            // @@@Brendon Cleanup the pipe descriptors.
            std::cerr << "ERROR failed fork. Reason: " << strerror(errno) << std::endl;
            EDOC_THROW_EXCEPTION(BugException, "", "");
            break;
         }
         case 0:
         {
            // Child.
            // Determine the command that we should run.
            std::vector<std::string> sep = Split(command_in, ' ');
            size_t len = sep.size();
            char** argv = new char*[len + 1];
            for (size_t i = 0; i < len; i++)
            {
               argv[i] = new char[sep[i].size() + 1];
               strcpy(argv[i], sep[i].c_str());
               EDOC_Debug("argv: " << i << ", value: " << argv[i]);
            }
            argv[len] = NULL;

            EDOC_Debug("Executing command: " << command_in);
            EDOC_Debug("argv0: \"" << argv[0] << "\"");
            
            // Close the un-needed side of the descriptors.
            close(out_pipe[READ]);
            close(err_pipe[READ]);

            // Duplicate the descriptors to the stdout stderr.
            result = dup2(out_pipe[WRITE], 1);
            if (result == -1)
            {
               std::cerr << "ERROR: Failed dup. Reason: " << strerror(errno) 
                         << std::endl;
               exit(1);
            }

            result = dup2(err_pipe[WRITE], 2);
            if (result == -1)
            {
               std::cerr << "ERROR: Failed dup. Reason: " << strerror(errno) 
                         << std::endl;
               exit(1);
            }
            
            // Close the now duplicated pipe.
            close(out_pipe[WRITE]);
            close(err_pipe[WRITE]);
            
            // Finally do a execvp to run the command replacing the current 
            // process.
            if (execvp(argv[0], argv) == -1)
            {
               std::cerr << "ERROR: Failed exec. Reason: " << strerror(errno) 
                         << std::endl;
               exit(1);
            }
         }
         default:
         {
            // Parent.
            
            // Close the un-used side of the pipe.
            close(out_pipe[WRITE]);
            close(err_pipe[WRITE]);
            
            // Go into a loop reading standard out and std err into the 
            // provided strings.
            bool out_eof = false;
            bool err_eof = false;
            static const int BUFSIZE = 100;
            char buf[BUFSIZE];
            while (!out_eof || !err_eof)
            {
               int max_descriptor = 0;
               fd_set descriptors;
               FD_ZERO(&descriptors);
               
               if (out_pipe[READ] > max_descriptor)
               {
                  max_descriptor = out_pipe[READ];
               }
               FD_SET(out_pipe[READ], &descriptors);
               
               if (err_pipe[READ] > max_descriptor)
               {
                  max_descriptor = err_pipe[READ];
               }
               FD_SET(err_pipe[READ], &descriptors);

               int result = select(max_descriptor + 1, 
                  &descriptors, NULL, NULL, NULL);
               if(result ==  -1)
               {
                  // @@@Brendon Cleanup the pipe descriptors.
                  std::cerr << "ERROR failed select. Reason: " << strerror(errno) << std::endl;
                  EDOC_THROW_EXCEPTION(BugException, "", "");
               }
               
               if (FD_ISSET(out_pipe[READ], &descriptors))
               {
                  result = read(out_pipe[READ], buf, BUFSIZE);
                  if (result == -1)
                  {
                     // @@@Brendon Cleanup the pipe descriptors.
                     std::cerr << "ERROR failed read. Reason: " << strerror(errno) << std::endl;
                     EDOC_THROW_EXCEPTION(BugException, "", "");
                  }
                  else if (result == 0)
                  {
                     out_eof = true;
                  }
                  out += std::string(buf, result);
               }

               if (FD_ISSET(err_pipe[READ], &descriptors))
               {
                  result = read(err_pipe[READ], buf, BUFSIZE);
                  if (result == -1)
                  {
                     // @@@Brendon Cleanup the pipe descriptors.
                     std::cerr << "ERROR failed read. Reason: " << strerror(errno) << std::endl;
                     EDOC_THROW_EXCEPTION(BugException, "", "");
                  }
                  else if (result == 0)
                  {
                     err_eof = true;
                  }
                  err += std::string(buf, result);
               }
            }

            close(out_pipe[READ]);
            close(err_pipe[READ]);

            int status = 0;
            if (waitpid(pid, &status, 0) == -1)
            {
               EDOC_THROW_EXCEPTION(BugException, "", "");
            }
            return status;
         }
      }
      return 0;
   }
   //===========================================================================
   static int mkdirs(char *path, mode_t mode)
   {
      size_t i;
      int retval = 0;
      
      if (!path[0])
      {
         std::cerr << "Path provided was empty." << std::endl;
         return 0;
      }

      for (i = 1; path[i] != 0; i++)
      {
         if (path[i] == '/')
         {
            path[i] = 0;
            EDOC_Debug("Making dir: "<< path);
            retval = mkdir(path, mode);
            if ((retval != 0) && (errno != EEXIST))
            {
               std::cerr << "Failed to create dir: " << path << std::endl;
               path[i] = '/';
               return retval;
            }
            path[i] = '/';
         }
      }
      
      retval = mkdir(path, mode);
      if ((retval != 0) && (errno != EEXIST))
      {
         std::cerr << "Failed to create dir: " << path << std::endl;
         return retval;
      }

      return 0;
   }
   //===========================================================================
   void MkDirs(std::string dir)
   {
      if (mkdirs(const_cast<char*>(dir.c_str()), 
                              S_IRUSR | S_IWUSR | S_IXUSR |
                              S_IRGRP | S_IWGRP | S_IXGRP |
                              S_IROTH | S_IWOTH | S_IXOTH) == -1)
      {
         EDOC_THROW_EXCEPTION(FileIOException, strerror(errno), 
            "Failed to create directory: " << dir);
      }
   }
   //===========================================================================
   void CopyFile(std::string source, std::string destination)
   {
      // @@@Brendon Should implement this properly at some point.

      // @@@Brendon Using system is the simplest way to copy this file. Should i
      // somehow sanitize this string to ensure nothing malicious is being done?
      std::ostringstream command;
      
      command << "cp " << source  << " " << destination;
      if (RunProgram(command.str()) != 0)
      {
         EDOC_THROW_EXCEPTION(FileIOException, "Failed to copy file.", "");
      }
   }
   //===========================================================================
   bool FileExists(std::string filename)
   {
      struct stat buffer;
      int result = stat(filename.c_str(), &buffer);
      if (result == -1)
      {
         return false;
      }
      return buffer.st_mode & S_IFREG;
   }
   //===========================================================================
   static const std::string white_space(" \t\r\n");
   std::string TrimWhitespace(const std::string& str)
   {
      std::string result = str;
      std::string::size_type pos;

      if ((pos = result.find_first_not_of(white_space)) == std::string::npos)
      {
         return std::string("");
      }
      else
      {
         result.erase(0, pos);
      }
      
      if ((pos = result.find_last_not_of(white_space)) != std::string::npos)
      {
         result.erase(pos+1);
      }
      
      return result;
   }
   //========================================================================
   std::string MakeTemporaryFile(std::string prefix, 
      std::string EDOC_UNUSED(suffix), std::string directory)
   {
      std::string ft = directory + "/" + prefix + "XXXXXX";// + suffix;
      
      // directory / prefix XXXXXX
      char* filename_template = new char[ft.size() + 1];
      strcpy(filename_template, ft.c_str());

      // Get the OS to create the temporary file for us.
      int result = mkstemp(filename_template);
      if (result == -1)
      {
         delete [] filename_template;
         filename_template = NULL;

         EDOC_THROW_EXCEPTION(FileIOException, strerror(errno), "Unable to create temporary file: " + ft);
      }

      // Cleanup and close the file descriptor.
      prefix = filename_template;
      delete [] filename_template;
      filename_template = NULL;
      result = close(result);
      if (result == -1)
      {
         EDOC_THROW_EXCEPTION(FileIOException, strerror(errno), "Failed closing descriptor for temporary file: " + ft);
      }

      return prefix;
   }
   //========================================================================
}

---