Subversion Repositories svnkaklik

Rev

Rev 507 | Details | Compare with Previous | Last modification | View Log

Rev Author Line No. Line
507 kaklik 1 
/*! \file rprintf.c \brief printf routine and associated routines. */
2 
//*****************************************************************************
3 
//
4 
// File Name	: 'rprintf.c'
5 
// Title		: printf routine and associated routines
6 
// Author		: Pascal Stang - Copyright (C) 2000-2002
7 
// Created		: 2000.12.26
8 
// Revised		: 2003.5.1
9 
// Version		: 1.0
10 
// Target MCU	: Atmel AVR series and other targets
11 
// Editor Tabs	: 4
12 
//
13 
// NOTE: This code is currently below version 1.0, and therefore is considered
14 
// to be lacking in some functionality or documentation, or may not be fully
15 
// tested.  Nonetheless, you can expect most functions to work.
16 
//
17 
// This code is distributed under the GNU Public License
18 
//		which can be found at http://www.gnu.org/licenses/gpl.txt
19 
//
20 
//*****************************************************************************
21 
 
22 
#include <avr/pgmspace.h>
23 
//#include <string-avr.h>
24 
//#include <stdlib.h>
25 
#include <stdarg.h>
26 
#include "global.h"
27 
#include "rprintf.h"
28 
 
29 
#ifndef TRUE
30 
	#define TRUE	-1
31 
	#define FALSE	0
32 
#endif
33 
 
34 
#define INF     32766	// maximum field size to print
35 
#define READMEMBYTE(a,char_ptr)	((a)?(pgm_read_byte(char_ptr)):(*char_ptr))
36 
 
37 
#ifdef RPRINTF_COMPLEX
38 
	static unsigned char buf[128];
39 
#endif
40 
 
41 
// use this to store hex conversion in RAM
42 
//static char HexChars[] = "0123456789ABCDEF";
43 
// use this to store hex conversion in program memory
44 
//static prog_char HexChars[] = "0123456789ABCDEF";
45 
static char __attribute__ ((progmem)) HexChars[] = "0123456789ABCDEF";
46 
 
47 
#define hexchar(x)	pgm_read_byte( HexChars+((x)&0x0f) )
48 
//#define hexchar(x)	((((x)&0x0F)>9)?((x)+'A'-10):((x)+'0'))
49 
 
50 
// function pointer to single character output routine
51 
static void (*rputchar)(unsigned char c);
52 
 
53 
// *** rprintf initialization ***
54 
// you must call this function once and supply the character output
55 
// routine before using other functions in this library
56 
void rprintfInit(void (*putchar_func)(unsigned char c))
57 
{
58 
	rputchar = putchar_func;
59 
}
60 
 
61 
// *** rprintfChar ***
62 
// send a character/byte to the current output device
63 
void rprintfChar(unsigned char c)
64 
{
65 
	// do LF -> CR/LF translation
66 
	if(c == '\n')
67 
		rputchar('\r');
68 
	// send character
69 
	rputchar(c);
70 
}
71 
 
72 
// *** rprintfStr ***
73 
// prints a null-terminated string stored in RAM
74 
void rprintfStr(char str[])
75 
{
76 
	// send a string stored in RAM
77 
	// check to make sure we have a good pointer
78 
	if (!str) return;
79 
 
80 
	// print the string until a null-terminator
81 
	while (*str)
82 
		rprintfChar(*str++);
83 
}
84 
 
85 
// *** rprintfStrLen ***
86 
// prints a section of a string stored in RAM
87 
// begins printing at position indicated by <start>
88 
// prints number of characters indicated by <len>
89 
void rprintfStrLen(char str[], unsigned int start, unsigned int len)
90 
{
91 
	register int i=0;
92 
 
93 
	// check to make sure we have a good pointer
94 
	if (!str) return;
95 
	// spin through characters up to requested start
96 
	// keep going as long as there's no null
97 
	while((i++<start) && (*str++));
98 
//	for(i=0; i<start; i++)
99 
//	{
100 
//		// keep steping through string as long as there's no null
101 
//		if(*str) str++;
102 
//	}
103 
 
104 
	// then print exactly len characters
105 
	for(i=0; i<len; i++)
106 
	{
107 
		// print data out of the string as long as we haven't reached a null yet
108 
		// at the null, start printing spaces
109 
		if(*str)
110 
			rprintfChar(*str++);
111 
		else
112 
			rprintfChar(' ');
113 
	}
114 
 
115 
}
116 
 
117 
// *** rprintfProgStr ***
118 
// prints a null-terminated string stored in program ROM
119 
void rprintfProgStr(const prog_char str[])
120 
{
121 
	// print a string stored in program memory
122 
	register char c;
123 
 
124 
	// check to make sure we have a good pointer
125 
	if (!str) return;
126 
 
127 
	// print the string until the null-terminator
128 
	while((c = pgm_read_byte(str++)))
129 
		rprintfChar(c);
130 
}
131 
 
132 
// *** rprintfCRLF ***
133 
// prints carriage return and line feed
134 
void rprintfCRLF(void)
135 
{
136 
	// print CR/LF
137 
	//rprintfChar('\r');
138 
	// LF -> CR/LF translation built-in to rprintfChar()
139 
	rprintfChar('\n');
140 
}
141 
 
142 
// *** rprintfu04 ***
143 
// prints an unsigned 4-bit number in hex (1 digit)
144 
void rprintfu04(unsigned char data)
145 
{
146 
	// print 4-bit hex value
147 
//	char Character = data&0x0f;
148 
//	if (Character>9)
149 
//		Character+='A'-10;
150 
//	else
151 
//		Character+='0';
152 
	rprintfChar(hexchar(data));
153 
}
154 
 
155 
// *** rprintfu08 ***
156 
// prints an unsigned 8-bit number in hex (2 digits)
157 
void rprintfu08(unsigned char data)
158 
{
159 
	// print 8-bit hex value
160 
	rprintfu04(data>>4);
161 
	rprintfu04(data);
162 
}
163 
 
164 
// *** rprintfu16 ***
165 
// prints an unsigned 16-bit number in hex (4 digits)
166 
void rprintfu16(unsigned short data)
167 
{
168 
	// print 16-bit hex value
169 
	rprintfu08(data>>8);
170 
	rprintfu08(data);
171 
}
172 
 
173 
// *** rprintfu32 ***
174 
// prints an unsigned 32-bit number in hex (8 digits)
175 
void rprintfu32(unsigned long data)
176 
{
177 
	// print 32-bit hex value
178 
	rprintfu16(data>>16);
179 
	rprintfu16(data);
180 
}
181 
 
182 
// *** rprintfNum ***
183 
// special printf for numbers only
184 
// see formatting information below
185 
//	Print the number "n" in the given "base"
186 
//	using exactly "numDigits"
187 
//	print +/- if signed flag "isSigned" is TRUE
188 
//	use the character specified in "padchar" to pad extra characters
189 
//
190 
//	Examples:
191 
//	uartPrintfNum(10, 6,  TRUE, ' ',   1234);  -->  " +1234"
192 
//	uartPrintfNum(10, 6, FALSE, '0',   1234);  -->  "001234"
193 
//	uartPrintfNum(16, 6, FALSE, '.', 0x5AA5);  -->  "..5AA5"
194 
void rprintfNum(char base, char numDigits, char isSigned, char padchar, long n)
195 
{
196 
	// define a global HexChars or use line below
197 
	//static char HexChars[16] = "0123456789ABCDEF";
198 
	char *p, buf[32];
199 
	unsigned long x;
200 
	unsigned char count;
201 
 
202 
	// prepare negative number
203 
	if( isSigned && (n < 0) )
204 
	{
205 
		x = -n;
206 
	}
207 
	else
208 
	{
209 
	 	x = n;
210 
	}
211 
 
212 
	// setup little string buffer
213 
	count = (numDigits-1)-(isSigned?1:0);
214 
  	p = buf + sizeof (buf);
215 
  	*--p = '\0';
216 
 
217 
	// force calculation of first digit
218 
	// (to prevent zero from not printing at all!!!)
219 
	*--p = hexchar(x%base); x /= base;
220 
	// calculate remaining digits
221 
	while(count--)
222 
	{
223 
		if(x != 0)
224 
		{
225 
			// calculate next digit
226 
			*--p = hexchar(x%base); x /= base;
227 
		}
228 
		else
229 
		{
230 
			// no more digits left, pad out to desired length
231 
			*--p = padchar;
232 
		}
233 
	}
234 
 
235 
	// apply signed notation if requested
236 
	if( isSigned )
237 
	{
238 
		if(n < 0)
239 
		{
240 
   			*--p = '-';
241 
		}
242 
		else if(n > 0)
243 
		{
244 
	   		*--p = '+';
245 
		}
246 
		else
247 
		{
248 
	   		*--p = ' ';
249 
		}
250 
	}
251 
 
252 
	// print the string right-justified
253 
	count = numDigits;
254 
	while(count--)
255 
	{
256 
		rprintfChar(*p++);
257 
	}
258 
}
259 
 
260 
#ifdef RPRINTF_FLOAT
261 
// *** rprintfFloat ***
262 
// floating-point print
263 
void rprintfFloat(char numDigits, double x)
264 
{
265 
	unsigned char firstplace = FALSE;
266 
	unsigned char negative;
267 
	unsigned char i, digit;
268 
	double place = 1.0;
269 
 
270 
	// save sign
271 
	negative = (x<0);
272 
	// convert to absolute value
273 
	x = (x>0)?(x):(-x);
274 
 
275 
	// find starting digit place
276 
	for(i=0; i<15; i++)
277 
	{
278 
		if((x/place) < 10.0)
279 
			break;
280 
		else
281 
			place *= 10.0;
282 
	}
283 
	// print polarity character
284 
	if(negative)
285 
		rprintfChar('-');
286 
	else
287 
		rprintfChar('+');
288 
 
289 
	// print digits
290 
	for(i=0; i<numDigits; i++)
291 
	{
292 
		digit = (x/place);
293 
 
294 
		if(digit | firstplace | (place == 1.0))
295 
		{
296 
			firstplace = TRUE;
297 
			rprintfChar(digit+0x30);
298 
		}
299 
		else
300 
			rprintfChar(' ');
301 
 
302 
		if(place == 1.0)
303 
		{
304 
			rprintfChar('.');
305 
		}
306 
 
307 
		x -= (digit*place);
308 
		place /= 10.0;
309 
	}
310 
}
311 
#endif
312 
 
313 
#ifdef RPRINTF_SIMPLE
314 
// *** rprintf1RamRom ***
315 
// called by rprintf() - does a simple printf (supports %d, %x, %c)
316 
// Supports:
317 
// %d - decimal
318 
// %x - hex
319 
// %c - character
320 
int rprintf1RamRom(unsigned char stringInRom, const char *format, ...)
321 
{
322 
	// simple printf routine
323 
	// define a global HexChars or use line below
324 
	//static char HexChars[16] = "0123456789ABCDEF";
325 
	char format_flag;
326 
	unsigned int u_val, div_val, base;
327 
	va_list ap;
328 
 
329 
	va_start(ap, format);
330 
	for (;;)
331 
	{
332 
		while ((format_flag = READMEMBYTE(stringInRom,format++) ) != '%')
333 
		{	// Until '%' or '\0'
334 
			if (!format_flag)
335 
			{
336 
				va_end(ap);
337 
				return(0);
338 
			}
339 
			rprintfChar(format_flag);
340 
		}
341 
 
342 
		switch (format_flag = READMEMBYTE(stringInRom,format++) )
343 
		{
344 
			case 'c': format_flag = va_arg(ap,int);
345 
			default:  rprintfChar(format_flag); continue;
346 
			case 'd': base = 10; div_val = 10000; goto CONVERSION_LOOP;
347 
//			case 'x': base = 16; div_val = 0x10;
348 
			case 'x': base = 16; div_val = 0x1000;
349 
 
350 
			CONVERSION_LOOP:
351 
			u_val = va_arg(ap,int);
352 
			if (format_flag == 'd')
353 
			{
354 
				if (((int)u_val) < 0)
355 
				{
356 
					u_val = - u_val;
357 
					rprintfChar('-');
358 
				}
359 
				while (div_val > 1 && div_val > u_val) div_val /= 10;
360 
			}
361 
			do
362 
			{
363 
				//rprintfChar(pgm_read_byte(HexChars+(u_val/div_val)));
364 
				rprintfu04(u_val/div_val);
365 
				u_val %= div_val;
366 
				div_val /= base;
367 
			} while (div_val);
368 
		}
369 
	}
370 
	va_end(ap);
371 
}
372 
#endif
373 
 
374 
 
375 
#ifdef RPRINTF_COMPLEX
376 
// *** rprintf2RamRom ***
377 
// called by rprintf() - does a more powerful printf (supports %d, %u, %o, %x, %c, %s)
378 
// Supports:
379 
// %d - decimal
380 
// %u - unsigned decimal
381 
// %o - octal
382 
// %x - hex
383 
// %c - character
384 
// %s - strings
385 
// and the width,precision,padding modifiers
386 
// **this printf does not support floating point numbers
387 
int rprintf2RamRom(unsigned char stringInRom, const char *sfmt, ...)
388 
{
389 
	register unsigned char *f, *bp;
390 
	register long l;
391 
	register unsigned long u;
392 
	register int i;
393 
	register int fmt;
394 
	register unsigned char pad = ' ';
395 
	int flush_left = 0, f_width = 0, prec = INF, hash = 0, do_long = 0;
396 
	int sign = 0;
397 
 
398 
	va_list ap;
399 
	va_start(ap, sfmt);
400 
 
401 
	f = (unsigned char *) sfmt;
402 
 
403 
	for (; READMEMBYTE(stringInRom,f); f++)
404 
	{
405 
		if (READMEMBYTE(stringInRom,f) != '%')
406 
		{	// not a format character
407 
			// then just output the char
408 
			rprintfChar(READMEMBYTE(stringInRom,f));
409 
		}
410 
		else
411 
		{
412 
			f++;						// if we have a "%" then skip it
413 
			if (READMEMBYTE(stringInRom,f) == '-')
414 
			{
415 
				flush_left = 1;	// minus: flush left
416 
				f++;
417 
			}
418 
            if (READMEMBYTE(stringInRom,f) == '0'
419 
				 || READMEMBYTE(stringInRom,f) == '.')
420 
				{
421 
					// padding with 0 rather than blank
422 
					pad = '0';
423 
					f++;
424 
            }
425 
            if (READMEMBYTE(stringInRom,f) == '*')
426 
				{	// field width
427 
					f_width = va_arg(ap, int);
428 
					f++;
429 
            }
430 
            else if (Isdigit(READMEMBYTE(stringInRom,f)))
431 
				{
432 
					f_width = atoiRamRom(stringInRom, (char *) f);
433 
					while (Isdigit(READMEMBYTE(stringInRom,f)))
434 
						f++;        // skip the digits
435 
            }
436 
            if (READMEMBYTE(stringInRom,f) == '.')
437 
				{	// precision
438 
					f++;
439 
					if (READMEMBYTE(stringInRom,f) == '*')
440 
					{
441 
						prec = va_arg(ap, int);
442 
						f++;
443 
					}
444 
					else if (Isdigit(READMEMBYTE(stringInRom,f)))
445 
					{
446 
						prec = atoiRamRom(stringInRom, (char *) f);
447 
						while (Isdigit(READMEMBYTE(stringInRom,f)))
448 
							f++;    // skip the digits
449 
					}
450 
				}
451 
            if (READMEMBYTE(stringInRom,f) == '#')
452 
				{	// alternate form
453 
					hash = 1;
454 
					f++;
455 
            }
456 
            if (READMEMBYTE(stringInRom,f) == 'l')
457 
				{	// long format
458 
					do_long = 1;
459 
					f++;
460 
            }
461 
 
462 
				fmt = READMEMBYTE(stringInRom,f);
463 
				bp = buf;
464 
				switch (fmt) {		// do the formatting
465 
				case 'd':			// 'd' signed decimal
466 
					if (do_long)
467 
						l = va_arg(ap, long);
468 
					else
469 
						l = (long) (va_arg(ap, int));
470 
					if (l < 0)
471 
					{
472 
						sign = 1;
473 
						l = -l;
474 
					}
475 
					do	{
476 
						*bp++ = l % 10 + '0';
477 
					} while ((l /= 10) > 0);
478 
					if (sign)
479 
						*bp++ = '-';
480 
					f_width = f_width - (bp - buf);
481 
					if (!flush_left)
482 
						while (f_width-- > 0)
483 
							rprintfChar(pad);
484 
					for (bp--; bp >= buf; bp--)
485 
						rprintfChar(*bp);
486 
					if (flush_left)
487 
						while (f_width-- > 0)
488 
							rprintfChar(' ');
489 
					break;
490 
            case 'o':			// 'o' octal number
491 
            case 'x':			// 'x' hex number
492 
            case 'u':			// 'u' unsigned decimal
493 
					if (do_long)
494 
						u = va_arg(ap, unsigned long);
495 
					else
496 
						u = (unsigned long) (va_arg(ap, unsigned));
497 
					if (fmt == 'u')
498 
					{	// unsigned decimal
499 
						do {
500 
							*bp++ = u % 10 + '0';
501 
						} while ((u /= 10) > 0);
502 
					}
503 
					else if (fmt == 'o')
504 
					{  // octal
505 
						do {
506 
							*bp++ = u % 8 + '0';
507 
						} while ((u /= 8) > 0);
508 
						if (hash)
509 
							*bp++ = '0';
510 
					}
511 
					else if (fmt == 'x')
512 
					{	// hex
513 
						do {
514 
							i = u % 16;
515 
							if (i < 10)
516 
								*bp++ = i + '0';
517 
							else
518 
								*bp++ = i - 10 + 'a';
519 
						} while ((u /= 16) > 0);
520 
						if (hash)
521 
						{
522 
							*bp++ = 'x';
523 
							*bp++ = '0';
524 
						}
525 
					}
526 
					i = f_width - (bp - buf);
527 
					if (!flush_left)
528 
						while (i-- > 0)
529 
							rprintfChar(pad);
530 
					for (bp--; bp >= buf; bp--)
531 
						rprintfChar((int) (*bp));
532 
					if (flush_left)
533 
						while (i-- > 0)
534 
							rprintfChar(' ');
535 
					break;
536 
            case 'c':			// 'c' character
537 
					i = va_arg(ap, int);
538 
					rprintfChar((int) (i));
539 
					break;
540 
            case 's':			// 's' string
541 
					bp = va_arg(ap, unsigned char *);
542 
					if (!bp)
543 
						bp = (unsigned char *) "(nil)";
544 
					f_width = f_width - strlen((char *) bp);
545 
					if (!flush_left)
546 
						while (f_width-- > 0)
547 
							rprintfChar(pad);
548 
					for (i = 0; *bp && i < prec; i++)
549 
					{
550 
						rprintfChar(*bp);
551 
						bp++;
552 
					}
553 
					if (flush_left)
554 
						while (f_width-- > 0)
555 
							rprintfChar(' ');
556 
					break;
557 
            case '%':			// '%' character
558 
					rprintfChar('%');
559 
					break;
560 
			}
561 
			flush_left = 0, f_width = 0, prec = INF, hash = 0, do_long = 0;
562 
			sign = 0;
563 
			pad = ' ';
564 
		}
565 
	}
566 
 
567 
	va_end(ap);
568 
	return 0;
569 
}
570 
 
571 
unsigned char Isdigit(char c)
572 
{
573 
	if((c >= 0x30) && (c <= 0x39))
574 
		return TRUE;
575 
	else
576 
		return FALSE;
577 
}
578 
 
579 
int atoiRamRom(unsigned char stringInRom, char *str)
580 
{
581 
	int num = 0;;
582 
 
583 
	while(Isdigit(READMEMBYTE(stringInRom,str)))
584 
	{
585 
		num *= 10;
586 
		num += ((READMEMBYTE(stringInRom,str++)) - 0x30);
587 
	}
588 
	return num;
589 
}
590 
 
591 
#endif
592 
 
593 
//******************************************************************************
594 
// code below this line is commented out and can be ignored
595 
//******************************************************************************
596 
/*
597 
char* sprintf(const char *sfmt, ...)
598 
{
599 
	register unsigned char *f, *bp, *str;
600 
	register long l;
601 
	register unsigned long u;
602 
	register int i;
603 
	register int fmt;
604 
	register unsigned char pad = ' ';
605 
	int     flush_left = 0, f_width = 0, prec = INF, hash = 0, do_long = 0;
606 
	int     sign = 0;
607 
 
608 
	va_list ap;
609 
	va_start(ap, sfmt);
610 
 
611 
	str = bufstring;
612 
	f = (unsigned char *) sfmt;
613 
 
614 
	for (; *f; f++)
615 
	{
616 
		if (*f != '%')
617 
		{								// not a format character
618 
			*str++ = (*f);			// then just output the char
619 
		}
620 
		else
621 
		{
622 
			f++;						// if we have a "%" then skip it
623 
			if (*f == '-')
624 
			{
625 
				flush_left = 1;	// minus: flush left
626 
				f++;
627 
			}
628 
            if (*f == '0' || *f == '.')
629 
				{
630 
					// padding with 0 rather than blank
631 
					pad = '0';
632 
					f++;
633 
            }
634 
            if (*f == '*')
635 
				{	// field width
636 
					f_width = va_arg(ap, int);
637 
					f++;
638 
            }
639 
            else if (Isdigit(*f))
640 
				{
641 
					f_width = atoi((char *) f);
642 
					while (Isdigit(*f))
643 
						f++;        // skip the digits
644 
            }
645 
            if (*f == '.')
646 
				{	// precision
647 
					f++;
648 
					if (*f == '*')
649 
					{
650 
						prec = va_arg(ap, int);
651 
						f++;
652 
					}
653 
					else if (Isdigit(*f))
654 
					{
655 
						prec = atoi((char *) f);
656 
						while (Isdigit(*f))
657 
							f++;    // skip the digits
658 
					}
659 
				}
660 
            if (*f == '#')
661 
				{	// alternate form
662 
					hash = 1;
663 
					f++;
664 
            }
665 
            if (*f == 'l')
666 
				{	// long format
667 
					do_long = 1;
668 
					f++;
669 
            }
670 
 
671 
				fmt = *f;
672 
				bp = buf;
673 
				switch (fmt) {		// do the formatting
674 
				case 'd':			// 'd' signed decimal
675 
					if (do_long)
676 
						l = va_arg(ap, long);
677 
					else
678 
						l = (long) (va_arg(ap, int));
679 
					if (l < 0)
680 
					{
681 
						sign = 1;
682 
						l = -l;
683 
					}
684 
					do	{
685 
						*bp++ = l % 10 + '0';
686 
					} while ((l /= 10) > 0);
687 
					if (sign)
688 
						*bp++ = '-';
689 
					f_width = f_width - (bp - buf);
690 
					if (!flush_left)
691 
						while (f_width-- > 0)
692 
							*str++ = (pad);
693 
					for (bp--; bp >= buf; bp--)
694 
						*str++ = (*bp);
695 
					if (flush_left)
696 
						while (f_width-- > 0)
697 
							*str++ = (' ');
698 
					break;
699 
            case 'o':			// 'o' octal number
700 
            case 'x':			// 'x' hex number
701 
            case 'u':			// 'u' unsigned decimal
702 
					if (do_long)
703 
						u = va_arg(ap, unsigned long);
704 
					else
705 
						u = (unsigned long) (va_arg(ap, unsigned));
706 
					if (fmt == 'u')
707 
					{	// unsigned decimal
708 
						do {
709 
							*bp++ = u % 10 + '0';
710 
						} while ((u /= 10) > 0);
711 
					}
712 
					else if (fmt == 'o')
713 
					{  // octal
714 
						do {
715 
							*bp++ = u % 8 + '0';
716 
						} while ((u /= 8) > 0);
717 
						if (hash)
718 
							*bp++ = '0';
719 
					}
720 
					else if (fmt == 'x')
721 
					{	// hex
722 
						do {
723 
							i = u % 16;
724 
							if (i < 10)
725 
								*bp++ = i + '0';
726 
							else
727 
								*bp++ = i - 10 + 'a';
728 
						} while ((u /= 16) > 0);
729 
						if (hash)
730 
						{
731 
							*bp++ = 'x';
732 
							*bp++ = '0';
733 
						}
734 
					}
735 
					i = f_width - (bp - buf);
736 
					if (!flush_left)
737 
						while (i-- > 0)
738 
							*str++ = (pad);
739 
					for (bp--; bp >= buf; bp--)
740 
						*str++ = ((int) (*bp));
741 
					if (flush_left)
742 
						while (i-- > 0)
743 
							*str++ = (' ');
744 
					break;
745 
            case 'c':			// 'c' character
746 
					i = va_arg(ap, int);
747 
					*str++ = ((int) (i));
748 
					break;
749 
            case 's':			// 's' string
750 
					bp = va_arg(ap, unsigned char *);
751 
					if (!bp)
752 
						bp = (unsigned char *) "(nil)";
753 
					f_width = f_width - strlen((char *) bp);
754 
					if (!flush_left)
755 
						while (f_width-- > 0)
756 
							*str++ = (pad);
757 
					for (i = 0; *bp && i < prec; i++)
758 
					{
759 
						*str++ = (*bp);
760 
						bp++;
761 
					}
762 
					if (flush_left)
763 
						while (f_width-- > 0)
764 
							*str++ = (' ');
765 
					break;
766 
            case '%':			// '%' character
767 
					*str++ = ('%');
768 
					break;
769 
			}
770 
			flush_left = 0, f_width = 0, prec = INF, hash = 0, do_long = 0;
771 
			sign = 0;
772 
			pad = ' ';
773 
		}
774 
	}
775 
 
776 
	va_end(ap);
777 
	// terminate string with null
778 
	*str++ = '\0';
779 
	return bufstring;
780 
}
781 
 
782 
*/