OSDev.org

Code: Select all

void Printf(char *fmt,...)
{
	va_list args;
	char number[10];
	int num;
	char buf;
	int buffer;
	int buffer2;
	
	va_start(args,fmt);

	while(*fmt!=NULL)
	{
		if(*fmt=='%')
		{
			fmt++;
			switch(*fmt)
			{
				case 'i':
				case 'd':
				case 'u':
				itoa(va_arg(args,int),number);
				Put(number);
				break;

				case 'c':
				putchar((unsigned char)va_arg(args,int));
				break;

				case 'x':
				buffer=va_arg(args,int);
				buffer2=buffer;
				buffer=buffer<<28;
				buffer=buffer>>28;
				putchar(return_hex(buffer));

				buffer=buffer2;
				buffer=buffer<<24;
				buffer=buffer>>28;
				putchar(return_hex(buffer));

				buffer=buffer2;
				buffer=buffer<<20;
				buffer=buffer>>24;
				putchar(return_hex(buffer));

				buffer=buffer2;
				buffer=buffer<<16;
				buffer=buffer>>20;
				putchar(return_hex(buffer));

				buffer=buffer2;
				buffer=buffer<<12;
				buffer=buffer>>16;
				putchar(return_hex(buffer));

				buffer=buffer2;
				buffer=buffer<<8;
				buffer=buffer>>12;
				putchar(return_hex(buffer));

				buffer=buffer2;
				buffer=buffer<<4;
				buffer=buffer>>8;
				putchar(return_hex(buffer));

				buffer=buffer2;
				buffer=buffer|0x0F;
				putchar(return_hex(buffer));
				break;

				case 's':
				Put(va_arg(args,char*));
				break;	
				
				default:
				putchar(*fmt);
				break;
			}
			fmt++;
		}
		else
		{
			putchar(*fmt);
			fmt++;
		}
	}
	va_end(args);
}

Code: Select all

char return_hex(unsigned short num)
{
	switch(num)
	{
		case 0x00:
		return '0';
		break;

		case 0x01:
		return '1';
		break;

		case 0x02:
		return '2';
		break;

		case 0x03:
		return '3';
		break;

		case 0x04:
		return '4';
		break;

		case 0x05:
		return '5';
		break;

		case 0x06:
		return '6';
		break;

		case 0x07:
		return '7';
		break;

		case 0x08:
		return '8';
		break;

		case 0x09:
		return '9';
		break;

		case 0x0A:
		return 'A';
		break;

		case 0x0B:
		return 'B';
		break;

		case 0x0C:
		return 'C';
		break;

		case 0x0D:
		return 'D';
		break;

		case 0x0E:
		return 'E';
		break;

		case 0x0F:
		return 'F';
		break;

		default:
		break;
	}
}

Code: Select all

void _main(struct MULTIBOOT *mbd,unsigned int magic)
{
	char *code;
	int c=0xAF;

	clrscr(BLACK,BLACK);
	set_color(WHITE,BLACK);
	set_echo(1);

	if((mbd->flags&0x08)==0x08)
	{
		Printf("Modules were loaded succesfully\n");
		Printf("Number of modules loaded: %d\n",mbd->mods_count);
		code=(char*)mbd->mods_addr;
		
		
	}
	else
	{
		Printf("Modules were not succesfully loaded\n");
	}

	idt_install();
	gdt_install();

	Printf("Welcome to PyroS\n");
	Printf("c is 0x%x",c);
	for(;;);
}

Code: Select all

char* int_to_string(int num, int base) {
	char* buffer = allocation_function_or_maybe_static_buffer_i_dont_know();
	int idx = 0;
	while (num != 0) {
		int digit = num % base;
		char c = (digit <= 9) ? '0'+digit : 'A'+digit-9;
		buffer[idx++] = c;
		num /= base;
	}
	magical_buffer_reversing_function(buffer);
	return buffer;
}

Code: Select all

char tbuf[32];
char bchars[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};

void itoa_s(int i,u8 base,char* buf) {
	if (base > 16) return;
	if (i < 0) {
		*buf++ = '-';
		i *= -1;
	}
	itoa((u64)i,base,buf);
}

void itoa(u64 i,u8 base,char* buf) {
	int pos = 0;
	int opos = 0;
	int top = 0;

	if (i == 0 || base > 16) {
		buf[0] = '0';
		buf[1] = '\0';
		return;
	}

	while (i != 0) {
		tbuf[pos] = bchars[i % base];
		pos++;
		i /= base;
	}
	top=pos--;
	for (opos=0; opos<top; pos--,opos++) {
		buf[opos] = tbuf[pos];
	}
	buf[opos] = 0;
}

Code: Select all

; ——————————————————————————————————————————————————
  __WriteQWORDAsHexExact:
    ; void __WriteQWORDAsHexExact (DWORD HighDWORD, DWORD LowDWORD); StdCall;
    PUSH    EAX
    PUSH    EBX
    PUSH    ECX
    PUSH    EDX
    PUSH    ESI
    PUSH    EDI
    PUSH    EBP
    MOV     EBP , ESP
    ; [EBP + 0x20] = HighDWORD 
    ; [EBP + 0x24] = LowDWORD
    
    INVOKE  __WriteChar , '0'
    INVOKE  __WriteChar , 'x'
    MOV     ESI , DWORD PTR [EBP + 0x24]
    MOV     EDI , DWORD PTR [EBP + 0x20]
    ; EDI:ESI holds the 64-bit QWORD value
    MOV     ECX , 8*2
    
    .Loop:
      MOV     EAX , EDI
      SHR     EAX , 28
      SHL     EDI , 0x00000004
      MOV     EBX , ESI
      SHL     ESI , 0x00000004
      SHR     EBX , 28
      OR      EDI , EBX
      ; EAX contains the hex digit to be printed
      CMP     EAX , 0x0000000A
      JB      .ItIsaDigit
      .ItIsaLetter:
        ADD     EAX , 0x00000007
      .ItIsaDigit:
        ADD     EAX , 0x00000030
      .PrintTheCharacter:
        INVOKE  __WriteChar , EAX
      
      DEC     ECX
      JNZ     .Loop

    .EP:
      POP     EBP
      POP     EDI
      POP     ESI
      POP     EDX
      POP     ECX
      POP     EBX
      POP     EAX
    RET     0x08
    
   
; ——————————————————————————————————————————————————

Code: Select all

; ——————————————————————————————————————————————————
  __WriteDWORDAsHex:
    ; void __WriteDWORDAsHex (DWORD InDWORD); StdCall;
    PUSH    EAX
    PUSH    ECX
    PUSH    EDX
    PUSH    EBP
    MOV     EBP , ESP
    MOV     EAX , DWORD PTR [EBP + 0x14]
    INVOKE  __WriteChar, '0'
    INVOKE  __WriteChar, 'x'
    MOV     ECX , 0x08
    .Loop:
      ROL     EAX , 0x04
      MOV     EDX , EAX
      AND     EDX , 0x0000000F
      OR      EDX , 0x00000030
      CMP     EDX , 0x0000003A
      JB      .Rest
      ADD     EDX , 0x00000007
      .Rest:
        INVOKE  __WriteChar, EDX
        DEC     ECX
        JNZ     .Loop
    POP     EBP
    POP     EDX
    POP     ECX
    POP     EAX
    RET     0x04
; ——————————————————————————————————————————————————

Code: Select all

//
// writeHex -- Outputs the given signed 32-bit integer to the monitor
//             as a hexidecimal number, prefixed with "0x", with the
//             foreground/background colours specified.
//
void MonitorDriver::writeHex(s32int n, Colour foreColour, Colour backColour)
{

  s32int tmp;

  write("0x", foreColour, backColour);

  bool noZeroes = true;

  int i;
  for (i = 28; i > 0; i -= 4)
  {
    tmp = (n >> i) & 0xF;
    if (tmp == 0 && noZeroes)
    {
      continue;
    }
    
    if (tmp >= 0xA)
    {
      noZeroes = false;
      put (tmp-0xA+'a', foreColour, backColour);
    }
    else
    {
      noZeroes = false;
      put( tmp+'0', foreColour, backColour);
    }
  }
  
  tmp = n & 0xF;
  if (tmp >= 0xA)
  {
    put (tmp-0xA+'a', foreColour, backColour);
  }
  else
  {
    put( tmp+'0', foreColour, backColour);
  }
  
}

Code: Select all

	case 'x':
	buffer=va_arg(args,int);
	buffer2=buffer;
	buffer=buffer<<28;
	buffer=buffer>>28;
	putchar(return_hex(buffer));

Code: Select all

	buffer=buffer2;
	buffer=buffer<<24;
	buffer=buffer>>28;
	putchar(return_hex(buffer));

Code: Select all

	buffer=buffer2;
	buffer=buffer<<20;
	buffer=buffer>>24;
	putchar(return_hex(buffer));

Code: Select all

	buffer=buffer2;
	buffer=buffer<<16;
	buffer=buffer>>20;
	putchar(return_hex(buffer));

Code: Select all

	buffer=buffer2;
	buffer=buffer|0x0F;
	putchar(return_hex(buffer));

Code: Select all

	case 0x00:
	return '0';
	break;

	case 0x01:
	return '1';
	break;

Code: Select all

	default:
	break;

Code: Select all

	char *code;
	int c=0xAF;
...
	Printf("c is 0x%x",c);

Code: Select all

void printhex(int i){

        puts("0x");

        uint counter = 8;
        uchar cur;

        while(counter-- > 0){
                cur = (i & 0xf0000000) >> 28;

                i <<= 4;

                if (cur >= 0xA)
                        cur += 0x07;

                cur += 0x30;

                putch(cur);
        }
}

Code: Select all

; display half a long, in hex -- designed to be called twice
; inputs: ecx = long to print, ah = attrib value, edi -> video buffer
; destroys: al (-- after 2 long calls, ecx is unchanged)
dhex_lng:
	ror ecx, 16			; swap the high & low words of ecx
dhex_s:
	push edx
	mov edx, ecx
	movzx ecx, ch
	call dohdig			; convert to 2 hex digits + 2 attrib bytes
	movzx ecx, dl
	call dohdig
	mov ecx, edx
	pop edx
	ret


; dohdig copies 2 hex digits plus attribute bytes into edi
; inputs: ecx = zero extended byte, ah = attrib value, edi -> video buffer
; destroys: al
dohdig:
	push edx
	mov dx, [hex_lkup + ecx*2]		; get 2 bytes from lookup table
	mov al, dl				; get 1st (high digit) ready to store
	; Note: the high digit is supposed to be written 1st, so it ends up in dl
	stosw
	mov al, dh				; get 2nd ready to store
	stosw					; attrib was still in ah
	pop edx
	ret

Code: Select all

void VideoManager::PrintHex(u32int num)
{
	char buffer[11];
	buffer[0] = '0';
	buffer[1] = 'x';
	for (int i = 7; i >= 0; i--)
	{
		buffer[i+2] = static_cast<char>(num % 16 < 10 ? '0' + num % 16 : 'A' - 10 + num % 16);
		num /= 16;
	}
	buffer[10]= '\0';         /* terminate string */

	PrintString(buffer);     /* print it */
}