From 96b7f32ab4543c330b517dd424a8d5eff5f9a94b Mon Sep 17 00:00:00 2001 From: kieron Date: Thu, 12 Apr 2018 00:35:32 +0000 Subject: [PATCH] git-svn-id: https://spexeah.com:8443/svn/Asuro@505 6dbc8c32-bb84-406f-8558-d1cf31a0ab0c --- lib/arp.ppu | Bin 0 -> 3509 bytes lib/fat32.ppu | Bin 0 -> 7184 bytes lib/isrmanager.ppu | Bin 0 -> 58088 bytes lib/tracer.ppu | Bin 0 -> 2690 bytes src/isrmanager.pas | 1594 ++++++++++++++++++++++++++++++++++++++++++++ 5 files changed, 1594 insertions(+) create mode 100644 lib/arp.ppu create mode 100644 lib/fat32.ppu create mode 100644 lib/isrmanager.ppu create mode 100644 lib/tracer.ppu create mode 100644 src/isrmanager.pas diff --git a/lib/arp.ppu b/lib/arp.ppu new file mode 100644 index 0000000000000000000000000000000000000000..93600b72f3554467566336fd91f5a7eec1bf30f3 GIT binary patch literal 3509 zcmbVOYiv|S6rOYU(cRJ)?QVH(i(NK~E*6BM2@zwvthy@g&Gu5PXqu(H%3^6ZyO$~^ zfRTvt2O1KL2LCA0#P~`~OpJ*l8h;p#X#7EpztkT@iP88EDW;z9+&gzyD1A7aJ9GA& zGv_gL9%Gt2ZrQXsc!X3yoiUT@Sff&JzVY9DijfA+$Z;9@sU-X@912Skkdp3S${`}=1zkF%~QO_TRLa=wzV7LkY!_o2L z?hN%8adw#$;Y1bABZ-Z2_Jm{aMQzHnW4_!QnwGyFGM&ZqOS1l~vHv z5EMm8g}_Miubxzd6rVS?dH|6UECCx}c5G{`MfNbOP5fXu<# z-7zhlO|3CRWACWq!d2@P(dfxY;13s|z)<6!P{0}EmEYL_U`o6lwj^4t1`|5FKY(N*Gn=0bjoKO>0% zbF(S2T0(>S%#$GV;Kyf8HXULNrE##wJUV!e17470rgp!$R!Qz5`Nuyu2ZGnYqP;_$uaZyNVl+3NIE(8SLhA e5#7aeuxyV``B%!1LpcOiJdGko=$2Ovn)w$Rs%Mh` literal 0 HcmV?d00001 diff --git a/lib/fat32.ppu b/lib/fat32.ppu new file mode 100644 index 0000000000000000000000000000000000000000..5385716c02b617153308026dfbaf88e0b57a72a3 GIT binary patch literal 7184 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 literal 0 HcmV?d00001 diff --git a/lib/isrmanager.ppu b/lib/isrmanager.ppu new file mode 100644 index 0000000000000000000000000000000000000000..d01c1824098a728f707d82a5dc7c38b485b61f8a GIT binary patch literal 58088 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 a0yWi_h+zH$gxch#tSYvpzx*r6tN#y4M2>*~ literal 0 HcmV?d00001 diff --git a/lib/tracer.ppu b/lib/tracer.ppu new file mode 100644 index 0000000000000000000000000000000000000000..e43e8c320b64c4c432f1f36a3af442ea1563d6da GIT binary patch literal 2690 zcma)8&2Jk;6rZ=Y*I#LpCU!zgQYvGKgGCU8AW;yKlNu5*uH_F(L&0(#w^(s) z!yGUr;k2gl$Uaki^BUmU`AqR0_ouHXIwko;HFsjan`08D#KnftKeAZXF!r~2?s@N{ zi)>O3xu!M9?J?MaGI^AVkAY1KUMBNyCgpl{y&-nCytbaN+%GF+@d!Ug229g#^qQC3 zd`9M+DU!-C3_<1iK*-K9Mh$+W95(n0KU$uK5oijlOgs%XEqPOz)>AlBc4lzD+|eIm zjJ8=*4!OMuz?Bl(Sdg_n%fxeF(=!RZwhL}LFBEExV!m2)s~W7Vhy^i5=UGz@Q$fwN zv|t3PRF{c8uxZ|_)Dbte=PQN6W+8Z)`UsQ51Z_lgP(vhwb(|{Edif|7}Je7C+9~6yiuWjaGlB$9X3-@n?2F zBt+CCxlb%{MK$Rcc0p)_qR@i4XExBbf9#8bC^eD?w<;T^lv{r=|l-~T+d z{62t4w`1AXvtNAIG|!*90wikL!%pv#^~d1VmBd$X6oEnLU+hcrzSp#e(JWv&%yJ#C zt`uP#Jhy42{lB6w11#2fOm*&c7CmW3$1)~xQDmJjNyX0(en>F9-dQL&t`J&Gvep$+ zG#!zxH6yMG)>0_OCk2;3rbXOmPQBQX5{DCO60zK}vFkx`on(;Gxc?@y?vZjf<&3k9 zNxjaq#4({c{K-Y_#<1Po+Ep~`B*TuDTZb;UvR~%#J7pI8t?l-fqLfGMxx}}*#pOhE im`b9C-@&TgY;9v#OIqyPb;%#PEy nil) AND (i < MAX_HOOKS) do begin + i:= i + 1; + end; + if i <= MAX_HOOKS then begin + Hooks[INT_N][i]:= callback; + end; +end; + +procedure ISR_N(INT_N : uint8); +var + i : uint8; + +begin + for i:=0 to MAX_HOOKS do begin + if Hooks[INT_N][i] <> nil then Hooks[INT_N][i](nil); + end; + if (INT_N >= 8 + 32) then outb($A0, $20); + outb($20, $20); +end; + +procedure ISR_0; interrupt; +begin + ISR_N(0); +end; + +procedure ISR_1; interrupt; +begin + ISR_N(1); +end; + +procedure ISR_2; interrupt; +begin + ISR_N(2); +end; + +procedure ISR_3; interrupt; +begin + ISR_N(3); +end; + +procedure ISR_4; interrupt; +begin + ISR_N(4); +end; + +procedure ISR_5; interrupt; +begin + ISR_N(5); +end; + +procedure ISR_6; interrupt; +begin + ISR_N(6); +end; + +procedure ISR_7; interrupt; +begin + ISR_N(7); +end; + +procedure ISR_8; interrupt; +begin + ISR_N(8); +end; + +procedure ISR_9; interrupt; +begin + ISR_N(9); +end; + +procedure ISR_10; interrupt; +begin + ISR_N(10); +end; + +procedure ISR_11; interrupt; +begin + ISR_N(11); +end; + +procedure ISR_12; interrupt; +begin + ISR_N(12); +end; + +procedure ISR_13; interrupt; +begin + ISR_N(13); +end; + +procedure ISR_14; interrupt; +begin + ISR_N(14); +end; + +procedure ISR_15; interrupt; +begin + ISR_N(15); +end; + +procedure ISR_16; interrupt; +begin + ISR_N(16); +end; + +procedure ISR_17; interrupt; +begin + ISR_N(17); +end; + +procedure ISR_18; interrupt; +begin + ISR_N(18); +end; + +procedure ISR_19; interrupt; +begin + ISR_N(19); +end; + +procedure ISR_20; interrupt; +begin + ISR_N(20); +end; + +procedure ISR_21; interrupt; +begin + ISR_N(21); +end; + +procedure ISR_22; interrupt; +begin + ISR_N(22); +end; + +procedure ISR_23; interrupt; +begin + ISR_N(23); +end; + +procedure ISR_24; interrupt; +begin + ISR_N(24); +end; + +procedure ISR_25; interrupt; +begin + ISR_N(25); +end; + +procedure ISR_26; interrupt; +begin + ISR_N(26); +end; + +procedure ISR_27; interrupt; +begin + ISR_N(27); +end; + +procedure ISR_28; interrupt; +begin + ISR_N(28); +end; + +procedure ISR_29; interrupt; +begin + ISR_N(29); +end; + +procedure ISR_30; interrupt; +begin + ISR_N(30); +end; + +procedure ISR_31; interrupt; +begin + ISR_N(31); +end; + +procedure ISR_32; interrupt; +begin + ISR_N(32); +end; + +procedure ISR_33; interrupt; +begin + ISR_N(33); +end; + +procedure ISR_34; interrupt; +begin + ISR_N(34); +end; + +procedure ISR_35; interrupt; +begin + ISR_N(35); +end; + +procedure ISR_36; interrupt; +begin + ISR_N(36); +end; + +procedure ISR_37; interrupt; +begin + ISR_N(37); +end; + +procedure ISR_38; interrupt; +begin + ISR_N(38); +end; + +procedure ISR_39; interrupt; +begin + ISR_N(39); +end; + +procedure ISR_40; interrupt; +begin + ISR_N(40); +end; + +procedure ISR_41; interrupt; +begin + ISR_N(41); +end; + +procedure ISR_42; interrupt; +begin + ISR_N(42); +end; + +procedure ISR_43; interrupt; +begin + ISR_N(43); +end; + +procedure ISR_44; interrupt; +begin + ISR_N(44); +end; + +procedure ISR_45; interrupt; +begin + ISR_N(45); +end; + +procedure ISR_46; interrupt; +begin + ISR_N(46); +end; + +procedure ISR_47; interrupt; +begin + ISR_N(47); +end; + +procedure ISR_48; interrupt; +begin + ISR_N(48); +end; + +procedure ISR_49; interrupt; +begin + ISR_N(49); +end; + +procedure ISR_50; interrupt; +begin + ISR_N(50); +end; + +procedure ISR_51; interrupt; +begin + ISR_N(51); +end; + +procedure ISR_52; interrupt; +begin + ISR_N(52); +end; + +procedure ISR_53; interrupt; +begin + ISR_N(53); +end; + +procedure ISR_54; interrupt; +begin + ISR_N(54); +end; + +procedure ISR_55; interrupt; +begin + ISR_N(55); +end; + +procedure ISR_56; interrupt; +begin + ISR_N(56); +end; + +procedure ISR_57; interrupt; +begin + ISR_N(57); +end; + +procedure ISR_58; interrupt; +begin + ISR_N(58); +end; + +procedure ISR_59; interrupt; +begin + ISR_N(59); +end; + +procedure ISR_60; interrupt; +begin + ISR_N(60); +end; + +procedure ISR_61; interrupt; +begin + ISR_N(61); +end; + +procedure ISR_62; interrupt; +begin + ISR_N(62); +end; + +procedure ISR_63; interrupt; +begin + ISR_N(63); +end; + +procedure ISR_64; interrupt; +begin + ISR_N(64); +end; + +procedure ISR_65; interrupt; +begin + ISR_N(65); +end; + +procedure ISR_66; interrupt; +begin + ISR_N(66); +end; + +procedure ISR_67; interrupt; +begin + ISR_N(67); +end; + +procedure ISR_68; interrupt; +begin + ISR_N(68); +end; + +procedure ISR_69; interrupt; +begin + ISR_N(69); +end; + +procedure ISR_70; interrupt; +begin + ISR_N(70); +end; + +procedure ISR_71; interrupt; +begin + ISR_N(71); +end; + +procedure ISR_72; interrupt; +begin + ISR_N(72); +end; + +procedure ISR_73; interrupt; +begin + ISR_N(73); +end; + +procedure ISR_74; interrupt; +begin + ISR_N(74); +end; + +procedure ISR_75; interrupt; +begin + ISR_N(75); +end; + +procedure ISR_76; interrupt; +begin + ISR_N(76); +end; + +procedure ISR_77; interrupt; +begin + ISR_N(77); +end; + +procedure ISR_78; interrupt; +begin + ISR_N(78); +end; + +procedure ISR_79; interrupt; +begin + ISR_N(79); +end; + +procedure ISR_80; interrupt; +begin + ISR_N(80); +end; + +procedure ISR_81; interrupt; +begin + ISR_N(81); +end; + +procedure ISR_82; interrupt; +begin + ISR_N(82); +end; + +procedure ISR_83; interrupt; +begin + ISR_N(83); +end; + +procedure ISR_84; interrupt; +begin + ISR_N(84); +end; + +procedure ISR_85; interrupt; +begin + ISR_N(85); +end; + +procedure ISR_86; interrupt; +begin + ISR_N(86); +end; + +procedure ISR_87; interrupt; +begin + ISR_N(87); +end; + +procedure ISR_88; interrupt; +begin + ISR_N(88); +end; + +procedure ISR_89; interrupt; +begin + ISR_N(89); +end; + +procedure ISR_90; interrupt; +begin + ISR_N(90); +end; + +procedure ISR_91; interrupt; +begin + ISR_N(91); +end; + +procedure ISR_92; interrupt; +begin + ISR_N(92); +end; + +procedure ISR_93; interrupt; +begin + ISR_N(93); +end; + +procedure ISR_94; interrupt; +begin + ISR_N(94); +end; + +procedure ISR_95; interrupt; +begin + ISR_N(95); +end; + +procedure ISR_96; interrupt; +begin + ISR_N(96); +end; + +procedure ISR_97; interrupt; +begin + ISR_N(97); +end; + +procedure ISR_98; interrupt; +begin + ISR_N(98); +end; + +procedure ISR_99; interrupt; +begin + ISR_N(99); +end; + +procedure ISR_100; interrupt; +begin + ISR_N(100); +end; + +procedure ISR_101; interrupt; +begin + ISR_N(101); +end; + +procedure ISR_102; interrupt; +begin + ISR_N(102); +end; + +procedure ISR_103; interrupt; +begin + ISR_N(103); +end; + +procedure ISR_104; interrupt; +begin + ISR_N(104); +end; + +procedure ISR_105; interrupt; +begin + ISR_N(105); +end; + +procedure ISR_106; interrupt; +begin + ISR_N(106); +end; + +procedure ISR_107; interrupt; +begin + ISR_N(107); +end; + +procedure ISR_108; interrupt; +begin + ISR_N(108); +end; + +procedure ISR_109; interrupt; +begin + ISR_N(109); +end; + +procedure ISR_110; interrupt; +begin + ISR_N(110); +end; + +procedure ISR_111; interrupt; +begin + ISR_N(111); +end; + +procedure ISR_112; interrupt; +begin + ISR_N(112); +end; + +procedure ISR_113; interrupt; +begin + ISR_N(113); +end; + +procedure ISR_114; interrupt; +begin + ISR_N(114); +end; + +procedure ISR_115; interrupt; +begin + ISR_N(115); +end; + +procedure ISR_116; interrupt; +begin + ISR_N(116); +end; + +procedure ISR_117; interrupt; +begin + ISR_N(117); +end; + +procedure ISR_118; interrupt; +begin + ISR_N(118); +end; + +procedure ISR_119; interrupt; +begin + ISR_N(119); +end; + +procedure ISR_120; interrupt; +begin + ISR_N(120); +end; + +procedure ISR_121; interrupt; +begin + ISR_N(121); +end; + +procedure ISR_122; interrupt; +begin + ISR_N(122); +end; + +procedure ISR_123; interrupt; +begin + ISR_N(123); +end; + +procedure ISR_124; interrupt; +begin + ISR_N(124); +end; + +procedure ISR_125; interrupt; +begin + ISR_N(125); +end; + +procedure ISR_126; interrupt; +begin + ISR_N(126); +end; + +procedure ISR_127; interrupt; +begin + ISR_N(127); +end; + +procedure ISR_128; interrupt; +begin + ISR_N(128); +end; + +procedure ISR_129; interrupt; +begin + ISR_N(129); +end; + +procedure ISR_130; interrupt; +begin + ISR_N(130); +end; + +procedure ISR_131; interrupt; +begin + ISR_N(131); +end; + +procedure ISR_132; interrupt; +begin + ISR_N(132); +end; + +procedure ISR_133; interrupt; +begin + ISR_N(133); +end; + +procedure ISR_134; interrupt; +begin + ISR_N(134); +end; + +procedure ISR_135; interrupt; +begin + ISR_N(135); +end; + +procedure ISR_136; interrupt; +begin + ISR_N(136); +end; + +procedure ISR_137; interrupt; +begin + ISR_N(137); +end; + +procedure ISR_138; interrupt; +begin + ISR_N(138); +end; + +procedure ISR_139; interrupt; +begin + ISR_N(139); +end; + +procedure ISR_140; interrupt; +begin + ISR_N(140); +end; + +procedure ISR_141; interrupt; +begin + ISR_N(141); +end; + +procedure ISR_142; interrupt; +begin + ISR_N(142); +end; + +procedure ISR_143; interrupt; +begin + ISR_N(143); +end; + +procedure ISR_144; interrupt; +begin + ISR_N(144); +end; + +procedure ISR_145; interrupt; +begin + ISR_N(145); +end; + +procedure ISR_146; interrupt; +begin + ISR_N(146); +end; + +procedure ISR_147; interrupt; +begin + ISR_N(147); +end; + +procedure ISR_148; interrupt; +begin + ISR_N(148); +end; + +procedure ISR_149; interrupt; +begin + ISR_N(149); +end; + +procedure ISR_150; interrupt; +begin + ISR_N(150); +end; + +procedure ISR_151; interrupt; +begin + ISR_N(151); +end; + +procedure ISR_152; interrupt; +begin + ISR_N(152); +end; + +procedure ISR_153; interrupt; +begin + ISR_N(153); +end; + +procedure ISR_154; interrupt; +begin + ISR_N(154); +end; + +procedure ISR_155; interrupt; +begin + ISR_N(155); +end; + +procedure ISR_156; interrupt; +begin + ISR_N(156); +end; + +procedure ISR_157; interrupt; +begin + ISR_N(157); +end; + +procedure ISR_158; interrupt; +begin + ISR_N(158); +end; + +procedure ISR_159; interrupt; +begin + ISR_N(159); +end; + +procedure ISR_160; interrupt; +begin + ISR_N(160); +end; + +procedure ISR_161; interrupt; +begin + ISR_N(161); +end; + +procedure ISR_162; interrupt; +begin + ISR_N(162); +end; + +procedure ISR_163; interrupt; +begin + ISR_N(163); +end; + +procedure ISR_164; interrupt; +begin + ISR_N(164); +end; + +procedure ISR_165; interrupt; +begin + ISR_N(165); +end; + +procedure ISR_166; interrupt; +begin + ISR_N(166); +end; + +procedure ISR_167; interrupt; +begin + ISR_N(167); +end; + +procedure ISR_168; interrupt; +begin + ISR_N(168); +end; + +procedure ISR_169; interrupt; +begin + ISR_N(169); +end; + +procedure ISR_170; interrupt; +begin + ISR_N(170); +end; + +procedure ISR_171; interrupt; +begin + ISR_N(171); +end; + +procedure ISR_172; interrupt; +begin + ISR_N(172); +end; + +procedure ISR_173; interrupt; +begin + ISR_N(173); +end; + +procedure ISR_174; interrupt; +begin + ISR_N(174); +end; + +procedure ISR_175; interrupt; +begin + ISR_N(175); +end; + +procedure ISR_176; interrupt; +begin + ISR_N(176); +end; + +procedure ISR_177; interrupt; +begin + ISR_N(177); +end; + +procedure ISR_178; interrupt; +begin + ISR_N(178); +end; + +procedure ISR_179; interrupt; +begin + ISR_N(179); +end; + +procedure ISR_180; interrupt; +begin + ISR_N(180); +end; + +procedure ISR_181; interrupt; +begin + ISR_N(181); +end; + +procedure ISR_182; interrupt; +begin + ISR_N(182); +end; + +procedure ISR_183; interrupt; +begin + ISR_N(183); +end; + +procedure ISR_184; interrupt; +begin + ISR_N(184); +end; + +procedure ISR_185; interrupt; +begin + ISR_N(185); +end; + +procedure ISR_186; interrupt; +begin + ISR_N(186); +end; + +procedure ISR_187; interrupt; +begin + ISR_N(187); +end; + +procedure ISR_188; interrupt; +begin + ISR_N(188); +end; + +procedure ISR_189; interrupt; +begin + ISR_N(189); +end; + +procedure ISR_190; interrupt; +begin + ISR_N(190); +end; + +procedure ISR_191; interrupt; +begin + ISR_N(191); +end; + +procedure ISR_192; interrupt; +begin + ISR_N(192); +end; + +procedure ISR_193; interrupt; +begin + ISR_N(193); +end; + +procedure ISR_194; interrupt; +begin + ISR_N(194); +end; + +procedure ISR_195; interrupt; +begin + ISR_N(195); +end; + +procedure ISR_196; interrupt; +begin + ISR_N(196); +end; + +procedure ISR_197; interrupt; +begin + ISR_N(197); +end; + +procedure ISR_198; interrupt; +begin + ISR_N(198); +end; + +procedure ISR_199; interrupt; +begin + ISR_N(199); +end; + +procedure ISR_200; interrupt; +begin + ISR_N(200); +end; + +procedure ISR_201; interrupt; +begin + ISR_N(201); +end; + +procedure ISR_202; interrupt; +begin + ISR_N(202); +end; + +procedure ISR_203; interrupt; +begin + ISR_N(203); +end; + +procedure ISR_204; interrupt; +begin + ISR_N(204); +end; + +procedure ISR_205; interrupt; +begin + ISR_N(205); +end; + +procedure ISR_206; interrupt; +begin + ISR_N(206); +end; + +procedure ISR_207; interrupt; +begin + ISR_N(207); +end; + +procedure ISR_208; interrupt; +begin + ISR_N(208); +end; + +procedure ISR_209; interrupt; +begin + ISR_N(209); +end; + +procedure ISR_210; interrupt; +begin + ISR_N(210); +end; + +procedure ISR_211; interrupt; +begin + ISR_N(211); +end; + +procedure ISR_212; interrupt; +begin + ISR_N(212); +end; + +procedure ISR_213; interrupt; +begin + ISR_N(213); +end; + +procedure ISR_214; interrupt; +begin + ISR_N(214); +end; + +procedure ISR_215; interrupt; +begin + ISR_N(215); +end; + +procedure ISR_216; interrupt; +begin + ISR_N(216); +end; + +procedure ISR_217; interrupt; +begin + ISR_N(217); +end; + +procedure ISR_218; interrupt; +begin + ISR_N(218); +end; + +procedure ISR_219; interrupt; +begin + ISR_N(219); +end; + +procedure ISR_220; interrupt; +begin + ISR_N(220); +end; + +procedure ISR_221; interrupt; +begin + ISR_N(221); +end; + +procedure ISR_222; interrupt; +begin + ISR_N(222); +end; + +procedure ISR_223; interrupt; +begin + ISR_N(223); +end; + +procedure ISR_224; interrupt; +begin + ISR_N(224); +end; + +procedure ISR_225; interrupt; +begin + ISR_N(225); +end; + +procedure ISR_226; interrupt; +begin + ISR_N(226); +end; + +procedure ISR_227; interrupt; +begin + ISR_N(227); +end; + +procedure ISR_228; interrupt; +begin + ISR_N(228); +end; + +procedure ISR_229; interrupt; +begin + ISR_N(229); +end; + +procedure ISR_230; interrupt; +begin + ISR_N(230); +end; + +procedure ISR_231; interrupt; +begin + ISR_N(231); +end; + +procedure ISR_232; interrupt; +begin + ISR_N(232); +end; + +procedure ISR_233; interrupt; +begin + ISR_N(233); +end; + +procedure ISR_234; interrupt; +begin + ISR_N(234); +end; + +procedure ISR_235; interrupt; +begin + ISR_N(235); +end; + +procedure ISR_236; interrupt; +begin + ISR_N(236); +end; + +procedure ISR_237; interrupt; +begin + ISR_N(237); +end; + +procedure ISR_238; interrupt; +begin + ISR_N(238); +end; + +procedure ISR_239; interrupt; +begin + ISR_N(239); +end; + +procedure ISR_240; interrupt; +begin + ISR_N(240); +end; + +procedure ISR_241; interrupt; +begin + ISR_N(241); +end; + +procedure ISR_242; interrupt; +begin + ISR_N(242); +end; + +procedure ISR_243; interrupt; +begin + ISR_N(243); +end; + +procedure ISR_244; interrupt; +begin + ISR_N(244); +end; + +procedure ISR_245; interrupt; +begin + ISR_N(245); +end; + +procedure ISR_246; interrupt; +begin + ISR_N(246); +end; + +procedure ISR_247; interrupt; +begin + ISR_N(247); +end; + +procedure ISR_248; interrupt; +begin + ISR_N(248); +end; + +procedure ISR_249; interrupt; +begin + ISR_N(249); +end; + +procedure ISR_250; interrupt; +begin + ISR_N(250); +end; + +procedure ISR_251; interrupt; +begin + ISR_N(251); +end; + +procedure ISR_252; interrupt; +begin + ISR_N(252); +end; + +procedure ISR_253; interrupt; +begin + ISR_N(253); +end; + +procedure ISR_254; interrupt; +begin + ISR_N(254); +end; + +procedure ISR_255; interrupt; +begin + ISR_N(255); +end; + +procedure init; +var + i, j : uint8; + +begin + for i:=0 to 255 do begin + for j:=0 to MAX_HOOKS do begin + Hooks[i][j]:= nil; + end; + end; + IDT.set_gate(0, uint32(@ISR_0), $08, ISR_RING_0); + IDT.set_gate(1, uint32(@ISR_1), $08, ISR_RING_0); + IDT.set_gate(2, uint32(@ISR_2), $08, ISR_RING_0); + IDT.set_gate(3, uint32(@ISR_3), $08, ISR_RING_0); + IDT.set_gate(4, uint32(@ISR_4), $08, ISR_RING_0); + IDT.set_gate(5, uint32(@ISR_5), $08, ISR_RING_0); + IDT.set_gate(6, uint32(@ISR_6), $08, ISR_RING_0); + IDT.set_gate(7, uint32(@ISR_7), $08, ISR_RING_0); + IDT.set_gate(8, uint32(@ISR_8), $08, ISR_RING_0); + IDT.set_gate(9, uint32(@ISR_9), $08, ISR_RING_0); + IDT.set_gate(10, uint32(@ISR_10), $08, ISR_RING_0); + IDT.set_gate(11, uint32(@ISR_11), $08, ISR_RING_0); + IDT.set_gate(12, uint32(@ISR_12), $08, ISR_RING_0); + IDT.set_gate(13, uint32(@ISR_13), $08, ISR_RING_0); + IDT.set_gate(14, uint32(@ISR_14), $08, ISR_RING_0); + IDT.set_gate(15, uint32(@ISR_15), $08, ISR_RING_0); + IDT.set_gate(16, uint32(@ISR_16), $08, ISR_RING_0); + IDT.set_gate(17, uint32(@ISR_17), $08, ISR_RING_0); + IDT.set_gate(18, uint32(@ISR_18), $08, ISR_RING_0); + IDT.set_gate(19, uint32(@ISR_19), $08, ISR_RING_0); + IDT.set_gate(20, uint32(@ISR_20), $08, ISR_RING_0); + IDT.set_gate(21, uint32(@ISR_21), $08, ISR_RING_0); + IDT.set_gate(22, uint32(@ISR_22), $08, ISR_RING_0); + IDT.set_gate(23, uint32(@ISR_23), $08, ISR_RING_0); + IDT.set_gate(24, uint32(@ISR_24), $08, ISR_RING_0); + IDT.set_gate(25, uint32(@ISR_25), $08, ISR_RING_0); + IDT.set_gate(26, uint32(@ISR_26), $08, ISR_RING_0); + IDT.set_gate(27, uint32(@ISR_27), $08, ISR_RING_0); + IDT.set_gate(28, uint32(@ISR_28), $08, ISR_RING_0); + IDT.set_gate(29, uint32(@ISR_29), $08, ISR_RING_0); + IDT.set_gate(30, uint32(@ISR_30), $08, ISR_RING_0); + IDT.set_gate(31, uint32(@ISR_31), $08, ISR_RING_0); + IDT.set_gate(32, uint32(@ISR_32), $08, ISR_RING_0); + IDT.set_gate(33, uint32(@ISR_33), $08, ISR_RING_0); + IDT.set_gate(34, uint32(@ISR_34), $08, ISR_RING_0); + IDT.set_gate(35, uint32(@ISR_35), $08, ISR_RING_0); + IDT.set_gate(36, uint32(@ISR_36), $08, ISR_RING_0); + IDT.set_gate(37, uint32(@ISR_37), $08, ISR_RING_0); + IDT.set_gate(38, uint32(@ISR_38), $08, ISR_RING_0); + IDT.set_gate(39, uint32(@ISR_39), $08, ISR_RING_0); + IDT.set_gate(40, uint32(@ISR_40), $08, ISR_RING_0); + IDT.set_gate(41, uint32(@ISR_41), $08, ISR_RING_0); + IDT.set_gate(42, uint32(@ISR_42), $08, ISR_RING_0); + IDT.set_gate(43, uint32(@ISR_43), $08, ISR_RING_0); + IDT.set_gate(44, uint32(@ISR_44), $08, ISR_RING_0); + IDT.set_gate(45, uint32(@ISR_45), $08, ISR_RING_0); + IDT.set_gate(46, uint32(@ISR_46), $08, ISR_RING_0); + IDT.set_gate(47, uint32(@ISR_47), $08, ISR_RING_0); + IDT.set_gate(48, uint32(@ISR_48), $08, ISR_RING_0); + IDT.set_gate(49, uint32(@ISR_49), $08, ISR_RING_0); + IDT.set_gate(50, uint32(@ISR_50), $08, ISR_RING_0); + IDT.set_gate(51, uint32(@ISR_51), $08, ISR_RING_0); + IDT.set_gate(52, uint32(@ISR_52), $08, ISR_RING_0); + IDT.set_gate(53, uint32(@ISR_53), $08, ISR_RING_0); + IDT.set_gate(54, uint32(@ISR_54), $08, ISR_RING_0); + IDT.set_gate(55, uint32(@ISR_55), $08, ISR_RING_0); + IDT.set_gate(56, uint32(@ISR_56), $08, ISR_RING_0); + IDT.set_gate(57, uint32(@ISR_57), $08, ISR_RING_0); + IDT.set_gate(58, uint32(@ISR_58), $08, ISR_RING_0); + IDT.set_gate(59, uint32(@ISR_59), $08, ISR_RING_0); + IDT.set_gate(60, uint32(@ISR_60), $08, ISR_RING_0); + IDT.set_gate(61, uint32(@ISR_61), $08, ISR_RING_0); + IDT.set_gate(62, uint32(@ISR_62), $08, ISR_RING_0); + IDT.set_gate(63, uint32(@ISR_63), $08, ISR_RING_0); + IDT.set_gate(64, uint32(@ISR_64), $08, ISR_RING_0); + IDT.set_gate(65, uint32(@ISR_65), $08, ISR_RING_0); + IDT.set_gate(66, uint32(@ISR_66), $08, ISR_RING_0); + IDT.set_gate(67, uint32(@ISR_67), $08, ISR_RING_0); + IDT.set_gate(68, uint32(@ISR_68), $08, ISR_RING_0); + IDT.set_gate(69, uint32(@ISR_69), $08, ISR_RING_0); + IDT.set_gate(70, uint32(@ISR_70), $08, ISR_RING_0); + IDT.set_gate(71, uint32(@ISR_71), $08, ISR_RING_0); + IDT.set_gate(72, uint32(@ISR_72), $08, ISR_RING_0); + IDT.set_gate(73, uint32(@ISR_73), $08, ISR_RING_0); + IDT.set_gate(74, uint32(@ISR_74), $08, ISR_RING_0); + IDT.set_gate(75, uint32(@ISR_75), $08, ISR_RING_0); + IDT.set_gate(76, uint32(@ISR_76), $08, ISR_RING_0); + IDT.set_gate(77, uint32(@ISR_77), $08, ISR_RING_0); + IDT.set_gate(78, uint32(@ISR_78), $08, ISR_RING_0); + IDT.set_gate(79, uint32(@ISR_79), $08, ISR_RING_0); + IDT.set_gate(80, uint32(@ISR_80), $08, ISR_RING_0); + IDT.set_gate(81, uint32(@ISR_81), $08, ISR_RING_0); + IDT.set_gate(82, uint32(@ISR_82), $08, ISR_RING_0); + IDT.set_gate(83, uint32(@ISR_83), $08, ISR_RING_0); + IDT.set_gate(84, uint32(@ISR_84), $08, ISR_RING_0); + IDT.set_gate(85, uint32(@ISR_85), $08, ISR_RING_0); + IDT.set_gate(86, uint32(@ISR_86), $08, ISR_RING_0); + IDT.set_gate(87, uint32(@ISR_87), $08, ISR_RING_0); + IDT.set_gate(88, uint32(@ISR_88), $08, ISR_RING_0); + IDT.set_gate(89, uint32(@ISR_89), $08, ISR_RING_0); + IDT.set_gate(90, uint32(@ISR_90), $08, ISR_RING_0); + IDT.set_gate(91, uint32(@ISR_91), $08, ISR_RING_0); + IDT.set_gate(92, uint32(@ISR_92), $08, ISR_RING_0); + IDT.set_gate(93, uint32(@ISR_93), $08, ISR_RING_0); + IDT.set_gate(94, uint32(@ISR_94), $08, ISR_RING_0); + IDT.set_gate(95, uint32(@ISR_95), $08, ISR_RING_0); + IDT.set_gate(96, uint32(@ISR_96), $08, ISR_RING_0); + IDT.set_gate(97, uint32(@ISR_97), $08, ISR_RING_0); + IDT.set_gate(98, uint32(@ISR_98), $08, ISR_RING_0); + IDT.set_gate(99, uint32(@ISR_99), $08, ISR_RING_0); + IDT.set_gate(100, uint32(@ISR_100), $08, ISR_RING_0); + IDT.set_gate(101, uint32(@ISR_101), $08, ISR_RING_0); + IDT.set_gate(102, uint32(@ISR_102), $08, ISR_RING_0); + IDT.set_gate(103, uint32(@ISR_103), $08, ISR_RING_0); + IDT.set_gate(104, uint32(@ISR_104), $08, ISR_RING_0); + IDT.set_gate(105, uint32(@ISR_105), $08, ISR_RING_0); + IDT.set_gate(106, uint32(@ISR_106), $08, ISR_RING_0); + IDT.set_gate(107, uint32(@ISR_107), $08, ISR_RING_0); + IDT.set_gate(108, uint32(@ISR_108), $08, ISR_RING_0); + IDT.set_gate(109, uint32(@ISR_109), $08, ISR_RING_0); + IDT.set_gate(110, uint32(@ISR_110), $08, ISR_RING_0); + IDT.set_gate(111, uint32(@ISR_111), $08, ISR_RING_0); + IDT.set_gate(112, uint32(@ISR_112), $08, ISR_RING_0); + IDT.set_gate(113, uint32(@ISR_113), $08, ISR_RING_0); + IDT.set_gate(114, uint32(@ISR_114), $08, ISR_RING_0); + IDT.set_gate(115, uint32(@ISR_115), $08, ISR_RING_0); + IDT.set_gate(116, uint32(@ISR_116), $08, ISR_RING_0); + IDT.set_gate(117, uint32(@ISR_117), $08, ISR_RING_0); + IDT.set_gate(118, uint32(@ISR_118), $08, ISR_RING_0); + IDT.set_gate(119, uint32(@ISR_119), $08, ISR_RING_0); + IDT.set_gate(120, uint32(@ISR_120), $08, ISR_RING_0); + IDT.set_gate(121, uint32(@ISR_121), $08, ISR_RING_0); + IDT.set_gate(122, uint32(@ISR_122), $08, ISR_RING_0); + IDT.set_gate(123, uint32(@ISR_123), $08, ISR_RING_0); + IDT.set_gate(124, uint32(@ISR_124), $08, ISR_RING_0); + IDT.set_gate(125, uint32(@ISR_125), $08, ISR_RING_0); + IDT.set_gate(126, uint32(@ISR_126), $08, ISR_RING_0); + IDT.set_gate(127, uint32(@ISR_127), $08, ISR_RING_0); + IDT.set_gate(128, uint32(@ISR_128), $08, ISR_RING_0); + IDT.set_gate(129, uint32(@ISR_129), $08, ISR_RING_0); + IDT.set_gate(130, uint32(@ISR_130), $08, ISR_RING_0); + IDT.set_gate(131, uint32(@ISR_131), $08, ISR_RING_0); + IDT.set_gate(132, uint32(@ISR_132), $08, ISR_RING_0); + IDT.set_gate(133, uint32(@ISR_133), $08, ISR_RING_0); + IDT.set_gate(134, uint32(@ISR_134), $08, ISR_RING_0); + IDT.set_gate(135, uint32(@ISR_135), $08, ISR_RING_0); + IDT.set_gate(136, uint32(@ISR_136), $08, ISR_RING_0); + IDT.set_gate(137, uint32(@ISR_137), $08, ISR_RING_0); + IDT.set_gate(138, uint32(@ISR_138), $08, ISR_RING_0); + IDT.set_gate(139, uint32(@ISR_139), $08, ISR_RING_0); + IDT.set_gate(140, uint32(@ISR_140), $08, ISR_RING_0); + IDT.set_gate(141, uint32(@ISR_141), $08, ISR_RING_0); + IDT.set_gate(142, uint32(@ISR_142), $08, ISR_RING_0); + IDT.set_gate(143, uint32(@ISR_143), $08, ISR_RING_0); + IDT.set_gate(144, uint32(@ISR_144), $08, ISR_RING_0); + IDT.set_gate(145, uint32(@ISR_145), $08, ISR_RING_0); + IDT.set_gate(146, uint32(@ISR_146), $08, ISR_RING_0); + IDT.set_gate(147, uint32(@ISR_147), $08, ISR_RING_0); + IDT.set_gate(148, uint32(@ISR_148), $08, ISR_RING_0); + IDT.set_gate(149, uint32(@ISR_149), $08, ISR_RING_0); + IDT.set_gate(150, uint32(@ISR_150), $08, ISR_RING_0); + IDT.set_gate(151, uint32(@ISR_151), $08, ISR_RING_0); + IDT.set_gate(152, uint32(@ISR_152), $08, ISR_RING_0); + IDT.set_gate(153, uint32(@ISR_153), $08, ISR_RING_0); + IDT.set_gate(154, uint32(@ISR_154), $08, ISR_RING_0); + IDT.set_gate(155, uint32(@ISR_155), $08, ISR_RING_0); + IDT.set_gate(156, uint32(@ISR_156), $08, ISR_RING_0); + IDT.set_gate(157, uint32(@ISR_157), $08, ISR_RING_0); + IDT.set_gate(158, uint32(@ISR_158), $08, ISR_RING_0); + IDT.set_gate(159, uint32(@ISR_159), $08, ISR_RING_0); + IDT.set_gate(160, uint32(@ISR_160), $08, ISR_RING_0); + IDT.set_gate(161, uint32(@ISR_161), $08, ISR_RING_0); + IDT.set_gate(162, uint32(@ISR_162), $08, ISR_RING_0); + IDT.set_gate(163, uint32(@ISR_163), $08, ISR_RING_0); + IDT.set_gate(164, uint32(@ISR_164), $08, ISR_RING_0); + IDT.set_gate(165, uint32(@ISR_165), $08, ISR_RING_0); + IDT.set_gate(166, uint32(@ISR_166), $08, ISR_RING_0); + IDT.set_gate(167, uint32(@ISR_167), $08, ISR_RING_0); + IDT.set_gate(168, uint32(@ISR_168), $08, ISR_RING_0); + IDT.set_gate(169, uint32(@ISR_169), $08, ISR_RING_0); + IDT.set_gate(170, uint32(@ISR_170), $08, ISR_RING_0); + IDT.set_gate(171, uint32(@ISR_171), $08, ISR_RING_0); + IDT.set_gate(172, uint32(@ISR_172), $08, ISR_RING_0); + IDT.set_gate(173, uint32(@ISR_173), $08, ISR_RING_0); + IDT.set_gate(174, uint32(@ISR_174), $08, ISR_RING_0); + IDT.set_gate(175, uint32(@ISR_175), $08, ISR_RING_0); + IDT.set_gate(176, uint32(@ISR_176), $08, ISR_RING_0); + IDT.set_gate(177, uint32(@ISR_177), $08, ISR_RING_0); + IDT.set_gate(178, uint32(@ISR_178), $08, ISR_RING_0); + IDT.set_gate(179, uint32(@ISR_179), $08, ISR_RING_0); + IDT.set_gate(180, uint32(@ISR_180), $08, ISR_RING_0); + IDT.set_gate(181, uint32(@ISR_181), $08, ISR_RING_0); + IDT.set_gate(182, uint32(@ISR_182), $08, ISR_RING_0); + IDT.set_gate(183, uint32(@ISR_183), $08, ISR_RING_0); + IDT.set_gate(184, uint32(@ISR_184), $08, ISR_RING_0); + IDT.set_gate(185, uint32(@ISR_185), $08, ISR_RING_0); + IDT.set_gate(186, uint32(@ISR_186), $08, ISR_RING_0); + IDT.set_gate(187, uint32(@ISR_187), $08, ISR_RING_0); + IDT.set_gate(188, uint32(@ISR_188), $08, ISR_RING_0); + IDT.set_gate(189, uint32(@ISR_189), $08, ISR_RING_0); + IDT.set_gate(190, uint32(@ISR_190), $08, ISR_RING_0); + IDT.set_gate(191, uint32(@ISR_191), $08, ISR_RING_0); + IDT.set_gate(192, uint32(@ISR_192), $08, ISR_RING_0); + IDT.set_gate(193, uint32(@ISR_193), $08, ISR_RING_0); + IDT.set_gate(194, uint32(@ISR_194), $08, ISR_RING_0); + IDT.set_gate(195, uint32(@ISR_195), $08, ISR_RING_0); + IDT.set_gate(196, uint32(@ISR_196), $08, ISR_RING_0); + IDT.set_gate(197, uint32(@ISR_197), $08, ISR_RING_0); + IDT.set_gate(198, uint32(@ISR_198), $08, ISR_RING_0); + IDT.set_gate(199, uint32(@ISR_199), $08, ISR_RING_0); + IDT.set_gate(200, uint32(@ISR_200), $08, ISR_RING_0); + IDT.set_gate(201, uint32(@ISR_201), $08, ISR_RING_0); + IDT.set_gate(202, uint32(@ISR_202), $08, ISR_RING_0); + IDT.set_gate(203, uint32(@ISR_203), $08, ISR_RING_0); + IDT.set_gate(204, uint32(@ISR_204), $08, ISR_RING_0); + IDT.set_gate(205, uint32(@ISR_205), $08, ISR_RING_0); + IDT.set_gate(206, uint32(@ISR_206), $08, ISR_RING_0); + IDT.set_gate(207, uint32(@ISR_207), $08, ISR_RING_0); + IDT.set_gate(208, uint32(@ISR_208), $08, ISR_RING_0); + IDT.set_gate(209, uint32(@ISR_209), $08, ISR_RING_0); + IDT.set_gate(210, uint32(@ISR_210), $08, ISR_RING_0); + IDT.set_gate(211, uint32(@ISR_211), $08, ISR_RING_0); + IDT.set_gate(212, uint32(@ISR_212), $08, ISR_RING_0); + IDT.set_gate(213, uint32(@ISR_213), $08, ISR_RING_0); + IDT.set_gate(214, uint32(@ISR_214), $08, ISR_RING_0); + IDT.set_gate(215, uint32(@ISR_215), $08, ISR_RING_0); + IDT.set_gate(216, uint32(@ISR_216), $08, ISR_RING_0); + IDT.set_gate(217, uint32(@ISR_217), $08, ISR_RING_0); + IDT.set_gate(218, uint32(@ISR_218), $08, ISR_RING_0); + IDT.set_gate(219, uint32(@ISR_219), $08, ISR_RING_0); + IDT.set_gate(220, uint32(@ISR_220), $08, ISR_RING_0); + IDT.set_gate(221, uint32(@ISR_221), $08, ISR_RING_0); + IDT.set_gate(222, uint32(@ISR_222), $08, ISR_RING_0); + IDT.set_gate(223, uint32(@ISR_223), $08, ISR_RING_0); + IDT.set_gate(224, uint32(@ISR_224), $08, ISR_RING_0); + IDT.set_gate(225, uint32(@ISR_225), $08, ISR_RING_0); + IDT.set_gate(226, uint32(@ISR_226), $08, ISR_RING_0); + IDT.set_gate(227, uint32(@ISR_227), $08, ISR_RING_0); + IDT.set_gate(228, uint32(@ISR_228), $08, ISR_RING_0); + IDT.set_gate(229, uint32(@ISR_229), $08, ISR_RING_0); + IDT.set_gate(230, uint32(@ISR_230), $08, ISR_RING_0); + IDT.set_gate(231, uint32(@ISR_231), $08, ISR_RING_0); + IDT.set_gate(232, uint32(@ISR_232), $08, ISR_RING_0); + IDT.set_gate(233, uint32(@ISR_233), $08, ISR_RING_0); + IDT.set_gate(234, uint32(@ISR_234), $08, ISR_RING_0); + IDT.set_gate(235, uint32(@ISR_235), $08, ISR_RING_0); + IDT.set_gate(236, uint32(@ISR_236), $08, ISR_RING_0); + IDT.set_gate(237, uint32(@ISR_237), $08, ISR_RING_0); + IDT.set_gate(238, uint32(@ISR_238), $08, ISR_RING_0); + IDT.set_gate(239, uint32(@ISR_239), $08, ISR_RING_0); + IDT.set_gate(240, uint32(@ISR_240), $08, ISR_RING_0); + IDT.set_gate(241, uint32(@ISR_241), $08, ISR_RING_0); + IDT.set_gate(242, uint32(@ISR_242), $08, ISR_RING_0); + IDT.set_gate(243, uint32(@ISR_243), $08, ISR_RING_0); + IDT.set_gate(244, uint32(@ISR_244), $08, ISR_RING_0); + IDT.set_gate(245, uint32(@ISR_245), $08, ISR_RING_0); + IDT.set_gate(246, uint32(@ISR_246), $08, ISR_RING_0); + IDT.set_gate(247, uint32(@ISR_247), $08, ISR_RING_0); + IDT.set_gate(248, uint32(@ISR_248), $08, ISR_RING_0); + IDT.set_gate(249, uint32(@ISR_249), $08, ISR_RING_0); + IDT.set_gate(250, uint32(@ISR_250), $08, ISR_RING_0); + IDT.set_gate(251, uint32(@ISR_251), $08, ISR_RING_0); + IDT.set_gate(252, uint32(@ISR_252), $08, ISR_RING_0); + IDT.set_gate(253, uint32(@ISR_253), $08, ISR_RING_0); + IDT.set_gate(254, uint32(@ISR_254), $08, ISR_RING_0); + IDT.set_gate(255, uint32(@ISR_255), $08, ISR_RING_0); +end; + +end. \ No newline at end of file