file_differ.cpp

Go to the documentation of this file.

#ifndef FILE_DIFFER_IMPLEMENTATION_FILE
#define FILE_DIFFER_IMPLEMENTATION_FILE

/*****************************************************************************\
*
*  Name   : file_differ
*  Author : Aaron Buchanan
*
*******************************************************************************
* Copyright (c) 2002-$now By Author.  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 is online at:      *
*     http://www.fsf.org/copyleft/gpl.html                                    *
* Please send any updates to: fred@gruntose.com                               *
\*****************************************************************************/

#include "file_differ.h"

#include <basis/convert_utf.h>
#include <basis/istring.h>
#include <basis/portable.h>

#include <stdio.h> 

#define BUFSIZE 4096 

bool file_differ::diff_files(const istring &_file1, const istring &_file2, const istring &_options,
                             istring &_results, istring &_error)
{ 
    _results.reset();

#ifdef __WIN32__
    // Set the bInheritHandle flag so pipe handles are inherited. 
    SECURITY_ATTRIBUTES saAttr; 
    saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); 
    saAttr.bInheritHandle = true; 
    saAttr.lpSecurityDescriptor = NULL; 
    
    // The steps for redirecting child process's STDOUT: 
    //     1. Save current STDOUT, to be restored later. 
    //     2. Create anonymous pipe to be STDOUT for child process. 
    //     3. Set STDOUT of the parent process to be write handle to 
    //        the pipe, so it is inherited by the child process. 
    //     4. Create a noninheritable duplicate of the read handle and
    //        close the inheritable read handle. 
    
    // Save the handle to the current STDOUT. 
    HANDLE hSaveStdout = GetStdHandle(STD_OUTPUT_HANDLE); 
    
    // Create a pipe for the child process's STDOUT. 
    HANDLE hChildStdoutRd, hChildStdoutWr;
    if( false == CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0) ) 
    {
        _error = "Stdout pipe creation failed";
        return false;
    }
    
    // Set a write handle to the pipe to be STDOUT. 
    if( false == SetStdHandle(STD_OUTPUT_HANDLE, hChildStdoutWr) )
    {
        _error = "Redirecting STDOUT failed";
        return false;
    }
    
    // Create noninheritable read handle and close the inheritable read handle. 
    HANDLE hChildStdoutRdDup;
    if( false == DuplicateHandle(GetCurrentProcess(), hChildStdoutRd,
                                 GetCurrentProcess(), &hChildStdoutRdDup , 0,
                                 false,
                                 DUPLICATE_SAME_ACCESS) )
    {
        _error = "DuplicateHandle failed";
        return false;
    }
    CloseHandle(hChildStdoutRd);
    
    // Now create the child process.
    // Set up members of the PROCESS_INFORMATION structure. 
    PROCESS_INFORMATION piProcInfo; 
    ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) );
    
    // Set up members of the STARTUPINFO structure. 
    STARTUPINFO siStartInfo; 
    ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) );
    siStartInfo.cb = sizeof(STARTUPINFO); 
    // Note here the dwFlags should be STARTF_USESTDHANDLES, which is descripted in 
    // win32 API document, but this was omitted in MSDN sample
    siStartInfo.dwFlags = STARTF_USESTDHANDLES;
    siStartInfo.hStdOutput = hChildStdoutWr;
    siStartInfo.hStdError = hChildStdoutWr;
    
    // Create the child process. 
    isprintf cmdline("diff %s %s %s", _options.s(), _file1.s(), _file2.s());
    if( !CreateProcess(NULL,          // app name
                       to_unicode_temp(cmdline),   // command line 
                       NULL,          // process security attributes 
                       NULL,          // primary thread security attributes 
                       true,          // handles are inherited 
                       CREATE_NO_WINDOW,    // creation flags 
                       NULL,          // use parent's environment 
                       NULL,          // use parent's current directory 
                       &siStartInfo,  // STARTUPINFO pointer 
                       &piProcInfo) ) // receives PROCESS_INFORMATION 
    {
        LPVOID lpMsgBuf;
        FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | 
                      FORMAT_MESSAGE_IGNORE_INSERTS,
                      NULL,
                      GetLastError(),
                      MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default language
                      (LPTSTR) &lpMsgBuf,
                      0,
                      NULL);
        _error = isprintf("Create process failed: %s", (LPCTSTR)lpMsgBuf);
        // Free the buffer.
        LocalFree( lpMsgBuf );
        return false;
    }
    
    // After process creation, restore the saved STDOUT. 
    if( false == SetStdHandle(STD_OUTPUT_HANDLE, hSaveStdout) )
    {
        _error = "Re-redirecting Stdout failed";
        return false;
    }
    
    // Close the write end of the pipe before reading from the 
    // read end of the pipe. 
    if( false == CloseHandle(hChildStdoutWr) ) 
    {
        _error = "Closing handle failed";
        return false;
    }
    
    // Read output from the child process, and save to the results string
    DWORD dwRead; 
    CHAR chBuf[BUFSIZE]; 
    HANDLE hStdout = GetStdHandle(STD_OUTPUT_HANDLE); 
    for (;;) 
    { 
        chBuf[0] = '\0';
        if( !ReadFile( hChildStdoutRdDup, chBuf, BUFSIZE - 1, &dwRead, NULL) || dwRead == 0)
            break; 
        chBuf[dwRead] = '\0';
        _results += chBuf;
    } 
#elif defined(__UNIX__)
if (!_file1 || !_file2 || !_options || !_error) {}
  // hmmm: add support for calling diff here.
#else
  // hmmm: add support for calling diff here.
#endif

    return true;
} 


void file_differ::AddCRs(istring &_string)
{
    const istring addin("\r");
    for( int i = 0; i < _string.length(); ++i )
    {
        if( ('\n' == _string[i]) && ((i == 0) || ('\r' != _string[i-1])) )
        {
            _string.insert(i, addin);
            ++i;
        }
    }
}


#endif //FILE_DIFFER_IMPLEMENTATION_FILE

---