From 99fc00450ef20e7cabb19a6b7dbd17c8792f81fa Mon Sep 17 00:00:00 2001 From: kieron Date: Tue, 21 Jul 2020 22:06:41 +0000 Subject: [PATCH] git-svn-id: https://spexeah.com:8443/svn/Asuro@1441 6dbc8c32-bb84-406f-8558-d1cf31a0ab0c --- src/driver/storage/vfs.pas | 51 +- src/fault/ACE.pas | 1 + src/fault/BPE.pas | 1 + src/fault/BTSSE.pas | 1 + src/fault/CFE.pas | 1 + src/fault/CSOE.pas | 1 + src/fault/DBGE.pas | 1 + src/fault/DBZ.pas | 1 + src/fault/DFE.pas | 1 + src/fault/GPF.pas | 13 +- src/fault/IDOE.pas | 1 + src/fault/IOPE.pas | 1 + src/fault/MCE.pas | 1 + src/fault/NCE.pas | 1 + src/fault/NMIE.pas | 1 + src/fault/OOBE.pas | 1 + src/fault/PF.pas | 1 + src/fault/SFE.pas | 1 + src/fault/SNPE.pas | 1 + src/fault/UIE.pas | 1 + src/include/util.pas | 13 +- src/isr/isr_types.pas | 48 ++ src/isr/isrmanager.pas | 1281 ++++++++++++++++++++++++++++-------- src/kernel.pas | 4 + 24 files changed, 1154 insertions(+), 274 deletions(-) diff --git a/src/driver/storage/vfs.pas b/src/driver/storage/vfs.pas index 9218e404..aa33d7a1 100644 --- a/src/driver/storage/vfs.pas +++ b/src/driver/storage/vfs.pas @@ -172,6 +172,7 @@ var elm : pchar; begin + tracer.push_trace('vfs.evaluatePath.enter'); List:= STRLL_FromString(Path, '/'); if STRLL_Size(List) > 0 then begin for i:=STRLL_Size(List)-1 downto 0 do begin @@ -186,6 +187,7 @@ begin end; evaluatePath:= CombineToAbsolutePath(List, STRLL_Size(List)); STRLL_Free(List); + tracer.push_trace('vfs.evaluatePath.exit'); end; function getAbsolutePath(Obj : PVFSObject) : pchar; @@ -225,6 +227,7 @@ var TempPath : pchar; begin + tracer.push_trace('vfs.MakeAbsolutePath.enter'); if Path[0] = '/' then AbsPath:= stringCopy(Path) else begin if CurrentDirectory[StringSize(CurrentDirectory)-1] <> '/' then TempPath:= StringConcat(CurrentDirectory, '/') @@ -234,6 +237,7 @@ begin kfree(void(TempPath)); end; MakeAbsolutePath:= AbsPath; + tracer.push_trace('vfs.MakeAbsolutePath.exit'); end; function GetObjectFromPath(path : pchar) : PVFSObject; @@ -367,8 +371,13 @@ var Obj : PVFSObject; ObjPath : pchar; RelPath : pchar; + AbsPath : pchar; + CopyPath : pchar; + MntPath : pchar; + ValidCallback : TPathValid; begin + tracer.push_trace('vfs.PathValid.enter'); PathValid:= pvInvalid; Obj:= GetObjectFromPath(Path); if Obj <> nil then begin @@ -379,14 +388,22 @@ begin otDRIVE:begin ObjPath:= getAbsolutePath(Obj); RelPath:= makeRelative(Path, ObjPath); - PathValid:= PVFSDrive(Obj^.Reference)^.PathValid(PVFSDrive(Obj^.Reference)^.DriveHandle, RelPath); //Fix this to be relative path!!! + ValidCallback:= PVFSDrive(Obj^.Reference)^.PathValid; + if ValidCallback <> nil then + PathValid:= ValidCallback(PVFSDrive(Obj^.Reference)^.DriveHandle, RelPath) + else + PathValid:= pvInvalid; kfree(void(ObjPath)); kfree(void(RelPath)); end; otDEVICE:begin ObjPath:= getAbsolutePath(Obj); RelPath:= makeRelative(Path, ObjPath); - PathValid:= PVFSDevice(Obj^.Reference)^.PathValid(PVFSDevice(Obj^.Reference)^.DeviceHandle, RelPath); //Fix this to be the relative path + ValidCallback:= PVFSDevice(Obj^.Reference)^.PathValid; + if ValidCallback <> nil then + PathValid:= ValidCallback(PVFSDevice(Obj^.Reference)^.DeviceHandle, RelPath) + else + PathValid:= pvInvalid; kfree(void(ObjPath)); kfree(void(RelPath)); end; @@ -394,10 +411,30 @@ begin PathValid:= pvFile; end; otMOUNT:begin - PathValid:= PathValid(PVFSMount(Obj^.Reference)^.Path); + { Get the absolute path of this object, i.e. /mnt/mount1 } + ObjPath:= getAbsolutePath(Obj); + { Make our path relative, i.e. /mnt/mount1/myfile becomes /myfile } + RelPath:= makeRelative(Path, ObjPath); + { Grab the Redirect Path i.e. /disk/disk1 } + MntPath:= PVFSMount(Obj^.Reference)^.Path; + { Ensure that if there isn't a '/' between the RelPath & MntPath we add one } + If (MntPath[StringSize(MntPath)-1] <> '/') AND (RelPath[0] <> '/') then + CopyPath:= StringConcat(MntPath, '/') + else + CopyPath:= StringCopy(MntPath); + { Concat MntPath + RelPath, i.e. above examples would become /disk/disk1/myfile } + AbsPath:= StringConcat(MntPath, RelPath); + { Recursively call PathValid on our new path } + PathValid:= PathValid(AbsPath); + { Free everything we allocated } + kfree(void(AbsPath)); + kfree(void(RelPath)); + kfree(void(CopyPath)); + kfree(void(ObjPath)); end; end; end; + tracer.push_trace('vfs.PathValid.exit'); end; function changeDirectory(Path : pchar) : TIsPathValid; @@ -407,6 +444,7 @@ var Validity : TIsPathValid; begin + tracer.push_trace('vfs.changeDirectory.enter'); TempPath:= MakeAbsolutePath(Path); AbsPath:= evaluatePath(TempPath); kfree(void(TempPath)); @@ -416,6 +454,7 @@ begin end; changeDirectory:= Validity; kfree(void(AbsPath)); + tracer.push_trace('vfs.changeDirectory.exit'); end; { VFS Functions } @@ -470,7 +509,9 @@ end; function getWorkingDirectory : pchar; begin + tracer.push_trace('vfs.getWorkingDirectory.enter'); getWorkingDirectory:= CurrentDirectory; + tracer.push_trace('vfs.getWorkingDirectory.exit'); end; { Terminal Commands } @@ -520,6 +561,7 @@ var i : uint32; begin + tracer.push_trace('vfs.VFS_COMMAND_CD.enter'); if ParamCount(Params) > 0 then begin for i:=0 to ParamCount(Params)-1 do begin if i = 0 then begin @@ -549,6 +591,7 @@ begin end; kfree(void(Path)); end; + tracer.push_trace('vfs.VFS_COMMAND_CD.exit'); end; { Init } @@ -573,10 +616,12 @@ begin newVirtualDirectory('/disk'); newVirtualDirectory('/disk/test'); newVirtualDirectory('/disk/test/myfolder'); + newVirtualDirectory('/disk/test/mytest'); // rel:= makeRelative('/disk/SDA/mydirectory/myfile', '/disk/SDA'); // if rel <> nil then outputln('VFS', rel) else outputln('VFS', 'REL IS NULL!'); + //outputln('VFS', makeRelative('/test/mydisk/mything', '/test/mydisk')); //while true do begin end; terminal.registerCommand('LS', @VFS_COMMAND_LS, 'List directory contents.'); diff --git a/src/fault/ACE.pas b/src/fault/ACE.pas index 2aeb3cbe..03f0fc58 100644 --- a/src/fault/ACE.pas +++ b/src/fault/ACE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(true); BSOD('AC', 'Alignment Check Exception.'); console.writestringln('Alignment Check Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/BPE.pas b/src/fault/BPE.pas index 98f33df4..9398fd92 100644 --- a/src/fault/BPE.pas +++ b/src/fault/BPE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(false); BSOD('BE', 'Breakpoint Exception.'); console.writestringln('Breakpoint Exception'); util.halt_and_catch_fire; diff --git a/src/fault/BTSSE.pas b/src/fault/BTSSE.pas index 57c650e9..66700a34 100644 --- a/src/fault/BTSSE.pas +++ b/src/fault/BTSSE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(true); BSOD('TSS', 'Bad TSS Exception.'); console.writestringln('Bad TSS Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/CFE.pas b/src/fault/CFE.pas index 59bd7380..5435a809 100644 --- a/src/fault/CFE.pas +++ b/src/fault/CFE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(false); BSOD('CF', 'Coprocessor Fault Exception.'); console.writestringln('Coprocessor Fault Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/CSOE.pas b/src/fault/CSOE.pas index 42a40b49..277b81d7 100644 --- a/src/fault/CSOE.pas +++ b/src/fault/CSOE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(false); BSOD('CSO', 'Coprocessor Seg Overrun Exception.'); console.writestringln('Coprocessor Seg Overrun Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/DBGE.pas b/src/fault/DBGE.pas index f24917d0..531bb615 100644 --- a/src/fault/DBGE.pas +++ b/src/fault/DBGE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(false); BSOD('DE', 'Debug Exception'); console.writestringln('Debug Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/DBZ.pas b/src/fault/DBZ.pas index 806d56f5..4706d10a 100644 --- a/src/fault/DBZ.pas +++ b/src/fault/DBZ.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(false); BSOD('DBZ', 'Divide By Zero Exception.'); console.writestringln('Divide by Zero Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/DFE.pas b/src/fault/DFE.pas index 08dd208b..c6eb698e 100644 --- a/src/fault/DFE.pas +++ b/src/fault/DFE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(true); BSOD('DF', 'Double Fault.'); console.writestringln('Double Fault.'); util.halt_and_catch_fire; diff --git a/src/fault/GPF.pas b/src/fault/GPF.pas index 8d283049..dd0f917b 100644 --- a/src/fault/GPF.pas +++ b/src/fault/GPF.pas @@ -25,20 +25,9 @@ var begin CLI; - asm - MOV EAX, EBP - MOV Regs, EAX - end; + correctInterruptRegisters(true); BSOD('GPF', 'General Protection Fault.'); console.writestringln('General Protection Fault.'); - console.writestring('Flags: '); - console.writehexln(Regs^.EFlags); - console.writestring('EIP: '); - console.writehexln(Regs^.EIP); - console.writestring('CS: '); - console.writehexln(Regs^.CS); - console.writestring('Error Code: '); - console.writehexln(Regs^.ErrorCode); util.halt_and_catch_fire; end; diff --git a/src/fault/IDOE.pas b/src/fault/IDOE.pas index 2a2e4f0a..8264f5a4 100644 --- a/src/fault/IDOE.pas +++ b/src/fault/IDOE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(false); BSOD('IDO', 'Into Detected Overflow Exception.'); console.writestringln('IDO Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/IOPE.pas b/src/fault/IOPE.pas index 68284009..46cc6a40 100644 --- a/src/fault/IOPE.pas +++ b/src/fault/IOPE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(false); BSOD('IO', 'Invalid OPCode Exception.'); console.writestringln('Invalid OPCode Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/MCE.pas b/src/fault/MCE.pas index 27972174..1e37dca5 100644 --- a/src/fault/MCE.pas +++ b/src/fault/MCE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(false); BSOD('MC', 'Machine Check Exception.'); console.writestringln('Machine Check Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/NCE.pas b/src/fault/NCE.pas index e7858633..8740ec1a 100644 --- a/src/fault/NCE.pas +++ b/src/fault/NCE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(false); BSOD('NC', 'No Coprocessor Exception.'); console.writestringln('No Coprocessor Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/NMIE.pas b/src/fault/NMIE.pas index 93e3ba5d..bf4ea0f6 100644 --- a/src/fault/NMIE.pas +++ b/src/fault/NMIE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(false); BSOD('NMI', 'Non-Maskable Interrupt Exception.'); console.writestringln('NMI Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/OOBE.pas b/src/fault/OOBE.pas index 3aeb5c93..d1314127 100644 --- a/src/fault/OOBE.pas +++ b/src/fault/OOBE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(false); BSOD('OOB', 'Out of Bouunds Exception.'); console.writestringln('OOB Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/PF.pas b/src/fault/PF.pas index e9f78f89..c03b5323 100644 --- a/src/fault/PF.pas +++ b/src/fault/PF.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(true); BSOD('PF', 'Page Fault.'); console.writestringln('Page Fault.'); util.halt_and_catch_fire; diff --git a/src/fault/SFE.pas b/src/fault/SFE.pas index 51949fe6..f5b55ed9 100644 --- a/src/fault/SFE.pas +++ b/src/fault/SFE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(true); BSOD('SF', 'Stack Fault Exception.'); console.writestringln('Stack Fault Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/SNPE.pas b/src/fault/SNPE.pas index 9cd63d7a..f040c7b6 100644 --- a/src/fault/SNPE.pas +++ b/src/fault/SNPE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(true); BSOD('SNS', 'Segment Not Present Exception.'); console.writestringln('Segment Not Present Exception.'); util.halt_and_catch_fire; diff --git a/src/fault/UIE.pas b/src/fault/UIE.pas index 1ffff7bd..6f51a83a 100644 --- a/src/fault/UIE.pas +++ b/src/fault/UIE.pas @@ -24,6 +24,7 @@ var begin CLI; + correctInterruptRegisters(false); BSOD('UI', 'Unknown Interrupt Exception.'); console.writestringln('Unknown Interrupt Exception.'); util.halt_and_catch_fire; diff --git a/src/include/util.pas b/src/include/util.pas index b34a737c..dd8ca2bd 100644 --- a/src/include/util.pas +++ b/src/include/util.pas @@ -73,7 +73,7 @@ var implementation uses - console, RTC, cpu, serial, strings; + console, RTC, cpu, serial, strings, isr_types; function MsSinceSystemBoot : uint64; begin @@ -580,12 +580,21 @@ begin console.writestring(' Fault Info: '); console.writestringln(info); console.writestringln(' '); + if IntReg <> nil then begin + console.writestringln(' Processor Info: '); + console.writestring(' EBP: '); console.writehex(IntReg^.EBP); console.writestring(' EAX: '); console.writehex(IntReg^.EAX); console.writestring(' EBX: '); console.writehexln(IntReg^.EBX); + console.writestring(' ECX: '); console.writehex(IntReg^.ECX); console.writestring(' EDX: '); console.writehex(IntReg^.EDX); console.writestring(' ESI: '); console.writehexln(IntReg^.ESI); + console.writestring(' EDI: '); console.writehex(IntReg^.EDI); console.writestring(' DS: '); console.writehex(IntReg^.DS); console.writestring(' ES: '); console.writehexln(IntReg^.ES); + console.writestring(' FS: '); console.writehex(IntReg^.FS); console.writestring(' GS: '); console.writehex(IntReg^.GS); console.writestring(' ERROR: '); console.writehexln(IntErr^.Error); + console.writestring(' EIP: '); console.writehex(IntSpec^.EIP); console.writestring(' CS: '); console.writehex(IntSpec^.CS); console.writestring(' EFLAGS: '); console.writehexln(IntSpec^.EFLAGS); + console.writestringln(' '); + end; console.writestring(' Call Stack: '); trace:= tracer.get_last_trace; if trace <> nil then begin console.writestring('[-0] '); console.writestringln(trace); - for i:=1 to tracer.get_trace_count-1 do begin + for i:=1 to tracer.get_trace_count-7 do begin trace:= tracer.get_trace_N(i); if trace <> nil then begin console.writestring(' ['); diff --git a/src/isr/isr_types.pas b/src/isr/isr_types.pas index cce53100..e1e6ab05 100644 --- a/src/isr/isr_types.pas +++ b/src/isr/isr_types.pas @@ -12,6 +12,33 @@ const MAX_HOOKS = 16; type + TInterruptRegisters = packed record + EBP : uint32; + EAX : uint32; + EBX : uint32; + ECX : uint32; + EDX : uint32; + ESI : uint32; + EDI : uint32; + DS : uint32; + ES : uint32; + FS : uint32; + GS : uint32; + end; + PInterruptRegisters = ^TInterruptRegisters; + + TError = packed record + Error : uint32; + end; + PError = ^TError; + + TInterruptSpecialRegisters = packed record + EIP : uint32; + CS : uint32; + EFLAGS : uint32; + end; + PInterruptSpecialRegisters = ^TInterruptSpecialRegisters; + PRegisters = ^TRegisters; TRegisters = record edi,esi,ebp,esp,ebx,edx,ecx,eax: uint32; @@ -22,6 +49,27 @@ type pp_hook_method = procedure(data : void); pp_void = pp_hook_method; +var + IntReg : PInterruptRegisters = nil; + IntSpec : PInterruptSpecialRegisters = nil; + IntErr : PError = nil; + ZeroError : uint32 = 0; + +procedure correctInterruptRegisters(Errorcode : boolean); + implementation +procedure correctInterruptRegisters(Errorcode : boolean); +begin + if IntReg <> nil then begin + If errorcode then begin + IntSpec:= PInterruptSpecialRegisters(uint32(IntReg) + uint32(SizeOf(TInterruptRegisters)) + uint32(Sizeof(TError))); + IntErr:= PError(uint32(IntReg) + uint32(sizeof(TInterruptRegisters))); + end else begin + IntSpec:= PInterruptSpecialRegisters(uint32(IntReg) + uint32(SizeOf(TInterruptRegisters))); + IntErr:= PError(@ZeroError); + end; + end; +end; + end. \ No newline at end of file diff --git a/src/isr/isrmanager.pas b/src/isr/isrmanager.pas index 60e16f2c..f8822d20 100644 --- a/src/isr/isrmanager.pas +++ b/src/isr/isrmanager.pas @@ -50,1283 +50,2050 @@ begin end; procedure ISR_0; interrupt; -begin - ISR_N(0); +begin + asm + MOV IntReg, EBP + end; + ISR_N(0); end; procedure ISR_1; interrupt; begin - ISR_N(1); + asm + MOV IntReg, EBP + end; + ISR_N(1); end; procedure ISR_2; interrupt; begin - ISR_N(2); + asm + MOV IntReg, EBP + end; + ISR_N(2); end; procedure ISR_3; interrupt; begin - ISR_N(3); + asm + MOV IntReg, EBP end; + ISR_N(3); end; procedure ISR_4; interrupt; begin - ISR_N(4); + asm + MOV IntReg, EBP + end; + ISR_N(4); end; procedure ISR_5; interrupt; begin - ISR_N(5); + asm + MOV IntReg, EBP + end; + ISR_N(5); end; procedure ISR_6; interrupt; begin - ISR_N(6); + asm + MOV IntReg, EBP + end; + ISR_N(6); end; procedure ISR_7; interrupt; begin - ISR_N(7); + asm + MOV IntReg, EBP + end; + ISR_N(7); end; procedure ISR_8; interrupt; begin - ISR_N(8); + asm + MOV IntReg, EBP + end; + ISR_N(8); end; procedure ISR_9; interrupt; begin - ISR_N(9); + asm + MOV IntReg, EBP + end; + ISR_N(9); end; procedure ISR_10; interrupt; begin - ISR_N(10); + asm + MOV IntReg, EBP + end; + ISR_N(10); end; procedure ISR_11; interrupt; begin - ISR_N(11); + asm + MOV IntReg, EBP + end; + ISR_N(11); end; procedure ISR_12; interrupt; begin - ISR_N(12); + asm + MOV IntReg, EBP + end; + ISR_N(12); end; procedure ISR_13; interrupt; begin - ISR_N(13); + asm + MOV IntReg, EBP + end; + ISR_N(13); end; procedure ISR_14; interrupt; begin - ISR_N(14); + asm + MOV IntReg, EBP + end; + ISR_N(14); end; procedure ISR_15; interrupt; begin - ISR_N(15); + asm + MOV IntReg, EBP + end; + ISR_N(15); end; procedure ISR_16; interrupt; begin - ISR_N(16); + asm + MOV IntReg, EBP + end; + ISR_N(16); end; procedure ISR_17; interrupt; begin - ISR_N(17); + asm + MOV IntReg, EBP + end; + ISR_N(17); end; procedure ISR_18; interrupt; begin - ISR_N(18); + asm + MOV IntReg, EBP + end; + ISR_N(18); end; procedure ISR_19; interrupt; begin - ISR_N(19); + asm + MOV IntReg, EBP + end; + ISR_N(19); end; procedure ISR_20; interrupt; begin - ISR_N(20); + asm + MOV IntReg, EBP + end; + ISR_N(20); end; procedure ISR_21; interrupt; begin - ISR_N(21); + asm + MOV IntReg, EBP + end; + ISR_N(21); end; procedure ISR_22; interrupt; begin - ISR_N(22); + asm + MOV IntReg, EBP + end; + ISR_N(22); end; procedure ISR_23; interrupt; begin - ISR_N(23); + asm + MOV IntReg, EBP + end; + ISR_N(23); end; procedure ISR_24; interrupt; begin - ISR_N(24); + asm + MOV IntReg, EBP + end; + ISR_N(24); end; procedure ISR_25; interrupt; begin - ISR_N(25); + asm + MOV IntReg, EBP + end; + ISR_N(25); end; procedure ISR_26; interrupt; begin - ISR_N(26); + asm + MOV IntReg, EBP + end; + ISR_N(26); end; procedure ISR_27; interrupt; begin - ISR_N(27); + asm + MOV IntReg, EBP + end; + ISR_N(27); end; procedure ISR_28; interrupt; begin - ISR_N(28); + asm + MOV IntReg, EBP + end; + ISR_N(28); end; procedure ISR_29; interrupt; begin - ISR_N(29); + asm + MOV IntReg, EBP + end; + ISR_N(29); end; procedure ISR_30; interrupt; begin - ISR_N(30); + asm + MOV IntReg, EBP + end; + ISR_N(30); end; procedure ISR_31; interrupt; begin - ISR_N(31); + asm + MOV IntReg, EBP + end; + ISR_N(31); end; procedure ISR_32; interrupt; begin - ISR_N(32); + asm + MOV IntReg, EBP + end; + ISR_N(32); end; procedure ISR_33; interrupt; begin - ISR_N(33); + asm + MOV IntReg, EBP + end; + ISR_N(33); end; procedure ISR_34; interrupt; begin - ISR_N(34); + asm + MOV IntReg, EBP + end; + ISR_N(34); end; procedure ISR_35; interrupt; begin - ISR_N(35); + asm + MOV IntReg, EBP + end; + ISR_N(35); end; procedure ISR_36; interrupt; begin - ISR_N(36); + asm + MOV IntReg, EBP + end; + ISR_N(36); end; procedure ISR_37; interrupt; begin - ISR_N(37); + asm + MOV IntReg, EBP + end; + ISR_N(37); end; procedure ISR_38; interrupt; begin - ISR_N(38); + asm + MOV IntReg, EBP + end; + ISR_N(38); end; procedure ISR_39; interrupt; begin - ISR_N(39); + asm + MOV IntReg, EBP + end; + ISR_N(39); end; procedure ISR_40; interrupt; begin - ISR_N(40); + asm + MOV IntReg, EBP + end; + ISR_N(40); end; procedure ISR_41; interrupt; begin - ISR_N(41); + asm + MOV IntReg, EBP + end; + ISR_N(41); end; procedure ISR_42; interrupt; begin - ISR_N(42); + asm + MOV IntReg, EBP + end; + ISR_N(42); end; procedure ISR_43; interrupt; begin - ISR_N(43); + asm + MOV IntReg, EBP + end; + ISR_N(43); end; procedure ISR_44; interrupt; begin - ISR_N(44); + asm + MOV IntReg, EBP + end; + ISR_N(44); end; procedure ISR_45; interrupt; begin - ISR_N(45); + asm + MOV IntReg, EBP + end; + ISR_N(45); end; procedure ISR_46; interrupt; begin - ISR_N(46); + asm + MOV IntReg, EBP + end; + ISR_N(46); end; procedure ISR_47; interrupt; begin - ISR_N(47); + asm + MOV IntReg, EBP + end; + ISR_N(47); end; procedure ISR_48; interrupt; begin - ISR_N(48); + asm + MOV IntReg, EBP + end; + ISR_N(48); end; procedure ISR_49; interrupt; begin - ISR_N(49); + asm + MOV IntReg, EBP + end; + ISR_N(49); end; procedure ISR_50; interrupt; begin - ISR_N(50); + asm + MOV IntReg, EBP + end; + ISR_N(50); end; procedure ISR_51; interrupt; begin - ISR_N(51); + asm + MOV IntReg, EBP + end; + ISR_N(51); end; procedure ISR_52; interrupt; begin - ISR_N(52); + asm + MOV IntReg, EBP + end; + ISR_N(52); end; procedure ISR_53; interrupt; begin - ISR_N(53); + asm + MOV IntReg, EBP + end; + ISR_N(53); end; procedure ISR_54; interrupt; begin - ISR_N(54); + asm + MOV IntReg, EBP + end; + ISR_N(54); end; procedure ISR_55; interrupt; begin - ISR_N(55); + asm + MOV IntReg, EBP + end; + ISR_N(55); end; procedure ISR_56; interrupt; begin - ISR_N(56); + asm + MOV IntReg, EBP + end; + ISR_N(56); end; procedure ISR_57; interrupt; begin - ISR_N(57); + asm + MOV IntReg, EBP + end; + ISR_N(57); end; procedure ISR_58; interrupt; begin - ISR_N(58); + asm + MOV IntReg, EBP + end; + ISR_N(58); end; procedure ISR_59; interrupt; begin - ISR_N(59); + asm + MOV IntReg, EBP + end; + ISR_N(59); end; procedure ISR_60; interrupt; begin - ISR_N(60); + asm + MOV IntReg, EBP + end; + ISR_N(60); end; procedure ISR_61; interrupt; begin - ISR_N(61); + asm + MOV IntReg, EBP + end; + ISR_N(61); end; procedure ISR_62; interrupt; begin - ISR_N(62); + asm + MOV IntReg, EBP + end; + ISR_N(62); end; procedure ISR_63; interrupt; begin - ISR_N(63); + asm + MOV IntReg, EBP + end; + ISR_N(63); end; procedure ISR_64; interrupt; begin - ISR_N(64); + asm + MOV IntReg, EBP + end; + ISR_N(64); end; procedure ISR_65; interrupt; begin - ISR_N(65); + asm + MOV IntReg, EBP + end; + ISR_N(65); end; procedure ISR_66; interrupt; begin - ISR_N(66); + asm + MOV IntReg, EBP + end; + ISR_N(66); end; procedure ISR_67; interrupt; begin - ISR_N(67); + asm + MOV IntReg, EBP + end; + ISR_N(67); end; procedure ISR_68; interrupt; begin - ISR_N(68); + asm + MOV IntReg, EBP + end; + ISR_N(68); end; procedure ISR_69; interrupt; begin - ISR_N(69); + asm + MOV IntReg, EBP + end; + ISR_N(69); end; procedure ISR_70; interrupt; begin - ISR_N(70); + asm + MOV IntReg, EBP + end; + ISR_N(70); end; procedure ISR_71; interrupt; begin - ISR_N(71); + asm + MOV IntReg, EBP + end; + ISR_N(71); end; procedure ISR_72; interrupt; begin - ISR_N(72); + asm + MOV IntReg, EBP + end; + ISR_N(72); end; procedure ISR_73; interrupt; begin - ISR_N(73); + asm + MOV IntReg, EBP + end; + ISR_N(73); end; procedure ISR_74; interrupt; begin - ISR_N(74); + asm + MOV IntReg, EBP + end; + ISR_N(74); end; procedure ISR_75; interrupt; begin - ISR_N(75); + asm + MOV IntReg, EBP + end; + ISR_N(75); end; procedure ISR_76; interrupt; begin - ISR_N(76); + asm + MOV IntReg, EBP + end; + ISR_N(76); end; procedure ISR_77; interrupt; begin - ISR_N(77); + asm + MOV IntReg, EBP + end; + ISR_N(77); end; procedure ISR_78; interrupt; begin - ISR_N(78); + asm + MOV IntReg, EBP + end; + ISR_N(78); end; procedure ISR_79; interrupt; begin - ISR_N(79); + asm + MOV IntReg, EBP + end; + ISR_N(79); end; procedure ISR_80; interrupt; begin - ISR_N(80); + asm + MOV IntReg, EBP + end; + ISR_N(80); end; procedure ISR_81; interrupt; begin - ISR_N(81); + asm + MOV IntReg, EBP + end; + ISR_N(81); end; procedure ISR_82; interrupt; begin - ISR_N(82); + asm + MOV IntReg, EBP + end; + ISR_N(82); end; procedure ISR_83; interrupt; begin - ISR_N(83); + asm + MOV IntReg, EBP + end; + ISR_N(83); end; procedure ISR_84; interrupt; begin - ISR_N(84); + asm + MOV IntReg, EBP + end; + ISR_N(84); end; procedure ISR_85; interrupt; begin - ISR_N(85); + asm + MOV IntReg, EBP + end; + ISR_N(85); end; procedure ISR_86; interrupt; begin - ISR_N(86); + asm + MOV IntReg, EBP + end; + ISR_N(86); end; procedure ISR_87; interrupt; begin - ISR_N(87); + asm + MOV IntReg, EBP + end; + ISR_N(87); end; procedure ISR_88; interrupt; begin - ISR_N(88); + asm + MOV IntReg, EBP + end; + ISR_N(88); end; procedure ISR_89; interrupt; begin - ISR_N(89); + asm + MOV IntReg, EBP + end; + ISR_N(89); end; procedure ISR_90; interrupt; begin - ISR_N(90); + asm + MOV IntReg, EBP + end; + ISR_N(90); end; procedure ISR_91; interrupt; begin - ISR_N(91); + asm + MOV IntReg, EBP + end; + ISR_N(91); end; procedure ISR_92; interrupt; begin - ISR_N(92); + asm + MOV IntReg, EBP + end; + ISR_N(92); end; procedure ISR_93; interrupt; begin - ISR_N(93); + asm + MOV IntReg, EBP + end; + ISR_N(93); end; procedure ISR_94; interrupt; begin - ISR_N(94); + asm + MOV IntReg, EBP + end; + ISR_N(94); end; procedure ISR_95; interrupt; begin - ISR_N(95); + asm + MOV IntReg, EBP + end; + ISR_N(95); end; procedure ISR_96; interrupt; begin - ISR_N(96); + asm + MOV IntReg, EBP + end; + ISR_N(96); end; procedure ISR_97; interrupt; begin - ISR_N(97); + asm + MOV IntReg, EBP + end; + ISR_N(97); end; procedure ISR_98; interrupt; begin - ISR_N(98); + asm + MOV IntReg, EBP + end; + ISR_N(98); end; procedure ISR_99; interrupt; begin - ISR_N(99); + asm + MOV IntReg, EBP + end; + ISR_N(99); end; procedure ISR_100; interrupt; begin - ISR_N(100); + asm + MOV IntReg, EBP + end; + ISR_N(100); end; procedure ISR_101; interrupt; begin - ISR_N(101); + asm + MOV IntReg, EBP + end; + ISR_N(101); end; procedure ISR_102; interrupt; begin - ISR_N(102); + asm + MOV IntReg, EBP + end; + ISR_N(102); end; procedure ISR_103; interrupt; begin - ISR_N(103); + asm + MOV IntReg, EBP + end; + ISR_N(103); end; procedure ISR_104; interrupt; begin - ISR_N(104); + asm + MOV IntReg, EBP + end; + ISR_N(104); end; procedure ISR_105; interrupt; begin - ISR_N(105); + asm + MOV IntReg, EBP + end; + ISR_N(105); end; procedure ISR_106; interrupt; begin - ISR_N(106); + asm + MOV IntReg, EBP + end; + ISR_N(106); end; procedure ISR_107; interrupt; begin - ISR_N(107); + asm + MOV IntReg, EBP + end; + ISR_N(107); end; procedure ISR_108; interrupt; begin - ISR_N(108); + asm + MOV IntReg, EBP + end; + ISR_N(108); end; procedure ISR_109; interrupt; begin - ISR_N(109); + asm + MOV IntReg, EBP + end; + ISR_N(109); end; procedure ISR_110; interrupt; begin - ISR_N(110); + asm + MOV IntReg, EBP + end; + ISR_N(110); end; procedure ISR_111; interrupt; begin - ISR_N(111); + asm + MOV IntReg, EBP + end; + ISR_N(111); end; procedure ISR_112; interrupt; begin - ISR_N(112); + asm + MOV IntReg, EBP + end; + ISR_N(112); end; procedure ISR_113; interrupt; begin - ISR_N(113); + asm + MOV IntReg, EBP + end; + ISR_N(113); end; procedure ISR_114; interrupt; begin - ISR_N(114); + asm + MOV IntReg, EBP + end; + ISR_N(114); end; procedure ISR_115; interrupt; begin - ISR_N(115); + asm + MOV IntReg, EBP + end; + ISR_N(115); end; procedure ISR_116; interrupt; begin - ISR_N(116); + asm + MOV IntReg, EBP + end; + ISR_N(116); end; procedure ISR_117; interrupt; begin - ISR_N(117); + asm + MOV IntReg, EBP + end; + ISR_N(117); end; procedure ISR_118; interrupt; begin - ISR_N(118); + asm + MOV IntReg, EBP + end; + ISR_N(118); end; procedure ISR_119; interrupt; begin - ISR_N(119); + asm + MOV IntReg, EBP + end; + ISR_N(119); end; procedure ISR_120; interrupt; begin - ISR_N(120); + asm + MOV IntReg, EBP + end; + ISR_N(120); end; procedure ISR_121; interrupt; begin - ISR_N(121); + asm + MOV IntReg, EBP + end; + ISR_N(121); end; procedure ISR_122; interrupt; begin - ISR_N(122); + asm + MOV IntReg, EBP + end; + ISR_N(122); end; procedure ISR_123; interrupt; begin - ISR_N(123); + asm + MOV IntReg, EBP + end; + ISR_N(123); end; procedure ISR_124; interrupt; begin - ISR_N(124); + asm + MOV IntReg, EBP + end; + ISR_N(124); end; procedure ISR_125; interrupt; begin - ISR_N(125); + asm + MOV IntReg, EBP + end; + ISR_N(125); end; procedure ISR_126; interrupt; begin - ISR_N(126); + asm + MOV IntReg, EBP + end; + ISR_N(126); end; procedure ISR_127; interrupt; begin - ISR_N(127); + asm + MOV IntReg, EBP + end; + ISR_N(127); end; procedure ISR_128; interrupt; begin - ISR_N(128); + asm + MOV IntReg, EBP + end; + ISR_N(128); end; procedure ISR_129; interrupt; begin - ISR_N(129); + asm + MOV IntReg, EBP + end; + ISR_N(129); end; procedure ISR_130; interrupt; begin - ISR_N(130); + asm + MOV IntReg, EBP + end; + ISR_N(130); end; procedure ISR_131; interrupt; begin - ISR_N(131); + asm + MOV IntReg, EBP + end; + ISR_N(131); end; procedure ISR_132; interrupt; begin - ISR_N(132); + asm + MOV IntReg, EBP + end; + ISR_N(132); end; procedure ISR_133; interrupt; begin - ISR_N(133); + asm + MOV IntReg, EBP + end; + ISR_N(133); end; procedure ISR_134; interrupt; begin - ISR_N(134); + asm + MOV IntReg, EBP + end; + ISR_N(134); end; procedure ISR_135; interrupt; begin - ISR_N(135); + asm + MOV IntReg, EBP + end; + ISR_N(135); end; procedure ISR_136; interrupt; begin - ISR_N(136); + asm + MOV IntReg, EBP + end; + ISR_N(136); end; procedure ISR_137; interrupt; begin - ISR_N(137); + asm + MOV IntReg, EBP + end; + ISR_N(137); end; procedure ISR_138; interrupt; begin - ISR_N(138); + asm + MOV IntReg, EBP + end; + ISR_N(138); end; procedure ISR_139; interrupt; begin - ISR_N(139); + asm + MOV IntReg, EBP + end; + ISR_N(139); end; procedure ISR_140; interrupt; begin - ISR_N(140); + asm + MOV IntReg, EBP + end; + ISR_N(140); end; procedure ISR_141; interrupt; begin - ISR_N(141); + asm + MOV IntReg, EBP + end; + ISR_N(141); end; procedure ISR_142; interrupt; begin - ISR_N(142); + asm + MOV IntReg, EBP + end; + ISR_N(142); end; procedure ISR_143; interrupt; begin - ISR_N(143); + asm + MOV IntReg, EBP + end; + ISR_N(143); end; procedure ISR_144; interrupt; begin - ISR_N(144); + asm + MOV IntReg, EBP + end; + ISR_N(144); end; procedure ISR_145; interrupt; begin - ISR_N(145); + asm + MOV IntReg, EBP + end; + ISR_N(145); end; procedure ISR_146; interrupt; begin - ISR_N(146); + asm + MOV IntReg, EBP + end; + ISR_N(146); end; procedure ISR_147; interrupt; begin - ISR_N(147); + asm + MOV IntReg, EBP + end; + ISR_N(147); end; procedure ISR_148; interrupt; begin - ISR_N(148); + asm + MOV IntReg, EBP + end; + ISR_N(148); end; procedure ISR_149; interrupt; begin - ISR_N(149); + asm + MOV IntReg, EBP + end; + ISR_N(149); end; procedure ISR_150; interrupt; begin - ISR_N(150); + asm + MOV IntReg, EBP + end; + ISR_N(150); end; procedure ISR_151; interrupt; begin - ISR_N(151); + asm + MOV IntReg, EBP + end; + ISR_N(151); end; procedure ISR_152; interrupt; begin - ISR_N(152); + asm + MOV IntReg, EBP + end; + ISR_N(152); end; procedure ISR_153; interrupt; begin - ISR_N(153); + asm + MOV IntReg, EBP + end; + ISR_N(153); end; procedure ISR_154; interrupt; begin - ISR_N(154); + asm + MOV IntReg, EBP + end; + ISR_N(154); end; procedure ISR_155; interrupt; begin - ISR_N(155); + asm + MOV IntReg, EBP + end; + ISR_N(155); end; procedure ISR_156; interrupt; begin - ISR_N(156); + asm + MOV IntReg, EBP + end; + ISR_N(156); end; procedure ISR_157; interrupt; begin - ISR_N(157); + asm + MOV IntReg, EBP + end; + ISR_N(157); end; procedure ISR_158; interrupt; begin - ISR_N(158); + asm + MOV IntReg, EBP + end; + ISR_N(158); end; procedure ISR_159; interrupt; begin - ISR_N(159); + asm + MOV IntReg, EBP + end; + ISR_N(159); end; procedure ISR_160; interrupt; begin - ISR_N(160); + asm + MOV IntReg, EBP + end; + ISR_N(160); end; procedure ISR_161; interrupt; begin - ISR_N(161); + asm + MOV IntReg, EBP + end; + ISR_N(161); end; procedure ISR_162; interrupt; begin - ISR_N(162); + asm + MOV IntReg, EBP + end; + ISR_N(162); end; procedure ISR_163; interrupt; begin - ISR_N(163); + asm + MOV IntReg, EBP + end; + ISR_N(163); end; procedure ISR_164; interrupt; begin - ISR_N(164); + asm + MOV IntReg, EBP + end; + ISR_N(164); end; procedure ISR_165; interrupt; begin - ISR_N(165); + asm + MOV IntReg, EBP + end; + ISR_N(165); end; procedure ISR_166; interrupt; begin - ISR_N(166); + asm + MOV IntReg, EBP + end; + ISR_N(166); end; procedure ISR_167; interrupt; begin - ISR_N(167); + asm + MOV IntReg, EBP + end; + ISR_N(167); end; procedure ISR_168; interrupt; begin - ISR_N(168); + asm + MOV IntReg, EBP + end; + ISR_N(168); end; procedure ISR_169; interrupt; begin - ISR_N(169); + asm + MOV IntReg, EBP + end; + ISR_N(169); end; procedure ISR_170; interrupt; begin - ISR_N(170); + asm + MOV IntReg, EBP + end; + ISR_N(170); end; procedure ISR_171; interrupt; begin - ISR_N(171); + asm + MOV IntReg, EBP + end; + ISR_N(171); end; procedure ISR_172; interrupt; begin - ISR_N(172); + asm + MOV IntReg, EBP + end; + ISR_N(172); end; procedure ISR_173; interrupt; begin - ISR_N(173); + asm + MOV IntReg, EBP + end; + ISR_N(173); end; procedure ISR_174; interrupt; begin - ISR_N(174); + asm + MOV IntReg, EBP + end; + ISR_N(174); end; procedure ISR_175; interrupt; begin - ISR_N(175); + asm + MOV IntReg, EBP + end; + ISR_N(175); end; procedure ISR_176; interrupt; begin - ISR_N(176); + asm + MOV IntReg, EBP + end; + ISR_N(176); end; procedure ISR_177; interrupt; begin - ISR_N(177); + asm + MOV IntReg, EBP + end; + ISR_N(177); end; procedure ISR_178; interrupt; begin - ISR_N(178); + asm + MOV IntReg, EBP + end; + ISR_N(178); end; procedure ISR_179; interrupt; begin - ISR_N(179); + asm + MOV IntReg, EBP + end; + ISR_N(179); end; procedure ISR_180; interrupt; begin - ISR_N(180); + asm + MOV IntReg, EBP + end; + ISR_N(180); end; procedure ISR_181; interrupt; begin - ISR_N(181); + asm + MOV IntReg, EBP + end; + ISR_N(181); end; procedure ISR_182; interrupt; begin - ISR_N(182); + asm + MOV IntReg, EBP + end; + ISR_N(182); end; procedure ISR_183; interrupt; begin - ISR_N(183); + asm + MOV IntReg, EBP + end; + ISR_N(183); end; procedure ISR_184; interrupt; begin - ISR_N(184); + asm + MOV IntReg, EBP + end; + ISR_N(184); end; procedure ISR_185; interrupt; begin - ISR_N(185); + asm + MOV IntReg, EBP + end; + ISR_N(185); end; procedure ISR_186; interrupt; begin - ISR_N(186); + asm + MOV IntReg, EBP + end; + ISR_N(186); end; procedure ISR_187; interrupt; begin - ISR_N(187); + asm + MOV IntReg, EBP + end; + ISR_N(187); end; procedure ISR_188; interrupt; begin - ISR_N(188); + asm + MOV IntReg, EBP + end; + ISR_N(188); end; procedure ISR_189; interrupt; begin - ISR_N(189); + asm + MOV IntReg, EBP + end; + ISR_N(189); end; procedure ISR_190; interrupt; begin - ISR_N(190); + asm + MOV IntReg, EBP + end; + ISR_N(190); end; procedure ISR_191; interrupt; begin - ISR_N(191); + asm + MOV IntReg, EBP + end; + ISR_N(191); end; procedure ISR_192; interrupt; begin - ISR_N(192); + asm + MOV IntReg, EBP + end; + ISR_N(192); end; procedure ISR_193; interrupt; begin - ISR_N(193); + asm + MOV IntReg, EBP + end; + ISR_N(193); end; procedure ISR_194; interrupt; begin - ISR_N(194); + asm + MOV IntReg, EBP + end; + ISR_N(194); end; procedure ISR_195; interrupt; begin - ISR_N(195); + asm + MOV IntReg, EBP + end; + ISR_N(195); end; procedure ISR_196; interrupt; begin - ISR_N(196); + asm + MOV IntReg, EBP + end; + ISR_N(196); end; procedure ISR_197; interrupt; begin - ISR_N(197); + asm + MOV IntReg, EBP + end; + ISR_N(197); end; procedure ISR_198; interrupt; begin - ISR_N(198); + asm + MOV IntReg, EBP + end; + ISR_N(198); end; procedure ISR_199; interrupt; begin - ISR_N(199); + asm + MOV IntReg, EBP + end; + ISR_N(199); end; procedure ISR_200; interrupt; begin - ISR_N(200); + asm + MOV IntReg, EBP + end; + ISR_N(200); end; procedure ISR_201; interrupt; begin - ISR_N(201); + asm + MOV IntReg, EBP + end; + ISR_N(201); end; procedure ISR_202; interrupt; begin - ISR_N(202); + asm + MOV IntReg, EBP + end; + ISR_N(202); end; procedure ISR_203; interrupt; begin - ISR_N(203); + asm + MOV IntReg, EBP + end; + ISR_N(203); end; procedure ISR_204; interrupt; begin - ISR_N(204); + asm + MOV IntReg, EBP + end; + ISR_N(204); end; procedure ISR_205; interrupt; begin - ISR_N(205); + asm + MOV IntReg, EBP + end; + ISR_N(205); end; procedure ISR_206; interrupt; begin - ISR_N(206); + asm + MOV IntReg, EBP + end; + ISR_N(206); end; procedure ISR_207; interrupt; begin - ISR_N(207); + asm + MOV IntReg, EBP + end; + ISR_N(207); end; procedure ISR_208; interrupt; begin - ISR_N(208); + asm + MOV IntReg, EBP + end; + ISR_N(208); end; procedure ISR_209; interrupt; begin - ISR_N(209); + asm + MOV IntReg, EBP + end; + ISR_N(209); end; procedure ISR_210; interrupt; begin - ISR_N(210); + asm + MOV IntReg, EBP + end; + ISR_N(210); end; procedure ISR_211; interrupt; begin - ISR_N(211); + asm + MOV IntReg, EBP + end; + ISR_N(211); end; procedure ISR_212; interrupt; begin - ISR_N(212); + asm + MOV IntReg, EBP + end; + ISR_N(212); end; procedure ISR_213; interrupt; begin - ISR_N(213); + asm + MOV IntReg, EBP + end; + ISR_N(213); end; procedure ISR_214; interrupt; begin - ISR_N(214); + asm + MOV IntReg, EBP + end; + ISR_N(214); end; procedure ISR_215; interrupt; begin - ISR_N(215); + asm + MOV IntReg, EBP + end; + ISR_N(215); end; procedure ISR_216; interrupt; begin - ISR_N(216); + asm + MOV IntReg, EBP + end; + ISR_N(216); end; procedure ISR_217; interrupt; begin - ISR_N(217); + asm + MOV IntReg, EBP + end; + ISR_N(217); end; procedure ISR_218; interrupt; begin - ISR_N(218); + asm + MOV IntReg, EBP + end; + ISR_N(218); end; procedure ISR_219; interrupt; begin - ISR_N(219); + asm + MOV IntReg, EBP + end; + ISR_N(219); end; procedure ISR_220; interrupt; begin - ISR_N(220); + asm + MOV IntReg, EBP + end; + ISR_N(220); end; procedure ISR_221; interrupt; begin - ISR_N(221); + asm + MOV IntReg, EBP + end; + ISR_N(221); end; procedure ISR_222; interrupt; begin - ISR_N(222); + asm + MOV IntReg, EBP + end; + ISR_N(222); end; procedure ISR_223; interrupt; begin - ISR_N(223); + asm + MOV IntReg, EBP + end; + ISR_N(223); end; procedure ISR_224; interrupt; begin - ISR_N(224); + asm + MOV IntReg, EBP + end; + ISR_N(224); end; procedure ISR_225; interrupt; begin - ISR_N(225); + asm + MOV IntReg, EBP + end; + ISR_N(225); end; procedure ISR_226; interrupt; begin - ISR_N(226); + asm + MOV IntReg, EBP + end; + ISR_N(226); end; procedure ISR_227; interrupt; begin - ISR_N(227); + asm + MOV IntReg, EBP + end; + ISR_N(227); end; procedure ISR_228; interrupt; begin - ISR_N(228); + asm + MOV IntReg, EBP + end; + ISR_N(228); end; procedure ISR_229; interrupt; begin - ISR_N(229); + asm + MOV IntReg, EBP + end; + ISR_N(229); end; procedure ISR_230; interrupt; begin - ISR_N(230); + asm + MOV IntReg, EBP + end; + ISR_N(230); end; procedure ISR_231; interrupt; begin - ISR_N(231); + asm + MOV IntReg, EBP + end; + ISR_N(231); end; procedure ISR_232; interrupt; begin - ISR_N(232); + asm + MOV IntReg, EBP + end; + ISR_N(232); end; procedure ISR_233; interrupt; begin - ISR_N(233); + asm + MOV IntReg, EBP + end; + ISR_N(233); end; procedure ISR_234; interrupt; begin - ISR_N(234); + asm + MOV IntReg, EBP + end; + ISR_N(234); end; procedure ISR_235; interrupt; begin - ISR_N(235); + asm + MOV IntReg, EBP + end; + ISR_N(235); end; procedure ISR_236; interrupt; begin - ISR_N(236); + asm + MOV IntReg, EBP + end; + ISR_N(236); end; procedure ISR_237; interrupt; begin - ISR_N(237); + asm + MOV IntReg, EBP + end; + ISR_N(237); end; procedure ISR_238; interrupt; begin - ISR_N(238); + asm + MOV IntReg, EBP + end; + ISR_N(238); end; procedure ISR_239; interrupt; begin - ISR_N(239); + asm + MOV IntReg, EBP + end; + ISR_N(239); end; procedure ISR_240; interrupt; begin - ISR_N(240); + asm + MOV IntReg, EBP + end; + ISR_N(240); end; procedure ISR_241; interrupt; begin - ISR_N(241); + asm + MOV IntReg, EBP + end; + ISR_N(241); end; procedure ISR_242; interrupt; begin - ISR_N(242); + asm + MOV IntReg, EBP + end; + ISR_N(242); end; procedure ISR_243; interrupt; begin - ISR_N(243); + asm + MOV IntReg, EBP + end; + ISR_N(243); end; procedure ISR_244; interrupt; begin - ISR_N(244); + asm + MOV IntReg, EBP + end; + ISR_N(244); end; procedure ISR_245; interrupt; begin - ISR_N(245); + asm + MOV IntReg, EBP + end; + ISR_N(245); end; procedure ISR_246; interrupt; begin - ISR_N(246); + asm + MOV IntReg, EBP + end; + ISR_N(246); end; procedure ISR_247; interrupt; begin - ISR_N(247); + asm + MOV IntReg, EBP + end; + ISR_N(247); end; procedure ISR_248; interrupt; begin - ISR_N(248); + asm + MOV IntReg, EBP + end; + ISR_N(248); end; procedure ISR_249; interrupt; begin - ISR_N(249); + asm + MOV IntReg, EBP + end; + ISR_N(249); end; procedure ISR_250; interrupt; begin - ISR_N(250); + asm + MOV IntReg, EBP + end; + ISR_N(250); end; procedure ISR_251; interrupt; begin - ISR_N(251); + asm + MOV IntReg, EBP + end; + ISR_N(251); end; procedure ISR_252; interrupt; begin - ISR_N(252); + asm + MOV IntReg, EBP + end; + ISR_N(252); end; procedure ISR_253; interrupt; begin - ISR_N(253); + asm + MOV IntReg, EBP + end; + ISR_N(253); end; procedure ISR_254; interrupt; begin - ISR_N(254); + asm + MOV IntReg, EBP + end; + ISR_N(254); end; procedure ISR_255; interrupt; begin - ISR_N(255); + asm + MOV IntReg, EBP + end; + ISR_N(255); end; procedure init; diff --git a/src/kernel.pas b/src/kernel.pas index 09200f19..ebcdb279 100644 --- a/src/kernel.pas +++ b/src/kernel.pas @@ -202,6 +202,9 @@ begin { Filsystems } fat32.init(); + i:= 0; + i:= i div i; + { Device Drivers } tracer.push_trace('kmain.DEVDRV'); console.outputln('KERNEL', 'DEVICE DRIVERS: INIT BEGIN.'); @@ -304,6 +307,7 @@ begin // iret; // end; + while true do begin tracer.push_trace('kmain.RedrawWindows'); console.redrawWindows;