util/kconfig/util.c

   1 // SPDX-License-Identifier: GPL-2.0-only
   2 /*
   3  * Copyright (C) 2002-2005 Roman Zippel <zippel@linux-m68k.org>
   4  * Copyright (C) 2002-2005 Sam Ravnborg <sam@ravnborg.org>
   5  */
   6
   7 #include <stdarg.h>
   8 #include <stdlib.h>
   9 #include <string.h>
  10 #include "lkc.h"
  11
  12 /* file already present in list? If not add it */
  13 struct file *file_lookup(const char *name)
  14 {
  15         struct file *file;
  16
  17         for (file = file_list; file; file = file->next) {
  18                 if (!strcmp(name, file->name)) {
  19                         return file;
  20                 }
  21         }
  22
  23         file = xmalloc(sizeof(*file));
  24         memset(file, 0, sizeof(*file));
  25         file->name = xstrdup(name);
  26         file->next = file_list;
  27         file_list = file;
  28         return file;
  29 }
  30
  31 /* Allocate initial growable string */
  32 struct gstr str_new(void)
  33 {
  34         struct gstr gs;
  35         gs.s = xmalloc(sizeof(char) * 64);
  36         gs.len = 64;
  37         gs.max_width = 0;
  38         strcpy(gs.s, "\0");
  39         return gs;
  40 }
  41
  42 /* Free storage for growable string */
  43 void str_free(struct gstr *gs)
  44 {
  45         free(gs->s);
  46         gs->s = NULL;
  47         gs->len = 0;
  48 }
  49
  50 /* Append to growable string */
  51 void str_append(struct gstr *gs, const char *s)
  52 {
  53         size_t l;
  54         if (s) {
  55                 l = strlen(gs->s) + strlen(s) + 1;
  56                 if (l > gs->len) {
  57                         gs->s = xrealloc(gs->s, l);
  58                         gs->len = l;
  59                 }
  60                 strcat(gs->s, s);
  61         }
  62 }
  63
  64 /* Append printf formatted string to growable string */
  65 void str_printf(struct gstr *gs, const char *fmt, ...)
  66 {
  67         va_list ap;
  68         char s[10000]; /* big enough... */
  69         va_start(ap, fmt);
  70         vsnprintf(s, sizeof(s), fmt, ap);
  71         str_append(gs, s);
  72         va_end(ap);
  73 }
  74
  75 /* Retrieve value of growable string */
  76 char *str_get(struct gstr *gs)
  77 {
  78         return gs->s;
  79 }
  80
  81 void *xmalloc(size_t size)
  82 {
  83         void *p = malloc(size);
  84         if (p)
  85                 return p;
  86         fprintf(stderr, "Out of memory.\n");
  87         exit(1);
  88 }
  89
  90 void *xcalloc(size_t nmemb, size_t size)
  91 {
  92         void *p = calloc(nmemb, size);
  93         if (p)
  94                 return p;
  95         fprintf(stderr, "Out of memory.\n");
  96         exit(1);
  97 }
  98
  99 void *xrealloc(void *p, size_t size)
 100 {
 101         p = realloc(p, size);
 102         if (p)
 103                 return p;
 104         fprintf(stderr, "Out of memory.\n");
 105         exit(1);
 106 }
 107
 108 char *xstrdup(const char *s)
 109 {
 110         char *p;
 111
 112         p = strdup(s);
 113         if (p)
 114                 return p;
 115         fprintf(stderr, "Out of memory.\n");
 116         exit(1);
 117 }
 118
 119 char *xstrndup(const char *s, size_t n)
 120 {
 121         char *p;
 122
 123         p = strndup(s, n);
 124         if (p)
 125                 return p;
 126         fprintf(stderr, "Out of memory.\n");
 127         exit(1);
 128 }