Revamped [...]printf functions, may fix a bug with insane engine since %o was not supported, added more [...]printf functions. Now can easly be used with other projects

svn-id: r13867

2 files changed, 310 insertions, 105 deletions

diff --git a/backends/PalmOS/Src/missing/_stdio.cpp b/backends/PalmOS/Src/missing/_stdio.cpp
index 71fbbe0da9..6939448c78 100644
--- a/backends/PalmOS/Src/missing/_stdio.cpp
+++ b/backends/PalmOS/Src/missing/_stdio.cpp
@@ -21,35 +21,32 @@
  */
 
 #include "stdio.h"
-#include "extend.h"
 
-static void DrawStatus(Boolean show) {
-	if (OPTIONS_TST(kOptDisableOnScrDisp))
-		return;
+FileRef	gStdioOutput = 0;
 
-	UInt8 x,y;
-	UInt8 *screen = (UInt8 *)(BmpGetBits(WinGetBitmap(WinGetDisplayWindow())));
-	UInt8 color = (show? gVars->indicator.on : gVars->indicator.off);
+static LedProc	gStdioLedProc = NULL;
+static UInt16	gStdioVolRefNum = sysInvalidRefNum;
 
-	if (gVars->screenLocked)
-		screen = (screen == gVars->flipping.pageAddr1) ? gVars->flipping.pageAddr2 : gVars->flipping.pageAddr1;
+static void dummy(Boolean){};
 
-	screen += gVars->screenPitch + 1;
-	for(y=0; y < 4; y++) {
-		for(x=0; x < 4; x++)
-			screen[x] = color;
+void StdioInit(UInt16 volRefNum, const Char *output, LedProc ledProc) {
+	gStdioVolRefNum = volRefNum;
+	
+	if (ledProc)
+		gStdioLedProc = ledProc;
+	else
+		gStdioLedProc = dummy;
+		
 
-		screen += gVars->screenPitch;
-	}
+	VFSFileDelete(gStdioVolRefNum, output);
+	VFSFileCreate(gStdioVolRefNum, output);
+	VFSFileOpen  (gStdioVolRefNum, output,vfsModeWrite, &gStdioOutput);
 }
 
-///////////////////////////////////////////////////////////////////////////////
-//FileRef gLogFile;
+void StdioRelease() {
+	VFSFileClose(gStdioOutput);
+}
 
-// WARNING :	printf functions must only be used if you compile your code with
-// 				4byte int option, use standard functions if 2byte int mode
-// TODO : enable use of 2byte or 4byte (ifdef PRINTF_4BYTE ...)
-///////////////////////////////////////////////////////////////////////////////
 UInt16 fclose(FileRef *stream) {
 	Err error = VFSFileClose(*stream);
 	
@@ -61,7 +58,7 @@ UInt16 fclose(FileRef *stream) {
 #endif
 	return error;
 }
-///////////////////////////////////////////////////////////////////////////////
+
 UInt16 feof(FileRef *stream) {
 	Err error = VFSFileEOF(*stream);
 
@@ -88,12 +85,12 @@ UInt16 feof(FileRef *stream) {
 
 	return error;
 }
-///////////////////////////////////////////////////////////////////////////////
+
 Char *fgets(Char *s, UInt32 n, FileRef *stream) {
 	UInt32 numBytesRead;
-	DrawStatus(true);
+	gStdioLedProc(true);
 	Err error = VFSFileRead(*stream, n, s, &numBytesRead);
-	DrawStatus(false);
+	gStdioLedProc(false);
 	if (error == errNone || error == vfsErrFileEOF) {
 		UInt32 reset = 0;
 		Char *endLine = StrChr(s, '\n');
@@ -133,7 +130,7 @@ Char *fgets(Char *s, UInt32 n, FileRef *stream) {
 
 	return NULL;
 }
-///////////////////////////////////////////////////////////////////////////////
+
 FileRef *fopen(const Char *filename, const Char *type) {
 	Err err;
 	UInt16 openMode;
@@ -153,7 +150,7 @@ FileRef *fopen(const Char *filename, const Char *type) {
 	if (openMode & vfsModeRead) {
 		// if read file :
 		// first try to load from the specfied card
-		err = VFSFileOpen (gVars->volRefNum, filename, openMode, fileRefP);
+		err = VFSFileOpen (gStdioVolRefNum, filename, openMode, fileRefP);
 		//if err (not found ?) parse each avalaible card for the specified file
 		if (err) {
 			UInt16 volRefNum;
@@ -173,11 +170,11 @@ FileRef *fopen(const Char *filename, const Char *type) {
 	} else {
 		// if write file :
 		// use only the specified card
-		err = VFSFileDelete(gVars->volRefNum, filename);	// delete it if exists
-		err = VFSFileCreate(gVars->volRefNum, filename);
+		err = VFSFileDelete(gStdioVolRefNum, filename);	// delete it if exists
+		err = VFSFileCreate(gStdioVolRefNum, filename);
 		openMode = vfsModeWrite;
 		if (!err) {
-			err = VFSFileOpen (gVars->volRefNum, filename, openMode, fileRefP);
+			err = VFSFileOpen (gStdioVolRefNum, filename, openMode, fileRefP);
 			if (!err)
 				return fileRefP;
 		}
@@ -216,12 +213,12 @@ FileRef *fopen(const Char *filename, const Char *type) {
 	MemPtrFree(fileRefP); // prevent memory leak
 	return NULL;
 }
-///////////////////////////////////////////////////////////////////////////////
+
 UInt32 fread(void *ptr, UInt32 size, UInt32 nitems, FileRef *stream) {
 	UInt32 numBytesRead;
-	DrawStatus(true);
+	gStdioLedProc(true);
 	Err error = VFSFileRead(*stream, size*nitems, ptr, &numBytesRead);
-	DrawStatus(false);
+	gStdioLedProc(false);
 	if (error == errNone || error == vfsErrFileEOF)
 		return (UInt32)(numBytesRead/size);
 
@@ -250,24 +247,24 @@ UInt32 fread(void *ptr, UInt32 size, UInt32 nitems, FileRef *stream) {
 #endif
 	return 0;
 }
-///////////////////////////////////////////////////////////////////////////////
+
 UInt32 fwrite(const void *ptr, UInt32 size, UInt32 nitems, FileRef *stream) {
 	UInt32 numBytesWritten;
-	DrawStatus(true);
+	gStdioLedProc(true);
 	Err error = VFSFileWrite(*stream, size*nitems, ptr, &numBytesWritten);
-	DrawStatus(false);
+	gStdioLedProc(false);
 
 	if (error == errNone || error == vfsErrFileEOF)
 		return (UInt32)(numBytesWritten/size);
 
 	return NULL;
 }
-///////////////////////////////////////////////////////////////////////////////
+
 Int32 fseek(FileRef *stream, Int32 offset, Int32 whence) {
 	Err error = VFSFileSeek(*stream, whence, offset);
 	return error;
 }
-///////////////////////////////////////////////////////////////////////////////
+
 UInt32 ftell(FileRef *stream) {
 	Err e;
 	UInt32 filePos;
@@ -278,8 +275,8 @@ UInt32 ftell(FileRef *stream) {
 	
 	return filePos;
 }
-///////////////////////////////////////////////////////////////////////////////
-UInt16 fprintf(FileRef *stream, const Char *format, ...) {
+
+Int32 fprintf(FileRef *stream, const Char *formatStr, ...) {
 	if (!*stream)
 		return 0;
 
@@ -287,15 +284,15 @@ UInt16 fprintf(FileRef *stream, const Char *format, ...) {
 	Char buf[256];
 	va_list va;
 
-	va_start(va, format);
-	vsprintf(buf, format, va);
+	va_start(va, formatStr);
+	vsprintf(buf, formatStr, va);
 	va_end(va);
 
 	VFSFileWrite (*stream, StrLen(buf), buf, &numBytesWritten);
 	return numBytesWritten;
 }
-///////////////////////////////////////////////////////////////////////////////
-Int16 printf(const Char *format, ...) {
+
+Int32 printf(const Char *format, ...) {
 	if (!*stdout)
 		return 0;
 
@@ -310,63 +307,261 @@ Int16 printf(const Char *format, ...) {
 	VFSFileWrite (*stdout, StrLen(buf), buf, &numBytesWritten);
 	return numBytesWritten;
 }
-///////////////////////////////////////////////////////////////////////////////
-Int16 sprintf(Char* s, const Char* formatStr, ...) {
-	Char buf[256];
+
+Int32 sprintf(Char* s, const Char* formatStr, ...) {
 	Int16 count;
 	va_list va;
 
 	va_start(va, formatStr);
-	count = vsprintf(buf, formatStr, va);
+	count = vsprintf(s, formatStr, va);
 	va_end(va);
 	
-	StrCopy(s,buf);
 	return count;
 }
-///////////////////////////////////////////////////////////////////////////////
-static void StrProcessCModifier(Char *ioStr, UInt16 maxLen) {
+
+Int32 snprintf(Char* s, UInt32 len, const Char* formatStr, ...) {
+	// len is ignored
+	Int16 count;
+	va_list va;
+
+	va_start(va, formatStr);
+	count = vsprintf(s, formatStr, va);
+	va_end(va);
+	
+	return count;
+}
+
+
+/* WARNING : vsprintf
+ * -------
+ * This function can handle only %[+- ][.0][field length][sxXdoiucp] format strings
+ * compiler option : 4byte int mode only !
+ *
+ * TODO : check http://www.ijs.si/software/snprintf/ for a potable implementation of vsnprintf
+ * This one make use of sprintf so need to check if it works with PalmOS.
+ */
+
+static Char *StrIToBase(Char *s, Int32 i, UInt8 b) {
+	const Char *conv = "0123456789ABCDEF";
+	Char o;
+	Int16 c, n = 0;
+	Int32 div, mod;
+	
+	do {
+		div = i / b;
+		mod = i % b;
+		
+		s[n++]	= *(conv + mod);
+		i		= div;
+
+	} while (i >= b);
+
+	if (i > 0) {
+		s[n + 0] = *(conv + i);
+		s[n + 1] = 0;
+	} else {
+		s[n + 0] = 0;
+		n--;
+	}
+
+	for (c=0; c <= (n >> 1); c++) {
+		o		= s[c];
+		s[c]	= s[n - c];
+		s[n - c]= o;
+	}
+
+	return s;
+}
+
+static void StrProcC_(Char *ioStr, UInt16 maxLen) {
 	Char *found;
-	UInt16 length;
+	Int16 length;
 	
-	while (found = StrChr(ioStr, '`')) {
-		if (found[1] == 0) { // if next char is NULL
-			length = maxLen - (found - ioStr);
-			MemMove(found, found + 2, length);
+	while (found = StrStr(ioStr, "`c`")) {
+		if (found[3] == 0) { 						// if next char is NULL
+			length = maxLen - (found - ioStr + 2);
+			MemMove(found, found + 4, length);
 			maxLen -= 2;
 		}
 	}
 }
 
-Int16 vsprintf(Char* s, const Char* formatStr, _Palm_va_list argParam) {
-	Char format[256];
-	Int16 retval;
-	// TODO : need a better modifier
-	StrCopy(format,formatStr);
-	StrReplace(format, 256, "%ld",	"%d");
-	StrReplace(format, 256, "%li",	"%i");
-	StrReplace(format, 256, "%lx",	"%x");
-	StrReplace(format, 256, "%lx",	"%X");
-	StrReplace(format, 256, "%2ld",	"%2d");
-	StrReplace(format, 256, "%03ld","%.3d");
-	StrReplace(format, 256, "%02ld","%.2d");
-	StrReplace(format, 256, "%01ld","%.1d");
-	StrReplace(format, 256, "%02ld","%02d");
-	StrReplace(format, 256, "%02lx","%02x");
-
-	StrReplace(format, 256, "%2ld","%2d");
-	StrReplace(format, 256, "%3ld","%3d");
-	StrReplace(format, 256, "%4ld","%4d");
-	StrReplace(format, 256, "%5ld","%5d");
-	StrReplace(format, 256, "%6ld","%6d");
-	StrReplace(format, 256, "%02lx","%02x");
-	StrReplace(format, 256, "`%c%c","%c");
-
-	retval = StrVPrintF(s, format, argParam);	// wrong value may be return due to %c%c
-	StrProcessCModifier(s, 256);
+static void StrProcXO(Char *ioStr, UInt16 maxLen, Char *tmp) {
+	Char *found, *last, mod, fill;
+	Int16 len, count, next;
+	Int32 val;
+		
+	while (found = StrChr(ioStr, '`')) {
+		last = StrChr(found + 1, '`');
+		
+		if (!last)
+			return;
+
+		*last	= 0;
+		next 	= 0;
+		fill	= *(found + 1);
+		mod		= *(found + 2);
+		count	= StrAToI(found + 3);
+
+		len = maxLen - (last - ioStr);
+		MemMove(found, (last + 1), len);
+
+		// x and X always 8char on palmos ... o set to 8char (not supported on palmos)
+		while (found[next] == '0' || found[next] == ' ')	// WARNING : reduce size only (TODO ?)
+			next++;
+		
+		// convert to base 8
+		if (mod == 'o') {
+			StrNCopy(tmp, found + next, 8 - next);
+			tmp[8 - next]	= 0;
+			val				= StrAToI(tmp);
+			StrIToBase(tmp, val, 8);				// now we have the same but in octal
+			next			= 8 - StrLen(tmp);
+			MemMove(found + next, tmp, StrLen(tmp));
+		} else {
+			// if val is 0, keep last 0
+			if (next == 8)
+				next = 7;
+		}
+
+		if ((8 - next) > count)
+			count = 8 - next;
+			
+		if (count == 0)
+			count = 1;
+
+		len = maxLen - (found - ioStr) - (8 - count);
+		MemSet(found, next, fill);
+		MemMove(found, found + (8 - count), len);
+
+		//  ... and upper case
+		if (mod == 'x') {
+			while (count--) {
+				if (*found >='A' && *found <='F')
+					*found = (*found + 32);
+				found++;
+			}
+		}
+	}
+}
+
+Int32 vsprintf(Char* s, const Char* formatStr, _Palm_va_list argParam) {
+	Char format[256], result[256], tmp[32];
+	
+	Char *found, *mod, *num;
+	UInt32 next;
+	Boolean zero;
+	Int16 count, len;
+	
+	MemSet(format, sizeof(format), 'x');
+	MemSet(result, sizeof(result), 'y');
+	MemSet(tmp, sizeof(tmp), 'z');
+
+	StrCopy(format,formatStr);	// copy actual formatStr to temp buffer
+	next = 0;					// start of the string
+
+	while (found = StrChr(format + next, '%')) {
+		mod = found + 1;
+		
+		if (*mod == '%') {			// just a % ?
+			mod++;
+
+		} else {
+			if (*mod == '+' ||
+				*mod == '-' ||
+				*mod == ' '	)		// skip
+				mod++;
+			
+			if (*mod == '0' ||
+				*mod == '.' ) {
+				*mod++ = '0';
+				zero =  true;
+			} else {
+				zero = false;
+			}
+			
+			num = mod;
+			while (	*mod >= '0' &&
+					*mod <= '9'	)	// search format char
+				mod++;
+			
+			// get the numeric value
+			if (num < mod) {
+				StrNCopy(tmp, num, mod - num);
+				tmp[mod - num] = 0;
+				count = StrAToI(tmp);
+			} else {
+				count = 0;
+			}
+
+			if (*mod == 'l')		// already set to %...l(x) ?
+				mod++;
+
+			// prepare new format
+			if (*mod == 'c') {
+				StrCopy(tmp, "`c`%c%c");
+
+			} else if (*mod == 'p') {
+				StrCopy(tmp, "%08lX");			// %x = %08X in palmos
+
+			} else {
+				len = 0;
+	
+				switch (*mod) {
+					case 'x':
+					case 'X':
+					case 'o':
+						tmp[0] = '`';
+						tmp[1] = (zero) ? '0' : ' ';
+						tmp[2] = *mod;	
+						StrIToA(tmp + 3, count);
+						len += StrLen(tmp);
+						tmp[len++] = '`';
+						tmp[len] = 0;
+						
+						if (*mod == 'o') {	// set as base 10 num and convert later
+							*mod = 'd';
+							count = 8;		// force 8char
+						}
+
+						break;
+				}
+					
+				StrNCopy(tmp + len, found, (num - found));
+				len += (num - found);
+
+				if (count) {
+					StrIToA(tmp + len, count);
+					len += StrLen(tmp + len);
+				}
+				
+				if (*mod == 'd' ||
+					*mod == 'i' ||
+					*mod == 'x' ||
+					*mod == 'X' ||
+					*mod == 'u' 
+					) {
+					tmp[len++] = 'l';
+				}
+
+				tmp[len + 0] = *mod;
+				tmp[len + 1] = 0;
+			}
+
+			mod++;
+			MemMove(found + StrLen(tmp), mod, StrLen(mod) + 1);
+			StrNCopy(found, tmp, StrLen(tmp));
+			mod = found + StrLen(tmp);
+		}
+		
+		next = (mod - format);
+	}
+	
+	// Copy result in a temp buffer to process last formats
+	StrVPrintF(result, format, argParam);
+	StrProcC_(result, 256);
+	StrProcXO(result, 256, tmp);
+	StrCopy(s, result);
 	
-	return retval;
+	return StrLen(s);
 }
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
-///////////////////////////////////////////////////////////////////////////////
diff --git a/backends/PalmOS/Src/missing/stdio.h b/backends/PalmOS/Src/missing/stdio.h
index 756e0f8946..393229c165 100644
--- a/backends/PalmOS/Src/missing/stdio.h
+++ b/backends/PalmOS/Src/missing/stdio.h
@@ -20,38 +20,48 @@
  *
  */
 
+#ifndef __STDIO_H__
+#define __STDIO_H__
+
 #include <PalmOS.h>
 #include <VFSMgr.h>
 #include <stdarg.h>
-#include "globals.h"
 
-//extern UInt16	gVolRefNum;
-//extern FileRef	gLogFile;
+typedef void (*LedProc)(Boolean show);
+
+extern FileRef	gStdioOutput;
 
 typedef FileRef FILE;
+typedef UInt32 size_t;
 
 #define stdin		0
-#define stdout		(&gVars->logFile)
-#define stderr		(&gVars->logFile)
+#define stdout		(&gStdioOutput)
+#define stderr		(&gStdioOutput)
 
 #define clearerr(a)
 #define fflush(a)
 #define vsnprintf(a,b,c,d)	vsprintf(a,c,d)
-#define snprintf(a,b,c,d)	sprintf(a,c,d)
 
 #define	SEEK_SET			vfsOriginBeginning 
 #define	SEEK_CUR			vfsOriginCurrent  
 #define	SEEK_END			vfsOriginEnd
 
-UInt16 fclose(FileRef *stream);
-UInt16 feof(FileRef *stream);
-Char *fgets(Char *s, UInt32 n, FileRef *stream);
-FileRef *fopen(const Char *filename, const Char *type);
-UInt32 fread(void *ptr, UInt32 size, UInt32 nitems, FileRef *stream);
-UInt32 fwrite(const void *ptr, UInt32 size, UInt32 nitems, FileRef *stream);
-Int32 fseek(FileRef *stream, Int32 offset, Int32 whence);
-UInt32 ftell(FileRef *stream);
-UInt16 fprintf(FileRef *stream, const Char *format, ...);
-Int16 printf(const Char* formatStr, ...);
-Int16 sprintf(Char* s, const Char* formatStr, ...);
-Int16 vsprintf(Char* s, const Char* formatStr, _Palm_va_list argParam);
+UInt16		fclose	(FileRef *stream);
+UInt16		feof	(FileRef *stream);
+Char *		fgets	(Char *s, UInt32 n, FileRef *stream);
+FileRef *	fopen	(const Char *filename, const Char *type);
+UInt32		fread	(void *ptr, UInt32 size, UInt32 nitems, FileRef *stream);
+UInt32		fwrite	(const void *ptr, UInt32 size, UInt32 nitems, FileRef *stream);
+Int32		fseek	(FileRef *stream, Int32 offset, Int32 whence);
+UInt32		ftell	(FileRef *stream);
+
+Int32	fprintf	(FileRef *stream, const Char *formatStr, ...);
+Int32	printf	(const Char* formatStr, ...);
+Int32	sprintf	(Char* s, const Char* formatStr, ...);
+Int32	snprintf(Char* s, UInt32 len, const Char* formatStr, ...);
+Int32	vsprintf(Char* s, const Char* formatStr, _Palm_va_list argParam);
+
+void	StdioInit	(UInt16 volRefNum, const Char *output, LedProc ledProc);
+void	StdioRelease();
+
+#endif
\ No newline at end of file