Support for both static and dynamically generated CGI pages.

[privoxy.git] / list.c

diff --git a/list.c b/list.c
index 18e5da7..28552d8 100644 (file)
--- a/list.c
+++ b/list.c
@@ -1,4 +1,4 @@
-const char list_rcs[] = "$Id: list.c,v 1.4 2001/06/29 13:30:22 oes Exp $";
+const char list_rcs[] = "$Id: list.c,v 1.7 2001/08/05 16:06:20 jongfoster Exp $";
 /*********************************************************************
  *
  * File        :  $Source: /cvsroot/ijbswa/current/list.c,v $
@@ -34,6 +34,19 @@ const char list_rcs[] = "$Id: list.c,v 1.4 2001/06/29 13:30:22 oes Exp $";
  *
  * Revisions   :
  *    $Log: list.c,v $
+ *    Revision 1.7  2001/08/05 16:06:20  jongfoster
+ *    Modifiying "struct map" so that there are now separate header and
+ *    "map_entry" structures.  This means that functions which modify a
+ *    map no longer need to return a pointer to the modified map.
+ *    Also, it no longer reverses the order of the entries (which may be
+ *    important with some advanced template substitutions).
+ *
+ *    Revision 1.6  2001/07/31 14:44:51  oes
+ *    list_to_text() now appends empty line at end
+ *
+ *    Revision 1.5  2001/06/29 21:45:41  oes
+ *    Indentation, CRLF->LF, Tab-> Space
+ *
  *    Revision 1.4  2001/06/29 13:30:22  oes
  *    - Added Convenience function enlist_unique_header(),
  *      which takes the Header name and value as separate
@@ -76,6 +89,8 @@ const char list_rcs[] = "$Id: list.c,v 1.4 2001/06/29 13:30:22 oes Exp $";
 #include <ctype.h>
 #include <string.h>
 
+#include <assert.h>
+
 #ifndef _WIN32
 #include <unistd.h>
 #endif
@@ -87,6 +102,7 @@ const char list_rcs[] = "$Id: list.c,v 1.4 2001/06/29 13:30:22 oes Exp $";
 
 const char list_h_rcs[] = LIST_H_VERSION;
 
+
 /*********************************************************************
  *
  * Function    :  enlist
@@ -218,8 +234,8 @@ void enlist_unique(struct list *header, const char *str, int n)
  *
  * Parameters  :
  *          1  :  header = pointer to list 'dummy' header
- *          2  :  first = first string to add to the list (maybe NULL)
- *          3  :  second = number of chars to use for uniqueness test
+ *          2  :  name = name of header to be added
+ *          3  :  value = value of header to be added
  *
  * Returns     :  N/A
  *
@@ -298,7 +314,8 @@ void destroy_list(struct list *header)
  *
  * Function    :  list_to_text
  *
- * Description :  "Flaten" a string list into 1 long \r\n delimited string.
+ * Description :  "Flaten" a string list into 1 long \r\n delimited string,
+ *                adding an empty line at the end.
  *
  * Parameters  :
  *          1  :  h = pointer to list 'dummy' header
@@ -311,9 +328,7 @@ char *list_to_text(struct list *h)
    struct list *p;
    char *ret = NULL;
    char *s;
-   int size;
-
-   size = 0;
+   int size = 2;
 
    for (p = h->next; p ; p = p->next)
    {
@@ -341,6 +356,7 @@ char *list_to_text(struct list *h)
          *s++ = '\r'; *s++ = '\n';
       }
    }
+   *s++ = '\r'; *s++ = '\n';
 
    return(ret);
 
@@ -496,29 +512,36 @@ void list_append_list_unique(struct list *dest, const struct list *src)
  *                      strings that will be independantly free()d.
  *
  * Parameters  :
- *          1  :  map = map to add to
+ *          1  :  the_map = map to add to
  *          2  :  name = name to add
  *          3  :  nc = flag set if a copy of name should be used
  *          4  :  value = value to add
  *          5  :  vc = flag set if a copy of value should be used
  *
- * Returns     :  pointer to extended map, or NULL if failiure
+ * Returns     :  N/A
  *
  *********************************************************************/
-struct map *map(struct map *map, char *name, int nc, char *value, int vc)
+void map(struct map *the_map, const char *name, int nc, const char *value, int vc)
 {
-   struct map *cur;
+   struct map_entry *new_entry;
 
-   if (NULL == (cur = zalloc(sizeof(*cur))))
+   if (NULL == (new_entry = zalloc(sizeof(*new_entry))))
    {
-      return(NULL);
+      return;
    }
 
-   cur->name  = nc ? strdup(name) : name;
-   cur->value = vc ? strdup(value) : value;
-   cur->next = map;
+   new_entry->name  = nc ? strdup(name) : name;
+   new_entry->value = vc ? strdup(value) : value;
+   /* new_entry->next = NULL;  - implied by zalloc */
 
-   return(cur);
+   if (the_map->last)
+   {
+      the_map->last = the_map->last->next = new_entry;
+   }
+   else
+   {
+      the_map->last = the_map->first = new_entry;
+   }
 
 }
 
@@ -536,20 +559,36 @@ struct map *map(struct map *map, char *name, int nc, char *value, int vc)
  * Returns     :  the value if found, else the empty string
  *
  *********************************************************************/
-char *lookup(struct map *map, char *name)
+const char *lookup(const struct map *the_map, const char *name)
 {
-   struct map *p = map;
+   const struct map_entry *cur_entry = the_map->first;
 
-   while (p)
+   while (cur_entry)
    {
-      if (!strcmp(name, p->name))
+      if (!strcmp(name, cur_entry->name))
       {
-         return p->value;
+         return cur_entry->value;
       }
-      p = p->next;
+      cur_entry = cur_entry->next;
    }
    return "";
+}
+
 
+/*********************************************************************
+ *
+ * Function    :  new_nap
+ *
+ * Description :  Create a new, empty map.
+ *
+ * Parameters  :
+ *
+ * Returns     :  A new, empty map, or NULL if out of memory.
+ *
+ *********************************************************************/
+struct map *new_map(void)
+{
+   return (struct map *) zalloc(sizeof(struct map));
 }
 
 
@@ -561,25 +600,33 @@ char *lookup(struct map *map, char *name)
  *                depandant strings
  *
  * Parameters  :
- *          1  :  list = list to bee freed
+ *          1  :  cur_entry = map to be freed.  May be NULL.
  *
  * Returns     :  N/A
  *
  *********************************************************************/
-void free_map(struct map *map)
+void free_map(struct map *the_map)
 {
-   struct map *p = map;
+   struct map_entry *cur_entry;
+   struct map_entry *next_entry;
 
-   while (p)
+   if (the_map == NULL)
    {
-      free(p->name);
-      free(p->value);
+      return;
+   }
 
-      map = p->next;
-      free(p);
-      p = map;
+   for (cur_entry = the_map->first; cur_entry != NULL; cur_entry = next_entry) 
+   {
+      freez((char *)cur_entry->name);
+      freez((char *)cur_entry->value);
+
+      next_entry = cur_entry->next;
+      free(cur_entry);
    }
 
+   the_map->first = the_map->last = NULL;
+
+   free(the_map);
 }