of/flattree: Update dtc to current mainline.
[linux-2.6.git] / scripts / dtc / srcpos.c
index 9641b76..2dbc874 100644 (file)
  *                                                                   USA
  */
 
+#define _GNU_SOURCE
+
+#include <stdio.h>
+
 #include "dtc.h"
 #include "srcpos.h"
 
-/*
- * Like yylineno, this is the current open file pos.
- */
 
-struct dtc_file *srcpos_file;
+static char *dirname(const char *path)
+{
+       const char *slash = strrchr(path, '/');
+
+       if (slash) {
+               int len = slash - path;
+               char *dir = xmalloc(len + 1);
+
+               memcpy(dir, path, len);
+               dir[len] = '\0';
+               return dir;
+       }
+       return NULL;
+}
+
+struct srcfile_state *current_srcfile; /* = NULL */
 
-static int dtc_open_one(struct dtc_file *file,
-                        const char *search,
-                        const char *fname)
+/* Detect infinite include recursion. */
+#define MAX_SRCFILE_DEPTH     (100)
+static int srcfile_depth; /* = 0 */
+
+FILE *srcfile_relative_open(const char *fname, char **fullnamep)
 {
+       FILE *f;
        char *fullname;
 
-       if (search) {
-               fullname = xmalloc(strlen(search) + strlen(fname) + 2);
-
-               strcpy(fullname, search);
-               strcat(fullname, "/");
-               strcat(fullname, fname);
+       if (streq(fname, "-")) {
+               f = stdin;
+               fullname = xstrdup("<stdin>");
        } else {
-               fullname = strdup(fname);
+               if (!current_srcfile || !current_srcfile->dir
+                   || (fname[0] == '/'))
+                       fullname = xstrdup(fname);
+               else
+                       fullname = join_path(current_srcfile->dir, fname);
+
+               f = fopen(fullname, "r");
+               if (!f)
+                       die("Couldn't open \"%s\": %s\n", fname,
+                           strerror(errno));
        }
 
-       file->file = fopen(fullname, "r");
-       if (!file->file) {
+       if (fullnamep)
+               *fullnamep = fullname;
+       else
                free(fullname);
-               return 0;
-       }
 
-       file->name = fullname;
-       return 1;
+       return f;
 }
 
+void srcfile_push(const char *fname)
+{
+       struct srcfile_state *srcfile;
+
+       if (srcfile_depth++ >= MAX_SRCFILE_DEPTH)
+               die("Includes nested too deeply");
+
+       srcfile = xmalloc(sizeof(*srcfile));
+
+       srcfile->f = srcfile_relative_open(fname, &srcfile->name);
+       srcfile->dir = dirname(srcfile->name);
+       srcfile->prev = current_srcfile;
+
+       srcfile->lineno = 1;
+       srcfile->colno = 1;
+
+       current_srcfile = srcfile;
+}
 
-struct dtc_file *dtc_open_file(const char *fname,
-                               const struct search_path *search)
+int srcfile_pop(void)
 {
-       static const struct search_path default_search = { NULL, NULL, NULL };
+       struct srcfile_state *srcfile = current_srcfile;
 
-       struct dtc_file *file;
-       const char *slash;
+       assert(srcfile);
 
-       file = xmalloc(sizeof(struct dtc_file));
+       current_srcfile = srcfile->prev;
 
-       slash = strrchr(fname, '/');
-       if (slash) {
-               char *dir = xmalloc(slash - fname + 1);
+       if (fclose(srcfile->f))
+               die("Error closing \"%s\": %s\n", srcfile->name,
+                   strerror(errno));
 
-               memcpy(dir, fname, slash - fname);
-               dir[slash - fname] = 0;
-               file->dir = dir;
-       } else {
-               file->dir = NULL;
-       }
+       /* FIXME: We allow the srcfile_state structure to leak,
+        * because it could still be referenced from a location
+        * variable being carried through the parser somewhere.  To
+        * fix this we could either allocate all the files from a
+        * table, or use a pool allocator. */
 
-       if (streq(fname, "-")) {
-               file->name = "stdin";
-               file->file = stdin;
-               return file;
-       }
+       return current_srcfile ? 1 : 0;
+}
 
-       if (fname[0] == '/') {
-               file->file = fopen(fname, "r");
-               if (!file->file)
-                       goto fail;
+/*
+ * The empty source position.
+ */
 
-               file->name = strdup(fname);
-               return file;
-       }
+struct srcpos srcpos_empty = {
+       .first_line = 0,
+       .first_column = 0,
+       .last_line = 0,
+       .last_column = 0,
+       .file = NULL,
+};
 
-       if (!search)
-               search = &default_search;
+#define TAB_SIZE      8
 
-       while (search) {
-               if (dtc_open_one(file, search->dir, fname))
-                       return file;
+void srcpos_update(struct srcpos *pos, const char *text, int len)
+{
+       int i;
+
+       pos->file = current_srcfile;
+
+       pos->first_line = current_srcfile->lineno;
+       pos->first_column = current_srcfile->colno;
+
+       for (i = 0; i < len; i++)
+               if (text[i] == '\n') {
+                       current_srcfile->lineno++;
+                       current_srcfile->colno = 1;
+               } else if (text[i] == '\t') {
+                       current_srcfile->colno =
+                               ALIGN(current_srcfile->colno, TAB_SIZE);
+               } else {
+                       current_srcfile->colno++;
+               }
+
+       pos->last_line = current_srcfile->lineno;
+       pos->last_column = current_srcfile->colno;
+}
 
-               if (errno != ENOENT)
-                       goto fail;
+struct srcpos *
+srcpos_copy(struct srcpos *pos)
+{
+       struct srcpos *pos_new;
 
-               search = search->next;
-       }
+       pos_new = xmalloc(sizeof(struct srcpos));
+       memcpy(pos_new, pos, sizeof(struct srcpos));
+
+       return pos_new;
+}
+
+
+
+void
+srcpos_dump(struct srcpos *pos)
+{
+       printf("file        : \"%s\"\n",
+              pos->file ? (char *) pos->file : "<no file>");
+       printf("first_line  : %d\n", pos->first_line);
+       printf("first_column: %d\n", pos->first_column);
+       printf("last_line   : %d\n", pos->last_line);
+       printf("last_column : %d\n", pos->last_column);
+       printf("file        : %s\n", pos->file->name);
+}
 
-fail:
-       die("Couldn't open \"%s\": %s\n", fname, strerror(errno));
+
+char *
+srcpos_string(struct srcpos *pos)
+{
+       const char *fname = "<no-file>";
+       char *pos_str;
+       int rc;
+
+       if (pos)
+               fname = pos->file->name;
+
+
+       if (pos->first_line != pos->last_line)
+               rc = asprintf(&pos_str, "%s:%d.%d-%d.%d", fname,
+                             pos->first_line, pos->first_column,
+                             pos->last_line, pos->last_column);
+       else if (pos->first_column != pos->last_column)
+               rc = asprintf(&pos_str, "%s:%d.%d-%d", fname,
+                             pos->first_line, pos->first_column,
+                             pos->last_column);
+       else
+               rc = asprintf(&pos_str, "%s:%d.%d", fname,
+                             pos->first_line, pos->first_column);
+
+       if (rc == -1)
+               die("Couldn't allocate in srcpos string");
+
+       return pos_str;
+}
+
+void
+srcpos_verror(struct srcpos *pos, char const *fmt, va_list va)
+{
+       const char *srcstr;
+
+       srcstr = srcpos_string(pos);
+
+       fprintf(stdout, "Error: %s ", srcstr);
+       vfprintf(stdout, fmt, va);
+       fprintf(stdout, "\n");
 }
 
-void dtc_close_file(struct dtc_file *file)
+void
+srcpos_error(struct srcpos *pos, char const *fmt, ...)
 {
-       if (fclose(file->file))
-               die("Error closing \"%s\": %s\n", file->name, strerror(errno));
+       va_list va;
+
+       va_start(va, fmt);
+       srcpos_verror(pos, fmt, va);
+       va_end(va);
+}
+
+
+void
+srcpos_warn(struct srcpos *pos, char const *fmt, ...)
+{
+       const char *srcstr;
+       va_list va;
+       va_start(va, fmt);
+
+       srcstr = srcpos_string(pos);
+
+       fprintf(stderr, "Warning: %s ", srcstr);
+       vfprintf(stderr, fmt, va);
+       fprintf(stderr, "\n");
 
-       free(file->dir);
-       free(file);
+       va_end(va);
 }