home *** CD-ROM | disk | FTP | other *** search
/ back2roots/padua / padua.7z / padua / uucp / auucp+-1.02 / fuucp_plus_src.lzh / uucplib / buffer / buffer.bak next >
Encoding:
Text File  |  1991-04-05  |  11.5 KB  |  389 lines
  1. /* -------------------------------------------------------------------------------------- */
  2.  
  3. #include "exec/memory.h"
  4. #include "dos/dos.h"
  5. #include "dos/dosextens.h"
  6. #include "clib/exec_protos.h"
  7. #include "clib/dos_protos.h"
  8. #include "pragmas/exec_pragmas.h"
  9. #include "pragmas/dos_pragmas.h"
  10. #include <string.h>
  11. #include "buffer.h"
  12.  
  13. /* -------------------------------------------------------------------------------------- */
  14.  
  15. /*  lese_puffer - !PRIVATE ROUTINE!
  16.     Liest so viel wie m÷glich Byte in den Buffer ein. Grundannahme ist, da▀ der
  17.     Puffer "ausbenutzt" ist. Es wird sowohl die neue Ausnutzung des Puffers wie
  18.     auch der Zeiger auf die aktuelle Position korrigiert.
  19. */
  20.  
  21. STATIC BOOL lese_puffer (struct datei *meine_datei)
  22. {
  23.   LONG anzahl;
  24.  
  25.   if (meine_datei->modus == MODE_OLDFILE)
  26.   {
  27.     anzahl = Read (meine_datei->datei_zeiger, meine_datei->puffer_zeiger, PUFFER_GROESSE);
  28.     if (anzahl == -1)
  29.     {
  30.       return (FALSE);
  31.     }
  32.     meine_datei->puffer_voelle = anzahl;
  33.     meine_datei->akt_position = 0;
  34.     return (TRUE);
  35.   }  
  36.   return (FALSE);
  37. }
  38.  
  39. /* -------------------------------------------------------------------------------------- */
  40.  
  41. /*  schreibe_puffer - !PRIVATE ROUTINE!
  42.     Schreib den Puffer bis "akt_position" in die Datei auf dem gewΣhlten Medium.
  43.     "akt_position" wird danach zurⁿckgesetzt, der Puffer kann neu benutzt werden.
  44.     Sollten keine Zeichen im Puffer sein (weil "akt_position" auf 0 steht), wird
  45.     "TRUE" zurⁿckgeliefert.
  46. */
  47.  
  48. STATIC BOOL schreibe_puffer (struct datei *meine_datei)
  49. {
  50.   LONG anzahl;
  51.  
  52.   if (meine_datei->modus == MODE_NEWFILE)
  53.   {
  54.     if (meine_datei->akt_position > 0)
  55.     {
  56.       anzahl = Write (meine_datei->datei_zeiger, meine_datei->puffer_zeiger, meine_datei->akt_position);
  57.       if (anzahl == -1)
  58.       {
  59.         return (FALSE);
  60.       }
  61.       if (anzahl != meine_datei->akt_position)
  62.       {
  63.         return (FALSE);
  64.       }
  65.       meine_datei->akt_position = 0;
  66.       return (TRUE);
  67.     }
  68.     else
  69.     {
  70.       return (TRUE);
  71.     }
  72.   }  
  73.   return (FALSE);
  74. }
  75.  
  76. /* -------------------------------------------------------------------------------------- */
  77.  
  78. /*  oeffne_datei
  79.     ╓ffnet Datei zum sequenziellen Lesen (Modus MODE_OLDFILE) oder legt neue
  80.     Datei zum sequenziellen Schreiben an (Modus MODE_NEWFILE). Rⁿckgabe ist
  81.     eine Struktur vom Typ "datei". Rⁿckgabe ist NULL wenn Datei nicht ge-
  82.     ÷ffnet werden kann oder kein RAM fⁿr Puffer da ist.
  83. */
  84.  
  85. struct datei * oeffne_datei (char *name, ULONG modus)
  86. {
  87.   struct datei *meine_datei;
  88.   char *mein_puffer;
  89.   BPTR mein_bptr;
  90.   BOOL ergebnis;
  91.  
  92.   meine_datei = AllocMem (sizeof (struct datei), MEMF_CLEAR|MEMF_PUBLIC);
  93.   if (meine_datei)
  94.   {
  95.     mein_puffer = AllocMem (PUFFER_GROESSE, MEMF_CLEAR);
  96.     if (mein_puffer)
  97.     {
  98.       if ((modus == MODE_OLDFILE) || (modus == MODE_NEWFILE))
  99.       {
  100.         mein_bptr = Open (name, modus);
  101.         if (mein_bptr)
  102.         {
  103.           meine_datei->datei_zeiger = mein_bptr;
  104.           meine_datei->puffer_zeiger = mein_puffer;
  105.           meine_datei->puffer_groesse = PUFFER_GROESSE;
  106.           meine_datei->akt_position = 0;
  107.           meine_datei->modus = modus;
  108.           if (modus == MODE_OLDFILE)
  109.           {
  110.             ergebnis = lese_puffer (meine_datei);
  111.             if (ergebnis == TRUE)
  112.             {
  113.               return (meine_datei);
  114.             }
  115.           }
  116.           else
  117.           {
  118.             meine_datei->puffer_voelle = 0;
  119.             return (meine_datei);
  120.           }
  121.           Close (mein_bptr);
  122.         }
  123.       }
  124.       FreeMem (mein_puffer, PUFFER_GROESSE);
  125.     }
  126.     FreeMem (meine_datei, sizeof (struct datei));
  127.   }
  128.   return (NULL);
  129. }
  130.  
  131. /* -------------------------------------------------------------------------------------- */
  132.  
  133. /*  hole_zeichen
  134.     Holt aus der Datei, welche in "*meine_datei" uebergeben wird die
  135.     gewⁿnschte Anzahl von Byte und kopiert diese in den "puffer". Benutzer mu▀
  136.     selbst dafⁿr sorgen da▀ der Puffer ausreichend gro▀ ist.
  137.     Als Rⁿckgabe gibts die Anzahl der gelesenen Byte oder einen Fehlercode:
  138.  
  139.     LESE_FEHLER                   : Datei konnte gelesen werden. Pufferung
  140.                                     defekt. Datei schlie▀en und neu ÷ffnen.
  141.     FALSCHER_MODUS                : Datei ist mit Modus "MODE_NEWFILE" ge-
  142.                                     ÷ffnet und kann nicht gelesen werden.
  143. */
  144.  
  145. LONG hole_zeichen (struct datei *meine_datei, char *puffer, ULONG anzahl)
  146. {
  147.   LONG zaehler = 0;
  148.   BOOL ergebnis;
  149.  
  150.   if (meine_datei->modus == MODE_OLDFILE)
  151.   {
  152.     if (meine_datei->akt_position > (meine_datei->puffer_groesse - 1))
  153.     {
  154.       ergebnis = lese_puffer (meine_datei);
  155.       if (ergebnis == FALSE)
  156.       {
  157.         return (LESE_FEHLER);
  158.       }
  159.     }
  160.     if (meine_datei->akt_position > (LONG) (meine_datei->puffer_voelle - 1))
  161.     {
  162.       return (0L);
  163.     }
  164.     while (anzahl > 0)
  165.     {
  166.       if (meine_datei->akt_position + anzahl > meine_datei->puffer_voelle)
  167.       {
  168.         memcpy (puffer + zaehler, meine_datei->puffer_zeiger + meine_datei->akt_position,
  169.                 meine_datei->puffer_voelle - meine_datei->akt_position);
  170.         zaehler += meine_datei->puffer_voelle - meine_datei->akt_position;
  171.         anzahl -= meine_datei->puffer_voelle - meine_datei->akt_position;
  172.         ergebnis = lese_puffer (meine_datei);
  173.         if (ergebnis == FALSE)
  174.         {
  175.           return (LESE_FEHLER);
  176.         }
  177.         if (meine_datei->puffer_voelle == 0)
  178.         {
  179.           return (zaehler);
  180.         }
  181.       }
  182.       else
  183.       {
  184.         memcpy (puffer + zaehler, meine_datei->puffer_zeiger + meine_datei->akt_position, anzahl);
  185.         meine_datei->akt_position += anzahl;
  186.         zaehler += anzahl;
  187.         return (zaehler);
  188.       }
  189.     }
  190.   }
  191.   else
  192.   {
  193.     return (FALSCHER_MODUS);
  194.   }
  195. }
  196.  
  197. /* -------------------------------------------------------------------------------------- */
  198.  
  199. /*  schliesse_datei
  200.     Schlie▀ die Datei (und schreibt vorher beim Schreibmodus den Puffer in
  201.     die Datei) und gibt allen allozierten Speicher wieder frei. Diese Routine
  202.     liefert einen der definierten Fehlercodes zurⁿck. Beim Fehler "NICHT_SCHLIESSBAR"
  203.     werden die Strukturen und der Puffer _*NICHT*_ freigegeben und einen
  204.     erneuten Schliessversuch m÷glich zu machen.
  205.  
  206.     NICHT_SCHLIESSBAR                 : Datei kann nicht geschlossen werden. Keine
  207.                                         ─nderung durchgefⁿhrt.
  208.     KEIN_FEHLER                       : Datei dicht und Puffer entfernt.
  209.     MEDIUM_VOLL                       : Medium ist voll oder Puffer konnte aus anderen
  210.                                         Grⁿnden nicht geschrieben werden.
  211. */
  212.  
  213. LONG schliesse_datei (struct datei *meine_datei)
  214. {
  215.   BOOL ergebnis;
  216.  
  217.   if (meine_datei->modus == MODE_OLDFILE)
  218.   {
  219.     ergebnis = Close (meine_datei->datei_zeiger);
  220.     if (ergebnis == FALSE)
  221.     {
  222.       return (NICHT_SCHLIESSBAR);
  223.     }      
  224.     FreeMem (meine_datei->puffer_zeiger, PUFFER_GROESSE);
  225.     FreeMem (meine_datei, sizeof (struct datei));
  226.     return (KEIN_FEHLER);
  227.   }
  228.   else
  229.   {
  230.     ergebnis = schreibe_puffer (meine_datei);
  231.     if (ergebnis == FALSE)
  232.     {
  233.       return (MEDIUM_VOLL);
  234.     }
  235.     ergebnis = Close (meine_datei->datei_zeiger);
  236.     if (ergebnis == FALSE)
  237.     {
  238.       return (NICHT_SCHLIESSBAR);
  239.     }
  240.     FreeMem (meine_datei->puffer_zeiger, PUFFER_GROESSE);
  241.     FreeMem (meine_datei, sizeof (struct datei));
  242.     return (KEIN_FEHLER);
  243.   }
  244. }
  245.  
  246. /* -------------------------------------------------------------------------------------- */
  247.  
  248. /*  schreibe_zeichen
  249.     Schreibt die gewⁿnschte Anzahl von Byte in die Datei die mit "*meine_datei"
  250.     ⁿbergeben wird. Rⁿckgabe ist ein Fehlercode:
  251.  
  252.     SCHREIB_FEHLER            : Datei konnte nicht geschrieben werden. Datei und
  253.                                 Pufferung defekt. Bitte schlie▀en und l÷schen.
  254.     FALSCHER_MODUS            : Datei ist mit Modus "MODE_OLDFILE" ge÷ffnet worden.
  255.                                 Es wurde keine ─nderung vorgenommen.
  256.     KEIN_FEHLER               : "anzahl" wurde zumindest in den Puffer korrekt ge-
  257.                                 schrieben.
  258. */
  259.  
  260. LONG schreibe_zeichen (struct datei *meine_datei, char *puffer, ULONG anzahl)
  261. {
  262.   LONG zaehler = 0;
  263.   BOOL ergebnis;
  264.  
  265.   if (meine_datei->modus == MODE_NEWFILE)
  266.   {
  267.     if (meine_datei->akt_position > (meine_datei->puffer_groesse - 1))
  268.     {
  269.       ergebnis = schreibe_puffer (meine_datei);
  270.       if (ergebnis == FALSE)
  271.       {
  272.         return (SCHREIB_FEHLER);
  273.       }
  274.     }
  275.     while (anzahl > 0)
  276.     {
  277.       if (meine_datei->akt_position + anzahl > meine_datei->puffer_groesse)
  278.       {
  279.         memcpy (meine_datei->puffer_zeiger + meine_datei->akt_position, puffer + zaehler,
  280.                 meine_datei->puffer_groesse - meine_datei->akt_position);
  281.  
  282.         zaehler += meine_datei->puffer_groesse - meine_datei->akt_position;
  283.         anzahl -= meine_datei->puffer_groesse - meine_datei->akt_position;
  284.  
  285.         meine_datei->akt_position += meine_datei->puffer_groesse - meine_datei->akt_position;
  286.  
  287.         ergebnis = schreibe_puffer (meine_datei);
  288.         if (ergebnis == FALSE)
  289.         {
  290.           return (SCHREIB_FEHLER);
  291.         }
  292.       }
  293.       else
  294.       {
  295.         memcpy (meine_datei->puffer_zeiger + meine_datei->akt_position,
  296.                 puffer + zaehler, anzahl);
  297.         meine_datei->akt_position += anzahl;
  298.  
  299.         return (KEIN_FEHLER);
  300.       }
  301.     }
  302.   }
  303.   else
  304.   {
  305.     return (FALSCHER_MODUS);
  306.   }
  307. }
  308.  
  309. /* -------------------------------------------------------------------------------------- */
  310.  
  311. /*  hole_byte
  312.     Holt ein einzelnes Zeichen aus der angegebenen Datei. Rⁿckgabe ist das
  313.     Zeichen oder ein Fehlercode:
  314.  
  315.     FALSCHER_MODUS                : Datei ist zum Schreiben und nicht zum
  316.                                     Lesen er÷ffnet.
  317.     DATEI_ENDE                    : Das Ende der Datei ist erreicht.
  318.     LESE_FEHLER                   : Datei konnte aus irgendeinem Grund nicht
  319.                                     gelesen werden. Datei bitte schlie▀en und
  320.                                     neu ÷ffnen.
  321. */
  322.  
  323. WORD hole_byte (struct datei *meine_datei)
  324. {
  325.   WORD zeichen;
  326.   BOOL ergebnis;
  327.  
  328.   if (meine_datei->modus == MODE_OLDFILE)
  329.   {
  330.     if (meine_datei->akt_position > (meine_datei->puffer_groesse - 1))
  331.     {
  332.       ergebnis = lese_puffer (meine_datei);
  333.       if (ergebnis == FALSE)
  334.       {
  335.         return (LESE_FEHLER);
  336.       }
  337.     }
  338.     if (meine_datei->akt_position > (LONG) (meine_datei->puffer_voelle - 1))
  339.     {
  340.       return (DATEI_ENDE);
  341.     }
  342.     zeichen = (WORD) *(meine_datei->puffer_zeiger + meine_datei->akt_position);
  343.     
  344.     meine_datei->akt_position++;
  345.     return (zeichen);
  346.   }
  347.   else
  348.   {
  349.     return (FALSCHER_MODUS);
  350.   }
  351. }
  352.  
  353. /* -------------------------------------------------------------------------------------- */
  354.  
  355. /*  schreibe_byte
  356.     Schreibt ein einzelnes Zeichen in die angegebene Datei. Liefert einen
  357.     Fehlercode zurⁿck:
  358.  
  359.     FALSCHER_MODUS          : Datei wurde zum Lesen, nicht zum Schreiben ge-
  360.                               ÷ffnet.
  361.     SCHREIB_FEHLER          : Datei konnte nicht geschrieben werden, evtl.
  362.                               Medium voll.
  363.     KEIN_FEHLER             : Zeichen konnte in den Puffer geschrieben werden.
  364. */
  365.  
  366. LONG schreibe_byte (struct datei *meine_datei, UBYTE zeichen)
  367. {
  368.   BOOL ergebnis;
  369.  
  370.   if (meine_datei->modus == MODE_NEWFILE)
  371.   {
  372.     if (meine_datei->akt_position > (meine_datei->puffer_groesse - 1))
  373.     {
  374.       ergebnis = schreibe_puffer (meine_datei);
  375.       if (ergebnis == FALSE)
  376.       {
  377.         return (SCHREIB_FEHLER);
  378.       }
  379.     }
  380.     *(meine_datei->puffer_zeiger + meine_datei->akt_position) = zeichen;
  381.     
  382.     meine_datei->akt_position++;
  383.     return (KEIN_FEHLER);
  384.   }
  385.   return (FALSCHER_MODUS);
  386. }
  387.  
  388. /* -------------------------------------------------------------------------------------- */
  389.