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 / ListL2.c < prev    next >
Encoding:
C/C++ Source or Header  |  1990-01-16  |  10.5 KB  |  269 lines
  1. /****************************************************************
  2. *                                                                                                                                *
  3. *     Filename : ListL2.c                                                                                    *
  4. *                                                                                                                                *
  5. *****************************************************************
  6. *                                                                                                                                *
  7. *        Comment : Alle Funktionen für die Listenverwaltung der            *
  8. *                            Plotlibrary. Es werden hier keine Fehler gesetzt,    *
  9. *                            denn es wird der einfachheit halber immer ein            *
  10. *                            Pointer zurückgegeben. Dieser kann NULL sein.            *
  11. *                                                                                                                                *
  12. *                                Funktionen                                                        *
  13. *                            ==========                                                        *
  14. *                                                                                                                                *
  15. *                addlist()                    fügt eine Kurvenstruktur in die Liste    *
  16. *                dellist()                    löscht Kurve aus der Liste                        *
  17. *                sortlist()                sortiert die Liste nach zmin                    *
  18. *                slistid()                    sucht eine bestimmte Kurve nach id        *
  19. *                slistname()                sucht eine bestimmte Kurve nach name    *
  20. *                                                                                                                                *
  21. *                Rev : V1.0                                                                                            *
  22. *                                                                                                                                *
  23. *        History : V1.0 erstellen dieses Files                            15/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"                                        /* all. Includes einlesen        */
  42. #include "ListL2.h"                                    /* und die eigene                        */
  43.  
  44. /****************************************************************
  45. *                                                                                                                                *
  46. *    externe Variablen                                                                                            *
  47. *                                                                                                                                *
  48. ****************************************************************/
  49.  
  50. extern struct Plot *plot;                        /* Plotpointer                            */
  51. extern int plerr;                                        /* Fehlervariable                        */
  52.  
  53. /****************************************************************
  54. *                                                                                                                                *
  55. *    Function : addlist()                                                                                    *
  56. *                                                                                                                                *
  57. *****************************************************************
  58. *                                                                                                                                *
  59. *         Input : curve                                                                                            *
  60. *                            struct Curve *curve                                                                *
  61. *                                                                                                                                *
  62. *        Output : void                                                                                                *
  63. *                                                                                                                                *
  64. *****************************************************************
  65. *                                                                                                                                *
  66. *     Comment : fügt eine Kurvenstruktur an die bestehende Liste        *
  67. *                         an. Die Kurvenid wird in die Kurvenstruktur                *
  68. *                         eingetragen.                                                                                *
  69. *                                                                                                                                *
  70. ****************************************************************/
  71.  
  72. void addlist(curve)
  73. struct Curve *curve;
  74. {
  75. struct Curve *temp;                                    /* temp. Kurvenzeiger                */
  76.  
  77.     if (plot->last == NULL)                        /* keine Kurve vorhanden ?    */
  78.         plot->first = curve;                        /* also erste                                */
  79.     else                                                            /* sonst an das ende der        */
  80.     {                                                                    /* Liste addieren                        */
  81.         temp = plot->last;                            /* hole letzte Kurve                */
  82.         temp->next = curve;                            /* neue als next eintragen    */
  83.     }
  84.     plot->last = curve;                                /* und last updaten                    */
  85.     plot->count++;                                        /* erhöhe plotcounter                */
  86.     curve->id = ++plot->currid;                /* id eintragen                            */
  87. }
  88.  
  89. /****************************************************************
  90. *                                                                                                                                *
  91. *    Function : dellist()                                                                                    *
  92. *                                                                                                                                *
  93. *****************************************************************
  94. *                                                                                                                                *
  95. *         Input : curve                                                                                            *
  96. *                            struct Curve *curve                                                                *
  97. *                                                                                                                                *
  98. *        Output : void                                                                                                *
  99. *                                                                                                                                *
  100. *****************************************************************
  101. *                                                                                                                                *
  102. *     Comment : löscht eine Kurve aus der Liste und korrigiert die    *
  103. *                         Pointer. ACHTUNG : Es muss sichergestellt sein,        *
  104. *                         dass die curve in der Liste enthalten ist. Dafür        *
  105. *                         kann slistid() oder slistname() verwendet werden.    *
  106. *                                                                                                                                *
  107. *                         Die Liste ist so aufgebaut:                                                *
  108. *                                                                                                                                *
  109. *                                plot->first zeigt auf erste Kurve, wenn keine        *
  110. *                                                        Daten geladen ist dieser Zeiger            *
  111. *                                                        NULL.                                                                *
  112. *                                                                                                                                *
  113. *                                plot->last    zeigt auf letzte Kurve, wenn keine    *
  114. *                                                        Daten geladen ist dieser Zeiger            *
  115. *                                                        NULL.                                                                *
  116. *                                                                                                                                *
  117. *                                curve->next    zeigt auf die nächste Kurve, wenn        *
  118. *                                                        letzte Kurve (plot->last) Zeiger        *
  119. *                                                        ist NULL.                                                        *
  120. *                                                                                                                                *
  121. ****************************************************************/
  122.  
  123. void dellist(curve)
  124. struct Curve *curve;
  125. {
  126.     struct Curve *prev = NULL,                /* prev auf null setzten        */
  127.                              *temp = plot->first;    /* temp auf first setzten        */
  128.  
  129.     while (temp != curve)                            /* suche bis gefunden                */
  130.     {
  131.         prev = temp;                                        /* auf nächstes Element            */
  132.         temp = temp->next;                            /* stellen                                    */
  133.     }
  134.  
  135.     if (prev == NULL)                                    /* kein Vorgänger ?                    */
  136.         plot->first = temp->next;                /* dann ist es die erste        */
  137.                                                                         /* Kurve in der Liste                */
  138.     else                                                            /* und sonst irgendwo da-        */
  139.         prev->next = temp->next;                /* zwischen, auch das                */
  140.                                                                         /* Element wird gesetzt            */
  141.     if (plot->last == temp)                        /* korrigiere wenn nötig        */
  142.         plot->last = prev;                            /* plot->last                                */
  143.     plot->count--;                                        /* eine Kurve weniger                */
  144. }
  145.  
  146. /****************************************************************
  147. *                                                                                                                                *
  148. *    Function : sortlist()                                                                                    *
  149. *                                                                                                                                *
  150. *****************************************************************
  151. *                                                                                                                                *
  152. *         Input : curve                                                                                            *
  153. *                            struct Curve *curve                                                                *
  154. *                                                                                                                                *
  155. *        Output : void                                                                                                *
  156. *                                                                                                                                *
  157. *****************************************************************
  158. *                                                                                                                                *
  159. *     Comment : SortList() sortiert alle Kurven nach ihren zmin        *
  160. *                         Werten. Diese Funktion wird für die Niveau-                *
  161. *                         darstellung benötigt. Es wird ein linearer                    *
  162. *                         Sortieralgorythmus verwendet.                                            *
  163. *                                                                                                                                *
  164. ****************************************************************/
  165.  
  166. void sortlist()
  167. {
  168.     int i;
  169.     struct Curve    **prev,                            /* Adr. des Kurvenzeigers        */
  170.                                 *curve,                            /* Kurvenzeiger                            */
  171.                                 *next;                            /* nächste Kurve                        */
  172.  
  173.     for (i=0;i<plot->count;i++)                /* für alle Kurven                    */
  174.     {
  175.         prev = &plot->first;                        /* Pointerinit.                            */
  176.         curve = plot->first;
  177.         next = curve->next;
  178.         while((curve) and (next))                /* solange Daten vorhanden    */
  179.         {
  180.             if (curve->zmin > next->zmin)    /* muss sortiert werden            */
  181.             {                                                            /* Ja                                                */
  182.                 *prev = next;                                /* Austausch mit diesem            */
  183.                 curve->next = next->next;        /* Element                                    */
  184.                 next->next = curve;
  185.                 prev = &next->next;
  186.                 next = curve->next;
  187.             }
  188.             else                                                    /* Nein, keine Sortierung        */
  189.             {
  190.                 prev = &curve->next;                /* also nächstes Element        */
  191.                 curve = next;                                /* nehmen                                        */
  192.                 next = curve->next;
  193.             }
  194.         }
  195.     }
  196. }
  197.  
  198. /****************************************************************
  199. *                                                                                                                                *
  200. *    Function : slistid()                                                                                    *
  201. *                                                                                                                                *
  202. *****************************************************************
  203. *                                                                                                                                *
  204. *         Input : id                                                                                                    *
  205. *                            int id                            id der gesuchten Kurve                *
  206. *                                                                                                                                *
  207. *        Output : struct Curve *curve                                                                *
  208. *                            curve != NULL                Kurve gefunden                                *
  209. *                            curve == NULL                keine Kurve gefunden                    *
  210. *                                                                                                                                *
  211. *****************************************************************
  212. *                                                                                                                                *
  213. *     Comment : Durchsucht die    Kurvenliste nach der entsprechenden    *
  214. *                         Nummer. Der Rückgabewert ist der Kurvenzeiger            *
  215. *                         oder ein NULL-Pointer.                                                            *
  216. *                                                                                                                                *
  217. ****************************************************************/
  218.  
  219. struct Curve *slistid(id)
  220. int id;
  221. {
  222.     struct Curve *temp = plot->first;    /* temp auf first setzten        */
  223.  
  224.     while ((id != temp->id) and             /* suche bis gefunden oder    */
  225.                 (temp != NULL))                            /* bis ende der Liste                */
  226.         temp = temp->next;                            /* nicht gefunden nächste        */
  227.                                                                         /* Kurve                                        */
  228.     if (temp == NULL)                                    /* setzte Fehler falls            */
  229.         seterror(NOTFOUND);                            /* nicht gefunden                        */
  230.     return (temp);
  231. }
  232.  
  233. /****************************************************************
  234. *                                                                                                                                *
  235. *    Function : slistname()                                                                                *
  236. *                                                                                                                                *
  237. *****************************************************************
  238. *                                                                                                                                *
  239. *         Input : name                                                                                                *
  240. *                            *char name                    name der gesuchten Kurve            *
  241. *                                                                                                                                *
  242. *        Output : struct Curve *curve                                                                *
  243. *                            curve != NULL                Kurve gefunden                                *
  244. *                            curve == NULL                keine Kurve gefunden                    *
  245. *                                                                                                                                *
  246. *****************************************************************
  247. *                                                                                                                                *
  248. *     Comment : Durchsucht die    Kurvenliste nach dem entsprechenden    *
  249. *                         Namen. Der Rückgabewert ist der Kurvenzeiger                *
  250. *                         oder ein NULL-Pointer.                                                            *
  251. *                                                                                                                                *
  252. ****************************************************************/
  253.  
  254. struct Curve *slistname(name)
  255. char *name;
  256. {
  257.     struct Curve *temp = plot->first;    /* temp auf first setzten        */
  258.  
  259.     while ((strcmp(name,temp->titel) != NULL) and
  260.                                                                          /* suche bis gleiche Namen    */
  261.                 (temp != NULL))                            /* oder ende der Liste            */
  262.             temp = temp->next;                        /* nicht gefunden, nächste    */
  263.                                                                         /* Kurve                                        */
  264.     if (temp == NULL)                                    /* setzte Fehler falls            */
  265.         seterror(NOTFOUND);                            /* nicht gefunden                        */
  266.     return (temp);                                        /* und zurück                                */
  267. }
  268.  
  269.