Commit 261c063f authored by Jonas Termansen's avatar Jonas Termansen

Refactored libmaxsi/file.c into a multiple files.

parent 8dc5955f
......@@ -31,7 +31,6 @@ ASFLAGS=$(CPUASFLAGS)
OBJS=\
ctype.o \
crc32.o \
file.o \
fdio.o \
fpipe.o \
stdio.o \
......@@ -115,6 +114,40 @@ strspn.o \
strstr.o \
strtok.o \
strtok_r.o \
clearerr.o \
fbufsize.o \
fclose.o \
fcloseall.o \
feof.o \
ferror.o \
fflush.o \
fgetc.o \
fgets.o \
fileno.o \
flbf.o \
flushlfb.o \
fnewline.o \
fpending.o \
fpurge.o \
fputc.o \
fputs.o \
fread.o \
freadable.o \
freading.o \
fregister.o \
fseek.o \
fseeko.o \
fseterr.o \
fsetlocking.o \
ftell.o \
ftello.o \
fwritable.o \
fwrite.o \
fwriting.o \
getc.o \
putc.o \
rewind.o \
ungetc.o \
UNPROCHEADERDIRS:=$(shell find include -type d)
UNPROCHEADERS:=$(shell find include -type f)
......
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi 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 3 of the License, or (at your option)
any later version.
LibMaxsi 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 LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
clearerr.cpp
Clears the error condition on a FILE.
*******************************************************************************/
#include <stdio.h>
extern "C" void clearerr(FILE* fp)
{
if ( fp->clearerr_func )
fp->clearerr_func(fp->user);
}
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi 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 3 of the License, or (at your option)
any later version.
LibMaxsi 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 LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
fbufsize.cpp
Returns the size of the FILE's buffer.
*******************************************************************************/
#include <stdio.h>
extern "C" size_t fbufsize(FILE* fp)
{
return fp->buffersize;
}
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi 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 3 of the License, or (at your option)
any later version.
LibMaxsi 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 LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
fclose.cpp
Closes and flushes a FILE.
*******************************************************************************/
#include <stdio.h>
extern "C" int fclose(FILE* fp)
{
int result = fflush(fp);
result |= fp->close_func ? fp->close_func(fp->user) : 0;
funregister(fp);
if ( fp->free_func ) { fp->free_func(fp); }
return result;
}
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi 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 3 of the License, or (at your option)
any later version.
LibMaxsi 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 LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
fcloseall.cpp
Closes and flushes all open registered files.
*******************************************************************************/
#include <stdio.h>
extern "C" int fcloseall(void)
{
int result = 0;
while ( _firstfile ) { result |= fclose(_firstfile); }
return (result) ? EOF : 0;
}
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi 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 3 of the License, or (at your option)
any later version.
LibMaxsi 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 LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
feof.cpp
Returns whether the end of file condition is set on a FILE.
*******************************************************************************/
#include <stdio.h>
extern "C" int feof(FILE* fp)
{
if ( fp->numpushedback )
return 0;
if ( fp->eof_func )
return fp->eof_func(fp->user);
return 0;
}
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi 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 3 of the License, or (at your option)
any later version.
LibMaxsi 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 LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
ferror.cpp
Returns whether the error condition is set on a FILE.
*******************************************************************************/
#include <stdio.h>
extern "C" int ferror(FILE* fp)
{
if ( fp->error_func )
return fp->error_func(fp->user);
return 0;
}
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi 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 3 of the License, or (at your option)
any later version.
LibMaxsi 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 LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
fflush.cpp
Flushes a FILE.
*******************************************************************************/
#include <stdio.h>
#include <errno.h>
extern "C" int fflush(FILE* fp)
{
if ( !fp )
{
int result = 0;
for ( fp = _firstfile; fp; fp = fp->next ) { result |= fflush(fp); }
return result;
}
if ( !fp->write_func ) { errno = EBADF; return EOF; }
if ( !fp->bufferused ) { return 0; }
size_t written = fp->write_func(fp->buffer, 1, fp->bufferused, fp->user);
if ( written < fp->bufferused ) { return EOF; }
fp->bufferused = 0;
return 0;
}
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi 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 3 of the License, or (at your option)
any later version.
LibMaxsi 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 LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
fgetc.cpp
Reads a single character from a FILE.
*******************************************************************************/
#include <stdio.h>
extern "C" int fgetc(FILE* fp)
{
unsigned char c;
if ( fread(&c, 1, sizeof(c), fp) < sizeof(c) ) { return EOF; }
return c;
}
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi 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 3 of the License, or (at your option)
any later version.
LibMaxsi 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 LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
fgets.cpp
Reads a string from a FILE.
*******************************************************************************/
#include <stdio.h>
#include <errno.h>
extern "C" char* fgets(char* dest, int size, FILE* fp)
{
if ( size <= 0 ) { errno = EINVAL; return NULL; }
int i;
for ( i = 0; i < size-1; i++ )
{
int c = getc(fp);
if ( c == EOF )
{
if ( ferror(fp) ) { return NULL; }
else { i++; break; } /* EOF */
}
dest[i] = c;
if ( c == '\n' ) { i++; break; }
}
dest[i] = '\0';
return dest;
}
/******************************************************************************
COPYRIGHT(C) JONAS 'SORTIE' TERMANSEN 2011.
This file is part of LibMaxsi.
LibMaxsi 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 3 of the License, or (at your option)
any later version.
LibMaxsi 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 LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
file.c
FILE* in libmaxsi is an interface to various implementations of the FILE*
API. This allows stuff like fmemopen, but also allows the application
programmers to provide their own backends.
******************************************************************************/
#include <sys/types.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
FILE* firstfile = NULL;
void fregister(FILE* fp)
{
fp->flags |= _FILE_REGISTERED;
if ( !firstfile ) { firstfile = fp; return; }
fp->next = firstfile;
firstfile->prev = fp;
firstfile = fp;
}
void funregister(FILE* fp)
{
if ( !(fp->flags & _FILE_REGISTERED) ) { return; }
if ( !fp->prev ) { firstfile = fp->next; }
if ( fp->prev ) { fp->prev->next = fp->next; }
if ( fp->next ) { fp->next->prev = fp->prev; }
fp->flags &= ~_FILE_REGISTERED;
}
size_t fread(void* ptr, size_t size, size_t nmemb, FILE* fp)
{
if ( fp->numpushedback && size != 1 ) { errno = ENOSYS; return 0; }
if ( fp->numpushedback && nmemb )
{
unsigned char* buf = (unsigned char*) ptr;
size_t amount = nmemb < fp->numpushedback ? nmemb : fp->numpushedback;
for ( size_t i = 0; i < amount; i++ )
{
buf[i] = fp->pushedback[--(fp->numpushedback)];
}
if ( nmemb <= amount ) { return nmemb; }
return amount + fread(buf + amount, size, nmemb - amount, fp);
}
if ( !fp->read_func ) { errno = EBADF; return 0; }
fp->flags &= ~_FILE_LAST_WRITE; fp->flags |= _FILE_LAST_READ;
return fp->read_func(ptr, size, nmemb, fp->user);
}
size_t fwrite(const void* ptr, size_t size, size_t nmemb, FILE* fp)
{
if ( !fp->write_func ) { errno = EBADF; return 0; }
fp->flags &= ~_FILE_LAST_READ; fp->flags |= _FILE_LAST_WRITE;
char* str = (char*) ptr;
size_t total = size * nmemb;
size_t sofar = 0;
while ( sofar < total )
{
size_t left = total - sofar;
if ( (!fp->bufferused && fp->buffersize <= left) || (fp->flags & _FILE_NO_BUFFER) )
{
return sofar + fp->write_func(str + sofar, 1, left, fp->user);
}
size_t available = fp->buffersize - fp->bufferused;
size_t count = ( left < available ) ? left : available;
count = left;
for ( size_t i = 0; i < count; i++ )
{
char c = str[sofar++];
fp->buffer[fp->bufferused++] = c;
if ( c == '\n' )
{
if ( fflush(fp) ) { return sofar; }
break;
}
}
if ( fp->buffersize <= fp->bufferused )
{
if ( fflush(fp) ) { return sofar; }
}
}
return sofar;
}
int fseeko(FILE* fp, off_t offset, int whence)
{
fp->numpushedback = 0;
return (fp->seek_func) ? fp->seek_func(fp->user, offset, whence) : 0;
}
int fseek(FILE* fp, long offset, int whence)
{
return fseeko(fp, offset, whence);
}
void fseterr(FILE* fp)
{
if ( fp->seterr_func ) { fp->seterr_func(fp->user); }
}
void clearerr(FILE* fp)
{
if ( fp->clearerr_func ) { fp->clearerr_func(fp->user); }
}
int ferror(FILE* fp)
{
if ( !fp->error_func ) { return 0; }
return fp->error_func(fp->user);
}
int feof(FILE* fp)
{
if ( fp->numpushedback ) { return 0; }
if ( !fp->eof_func ) { return 0; }
return fp->eof_func(fp->user);
}
void rewind(FILE* fp)
{
fseek(fp, 0L, SEEK_SET);
clearerr(fp);
}
off_t ftello(FILE* fp)
{
if ( !fp->tell_func ) { errno = EBADF; return -1; }
return fp->tell_func(fp->user) - fp->numpushedback;
}
long ftell(FILE* fp)
{
return (long) ftello(fp);
}
int ungetc(int c, FILE* fp)
{
if ( fp->numpushedback == _FILE_MAX_PUSHBACK ) { errno = ERANGE; return EOF; }
unsigned char uc = c;
fp->pushedback[fp->numpushedback++] = uc;
return uc;
}
int fflush(FILE* fp)
{
if ( !fp )
{
int result = 0;
for ( fp = firstfile; fp; fp = fp->next ) { result |= fflush(fp); }
return result;
}
if ( !fp->write_func ) { errno = EBADF; return EOF; }
if ( !fp->bufferused ) { return 0; }
size_t written = fp->write_func(fp->buffer, 1, fp->bufferused, fp->user);
if ( written < fp->bufferused ) { return EOF; }
fp->bufferused = 0;
return 0;
}
int fclose(FILE* fp)
{
int result = fflush(fp);
result |= (fp->close_func) ? fp->close_func(fp->user) : 0;
funregister(fp);
if ( fp->free_func ) { fp->free_func(fp); }
return result;
}
int fileno(FILE* fp)
{
int result = (fp->fileno_func) ? fp->fileno_func(fp->user) : -1;
if ( result < 0 ) { errno = EBADF; }
return result;
}
size_t fbufsize(FILE* fp)
{
return fp->buffersize;
}
int freading(FILE* fp)
{
if ( fp->read_func ) { return 1; }
if ( fp->flags & _FILE_LAST_READ ) { return 1; }
return 0;
}
int fwriting(FILE* fp)
{
if ( fp->write_func ) { return 1; }
if ( fp->flags & _FILE_LAST_WRITE ) { return 1; }
return 0;
}
int freadable(FILE* fp)
{
return fp->read_func != NULL;
}
int fwritable(FILE* fp)
{
return fp->write_func != NULL;
}
int flbf(FILE* fp)
{
return !(fp->flags & _FILE_NO_BUFFER);
}
void fpurge(FILE* fp)
{
fp->bufferused = 0;
}
size_t fpending(FILE* fp)
{
return fp->bufferused;
}
int fsetlocking(FILE* fp, int type)
{
switch ( type )
{
case FSETLOCKING_INTERNAL: fp->flags |= _FILE_AUTO_LOCK;
case FSETLOCKING_BYCALLER: fp->flags &= ~_FILE_AUTO_LOCK;
}
return (fp->flags & _FILE_AUTO_LOCK) ? FSETLOCKING_INTERNAL
: FSETLOCKING_BYCALLER;
}
static void ffreefile(FILE* fp)
{
free(fp->buffer);
free(fp);
}
FILE* fnewfile(void)
{
FILE* fp = (FILE*) calloc(sizeof(FILE), 1);
if ( !fp ) { return NULL; }
fp->buffersize = BUFSIZ;
fp->buffer = (char*) malloc(fp->buffersize);
if ( !fp->buffer ) { free(fp); return NULL; }
fp->flags = _FILE_AUTO_LOCK;
fp->free_func = ffreefile;
fregister(fp);
return fp;
}
int fcloseall(void)
{
int result = 0;
while ( firstfile ) { result |= fclose(firstfile); }
return (result) ? EOF : 0;
}
void flushlbf(void)
{
for ( FILE* fp = firstfile; fp; fp = fp->next )
{
fflush(fp);
}
}
int fgetc(FILE* fp)
{
unsigned char c;
if ( fread(&c, 1, sizeof(c), fp) < sizeof(c) ) { return EOF; }
return c;
}
int fputc(int cint, FILE* fp)
{
unsigned char c = (unsigned char) cint;
if ( fwrite(&c, 1, sizeof(c), fp) < sizeof(c) ) { return EOF; }
return c;
}
int getc(FILE* fp)
{
return fgetc(fp);
}
int putc(int c, FILE* fp)
{
return fputc(c, fp);
}
int fputs(const char* str, FILE* fp)
{
size_t stringlen = strlen(str);
int result = fwrite(str, 1, stringlen, fp);
if ( result < stringlen ) { return EOF; }
return result;
}
char* fgets(char* dest, int size, FILE* fp)
{
if ( size <= 0 ) { errno = EINVAL; return NULL; }
int i;
for ( i = 0; i < size-1; i++ )
{
int c = getc(fp);
if ( c == EOF )
{
if ( ferror(fp) ) { return NULL; }
else { i++; break; } /* EOF */
}
dest[i] = c;
if ( c == '\n' ) { i++; break; }
}
dest[i] = '\0';
return dest;
}
/*******************************************************************************
Copyright(C) Jonas 'Sortie' Termansen 2011, 2012.
This file is part of LibMaxsi.
LibMaxsi 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 3 of the License, or (at your option)
any later version.
LibMaxsi 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 LibMaxsi. If not, see <http://www.gnu.org/licenses/>.
fileno.cpp
Returns the underlying file descriptor of a FILE if applicable.