/* FILE.C * * High-level file I/O for MIDAS Sound System * * $Id: file.c,v 1.2 1997/01/16 18:41:59 pekangas Exp $ * * Copyright 1996,1997 Housemarque Inc. * * This file is part of the MIDAS Sound System, and may only be * used, modified and distributed under the terms of the MIDAS * Sound System license, LICENSE.TXT. By continuing to use, * modify or distribute this file you indicate that you have * read the license and understand and accept it fully. */ /****************************************************************************\ * Note! This module basicly calls directly the raw file I/O functions. * This kind of separation, however, is useful as it allows other kinds * of file systems, such as a compressed file library, to be added by * simply relinking MIDAS with another high-level file I/O module. \****************************************************************************/ #include #include #include #include "lang.h" #include "mtypes.h" #include "errors.h" #include "mmem.h" #include "rawfile.h" #include "file.h" RCSID(const char *file_rcsid = "$Id: file.c,v 1.2 1997/01/16 18:41:59 pekangas Exp $";) /****************************************************************************\ * * Function: int fileOpen(char *fileName, int openMode, fileHandle *file); * * Description: Opens a file for reading or writing * * Input: char *fileName name of file * int openMode file opening mode, see enum rfOpenMode * fileHandle *file pointer to file handle * * Returns: MIDAS error code. * File handle is stored in *file. * \****************************************************************************/ int CALLING fileOpen(char *fileName, int openMode, fileHandle *file) { int error; int rfMode; fileHandle hdl; /* allocate file structure: */ if ( (error = memAlloc(sizeof(fileFile), (void**) &hdl)) != OK ) PASSERROR(ID_fileOpen) switch ( openMode ) { case fileOpenRead: /* open file for reading */ rfMode = rfOpenRead; break; case fileOpenWrite: /* open file for writing */ rfMode = rfOpenWrite; break; case fileOpenReadWrite: /* open file for reading and writing */ rfMode = rfOpenReadWrite; break; default: ERROR(ID_fileOpen, errInvalidArguments); return errInvalidArguments; } /* open file: */ if ( (error = rfOpen(fileName, rfMode, (rfHandle*) &hdl->rf)) != OK ) PASSERROR(ID_fileOpen) *file = hdl; return OK; } /****************************************************************************\ * * Function: int fileClose(fileHandle file); * * Description: Closes a file opened with fileOpen(). * * Input: fileHandle file handle of an open file * * Returns: MIDAS error code * \****************************************************************************/ int CALLING fileClose(fileHandle file) { int error; /* close file: */ if ( (error = rfClose(file->rf)) != OK ) PASSERROR(ID_fileClose) /* deallocate file structure: */ if ( (error = memFree(file)) != OK ) PASSERROR(ID_fileClose) return OK; } /****************************************************************************\ * * Function: int fileGetSize(fileHandle file, long *fileSize); * * Description: Get the size of a file * * Input: fileHandle file handle of an open file * ulong *fileSize pointer to file size * * Returns: MIDAS error code. * File size is stored in *fileSize. * \****************************************************************************/ int CALLING fileGetSize(fileHandle file, long *fileSize) { int error; /* get file size to *fileSize: */ if ( (error = rfGetSize(file->rf, fileSize)) != OK ) PASSERROR(ID_fileGetSize) return OK; } /****************************************************************************\ * * Function: int fileRead(fileHandle file, void *buffer, ulong numBytes); * * Description: Reads binary data from a file * * Input: fileHandle file file handle * void *buffer reading buffer * ulong numBytes number of bytes to read * * Returns: MIDAS error code. * Read data is stored in *buffer, which must be large enough * for it. * \****************************************************************************/ int CALLING fileRead(fileHandle file, void *buffer, ulong numBytes) { int error; /* read data from file: */ if ( (error = rfRead(file->rf, buffer, numBytes)) != OK ) PASSERROR(ID_fileRead) return OK; } /****************************************************************************\ * * Function: int fileWrite(fileHandle file, void *buffer, ulong numBytes); * * Description: Writes binary data to a file * * Input: fileHandle file file handle * void *buffer pointer to data to be written * ulong numBytes number of bytes to write * * Returns: MIDAS error code * \****************************************************************************/ int CALLING fileWrite(fileHandle file, void *buffer, ulong numBytes) { int error; /* write data to file: */ if ( (error = rfWrite(file->rf, buffer, numBytes)) != OK ) PASSERROR(ID_fileWrite) return OK; } /****************************************************************************\ * * Function: int fileSeek(fileHandle file, long newPosition, int seekMode); * * Description: Seeks to a new position in file. Subsequent reads and writes * go to the new position. * * Input: fileHandle file file handle * long newPosition new file position * int seekMode file seek mode, see enum rfSeekMode * * Returns: MIDAS error code * \****************************************************************************/ int CALLING fileSeek(fileHandle file, long newPosition, int seekMode) { int error; int rfMode; switch ( seekMode ) { case fileSeekAbsolute: /* seek to an absolute position */ rfMode = rfSeekAbsolute; break; case fileSeekRelative: /* seek relative to current position */ rfMode = rfSeekRelative; break; case fileSeekEnd: /* seek from end of file */ rfMode = rfSeekEnd; break; default: ERROR(ID_fileSeek, errInvalidArguments); return errInvalidArguments; } /* seek to new file position: */ if ( (error = rfSeek(file->rf, newPosition, rfMode)) != OK ) PASSERROR(ID_fileSeek) return OK; } /****************************************************************************\ * * Function: int fileGetPosition(fileHandle file, long *position); * * Description: Reads the current position in a file * * Input: fileHandle file file handle * long *position pointer to file position * * Returns: MIDAS error code. * Current file position is stored in *position. * \****************************************************************************/ int CALLING fileGetPosition(fileHandle file, long *position) { int error; /* get current file position to *position: */ if ( (error = rfGetPosition(file->rf, position)) != OK ) PASSERROR(ID_fileGetPosition) return OK; } /****************************************************************************\ * * Function: int fileExists(char *fileName, int *exists); * * Description: Checks if a file exists or not * * Input: char *fileName file name, ASCIIZ * int *exists pointer to file exists status * * Returns: MIDAS error code. * *exists contains 1 if file exists, 0 if not. * \****************************************************************************/ int CALLING fileExists(char *fileName, int *exists) { int error; if ( (error = rfFileExists(fileName, exists)) != OK ) PASSERROR(ID_fileExists); return OK; }