home *** CD-ROM | disk | FTP | other *** search
/ The Fred Fish Collection 1.5 / ffcollection-1-5-1992-11.iso / ff_progs / libs / plotlib.lha / Plot_1.lzh / Source / LoadL2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-02-22  |  24.9 KB  |  668 lines
  1. /****************************************************************
  2. *                                                                                                                                *
  3. *     Filename : LoadL2.c                                                                                    *
  4. *                                                                                                                                *
  5. *****************************************************************
  6. *                                                                                                                                *
  7. *        Comment : Loadfunktionen von der Plotlibrary. Unterstützt        *
  8. *                            folgenden Funktionen.                                                            *
  9. *                                                                                                                                *
  10. *                                Funktionen                                                        *
  11. *                            ==========                                                        *
  12. *                                                                                                                                *
  13. *                loaddata()                spez. Datei wird geladen                            *
  14. *                getheader()                liest bis zum '#' und erkennt Typ            *
  15. *                contoup()                    konvertiert String                                        *
  16. *                load2d()                    2d Daten werden geladen                                *
  17. *                loadniv()                    Niveau Daten werden geladen                        *
  18. *                load3d()                    3d Daten werden geladen                                *
  19. *                reallocval()            holt Speicher für neue Daten                    *
  20. *                                                                                                                                *
  21. *                Rev : V1.0                                                                                            *
  22. *                                                                                                                                *
  23. *        History : V1.0 erstellen dieses Files                            26/11/89    *
  24. *                                                                                                                                *
  25. *                Doc : Plotlibrary User's Guide                                                    *
  26. *                                                                                                                                *
  27. *             Bugs : keine bekannten                                                                        *
  28. *                                                                                                                                *
  29. *            Autor : Oesch Silvano                                                                            *
  30. *                                                                                                                                *
  31. *            Datum : 10/12/89                                                                                    *
  32. *                                                                                                                                *
  33. ****************************************************************/
  34.  
  35. /****************************************************************
  36. *                                                                                                                                *
  37. *    Plotlibrary Includedateien                                                                        *
  38. *                                                                                                                                *
  39. ****************************************************************/
  40.  
  41. #include "Plot.h"                                        /* allg. Includes                        */
  42. #include "PlotL2.h"                                    /* Level 2                                    */
  43. #include "LoadL2.h"                                    /* und eigene                                */
  44.  
  45. /****************************************************************
  46. *                                                                                                                                *
  47. *    externe Variablen                                                                                            *
  48. *                                                                                                                                *
  49. ****************************************************************/
  50.  
  51. extern struct Plot *plot;                        /* Plotpointer                            */
  52. extern int plerr;                                        /* Fehlervariable                        */
  53.  
  54. /****************************************************************
  55. *                                                                                                                                *
  56. *    Function : loaddata()                                                                                    *
  57. *                                                                                                                                *
  58. *****************************************************************
  59. *                                                                                                                                *
  60. *         Input : file,typ,name                                                                            *
  61. *                            char *file            filename der zu ladenden Daten        *
  62. *                            int  typ                Darstellungstyp                                        *
  63. *                            char *name      name der neuen Kurve                            *
  64. *                                                                                                                                *
  65. *        Output : int returnset                                                                            *
  66. *                            != NULL                    ID der neuen Kurve bei 2D oder        *
  67. *                                                            status bei NIVEAU und 3D                    *
  68. *                            == NULL                    Fehler beim laden oder konvert.        *
  69. *                                                                                                                                *
  70. *****************************************************************
  71. *                                                                                                                                *
  72. *     Comment : Diese Funktion ist die 2 Stufe der load_data                *
  73. *                         Funktion. Es wird die spez. Datei geöffnet und            *
  74. *                         die erste Zeile gelesen. Danach wird eine Kurven-    *
  75. *                         struktur erzeugt. Anhand des Types werden die            *
  76. *                         verschiedenen Ladefunktionen                                             *
  77. *                         aufgerufen.                                                                                *
  78. *                                                                                                                                *
  79. ****************************************************************/
  80.  
  81. int loaddata(file,typ)
  82. char *file;
  83. int typ;
  84. {
  85.     int dattyp,                                                /* Darstellunstyp von Datei    */
  86.             returnset,                                        /* allg. Rückgabewert                */
  87.             returnload;                                        /* loadrückgabe                            */
  88.  
  89.     struct Curve *curve = NULL;                /* Kurvenzeiger                            */
  90.     FILE *fp = NULL;                                    /* Dateizeiger                            */
  91.  
  92.     fp = fopen(file,"r");                            /* öffne Datei zum lesen        */
  93.     if (fp == NULL)                                        /* vorhanden                                */
  94.     {                                                                    /* Nein                                            */
  95.         seterror(FILEODATA);                        /* setzte Fehler                        */
  96.         setreturn(FALSE);
  97.     }
  98.     else                                                            /* Ja                                                */
  99.     {
  100.         dattyp = getheader(fp);                    /* Hole Datentyp                        */
  101.         if (dattyp == FALSE)                        /* Fehler                                        */
  102.             setreturn(FALSE);                            /* ja                                                */
  103.         else                                                        /* kontrolliere typen                */
  104.  
  105. /****************************************************************
  106. *                                                                                                                                *
  107. *    Bei dieser Abfrage werden verschiedene Kriterien untersucht.    *
  108. *                                                                                                                                *
  109. *    1. Ist ein Typ beim Funktionsaufruf vorgegeben, wenn ja                *
  110. *         stimmt dieser Typ mit dem des Datenfiles überein.                    *
  111. *    2. Ist schon eine Kurve im Speicher vorhanden, wenn ja                *
  112. *         stimmen diese Darstellungstypen überein.                                        *
  113. *                                                                                                                                *
  114. *                                                                                                                                *
  115. *    Diese beiden Kriterien werden mit einer ODER-Funktion                    *
  116. *    verknüpft, d.h. für eine erfolgreiches weiterfahren dieser        *
  117. *    dieser Funktion müssen alle Bedingungen erfüllt sein.                    *
  118. *                                                                                                                                *
  119. ****************************************************************/
  120.  
  121.             if (((typ != NOTYP) and
  122.                  (typ != dattyp)) or
  123.                  ((plot->last != NULL) and
  124.                  (dattyp != plot->typ)))
  125.             {                                                            /* Nein Fehler                            */
  126.                 seterror(NOTYPEQ);
  127.                 setreturn(FALSE);                        /* setzte Fehler                        */
  128.             }
  129.             else
  130.             {
  131.                 plot->typ = dattyp;                    /* setzte Darstellungstyp        */
  132.                 if (dattyp == D3)
  133.                     curve = getcurve(DEFCOUNT*2);
  134.                                                                         /* hole neue Kurve                    */
  135.                 else
  136.                     curve = getcurve(DEFCOUNT);
  137.                                                                         /* hole neue Kurve                    */
  138.                 if (curve == FALSE)                    /* bekommen                                    */
  139.                     setreturn(FALSE);                    /* Nein, Fehler                            */
  140.                 else
  141.                 {
  142.                     switch (dattyp)                        /* Ladefunktionen aufrufen    */
  143.                     {
  144.                         case D2:
  145.                             returnload = load2d(fp,curve);
  146.                             break;
  147.                         case NIV:
  148.                             returnload = loadniv(fp,curve);
  149.                             curve = NULL;                    /* löschen, weil schon            */
  150.                             break;                                /* addiert                                    */
  151.                         case D3:
  152.                             returnload = load3d(fp,curve);
  153.                             break;
  154.                         default:
  155.                             returnload = FALSE;
  156.                             break;
  157.                     }
  158.                     if (returnload == FALSE)    /* Fehler beim Laden                */
  159.                         setreturn(returnload);    /* dann Fehler setzten            */
  160.                     else
  161.                     {
  162.                         if (plot->typ == NIV)
  163.                             setreturn(plot->currid);
  164.                         else
  165.                         {
  166.                             addlist(curve);                /* add neue Kurve zur Liste    */
  167.                             setreturn(curve->id);    /* mit ID zurück                        */
  168.                         }
  169.                         if (plot->autoval == AUTOON)
  170.                                                                             /* nur wenn gewünscht                */
  171.                             setminmax();                        /* Grenzen korrigieren            */
  172.                     }
  173.                 }
  174.             }
  175.     }
  176.  
  177.     if (fp) fclose(fp);                                /* zuletzt Datei schliessen    */
  178.     if (returnset == FALSE)                        /* Fehler aufgetretten            */
  179.         if (curve)                                            /* Ja, also alles wieder        */
  180.         {                                                                /* zurückgeben                            */
  181.             if (curve->val)
  182.                 free(curve->val);                        /* vorhandene Daten löschen    */
  183.             free(curve);                                    /* Kurvenspeicher freigeben    */
  184.         }
  185.     return(returnset);                                /* und zurück                                */
  186. }
  187.  
  188. /****************************************************************
  189. *                                                                                                                                *
  190. *    Function : getheader()                                                                                *
  191. *                                                                                                                                *
  192. *****************************************************************
  193. *                                                                                                                                *
  194. *         Input : fp                                                                                                    *
  195. *                            FILE *fp                zu durchsuchende Datei                        *
  196. *                                                                                                                                *
  197. *        Output : int typ                    Darstellungstyp der Daten                    *
  198. *                            != FALSE                typ vorhanden                                            *
  199. *                            == FALSE                kein typ oder nicht spezifiziert    *
  200. *                                                                                                                                *
  201. *****************************************************************
  202. *                                                                                                                                *
  203. *     Comment : Konvertiert den Darstellungstyp am Anfang der             *
  204. *                         Datei und überspringt den nachfolgenden Kommentar    *
  205. *                         bis zum ersten Datenpaar.                                                    *
  206. *                                                                                                                                *
  207. ****************************************************************/
  208.  
  209. static int getheader(fp)
  210. FILE *fp;
  211. {
  212.     int i,                                                        /* generelle Schleifenvar.    */
  213.             returnset = FALSE;                        /* Rückgabewert                            */
  214.     char buffer[BUFFERSIZE+1];                /* Einlesebuffer                        */
  215.  
  216.     char *typnamen[] =                                /* Darstellungstypen                */
  217.     {
  218.         "2D",
  219.         "NIVEAU",
  220.         "3D"
  221.     };
  222.  
  223.     seterror(INVFILESTR);                            /* Voreinstellung Fehler        */
  224.     if (fscanf(fp,"%80s",buffer) != EOF)
  225.                                                                         /* 1. Zeile Dateiende ?            */
  226.     {                                                                    /* Nein                                            */
  227.         seterror(INVFILETYP);                        /* Voreinstellung Fehler        */
  228.         contoup(buffer);                                /* konvertiere String                */
  229.         for (i=D2;i<=D3;i++)                        /* durchsuche Typen                    */
  230.             if (strcmp(buffer,typnamen[i-1]) == NULL)
  231.             {                                                            /* gefunden                                    */
  232.                 setreturn(i);                                /* setzte Typ                                */
  233.                 break;                                            /* und verlasse Schleife        */
  234.             }
  235.     }
  236.  
  237.     if (returnset != FALSE)                        /* positioniere auf Daten        */
  238.         while ((fscanf(fp,"%80s",buffer) != EOF)
  239.                      and (buffer[0] != '#'));
  240.                                                                         /* lese solange bis EOF         */
  241.                                                                         /* Datenanfang # markiert        */
  242.     return(returnset);                                /* und zurück                                */
  243. }
  244.  
  245. /****************************************************************
  246. *                                                                                                                                *
  247. *    Function : contoup()                                                                                    *
  248. *                                                                                                                                *
  249. *****************************************************************
  250. *                                                                                                                                *
  251. *         Input : buffer                                                                                            *
  252. *                            char *buffer                String mit Nullzeichen                *
  253. *                                                                    abgeschlossen                                    *
  254. *                                                                                                                                *
  255. *        Output : void                                                                                                *
  256. *                                                                                                                                *
  257. *****************************************************************
  258. *                                                                                                                                *
  259. *     Comment : Konvertiert einen String in Grossschrift. Der            *
  260. *                         String muss mit einem Nullzeichen enden.                        *
  261. *                                                                                                                                *
  262. ****************************************************************/
  263.  
  264. static void contoup(buffer)
  265. char *buffer;
  266. {
  267.     while (*buffer != EOS)                        /* solange kein ende kommt    */
  268.     {
  269.         *buffer = toupper(*buffer);            /* konvertiere zu upper            */
  270.         buffer++;                                                /* und nächstes zeichen            */
  271.     }
  272. }
  273.  
  274. /****************************************************************
  275. *                                                                                                                                *
  276. *    Function : load2d()                                                                                        *
  277. *                                                                                                                                *
  278. *****************************************************************
  279. *                                                                                                                                *
  280. *         Input : fp,curve                                                                                        *
  281. *                            FILE *fp                            Dateipointer                                *
  282. *                            struct Curve *curve        Kurvenpointer                                *
  283. *                                                                                                                                *
  284. *        Output : int returnset                                                                            *
  285. *                            == EOF                                eff. Ende der Datei                    *
  286. *                            == TRUE                                Datenabschluss mit '#'            *
  287. *                            == FALSE                            Fehler beim laden                        *
  288. *                                                                                                                                *
  289. *****************************************************************
  290. *                                                                                                                                *
  291. *     Comment : Von einer Datei werden 2D-Daten geladen. Es werden    *
  292. *                         Zahlen geladen solange kein Fehler auftritt.                *
  293. *                         Wenn der angeforderte Speicher für die aufnahme        *
  294. *                         der Werte nicht mehr ausreicht, wird ein neuer            *
  295. *                         Speicher angefordert. Die neuen Werte werden                *
  296. *                         eingetragen und dann weiter geladen.                                *
  297. *                         Das einlesen wird auf drei Arten beendet.                    *
  298. *                                                                                                                                *
  299. *                         1. EOF erreicht -> alle Daten sind geladen                    *
  300. *                         2. '#' erkannt  -> alle Daten bis zu diesem                *
  301. *                                                                Zeichen sind geladen                        *
  302. *                         3. Illegal             -> Ein unbekanntes Zeichen welches    *
  303. *                                                                nicht konvertiert werden                *
  304. *                                                                konnte wurde gelesen.                        *
  305. *                        Nur der dritte Fall gibt einen Rückgabewert von            *
  306. *                        FALSE.                                                                                            *
  307. *                                                                                                                                *
  308. ****************************************************************/
  309.  
  310. static int load2d(fp,curve)
  311. FILE *fp;
  312. struct Curve *curve;
  313. {
  314.     double x,                                                    /* gelesener X-Wert                    */
  315.                  y;                                                    /* gelesener Y-Wert                    */
  316.     DATA *array = curve->val;                    /* Datenfeld                                */
  317.     int sret,                                                    /* fscanf returnwert                */
  318.             returnset,                                        /* globaler Rückgabewert        */
  319.             init = NULL,                                    /* initialisierungswert            */
  320.             count = NULL;                                    /* Datenzähler                            */
  321.     char buffer[BUFFERSIZE+1];                /* Stringbuffer                            */
  322.  
  323.     forever
  324.     {
  325.         sret = fscanf(fp,"%lf %lf",&x,&y);
  326.                                                                         /* lese von Datei x und y        */
  327.  
  328.         if (sret == EOF)                                /* End of File erreicht            */
  329.         {                                                                /* Ja                                                */
  330.             curve->count = count;                    /* speicher Zähler                    */
  331.             setreturn(EOF);                                /* EOF als Rückgabewert            */
  332.             break;                                                /* forever verlassen                */
  333.         }
  334.         else if (sret == D2MULT)                /* x und y gelesen                    */
  335.         {                                                                /* Ja                                                */
  336.             *array++=(DATA)x;                            /* speichere x und erhöhe        */
  337.             *array++=(DATA)y;                            /* speichere y und erhöhe        */
  338.             count++;                                            /* ein Datenfeld mehr                */
  339.             if (init)                                            /* Daten schon init ?                */
  340.             {
  341.                 if (curve->xmin > x)                /* ok, nur min und max            */
  342.                     curve->xmin = x;                    /* setzten für x                        */
  343.                 else if (curve->xmax < x)
  344.                     curve->xmax=x;
  345.  
  346.                 if (curve->ymin > y)                /* ok, nur min und max            */
  347.                     curve->ymin = y;                    /* setzten für y                        */
  348.                 else if (curve->ymax < y)
  349.                     curve->ymax=y;
  350.             }
  351.             else                                                    /* nein, also init. mit            */
  352.             {                                                            /* ersten Werten die vor-        */
  353.                 curve->xmin = curve->xmax = x;
  354.                 curve->ymin = curve->ymax = y;
  355.                                                                         /* handen.                                    */
  356.                 init ++;                                        /* init switch setzten            */
  357.             }
  358.  
  359.             if (count >= curve->maxcount)    /* haben noch weitere Daten    */
  360.             {                                                            /* platz in dem Datenfeld        */
  361.                 array = reallocval(curve);    /* Nein also hole mehr            */
  362.                 if (array == NULL)                    /* bekommen ?                                */
  363.                 {
  364.                     setreturn(FALSE);                    /* Nein Fehler                            */
  365.                     break;                                        /* und forever verlassen        */
  366.                 }
  367.             }
  368.         }
  369.         else                                                        /* weder EOF noch Daten            */
  370.         {
  371.             sret = fscanf(fp,"%80s",buffer);
  372.                                                                         /* lese als String                    */
  373.             if (buffer[0] != '#')                    /* ist 1. Zeichen != '#'        */
  374.             {                                                            /* Ja                                                */
  375.                 seterror(INVDATAS);                    /* Setzte Fehler                        */
  376.                 setreturn(FALSE);
  377.             }
  378.             else                                                    /* also ist es '#'                    */
  379.             {
  380.                 curve->count = count;                /* speicher count                        */
  381.                 setreturn(TRUE);                        /* und mit TRUE zurück            */
  382.             }
  383.             break;                                                /* forever verlassen                */
  384.         }
  385.     }
  386.     return(returnset);                                /* status zurückgeben                */
  387. }
  388.  
  389. /****************************************************************
  390. *                                                                                                                                *
  391. *    Function : loadniv()                                                                                    *
  392. *                                                                                                                                *
  393. *****************************************************************
  394. *                                                                                                                                *
  395. *         Input : fp,curve                                                                                        *
  396. *                            FILE *fp                            Datenfile                                        *
  397. *                            struct Curve *curve        erste Kurvenstruktur                *
  398. *                                                                                                                                *
  399. *        Output : int return                                                                                    *
  400. *                            != FALSE                            alles ok                                        *
  401. *                            == FALSE                            Fehler beim laden                        *
  402. *                                                                                                                                *
  403. *****************************************************************
  404. *                                                                                                                                *
  405. *     Comment : Von einer Datei werden die Daten als Niveaudaten        *
  406. *                         eingelesen. Zuerst wird der Niveauwert geholt und    *
  407. *                         als z-Koordinate gespeichert. Danach werden die        *
  408. *                         via load2d geladen. Diese Funktion gibt uns zu            *
  409. *                         erkennen, wenn das Ende der Datei da ist. Wenn            *
  410. *                         dies nicht der Fall ist, wird eine neue Kurve            *
  411. *                         gelesen.                                                                                        *
  412. *                         Bei einem auftrettenden Fehler werden alle Daten        *
  413. *                         gelöscht und der Speicher ans System zurück-                *
  414. *                         gegeben.                                                                                        *
  415. *                                                                                                                                *
  416. ****************************************************************/
  417.  
  418. static int loadniv(fp,curve)
  419. FILE *fp;
  420. struct Curve *curve;
  421. {
  422.     DATA z;                                                        /* Niveau Wert                            */
  423.     int sret,                                                    /* scanf returnwert                    */
  424.     returnset;                                                /* allg. returnwert                    */
  425.  
  426.     plot->currid = NULL;                            /* setzte auf NULL                    */
  427.  
  428.     do
  429.     {
  430.         sret = fscanf(fp,"%lf",&z);            /* hole Niveau Wert                    */
  431.         if (sret != 1)                                    /* bekommen ?                                */
  432.         {
  433.             seterror(INVDATAS);                        /* Nein also Fehler                    */
  434.             setreturn(FALSE);    
  435.         }
  436.         else                                                        /* Hurra, alles da                    */
  437.         {
  438.             curve->zmin=curve->zmax=(DATA)z;
  439.                                                                         /* setze als Z-Wert                    */
  440.             setreturn(load2d(fp,curve));    /* und lade 2D Kurve                */
  441.             if (returnset == TRUE)                /* hat es noch mehr Kurven    */
  442.             {                                                            /* ja, also hole eine neue    */
  443.                 addlist(curve);                            /* add Kurve zur Liste            */
  444.                 curve = getcurve(DEFCOUNT);    /* hole neue Kurve                    */
  445.                 if (curve == FALSE)                    /* bekommen                                    */
  446.                     setreturn(FALSE);                    /* Nein, Fehler                            */
  447.             }
  448.         }
  449.     }
  450.     while(returnset == TRUE);                    /* sobald ein Fehler oder        */
  451.                                                                         /* EOF da ist brechen wir        */
  452.                                                                         /* ab                                                */
  453.     if (returnset == FALSE)                        /* ist abbruch ein fehler        */
  454.     {
  455.         if (curve)                                            /* Ja, also alles wieder        */
  456.         {                                                                /* zurückgeben                            */
  457.             if (curve->val)
  458.                 free(curve->val);                        /* vorhandene Daten löschen    */
  459.             free(curve);                                    /* Kurvenspeicher freigeben    */
  460.         }
  461.         (void)deldata(DELALL,NULL);            /* und die ganze Liste            */
  462.                                                                         /* freigeben                                */
  463.     }
  464.     else                                                            /* Es war EOF                                */
  465.     {
  466.         if (curve) addlist(curve);            /* letzte Kurve zur Liste        */
  467.         sortlist();
  468.     }
  469.     return(returnset);
  470. }
  471.  
  472. /****************************************************************
  473. *                                                                                                                                *
  474. *    Function : load3d()                                                                                        *
  475. *                                                                                                                                *
  476. *****************************************************************
  477. *                                                                                                                                *
  478. *         Input : fp,curve                                                                                        *
  479. *                            FILE *fp                            Dateipointer                                *
  480. *                            struct Curve *curve        Kurvenpointer                                *
  481. *                                                                                                                                *
  482. *        Output : int return                                                                                    *
  483. *                            == EOF                                eff. Ende der Datei                    *
  484. *                            == TRUE                                Datenabschluss mit '#'            *
  485. *                            == FALSE                            Fehler beim laden                        *
  486. *                                                                                                                                *
  487. *****************************************************************
  488. *                                                                                                                                *
  489. *     Comment : Von einer Datei werden 3D-Daten geladen. Es werden    *
  490. *                         Zahlen geladen solange kein Fehler auftritt.                *
  491. *                         Wenn der angeforderte Speicher für die aufnahme        *
  492. *                         der Werte nicht mehr ausreicht, wird ein neuer            *
  493. *                         Speicher angefordert. Die neuen Werte werden                *
  494. *                         eingetragen und dann weiter geladen.                                *
  495. *                         Das einlesen wird auf drei Arten beendet.                    *
  496. *                                                                                                                                *
  497. *                         1. EOF erreicht -> alle Daten sind geladen                    *
  498. *                         2. '#' erkannt  -> alle Daten bis zu diesem                *
  499. *                                                                Zeichen sind geladen                        *
  500. *                         3. Illegal             -> Ein unbekanntes Zeichen welches    *
  501. *                                                                nicht konvertiert werden                *
  502. *                                                                konnte wurde gelesen.                        *
  503. *                        Nur der dritte Fall gibt einen Rückgabewert von            *
  504. *                        FALSE.                                                                                            *
  505. *                                                                                                                                *
  506. *                        Diese Funktion unterscheidet sich nur gering von        *
  507. *                        der 2D-Funktion. Um jedoch eine Ladeverzögerung            *
  508. *                        zu vermeiden, wurde für die 3D-Darstellung eine            *
  509. *                        eigene Funktion geschrieben.                                                *
  510. *                                                                                                                                *
  511. ****************************************************************/
  512.  
  513. static int load3d(fp,curve)
  514. FILE *fp;
  515. struct Curve *curve;
  516. {
  517.     double x,                                                    /* gelesener X-Wert                    */
  518.                  y,                                                    /* gelesener Y-Wert                    */
  519.                  z;                                                    /* gelesener Z-Wert                    */
  520.     DATA *array = curve->val;                    /* Datenfeld                                */
  521.     int sret,                                                    /* fscanf returnwert                */
  522.             returnset,                                        /* globaler Rückgabewert        */
  523.             init = NULL,                                    /* initialisierungswert            */
  524.             count = NULL;                                    /* Datenzähler                            */
  525.     char buffer[BUFFERSIZE+1];                /* Stringbuffer                            */
  526.  
  527.     forever
  528.     {
  529.         sret = fscanf(fp,"%lf %lf %lf",&x,&y,&z);
  530.                                                                         /* lese von Datei x,y und z    */
  531.  
  532.         if (sret == EOF)                                /* End of File erreicht            */
  533.         {                                                                /* Ja                                                */
  534.             curve->count = count;                    /* speicher Zähler                    */
  535.             setreturn(EOF);                                /* EOF als Rückgabewert            */
  536.             break;                                                /* forever verlassen                */
  537.         }
  538.         else if (sret == D3MULT)                /* x,y und z gelesen                */
  539.         {                                                                /* Ja                                                */
  540.             *array++=(DATA)x;                            /* speichere x und erhöhe        */
  541.             *array++=(DATA)y;                            /* speichere y und erhöhe        */
  542.             *array++=(DATA)z;                            /* speichere z und erhöhe        */
  543.             count++;                                            /* ein Datenfeld mehr                */
  544.             if (init)                                            /* Daten schon init ?                */
  545.             {
  546.                 if (curve->xmin > x)                /* ok, nur min und max            */
  547.                     curve->xmin = x;                    /* setzten für x                        */
  548.                 else if (curve->xmax < x)
  549.                     curve->xmax=x;
  550.  
  551.                 if (curve->ymin > y)                /* ok, nur min und max            */
  552.                     curve->ymin = y;                    /* setzten für y                        */
  553.                 else if (curve->ymax < y)
  554.                     curve->ymax=y;
  555.  
  556.                 if (curve->zmin > z)                /* ok, nur min und max            */
  557.                     curve->zmin = z;                    /* setzten für z                        */
  558.                 else if (curve->zmax < z)
  559.                     curve->zmax=z;
  560.             }
  561.             else                                                    /* nein, also init. mit            */
  562.             {                                                            /* ersten Werten die vor-        */
  563.                 curve->xmin = curve->xmax = x;
  564.                 curve->ymin = curve->ymax = y;
  565.                 curve->zmin = curve->zmax = z;
  566.                                                                         /* handen.                                    */
  567.                 init ++;                                        /* init switch setzten            */
  568.             }
  569.  
  570.             if (count >= curve->maxcount)    /* haben noch weitere Daten    */
  571.             {                                                            /* platz in dem Datenfeld        */
  572.                 array = reallocval(curve);    /* Nein also hole mehr            */
  573.                 if (array == NULL)                    /* bekommen ?                                */
  574.                 {
  575.                     setreturn(FALSE);                    /* Nein Fehler                            */
  576.                     break;                                        /* und forever verlassen        */
  577.                 }
  578.             }
  579.         }
  580.         else                                                        /* weder EOF noch Daten            */
  581.         {
  582.             sret = fscanf(fp,"%80s",buffer);
  583.                                                                         /* lese als String                    */
  584.             if (buffer[0] != '#')                    /* ist 1. Zeichen != '#'        */
  585.             {                                                            /* Ja                                                */
  586.                 seterror(INVDATAS);                    /* Setzte Fehler                        */
  587.                 setreturn(FALSE);
  588.             }
  589.             else                                                    /* also ist es '#'                    */
  590.             {
  591.                 curve->count = count;                /* speicher count                        */
  592.                 setreturn(TRUE);                        /* und mit TRUE zurück            */
  593.             }
  594.             break;                                                /* forever verlassen                */
  595.         }
  596.     }
  597.     return(returnset);                                /* status zurückgeben                */
  598. }
  599.  
  600. /****************************************************************
  601. *                                                                                                                                *
  602. *    Function : reallocval()                                                                                *
  603. *                                                                                                                                *
  604. *****************************************************************
  605. *                                                                                                                                *
  606. *         Input : curve                                                                                            *
  607. *                            struct Curve *curve        Kurvenzeiger                                *
  608. *                                                                                                                                *
  609. *        Output : DATA *returnset                Datenfeldzeiger                            *
  610. *                            != NULL                                neuer Speicherbereich                *
  611. *                                                                        bekommen. Zeiger auf                *
  612. *                                                                        nächstes freies Element.        *
  613. *                            == NULL                                Kein neuer Speicherbereich    *
  614. *                                                                        bekommen                                        *
  615. *                                                                                                                                *
  616. *****************************************************************
  617. *                                                                                                                                *
  618. *     Comment : Wenn die Kurvendaten nicht in das erste Datenfeld    *
  619. *                         hineinpassen, muss ein grösserer Speicherbereich        *
  620. *                         geholt werden. Dieser neue Speicher erhält um            *
  621. *                         um COUNTSTEP (definiert in Plot.h) mehr Elemente        *
  622. *                         als zuvor. Die Grösse des Feldes sieht also wie        *
  623. *                         folgt aus:                                                                                    *
  624. *                                                1. DEFCOUNT                                                            *
  625. *                                                2. DEFCOUNT+COUNTSTEP                                        *
  626. *                                                3. DEFCOUNT+2*COUNTSTEP                                    *
  627. *                                                                    "                                                            *
  628. *                         Die Daten werden in diesen neuen Speicherbereich        *
  629. *                         kopiert und die Kurvenstruktur wird korrigiert.        *
  630. *                         Der Rückgabewert ist ein Zeiger auf das nächste        *
  631. *                         freie Element in diesem Datenfeld. Diese Routine        *
  632. *                         kann für 2D und 3D Daten verwendet werden.                    *
  633. *                                                                                                                                *
  634. ****************************************************************/
  635.  
  636. static DATA *reallocval(curve)
  637. struct Curve *curve;
  638. {
  639.     int newcount,                                            /* neue Anzahl Elemente            */
  640.             newsize;                                            /* neue Grösse in Bytes            */
  641.     DATA *val,                                                /* Zeiger auf Datenfeld            */
  642.              *returnset;                                    /* allg. Rückgabewert                */
  643.  
  644.     if (plot->typ == D3)
  645.         newcount = curve->maxcount+COUNTSTEP*2;
  646.     else
  647.         newcount = curve->maxcount+COUNTSTEP;
  648.                                                                         /* newcount berechnen                */
  649.     newsize = getsize(newcount);            /* hole Grösse                            */
  650.     val = realloc(curve->val,newsize);
  651.                                                                         /* und hole neuen Speicher    */
  652.     if (val == NULL)                                    /* bekommen ?                                */
  653.     {                                                                    /* Nein Fehler                            */
  654.         seterror(REALFAIL);
  655.         setreturn(val);                                    /* zurück mit NULL                    */
  656.     }
  657.     else                                                            /* Ja Kurve korrigieren            */
  658.     {
  659.         setreturn(&val[curve->maxcount*valsize()]);
  660.                                                                         /* nächstes freie Element        */
  661.                                                                         /* berechnen                                */
  662.         curve->maxcount = newcount;            /* neuer maxcount setzten        */
  663.         curve->val = val;                                /* neuer Datenfeldzeiger        */
  664.     }
  665.     return(returnset);
  666. }
  667.  
  668.