root/trunk/orca/win32/os.c

/*============================================================================
    ORCA Interpreter
    Copyright (C) 2005-2006  Karl Robillard

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2.1 of the License, or (at your option) any later version.

    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.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
===========================================================================*/


#include <windows.h>
#include <direct.h>
#include <io.h>
#include <sys/timeb.h>
#include <time.h>
#include "os.h"
#include "ovalue.h"


unsigned long randomSeed()
{
    unsigned long seed;
    seed  = time(NULL);
    seed += clock();
    return seed;
}


/**
  Returns -1 if not present.
*/
int orFileSize( const char* path )
{
    LARGE_INTEGER lsize;
    HANDLE fh = CreateFile( path, GENERIC_READ, FILE_SHARE_READ, NULL,
                            OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL );
    if( fh == INVALID_HANDLE_VALUE)
        return -1;
    if( ! GetFileSizeEx( fh, &lsize ) )
        return -1;
    CloseHandle( fh );
    return lsize.LowPart;
}


/**
  Returns 1 if directory, 0 if file or -1 if error.
*/
int orIsDir( const char* path )
{
    DWORD attr;
    attr = GetFileAttributes( path );
    if( attr == INVALID_FILE_ATTRIBUTES )
        return -1;
    return (attr & FILE_ATTRIBUTE_DIRECTORY) ? 1 : 0;
}


/**
  Returns 0 if result set to file modification time or -1 if error.
*/
int orFileModified( const char* path, OValue* res )
{
    (void) path;
    (void) res;
    /*
    struct stat buf;
    if( stat( path, &buf ) == -1 )
    */
        return -1;

    /*
    orSetTF( res, OT_TIME );
    res->time.sec  = buf.st_mtime;
    res->time.usec = 0;
    return 0;
    */
}


/*
   change-dir
*/
OR_NATIVE_PUB( orChangeDirNative )
{
    int logic = 0;
    OString* str = orSTRING(a1);
    orTermCStr(str);
    if( _chdir( str->charArray ) == 0 )
        logic = 1;
    orResult( OT_LOGIC, logic );
}


/*
   what-dir
*/
OR_NATIVE_PUB( orWhatDirNative )
{
    if( _getcwd( orTmp, OR_TMP_SIZE ) )
    {
        int len;
        OString* str;
       
        len = strLen( orTmp );
        if( len > 0 )
        {
            str = orMakeString( len + OR_CTERM_LEN );
            str->used = len;
            memCpy( str->charArray, orTmp, len );
            orResultFILE( orStringN(str) );
            return;
        }
    }
    orResultFALSE;
}


/*
  No error if directory exists.
*/
OR_NATIVE_PUB( orMakeDirNative )
{
    OString* str = orSTRING(a1);
    orTermCStr(str);

#if 1
    if( ! CreateDirectory( str->charArray, NULL ) )
    {
        DWORD err;
        err = GetLastError();
        if( (err != ERROR_FILE_EXISTS) || (orIsDir(str->charArray) != 1) )
        {
            orErrorT( OR_ERROR_ACCESS, "CreateDirectory error (%d)", err );
        }
    }
#else
    int err;
    err = _mkdir( str->charArray );
    if( err )
    {
        if( (errno != EEXIST) || (orIsDir(str->charArray) != 1) )
        {
            orErrorT( OR_ERROR_ACCESS, strerror/*_r*/(errno) );
        }
    }
#endif
}


#define REF_TIME    a1

OR_NATIVE_PUB( orNowNative )
{
    struct _timeb tb;

    _ftime( &tb );

    if( orRefineSet( REF_TIME ) )
        orSetTF( a1, OT_TIME );
    else
        orSetTF( a1, OT_DATE );
    orSeconds(a1) = tb.time + (tb.millitm * 0.001);
}


void orReadDir( OValue* a1, const char* filename )
{
    char filespec[ _MAX_PATH ];
    struct _finddata_t fileinfo;
    long handle;

    // Look for all files.  We ensure there is a slash before the wildcard.
    // It's OK if the path is already terminated with a slash - multiple
    // slashes are filtered by _findfirst.

    strcpy( filespec, filename );
    strcat( filespec, "\\*.*" );

    handle = _findfirst( filespec, &fileinfo );
    if( handle != -1 )
    {
        OIndex hold;
        OIndex blkN;
        OBlock* blk = orMakeBlock( 0 );

        blkN = orBlockN(blk);
        hold = orHold( OT_BLOCK, blkN );

        do
        {
            const char* cp = fileinfo.name;
            if( cp[0] == '.' && (cp[1] == '.' || cp[1] == '\0') )
                continue;

            orAppendFile( blk, orMakeCString(fileinfo.name, -1) );
        }
        while( _findnext( handle, &fileinfo ) != -1 );

        _findclose( handle );

        orRelease( hold );
        orResultBLOCK( blkN );
    }
    else
    {
        orResultFALSE;
    }
}


#ifdef OR_CONFIG_OS_CALL

#define REF_CALL_OUTPUT     a1+1
#define REF_CALL_OUT        a1+2
#define REF_CALL_WAIT       a1+3


static void callOutput( OValue* a1 )
{
#define BUFSIZE     256
    OString* str;
    char* cp;
    HANDLE childStdOutR;
    HANDLE childStdOutW;
    DWORD nr;
    SECURITY_ATTRIBUTES sec;
    STARTUPINFO si;
    PROCESS_INFORMATION pi;


    str = orSTRING( a1 );
    orTermCStr( str );
    cp  = orStrChars( str, a1 );


    sec.nLength              = sizeof(SECURITY_ATTRIBUTES); 
    sec.lpSecurityDescriptor = NULL;
    sec.bInheritHandle       = TRUE; 

    if( ! CreatePipe( &childStdOutR, &childStdOutW, &sec, 0 ) ) 
    {
        orError( "CreatePipe failed\n" );
        return;
    }

    SetHandleInformation( childStdOutR, HANDLE_FLAG_INHERIT, 0 );

    ZeroMemory( &si, sizeof(si) );
    si.cb         = sizeof(si);
    si.hStdError  = childStdOutW;
    si.hStdOutput = childStdOutW;
    si.hStdInput  = NULL;
    si.dwFlags    = STARTF_USESTDHANDLES;

    ZeroMemory( &pi, sizeof(pi) );

    // Start the child process. 
    if( ! CreateProcess( NULL,   // No module name (use command line). 
        TEXT(cp),         // Command line. 
        NULL,             // Process handle not inheritable. 
        NULL,             // Thread handle not inheritable. 
        TRUE,             // Handle inheritance. 
        DETACHED_PROCESS, // Prevent pop-up of MSDOS windows.
        NULL,             // Use parent's environment block. 
        NULL,             // Use parent's starting directory. 
        &si,              // Pointer to STARTUPINFO structure.
        &pi )             // Pointer to PROCESS_INFORMATION structure.
    )
    {
        CloseHandle( childStdOutW );
        CloseHandle( childStdOutR );
        orError( "CreateProcess failed (%d).\n", GetLastError() );
        return;
    }

    CloseHandle( childStdOutW );

    str = orSTRING(REF_CALL_OUT);
    str->used = 0;
    orArrayReserve( str, 1, BUFSIZE ); 

    while( 1 )
    {
        if( ReadFile( childStdOutR, str->charArray + str->used, BUFSIZE,
                      &nr, NULL ) == 0 )
        {
            // GetLastError();
            break;
        }
        if( nr == 0 )
            break;

        str->used += nr;
        orArrayReserve( str, 1, str->used + BUFSIZE ); 
    }

    // MSDN example does not CloseHandle(childStdOutR);

    {
    DWORD code;

    // Wait until child process exits.
    WaitForSingleObject( pi.hProcess, INFINITE );

    if( GetExitCodeProcess( pi.hProcess, &code ) )
    {
        orResult( OT_INTEGER, code );
    }
    else
    {
        orResultNONE;
    }
    }

    // Close process and thread handles. 
    CloseHandle( pi.hProcess );
    CloseHandle( pi.hThread );
}


static void callSimple( OValue* a1 )
{
    OString* str;
    char* cp;
    STARTUPINFO si;
    PROCESS_INFORMATION pi;

    str = orSTRING( a1 );
    orTermCStr( str );
    cp  = orStrChars( str, a1 );

    ZeroMemory( &si, sizeof(si) );
    si.cb = sizeof(si);

    ZeroMemory( &pi, sizeof(pi) );

    // Start the child process. 
    if( ! CreateProcess( NULL,   // No module name (use command line). 
        TEXT(cp),         // Command line. 
        NULL,             // Process handle not inheritable. 
        NULL,             // Thread handle not inheritable. 
        FALSE,            // Set handle inheritance to FALSE. 
        0,                // No creation flags. 
        NULL,             // Use parent's environment block. 
        NULL,             // Use parent's starting directory. 
        &si,              // Pointer to STARTUPINFO structure.
        &pi )             // Pointer to PROCESS_INFORMATION structure.
    )
    {
        orError( "CreateProcess failed (%d).\n", GetLastError() );
        return;
    }

    orResultNONE;

    if( orRefineSet(REF_CALL_WAIT) )
    {
        DWORD code;

        // Wait until child process exits.
        WaitForSingleObject( pi.hProcess, INFINITE );

        if( GetExitCodeProcess( pi.hProcess, &code ) )
        {
            orResult( OT_INTEGER, code );
        }
    }

    // Close process and thread handles. 
    CloseHandle( pi.hProcess );
    CloseHandle( pi.hThread );
}


OR_NATIVE_PUB( orCallNative )
{
    if( a1->type != OT_STRING )
    {
        orResultFALSE;
        return;
    }

    if( orRefineSet( REF_CALL_OUTPUT ) )
    {
        callOutput( a1 );
    }
    else
    {
        callSimple( a1 );
    }
}
#endif


void orInstallExceptionHandlers() {}


/*EOF*/