home *** CD-ROM | disk | FTP | other *** search
/ Monster Media 1993 #2 / Image.iso / wp / ehp10.zip / CONFIG.C < prev    next >
C/C++ Source or Header  |  1993-04-08  |  17KB  |  397 lines
  1. /****************************************************************/
  2. /*                                                              */
  3. /*      MODUL:  config.c                                        */
  4. /*                                                              */
  5. /*      FUNKTIONEN:                                             */
  6. /*              - save_read (aus Datei lesen)                   */
  7. /*              - check_koors (Koordinaten ueberpruefen)        */
  8. /*              - read_config (Config-Datei einlesen)           */
  9. /*              - save_write (in Datei schreiben)               */
  10. /*              - write_config (Config-Datei schreiben)         */
  11. /*                                                              */
  12. /****************************************************************/
  13.  
  14. #include <fcntl.h>
  15. #include "defs.h"
  16.  
  17. #define SH_SIZ (sizeof (short int))
  18.  
  19. extern char backupflag,helpflag,highblockflag,*reserve_mem(),*conffile;
  20. extern win_typ *akt_winp;
  21. extern marker_typ marker[];
  22. extern puff_typ macro[];
  23.  
  24. int wc_errflag = FALSE;  /* Zeigt an, ob beim Lesen oder Schreiben */
  25.              /* der Config-Datei ein Fehler auftrat    */
  26.  
  27. /*****************************************************************************
  28. *
  29. *  Funktion       Aus Datei lesen mit Fehlerbehandlung (save_read)
  30. *  --------
  31. *
  32. *  Parameter    : f         :
  33. *                   Typ          : int
  34. *                   Wertebereich : Dateihandle
  35. *                   Bedeutung    : Datei, aus der gelesen werden soll
  36. *
  37. *                 b         :
  38. *                   Typ          : char *
  39. *                   Wertebereich : Pointer auf Speicherbereich
  40. *                   Bedeutung    : Puffer, in den Daten gelesen werden
  41. *
  42. *                 n         :
  43. *                   Typ          : int
  44. *                   Wertebereich : 0 - MAX_INT
  45. *                   Bedeutung    : Anzahl einzulesender Bytes
  46. *
  47. *  Beschreibung : Aus der Datei mit dem Handle f werden n Bytes in den
  48. *                 Puffer b gelesen. Ist dies nicht moeglich, so wird eine
  49. *                 Fehlermeldung ausgegeben und versucht, das Config-File
  50. *                 zu loeschen. Gelingt dies nicht, so wird eine entspre-
  51. *                 chende Meldung ausgegeben.
  52. *                 Diese Funktion wird nur von read_config() aufgerufen.
  53. *
  54. *****************************************************************************/
  55.  
  56. void save_read(f,b,n)
  57. int f,n;
  58. char *b;
  59. {
  60.   if(read(f,b,n) < n)  /* Falls Lesen fehlschlaegt, Meldung ausgeben */
  61.   {                    /* und Datei loeschen.                        */
  62.     pe_or(PROMPT_ERRCONF);
  63.     close (f);
  64.     if(unlink(conffile) < 0)
  65.       pe_or(PROMPT_ERRDELETE);
  66.     ende(1, TRUE);  /* da noch nichts gemacht wurde, muss auch nichts gespeichert */
  67.   }                 /* werden */
  68. }
  69.  
  70. /*****************************************************************************
  71. *
  72. *  Funktion       Koordinaten ueberpruefen und ggf. anpassen (check_koors)
  73. *  --------
  74. *
  75. *  Parameter    : dy        :
  76. *                   Typ          : int *
  77. *                   Wertebereich : Pointer auf Integer-Variable
  78. *                   Bedeutung    : Hoehe des Bereichs in Bildschirmzeilen
  79. *
  80. *                 dx        :
  81. *                   Typ          : int *
  82. *                   Wertebereich : Pointer auf Integer-Variable
  83. *                   Bedeutung    : Breite des Bereichs in Spalten
  84. *
  85. *                 y         :
  86. *                   Typ          : int *
  87. *                   Wertebereich : Pointer auf Integer-Variable
  88. *                   Bedeutung    : Anfangszeile
  89. *
  90. *                 x         :
  91. *                   Typ          : int *
  92. *                   Wertebereich : Pointer auf Integer-Variable
  93. *                   Bedeutung    : Anfangsspalte
  94. *
  95. *  Beschreibung :   Es wird ueberprueft, ob ein Fenster mit den uebergebenen
  96. *                   Koordinaten vollstaendig auf dem Bildschirm dargestellt
  97. *                   werden koennte (die Groesse eines Rahmens wird intern
  98. *                   beruecksichtigt). Ist dies nicht der Fall, so werden
  99. *                   die Koordinaten angepasst.
  100. *
  101. *****************************************************************************/
  102.  
  103. void check_koors(dy,dx,y,x)
  104. int *dy,*dx,*y,*x;
  105. {
  106.   if(*dy > MAX_HEIGHT - 2)  /* -2 wg. rahmen */
  107.     *dy = MAX_HEIGHT - 2;
  108.  
  109.   if(*y + *dy > MAX_HEIGHT-2 + START_Y)
  110.     *y = MAX_HEIGHT - *dy - 2 + START_Y;
  111.  
  112.   if(*dx > MAX_WIDTH - 2)
  113.     *dx = MAX_WIDTH - 2;
  114.  
  115.   if(*x + *dx > MAX_WIDTH - 2 + START_X)
  116.     *x = MAX_WIDTH - *dx - 2 + START_X;
  117. }
  118.  
  119. /*****************************************************************************
  120. *
  121. *  Funktion       Config-Datei einlesen (read_config)
  122. *  --------
  123. *
  124. *  Parameter    : argc :
  125. *                   Typ          : int
  126. *                   Wertebereich : 1 - ANZ_WIN+1 (max. Anz. Fenster+1)
  127. *                   Bedeutung    : Anzahl v. Parameter in der Kommandozeile
  128. *
  129. *  Ergebnis     :
  130. *                   Typ          : int
  131. *                   Wertebereich : 0 - ANZ_WIN (max. Anz. Fenster)
  132. *                   Bedeutung    : Anzahl eingelesener Dateien
  133. *
  134. *  Beschreibung :  Es wird versucht, eine Config-Datei einzulesen.
  135. *                  Existiert keine solche Datei, so wird 0 zurueckgegeben.
  136. *                  Die Config-Datei hat folgenden Aufbau:
  137. *                    char helpflag,backupflag,highblockflag;
  138. *                    short int Anzahl Macros in Datei
  139. *                    short int Anzahl short ints 1. Macro
  140. *                     <entsprechend viele short ints>
  141. *                    ... gleiches fuer alle anderen Macros
  142. *                    short int Anzahl der Fenster
  143. *                    <Anzahl der Fenster> Strukturen vom Typ win_typ
  144. *                    Hierbei ist zu beachten, dass in dem Struktur-
  145. *                    element filename die Laenge des Dateinamens in Byte
  146. *                    steht. Der Filename selbst folgt der jeweiligen
  147. *                    Struktur unmittelbar und ist nicht durch ein bes.
  148. *                    Zeichen terminiert.
  149. *                    Fuer jedes Fenster wird die entsprechende Datei
  150. *                    geladen und ein Fenster geoeffnet.
  151. *                    short int Anzahl Marker
  152. *                    <Anzahl Marker> Strukturen vom Typ marker_typ
  153. *                  Endet die Datei unerwartet, so wird eine Fehlermel-
  154. *                  dung ausgegeben und das Programm abgebrochen.
  155. *
  156. *****************************************************************************/
  157.  
  158. int read_config(argc)
  159. int argc;
  160. {
  161.   /* *** interne Daten und Initialisierung *** */
  162.   int       i,          /* Zähler für Fenster, Macros etc.           */
  163.         fh,         /* Filehandle fuer Config-Datei              */
  164.         mnum=0,     /* Schleifenzaehler fuer Einlesen der Macors */
  165.         msizeb,     /* Macrogroesse in Bytes                     */
  166.         old_tl,     /* Zwischenspeicher fuer Cursorzeile         */
  167.         old_sc,     /* Zwischenspeicher fuer Cursorspalte        */
  168.         namelen;    /* Laenge des Filenamens des aktuellen Fstr. */
  169.   short int msize,      /* Macrogroesse in short int gemessen        */
  170.         anz_win=0,  /* Anzahl der Fenster                        */
  171.         anz_marker, /* Anzahl der Marker                         */
  172.         anz_macros; /* Anzahl der Macros                         */
  173.   win_typ   *old_next,  /* Zwischenspeicher der Verzeigerung des ak- */
  174.         *old_prev,  /* tuell eingelesenen Fensters, da abgespei- */
  175.             /* cherte Verzeigerung jetzt falsch ist.     */
  176.         dummy;      /* Zum evtl. Skippen von Fenstereintraegen   */
  177.  
  178.   if(access(conffile,4))   /* Kann das Config-File gelesen werden ? */
  179.     return(0);             /* kein Config-File */
  180.   fh = open(conffile,O_RDONLY | O_BINARY);    /* Datei oeffnen */
  181.   save_read(fh,&helpflag,1);       /* Die drei globalen Flags einlesen */
  182.   save_read(fh,&backupflag,1);
  183.   save_read(fh,&highblockflag,1);
  184.  
  185.   save_read(fh,&anz_macros,SH_SIZ); /* Anzahl der Macros einlesen */
  186.   for(i=anz_macros;i>0;i--)         /* Fuer alle Macros Groesse   */
  187.   {                                 /* und Inhalt einlesen        */
  188.     save_read(fh,&msize,SH_SIZ);
  189.     if(msize >= 0)
  190.       if(mnum < ANZ_MACROS)
  191.     if(!msize)
  192.       macro[mnum].begin = macro[mnum].end = NULL; /* leere Macros auf Null */
  193.     else
  194.     {
  195.       msizeb = msize * SH_SIZ;
  196.       save_read(fh,macro[mnum].begin = (short int *) reserve_mem(msizeb),msizeb);
  197.       macro[mnum].end = macro[mnum].begin + msize - 1;
  198.       mnum++;
  199.     }
  200.       else
  201.     lseek(fh,(long)(msize * SH_SIZ),1); /* Zum naechsten Macro in Datei */
  202.   }
  203.   if(argc == 1)         /* no params - use old windows and markers */
  204.   {
  205.     save_read(fh,&anz_win,SH_SIZ); /* Fensteranzahl einlesen */
  206.     for(i=anz_win;i>0;i--)
  207.     {
  208.       if(koppel_win())             /* Neues Fenster in Liste einhaengen */
  209.       {
  210.     old_next = akt_winp->next; /* Verzeigerung merken */
  211.     old_prev = akt_winp->prev;
  212.     save_read(fh,akt_winp,sizeof(win_typ)); /* Fensterdaten einlesen */
  213.     akt_winp->next = old_next; /* Verzeigerung wieder korrigieren    */
  214.     akt_winp->prev = old_prev;
  215.     akt_winp->filename = reserve_mem((namelen = (int)akt_winp->filename)+1);
  216.     save_read(fh,akt_winp->filename,namelen); /* Filenamen einlesen  */
  217.     akt_winp->filename[namelen] = '\0'; /* Filenamen abschliessen    */
  218.     old_tl = akt_winp->textline; /* Cursorposition zwischenspeichern */
  219.     old_sc = akt_winp->screencol;
  220.     if(!lies_file())             /* Dateitext einlesen */
  221.     {                            /* klappt das nicht, Fenster wieder */
  222.       gb_win_frei();             /* freigeben und Fensteranzahl um   */
  223.       anz_win--;                 /* eins reduzieren.                 */
  224.       setz_cursor(W_NOTAKT);     /* lies_file macht kein setz_cursor */
  225.     }
  226.     else  /* Einlesen des Textes hat geklappt */
  227.     {
  228.       /* Ueberpruefen, ob Fenster auf Bildschirm passt, ggf. anpassen */
  229.       check_koors(&akt_winp->dy,&akt_winp->dx,&akt_winp->y,&akt_winp->x);
  230.       check_koors(&akt_winp->ady,&akt_winp->adx,&akt_winp->ay,&akt_winp->ax);
  231.       if(old_tl > akt_winp->maxline)  /* nur wenn old_tl groesser maxline */
  232.       {                               /* kann auch ws_line zu gross sein  */
  233.         old_tl = akt_winp->maxline;
  234.         if(akt_winp->ws_line > akt_winp->maxline)
  235.           if((akt_winp->ws_line = akt_winp->maxline - akt_winp->dy + 1) < 0)
  236.         akt_winp->ws_line = 0;
  237.       }
  238.       gotox(old_tl); /* Cursorposition restaurieren */
  239.  
  240.       /* Wenn Cursorspalte zu gross, anpassen */
  241.       if((akt_winp->screencol = old_sc) > MAXLENGTH)
  242.         akt_winp->screencol = MAXLENGTH;
  243.       if(akt_winp->lastcol > MAXLENGTH)
  244.         akt_winp->lastcol = MAXLENGTH;
  245.  
  246.       /* Falls Cursor ausserhalb des Fensters steht, */
  247.       /* Fensterinhalt anpassen.                     */
  248.       if(akt_winp->ws_line + akt_winp->dy <= akt_winp->textline)
  249.         akt_winp->ws_line = akt_winp->textline - akt_winp->dy + 1;
  250.       if(akt_winp->ws_col + akt_winp->dx <= akt_winp->screencol)
  251.         akt_winp->ws_col = akt_winp->screencol - akt_winp->dx + 1;
  252.       akt_winp->winp = newwin(akt_winp->dy+2,akt_winp->dx+2,akt_winp->y,akt_winp->x);
  253.       init_win();  /* Fenster mit Curses anlegen und initialisieren */
  254.       show_win(W_NOTAKT); /* Fensterinhalt auf Bildschirm darstellen */
  255.     }
  256.       }
  257.       else  /* Falls kein Fenster mehr in Liste passte: */
  258.       {
  259.     print_err(W_COUNT_ERRTEXT);   /* Fehlermeldung ausgeben */
  260.     while(i--)                    /* Alle weiteren Fenstereintraege skippen */
  261.     {
  262.       save_read(fh,&dummy,sizeof(win_typ));
  263.       lseek(fh,(long)dummy.filename,1);
  264.     }
  265.     break;     /* keine weiteren Dateien lesen */
  266.       }
  267.     }
  268.  
  269.     rahmen(W_AKT); /* Cursor setzen, Rahmen highlighten */
  270.     setz_cursor(W_AKT); 
  271.  
  272.     save_read(fh,&anz_marker,SH_SIZ); /* Anzahl der Marker einlesen */
  273.     if(anz_marker > ANZ_MARKER)
  274.       anz_marker = ANZ_MARKER;
  275.     save_read(fh,marker,anz_marker * sizeof(marker_typ));
  276.     for(i=0;i<anz_marker;i++)
  277.       if(marker[i].col > MAXLENGTH)   /* falls EHP in der Zwischenzeit mit */
  278.       marker[i].col = MAXLENGTH;  /* einer Verringerung von MAXLENGTH  */
  279.   }                                   /* neu kompiliert wurde              */
  280.   close(fh);
  281.   return(anz_win);
  282. }
  283.  
  284. /*****************************************************************************
  285. *
  286. *  Funktion       In Datei schreiben mit Fehlerbehandlung (save_write)
  287. *  --------
  288. *
  289. *  Parameter    : f         :
  290. *                   Typ          : int
  291. *                   Wertebereich : Dateihandle
  292. *                   Bedeutung    : Datei, in die geschrieben werden soll
  293. *
  294. *                 b         :
  295. *                   Typ          : char *
  296. *                   Wertebereich : Pointer auf Speicherbereich
  297. *                   Bedeutung    : Puffer, aus dem Daten geschrieben werden
  298. *
  299. *                 n         :
  300. *                   Typ          : int
  301. *                   Wertebereich : 0 - MAX_INT
  302. *                   Bedeutung    : Anzahl zu schreibender Bytes
  303. *
  304. *  Beschreibung : In die Datei mit dem Handle f werden n Bytes aus dem
  305. *                 Puffer b gelesen. Ist dies nicht moeglich, so wird die
  306. *                 Variable wc_errflag gesetzt.
  307. *                 Ist wc_errflag schon gesetzt, wenn die Funktion aufge-
  308. *                 rufen wird, so wird nichts in die Datei geschrieben.
  309. *                 Diese Funktion wird nur von write_config() aufgerufen.
  310. *
  311. *****************************************************************************/
  312.                             
  313. void save_write(f,b,n)
  314. int f,n;
  315. char *b;
  316. {
  317.   if(!wc_errflag && (write(f,b,n) < n)) /* liefert write Fehler,   */
  318.     wc_errflag = TRUE;                  /* wird wc_errflag gesetzt */
  319. }
  320.  
  321. /*****************************************************************************
  322. *
  323. *  Funktion       Config-Datei schreiben (write_config)
  324. *  --------
  325. *
  326. *  Beschreibung : Das Config-File wird in dem in read_config beschriebenen
  327. *                 Format abgespeichert. Trat dabei ein Fehler auf, so wird
  328. *                 eine entsprechende Fehlermeldung ausgegeben und die Datei
  329. *                 geloescht.
  330. *
  331. *****************************************************************************/
  332.  
  333. void write_config()
  334. {
  335.   /* *** interne Daten *** */
  336.   int       fh,         /* Handle fuer Config-Datei               */
  337.         namelen,    /* Laenge des Filenamens fuer ein Fenster */
  338.         i;          /* Schleifenzaehler                       */
  339.   short int msize,      /* Macrogroesse                           */
  340.         anz_macros, /* Anzahl der belegten Macros             */
  341.         anz_win,    /* Anzahl der Fenster                     */
  342.         anz_marker; /* Anzahl der belegten Marker             */
  343.   char      *name;      /* Filename des zu schreibenden Fensters  */
  344.   win_typ   *w;         /* Pointer fuer Schleife ueber Windows    */
  345.  
  346.   if((fh = open(conffile,O_WRONLY | O_CREAT | O_TRUNC | O_BINARY,0666)) < 0)
  347.   {
  348.     print_err("Konnte Config-Datei nicht zum Schreiben oeffnen!");
  349.     return;                /* kein Config-File */
  350.   }
  351.  
  352.   wc_errflag = FALSE; /* Fehlerflag zuruecksetzen */
  353.  
  354.   /* globale flags schreiben */
  355.   save_write(fh,&helpflag,1);
  356.   save_write(fh,&backupflag,1);
  357.   save_write(fh,&highblockflag,1);
  358.  
  359.   /* macros schreiben */
  360.   for(anz_macros = ANZ_MACROS; !macro[anz_macros-1].begin; anz_macros--);
  361.   save_write(fh,&anz_macros,SH_SIZ);    /* falls hintere macros leer, nicht */
  362.   for(i=0;i<anz_macros;i++)             /* schreiben */
  363.   {
  364.     msize = macro[i].end - macro[i].begin + 1;    /* size in short ints */
  365.     save_write(fh,&msize,SH_SIZ);
  366.     if(msize > 0)
  367.       save_write(fh,macro[i].begin,msize * SH_SIZ); /* Inhalt schreiben */
  368.   }
  369.  
  370.   /* windows schreiben */
  371.   for(w=akt_winp->next->next,anz_win = 0;w != akt_winp->next;w=w->next,anz_win++);
  372.   save_write(fh,&anz_win,SH_SIZ);  /* Anzahl der Fenster schreiben */
  373.   for(w = akt_winp->next->next,i=anz_win;i>0;w = w->next,i--)
  374.   {
  375.     name = w->filename; /* Pointer auf Filename durch dessen Laenge ersetzen */
  376.     w->filename = (char*) (namelen = strlen(w->filename));
  377.     save_write(fh,w,sizeof(win_typ)); /* Fensterstruktur abspeichern */
  378.     save_write(fh,name,namelen); /* Dateinamen abspeichern */
  379.     w->filename = name;          /* Filenamen rekonstruieren */
  380.   }
  381.  
  382.   /* marker schreiben */
  383.   /* Zuerst Anzahl der belegten Marker ermitteln */
  384.   for(anz_marker = ANZ_MARKER; marker[anz_marker-1].window == -1; anz_marker--);
  385.   save_write(fh,&anz_marker,SH_SIZ); /* Anzahl der Marker schreiben */
  386.   /* Belegten Anteil des Markerfeldes abspeichern */
  387.   save_write(fh,marker,anz_marker * sizeof(marker_typ));
  388.  
  389.   close(fh);
  390.   if(wc_errflag)  /* trat beim Abspeichern ein Fehler auf, dann loeschen */
  391.   {
  392.     print_err(PROMPT_ERRWRTCFG);
  393.     if(unlink(conffile) < 0)
  394.       print_err(PROMPT_ERRUNLINK);
  395.   }
  396. }
  397.