1 // SPDX-License-Identifier: GPL-2.0 <<
2 /* 1 /*
3 * Copyright (C) 2002-2005 Roman Zippel <zippe 2 * Copyright (C) 2002-2005 Roman Zippel <zippel@linux-m68k.org>
4 * Copyright (C) 2002-2005 Sam Ravnborg <sam@r 3 * Copyright (C) 2002-2005 Sam Ravnborg <sam@ravnborg.org>
>> 4 *
>> 5 * Released under the terms of the GNU GPL v2.0.
5 */ 6 */
6 7
7 #include <stdarg.h> 8 #include <stdarg.h>
8 #include <stdlib.h> 9 #include <stdlib.h>
9 #include <string.h> 10 #include <string.h>
10 <<
11 #include <hash.h> <<
12 #include <hashtable.h> <<
13 #include <xalloc.h> <<
14 #include "lkc.h" 11 #include "lkc.h"
15 12
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 13 /* file already present in list? If not add it */
25 const char *file_lookup(const char *name) !! 14 struct file *file_lookup(const char *name)
26 { 15 {
27 struct file *file; 16 struct file *file;
28 size_t len; !! 17 char *file_name = sym_expand_string_value(name);
29 int hash = hash_str(name); <<
30 18
31 hash_for_each_possible(file_hashtable, !! 19 for (file = file_list; file; file = file->next) {
32 if (!strcmp(name, file->name)) !! 20 if (!strcmp(name, file->name)) {
33 return file->name; !! 21 free(file_name);
>> 22 return file;
>> 23 }
>> 24 }
34 25
35 len = strlen(name); !! 26 file = xmalloc(sizeof(*file));
36 file = xmalloc(sizeof(*file) + len + 1 <<
37 memset(file, 0, sizeof(*file)); 27 memset(file, 0, sizeof(*file));
38 memcpy(file->name, name, len); !! 28 file->name = file_name;
39 file->name[len] = '\0'; !! 29 file->next = file_list;
>> 30 file_list = file;
>> 31 return file;
>> 32 }
40 33
41 hash_add(file_hashtable, &file->node, !! 34 /* write a dependency file as used by kbuild to track dependencies */
>> 35 int file_write_dep(const char *name)
>> 36 {
>> 37 struct symbol *sym, *env_sym;
>> 38 struct expr *e;
>> 39 struct file *file;
>> 40 FILE *out;
>> 41
>> 42 if (!name)
>> 43 name = ".kconfig.d";
>> 44 out = fopen("..config.tmp", "w");
>> 45 if (!out)
>> 46 return 1;
>> 47 fprintf(out, "deps_config := \\\n");
>> 48 for (file = file_list; file; file = file->next) {
>> 49 if (file->next)
>> 50 fprintf(out, "\t%s \\\n", file->name);
>> 51 else
>> 52 fprintf(out, "\t%s\n", file->name);
>> 53 }
>> 54 fprintf(out, "\n%s: \\\n"
>> 55 "\t$(deps_config)\n\n", conf_get_autoconfig_name());
42 56
43 str_printf(&autoconf_cmd, "\t%s \\\n", !! 57 expr_list_for_each_sym(sym_env_list, e, sym) {
>> 58 struct property *prop;
>> 59 const char *value;
>> 60
>> 61 prop = sym_get_env_prop(sym);
>> 62 env_sym = prop_get_symbol(prop);
>> 63 if (!env_sym)
>> 64 continue;
>> 65 value = getenv(env_sym->name);
>> 66 if (!value)
>> 67 value = "";
>> 68 fprintf(out, "ifneq \"$(%s)\" \"%s\"\n", env_sym->name, value);
>> 69 fprintf(out, "%s: FORCE\n", conf_get_autoconfig_name());
>> 70 fprintf(out, "endif\n");
>> 71 }
44 72
45 return file->name; !! 73 fprintf(out, "\n$(deps_config): ;\n");
>> 74 fclose(out);
>> 75 rename("..config.tmp", name);
>> 76 return 0;
46 } 77 }
47 78
>> 79
48 /* Allocate initial growable string */ 80 /* Allocate initial growable string */
49 struct gstr str_new(void) 81 struct gstr str_new(void)
50 { 82 {
51 struct gstr gs; 83 struct gstr gs;
52 gs.s = xmalloc(sizeof(char) * 64); 84 gs.s = xmalloc(sizeof(char) * 64);
53 gs.len = 64; 85 gs.len = 64;
54 gs.max_width = 0; 86 gs.max_width = 0;
55 strcpy(gs.s, "\0"); 87 strcpy(gs.s, "\0");
56 return gs; 88 return gs;
57 } 89 }
58 90
59 /* Free storage for growable string */ 91 /* Free storage for growable string */
60 void str_free(struct gstr *gs) 92 void str_free(struct gstr *gs)
61 { 93 {
62 free(gs->s); !! 94 if (gs->s)
>> 95 free(gs->s);
63 gs->s = NULL; 96 gs->s = NULL;
64 gs->len = 0; 97 gs->len = 0;
65 } 98 }
66 99
67 /* Append to growable string */ 100 /* Append to growable string */
68 void str_append(struct gstr *gs, const char *s 101 void str_append(struct gstr *gs, const char *s)
69 { 102 {
70 size_t l; 103 size_t l;
71 if (s) { 104 if (s) {
72 l = strlen(gs->s) + strlen(s) 105 l = strlen(gs->s) + strlen(s) + 1;
73 if (l > gs->len) { 106 if (l > gs->len) {
74 gs->s = xrealloc(gs->s 107 gs->s = xrealloc(gs->s, l);
75 gs->len = l; 108 gs->len = l;
76 } 109 }
77 strcat(gs->s, s); 110 strcat(gs->s, s);
78 } 111 }
79 } 112 }
80 113
81 /* Append printf formatted string to growable 114 /* Append printf formatted string to growable string */
82 void str_printf(struct gstr *gs, const char *f 115 void str_printf(struct gstr *gs, const char *fmt, ...)
83 { 116 {
84 va_list ap; 117 va_list ap;
85 char s[10000]; /* big enough... */ 118 char s[10000]; /* big enough... */
86 va_start(ap, fmt); 119 va_start(ap, fmt);
87 vsnprintf(s, sizeof(s), fmt, ap); 120 vsnprintf(s, sizeof(s), fmt, ap);
88 str_append(gs, s); 121 str_append(gs, s);
89 va_end(ap); 122 va_end(ap);
90 } 123 }
91 124
92 /* Retrieve value of growable string */ 125 /* Retrieve value of growable string */
93 char *str_get(const struct gstr *gs) !! 126 const char *str_get(struct gstr *gs)
94 { 127 {
95 return gs->s; 128 return gs->s;
>> 129 }
>> 130
>> 131 void *xmalloc(size_t size)
>> 132 {
>> 133 void *p = malloc(size);
>> 134 if (p)
>> 135 return p;
>> 136 fprintf(stderr, "Out of memory.\n");
>> 137 exit(1);
>> 138 }
>> 139
>> 140 void *xcalloc(size_t nmemb, size_t size)
>> 141 {
>> 142 void *p = calloc(nmemb, size);
>> 143 if (p)
>> 144 return p;
>> 145 fprintf(stderr, "Out of memory.\n");
>> 146 exit(1);
>> 147 }
>> 148
>> 149 void *xrealloc(void *p, size_t size)
>> 150 {
>> 151 p = realloc(p, size);
>> 152 if (p)
>> 153 return p;
>> 154 fprintf(stderr, "Out of memory.\n");
>> 155 exit(1);
>> 156 }
>> 157
>> 158 char *xstrdup(const char *s)
>> 159 {
>> 160 char *p;
>> 161
>> 162 p = strdup(s);
>> 163 if (p)
>> 164 return p;
>> 165 fprintf(stderr, "Out of memory.\n");
>> 166 exit(1);
96 } 167 }
97 168
Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.