xref: /external/srec/portable/src/PFileWrap.c

/*---------------------------------------------------------------------------*
 *  PFileWrap.c  *
 *                                                                           *
 *  Copyright 2007, 2008 Nuance Communciations, Inc.                               *
 *                                                                           *
 *  Licensed under the Apache License, Version 2.0 (the 'License');          *
 *  you may not use this file except in compliance with the License.         *
 *                                                                           *
 *  You may obtain a copy of the License at                                  *
 *      http://www.apache.org/licenses/LICENSE-2.0                           *
 *                                                                           *
 *  Unless required by applicable law or agreed to in writing, software      *
 *  distributed under the License is distributed on an 'AS IS' BASIS,        *
 *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
 *  See the License for the specific language governing permissions and      *
 *  limitations under the License.                                           *
 *                                                                           *
 *---------------------------------------------------------------------------*/

#include <stdio.h>
#include <stdarg.h>
#include "LCHAR.h"
#include "pendian.h"
#include "PFile.h"
#include "plog.h"
#include "pstdio.h"
#include "ptypes.h"




ESR_ReturnCode PFileClose( PFile *self )
    {

    fclose ( (FILE *)self );
    return ( ESR_SUCCESS );
    }



ESR_ReturnCode PFileRead ( PFile *self, void *buffer, size_t size, size_t *count )
    {
    ESR_ReturnCode  read_status;
    size_t          items_read;
    int             ferror_status;

    items_read = fread ( buffer, size, *count, (FILE *)self );

    if ( items_read > 0 )
        {
        read_status = ESR_SUCCESS;
        *count = items_read;
        }
    else
        {
        ferror_status = ferror ( (FILE *)self );

        if ( ferror_status == 0 )
            {
            read_status = ESR_SUCCESS;
            *count = items_read;
            }
        else
            {
            read_status = ESR_READ_ERROR;
            }
        }
    return ( read_status );
    }



ESR_ReturnCode PFileWrite ( PFile *self, const void *buffer, size_t size, size_t *count )
    {
    ESR_ReturnCode  write_status;
    size_t          items_written;

    items_written = fwrite ( buffer, size, *count, (FILE *)self );

    if ( items_written == ( *count ) )
        {
        write_status = ESR_SUCCESS;
        *count = items_written;
        }
    else
        {
        write_status = ESR_READ_ERROR;
        }
    return ( write_status );
    }



ESR_ReturnCode PFileFlush ( PFile *self )
    {
    ESR_ReturnCode  flush_status;
    size_t          flush_ok;

    flush_ok = fflush ( (FILE *)self );

    if ( flush_ok == 0 )
        {
        flush_status = ESR_SUCCESS;
        }
    else
        {
        flush_status = ESR_FLUSH_ERROR;
        }
    return ( flush_status );
    }



ESR_ReturnCode PFileSeek ( PFile *self, long offset, int origin )
    {
    ESR_ReturnCode  seek_status;
    size_t          seek_ok;

    seek_ok = fseek ( (FILE *)self, offset, origin );

    if ( seek_ok == 0 )
        {
        seek_status = ESR_SUCCESS;
        }
    else
        {
        seek_status = ESR_SEEK_ERROR;
        }
    return ( seek_status );
    }



ESR_ReturnCode PFileGetPosition ( PFile *self, size_t *position )
    {
    ESR_ReturnCode  get_status;
    long            ftell_result;

    ftell_result = ftell ( (FILE *)self );

    if ( ftell_result >= 0 )
        {
	*position = (size_t)ftell_result;
        get_status = ESR_SUCCESS;
        }
    else
        {
        get_status = ESR_INVALID_STATE;
        }
    return ( get_status );
    }



ESR_ReturnCode PFileIsEOF ( PFile *self, ESR_BOOL *isEof )
    {
#ifdef NO_FEOF
    long            posCur;    /* remember current file position */
    long            posEnd;    /* end of file position */

    posCur = ftell ( self );
    fseek ( self, 0, SEEK_END );
    posEnd = ftell ( self );

    if ( posCur == posEnd )
        *isEof = ESR_TRUE;
    else
        *isEof = ESR_FALSE;
    fseek ( self, posCur, SEEK_SET );  /* restore position in file */
#else
    int             is_eof;

    is_eof = feof ( (FILE *)self );

    if ( is_eof != 0 )
        *isEof = ESR_TRUE;
    else
        *isEof = ESR_FALSE;
#endif
    return ( ESR_SUCCESS );
    }



ESR_ReturnCode PFileIsErrorSet ( PFile *self, ESR_BOOL *isError )
    {
    int is_error;

    is_error = ferror ( (FILE *)self );

    if ( is_error != 0 )
        *isError = ESR_TRUE;
    else
        *isError = ESR_FALSE;
    return ( ESR_SUCCESS );
    }



ESR_ReturnCode PFileClearError ( PFile *self )
    {

    clearerr ( (FILE *)self );
    return ( ESR_SUCCESS );
    }



ESR_ReturnCode PFileVfprintf ( PFile *self, int *result, const LCHAR *format, va_list args )
    {
    int bytes_printed;

    bytes_printed = vfprintf ( (FILE *)self, format, args );

    if ( result != NULL )
        *result = bytes_printed;
    return ( ESR_SUCCESS );
    }



ESR_ReturnCode PFileFgetc ( PFile *self, LINT *result )
    {
    ESR_ReturnCode  fgetc_status;
    int             error_status;

    *result = fgetc ( (FILE *)self );

    if ( ( *result ) != EOF )
        {
        fgetc_status = ESR_SUCCESS;
        }
    else
        {
        error_status = ferror ( (FILE *)self );

        if ( error_status == 0 )
            fgetc_status = ESR_SUCCESS;
        else
            fgetc_status = ESR_INVALID_STATE;
        }
    return ( fgetc_status );
    }



ESR_ReturnCode PFileFgets ( PFile *self, LCHAR *string, int n, LCHAR **result )
    {
    ESR_ReturnCode  fgets_status;
    int             error_status;
    LCHAR           *temp;

    temp = fgets ( string, n, (FILE *)self );

    if ( temp != NULL )
        {
        fgets_status = ESR_SUCCESS;

        if ( result != NULL )
            *result = temp;
        }
    else
        {
        error_status = ferror ( (FILE *)self );

        if ( error_status == 0 )
            {
            fgets_status = ESR_SUCCESS;

            if ( result != NULL )
                *result = NULL;
            }
        else
            fgets_status = ESR_INVALID_STATE;
        }
    return ( fgets_status );
    }



PFile *pfopen ( const LCHAR *filename, const LCHAR *mode )
    {
    PFile           *result;

    result = (PFile *)fopen ( filename, mode );
    return ( result );
    }



size_t pfread ( void *buffer, size_t size, size_t count, PFile *stream )
    {
    ESR_ReturnCode rc;

    rc = PFileRead ( stream, buffer, size, &count );

    if ( rc != ESR_SUCCESS )
        return ( 0 );
    return ( count );
    }



size_t pfwrite ( const void *buffer, size_t size, size_t count, PFile *stream )
    {
    ESR_ReturnCode rc;

    rc = PFileWrite ( stream, buffer, size, &count );
    if ( rc != ESR_SUCCESS )
        return ( 0 );
    return ( count );
    }



int pfclose ( PFile *stream )
    {

    fclose ( (FILE *)stream );

    return ( 0 );
    }



void prewind (PFile *stream)
    {

    PFileSeek ( stream, 0, SEEK_SET );
    }



int pfseek ( PFile *stream, long offset, int origin )
    {
    ESR_ReturnCode rc;

    rc = PFileSeek ( stream, offset, origin );

    if ( rc != ESR_SUCCESS )
        return ( 1 );
    return ( 0 );
    }



long pftell ( PFile *stream )
    {
    ESR_ReturnCode  rc;
    size_t          result;

    rc = PFileGetPosition ( stream, &result );

    if ( rc != ESR_SUCCESS )
        return ( -1 );
    return ( result );
    }



int pfeof ( PFile *stream )
    {
    ESR_BOOL eof;

    PFileIsEOF ( stream, &eof );

    if ( ! eof )
        return ( 0 );
        return ( 1 );
    }



int pferror ( PFile *stream )
    {
    ESR_BOOL error;

    PFileIsErrorSet ( stream, &error );

    if ( ! error )
        return ( 0 );
    return ( 1 );
    }



void pclearerr ( PFile *stream )
    {

    PFileClearError ( stream );
    }



int pfflush ( PFile *stream )
    {
    ESR_ReturnCode rc;

    rc = PFileFlush ( stream );

    if ( rc != ESR_SUCCESS )
        return ( PEOF );
    return ( 0 );
    }



LCHAR* pfgets ( LCHAR *string, int n, PFile *self )
    {
    LCHAR           *result;
    ESR_ReturnCode  rc;

    rc = PFileFgets ( self, string, n, &result );

    if ( rc != ESR_SUCCESS )
        return ( NULL );
    return ( result );
    }



LINT pfgetc ( PFile *self )
    {
    ESR_ReturnCode  rc;
    LINT            result;

    rc = PFileFgetc ( self, &result );

    if ( rc != ESR_SUCCESS )
        return ( PEOF );
    return ( result );
    }



int pfprintf ( PFile *stream, const LCHAR *format, ... )
    {
    ESR_ReturnCode  rc;
    int             result;
    va_list         args;

    va_start ( args, format );
    rc = PFileVfprintf ( stream, &result, format, args );
    va_end ( args );

    if ( rc != ESR_SUCCESS )
        return ( -1 );
    return ( result );
    }



int pvfprintf ( PFile *stream, const LCHAR *format, va_list argptr )
    {
    ESR_ReturnCode  rc;
    int             result;

    rc = PFileVfprintf ( stream, &result, format, argptr );

    if ( rc != ESR_SUCCESS )
        return ( -1 );
    return ( result );
    }


ESR_ReturnCode pf_convert_backslashes_to_forwardslashes ( LCHAR *string_to_convert )
    {
    ESR_ReturnCode  rc;
    int             string_status;

    if ( string_to_convert != NULL )
        {
	string_status = lstrreplace ( string_to_convert, L('\\'), L('/') );

	if ( string_status == 0 )
	    rc = ESR_SUCCESS;
	else
	    rc = ESR_INVALID_ARGUMENT;
	}
    else
	{
	rc = ESR_INVALID_ARGUMENT;
	}
    return ( rc );
    }



ESR_ReturnCode pf_is_path_absolute ( const LCHAR* input_path, ESR_BOOL* isAbsolute )
    {
    ESR_ReturnCode rc;
    LCHAR path [P_PATH_MAX];

    if ( isAbsolute != NULL )
        {
	LSTRCPY ( path, input_path );
	rc = pf_convert_backslashes_to_forwardslashes ( path );

	if ( rc == ESR_SUCCESS )
	    {
	    if ( ( path [0] == '/' ) || ( ( LISALPHA ( path [0] ) ) && ( path [1] == ':' ) && ( path [2] == '/' ) ) )
		*isAbsolute = ESR_TRUE;
	    else
		*isAbsolute = ESR_FALSE;
	    }
	}
    else
	{
	rc = ESR_INVALID_ARGUMENT;
	}
    return ( rc );
    }