TLA  Line data    Source code

       1                 : /*-------------------------------------------------------------------------
       2                 :  *
       3                 :  * Simple list facilities for frontend code
       4                 :  *
       5                 :  * Data structures for simple lists of OIDs and strings.  The support for
       6                 :  * these is very primitive compared to the backend's List facilities, but
       7                 :  * it's all we need in, eg, pg_dump.
       8                 :  *
       9                 :  *
      10                 :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
      11                 :  * Portions Copyright (c) 1994, Regents of the University of California
      12                 :  *
      13                 :  * src/fe_utils/simple_list.c
      14                 :  *
      15                 :  *-------------------------------------------------------------------------
      16                 :  */
      17                 : #include "postgres_fe.h"
      18                 : 
      19                 : #include "fe_utils/simple_list.h"
      20                 : 
      21                 : 
      22                 : /*
      23                 :  * Append an OID to the list.
      24                 :  */
      25                 : void
      26 CBC          35 : simple_oid_list_append(SimpleOidList *list, Oid val)
      27                 : {
      28                 :     SimpleOidListCell *cell;
      29                 : 
      30              35 :     cell = (SimpleOidListCell *) pg_malloc(sizeof(SimpleOidListCell));
      31              35 :     cell->next = NULL;
      32              35 :     cell->val = val;
      33                 : 
      34              35 :     if (list->tail)
      35              13 :         list->tail->next = cell;
      36                 :     else
      37              22 :         list->head = cell;
      38              35 :     list->tail = cell;
      39              35 : }
      40                 : 
      41                 : /*
      42                 :  * Is OID present in the list?
      43                 :  */
      44                 : bool
      45           25400 : simple_oid_list_member(SimpleOidList *list, Oid val)
      46                 : {
      47                 :     SimpleOidListCell *cell;
      48                 : 
      49           28810 :     for (cell = list->head; cell; cell = cell->next)
      50                 :     {
      51            3444 :         if (cell->val == val)
      52              34 :             return true;
      53                 :     }
      54           25366 :     return false;
      55                 : }
      56                 : 
      57                 : /*
      58                 :  * Append a string to the list.
      59                 :  *
      60                 :  * The given string is copied, so it need not survive past the call.
      61                 :  */
      62                 : void
      63            3136 : simple_string_list_append(SimpleStringList *list, const char *val)
      64                 : {
      65                 :     SimpleStringListCell *cell;
      66                 : 
      67                 :     cell = (SimpleStringListCell *)
      68            3136 :         pg_malloc(offsetof(SimpleStringListCell, val) + strlen(val) + 1);
      69                 : 
      70            3136 :     cell->next = NULL;
      71            3136 :     cell->touched = false;
      72            3136 :     strcpy(cell->val, val);
      73                 : 
      74            3136 :     if (list->tail)
      75            2891 :         list->tail->next = cell;
      76                 :     else
      77             245 :         list->head = cell;
      78            3136 :     list->tail = cell;
      79            3136 : }
      80                 : 
      81                 : /*
      82                 :  * Is string present in the list?
      83                 :  *
      84                 :  * If found, the "touched" field of the first match is set true.
      85                 :  */
      86                 : bool
      87              44 : simple_string_list_member(SimpleStringList *list, const char *val)
      88                 : {
      89                 :     SimpleStringListCell *cell;
      90                 : 
      91              56 :     for (cell = list->head; cell; cell = cell->next)
      92                 :     {
      93              15 :         if (strcmp(cell->val, val) == 0)
      94                 :         {
      95               3 :             cell->touched = true;
      96               3 :             return true;
      97                 :         }
      98                 :     }
      99              41 :     return false;
     100                 : }
     101                 : 
     102                 : /*
     103                 :  * Destroy an OID list
     104                 :  */
     105                 : void
     106 UBC           0 : simple_oid_list_destroy(SimpleOidList *list)
     107                 : {
     108                 :     SimpleOidListCell *cell;
     109                 : 
     110               0 :     cell = list->head;
     111               0 :     while (cell != NULL)
     112                 :     {
     113                 :         SimpleOidListCell *next;
     114                 : 
     115               0 :         next = cell->next;
     116               0 :         pg_free(cell);
     117               0 :         cell = next;
     118                 :     }
     119               0 : }
     120                 : 
     121                 : /*
     122                 :  * Destroy a string list
     123                 :  */
     124                 : void
     125 CBC          17 : simple_string_list_destroy(SimpleStringList *list)
     126                 : {
     127                 :     SimpleStringListCell *cell;
     128                 : 
     129              17 :     cell = list->head;
     130              42 :     while (cell != NULL)
     131                 :     {
     132                 :         SimpleStringListCell *next;
     133                 : 
     134              25 :         next = cell->next;
     135              25 :         pg_free(cell);
     136              25 :         cell = next;
     137                 :     }
     138              17 : }
     139                 : 
     140                 : /*
     141                 :  * Find first not-touched list entry, if there is one.
     142                 :  */
     143                 : const char *
     144 UBC           0 : simple_string_list_not_touched(SimpleStringList *list)
     145                 : {
     146                 :     SimpleStringListCell *cell;
     147                 : 
     148               0 :     for (cell = list->head; cell; cell = cell->next)
     149                 :     {
     150               0 :         if (!cell->touched)
     151               0 :             return cell->val;
     152                 :     }
     153               0 :     return NULL;
     154                 : }
     155                 : 
     156                 : /*
     157                 :  * Append a pointer to the list.
     158                 :  *
     159                 :  * Caller must ensure that the pointer remains valid.
     160                 :  */
     161                 : void
     162 CBC        6449 : simple_ptr_list_append(SimplePtrList *list, void *ptr)
     163                 : {
     164                 :     SimplePtrListCell *cell;
     165                 : 
     166            6449 :     cell = (SimplePtrListCell *) pg_malloc(sizeof(SimplePtrListCell));
     167            6449 :     cell->next = NULL;
     168            6449 :     cell->ptr = ptr;
     169                 : 
     170            6449 :     if (list->tail)
     171            6198 :         list->tail->next = cell;
     172                 :     else
     173             251 :         list->head = cell;
     174            6449 :     list->tail = cell;
     175            6449 : }