home *** CD-ROM | disk | FTP | other *** search
/ Turbo Toolbox / Turbo_Toolbox.iso / extra18 / bootctrl / bootctrl.c < prev    next >
Encoding:
C/C++ Source or Header  |  1991-12-06  |  6.0 KB  |  159 lines
  1. /* ------------------------------------------------- */
  2. /*                    BOOTCTRL.C,                    */
  3. /*        (c) 1991 Elmar Warken & DMV-Verlag         */
  4. /*    Compiler: Turbo C, Turbo C++, Borland C++      */
  5. /* ------------------------------------------------- */
  6.  
  7. /*  Definitionen für den Aufbau einer Steuerdatei:   */
  8. #define FileListBegin 50
  9. #define FileListLen 500
  10.  
  11. #ifndef __BORLANDC__
  12. #pragma inline
  13. #elif __BORLANDC__ < 0x200
  14. #pragma inline
  15. #endif
  16.  
  17. #include "driver.h"
  18.  
  19. #define C(s) { for(c=s;*c++!=32&&*c!=10;); *--c=0; }
  20. /* Schneidet den als Parameter angegebenen String    */
  21. /* nach dem ersten Leerzeichen oder beim Zeilenende  */
  22. /* ab, der Zeiger c zeigt danach auf diese Position. */
  23.  
  24. char
  25.   b[8096],            /* Puffer für Dateioperationen */
  26.   f[10][FileListLen], /* Kopierlisten, f für files   */
  27.   s[FileListBegin + FileListLen], /* eine Zeile der  */
  28.                                 /*   Steuerdatei     */
  29.   t[80],              /* Parameter in CONFIG.SYS     */
  30.   e = 0;              /* Errorflag                   */
  31.  
  32. /* Da das Format der Gerätetreiber mit dem normalen  */
  33. /* Startcode nicht hergestellt werden kann, wird der */
  34. /* Startcode durch das Modul DRIVER0.ASM ersetzt.    */
  35. /* Daher können auch keine Standardbibliotheken ver- */
  36. /* wendet werden; die notwendigen Funktionen rufen   */
  37. /* den Int 21 über die folgende Funktion direkt auf. */
  38. /* Die resultierende SYS-Datei ist daher mit Borland */
  39. /* C++ (286-Code, Standard Stack Frame off) nur 627  */
  40. /* Bytes groß.                                       */
  41.  
  42. int I(char*s, int h, int c, char cm)
  43. /* Ruft Interrupt 21h mit Unterfunktion cm auf.      */
  44. /* Geeignet für folgende Funktionen:                 */
  45. /* Einlesen eines Strings cm = 7;                    */
  46. /* Ausgabe eines durch "$" begrenzten Strings cm = 9;*/
  47. /* Erstellen einer Datei cm = 60, s: Dateiname,      */
  48. /* Rückgabe: handle;                                 */
  49. /* Öffnen einer Datei für Leseoperationen cm = 61,   */
  50. /* s: Dateiname, Rückgabe: handle;                   */
  51. /* Schließen einer Datei cm = 62, h: handle          */
  52. /* Lesen aus einer Datei cm = 63, h: handle, c: zu   */
  53. /* lesende Bytes, s: Datenpuffer, Rückgabe : Anzahl  */
  54. /* der gelesenen Bytes;                              */
  55. /* Schreiben in eine Datei cm = 64, h: handle, c: zu */
  56. /* schreibende Bytes, s: Daten.                      */
  57. /* Der von DOS zurückgegebene Wert wird auch von der */
  58. /* Funktion zurückgegeben, im Falle eines Fehlers    */
  59. /* wird das Errorflag gesetzt.                       */
  60.  
  61. {
  62.   asm mov ah, cm;
  63.   asm mov al, 2;
  64.   asm mov bx, h;
  65.   asm mov cx, c;
  66.   asm mov dx, s;
  67.   asm int 21h;
  68.   asm jnb X;
  69.   asm mov e,  1;
  70. X:
  71.   return(_AX);
  72. }
  73.  
  74. void go()
  75. /* wird von M() in DRIVER.H aufgerufen               */
  76. {
  77.   char *n, *c, *d,      /* Mehrzweckzeiger           */
  78.        *a;              /* Zeiger in Parameterstring */
  79.   int h,                /* Handle der Steuerdatei    */
  80.                         /* für das Kopieren :        */
  81.       q,                /* Handle Quelle             */
  82.       z,                /* Handle Ziel               */
  83.       j, i = 0;
  84.  
  85.   /* Die Zeile aus der CONFIG.SYS wird ab dem        */
  86.   /* Gleichheitszeichen in den String "t" kopiert.   */
  87.   /* Zu p siehe DRIVER.H                             */
  88.   for(;*p -> l != 13; t[i++] = *p -> l++);
  89.   t[i] = 32; C(t); a = c + 2;
  90.   /* a zeigt jetzt auf den Namen der 1. Steuerdatei  */
  91.  
  92.   while(*a != 0) {
  93.     /* Öffnen der Menüdatei                          */
  94.     C(a);
  95.     h = I(a, 0, 0, 61); if (e) break;
  96.     a = ++c;         /* a zeigt bereits auf den      */
  97.                      /* nächsten Namen in der Datei  */
  98.     d = f[0];
  99.  
  100.     /* gesamte Steuerdatei in Puffer einlesen,       */
  101.     /* max. 8 KByte Länge der Datei in i speichern.  */
  102.     i = I(n = b, h, 8096, 63);
  103.     do{
  104.       s[FileListBegin - 1] = 10;
  105.       /* falls Zeile vor der 50. Spalte endet:       */
  106.       /* Zeilenende an 50. Spalte setzen, damit die  */
  107.       /* nächste while-Schleife funktioniert.        */
  108.       /* eine Zeile in s speichern:                  */
  109.       for(c=s;(*c = *n++) != 10; c++, i--); i--;
  110.       /* Text ausgeben:                              */
  111.       I(s, 0, 0, 9); I("\n\r$", 0, 0, 9);
  112.       /* zu kopierende Dateien speichern             */
  113.       /* (d zeigt in f-Array, c auf Spalte 50):      */
  114.       for(j = 0, c = s + 49; j++<FileListLen;
  115.         *d++ = *c++);
  116.     }
  117.     while(i);
  118.     /* Da i am Anfang gleich der Dateilänge ist, und */
  119.     /* dann pro Zeichen dekrementiert wird, zeigt    */
  120.     /* i = 0 das Dateiende an.                       */
  121.  
  122.     I(0, h, 0, 62);               /* Datei schließen */
  123.  
  124.     /* Nächstes Zeichen von der Tastatur lesen und   */
  125.     /* umwandeln                                     */
  126.     j = (I(0, 0, 0, 7) & 255) - 48;
  127.     n = f[j];
  128.     /* n zeigt jetzt auf die Liste der Dateien, die  */
  129.     /* kopiert werden sollen, das Listenende ist     */
  130.     /* durch das Zeilenende gekennzeichnet.          */
  131.     while (*n != 10)
  132.     {
  133.       C(n);             /* Quelldateinamen begrenzen */
  134.       d = ++c;
  135.       C(d);             /* ebenso Zieldateinamen     */
  136.       /* Dateien für das Umkopieren öffnen bzw.      */
  137.       /* erzeugen.                                   */
  138.       q = I(n, 0, 0, 61); if (e) break;
  139.       z = I(d, 0, 0, 60);
  140.  
  141.       /* Datei in 8 KByte-Schritten kopieren, der    */
  142.       /* interne Interruptaufruf gibt die Zahl der   */
  143.       /* gelesenen Zeichen zurück. Wenn diese nicht  */
  144.       /* mehr gleich 8 KByte ist, ist das Dateiende  */
  145.       /* erreicht.                                   */
  146.       while(I(b, z, I(b, q, 8096, 63), 64) == 8096);
  147.  
  148.       /* Schließen der Dateien                       */
  149.       I(0, q, 0, 62);
  150.       I(0, z, 0, 62);
  151.       n = ++c;
  152.       /* n zeigt auf nächste Quelldatei oder auf das */
  153.       /* Zeilenendezeichen                           */
  154.     }
  155.   }
  156. }
  157. /* ------------------------------------------------- */
  158. /*               Ende von BOOTCTRL.C,                */
  159.