Age         Owner                  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
 2572 tgl                        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 *)
 2118                            68            3136 :         pg_malloc(offsetof(SimpleStringListCell, val) + strlen(val) + 1);
                                 69                 : 
 2572                            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
 1349 michael                   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
 1349 michael                   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 *
 2572 tgl                       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
 1270 alvherre                  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 : }