vxd_clib.c

wince host 和 target PCI驱动程序

		case 'b': /* EXTENSION: binary conversion */
			base = 2;
			chSign = '\0';
			goto L_read_number;
		case 'U': /* EXTENSION: unsigned long decimal conversion */
			flags |= FLAG_LONGINT;
			/* FALLTHROUGH */
		case 'u': /* unsigned decimal conversion */
			base = 10;
			chSign = '\0';
			goto L_read_number;
		case 'D': /* EXTENSION: long decimal conversion */
			flags |= FLAG_LONGINT;
			/* FALLTHROUGH */
		case 'd': /* decimal conversion */
		case 'i':
			flags |= FLAG_SIGNED;
			base = 10;
			/* FALLTHROUGH */
		L_read_number:
			/* read number */
			if (flags & FLAG_LONGINT) {
				if (flags & FLAG_SIGNED) {
					long lValue = va_arg(ap, long);
					if (lValue < 0) {
						ulValue = (unsigned long)(-lValue);
						chSign = '-';
					} else {
						ulValue = (unsigned long)lValue;
					}
				} else {
					ulValue = va_arg(ap, unsigned long);
				}
			} else {
				if (flags & FLAG_SIGNED) {
					int iValue = va_arg(ap, int);
					if (iValue < 0) {
						ulValue = (unsigned long)(-iValue);
						chSign = '-';
					} else {
						ulValue = (unsigned long)iValue;
					}
				} else {
					ulValue = (unsigned long)va_arg(ap, unsigned int);
				}
			}
			if ((base == 16)&&(flags & FLAG_ALTFORM)&&(ulValue != 0)) {
				flags |= FLAG_HEXPREFIX;
			}
			/*FALLTHROUGH*/
		L_number:
			/* don't zero pad if precision is specified */
			if (precision >= 0) flags &= ~FLAG_ZEROPAD;

			lpch = &chBufTemp[CONV_SIZE];
			if ((ulValue != 0) || (precision != 0)) {
				do {
					*--lpch = mchDigit[ulValue % base];
					ulValue /= base;
				} while (ulValue != 0);
				if ((flags & FLAG_ALTFORM)&&(base == 8)&&(*lpch != '0')) {
					*--lpch = '0';
				}
			}
#ifdef NEARFAR_POINTERS
			size = (int)((char _far *)(&chBufTemp[CONV_SIZE]) - lpch);
#else
			size = (int)(&chBufTemp[CONV_SIZE] - lpch);
#endif /* NEARFAR_POINTERS */
			break;
		}

		/* process conversion */
		{
			int     n;                      /* integer for loop counts */
			int     real_size = size;       /* actual size of conversion for alignment */
			char    *pzStart = pzOutBuf; /* save start position of conversion */

			/* adjust precision to equal size for strings */
			if (flags & FLAG_STRING) precision = size;
			else if (precision > real_size) real_size = precision;

			/* adjust real_size for prefix */
			if (chSign != '\0') ++real_size;
			if (flags & FLAG_HEXPREFIX) real_size += 2;

			/* put in blank padding for right adjust before prefixes */
			if ((flags & (FLAG_LEFTADJ|FLAG_ZEROPAD)) == 0) {
				for (n = real_size; n < min_width; ++n) *pzOutBuf++ = ' ';
			}

            /* put in conversion prefix(es) */
			if (chSign != '\0') *pzOutBuf++ = chSign;
			if (flags & FLAG_HEXPREFIX) {
				*pzOutBuf++ = '0';
				*pzOutBuf++ = ch;
			}

            /* put in zero padding for right adjust after prefixes*/
			if ((flags & (FLAG_LEFTADJ|FLAG_ZEROPAD)) == FLAG_ZEROPAD) {
				for (n = real_size; n < min_width; ++n) *pzOutBuf++ = '0';
			}

			/* put in leading zeroes to fill precision for numbers */
			for (n = size; n < precision; ++n) *pzOutBuf++ = '0';

			/* put in the conversion text */
			for (n = 0; n < size; ++n) *pzOutBuf++ = *lpch++;

			/* put in blank padding for left adjust */
			if (flags & FLAG_LEFTADJ) {
				for (n = real_size; n < min_width; ++n) *pzOutBuf++ = ' ';
			}

			/* compute number of characters in conversion */
			nChars += (int)(pzOutBuf - pzStart);
		}
	}
	/* NOTREACHED */
}

int VXD_sprintf(char *pzOutBuf, const char *pzFmt, ...)
{
	int		nChars;
	va_list ap;

	va_start(ap, pzFmt);
	nChars = VXD_vsprintf(pzOutBuf, pzFmt, ap);
	va_end(ap);
	return (nChars);
}

#include <basedef.h>
#include <vmm.h>

#define HASH_LINE_SIZE  128
#define NUM_HASH_LINES  16      /* must be a power of 2 */
#define HASH_LINE_MASK  (NUM_HASH_LINES-1)
/* WARNING: the largest printf is 3*HASH_LINE_SIZE-1 characters */

int VXD_printf(const char *pzFmt, ...)
{
	int		nChars;
	int		i;
	char    *psz;
	va_list ap;
	static unsigned int uIndex = 0;
	static char chBuffer[(NUM_HASH_LINES+2)*HASH_LINE_SIZE];

#ifndef ENABLE_PRINTF
	return(0);
#endif
    /* Hash the index number to a location in the buffer that changes with */
    /* every call to VXD_printf().  The hash function was chosen so that a */
    /* mixture of long and short lines can queued without over-writing the */
    /* buffer used by previous calls.  The function now pseudo re-entrant. */
    i = (int)(++uIndex);
    i = (3 * (i & HASH_LINE_MASK)) % HASH_LINE_MASK;

    psz = &chBuffer[i * HASH_LINE_SIZE]; /* save pointer to buffer location */
	va_start(ap, pzFmt);
	nChars = VXD_vsprintf(psz, pzFmt, ap);
	va_end(ap);

#ifdef FORCE_ALT_SCREEN
	{
		extern void ALT_puts(char *string);
		ALT_puts(psz);
	}
#else
	Out_Debug_String(psz);
#endif

	return (nChars);
}

void ALT_puts(char *string)
{
	static unsigned char *pAltScr = 0;
	static int pos = 0;
	static int next_pos_attrib = 1;
	int i;
	int check;
	
#ifndef ENABLE_ALT_SCREEN
	return;
#endif
#define POS_LSB		(24*80*2)
#define POS_MSB		(24*80*2+1)
#define ATTRIB_LSB	(24*80*2+2)
#define ATTRIB_MSB	(24*80*2+3)
#define CHECK_POS	(24*80*2+4)

	if (pAltScr == 0)  {
		pAltScr = (unsigned char *)_MapPhysToLinear(
			0xb0000, 0x1000, 0);

		check = pAltScr[POS_LSB] ^ pAltScr[POS_MSB] ^
				pAltScr[ATTRIB_LSB] ^ pAltScr[ATTRIB_MSB] ^ 
				pAltScr[CHECK_POS] ^ 0xA5;

		if (check == 0) {
			/* try to load a saved version pos and next_pos_attrib */
			pos = pAltScr[POS_LSB] + 256 * pAltScr[POS_MSB];
			next_pos_attrib = pAltScr[ATTRIB_LSB] + 256 * pAltScr[ATTRIB_MSB];
			if ((pos > (24*80*2)) || (next_pos_attrib > (24*80*2)) ||
					((pos+1) != next_pos_attrib)) {
				check = 1;
			}
		} 
		if (check != 0) {
			/* clear screen */
			i = 0;
			do {
				pAltScr[i++] = ' '; /* character */
				pAltScr[i++] = 0x7; /* attribute */		
			} while (i<(24*80*2));
			pos = 0;
			next_pos_attrib = 1;
		}
		VXD_printf("ALT_puts: [phys] B0000 -> [linear] %X\n",pAltScr);
	}
	if ((pAltScr != 0) && (pAltScr != (unsigned char *)0xFFFFFFFF)) {
		/* attribute  b7->blink, b654->RGB background */
		/* attribute  b3->intensity, b210->RGB foreground (001->underline) */
		/* reset last pos to normal */
		pAltScr[next_pos_attrib] = 0x7; 
		while (*string != '\0') {
			if (*string == '\n') {
				while ((pos%160) != 0) {
					pAltScr[pos++] = ' '; /* character */
					pAltScr[pos++] = 0x7; /* attribute */
				}
			} else if (*string >= ' ') {
				pAltScr[pos++] = *string; /* character */
				pAltScr[pos++] = 0x7; /* attribute */
			}
			next_pos_attrib = pos+1;
			if (pos >= 24*160) {
				pos = 0;
				next_pos_attrib = pos+1;
			}
			string++;
		}
		pAltScr[next_pos_attrib] = 0xF0; /* set next pos to blinking */

		/* save variables in screen memory */
		pAltScr[POS_LSB] = pos;
		pAltScr[POS_MSB] = pos>>8;		
		pAltScr[ATTRIB_LSB] = next_pos_attrib;
		pAltScr[ATTRIB_MSB] = next_pos_attrib>>8;
		pAltScr[CHECK_POS] = pAltScr[POS_LSB] ^ pAltScr[POS_MSB] ^
				pAltScr[ATTRIB_LSB] ^ pAltScr[ATTRIB_MSB] ^ 0xA5;
	}
	return;
}

int ALT_printf(const char *pzFmt, ...)
{
	int		nChars;
	char    psz[1024];
	va_list ap;

#ifndef ENABLE_ALT_SCREEN
	return(0);
#endif
#ifndef ENABLE_PRINTF
	return(0);
#endif
	va_start(ap, pzFmt);
	nChars = VXD_vsprintf(psz, pzFmt, ap);
	va_end(ap);
	ALT_puts(psz);
	return (nChars);
}