1/*- 2 * Copyright (c) 2010 The NetBSD Foundation, Inc. 3 * All rights reserved. 4 * 5 * This code is derived from software contributed to The NetBSD Foundation 6 * by David A. Holland. 7 * 8 * Redistribution and use in source and binary forms, with or without 9 * modification, are permitted provided that the following conditions 10 * are met: 11 * 1. Redistributions of source code must retain the above copyright 12 * notice, this list of conditions and the following disclaimer. 13 * 2. Redistributions in binary form must reproduce the above copyright 14 * notice, this list of conditions and the following disclaimer in the 15 * documentation and/or other materials provided with the distribution. 16 * 17 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS 18 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED 19 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR 20 * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS 21 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR 22 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF 23 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS 24 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN 25 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 26 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 27 * POSSIBILITY OF SUCH DAMAGE. 28 */ 29 30#include <assert.h> 31#include <stdarg.h> 32#include <stdio.h> 33#include <stdlib.h> 34#include <string.h> 35#include <errno.h> 36 37#include "utils.h" 38#include "array.h" 39#include "place.h" 40 41struct placefile { 42 struct place includedfrom; 43 char *dir; 44 char *name; 45 int depth; 46 bool fromsystemdir; 47}; 48DECLARRAY(placefile, static UNUSED); 49DEFARRAY(placefile, static); 50 51static struct placefilearray placefiles; 52static bool overall_failure; 53 54static const char *myprogname; 55 56static FILE *debuglogfile; 57 58//////////////////////////////////////////////////////////// 59// placefiles 60 61static 62struct placefile * 63placefile_create(const struct place *from, const char *name, 64 bool fromsystemdir) 65{ 66 struct placefile *pf; 67 const char *s; 68 size_t len; 69 70 pf = domalloc(sizeof(*pf)); 71 pf->includedfrom = *from; 72 73 s = strrchr(name, '/'); 74 len = (s == NULL) ? 0 : s - name; 75 pf->dir = dostrndup(name, len); 76 77 pf->name = dostrdup(name); 78 pf->fromsystemdir = fromsystemdir; 79 80 if (from->file != NULL) { 81 pf->depth = from->file->depth + 1; 82 } else { 83 pf->depth = 1; 84 } 85 return pf; 86} 87 88static 89void 90placefile_destroy(struct placefile *pf) 91{ 92 dostrfree(pf->name); 93 dofree(pf, sizeof(*pf)); 94} 95 96DESTROYALL_ARRAY(placefile, ); 97 98const char * 99place_getparsedir(const struct place *place) 100{ 101 if (place->file == NULL) { 102 return "."; 103 } 104 return place->file->dir; 105} 106 107static 108struct placefile * 109placefile_find(const struct place *incfrom, const char *name) 110{ 111 unsigned i, num; 112 struct placefile *pf; 113 114 num = placefilearray_num(&placefiles); 115 for (i=0; i<num; i++) { 116 pf = placefilearray_get(&placefiles, i); 117 if (place_eq(incfrom, &pf->includedfrom) && 118 !strcmp(name, pf->name)) { 119 return pf; 120 } 121 } 122 return NULL; 123} 124 125void 126place_changefile(struct place *p, const char *name) 127{ 128 struct placefile *pf; 129 130 assert(p->type == P_FILE); 131 if (!strcmp(name, p->file->name)) { 132 return; 133 } 134 pf = placefile_find(&p->file->includedfrom, name); 135 if (pf == NULL) { 136 pf = placefile_create(&p->file->includedfrom, name, 137 p->file->fromsystemdir); 138 placefilearray_add(&placefiles, pf, NULL); 139 } 140 p->file = pf; 141} 142 143const struct placefile * 144place_addfile(const struct place *place, const char *file, bool issystem) 145{ 146 struct placefile *pf; 147 148 pf = placefile_create(place, file, issystem); 149 placefilearray_add(&placefiles, pf, NULL); 150 if (pf->depth > 120) { 151 complain(place, "Maximum include nesting depth exceeded"); 152 die(); 153 } 154 return pf; 155} 156 157//////////////////////////////////////////////////////////// 158// places 159 160void 161place_setnowhere(struct place *p) 162{ 163 p->type = P_NOWHERE; 164 p->file = NULL; 165 p->line = 0; 166 p->column = 0; 167} 168 169void 170place_setbuiltin(struct place *p, unsigned num) 171{ 172 p->type = P_BUILTIN; 173 p->file = NULL; 174 p->line = num; 175 p->column = 1; 176} 177 178void 179place_setcommandline(struct place *p, unsigned line, unsigned column) 180{ 181 p->type = P_COMMANDLINE; 182 p->file = NULL; 183 p->line = line; 184 p->column = column; 185} 186 187void 188place_setfilestart(struct place *p, const struct placefile *pf) 189{ 190 p->type = P_FILE; 191 p->file = pf; 192 p->line = 1; 193 p->column = 1; 194} 195 196void 197place_addcolumns(struct place *p, unsigned cols) 198{ 199 unsigned newcol; 200 201 newcol = p->column + cols; 202 if (newcol < p->column) { 203 /* overflow (use the old place to complain) */ 204 complain(p, "Column numbering overflow"); 205 die(); 206 } 207 p->column = newcol; 208} 209 210void 211place_addlines(struct place *p, unsigned lines) 212{ 213 unsigned nextline; 214 215 nextline = p->line + lines; 216 if (nextline < p->line) { 217 /* overflow (use the old place to complain) */ 218 complain(p, "Line numbering overflow"); 219 die(); 220 } 221 p->line = nextline; 222} 223 224const char * 225place_getname(const struct place *p) 226{ 227 switch (p->type) { 228 case P_NOWHERE: return "<nowhere>"; 229 case P_BUILTIN: return "<built-in>"; 230 case P_COMMANDLINE: return "<command-line>"; 231 case P_FILE: return p->file->name; 232 } 233 assert(0); 234 return NULL; 235} 236 237bool 238place_samefile(const struct place *a, const struct place *b) 239{ 240 if (a->type != b->type) { 241 return false; 242 } 243 if (a->file != b->file) { 244 return false; 245 } 246 return true; 247} 248 249bool 250place_eq(const struct place *a, const struct place *b) 251{ 252 if (!place_samefile(a, b)) { 253 return false; 254 } 255 if (a->line != b->line || a->column != b->column) { 256 return false; 257 } 258 return true; 259} 260 261static 262void 263place_printfrom(const struct place *p) 264{ 265 const struct place *from; 266 267 if (p->file == NULL) { 268 return; 269 } 270 from = &p->file->includedfrom; 271 if (from->type != P_NOWHERE) { 272 place_printfrom(from); 273 fprintf(stderr, "In file included from %s:%u:%u:\n", 274 place_getname(from), from->line, from->column); 275 } 276} 277 278//////////////////////////////////////////////////////////// 279// complaints 280 281void 282complain_init(const char *pn) 283{ 284 myprogname = pn; 285} 286 287void 288complain(const struct place *p, const char *fmt, ...) 289{ 290 va_list ap; 291 292 if (p != NULL) { 293 place_printfrom(p); 294 fprintf(stderr, "%s:%u:%u: ", place_getname(p), 295 p->line, p->column); 296 } else { 297 fprintf(stderr, "%s: ", myprogname); 298 } 299 va_start(ap, fmt); 300 vfprintf(stderr, fmt, ap); 301 va_end(ap); 302 fprintf(stderr, "\n"); 303} 304 305void 306complain_fail(void) 307{ 308 overall_failure = true; 309} 310 311bool 312complain_failed(void) 313{ 314 return overall_failure; 315} 316 317//////////////////////////////////////////////////////////// 318// debug logging 319 320void 321debuglog_open(const struct place *p, /*const*/ char *file) 322{ 323 assert(debuglogfile == NULL); 324 debuglogfile = fopen(file, "w"); 325 if (debuglogfile == NULL) { 326 complain(p, "%s: %s", file, strerror(errno)); 327 die(); 328 } 329} 330 331void 332debuglog_close(void) 333{ 334 if (debuglogfile != NULL) { 335 fclose(debuglogfile); 336 debuglogfile = NULL; 337 } 338} 339 340PF(2, 3) void 341debuglog(const struct place *p, const char *fmt, ...) 342{ 343 va_list ap; 344 345 if (debuglogfile == NULL) { 346 return; 347 } 348 349 fprintf(debuglogfile, "%s:%u: ", place_getname(p), p->line); 350 va_start(ap, fmt); 351 vfprintf(debuglogfile, fmt, ap); 352 va_end(ap); 353 fprintf(debuglogfile, "\n"); 354 fflush(debuglogfile); 355} 356 357PF(3, 4) void 358debuglog2(const struct place *p, const struct place *p2, const char *fmt, ...) 359{ 360 va_list ap; 361 362 if (debuglogfile == NULL) { 363 return; 364 } 365 366 fprintf(debuglogfile, "%s:%u: ", place_getname(p), p->line); 367 if (place_samefile(p, p2)) { 368 fprintf(debuglogfile, "(block began at line %u) ", 369 p2->line); 370 } else { 371 fprintf(debuglogfile, "(block began at %s:%u)", 372 place_getname(p2), p2->line); 373 } 374 va_start(ap, fmt); 375 vfprintf(debuglogfile, fmt, ap); 376 va_end(ap); 377 fprintf(debuglogfile, "\n"); 378 fflush(debuglogfile); 379} 380 381//////////////////////////////////////////////////////////// 382// module init and cleanup 383 384void 385place_init(void) 386{ 387 placefilearray_init(&placefiles); 388} 389 390void 391place_cleanup(void) 392{ 393 placefilearray_destroyall(&placefiles); 394 placefilearray_cleanup(&placefiles); 395} 396