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