root/trunk/orca/files.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 <assert.h>
#include "os.h"
#include "ovalue.h"


extern int orIsDir( const char* path );
extern int orFileModified( const char* path, OValue* res );
extern void orReadDir( OValue*, const char* filename );
extern void orNowNative( OValue* a1 );
extern void orChangeDirNative( OValue* a1 );
extern void orWhatDirNative();
extern void orMakeDirNative( OValue* a1 );
extern void orRenameNative( OValue* a1 );
extern void orDeleteNative( OValue* a1 );
extern void orGetenvNative( OValue* a1 );

#ifdef OR_CONFIG_OS_CALL
extern void orCallNative( OValue* a1 );
#endif


#define DEVICE_CLASS  argc


OR_NATIVE( orOpenNative )
{
    OArray* arr = &orEnv->devices;
    OPortDevice** it  = (OPortDevice**) arr->buf;
    OPortDevice** end = it + arr->used;
    OContext ctx;

    ctx.vblkN = 0;

    while( it != end )
    {
        if( (*it)->open( a1, &ctx ) )
        {
            if( ctx.vblkN )
            {
                orSetTF( a1, OT_PORT );
                a1->DEVICE_CLASS = it - ((OPortDevice**) arr->buf);
                a1->ctx          = ctx;
            }
            return;
        }
        ++it;
    }

    orResultNONE;
}


OR_NATIVE( orCloseNative )
{
    OArray* arr = &orEnv->devices;
    int devID = a1->DEVICE_CLASS;

    assert( (devID > -1) && (devID < arr->used) );
    ((OPortDevice**) arr->buf)[ devID ]->close( &a1->ctx );
}


OR_NATIVE( orExistsQNative )
{
    int logic = 0;
    OString* str = orSTRING(a1);
    orTermCStr( str );
    if( orIsDir( str->charArray + a1->series.it ) > -1 )
        logic = 1;
    orResult( OT_LOGIC, logic );
}


OR_NATIVE( orSizeQNative )
{
    int size;
    OString* str = orSTRING(a1);
    orTermCStr( str );
    size = orFileSize( str->charArray + a1->series.it );
    if( size < 0 )
    {
        orResultNONE;
    }
    else
    {
        orResult( OT_INTEGER, size );
    }
}


OR_NATIVE( orDirQNative )
{
    int status;
    OString* str = orSTRING(a1);
    orTermCStr( str );
    status = orIsDir( str->charArray + a1->series.it );
    if( status < 0 )
    {
        orErrorT( OR_ERROR_ACCESS, "cannot query \"%s\"", 
                  str->charArray + a1->series.it );
        return;
    }
    orResult( OT_LOGIC, status );
}


OR_NATIVE( orModifiedQNative )
{
    int status;
    OString* str = orSTRING(a1);
    orTermCStr( str );
    status = orFileModified( str->charArray + a1->series.it, a1 );
    if( status < 0 )
    {
        orResultNONE;
    }
}


/*
   Returns zero if no newlines are found.
*/
static const char* findNewline( const char* it, const char* end )
{
    while( it != end )
    {
        if( *it == '\n' )
            return it;
        ++it;
    }
    return 0;
}


#define LINEBUF_SIZE        (1024 * 4)

static void readLines( const char* fn, OBlock* blk )
{
    //orError( "read /lines not implemented" );

    FileHandle fp;
    int n;
    int len;
    int totalRead;
    int seen;
    int offset;
    char* buffer;
    const char* npos;
    const char* pos;
    const char* end;


    fp = fileOpen( fn, FILE_READ );
    if( ! fp )
    {
        orErrorT( OR_ERROR_ACCESS, "cannot open file %s", fn );
        return;
    }

    buffer = memAlloc( LINEBUF_SIZE );
    totalRead = seen = offset = 0;

    do
    {
        n = fileRead( fp, buffer, LINEBUF_SIZE );
        if( n < 1 )
            break;

        offset += n;

        pos = buffer;
        end = buffer + n;

        while( 1 )
        {
            npos = findNewline( pos, end );
            if( ! npos )
            {
                seen += end - pos;
                break;
            }
            else if( seen > totalRead )
            {
                OString* str;
                int n2;

                seen += npos - pos;
                len = seen - totalRead;

                str = orMakeString( len + OR_CTERM_LEN );
                orAppendString( blk, str - orSTRINGS );

                // Would be good to avoid seek/read just to pick up end of buffer.
                fileSeek( fp, totalRead );
                n2 = fileRead( fp, str->charArray, len );
                fileSeek( fp, offset );

                str->used = n2;
                totalRead += n2 + 1;
                seen = totalRead;
                pos = npos + 1;
            }
            else
            {
                len = npos - pos;
                orAppendString( blk, orMakeCString( pos, len ) );
                totalRead += len + 1;
                seen = totalRead;
                pos = npos + 1;
            }
        }
    }
    while( n == LINEBUF_SIZE );

    if( seen > totalRead )
    {
        cprint( "FIXME: read/lines excess %d\n", seen - totalRead );
        //len = seen - totalRead;
        //orAppendString( blk, orMakeCString( buffer + n - len, len ) );
    }

    fileClose( fp );
    memFree( buffer );
}


#define REF_READ_BINARY     a1+1
#define REF_READ_LINES      a1+2
#define REF_READ_SKIP       a1+3
#define REF_READ_LENGTH     a1+4
#define REF_READ_PART       a1+5
#define REF_READ_SIZE       a1+6

/*
    read: native [
        source [file! port!]
        /binary
        /lines
        /skip length [number!]
        /part size [number!]
    ]
*/
OR_NATIVE( orReadNative )
{
    if( orIs(a1, OT_FILE) )
    {
        int n;
        const char* fn;
        OString* str = orSTRING(a1);

        orTermCStr( str );
        fn = str->charArray + a1->series.it;

        n = orIsDir( fn );
        if( n < 0 )
        {
            goto read_error;
        }
        else if( n == 1 )
        {
            orReadDir( a1, fn );
        }
        else
        {
            if( orRefineSet(REF_READ_LINES) )
            {
                OBlock* blk;

                if( orRefineSet(REF_READ_BINARY) )
                {
                    orError( "cannot use /binary with /lines" );
                    return;
                }

                blk = orMakeBlock(0);
                orRefPush( OT_BLOCK, orBlockN(blk) );
                readLines( fn, blk );
                orRefPop( 1 );
                orResultBLOCK( blk - orBLOCKS );
            }
            else
            {
                FileHandle fp;
                OString* buf;
                int err;
                int size;
                int skip = 0;

                if( orRefineSet(REF_READ_SKIP) )
                {
                    OValue* rval = REF_READ_LENGTH;
                    skip = orNumberToInt( rval );
                }

                if( orRefineSet(REF_READ_PART) )
                {
                    OValue* rval = REF_READ_SIZE;
                    size = orNumberToInt( rval );
                }
                else
                {
                    size = orFileSize( fn );
                    if( size < 0 )
                    {
                        orErrorT( OR_ERROR_ACCESS, "cannot query file %s", fn );
                        return;
                    }
                }

                buf = orMakeString( size + OR_CTERM_LEN );

                fp = fileOpen( fn, orRefineSet(REF_READ_BINARY) ?
                               FILE_READ_BINARY : FILE_READ );
                if( fp )
                {
                    if( skip )
                    {
                        n = fileSeek( fp, skip );
                        if( n == -1 )
                        {
                            fileClose( fp );
                            orErrorT(OR_ERROR_ACCESS, "skip failed on %s", fn);
                            return;
                        }
                    }

                    n = fileRead( fp, buf->buf, size );
                    err = fileError( fp );
                    fileClose( fp );

                    if( err )
                    {
read_error:
                        orErrorT( OR_ERROR_ACCESS, "read failed on %s", fn );
                        return;
                    }

                    buf->used = n;
                    orResultSeries( orRefineSet(REF_READ_BINARY) ?
                                    OT_BINARY : OT_STRING,
                                    buf - orSTRINGS, 0 );
                }
                else
                {
                    orErrorT( OR_ERROR_ACCESS, "cannot open file %s", fn );
                }
            }
        }
    }
    else if( orIs(a1, OT_PORT) )
    {
        OArray* arr = &orEnv->devices;
        int devID = a1->DEVICE_CLASS;

        assert( (devID > -1) && (devID < arr->used) );
        ((OPortDevice**) arr->buf)[ devID ]->read( &a1->ctx, a1 );
    }
}


#define REF_BINARY    a1+2
#define REF_APPEND    a1+3

OR_NATIVE( orWriteNative )
{
    if( a1->type == OT_FILE )
    {
        FileHandle fp;
        FileMode mode;
        OValue* a2;
        OString* file;

        a2 = a1 + 1;
        file = orSTRING(a1);
        orTermCStr( file );

        if( orRefineSet(REF_APPEND) )
        {
            if( orIs(a2, OT_BINARY) || orRefineSet(REF_BINARY) )
                mode = FILE_APPEND_BINARY;
            else
                mode = FILE_APPEND; 
        }
        else
        {
            if( orIs(a2, OT_BINARY) || orRefineSet(REF_BINARY) )
                mode = FILE_WRITE_BINARY;
            else
                mode = FILE_WRITE; 
        }

        fp = fileOpen( file->charArray, mode );
        if( fp )
        {
            OString* data = 0;

            if( orIs(a2, OT_OBJECT) )
            {
                data = orMakeString(0);
                orForm( data, a2 );
            }
            else if( orIs(a2, OT_STRING) || orIs(a2, OT_BINARY) )
            {
                data = orSTRING(a2);
            }

            if( data )
            {
                int n;

                n = fileWrite( fp, data->charArray, data->used );
                fileClose( fp );

                if( n != data->used )
                {
                    orErrorT( OR_ERROR_ACCESS,
                              "Only wrote %d bytes to %s", n, file->charArray );
                    return;
                }
            }
            else
            {
                fileClose( fp );
            }

            orResultUNSET;
            return;
        }
        orErrorT( OR_ERROR_ACCESS, "Cannot open %s", file->charArray );
    }
    else if( a1->type == OT_PORT )
    {
        OArray* arr = &orEnv->devices;
        int devID = a1->DEVICE_CLASS;

        assert( (devID > -1) && (devID < arr->used) );
        ((OPortDevice**) arr->buf)[ devID ]->write( &a1->ctx, a1 );
    }
}


char* orCleanPath( const char* src, const char* end, char* clean )
{
    char* dst = clean;
    while( src != end )
    {
        if( *src == '\\' || *src == '/' )
        {
            int len = end - src;
            if( (len > 2) && (src[1] == '.') && (src[2] == '.') )
            {
                src += 3;
                while( dst != clean )
                {
                    --dst;
                    if( *dst == '/' )
                        break;
                }
            }
            else
            {
                ++src;
                *dst++ = '/';
            }
        }
        else
        {
            *dst++ = *src++;
        }
    }
    return dst;
}


OR_NATIVE( cleanPathNative )
{
    OString* str;
    OString* clean;
    char* dst;

    str = orSTRING(a1);
    clean = orMakeString( orSeriesLen(str,a1) );

    dst = orCleanPath( orStrChars(str, a1), str->charArray + str->used,
                       clean->charArray );
    clean->used = dst - clean->charArray;

    orSetSeries( a1, orStringN(clean), 0 );
}


#ifdef OR_CONFIG_COMPRESS
#include <bzlib.h>


OR_NATIVE( orCompressNative )
{
    OString* str;
    OString* bin;
    int ret;
    unsigned int len;
    unsigned int blen;

    str = orSTRING(a1);
    len = str->used - a1->series.it;
    blen = len + (len / 99) + 600;
    bin = orMakeString( blen /*+ 4*/ );

    if( len > 0 )
    {
        ret = BZ2_bzBuffToBuffCompress( bin->charArray /*+ 4*/, &blen,
                                        str->charArray + a1->series.it, len,
                                        3, 0, 0 );
        if( ret == BZ_OUTBUFF_FULL )
        {
            orArrayFree( bin );
            orError( "compress buffer full" );
            return;
        }
        bin->used = blen;
    }
    orResultBINARY( bin - orSTRINGS );
}


OR_NATIVE_PUB( orDecompressNative )
{
#define BUF_LOW     32
    int ok;
    int len;
    bz_stream strm;
    OString* str;
    OString* bin;

    strm.bzalloc = 0;
    strm.bzfree  = 0;
    strm.opaque  = 0;

    ok = BZ2_bzDecompressInit( &strm, 0, 0 );
    if( ok == BZ_OK )
    {
        bin = orSTRING(a1);
        len = orSeriesLen( bin, a1 );
        strm.next_in   = orStrChars( bin, a1 );
        strm.avail_in  = len;

        str = orMakeString( (len < BUF_LOW) ? BUF_LOW : len );
        strm.next_out  = str->charArray;
        strm.avail_out = str->avail;

        while( ok == BZ_OK )
        {
            if( strm.avail_out < BUF_LOW )
            {
                orArrayReserve( str, 1, str->avail + (2 * BUF_LOW) );
                strm.next_out  = str->charArray + strm.total_out_lo32;
                strm.avail_out = str->avail - strm.total_out_lo32;
            }

            ok = BZ2_bzDecompress( &strm );
            str->used = strm.total_out_lo32;
        }

        BZ2_bzDecompressEnd( &strm );

        if( ok == BZ_STREAM_END )
        {
            orResultSTRING( str - orSTRINGS );
            return;
        }
        orError( "decompress failure (%d)", ok );
    }
    orError( "decompress init failure (%d)", ok );
}
#endif


void orFileNatives()
{
    orNative( orOpenNative,       "open"       );
    orNative( orCloseNative,      "close"      );
    orNative( orExistsQNative,    "exists?"    );
    orNative( orDirQNative,       "dir?"       );
    orNative( orSizeQNative,      "size?"      );
    orNative( orModifiedQNative,  "modified?"  );
    orNative( orReadNative,       "read"       );
    orNative( orWriteNative,      "write"      );
    orNative( orRenameNative,     "rename"     );
    orNative( orDeleteNative,     "delete"     );
    orNative( orChangeDirNative,  "change-dir" );
    orNative( orWhatDirNative,    "what-dir"   );
    orNative( orMakeDirNative,    "make-dir"   );
    orNative( orNowNative,        "now"        );
    orNative( orGetenvNative,     "getenv"     );
    orNative( cleanPathNative,    "clean-path" );

#ifdef OR_CONFIG_OS_CALL
    orNative( orCallNative,       "call"       );
#endif

#ifdef OR_CONFIG_COMPRESS
    orNative( orCompressNative,   "compress"   );
    orNative( orDecompressNative, "decompress" );
#endif
}


/*EOF*/