Subversion Repositories pentevo

Rev

Blame | Last modification | View Log | Download | RSS feed | ?url?

  1. /* stringlists.c */
  2. /*****************************************************************************/
  3. /* SPDX-License-Identifier: GPL-2.0-only OR GPL-3.0-only                     */
  4. /*                                                                           */
  5. /* AS-Portierung                                                             */
  6. /*                                                                           */
  7. /* Implementation von String-Listen                                          */
  8. /*                                                                           */
  9. /* Historie:  5. 4.1996 Grundsteinlegung                                     */
  10. /*                                                                           */
  11. /*****************************************************************************/
  12.  
  13. #include "stdinc.h"
  14. #include <string.h>
  15. #include "strutil.h"
  16. #include "stringlists.h"
  17.  
  18. /*!------------------------------------------------------------------------
  19.  * \fn     free_rec(StringRecPtr p_rec)
  20.  * \brief  free/destroy string list record
  21.  * \param  p_rec record to free
  22.  * ------------------------------------------------------------------------ */
  23.  
  24. void InitStringList(StringList *List)
  25. {
  26.   *List = NULL;
  27. }
  28.  
  29. void ClearStringEntry(StringRecPtr *Elem)
  30. {
  31.   if (*Elem)
  32.   {
  33.     if ((*Elem)->Content)
  34.       free((*Elem)->Content);
  35.     free(*Elem);
  36.     *Elem = NULL;
  37.   }
  38. }
  39.  
  40. void ClearStringList(StringList *List)
  41. {
  42.   StringRecPtr Hilf;
  43.  
  44.   while (*List)
  45.   {
  46.     Hilf = (*List);
  47.     *List = (*List)->Next;
  48.     ClearStringEntry(&Hilf);
  49.   }
  50. }
  51.  
  52. void AddStringListFirst(StringList *List, const char *NewStr)
  53. {
  54.   StringRecPtr Neu;
  55.  
  56.   Neu=(StringRecPtr) malloc(sizeof(StringRec));
  57.   Neu->Content = NewStr ? as_strdup(NewStr) : NULL;
  58.   Neu->Next = (*List);
  59.   *List = Neu;
  60. }
  61.  
  62. void AddStringListLast(StringList *List, const char *NewStr)
  63. {
  64.   StringRecPtr Neu, Lauf;
  65.  
  66.   Neu = (StringRecPtr) malloc(sizeof(StringRec));
  67.   Neu->Content = NewStr ? as_strdup(NewStr) : NULL;
  68.   Neu->Next = NULL;
  69.   if (!*List)
  70.     *List = Neu;
  71.   else
  72.   {
  73.     Lauf = (*List);
  74.     while (Lauf->Next)
  75.       Lauf = Lauf->Next;
  76.     Lauf->Next = Neu;
  77.   }
  78. }
  79.  
  80. void RemoveStringList(StringList *List, const char *OldStr)
  81. {
  82.   StringRecPtr Lauf, Hilf;
  83.  
  84.   if (!*List)
  85.     return;
  86.   if (!strcmp((*List)->Content,OldStr))
  87.   {
  88.     Hilf = *List;
  89.     *List = (*List)->Next;
  90.     ClearStringEntry(&Hilf);
  91.   }
  92.   else
  93.   {
  94.     Lauf = (*List);
  95.     while ((Lauf->Next) && (strcmp(Lauf->Next->Content,OldStr)))
  96.       Lauf = Lauf->Next;
  97.     if (Lauf->Next)
  98.     {
  99.       Hilf = Lauf->Next;
  100.       Lauf->Next = Hilf->Next;
  101.       ClearStringEntry(&Hilf);
  102.     }
  103.   }
  104. }
  105.  
  106. /*!------------------------------------------------------------------------
  107.  * \fn     GetStringListFirst(StringList List, StringRecPtr *Lauf)
  108.  * \brief  retrieve first item of string list & set run pointer
  109.  * \param  List list to iterate
  110.  * \param  Lauf run pointer
  111.  * \return content of head or NULL if list empty
  112.  * ------------------------------------------------------------------------ */
  113.  
  114. const char *GetStringListFirst(StringList List, StringRecPtr *Lauf)
  115. {
  116.   *Lauf = List;
  117.   if (!*Lauf)
  118.     return NULL;
  119.   else
  120.   {
  121.     char *tmp = (*Lauf)->Content;
  122.     *Lauf = (*Lauf)->Next;
  123.     return tmp;
  124.   }
  125. }
  126.  
  127. /*!------------------------------------------------------------------------
  128.  * \fn     GetStringListNext(StringRecPtr *Lauf)
  129.  * \brief  retrieve nextitem of string list & update run pointer
  130.  * \param  Lauf run pointer
  131.  * \return content of next item or NULL if end of list reached
  132.  * ------------------------------------------------------------------------ */
  133.  
  134. const char *GetStringListNext(StringRecPtr *Lauf)
  135. {
  136.   if (!*Lauf)
  137.     return NULL;
  138.   else
  139.   {
  140.     char *tmp = (*Lauf)->Content;
  141.     *Lauf = (*Lauf)->Next;
  142.     return tmp;
  143.   }
  144. }
  145.  
  146. /*!------------------------------------------------------------------------
  147.  * \fn     MoveAndCutStringListFirst(StringList *p_list)
  148.  * \brief  cut off the head of the string list and return its content, which
  149.            must be freed afer use
  150.  * \param  p_list list to cut from
  151.  * \return * to former head's content or NULL
  152.  * ------------------------------------------------------------------------ */
  153.  
  154. char *MoveAndCutStringListFirst(StringList *p_list)
  155. {
  156.   if (!*p_list)
  157.     return NULL;
  158.   else
  159.   {
  160.     StringRecPtr p_head;
  161.     char *p_ret;
  162.  
  163.     p_head = *p_list;
  164.     *p_list = (*p_list)->Next;
  165.     p_ret = p_head->Content; p_head->Content = NULL;
  166.     ClearStringEntry(&p_head);
  167.     return p_ret;
  168.   }
  169. }
  170.  
  171. /*!------------------------------------------------------------------------
  172.  * \fn     MoveAndCutStringListLast(StringList *p_list)
  173.  * \brief  cut off the tail of the string list and return its content, which
  174.            must be freed afer use
  175.  * \param  p_list list to cut from
  176.  * \return * to former head's content or NULL
  177.  * ------------------------------------------------------------------------ */
  178.  
  179. char *MoveAndCutStringListLast(StringList *p_list)
  180. {
  181.   if (!*p_list)
  182.     return NULL;
  183.   else
  184.   {
  185.     StringRecPtr p_run, p_prev;
  186.     char *p_ret;
  187.  
  188.     for (p_prev = NULL, p_run = *p_list; p_run->Next; p_prev = p_run, p_run = p_run->Next);
  189.     if (p_prev)
  190.       p_prev->Next = p_run->Next;
  191.     else
  192.       *p_list = p_run->Next;
  193.     p_ret = p_run->Content; p_run->Content = NULL;
  194.     ClearStringEntry(&p_run);
  195.     return p_ret;
  196.   }
  197. }
  198.  
  199. Boolean StringListEmpty(StringList List)
  200. {
  201.   return (!List);
  202. }
  203.  
  204. unsigned StringListCount(StringList List)
  205. {
  206.   unsigned count = 0;
  207.  
  208.   while (List)
  209.   {
  210.     List = List->Next;
  211.     count++;
  212.   }
  213.   return count;
  214. }
  215.  
  216. StringList DuplicateStringList(StringList Src)
  217. {
  218.   StringRecPtr Lauf;
  219.   StringList Dest;
  220.  
  221.   InitStringList(&Dest);
  222.   if (Src)
  223.   {
  224.     AddStringListLast(&Dest, GetStringListFirst(Src, &Lauf));
  225.     while (Lauf)
  226.       AddStringListLast(&Dest, GetStringListNext(&Lauf));
  227.   }
  228.   return Dest;
  229. }
  230.  
  231. Boolean StringListPresent(StringList List, char *Search)
  232. {
  233.   while ((List) && (strcmp(List->Content, Search)))
  234.     List = List->Next;
  235.   return (List != NULL);
  236. }
  237.  
  238. void DumpStringList(StringList List)
  239. {
  240.   while (List)
  241.   {
  242.     printf("'%s' -> ", List->Content ? List->Content : "<NULL>");
  243.     List = List->Next;
  244.   }
  245.   printf("\n");
  246. }
  247.