tools/perf/util/strlist.c

   1 /*
   2  * (c) 2009 Arnaldo Carvalho de Melo <acme@redhat.com>
   3  *
   4  * Licensed under the GPLv2.
   5  */
   6
   7 #include "strlist.h"
   8 #include "util.h"
   9 #include <errno.h>
  10 #include <stdio.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 static
  15 struct rb_node *strlist__node_new(struct rblist *rblist, const void *entry)
  16 {
  17         const char *s = entry;
  18         struct rb_node *rc = NULL;
  19         struct strlist *strlist = container_of(rblist, struct strlist, rblist);
  20         struct str_node *snode = malloc(sizeof(*snode));
  21
  22         if (snode != NULL) {
  23                 if (strlist->dupstr) {
  24                         s = strdup(s);
  25                         if (s == NULL)
  26                                 goto out_delete;
  27                 }
  28                 snode->s = s;
  29                 rc = &snode->rb_node;
  30         }
  31
  32         return rc;
  33
  34 out_delete:
  35         free(snode);
  36         return NULL;
  37 }
  38
  39 static void str_node__delete(struct str_node *snode, bool dupstr)
  40 {
  41         if (dupstr)
  42                 zfree((char **)&snode->s);
  43         free(snode);
  44 }
  45
  46 static
  47 void strlist__node_delete(struct rblist *rblist, struct rb_node *rb_node)
  48 {
  49         struct strlist *slist = container_of(rblist, struct strlist, rblist);
  50         struct str_node *snode = container_of(rb_node, struct str_node, rb_node);
  51
  52         str_node__delete(snode, slist->dupstr);
  53 }
  54
  55 static int strlist__node_cmp(struct rb_node *rb_node, const void *entry)
  56 {
  57         const char *str = entry;
  58         struct str_node *snode = container_of(rb_node, struct str_node, rb_node);
  59
  60         return strcmp(snode->s, str);
  61 }
  62
  63 int strlist__add(struct strlist *slist, const char *new_entry)
  64 {
  65         return rblist__add_node(&slist->rblist, new_entry);
  66 }
  67
  68 int strlist__load(struct strlist *slist, const char *filename)
  69 {
  70         char entry[1024];
  71         int err;
  72         FILE *fp = fopen(filename, "r");
  73
  74         if (fp == NULL)
  75                 return -errno;
  76
  77         while (fgets(entry, sizeof(entry), fp) != NULL) {
  78                 const size_t len = strlen(entry);
  79
  80                 if (len == 0)
  81                         continue;
  82                 entry[len - 1] = '\0';
  83
  84                 err = strlist__add(slist, entry);
  85                 if (err != 0)
  86                         goto out;
  87         }
  88
  89         err = 0;
  90 out:
  91         fclose(fp);
  92         return err;
  93 }
  94
  95 void strlist__remove(struct strlist *slist, struct str_node *snode)
  96 {
  97         rblist__remove_node(&slist->rblist, &snode->rb_node);
  98 }
  99
 100 struct str_node *strlist__find(struct strlist *slist, const char *entry)
 101 {
 102         struct str_node *snode = NULL;
 103         struct rb_node *rb_node = rblist__find(&slist->rblist, entry);
 104
 105         if (rb_node)
 106                 snode = container_of(rb_node, struct str_node, rb_node);
 107
 108         return snode;
 109 }
 110
 111 static int strlist__parse_list_entry(struct strlist *slist, const char *s,
 112                                      const char *subst_dir)
 113 {
 114         int err;
 115         char *subst = NULL;
 116
 117         if (strncmp(s, "file://", 7) == 0)
 118                 return strlist__load(slist, s + 7);
 119
 120         if (subst_dir) {
 121                 err = -ENOMEM;
 122                 if (asprintf(&subst, "%s/%s", subst_dir, s) < 0)
 123                         goto out;
 124
 125                 if (access(subst, F_OK) == 0) {
 126                         err = strlist__load(slist, subst);
 127                         goto out;
 128                 }
 129         }
 130
 131         err = strlist__add(slist, s);
 132 out:
 133         free(subst);
 134         return err;
 135 }
 136
 137 static int strlist__parse_list(struct strlist *slist, const char *s, const char *subst_dir)
 138 {
 139         char *sep;
 140         int err;
 141
 142         while ((sep = strchr(s, ',')) != NULL) {
 143                 *sep = '\0';
 144                 err = strlist__parse_list_entry(slist, s, subst_dir);
 145                 *sep = ',';
 146                 if (err != 0)
 147                         return err;
 148                 s = sep + 1;
 149         }
 150
 151         return *s ? strlist__parse_list_entry(slist, s, subst_dir) : 0;
 152 }
 153
 154 struct strlist *strlist__new(const char *list, const struct strlist_config *config)
 155 {
 156         struct strlist *slist = malloc(sizeof(*slist));
 157
 158         if (slist != NULL) {
 159                 bool dupstr = true;
 160                 const char *dirname = NULL;
 161
 162                 if (config) {
 163                         dupstr = !config->dont_dupstr;
 164                         dirname = config->dirname;
 165                 }
 166
 167                 rblist__init(&slist->rblist);
 168                 slist->rblist.node_cmp    = strlist__node_cmp;
 169                 slist->rblist.node_new    = strlist__node_new;
 170                 slist->rblist.node_delete = strlist__node_delete;
 171
 172                 slist->dupstr    = dupstr;
 173
 174                 if (list && strlist__parse_list(slist, list, dirname) != 0)
 175                         goto out_error;
 176         }
 177
 178         return slist;
 179 out_error:
 180         free(slist);
 181         return NULL;
 182 }
 183
 184 void strlist__delete(struct strlist *slist)
 185 {
 186         if (slist != NULL)
 187                 rblist__delete(&slist->rblist);
 188 }
 189
 190 struct str_node *strlist__entry(const struct strlist *slist, unsigned int idx)
 191 {
 192         struct str_node *snode = NULL;
 193         struct rb_node *rb_node;
 194
 195         rb_node = rblist__entry(&slist->rblist, idx);
 196         if (rb_node)
 197                 snode = container_of(rb_node, struct str_node, rb_node);
 198
 199         return snode;
 200 }