Mercurial > ~dholland > hg > tradcpp > index.cgi
annotate place.c @ 65:161edab0d361
test undef
| author | David A. Holland |
|---|---|
| date | Sun, 31 Mar 2013 02:18:24 -0400 |
| parents | 2e25e55dba6b |
| children | 1c0575f7dd46 |
| rev | line source |
|---|---|
| 30 | 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 | |
| 8 | 30 #include <assert.h> |
| 31 #include <stdarg.h> | |
| 32 #include <stdio.h> | |
| 33 #include <stdlib.h> | |
| 34 | |
| 35 #include "utils.h" | |
| 10 | 36 #include "array.h" |
| 8 | 37 #include "place.h" |
| 38 | |
| 13 | 39 struct placefile { |
| 10 | 40 struct place includedfrom; |
| 41 char *name; | |
| 28 | 42 int depth; |
| 10 | 43 bool fromsystemdir; |
| 44 }; | |
|
47
2e25e55dba6b
Fix inline usage as per the version in dholland-make2.
David A. Holland
parents:
39
diff
changeset
|
45 DECLARRAY(placefile, static __unused); |
|
2e25e55dba6b
Fix inline usage as per the version in dholland-make2.
David A. Holland
parents:
39
diff
changeset
|
46 DEFARRAY(placefile, static); |
| 10 | 47 |
| 13 | 48 static struct placefilearray placefiles; |
| 10 | 49 static bool overall_failure; |
| 50 | |
| 51 //////////////////////////////////////////////////////////// | |
| 52 // seenfiles | |
| 53 | |
| 54 static | |
| 13 | 55 struct placefile * |
| 56 placefile_create(const struct place *from, const char *name, | |
| 57 bool fromsystemdir) | |
| 10 | 58 { |
| 13 | 59 struct placefile *pf; |
| 10 | 60 |
| 13 | 61 pf = domalloc(sizeof(*pf)); |
| 62 pf->includedfrom = *from; | |
| 63 pf->name = dostrdup(name); | |
| 64 pf->fromsystemdir = fromsystemdir; | |
| 28 | 65 if (from->file != NULL) { |
| 66 pf->depth = from->file->depth + 1; | |
| 67 } else { | |
| 68 pf->depth = 1; | |
| 69 } | |
| 13 | 70 return pf; |
| 10 | 71 } |
| 72 | |
| 73 static | |
| 74 void | |
| 13 | 75 placefile_destroy(struct placefile *pf) |
| 10 | 76 { |
|
39
337110e7240a
Pass the size to free; it makes debug checking easier.
David A. Holland
parents:
38
diff
changeset
|
77 dostrfree(pf->name); |
|
337110e7240a
Pass the size to free; it makes debug checking easier.
David A. Holland
parents:
38
diff
changeset
|
78 dofree(pf, sizeof(*pf)); |
| 10 | 79 } |
| 80 | |
| 13 | 81 DESTROYALL_ARRAY(placefile, ); |
| 10 | 82 |
| 13 | 83 const struct placefile * |
| 84 place_addfile(const struct place *place, const char *file, bool issystem) | |
| 10 | 85 { |
| 13 | 86 struct placefile *pf; |
| 10 | 87 |
| 13 | 88 pf = placefile_create(place, file, issystem); |
| 89 placefilearray_add(&placefiles, pf, NULL); | |
| 28 | 90 if (pf->depth > 128) { |
| 91 complain(place, "Maximum include nesting depth exceeded"); | |
| 92 die(); | |
| 93 } | |
| 13 | 94 return pf; |
| 10 | 95 } |
| 96 | |
| 97 //////////////////////////////////////////////////////////// | |
| 98 // places | |
| 99 | |
| 8 | 100 void |
| 101 place_setnowhere(struct place *p) | |
| 102 { | |
| 12 | 103 p->type = P_NOWHERE; |
| 8 | 104 p->file = NULL; |
| 12 | 105 p->line = 0; |
| 8 | 106 p->column = 0; |
| 107 } | |
| 108 | |
| 109 void | |
| 110 place_setbuiltin(struct place *p, unsigned num) | |
| 111 { | |
| 12 | 112 p->type = P_BUILTIN; |
| 8 | 113 p->file = NULL; |
| 12 | 114 p->line = num; |
| 115 p->column = 1; | |
| 8 | 116 } |
| 117 | |
| 118 void | |
| 14 | 119 place_setcommandline(struct place *p, unsigned line, unsigned column) |
| 8 | 120 { |
| 14 | 121 p->type = P_COMMANDLINE; |
| 8 | 122 p->file = NULL; |
| 14 | 123 p->line = line; |
| 8 | 124 p->column = column; |
| 125 } | |
| 126 | |
| 14 | 127 void |
| 128 place_setfilestart(struct place *p, const struct placefile *pf) | |
| 129 { | |
| 28 | 130 p->type = P_FILE; |
| 14 | 131 p->file = pf; |
| 132 p->line = 1; | |
| 133 p->column = 1; | |
| 134 } | |
| 135 | |
| 8 | 136 static |
| 12 | 137 const char * |
| 138 place_getname(const struct place *p) | |
| 8 | 139 { |
| 12 | 140 switch (p->type) { |
| 141 case P_NOWHERE: return "<nowhere>"; | |
| 142 case P_BUILTIN: return "<built-in>"; | |
| 143 case P_COMMANDLINE: return "<command-line>"; | |
| 144 case P_FILE: return p->file->name; | |
| 8 | 145 } |
| 12 | 146 assert(0); |
| 147 return NULL; | |
| 8 | 148 } |
| 149 | |
| 150 static | |
| 151 void | |
| 152 place_printfrom(const struct place *p) | |
| 153 { | |
| 154 const struct place *from; | |
| 155 | |
| 10 | 156 from = &p->file->includedfrom; |
| 12 | 157 if (from->type != P_NOWHERE) { |
| 8 | 158 place_printfrom(from); |
| 12 | 159 fprintf(stderr, "In file included from %s:%u:%u:\n", |
| 160 place_getname(from), from->line, from->column); | |
| 8 | 161 } |
| 162 } | |
| 163 | |
| 10 | 164 //////////////////////////////////////////////////////////// |
| 165 // complaints | |
| 166 | |
| 8 | 167 void |
| 168 complain(const struct place *p, const char *fmt, ...) | |
| 169 { | |
| 170 va_list ap; | |
| 171 | |
| 12 | 172 place_printfrom(p); |
| 173 fprintf(stderr, "%s:%u:%u: ", place_getname(p), p->line, p->column); | |
| 8 | 174 va_start(ap, fmt); |
| 175 vfprintf(stderr, fmt, ap); | |
| 176 va_end(ap); | |
| 177 fprintf(stderr, "\n"); | |
| 178 } | |
| 179 | |
| 180 void | |
| 181 complain_fail(void) | |
| 182 { | |
| 183 overall_failure = true; | |
| 184 } | |
| 185 | |
| 186 bool | |
| 187 complain_failed(void) | |
| 188 { | |
| 189 return overall_failure; | |
| 190 } | |
| 191 | |
| 10 | 192 //////////////////////////////////////////////////////////// |
| 193 // module init and cleanup | |
| 194 | |
| 195 void | |
| 196 place_init(void) | |
| 197 { | |
| 13 | 198 placefilearray_init(&placefiles); |
| 10 | 199 } |
| 200 | |
| 201 void | |
| 202 place_cleanup(void) | |
| 203 { | |
| 13 | 204 placefilearray_destroyall(&placefiles); |
| 205 placefilearray_cleanup(&placefiles); | |
| 10 | 206 } |