Turbo Toolbox/Turbo_Toolbox.iso/1989/10/tricks/search.pas

Pascal/Delphi Source File | 1989-07-12 | 6.9 KB | 196 lines

(* ------------------------------------------------------ *)
(*                      SEARCH.PAS                        *)
(*   Dateisuchroutinen unter spezieller Berücksichtigung  *)
(*   der BGI-Treiber                                      *)
(*          (c) 1989  Frank Jürgensen  &  TOOLBOX         *)
(* ------------------------------------------------------ *)
UNIT search;

INTERFACE

USES Graph, Dos;
                 { Graph kann entfallen, wenn man auf die  }
                 { automatische Bestimmung eines benötigten}
                 { BGI-Treibers verzichten will            }

FUNCTION DriverPath(searchfile : STRING) : PathStr;

  { Sucht den zu "searchfile" passenden Pfad. Der Dateiname}
  { ist nicht Teil der zurückgegebenen Pfadangabe.         }
  { Ist searchfile = '' wird angenommen, daß der passende  }
  { BGI-Treiber gesucht werden soll.                       }
  { Zuerst wird im DOS-PATH gesucht, dann auf dem gesamten }
  { aktiven Datenträger. Bei Mißerfolg wird ''             }
  { zurückgegeben und driverpath_ok = FALSE.               }

FUNCTION MyFsearch(searchfile    : PathStr;
                   dostime, size : LONGINT;
                   dirlist       : STRING) : PathStr;

  { Fsearch aus UNIT Dos kann Datum und Zeit bei der Suche }
  { nicht berücksichtigen. MyFsearch arbeitet genau wie    }
  { Fsearch, wenn dostime = notime und size = nosize       }
  { (also unwirksam) sind, ansonsten prüft es auch         }
  { Dateigröße und/oder Datum. Den Wert für dostime erhält }
  { man durch packtime aus der UNIT DOS. Der Sekundenanteil}
  { ist nicht relevant: bei der Suche wird eine Toleranz   }
  { von 60 s (timetol*2=Toleranz in Sekunden) eingeräumt.  }
  { Wegen Kompatibilität mit Fsearch gehört der Dateiname  }
  { zum zurückgegebenen Pfad.                              }

VAR
  driverpath_ok : BOOLEAN;
  drivertime    : LONGINT;
  driversize    : LONGINT;
               { Zusätzliche Suchkriterien für Driverpath. }

CONST
  timetol = 30;          { Toleranz bei Zeitangaben:       }
                         { timetol*2=Toleranz in Sekunden  }
  notime  = -1;
  nosize  = -1;          { Flag: Zeit und Größe beliebig   }

IMPLEMENTATION

  FUNCTION Upper(s : STRING) : STRING;
  VAR
    i : BYTE;
  BEGIN
    FOR i := 1 TO Length(s) DO
      CASE s[i] OF
        'ä' : s[i] := 'Ä';
        'ö' : s[i] := 'Ö';
        'ü' : s[i] := 'Ü';
        ELSE  s[i] := UpCase(s[i]);
      END;
    Upper := s;
  END;

FUNCTION MyFsearch(searchfile    : PathStr;
                   dostime, size : LONGINT;
                   dirlist       : STRING) : PathStr;
VAR
  f           : searchrec;
  currentpath : pathstr;
  sempos      : BYTE;
BEGIN
  currentpath := '.';
  searchfile  := Upper(searchfile);
  REPEAT
    FindFirst(currentpath + '\*.*', anyfile, f);
    WHILE DosError = 0 DO BEGIN
      IF (f.name=searchfile) AND ((dostime = notime) OR
         (Abs(f.time-dostime)<timetol)) AND
         ((size = nosize) OR (f.size = size)) THEN BEGIN
        IF currentpath[Length(currentpath)] <> '\' THEN
          currentpath := currentpath + '\';
        MyFsearch   := currentpath + searchfile;
        Exit;
      END;
      FindNext(f);
    END;
    WHILE (Length(dirlist)>0) AND (dirlist[1] IN [';',' '])
      DO Delete(dirlist,1,1);
    sempos := Pos(';', dirlist);
    IF sempos = 0 THEN
      sempos := Length(dirlist) + 1;               { Trick }
    currentpath := Copy(dirlist, 1, sempos - 1);
    dirlist := Copy(dirlist, sempos + 1, Length(dirlist));
  UNTIL Length(currentpath) = 0;
  myfsearch := '';                       { nichts gefunden }
END;

FUNCTION DriverPath(searchfile : STRING) : PathStr;
CONST
  BGIname : ARRAY[1..10]OF STRING[8] =
          ('CGA',     'CGA',  'EGAVGA', 'EGAVGA', 'EGAVGA',
           'IBM8514', 'HERC', 'ATT',    'EGAVGA', 'PC3270');
  BGItimerec : datetime =
                         (Year : 1988; Month : 10; Day : 10;
                          Hour : 5;    Min   : 0;  Sec : 0);

  { Dieses Datum gilt für die Treiber, die Graph in        }
  { Turbo-5 braucht. Die Unterscheidung ist wichtig - denn }
  { Turbo Prolog z.B. hat Treiber gleichen Namens, die     }
  { aber nicht passen                                      }

VAR
  gd, gm           : INTEGER;
  dospath          : STRING;
  test, scanresult : PathStr;
  scansuccess      : BOOLEAN;

  PROCEDURE Scan(scanpath : PathStr);
     { Sucht scanpath mit allen Unterverzeichnissen nach   }
     { der Datei searchfile ab. Der gefundene Pfad landet  }
     { in scanresult und scansuccess ist dann TRUE.        }
     { Scansuccess muß vor dem Aufruf auf FALSE gesetzt    }
     { worden sein.                                        }
  VAR
    doserr : INTEGER;
    f      : searchrec;
  BEGIN
    FindFirst(scanpath + '*.*', anyfile, f);
    doserr := DosError;
    WHILE doserr = 0 DO BEGIN
      IF (f.attr = directory) AND
                           (Pos('.', f.name) = 0) THEN BEGIN
        Scan(scanpath + f.name + '\');
        IF scansuccess THEN Exit;
      END ELSE
        IF (f.name = searchfile) AND
           ((drivertime = notime) OR
           (Abs(f.time - drivertime) < timetol)) AND
           ((driversize = nosize) OR
           (f.size = driversize)) THEN BEGIN
          scansuccess := TRUE;
          IF (Length(scanpath) > Pos(':', scanpath) + 1) AND
             (scanpath[Length(scanpath)]='\') THEN
            Dec(BYTE(scanpath[0]));
          scanresult := scanpath;
          Exit;
        END;
      FindNext(f);  doserr := DosError;
    END;
  END;

BEGIN { driverpath }
   driverpath_ok := TRUE;           { zuerst normale Suche }
   IF searchfile = '' THEN BEGIN
        { den benötigten BGI-Treibernamen selbst festlegen }
     DetectGraph(gd, gm);
     searchfile := BGIname[gd] + '.BGI';
     PackTime(BGItimerec, drivertime);
     driversize := nosize;
   END ELSE
        { es wird nach irgendeinem anderen Treiber gesucht }
     searchfile := Upper(searchfile);
                    { Erste Suchstufe: im Dos-Pfad suchen: }
   dospath := getenv('PATH');
   test := MyFsearch(searchfile, drivertime,
                     driversize, dospath);
   IF Length(test) > 0 THEN BEGIN
     driverpath := Copy(test, 1, Pos(searchfile, test) - 2);
     drivertime := notime;
     driversize := nosize;                       { default }
     Exit;
   END;
    { Zweite Suchstufe: den gesamten Datenträger absuchen: }
   scansuccess := FALSE;
   scan('\');                     { Ab Root alles abgrasen }
   IF scansuccess THEN
     driverpath := scanresult
   ELSE BEGIN
     driverpath    := '';
     driverpath_ok := FALSE;
   END;
   drivertime := notime;
   driversize := nosize;
END; { driverpath }

BEGIN
  drivertime := notime; driversize := nosize; { default: }
END.
(* ------------------------------------------------------ *)
(*                  Ende von SEARCH.PAS                   *)