ref: 64061a0b01413a0aa8f7e19c34475b2d80182a88
dir: /src/utils/cst_file_palmos.c/
/*************************************************************************/
/* */
/* 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 <awb@cs.cmu.edu> */
/* 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 <PalmOS.h>
#include <StdIOPalm.h>
#include <System/FileStream.h>
#include <string.h>
#include <stdarg.h>
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;
}