home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / 1989 / 07 / tricks / alias.mod < prev    next >
Encoding:
Text File  |  1984-01-27  |  9.0 KB  |  285 lines
  1. (* ------------------------------------------------------ *)
  2. (*                      ALIAS.MOD                         *)
  3. (*                                                        *)
  4. (*          DOS-Erweiterung in TopSpeed Modula-2          *)
  5. (* Aufruf: alias [/d] [name] [Befehl {' #' [' '] Befehl}] *)
  6. (*                                                        *)
  7. (*         (c) 1989  Rüdiger Stobbe  &  TOOLBOX           *)
  8. (* ------------------------------------------------------ *)
  9. MODULE Alias;
  10.  
  11. IMPORT IO;
  12. FROM   SYSTEM IMPORT Registers;
  13. FROM   FIO    IMPORT File, Create, Close, Erase, FileAttr,
  14.                      readonly, archive, hidden, PathTail,
  15.                      DirEntry, ReadFirstEntry,
  16.                      ReadNextEntry, WrStr, IOcheck,
  17.                      IOresult, GetDir, ChDir;
  18. FROM   Str    IMPORT Concat, Compare, Delete, Copy, Pos,
  19.                      Length, Caps, ItemS;
  20. FROM   Lib    IMPORT Dos, ParamStr, ParamCount,
  21.                      CommandType, Environment;
  22.  
  23. CONST
  24.   MaxLineLength  = 100;
  25.   VersionMessage = "alias version 1.02  27.02.1989";
  26.  
  27. TYPE
  28.   SetOfChar = SET OF CHAR;
  29.  
  30. CONST
  31.   PossibleNew      = SetOfChar{'0'..'9','A'..'Z',
  32.                                'a'..'z','$'};
  33.   PossibleList     = PossibleNew + SetOfChar{'*','?'};
  34.   DefaultDirectory = "C:\ALIASLST";
  35.  
  36. VAR
  37.   parameter           : ARRAY [0..MaxLineLength] OF CHAR;
  38.   NumberOfParams,
  39.   len, i              : CARDINAL;
  40.   Drv, DefDrv         : SHORTCARD;
  41.   AliasDirectory,
  42.   SaveDirectory,
  43.   EnvironmentString   : ARRAY [0..63] OF CHAR;
  44.   DriveString         : ARRAY [0..1] OF CHAR;
  45.  
  46.  
  47. PROCEDURE FindEnvVariable(Variable   : ARRAY OF CHAR;
  48.                           VAR Result : ARRAY OF CHAR);
  49. VAR
  50.   i              : CARDINAL;
  51.   EnvVar, EnvStr : ARRAY [0..80] OF CHAR;
  52.   EnvPtr         : CommandType;
  53.  
  54. BEGIN
  55.   Caps(Variable);
  56.   i := 0;
  57.   LOOP
  58.     EnvPtr := Environment(i);
  59.     Copy(EnvStr, EnvPtr^);
  60.     IF Length(EnvStr[0]) = 0 THEN
  61.       Result[0] := CHAR (0);
  62.       RETURN;
  63.     END;
  64.     ItemS(EnvVar, EnvStr, " =", 0);
  65.     IF Compare(EnvVar, Variable) = 0 THEN
  66.       ItemS(Result, EnvStr, " =", 1);
  67.       RETURN;
  68.     END;
  69.     INC(i);
  70.   END;
  71. END FindEnvVariable;
  72.  
  73.  
  74. PROCEDURE GetDefaultDrive() : SHORTCARD;
  75.          (* Gibt die Nummer (A = 0, B = 1, ...) des       *)
  76.          (* aktuellen Laufwerks zurück                    *)
  77. VAR
  78.   Regs : Registers;
  79.  
  80. BEGIN
  81.   Regs.AH := 19H;
  82.   Dos(Regs);
  83.   RETURN(Regs.AL);
  84. END GetDefaultDrive;
  85.  
  86.  
  87. PROCEDURE AliasList(listname : ARRAY OF CHAR);
  88.          (* AliasList listet alle Kommandos aus \ALIASLST *)
  89.          (* auf, die dem Suchmuster ('*','?' erlaubt) in  *)
  90.          (* listname entsprechen                          *)
  91. CONST
  92.   Attributes = FileAttr{readonly, hidden, archive};
  93. VAR
  94.   matchcode : ARRAY [0..63] OF CHAR;
  95.   Output    : PathTail;
  96.   directory : DirEntry;
  97.   len, i, p : CARDINAL;
  98.   found     : BOOLEAN;
  99.  
  100. BEGIN
  101.   IO.WrLn; IO.WrStr(VersionMessage); IO.WrLn; IO.WrLn;
  102.   Caps(listname);
  103.   len := Length(listname);
  104.   IF len > 8 THEN len := 7; ELSE DEC(len); END;
  105.   i := 0;
  106.   REPEAT
  107.     INC(i);
  108.   UNTIL NOT (listname[i-1] IN PossibleList) OR (i > len);
  109.   listname[i] := 0C;
  110.   Concat(matchcode, AliasDirectory, listname);
  111.   Concat(matchcode, matchcode, ".BAT");
  112.          (* Suche ersten Eintrag entsprechend Suchmuster  *)
  113.   found := ReadFirstEntry(matchcode, Attributes, directory);
  114.   WHILE found DO
  115.          (* gebe alle gefundenen Einträge aus - ohne .BAT *)
  116.     Copy(Output, directory.Name);
  117.     p := Pos(Output, ".");
  118.     IF p # MAX (CARDINAL) THEN Output[p] := 0C; END;
  119.     IO.WrStr(Output); IO.WrLn;
  120.     found := ReadNextEntry(directory);
  121.   END;
  122. END AliasList;
  123.  
  124.  
  125. PROCEDURE AliasDelete(deletename : ARRAY OF CHAR);
  126.          (* AliasDelete löscht alle bestehenden Einträge  *)
  127.          (* in \ALIASLST die dem Suchmuster in deletename *)
  128.          (* entsprechen, auch hier sind wie bei AliasList *)
  129.          (* wildcards ('*' und '?') erlaubt               *)
  130. CONST
  131.   Attributes = FileAttr{hidden, archive};
  132. VAR
  133.   matchcode, delname : ARRAY [0..63] OF CHAR;
  134.   directory          : DirEntry;
  135.   len, i             : CARDINAL;
  136.   found              : BOOLEAN;
  137.  
  138. BEGIN
  139.   Caps (deletename);
  140.   len := Length (deletename);
  141.   IF len > 8 THEN len := 7; ELSE DEC (len) END;
  142.   i := 0;
  143.   REPEAT
  144.     INC (i);
  145.   UNTIL NOT (deletename [i-1] IN PossibleList) OR (i > len);
  146.   deletename [i] := 0C;
  147.   Concat (matchcode, AliasDirectory, deletename);
  148.   Concat (matchcode, matchcode, ".BAT");
  149.          (* Suche den ersten Eintrag                      *)
  150.   found := ReadFirstEntry(matchcode, Attributes, directory);
  151.   WHILE found DO
  152.     Concat (delname, AliasDirectory, directory.Name);
  153.     found := ReadNextEntry (directory);
  154.     Erase (delname);
  155.   END;
  156. END AliasDelete;
  157.  
  158.  
  159. PROCEDURE AliasInsert(insertname : ARRAY OF CHAR) : BOOLEAN;
  160.                 (* AliasInsert erzeugt ein neues Kommando *)
  161. VAR
  162.   filename     : ARRAY [0..63] OF CHAR;
  163.   help, Line   : ARRAY [0..MaxLineLength] OF CHAR;
  164.   batchfile    : File;
  165.   found, error : BOOLEAN;
  166.   len, i       : CARDINAL;
  167.   crlf         : ARRAY [0..1] OF CHAR;
  168.  
  169. BEGIN
  170.   Concat(crlf, CHR(13), CHR(10));
  171.   Caps(insertname);
  172.          (* kürze insertname auf maximal 8 Zeichen, die   *)
  173.          (* alle gültig sind der Name wird ab dem ersten  *)
  174.          (* ungültigen Zeichen abgeschnitten              *)
  175.   len := Length(insertname);
  176.   IF len > 8 THEN len := 7; ELSE DEC(len) END;
  177.   i := 0;
  178.   REPEAT
  179.     INC(i);
  180.   UNTIL NOT (insertname[i] IN PossibleNew) OR (i > len);
  181.   IF i = 0 THEN RETURN(FALSE); END;
  182.   insertname[i] := 0C;
  183.          (* Erstelle Pfadnamen und erzeuge die            *)
  184.          (* entsprechende Datei                           *)
  185.   Concat(filename, AliasDirectory, insertname);
  186.   Concat(filename, filename, ".BAT");
  187.   batchfile := Create(filename);
  188.   IF IOresult() # 0 THEN RETURN(FALSE); END;
  189.          (* Schreibe Batchkommandos zunächst nach Line    *)
  190.   Concat(Line, "@echo off", crlf);             (* DOS 3.3 *)
  191.   FOR i := 2 TO NumberOfParams DO
  192.     ParamStr(help, i);
  193.     IF Pos(help, "#") = 0 THEN      (* neue Zeile beginnt *)
  194.       Concat(Line, Line, crlf);
  195.       IF Length(help) > 1 THEN
  196.                          (* nach # stand kein Leerzeichen *)
  197.         Delete(help, 0, 1);
  198.         Concat(Line, Line, help);
  199.         Concat(Line, Line, ' ');
  200.       END;
  201.     ELSE
  202.          (* keine neue Zeile, also Befehl an die          *)
  203.          (* bestehende anhängen                           *)
  204.       Concat(Line, Line, help);
  205.       Concat(Line, Line, ' ');
  206.     END;
  207.   END;                               (* Datei beschreiben *)
  208.   WrStr(batchfile, Line);
  209.   error := IOresult() # 0;
  210.   Close(batchfile);
  211.   RETURN(NOT error);
  212. END AliasInsert;
  213.  
  214.  
  215. BEGIN
  216.   IOcheck := FALSE;
  217.   DriveString := "C:";
  218.   DefDrv := GetDefaultDrive();
  219.   FindEnvVariable("ALIAS", AliasDirectory);
  220.   Caps(AliasDirectory);
  221.   IF AliasDirectory[0] = CHR(0) THEN
  222.     AliasDirectory := DefaultDirectory;
  223.   END;
  224.          (* prüfe ob das angegebene Verzeichnis existiert *)
  225.   IF len > 1 THEN
  226.     IF AliasDirectory [1] = ':' THEN
  227.                           (* Pfad enthält Laufwerksangabe *)
  228.       Drv := SHORTCARD(AliasDirectory[0]) - SHORTCARD ('A');
  229.     ELSE
  230.       Drv := DefDrv;
  231.       DriveString[0] := CHR(Drv + SHORTCARD('A'));
  232.       Concat(AliasDirectory, DriveString, AliasDirectory);
  233.     END;
  234.   END;
  235.   GetDir(DefDrv + 1, SaveDirectory);
  236.   ChDir(AliasDirectory);
  237.   IF IOresult() # 0 THEN
  238.     IO.WrStr("directory ");
  239.     IO.WrStr(AliasDirectory);
  240.     IO.WrStr(" not found");
  241.     HALT;
  242.   END;
  243.   DriveString[0] := CHAR(DefDrv + SHORTCARD('A'));
  244.   Concat(SaveDirectory, "\", SaveDirectory);
  245.   Concat(SaveDirectory, DriveString, SaveDirectory);
  246.   ChDir(SaveDirectory);
  247.   IF IOresult() # 0 THEN
  248.     IO.WrStr(SaveDirectory);
  249.     IO.WrStr(" xxxxxx");
  250.   END;
  251.   Concat(AliasDirectory, AliasDirectory, '\');
  252.                       (* Anzahl der Parameter feststellen *)
  253.   NumberOfParams := ParamCount();
  254.   IF NumberOfParams = 0 THEN
  255.                                (* alle Kommandos anzeigen *)
  256.     AliasList("*");
  257.   ELSIF NumberOfParams = 1 THEN
  258.     ParamStr(parameter, 1);
  259.     Caps(parameter);
  260.     IF Compare(parameter, "/D") = 0 THEN
  261.                                 (* alle Kommandos löschen *)
  262.       AliasDelete("*");
  263.     ELSE
  264.                           (* bestimmtes Kommando anzeigen *)
  265.       AliasList(parameter);
  266.     END;
  267.   ELSE                            (* mehr als 1 Parameter *)
  268.     ParamStr(parameter, 1);
  269.     Caps(parameter);
  270.     IF Compare(parameter, "/D") = 0 THEN
  271.                            (* bestimmte Kommandos löschen *)
  272.       FOR i := 2 TO NumberOfParams DO
  273.         ParamStr(parameter, i);
  274.         AliasDelete(parameter);
  275.       END;
  276.     ELSE                       (* neues Kommando erzeugen *)
  277.       IF NOT AliasInsert (parameter) THEN
  278.         IO.WrStr ("file error"); IO.WrLn;
  279.       END;
  280.     END;
  281.   END;
  282. END Alias.
  283. (* ------------------------------------------------------ *)
  284. (*                 Ende von ALIAS.MOD                     *)
  285.