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