home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / MADTRB18.ZIP / DISK.PAS < prev    next >
Encoding:
Pascal/Delphi Source File  |  1985-08-02  |  4.9 KB  |  164 lines
  1. {*$C-}
  2.  
  3. Function __ReadWriteSectors(Var Buffer;
  4.                             Drive, NumberSectors, LogicalSector: Integer;
  5.                             WriteFlag: Byte): Integer;
  6.   Var Result: Integer;
  7.   Begin
  8.     Result:=0;
  9.     Inline($8A/$86/ Drive /           {       MOV  AL,[BP+Drive]             }
  10.            $8B/$8E/ NumberSectors /   {       MOV  CX,[BP+NumberSectors]     }
  11.            $8B/$96/ LogicalSector /   {       MOV  DX,[BP+LogicalSector]     }
  12.            $55/                       {       PUSH BP                        }
  13.            $1E/                       {       PUSH DS                        }
  14.            $C5/$9E/ Buffer /          {       LDS  BX,[BP+Buffer]            }
  15.            $80/$BE/ WriteFlag /$01/   {       CMP  BYTE PTR [BP+WriteFlag],1 }
  16.            $74/$04/                   {       JE   Write                     }
  17.            $CD/$25/                   {       INT  25H                       }
  18.            $EB/$02/                   {       JMP  WrapUp                    }
  19.            $CD/$26/                   {Write: INT 26H                        }
  20.            $5B/                       {WrapUp:POP  BX     ;Dispose of flags  }
  21.            $1F/                       {       POP  DS                        }
  22.            $5D/                       {       POP  BP                        }
  23.            $73/$04/                   {       JNB  Ok                        }
  24.            $89/$86/ Result            {       MOV  [BP+Result],AX            }
  25.            );                         {Ok:                                   }
  26.     __ReadWriteSectors:=Result;
  27.   End;
  28.  
  29. Function ReadSectors(Var Buffer;
  30.                      Drive, NumberSectors, LogicalSector: Integer): Integer;
  31.   Begin
  32.     ReadSectors:=
  33.       __ReadWriteSectors(Buffer,Drive,NumberSectors,LogicalSector,0);
  34.   End;
  35.  
  36. Function WriteSectors(Var Buffer;
  37.                       Drive, NumberSectors, LogicalSector: Integer): Integer;
  38.   Begin
  39.     WriteSectors:=
  40.       __ReadWriteSectors(Buffer,Drive,NumberSectors,LogicalSector,1);
  41.   End;
  42.  
  43.  
  44. {$R+}
  45.  
  46. Type
  47.   Str=String[4];
  48.  
  49. Function Int2Hex2(B: Byte): Str;
  50.   Const H: Array [0..15] Of Char='0123456789ABCDEF';
  51.   Begin
  52.     Int2Hex2:=H[B Shr 4]+H[B And 15];
  53.   End;
  54.  
  55. Function Int2Hex4(I: Integer): Str;
  56.   Const H: Array [0..15] Of Char='0123456789ABCDEF';
  57.   Begin
  58.     Int2Hex4:=H[I Shr 12]+H[(I Shr 8) And 15]+H[(I Shr 4) And 15]+H[I And 15];
  59.   End;
  60.  
  61. Function Hex2Int1(C: Char): Byte;
  62.   Begin
  63.     Case Upcase(C) Of
  64.       '0'..'9': Hex2Int1:=Ord(C) And 15;
  65.       'A'..'F': Hex2Int1:=Ord(C) And 15+9;
  66.       Else Hex2Int1:=0;
  67.      End;
  68.   End;
  69.  
  70. Function Hex2Int4(S: Str; Default: Integer): Integer;
  71.   Var I: Integer;
  72.   Begin
  73.     If S='' Then Hex2Int4:=Default
  74.     Else
  75.      Begin
  76.       I:=0;
  77.       While S<>'' Do
  78.        Begin
  79.         I:=I Shl 4 + Hex2Int1(S[1]);
  80.         Delete(S,1,1);
  81.        End;
  82.       Hex2Int4:=I;
  83.      End;
  84.   End;
  85.  
  86. Procedure ShowSector(Var S);
  87.   Var Buffer: Array [0..31,0..15] Of Byte Absolute S;
  88.       I,J: Integer;
  89.       B: Byte;
  90.   Begin
  91.     For I:=0 To 31 Do
  92.      Begin
  93.       Write(Int2Hex4(I Shl 4),' |  ');
  94.       For J:=0 To 15 Do
  95.        Begin
  96.         Write(Int2Hex2(Buffer[I,J]),' ');
  97.         If J And 3=3 Then Write(' ');
  98.        End;
  99.       Write('| ');
  100.       For J:=0 To 15 Do
  101.        Begin
  102.         B:=Buffer[I,J];
  103.         If B<127 Then NormVideo
  104.         Else LowVideo;
  105.         B:=B And $7F;
  106.         If B<32 Then B:=Ord('.');
  107.         Write(Chr(B));
  108.        End;
  109.       NormVideo;
  110.       WriteLn;
  111.      End;
  112.   End;
  113.  
  114. Var
  115.   Buffer: Array [0..511] Of Byte;
  116.   DR,LS,Result,C: Integer;
  117.   W: Char;
  118.   V: Str;
  119.   Changed: Boolean;
  120.  
  121. Begin
  122.   FillChar(Buffer,SizeOf(Buffer),'z');
  123.   Repeat
  124.     DR:=-1;
  125.     Write('Enter the drive # to read (CR to end): ');
  126.     ReadLn(DR);
  127.     If DR In [0..25] Then
  128.      Begin
  129.       Write('Enter the logical sector # to read: ');
  130.       ReadLn(LS);
  131.       Result:=ReadSectors(Buffer,DR,1,LS);
  132.       WriteLn('Result code = ',Result);
  133.       Changed:=False;
  134.       Repeat
  135.         ShowSector(Buffer);
  136.         Write('Enter the number of the byte to change (0-1FF, CR to end): ');
  137.         ReadLn(V);
  138.         C:=Hex2Int4(V,-1);
  139.         If (C>0) And (C<512) Then
  140.          Begin
  141.           Write('Enter new value [',Int2Hex2(Buffer[C]),']: ');
  142.           ReadLn(V);
  143.           If Length(V)>1 Then
  144.             If V[1] In ['''','"'] Then Buffer[C]:=Ord(V[2])
  145.             Else Buffer[C]:=Hex2Int4(V,Buffer[C])
  146.           Else Buffer[C]:=Hex2Int4(V,Buffer[C]);
  147.           Changed:=True;
  148.          End
  149.         Else C:=-1;
  150.       Until C=-1;
  151.       If Changed Then
  152.        Begin
  153.         Write('Write changes back to drive ',DR,', logical sector #',LS,' (Y/N)? ');
  154.         ReadLn(W);
  155.         If Upcase(W)='Y' Then
  156.          Begin
  157.           Result:=WriteSectors(Buffer,DR,1,LS);
  158.           WriteLn('Result code = ',Result);
  159.          End;
  160.        End;
  161.      End
  162.     Else DR:=-1;
  163.   Until DR=-1;
  164. End.