/*---------------------------------------------------------------------------*
* 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 );
}