Spexeah/Asuro
Spexeah/Asuro
3
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Standardized to standard types in types.pas

Browse Source 
git-svn-id: https://spexeah.com:8443/svn/Asuro@31 6dbc8c32-bb84-406f-8558-d1cf31a0ab0c
This commit is contained in:
kieron 2017-05-16 22:25:41 +00:00
parent 7da445635c
commit 7a24ea11ba
17 changed files with 186 additions and 161 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

BIN
Asuro.iso
View File

Binary file not shown.

BIN
bin/kernel.bin
View File

Binary file not shown.

BIN
iso/boot/asuro.bin
View File

Binary file not shown.

BIN
lib/gdt.ppu
View File

Binary file not shown.

BIN
lib/kernel.o
View File

Binary file not shown.

BIN
lib/kernel.ppu
View File

Binary file not shown.

BIN
lib/libpkernel.a
View File

Binary file not shown.

BIN
lib/types.ppu
View File

Binary file not shown.

36
src/bios_data_area.pas
View File

@ -4,24 +4,24 @@ interface
type type
TBDA = bitpacked record TBDA = bitpacked record
COM1 : WORD; COM1 : uint16;
COM2 : WORD; COM2 : uint16;
COM3 : WORD; COM3 : uint16;
COM4 : WORD; COM4 : uint16;
LPT1 : WORD; LPT1 : uint16;
LPT2 : WORD; LPT2 : uint16;
LPT3 : WORD; LPT3 : uint16;
EBDA : WORD; EBDA : uint16;
Hardware_Flags : WORD; Hardware_Flags : uint16;
Keyboard_Flags : WORD; Keyboard_Flags : uint16;
Keyboard_Buffer : ARRAY[0..31] OF BYTE; Keyboard_Buffer : ARRAY[0..31] OF uint8;
Display_Mode : BYTE; Display_Mode : uint8;
BaseIO : WORD; BaseIO : uint16;
Ticks : WORD; Ticks : uint16;
HDD_Count : BYTE; HDD_Count : uint8;
Keyboard_Start : WORD; Keyboard_Start : uint16;
Keyboard_End : WORD; Keyboard_End : uint16;
Keyboard_State : Byte; Keyboard_State : uint8;
end; end;
PBDA = ^TBDA; PBDA = ^TBDA;

134
src/console.pas
View File

@ -26,33 +26,33 @@ type
procedure init(); procedure init();
procedure clear(); procedure clear();
procedure setdefaultattribute(attribute : char); procedure setdefaultattribute(attribute : sint8);
procedure writechar(character : char); procedure writechar(character : sint8);
procedure writestring(str: PChar); procedure writestring(str: psint8);
procedure writeint(i: Integer); procedure writeint(i: sint32);
procedure writeword(i: DWORD); procedure writeword(i: uint32);
procedure writehex(i: DWORD); procedure writehex(i: uint32);
procedure writecharln(character : char); procedure writecharln(character : sint8);
procedure writestringln(str: PChar); procedure writestringln(str: psint8);
procedure writeintln(i: Integer); procedure writeintln(i: sint32);
procedure writewordln(i: DWORD); procedure writewordln(i: uint32);
procedure writehexln(i: DWORD); procedure writehexln(i: uint32);
procedure writecharex(character : char; attributes : char); procedure writecharex(character : sint8; attributes : sint8);
procedure writestringex(str: PChar; attributes : char); procedure writestringex(str: psint8; attributes : sint8);
procedure writeintex(i: Integer; attributes : char); procedure writeintex(i: sint32; attributes : sint8);
procedure writewordex(i: DWORD; attributes : char); procedure writewordex(i: uint32; attributes : sint8);
procedure writehexex(i : DWORD; attributes : char); procedure writehexex(i : uint32; attributes : sint8);
procedure writecharlnex(character : char; attributes : char); procedure writecharlnex(character : sint8; attributes : sint8);
procedure writestringlnex(str: PChar; attributes : char); procedure writestringlnex(str: psint8; attributes : sint8);
procedure writeintlnex(i: Integer; attributes : char); procedure writeintlnex(i: sint32; attributes : sint8);
procedure writewordlnex(i: DWORD; attributes : char); procedure writewordlnex(i: uint32; attributes : sint8);
procedure writehexlnex(i: DWORD; attributes : char); procedure writehexlnex(i: uint32; attributes : sint8);
function combinecolors(Foreground, Background : TColor) : char; function combinecolors(Foreground, Background : TColor) : sint8;
procedure _increment_x(); procedure _increment_x();
procedure _increment_y(); procedure _increment_y();
@ -64,12 +64,12 @@ implementation
type type
TConsoleProperties = record TConsoleProperties = record
Default_Attribute : Char; Default_Attribute : sint8;
end; end;
TCharacter = bitpacked record TCharacter = bitpacked record
Character : Char; Character : sint8;
Attributes : Char; Attributes : sint8;
end; end;
PCharacter = ^TCharacter; PCharacter = ^TCharacter;
@ -80,8 +80,8 @@ type
P2DVideoMemory = ^T2DVideoMemory; P2DVideoMemory = ^T2DVideoMemory;
TCoord = record TCoord = record
X : Byte; X : uint8;
Y : Byte; Y : uint8;
end; end;
var var
@ -98,7 +98,7 @@ end;
procedure clear(); [public, alias: 'console_clear']; procedure clear(); [public, alias: 'console_clear'];
var var
x,y: Byte; x,y: uint8;
begin begin
for x:=0 to 79 do begin for x:=0 to 79 do begin
@ -111,64 +111,64 @@ begin
Console_Cursor.Y:= 0; Console_Cursor.Y:= 0;
end; end;
procedure setdefaultattribute(attribute: char); [public, alias: 'console_setdefaultattribute']; procedure setdefaultattribute(attribute: sint8); [public, alias: 'console_setdefaultattribute'];
begin begin
Console_Properties.Default_Attribute:= attribute; Console_Properties.Default_Attribute:= attribute;
end; end;
procedure writechar(character: char); [public, alias: 'console_writechar']; procedure writechar(character: sint8); [public, alias: 'console_writechar'];
begin begin
console.writecharex(character, Console_Properties.Default_Attribute); console.writecharex(character, Console_Properties.Default_Attribute);
end; end;
procedure writestring(str: PChar); [public, alias: 'console_writestring']; procedure writestring(str: psint8); [public, alias: 'console_writestring'];
begin begin
console.writestringex(str, Console_Properties.Default_Attribute); console.writestringex(str, Console_Properties.Default_Attribute);
end; end;
procedure writeint(i: Integer); [public, alias: 'console_writeint']; procedure writeint(i: sint32); [public, alias: 'console_writeint'];
begin begin
console.writeintex(i, Console_Properties.Default_Attribute); console.writeintex(i, Console_Properties.Default_Attribute);
end; end;
procedure writeword(i: DWORD); [public, alias: 'console_writeword']; procedure writeword(i: uint32); [public, alias: 'console_writeword'];
begin begin
console.writewordex(i, Console_Properties.Default_Attribute); console.writewordex(i, Console_Properties.Default_Attribute);
end; end;
procedure writecharln(character: char); [public, alias: 'console_writecharln']; procedure writecharln(character: sint8); [public, alias: 'console_writecharln'];
begin begin
console.writecharlnex(character, Console_Properties.Default_Attribute); console.writecharlnex(character, Console_Properties.Default_Attribute);
end; end;
procedure writestringln(str: PChar); [public, alias: 'console_writestringln']; procedure writestringln(str: psint8); [public, alias: 'console_writestringln'];
begin begin
console.writestringlnex(str, Console_Properties.Default_Attribute); console.writestringlnex(str, Console_Properties.Default_Attribute);
end; end;
procedure writeintln(i: Integer); [public, alias: 'console_writeintln']; procedure writeintln(i: sint32); [public, alias: 'console_writeintln'];
begin begin
console.writeintlnex(i, Console_Properties.Default_Attribute); console.writeintlnex(i, Console_Properties.Default_Attribute);
end; end;
procedure writewordln(i: DWORD); [public, alias: 'console_writewordln']; procedure writewordln(i: uint32); [public, alias: 'console_writewordln'];
begin begin
console.writewordlnex(i, Console_Properties.Default_Attribute); console.writewordlnex(i, Console_Properties.Default_Attribute);
end; end;
procedure writecharex(character: char; attributes: char); [public, alias: 'console_writecharex']; procedure writecharex(character: sint8; attributes: sint8); [public, alias: 'console_writecharex'];
begin begin
Console_Matrix^[Console_Cursor.Y][Console_Cursor.X].Character:= character; Console_Matrix^[Console_Cursor.Y][Console_Cursor.X].Character:= character;
Console_Matrix^[Console_Cursor.Y][Console_Cursor.X].Attributes:= attributes; Console_Matrix^[Console_Cursor.Y][Console_Cursor.X].Attributes:= attributes;
console._safeincrement_x(); console._safeincrement_x();
end; end;
procedure writehexex(i : dword; attributes: char); [public, alias: 'console_writehexex']; procedure writehexex(i : uint32; attributes: sint8); [public, alias: 'console_writehexex'];
var var
Hex : Array[0..7] of Byte; Hex : Array[0..7] of uint8;
Res : DWORD; Res : uint32;
Rem : DWORD; Rem : uint32;
c : Integer; c : sint32;
begin begin
for c:=0 to 7 do begin for c:=0 to 7 do begin
@ -209,25 +209,25 @@ begin
end; end;
end; end;
procedure writehex(i : dword); [public, alias: 'console_writehex']; procedure writehex(i : uint32); [public, alias: 'console_writehex'];
begin begin
console.writehexex(i, Console_Properties.Default_Attribute); console.writehexex(i, Console_Properties.Default_Attribute);
end; end;
procedure writehexlnex(i : dword; attributes : char); procedure writehexlnex(i : uint32; attributes : sint8);
begin begin
console.writehexex(i, attributes); console.writehexex(i, attributes);
console._safeincrement_y(); console._safeincrement_y();
end; end;
procedure writehexln(i : dword); procedure writehexln(i : uint32);
begin begin
writehexlnex(i, Console_Properties.Default_Attribute); writehexlnex(i, Console_Properties.Default_Attribute);
end; end;
procedure writestringex(str: PChar; attributes: char); [public, alias: 'console_writestringex']; procedure writestringex(str: psint8; attributes: sint8); [public, alias: 'console_writestringex'];
var var
i : integer; i : sint32;
begin begin
i:= 0; i:= 0;
@ -237,11 +237,11 @@ begin
end; end;
end; end;
procedure writeintex(i: Integer; attributes : char); [public, alias: 'console_writeintex']; procedure writeintex(i: sint32; attributes : sint8); [public, alias: 'console_writeintex'];
var var
buffer: array [0..11] of Char; buffer: array [0..11] of sint8;
str: PChar; str: psint8;
digit: DWORD; digit: uint32;
minus: Boolean; minus: Boolean;
begin begin
str := @buffer[11]; str := @buffer[11];
@ -255,7 +255,7 @@ begin
end; end;
repeat repeat
Dec(str); Dec(str);
str^ := Char((digit mod 10) + Byte('0')); str^ := sint8((digit mod 10) + uint8('0'));
digit := digit div 10; digit := digit div 10;
until (digit = 0); until (digit = 0);
if (minus) then begin if (minus) then begin
@ -265,11 +265,11 @@ begin
console.writestringex(str, attributes); console.writestringex(str, attributes);
end; end;
procedure writewordex(i: DWORD; attributes : char); [public, alias: 'console_writedwordex']; procedure writewordex(i: uint32; attributes : sint8); [public, alias: 'console_writedwordex'];
var var
buffer: array [0..11] of Char; buffer: array [0..11] of sint8;
str: PChar; str: psint8;
digit: DWORD; digit: uint32;
begin begin
for digit := 0 to 10 do buffer[digit] := '0'; for digit := 0 to 10 do buffer[digit] := '0';
str := @buffer[11]; str := @buffer[11];
@ -277,45 +277,45 @@ begin
digit := i; digit := i;
repeat repeat
Dec(str); Dec(str);
str^ := Char((digit mod 10) + Byte('0')); str^ := sint8((digit mod 10) + uint8('0'));
digit := digit div 10; digit := digit div 10;
until (digit = 0); until (digit = 0);
console.writestringex(@Buffer[0], attributes); console.writestringex(@Buffer[0], attributes);
end; end;
procedure writecharlnex(character: char; attributes: char); [public, alias: 'console_writecharlnex']; procedure writecharlnex(character: sint8; attributes: sint8); [public, alias: 'console_writecharlnex'];
begin begin
console.writecharex(character, attributes); console.writecharex(character, attributes);
console._safeincrement_y(); console._safeincrement_y();
end; end;
procedure writestringlnex(str: PChar; attributes: char); [public, alias: 'console_writestringlnex']; procedure writestringlnex(str: sint8; attributes: sint8); [public, alias: 'console_writestringlnex'];
begin begin
console.writestringex(str, attributes); console.writestringex(str, attributes);
console._safeincrement_y(); console._safeincrement_y();
end; end;
procedure writeintlnex(i: Integer; attributes: char); [public, alias: 'console_writeintlnex']; procedure writeintlnex(i: sint32; attributes: sint8); [public, alias: 'console_writeintlnex'];
begin begin
console.writeintex(i, attributes); console.writeintex(i, attributes);
console._safeincrement_y(); console._safeincrement_y();
end; end;
procedure writewordlnex(i: DWORD; attributes: char); [public, alias: 'console_writewordlnex']; procedure writewordlnex(i: uint32; attributes: sint8); [public, alias: 'console_writewordlnex'];
begin begin
console.writewordex(i, attributes); console.writewordex(i, attributes);
console._safeincrement_y(); console._safeincrement_y();
end; end;
function combinecolors(Foreground, Background: TColor): char; [public, alias: 'console_combinecolors']; function combinecolors(Foreground, Background: TColor): sint8; [public, alias: 'console_combinecolors'];
begin begin
combinecolors:= char(((ord(Background) shl 4) or ord(Foreground))); combinecolors:= sint8(((ord(Background) shl 4) or ord(Foreground)));
end; end;
procedure _update_cursor(); [public, alias: '_console_update_cursor']; procedure _update_cursor(); [public, alias: '_console_update_cursor'];
var var
pos : word; pos : uint16;
b : byte; b : uint8;
begin begin
pos:= (Console_Cursor.Y * 80) + Console_Cursor.X; pos:= (Console_Cursor.Y * 80) + Console_Cursor.X;
@ -366,7 +366,7 @@ end;
procedure _newline(); [public, alias: '_console_newline']; procedure _newline(); [public, alias: '_console_newline'];
var var
x, y : byte; x, y : uint8;
begin begin
for x:=0 to 79 do begin for x:=0 to 79 do begin

30
src/gdt.pas
View File

@ -7,18 +7,18 @@ uses
type type
TGDT_Entry = bitpacked record TGDT_Entry = bitpacked record
limit_low : int16; limit_low : uint16;
base_low : int16; base_low : uint16;
base_middle : int8; base_middle : uint8;
access : int8; access : uint8;
granularity : int8; granularity : uint8;
base_high : int8; base_high : uint8;
end; end;
PGDT_Entry = ^TGDT_Entry; PGDT_Entry = ^TGDT_Entry;
TGDT_Pointer = bitpacked record TGDT_Pointer = bitpacked record
limit : int16; limit : uint16;
base : int32; base : uint32;
end; end;
var var
@ -29,7 +29,7 @@ procedure init();
implementation implementation
procedure flush_gdt(gdt_pointer : int32); assembler; nostackframe; procedure flush_gdt(gdt_pointer : uint32); assembler; nostackframe;
asm asm
MOV EAX, gdt_pointer MOV EAX, gdt_pointer
LGDT [EAX] LGDT [EAX]
@ -40,13 +40,11 @@ asm
MOV GS, AX MOV GS, AX
MOV SS, AX MOV SS, AX
db $EA // Bypass stupid inline ASM restrictions- db $EA // Bypass stupid inline ASM restrictions-
dw @@flush, $08 // by assembling the farjump instruction ourselves. dw @@flush, $08 // by assembling the farjump instruction ourselves.
// It's just data, honest gov'. @@flush: // It's just data, honest gov'.
@@flush:
RET
end; end;
procedure set_gate(Gate_Number : int32; Base : int32; Limit : int32; Access : int8; Granularity : int8); procedure set_gate(Gate_Number : uint32; Base : uint32; Limit : uint32; Access : uint8; Granularity : uint8);
begin begin
gdt_entries[Gate_Number].base_low := (Base AND $FFFF); gdt_entries[Gate_Number].base_low := (Base AND $FFFF);
gdt_entries[Gate_Number].base_middle := (Base SHR 16) AND $FF; gdt_entries[Gate_Number].base_middle := (Base SHR 16) AND $FF;
@ -59,13 +57,13 @@ end;
procedure init(); procedure init();
begin begin
gdt_pointer.limit := (sizeof(TGDT_Entry) * 5) - 1; gdt_pointer.limit := (sizeof(TGDT_Entry) * 5) - 1;
gdt_pointer.base := int32(@gdt_entries); gdt_pointer.base := uint32(@gdt_entries);
set_gate($00, $00, $00, $00, $00); set_gate($00, $00, $00, $00, $00);
set_gate($01, $00, $FFFFFFFF, $9A, $CF); set_gate($01, $00, $FFFFFFFF, $9A, $CF);
set_gate($02, $00, $FFFFFFFF, $92, $CF); set_gate($02, $00, $FFFFFFFF, $92, $CF);
set_gate($03, $00, $FFFFFFFF, $FA, $CF); set_gate($03, $00, $FFFFFFFF, $FA, $CF);
set_gate($04, $00, $FFFFFFFF, $F2, $CF); set_gate($04, $00, $FFFFFFFF, $F2, $CF);
flush_gdt(int32(@gdt_pointer)) flush_gdt(uint32(@gdt_pointer))
end; end;
end. end.

16
src/idt.pas Normal file
View File

@ -0,0 +1,16 @@
unit idt;
interface
uses
system,
types;
type
TIDT_Entry = bitpacked record
end;
implementation
end.

14
src/kernel.pas
View File

@ -14,12 +14,12 @@ procedure kmain(mbinfo: Pmultiboot_info_t; mbmagic: DWORD); stdcall;
implementation implementation
procedure kmain(mbinfo: Pmultiboot_info_t; mbmagic: DWORD); stdcall; [public, alias: 'kmain']; procedure kmain(mbinfo: Pmultiboot_info_t; mbmagic: uint32); stdcall; [public, alias: 'kmain'];
var var
c : byte; c : uint8;
mbi : Pmultiboot_info_t; mbi : Pmultiboot_info_t;
mbm : DWORD; mbm : uint32;
dds : DWORD; dds : uint32;
begin begin
mbi:= mbinfo; mbi:= mbinfo;
@ -41,8 +41,6 @@ begin
console.setdefaultattribute(console.combinecolors(Red, Black)); console.setdefaultattribute(console.combinecolors(Red, Black));
if dds = $08 then console.setdefaultattribute(console.combinecolors(Green, Black)); if dds = $08 then console.setdefaultattribute(console.combinecolors(Green, Black));
console.writehexln(dds); console.writehexln(dds);
util.halt_and_catch_fire;
console.setdefaultattribute(console.combinecolors(Green, Black)); console.setdefaultattribute(console.combinecolors(Green, Black));
console.writestringln('Asuro Booted Correctly!'); console.writestringln('Asuro Booted Correctly!');
console.writestringln(''); console.writestringln('');
@ -57,11 +55,11 @@ begin
console.writeint(((mbinfo^.mem_upper + 1000) div 1024) +1); console.writeint(((mbinfo^.mem_upper + 1000) div 1024) +1);
console.writestringln('MB'); console.writestringln('MB');
console.setdefaultattribute(console.combinecolors(lYellow, Black)); console.setdefaultattribute(console.combinecolors(lYellow, Black));
while true do begin {while true do begin
c:= keyboard.get_scancode; c:= keyboard.get_scancode;
console.writehexln(c); console.writehexln(c);
end; end;
util.halt_and_catch_fire; util.halt_and_catch_fire;}
end; end;
end. end.

6
src/keyboard.pas
View File

@ -7,13 +7,13 @@ interface
uses uses
util; util;
function get_scancode() : byte; function get_scancode() : uint8;
implementation implementation
function get_scancode() : byte; [public, alias: 'get_scancode']; function get_scancode() : uint8; [public, alias: 'get_scancode'];
var var
c : byte; c : uint8;
begin begin
c:= 0; c:= 0;

42
src/multiboot.pas
View File

@ -9,40 +9,40 @@ const
type type
Pelf_section_header_table_t = ^elf_section_header_table_t; Pelf_section_header_table_t = ^elf_section_header_table_t;
elf_section_header_table_t = packed record elf_section_header_table_t = packed record
num: DWORD; num: uint32;
size: DWORD; size: uint32;
addr: DWORD; addr: uint32;
shndx: DWORD; shndx: uint32;
end; end;
Pmultiboot_info_t = ^multiboot_info_t; Pmultiboot_info_t = ^multiboot_info_t;
multiboot_info_t = packed record multiboot_info_t = packed record
flags: DWORD; flags: uint32;
mem_lower: DWORD; mem_lower: uint32;
mem_upper: DWORD; mem_upper: uint32;
boot_device: DWORD; boot_device: uint32;
cmdline: DWORD; cmdline: uint32;
mods_count: DWORD; mods_count: uint32;
mods_addr: DWORD; mods_addr: uint32;
elf_sec: elf_section_header_table_t; elf_sec: elf_section_header_table_t;
mmap_length: DWORD; mmap_length: uint32;
mmap_addr: DWORD; mmap_addr: uint32;
end; end;
Pmodule_t = ^module_t; Pmodule_t = ^module_t;
module_t = packed record module_t = packed record
mod_start: DWORD; mod_start: uint32;
mod_end: DWORD; mod_end: uint32;
name: DWORD; name: uint32;
reserved: DWORD; reserved: uint32;
end; end;
Pmemory_map_t = ^memory_map_t; Pmemory_map_t = ^memory_map_t;
memory_map_t = packed record memory_map_t = packed record
size: DWORD; size: uint32;
base_addr : QWORD; base_addr : uint64;
length : QWORD; length : uint64;
mtype: DWORD; mtype: uint32;
end; end;
implementation implementation

33
src/types.pas
View File

@ -4,21 +4,34 @@ interface
type type
//Standard Types //Standard Types
Int8 = BYTE; uInt8 = BYTE;
Int16 = WORD; uInt16 = WORD;
Int32 = DWORD; uInt32 = DWORD;
Int64 = QWORD; uInt64 = QWORD;
sInt8 = shortint;
sInt16 = smallint;
sInt32 = integer;
sInt64 = longint;
Float = Single;
//Pointer Types //Pointer Types
PByte = ^Byte; PuByte = ^Byte;
PInt8 = PByte; PuInt8 = PuByte;
PInt16 = ^Int16; PuInt16 = ^uInt16;
PInt32 = ^Int32; PuInt32 = ^uInt32;
PInt64 = ^Int64; PuInt64 = ^uInt64;
Void = ^Int32; PsInt8 = ^sInt8;
PsInt16 = ^sInt16;
PsInt32 = ^sInt32;
PsInt64 = ^sInt64;
PFloat = ^Float;
PDouble = ^Double;
Void = ^uInt32;
implementation implementation

36
src/util.pas
View File

@ -4,35 +4,35 @@ unit util;
interface interface
function hi(b : byte) : byte; function hi(b : uint8) : uint8;
function lo(b : byte) : byte; function lo(b : uint8) : uint8;
function switchendian(b : byte) : byte; function switchendian(b : uint8) : uint8;
procedure outb(port : word; val : byte); procedure outb(port : uint16; val : uint8);
procedure outw(port : word; val : word); procedure outw(port : uint16; val : uint16);
procedure outl(port : word; val : longword); procedure outl(port : uint16; val : uint32);
procedure halt_and_catch_fire(); procedure halt_and_catch_fire();
function inb(port : word) : byte; function inb(port : uint16) : uint8;
function inw(port : word) : word; function inw(port : uint16) : uint16;
function inl(port : word) : dword; function inl(port : uint16) : uint32;
implementation implementation
function hi(b : byte) : byte; [public, alias: 'util_hi']; function hi(b : uint8) : uint8; [public, alias: 'util_hi'];
begin begin
hi:= (b AND $F0) SHR 4; hi:= (b AND $F0) SHR 4;
end; end;
function lo(b : byte) : byte; [public, alias: 'util_lo']; function lo(b : uint8) : uint8; [public, alias: 'util_lo'];
begin begin
lo:= b AND $0F; lo:= b AND $0F;
end; end;
function switchendian(b : byte) : byte; [public, alias: 'util_switchendian']; function switchendian(b : uint8) : uint8; [public, alias: 'util_switchendian'];
begin begin
switchendian:= (lo(b) SHL 4) OR hi(b); switchendian:= (lo(b) SHL 4) OR hi(b);
end; end;
procedure outl(port : word; val : longword); [public, alias: 'util_outl']; procedure outl(port : uint16; val : uint32); [public, alias: 'util_outl'];
begin begin
asm asm
PUSH EAX PUSH EAX
@ -45,7 +45,7 @@ begin
end; end;
end; end;
procedure outw(port : word; val : word); [public, alias: 'util_outw']; procedure outw(port : uint16; val : uint16); [public, alias: 'util_outw'];
begin begin
asm asm
PUSH EAX PUSH EAX
@ -58,7 +58,7 @@ begin
end; end;
end; end;
procedure outb(port : word; val : byte); [public, alias: 'util_outb']; procedure outb(port : uint16; val : uint8); [public, alias: 'util_outb'];
begin begin
asm asm
PUSH EAX PUSH EAX
@ -79,7 +79,7 @@ begin
end; end;
end; end;
function inl(port : word) : dword; [public, alias: 'util_inl']; function inl(port : uint16) : uint32; [public, alias: 'util_inl'];
begin begin
asm asm
PUSH EAX PUSH EAX
@ -92,7 +92,7 @@ begin
end; end;
end; end;
function inw(port : word) : word; [public, alias: 'util_inw']; function inw(port : uint16) : uint16; [public, alias: 'util_inw'];
begin begin
asm asm
PUSH EAX PUSH EAX
@ -105,7 +105,7 @@ begin
end; end;
end; end;
function inb(port : word) : byte; [public, alias: 'util_inb']; function inb(port : uint16) : uint8; [public, alias: 'util_inb'];
begin begin
asm asm
PUSH EAX PUSH EAX