pm12c.c

《自己动手写操作系统》一书的光盘配套代码

				Radix=8;
/* load the value to be printed. 32 bits: */
DO_NUM:				if(Flags & VPR_32)
					Num=va_arg(Args, unsigned long);
/* 16 bits (signed or unsigned) */
				else if(Flags & VPR_16)
				{	if(Flags & VPR_SG)
						Num=va_arg(Args, short);
					else Num=va_arg(Args, unsigned short); }
/* sizeof(int) bits (signed or unsigned) */
				else
				{	if(Flags & VPR_SG)
						Num=va_arg(Args, int);
					else Num=va_arg(Args, unsigned int); }
/* take care of sign */
				if(Flags & VPR_SG)
				{	if((long)Num < 0)
					{	Flags |= VPR_WS;
						Num=-Num; }}
/* convert binary to octal/decimal/hex ASCII */
				do
				{	Temp=Num % Radix;
					if(Temp < 10) *--Where=Temp + '0';
					else if(Flags & VPR_CA)
						*--Where=Temp - 10 + 'A';
					else *--Where=Temp - 10 + 'a';
					Num /= Radix; }
				while(Num);
/* sign, again */
				if(Flags & VPR_WS) *--Where='-';
				goto EMIT;
			case 'c':
				*--Where=(char)va_arg(Args, char);
				ActualWd=1;
				goto EMIT2;
			case 's':
				Where=va_arg(Args, char *);
EMIT:				ActualWd=strlen(Where);
/* pad on left with spaces (for right justify) */
EMIT2:				if((Flags & VPR_LJ) == 0)
				{	for(; GivenWd > ActualWd; GivenWd--)
					{	Fn(Ptr++, ' ');
						Count++; }}
/* emit string/char/converted number from Buf */
				while(*Where)
				{	Fn(Ptr++, *Where++);
					Count++; }
/* pad on right with spaces (for left justify) */
				if(GivenWd < ActualWd) GivenWd=0;
				else GivenWd -= ActualWd;
				for(; GivenWd; GivenWd--)
				{	Fn(Ptr++, ' ');
					Count++; }	/* FALL THROUGH */
			default:	/* FALL THROUGH */
				break; }
		default:
			State=Flags=GivenWd=0;
			break; }}
	return(Count); }
/*****************************************************************************
	name:	putchar
	action:	write Char to stdout (console only, for now)
	returns:Char
*****************************************************************************/
int putchar(int Char)
{	asm("mov 8(%esp),%eax");
	asm("int $0x30"); }
/*****************************************************************************
	name:	printf
*****************************************************************************/
int printfOut(char *Str, char Char)
{	return(putchar(Char)); }

int printf(const char *Fmt, ...)
{	va_list Args;
	int RetVal;

	va_start(Args, Fmt);
	RetVal=myPrintf(printfOut, NULL, Fmt, Args);
	va_end(Args);
	return(RetVal); }
/*////////////////////////////////////////////////////////////////////////////
	conio.h
////////////////////////////////////////////////////////////////////////////*/
#define		LINEAR_SEL	8

#define		ATTRIB		0x7100
#define		FAKE_SPACE	0xFFu
#define		SCN_HT		25
#define		SCN_WD		80

extern char CsrX;
extern char CsrY;
/*****************************************************************************
	name:	scroll
	action:	scrolls display up, down, left, or right as needed
*****************************************************************************/
void scroll(void)
{	unsigned Count;
	unsigned short Blank;

	Blank=' ' | ATTRIB;
/* scroll up */
	if(CsrY >= SCN_HT)
	{	Count=CsrY - SCN_HT + 1;
		farmemmove(LINEAR_SEL, 0xB8000ul,
			LINEAR_SEL, 0xB8000ul + Count * SCN_WD * 2,
			(SCN_HT - Count) * SCN_WD * 2);
		farmemsetw(LINEAR_SEL,
			0xB8000ul + (SCN_HT - Count) * SCN_WD * 2,
			Blank, SCN_WD);
		CsrY=SCN_HT - 1; }
/* scroll down XXX - CsrY is unsigned */
	else if(CsrY < 0)
	{	Count=-CsrY;
		farmemmove(LINEAR_SEL, 0xB8000ul,
			LINEAR_SEL, 0xB8000ul + Count * SCN_WD,
			SCN_WD * (SCN_HT - Count));
		farmemsetw(LINEAR_SEL, 0xB8000ul, Blank, Count * SCN_WD); }
/* scroll right */
//	if(CsrX >= 80)
}//        {
/* XXX - no left/right scroll? */
/*****************************************************************************
	name:	putch
*****************************************************************************/
int putch(int Char)
{	unsigned long Where;
	unsigned short Temp;

	Where=(CsrY * SCN_WD + CsrX) * 2 + 0xB8000ul;
/* backspace (destructive cursor left) */
	if(Char == 0x08)
	{	Temp=ATTRIB | FAKE_SPACE;
		if(CsrX == 0 && CsrY == 0) return(EOF);
		do	/* skip tab, cr, or lf blanks */
		{	Where -= 2;
			if(CsrX) CsrX--;
			else
			{	CsrX=SCN_WD - 1;
				CsrY--; }}
		while(peekw(LINEAR_SEL, Where) == Temp);
		pokew(LINEAR_SEL, Where, Temp); }
/* tab (destructive) */
	else if(Char == 0x09)
	{	Temp=7 - (CsrX & 7);
		goto CON_CR; }
/* carriage return (non-destructive) */
	else if(Char == '\r')	/* 0x0D */
		CsrX=0;
/* CR/LF (destructive) */
	else if(Char == '\n')	/* 0x0A */
	{	Temp=SCN_WD - CsrX - 1;
CON_CR:		putch(' ');	/* recursion */
		for(; Temp; Temp--) putch(FAKE_SPACE);
		return(Char); }
/* line feed (destructive cursor down) */
	else if(Char == '\n')	/* XXX - 0x0A again */
	{	Temp=SCN_WD - 1;
		goto CON_CR; }
/* printable ASCII */
	else if(Char >= ' ')
	{	pokew(LINEAR_SEL, Where, Char | ATTRIB);
		CsrX++;
		if(CsrX >= SCN_WD)
		{	CsrX=0;
			CsrY++;
			scroll(); }}
	Temp=CsrY * SCN_WD + CsrX;
	disable();		/* XXX - save flags, then disable */
	outb(0x3D4, 14);
	outb(0x3D5, Temp >> 8);
	outb(0x3D4, 15);
	outb(0x3D5, Temp);
	enable();		/* XXX - restore flags */
	return(Char); }
/*////////////////////////////////////////////////////////////////////////////
	main
////////////////////////////////////////////////////////////////////////////*/
char *Msg[]={
	"zero divide", "debug exception", "NMI", "INT3",
	"INTO", "BOUND exception", "invalid opcode", "no coprocessor",
	"double fault", "coprocessor segment overrun",
		"bad TSS", "segment not present",
	"stack fault", "GPF", "page fault", "coprocessor error",
	"??", "alignment check", "??", "??",
	"??", "??", "??", "??",
	"??", "??", "??", "??",
	"??", "??", "??", "??",
	"timer tick", "keyboard", "IRQ 2", "IRQ 3",
	"IRQ 4", "IRQ 5", "floppy", "IRQ 7",
	"real-time clock", "IRQ 9", "IRQ 10", "IRQ 11",
	"IRQ 12", "math chip", "primary IDE", "secondary IDE" };
/*****************************************************************************
	name:	unhand
*****************************************************************************/
void unhand(unsigned WhichInt, unsigned Off, unsigned Sel)
{	printf("\nException #%u (%s) at address 0x%X:0x%lX\n"
		"System halted.\n", WhichInt, (WhichInt < 48 ?
		Msg[WhichInt] : "??"), Sel, Off);
	while(1); }
/*****************************************************************************
	name:	unhand2
*****************************************************************************/
void unhand2(unsigned WhichInt, unsigned ErrorCode, unsigned Off, unsigned Sel)
{	register long PageFaultAdr;

	printf("\nException #%u (%s) at address 0x%X:0x%X (error code "
		"0x%X)\n", WhichInt, (WhichInt < 48
		? Msg[WhichInt] : "??"), Sel, Off, ErrorCode);
	if(WhichInt == 14)
	{	asm("mov %%cr2, %0" : "=r"(PageFaultAdr));
		printf("Page fault address: 0x%X\n", PageFaultAdr); }
	printf("System halted.");
	while(1); }
/*****************************************************************************
	name:	taskA

	This code runs in Ring 3.
*****************************************************************************/
void taskA(void)
{	long Pause;

	while(1)
	{	printf("Hello from task A. ");
		for(Pause=0xFFFFF; Pause; Pause--); }}
/*****************************************************************************
	name:	taskB

	This code runs in Ring 3.
*****************************************************************************/
void taskB(void)
{	long Pause;

	while(1)
	{	printf("Greetings from task B. ");
		for(Pause=0xFFFFF; Pause; Pause--);
/* die */
//		asm("int $0x18");
		}}