home *** CD-ROM | disk | FTP | other *** search
/ Programmer 7500 / MAX_PROGRAMMERS.iso / PASCAL / PRINTDIR.ZIP / PWD.PAS < prev   
Encoding:
Pascal/Delphi Source File  |  1993-01-04  |  3.5 KB  |  88 lines
  1. PROGRAM PWD; {Print Working Directories on all valid drives.
  2.  
  3.   (C) Copyright 1989, Earl F. Glynn, Overland Park, KS.  Compuserve:  73257,3527
  4.   All Rights Reserved.  Version 1.0, 14 June 1989.  This program may be
  5.   freely distributed for non-commerical use.
  6.  
  7.   Information about the Disk Parameter Block and what I have termed the
  8.   "Drive Array" was found in the public domain program SYSID.PAS by
  9.   Steve Grant, Long Beach, CA.  I prefer to use RECORDs and pointers to
  10.   access this information instead of the MEM and MEMW Turbo Pascal "arrays".}
  11.  
  12.   USES DOS;  {INTR}
  13.  
  14.   TYPE
  15.     DiskParameterBlockPointer = ^DiskParameterBlock;
  16.     DiskParameterBlock      =
  17.       RECORD                                        { offset }
  18.         misc1               :  BYTE;                {  0 $00 }
  19.         driveunit           :  BYTE;                {  1 $01 }
  20.         BytesPerSector      :  WORD;                {  2 $02 }
  21.         SectorsPerCluster   :  BYTE;                {  4 $04 }
  22.         ClusterToSectorShift:  BYTE;                {  5 $05 }
  23.         ReservedSectors     :  WORD;                {  6 $06 }
  24.         FATs                :  BYTE;                {  8 $08 }
  25.         RootDirectoryEntries:  WORD;                {  9 $09 }
  26.         FirstDataSector     :  WORD;                { 11 $0B }
  27.         Clusters            :  WORD;                { 13 $0D }
  28.         SectorsPerFAT       :  BYTE;                { 15 $0F }
  29.         RootDirectorySector :  WORD;                { 16 $10 }
  30.         DeviceHeader        :  pointer;             { 18 $12 }
  31.         MediaType           :  BYTE;                { 22 $16 }
  32.         Valid               :  BYTE;                { 23 $17 }
  33.         NextDPB             :  pointer              { 24 $18 }
  34.       END;
  35.  
  36.     DriveArrayPointer   = ^DriveArray;
  37.     DriveArray          =
  38.       RECORD
  39.         DefaultDirectory:  ARRAY[1..69] OF CHAR;   {ASCIIZ string}
  40.         DPB             :  DiskParameterBlockPointer;
  41.       END;
  42.  
  43.     DOSListOfLists      =
  44.       RECORD                                        { offset  }
  45.         FirstMCBSegment :  WORD;                    { -2 -$02 }
  46.         misc1           :  ARRAY[1..16] OF BYTE;    {  0  $00 }
  47.         MaxBytesPerBlock:  WORD;                    { 16  $10 }
  48.         misc2           :  ARRAY[1..4]  OF BYTE;    { 18  $12 }
  49.         BaseDA          :  DriveArrayPointer;       { 22  $16 }
  50.         misc3           :  ARRAY[1..7]  OF BYTE;    { 26  $1A }
  51.         LastDrive       :  BYTE                     { 33  $21 }
  52.       END;
  53.  
  54.   VAR
  55.     c    :  CHAR;
  56.     DA   :  DriveArrayPointer;
  57.     DPB  :  DiskParameterBlockPointer;
  58.     drive:  WORD;
  59.     i    :  WORD;
  60.     LoL  :  ^DOSListOfLists;
  61.     r    :  Registers;
  62.  
  63. BEGIN
  64.   WRITELN ('Working Directories:');
  65.   r.AH := $52;
  66.   Intr ($21,r);                        {Undocumented DOS function}
  67.   LoL := Ptr(r.ES,r.BX-2);             {DOS List of Lists - 2}
  68.   DA := LoL^.BaseDA;                   {First Drive Array entry}
  69.   drive := 1;
  70.   REPEAT
  71.     DPB := DA^.DPB;                    {Disk Parameter Block}
  72.     IF   DPB^.valid = 0                {Is this drive valid?}
  73.     THEN BEGIN
  74.       WRITE ('  ');
  75.       i := 1;
  76.       c := DA^.DefaultDirectory[i];    {Output working directory}
  77.       WHILE c > #$00 DO BEGIN          {Look for end of ASCIIZ string}
  78.         WRITE (c);
  79.         INC (i);
  80.         c := DA^.DefaultDirectory[i]
  81.       END;
  82.       WRITELN
  83.     END;
  84.     INC (drive);
  85.     DA := Ptr(Seg(DA^), Ofs(DA^)+$51)  {Next Drive Array entry}
  86.   UNTIL (Seg(DPB^.NextDPB^) = $FFFF) OR (drive > LoL^.LastDrive)
  87. END {PWD}.
  88.