/*************************************************************************/ /* */ /* Language Technologies Institute */ /* Carnegie Mellon University */ /* Copyright (c) 2001 */ /* All Rights Reserved. */ /* */ /* Permission is hereby granted, free of charge, to use and distribute */ /* this software and its documentation without restriction, including */ /* without limitation the rights to use, copy, modify, merge, publish, */ /* distribute, sublicense, and/or sell copies of this work, and to */ /* permit persons to whom this work is furnished to do so, subject to */ /* the following conditions: */ /* 1. The code must retain the above copyright notice, this list of */ /* conditions and the following disclaimer. */ /* 2. Any modifications must be clearly marked as such. */ /* 3. Original authors' names are not deleted. */ /* 4. The authors' names are not used to endorse or promote products */ /* derived from this software without specific prior written */ /* permission. */ /* */ /* CARNEGIE MELLON UNIVERSITY AND THE CONTRIBUTORS TO THIS WORK */ /* DISCLAIM ALL WARRANTIES WITH REGARD TO THIS SOFTWARE, INCLUDING */ /* ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS, IN NO EVENT */ /* SHALL CARNEGIE MELLON UNIVERSITY NOR THE CONTRIBUTORS BE LIABLE */ /* FOR ANY SPECIAL, INDIRECT OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES */ /* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN */ /* AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, */ /* ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF */ /* THIS SOFTWARE. */ /* */ /*************************************************************************/ /* Author: Alan W Black */ /* Date: July 2004 */ /*************************************************************************/ /* */ /* File I/O wrappers for PalmOS platforms. */ /* */ /* flop/armflite currently (Jan 05) only uses cst_sprintf */ /* */ /*************************************************************************/ #include "cst_file.h" #include "cst_error.h" #include "cst_alloc.h" #define _STDIO_PALM_C_ #include #include #include #include #include cst_file cst_fopen(const char *path, int mode) { /* This is kind of hacky. */ if ((mode & CST_OPEN_WRITE) && (mode & CST_OPEN_READ)) return FileOpen(0, path, 0, 0, fileModeReadWrite, NULL); else if ((mode & CST_OPEN_APPEND) && (mode & CST_OPEN_READ)) return FileOpen(0, path, 0, 0, fileModeAppend | fileModeReadWrite, NULL); else if (mode & CST_OPEN_WRITE) return FileOpen(0, path, 0, 0, fileModeReadWrite, NULL); else if (mode & CST_OPEN_APPEND) return FileOpen(0, path, 0, 0, fileModeAppend, NULL); else if (mode & CST_OPEN_READ) return FileOpen(0, path, 0, 0, fileModeReadOnly, NULL); else return FileOpen(0, path, 0, 0, fileModeReadOnly, NULL); } long cst_fwrite(cst_file fh, const void *buf, long size, long count) { return FileWrite(fh, buf, size, count, NULL); } long cst_fread(cst_file fh, void *buf, long size, long count) { return FileRead(fh,buf,size,count,NULL); } long cst_filesize(cst_file fh) { long epos=0; FileTell(fh,&epos,NULL); return epos; } int cst_fgetc(cst_file fh) { return fgetc(fh); } long cst_ftell(cst_file fh) { return FileTell(fh,NULL,NULL); } long cst_fseek(cst_file fh, long pos, int whence) { FileOriginEnum w = fileOriginBeginning; if (whence == CST_SEEK_ABSOLUTE) w = fileOriginBeginning; else if (whence == CST_SEEK_RELATIVE) w = fileOriginCurrent; else if (whence == CST_SEEK_ENDREL) w = fileOriginEnd; return FileSeek(fh, pos, w); } int cst_fclose(cst_file fh) { return FileClose(fh); } static int po_itoa(char *s, int i, const char* modifier) { /* print ascii representation of i to s with any modifier (e.g. "03") */ char n[20]; /* numbers cannot be bigger than 20 places */ int ni, si; int q; /* modifier currently ignored */ /* construct the ascii backwards */ if (i == 0) { n[0] = '0'; ni=1; } else for (ni=0,q=(i < 0 ? -i : i); q > 0; q/=10,ni++) n[ni] = q%10 + '0'; if (i < 0) { n[ni] = '-'; ni++; } /* pop it off and onto the string */ for (si=0; ni>0; si++,ni--) s[si] = n[ni-1]; return si; } static int po_ftoa(char *s, float f, const char* modifier) { char n[20]; /* numbers cannot be bigger than 30 places */ char p[20]; int ni, si, pi; int q,i,d; float pp; /* modifier currently ignored */ /* construct the ascii backwards */ if (f == 0.0) { n[0] = '0'; n[1] = '.'; n[2] = '0'; ni=3; p[0] = '\0'; } else { /* above zero part */ i = (f < 0 ? (int)-f : (int)f); for (ni=0,q=i; q > 0; q/=10,ni++) n[ni] = q%10 + '0'; /* point */ p[0] = '.'; /* below zero part */ pp = (f < 0 ? -f : f) - (float)i; if (pp == 0) { p[1] = '0'; pi = 2; } else for (pi=1,pp*=10.0; (pp > 0) && (pi < 4); pp*=10.0,pi++) { d = (int)pp; p[pi] = d + '0'; pp -= d; } p[pi] = '\0'; } /* sign */ if (f < 0) { n[ni] = '-'; ni++; } /* pop it off and onto the string */ for (si=0; ni>0; si++,ni--) s[si] = n[ni-1]; for (pi=0; p[pi]; si++,pi++) s[si] = p[pi]; return si; } int cst_vsprintf(char *s, const char *fmt, va_list args) { /* A simple sprintf that caters for what flite uses */ int sp=0,fp=0; char *sa; char ca; int ia; float fa; for (sp=0,fp=0; fmt[fp]; fp++) { if (fmt[fp] == '%') { if (fmt[fp+1] == '%') { s[sp] = '%'; sp++; fp++; } else if (fmt[fp+1] == 's') { sa = va_arg(args, char *); memmove(s+sp,sa,cst_strlen(sa)); sp+=cst_strlen(sa); fp++; } else if (fmt[fp+1] == '.') { if (fmt[fp+2] == '*') { /* When the length is specified on the stack */ ia = va_arg(args, int); sa = va_arg(args, char *); memmove(s+sp,sa,ia); sp+=ia; fp+=3; } else { /* When the length is specified in the format */ fp+=2; /* skip over the field width */ while ((strchr("0123456789",fmt[fp]) != 0) && fmt[fp]) fp++; sa = va_arg(args, char *); memmove(s+sp,sa,cst_strlen(sa)); sp+=cst_strlen(sa); } } else if (fmt[fp+1] == 'c') { ca = (unsigned char)va_arg(args, unsigned int); s[sp] = ca; sp++; fp++; } else if (fmt[fp+1] == 'd') { ia = va_arg(args, int); sp += po_itoa(s+sp,ia,""); fp++; } else if (fmt[fp+1] == 'f') { fa = (float)va_arg(args, double); sp += po_ftoa(s+sp,fa,""); fp++; } } else { s[sp] = fmt[fp]; sp++; } } va_end(args); s[sp] = '\0'; return sp; } int cst_fprintf(cst_file fh, char *fmt, ...) { va_list args; char outbuf[512]; int count; va_start(args,fmt); count = cst_vsprintf(outbuf,fmt,args); va_end(args); return cst_fwrite(fh,outbuf,1,count); } int cst_sprintf(char *s, const char *fmt, ...) { va_list args; int count; va_start(args,fmt); count = cst_vsprintf(s,fmt,args); va_end(args); return count; }