xref: /linux/scripts/dtc/srcpos.c (revision 9792d660a4e91d31a6b1af105ae3f1c29107e94b)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * Copyright 2007 Jon Loeliger, Freescale Semiconductor, Inc.
4  */
5 
6 #ifndef _GNU_SOURCE
7 #define _GNU_SOURCE
8 #endif
9 
10 #include <stdio.h>
11 
12 #include "dtc.h"
13 #include "srcpos.h"
14 
15 /* A node in our list of directories to search for source/include files */
16 struct search_path {
17 	struct search_path *next;	/* next node in list, NULL for end */
18 	const char *dirname;		/* name of directory to search */
19 };
20 
21 /* This is the list of directories that we search for source files */
22 static struct search_path *search_path_head, **search_path_tail;
23 
24 /* Detect infinite include recursion. */
25 #define MAX_SRCFILE_DEPTH     (200)
26 static int srcfile_depth; /* = 0 */
27 
28 static char *get_dirname(const char *path)
29 {
30 	const char *slash = strrchr(path, '/');
31 
32 	if (slash) {
33 		int len = slash - path;
34 		char *dir = xmalloc(len + 1);
35 
36 		memcpy(dir, path, len);
37 		dir[len] = '\0';
38 		return dir;
39 	}
40 	return NULL;
41 }
42 
43 FILE *depfile; /* = NULL */
44 struct srcfile_state *current_srcfile; /* = NULL */
45 static char *initial_path; /* = NULL */
46 static int initial_pathlen; /* = 0 */
47 static bool initial_cpp = true;
48 
49 static void set_initial_path(char *fname)
50 {
51 	int i, len = strlen(fname);
52 
53 	xasprintf(&initial_path, "%s", fname);
54 	initial_pathlen = 0;
55 	for (i = 0; i != len; i++)
56 		if (initial_path[i] == '/')
57 			initial_pathlen++;
58 }
59 
60 static char *shorten_to_initial_path(char *fname)
61 {
62 	char *p1, *p2, *prevslash1 = NULL;
63 	int slashes = 0;
64 
65 	for (p1 = fname, p2 = initial_path; *p1 && *p2; p1++, p2++) {
66 		if (*p1 != *p2)
67 			break;
68 		if (*p1 == '/') {
69 			prevslash1 = p1;
70 			slashes++;
71 		}
72 	}
73 	p1 = prevslash1 + 1;
74 	if (prevslash1) {
75 		int diff = initial_pathlen - slashes, i, j;
76 		int restlen = strlen(fname) - (p1 - fname);
77 		char *res;
78 
79 		res = xmalloc((3 * diff) + restlen + 1);
80 		for (i = 0, j = 0; i != diff; i++) {
81 			res[j++] = '.';
82 			res[j++] = '.';
83 			res[j++] = '/';
84 		}
85 		strcpy(res + j, p1);
86 		return res;
87 	}
88 	return NULL;
89 }
90 
91 /**
92  * Try to open a file in a given directory.
93  *
94  * If the filename is an absolute path, then dirname is ignored. If it is a
95  * relative path, then we look in that directory for the file.
96  *
97  * @param dirname	Directory to look in, or NULL for none
98  * @param fname		Filename to look for
99  * @param fp		Set to NULL if file did not open
100  * @return allocated filename on success (caller must free), NULL on failure
101  */
102 static char *try_open(const char *dirname, const char *fname, FILE **fp)
103 {
104 	char *fullname;
105 
106 	if (!dirname || fname[0] == '/')
107 		fullname = xstrdup(fname);
108 	else
109 		fullname = join_path(dirname, fname);
110 
111 	*fp = fopen(fullname, "rb");
112 	if (!*fp) {
113 		free(fullname);
114 		fullname = NULL;
115 	}
116 
117 	return fullname;
118 }
119 
120 /**
121  * Open a file for read access
122  *
123  * If it is a relative filename, we search the full search path for it.
124  *
125  * @param fname	Filename to open
126  * @param fp	Returns pointer to opened FILE, or NULL on failure
127  * @return pointer to allocated filename, which caller must free
128  */
129 static char *fopen_any_on_path(const char *fname, FILE **fp)
130 {
131 	const char *cur_dir = NULL;
132 	struct search_path *node;
133 	char *fullname;
134 
135 	/* Try current directory first */
136 	assert(fp);
137 	if (current_srcfile)
138 		cur_dir = current_srcfile->dir;
139 	fullname = try_open(cur_dir, fname, fp);
140 
141 	/* Failing that, try each search path in turn */
142 	for (node = search_path_head; !*fp && node; node = node->next)
143 		fullname = try_open(node->dirname, fname, fp);
144 
145 	return fullname;
146 }
147 
148 FILE *srcfile_relative_open(const char *fname, char **fullnamep)
149 {
150 	FILE *f;
151 	char *fullname;
152 
153 	if (streq(fname, "-")) {
154 		f = stdin;
155 		fullname = xstrdup("<stdin>");
156 	} else {
157 		fullname = fopen_any_on_path(fname, &f);
158 		if (!f)
159 			die("Couldn't open \"%s\": %s\n", fname,
160 			    strerror(errno));
161 	}
162 
163 	if (depfile) {
164 		fputc(' ', depfile);
165 		fprint_path_escaped(depfile, fullname);
166 	}
167 
168 	if (fullnamep)
169 		*fullnamep = fullname;
170 	else
171 		free(fullname);
172 
173 	return f;
174 }
175 
176 void srcfile_push(const char *fname)
177 {
178 	struct srcfile_state *srcfile;
179 
180 	if (srcfile_depth++ >= MAX_SRCFILE_DEPTH)
181 		die("Includes nested too deeply");
182 
183 	srcfile = xmalloc(sizeof(*srcfile));
184 
185 	srcfile->f = srcfile_relative_open(fname, &srcfile->name);
186 	srcfile->dir = get_dirname(srcfile->name);
187 	srcfile->prev = current_srcfile;
188 
189 	srcfile->lineno = 1;
190 	srcfile->colno = 1;
191 
192 	current_srcfile = srcfile;
193 
194 	if (srcfile_depth == 1)
195 		set_initial_path(srcfile->name);
196 }
197 
198 bool srcfile_pop(void)
199 {
200 	struct srcfile_state *srcfile = current_srcfile;
201 
202 	assert(srcfile);
203 
204 	current_srcfile = srcfile->prev;
205 
206 	if (fclose(srcfile->f))
207 		die("Error closing \"%s\": %s\n", srcfile->name,
208 		    strerror(errno));
209 
210 	/* FIXME: We allow the srcfile_state structure to leak,
211 	 * because it could still be referenced from a location
212 	 * variable being carried through the parser somewhere.  To
213 	 * fix this we could either allocate all the files from a
214 	 * table, or use a pool allocator. */
215 
216 	return current_srcfile ? true : false;
217 }
218 
219 void srcfile_add_search_path(const char *dirname)
220 {
221 	struct search_path *node;
222 
223 	/* Create the node */
224 	node = xmalloc(sizeof(*node));
225 	node->next = NULL;
226 	node->dirname = xstrdup(dirname);
227 
228 	/* Add to the end of our list */
229 	if (search_path_tail)
230 		*search_path_tail = node;
231 	else
232 		search_path_head = node;
233 	search_path_tail = &node->next;
234 }
235 
236 void srcpos_update(struct srcpos *pos, const char *text, int len)
237 {
238 	int i;
239 
240 	pos->file = current_srcfile;
241 
242 	pos->first_line = current_srcfile->lineno;
243 	pos->first_column = current_srcfile->colno;
244 
245 	for (i = 0; i < len; i++)
246 		if (text[i] == '\n') {
247 			current_srcfile->lineno++;
248 			current_srcfile->colno = 1;
249 		} else {
250 			current_srcfile->colno++;
251 		}
252 
253 	pos->last_line = current_srcfile->lineno;
254 	pos->last_column = current_srcfile->colno;
255 }
256 
257 struct srcpos *
258 srcpos_copy(struct srcpos *pos)
259 {
260 	struct srcpos *pos_new;
261 	struct srcfile_state *srcfile_state;
262 
263 	if (!pos)
264 		return NULL;
265 
266 	pos_new = xmalloc(sizeof(struct srcpos));
267 	assert(pos->next == NULL);
268 	memcpy(pos_new, pos, sizeof(struct srcpos));
269 
270 	/* allocate without free */
271 	srcfile_state = xmalloc(sizeof(struct srcfile_state));
272 	memcpy(srcfile_state, pos->file, sizeof(struct srcfile_state));
273 	pos_new->file = srcfile_state;
274 
275 	return pos_new;
276 }
277 
278 struct srcpos *srcpos_extend(struct srcpos *pos, struct srcpos *newtail)
279 {
280 	struct srcpos *p;
281 
282 	if (!pos)
283 		return newtail;
284 
285 	for (p = pos; p->next != NULL; p = p->next);
286 	p->next = newtail;
287 	return pos;
288 }
289 
290 void srcpos_free(struct srcpos *pos)
291 {
292 	struct srcpos *p_next;
293 
294 	while (pos) {
295 		p_next = pos->next;
296 		free(pos);
297 		pos = p_next;
298 	}
299 }
300 
301 char *
302 srcpos_string(struct srcpos *pos)
303 {
304 	const char *fname = "<no-file>";
305 	char *pos_str;
306 
307 	if (pos->file && pos->file->name)
308 		fname = pos->file->name;
309 
310 
311 	if (pos->first_line != pos->last_line)
312 		xasprintf(&pos_str, "%s:%d.%d-%d.%d", fname,
313 			  pos->first_line, pos->first_column,
314 			  pos->last_line, pos->last_column);
315 	else if (pos->first_column != pos->last_column)
316 		xasprintf(&pos_str, "%s:%d.%d-%d", fname,
317 			  pos->first_line, pos->first_column,
318 			  pos->last_column);
319 	else
320 		xasprintf(&pos_str, "%s:%d.%d", fname,
321 			  pos->first_line, pos->first_column);
322 
323 	return pos_str;
324 }
325 
326 static char *
327 srcpos_string_comment(struct srcpos *pos, bool first_line, int level)
328 {
329 	char *pos_str, *fresh_fname = NULL, *first, *rest;
330 	const char *fname;
331 
332 	if (!pos) {
333 		if (level > 1) {
334 			xasprintf(&pos_str, "<no-file>:<no-line>");
335 			return pos_str;
336 		} else {
337 			return NULL;
338 		}
339 	}
340 
341 	if (!pos->file)
342 		fname = "<no-file>";
343 	else if (!pos->file->name)
344 		fname = "<no-filename>";
345 	else if (level > 1)
346 		fname = pos->file->name;
347 	else {
348 		fresh_fname = shorten_to_initial_path(pos->file->name);
349 		if (fresh_fname)
350 			fname = fresh_fname;
351 		else
352 			fname = pos->file->name;
353 	}
354 
355 	if (level > 1)
356 		xasprintf(&first, "%s:%d:%d-%d:%d", fname,
357 			  pos->first_line, pos->first_column,
358 			  pos->last_line, pos->last_column);
359 	else
360 		xasprintf(&first, "%s:%d", fname,
361 			  first_line ? pos->first_line : pos->last_line);
362 
363 	if (fresh_fname)
364 		free(fresh_fname);
365 
366 	if (pos->next != NULL) {
367 		rest = srcpos_string_comment(pos->next, first_line, level);
368 		xasprintf(&pos_str, "%s, %s", first, rest);
369 		free(first);
370 		free(rest);
371 	} else {
372 		pos_str = first;
373 	}
374 
375 	return pos_str;
376 }
377 
378 char *srcpos_string_first(struct srcpos *pos, int level)
379 {
380 	return srcpos_string_comment(pos, true, level);
381 }
382 
383 char *srcpos_string_last(struct srcpos *pos, int level)
384 {
385 	return srcpos_string_comment(pos, false, level);
386 }
387 
388 void srcpos_verror(struct srcpos *pos, const char *prefix,
389 		   const char *fmt, va_list va)
390 {
391 	char *srcstr;
392 
393 	srcstr = srcpos_string(pos);
394 
395 	fprintf(stderr, "%s: %s ", prefix, srcstr);
396 	vfprintf(stderr, fmt, va);
397 	fprintf(stderr, "\n");
398 
399 	free(srcstr);
400 }
401 
402 void srcpos_error(struct srcpos *pos, const char *prefix,
403 		  const char *fmt, ...)
404 {
405 	va_list va;
406 
407 	va_start(va, fmt);
408 	srcpos_verror(pos, prefix, fmt, va);
409 	va_end(va);
410 }
411 
412 void srcpos_set_line(char *f, int l)
413 {
414 	current_srcfile->name = f;
415 	current_srcfile->lineno = l;
416 
417 	if (initial_cpp) {
418 		initial_cpp = false;
419 		set_initial_path(f);
420 	}
421 }
422