scripts/dtc/srcpos.c

   1 /*
   2  * Copyright 2007 Jon Loeliger, Freescale Semiconductor, Inc.
   3  *
   4  * This program is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU General Public License as
   6  * published by the Free Software Foundation; either version 2 of the
   7  * License, or (at your option) any later version.
   8  *
   9  *  This program is distributed in the hope that it will be useful,
  10  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  *  General Public License for more details.
  13  *
  14  *  You should have received a copy of the GNU General Public License
  15  *  along with this program; if not, write to the Free Software
  16  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
  17  *                                                                   USA
  18  */
  19
  20 #define _GNU_SOURCE
  21
  22 #include <stdio.h>
  23
  24 #include "dtc.h"
  25 #include "srcpos.h"
  26
  27
  28 static char *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 struct srcfile_state *current_srcfile; /* = NULL */
  44
  45 /* Detect infinite include recursion. */
  46 #define MAX_SRCFILE_DEPTH     (100)
  47 static int srcfile_depth; /* = 0 */
  48
  49 FILE *srcfile_relative_open(const char *fname, char **fullnamep)
  50 {
  51         FILE *f;
  52         char *fullname;
  53
  54         if (streq(fname, "-")) {
  55                 f = stdin;
  56                 fullname = xstrdup("<stdin>");
  57         } else {
  58                 if (!current_srcfile || !current_srcfile->dir
  59                     || (fname[0] == '/'))
  60                         fullname = xstrdup(fname);
  61                 else
  62                         fullname = join_path(current_srcfile->dir, fname);
  63
  64                 f = fopen(fullname, "r");
  65                 if (!f)
  66                         die("Couldn't open \"%s\": %s\n", fname,
  67                             strerror(errno));
  68         }
  69
  70         if (fullnamep)
  71                 *fullnamep = fullname;
  72         else
  73                 free(fullname);
  74
  75         return f;
  76 }
  77
  78 void srcfile_push(const char *fname)
  79 {
  80         struct srcfile_state *srcfile;
  81
  82         if (srcfile_depth++ >= MAX_SRCFILE_DEPTH)
  83                 die("Includes nested too deeply");
  84
  85         srcfile = xmalloc(sizeof(*srcfile));
  86
  87         srcfile->f = srcfile_relative_open(fname, &srcfile->name);
  88         srcfile->dir = dirname(srcfile->name);
  89         srcfile->prev = current_srcfile;
  90
  91         srcfile->lineno = 1;
  92         srcfile->colno = 1;
  93
  94         current_srcfile = srcfile;
  95 }
  96
  97 int srcfile_pop(void)
  98 {
  99         struct srcfile_state *srcfile = current_srcfile;
 100
 101         assert(srcfile);
 102
 103         current_srcfile = srcfile->prev;
 104
 105         if (fclose(srcfile->f))
 106                 die("Error closing \"%s\": %s\n", srcfile->name,
 107                     strerror(errno));
 108
 109         /* FIXME: We allow the srcfile_state structure to leak,
 110          * because it could still be referenced from a location
 111          * variable being carried through the parser somewhere.  To
 112          * fix this we could either allocate all the files from a
 113          * table, or use a pool allocator. */
 114
 115         return current_srcfile ? 1 : 0;
 116 }
 117
 118 /*
 119  * The empty source position.
 120  */
 121
 122 struct srcpos srcpos_empty = {
 123         .first_line = 0,
 124         .first_column = 0,
 125         .last_line = 0,
 126         .last_column = 0,
 127         .file = NULL,
 128 };
 129
 130 #define TAB_SIZE      8
 131
 132 void srcpos_update(struct srcpos *pos, const char *text, int len)
 133 {
 134         int i;
 135
 136         pos->file = current_srcfile;
 137
 138         pos->first_line = current_srcfile->lineno;
 139         pos->first_column = current_srcfile->colno;
 140
 141         for (i = 0; i < len; i++)
 142                 if (text[i] == '\n') {
 143                         current_srcfile->lineno++;
 144                         current_srcfile->colno = 1;
 145                 } else if (text[i] == '\t') {
 146                         current_srcfile->colno =
 147                                 ALIGN(current_srcfile->colno, TAB_SIZE);
 148                 } else {
 149                         current_srcfile->colno++;
 150                 }
 151
 152         pos->last_line = current_srcfile->lineno;
 153         pos->last_column = current_srcfile->colno;
 154 }
 155
 156 struct srcpos *
 157 srcpos_copy(struct srcpos *pos)
 158 {
 159         struct srcpos *pos_new;
 160
 161         pos_new = xmalloc(sizeof(struct srcpos));
 162         memcpy(pos_new, pos, sizeof(struct srcpos));
 163
 164         return pos_new;
 165 }
 166
 167
 168
 169 void
 170 srcpos_dump(struct srcpos *pos)
 171 {
 172         printf("file        : \"%s\"\n",
 173                pos->file ? (char *) pos->file : "<no file>");
 174         printf("first_line  : %d\n", pos->first_line);
 175         printf("first_column: %d\n", pos->first_column);
 176         printf("last_line   : %d\n", pos->last_line);
 177         printf("last_column : %d\n", pos->last_column);
 178         printf("file        : %s\n", pos->file->name);
 179 }
 180
 181
 182 char *
 183 srcpos_string(struct srcpos *pos)
 184 {
 185         const char *fname = "<no-file>";
 186         char *pos_str;
 187         int rc;
 188
 189         if (pos)
 190                 fname = pos->file->name;
 191
 192
 193         if (pos->first_line != pos->last_line)
 194                 rc = asprintf(&pos_str, "%s:%d.%d-%d.%d", fname,
 195                               pos->first_line, pos->first_column,
 196                               pos->last_line, pos->last_column);
 197         else if (pos->first_column != pos->last_column)
 198                 rc = asprintf(&pos_str, "%s:%d.%d-%d", fname,
 199                               pos->first_line, pos->first_column,
 200                               pos->last_column);
 201         else
 202                 rc = asprintf(&pos_str, "%s:%d.%d", fname,
 203                               pos->first_line, pos->first_column);
 204
 205         if (rc == -1)
 206                 die("Couldn't allocate in srcpos string");
 207
 208         return pos_str;
 209 }
 210
 211 void
 212 srcpos_verror(struct srcpos *pos, char const *fmt, va_list va)
 213 {
 214        const char *srcstr;
 215
 216        srcstr = srcpos_string(pos);
 217
 218        fprintf(stdout, "Error: %s ", srcstr);
 219        vfprintf(stdout, fmt, va);
 220        fprintf(stdout, "\n");
 221 }
 222
 223 void
 224 srcpos_error(struct srcpos *pos, char const *fmt, ...)
 225 {
 226         va_list va;
 227
 228         va_start(va, fmt);
 229         srcpos_verror(pos, fmt, va);
 230         va_end(va);
 231 }
 232
 233
 234 void
 235 srcpos_warn(struct srcpos *pos, char const *fmt, ...)
 236 {
 237         const char *srcstr;
 238         va_list va;
 239         va_start(va, fmt);
 240
 241         srcstr = srcpos_string(pos);
 242
 243         fprintf(stderr, "Warning: %s ", srcstr);
 244         vfprintf(stderr, fmt, va);
 245         fprintf(stderr, "\n");
 246
 247         va_end(va);
 248 }