Mercurial > ~dholland > hg > tradcpp > index.cgi
annotate files.c @ 201:cc6ad214664a
Added tag release-0.5.2 for changeset 18b872f36217
| author | David A. Holland |
|---|---|
| date | Sun, 04 Sep 2016 17:16:47 -0400 |
| parents | 1d2bad7151f9 |
| children | 3a25180d3a5c |
| rev | line source |
|---|---|
| 30 | 1 /*- |
|
99
60184aa42604
add 2013 to copyrights where it seems warranted
David A. Holland
parents:
81
diff
changeset
|
2 * Copyright (c) 2010, 2013 The NetBSD Foundation, Inc. |
| 30 | 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 | |
| 6 | 30 #include <stdio.h> |
| 31 #include <stdlib.h> | |
| 13 | 32 #include <string.h> |
| 6 | 33 #include <unistd.h> |
| 34 #include <fcntl.h> | |
|
113
1e7144176a42
Print a warning if we get an unexpected error trying to open a file.
David A. Holland
parents:
112
diff
changeset
|
35 #include <errno.h> |
| 6 | 36 |
|
183
4c3375895c6e
Don't use <stdbool.h> unless __STDC__ is large enough.
David A. Holland
parents:
175
diff
changeset
|
37 #include "bool.h" |
| 6 | 38 #include "array.h" |
| 15 | 39 #include "mode.h" |
| 8 | 40 #include "place.h" |
| 6 | 41 #include "files.h" |
| 15 | 42 #include "directive.h" |
| 6 | 43 |
| 44 struct incdir { | |
| 45 const char *name; | |
| 46 bool issystem; | |
| 47 }; | |
| 48 | |
| 107 | 49 DECLARRAY(incdir, static UNUSED); |
|
47
2e25e55dba6b
Fix inline usage as per the version in dholland-make2.
David A. Holland
parents:
39
diff
changeset
|
50 DEFARRAY(incdir, static); |
| 6 | 51 |
| 52 static struct incdirarray quotepath, bracketpath; | |
| 53 | |
| 54 //////////////////////////////////////////////////////////// | |
| 55 // management | |
| 56 | |
| 57 static | |
| 58 struct incdir * | |
| 59 incdir_create(const char *name, bool issystem) | |
| 60 { | |
| 61 struct incdir *id; | |
| 62 | |
| 63 id = domalloc(sizeof(*id)); | |
| 64 id->name = name; | |
| 65 id->issystem = issystem; | |
| 66 return id; | |
| 67 } | |
| 68 | |
| 69 static | |
| 70 void | |
| 71 incdir_destroy(struct incdir *id) | |
| 72 { | |
|
39
337110e7240a
Pass the size to free; it makes debug checking easier.
David A. Holland
parents:
38
diff
changeset
|
73 dofree(id, sizeof(*id)); |
| 6 | 74 } |
| 75 | |
| 76 void | |
| 77 files_init(void) | |
| 78 { | |
| 79 incdirarray_init("epath); | |
| 80 incdirarray_init(&bracketpath); | |
| 81 } | |
| 82 | |
| 9 | 83 DESTROYALL_ARRAY(incdir, ); |
| 6 | 84 |
| 85 void | |
| 86 files_cleanup(void) | |
| 87 { | |
| 88 incdirarray_destroyall("epath); | |
| 89 incdirarray_cleanup("epath); | |
| 90 incdirarray_destroyall(&bracketpath); | |
| 91 incdirarray_cleanup(&bracketpath); | |
| 92 } | |
| 93 | |
| 94 //////////////////////////////////////////////////////////// | |
| 95 // path setup | |
| 96 | |
| 97 void | |
| 98 files_addquotepath(const char *dir, bool issystem) | |
| 99 { | |
| 100 struct incdir *id; | |
| 101 | |
| 102 id = incdir_create(dir, issystem); | |
| 103 incdirarray_add("epath, id, NULL); | |
| 104 } | |
| 105 | |
| 106 void | |
| 107 files_addbracketpath(const char *dir, bool issystem) | |
| 108 { | |
| 109 struct incdir *id; | |
| 110 | |
| 111 id = incdir_create(dir, issystem); | |
| 112 incdirarray_add(&bracketpath, id, NULL); | |
| 113 } | |
| 114 | |
| 115 //////////////////////////////////////////////////////////// | |
| 116 // parsing | |
| 117 | |
| 75 | 118 /* |
| 119 * Find the end of the logical line. End of line characters that are | |
| 120 * commented out do not count. | |
| 121 */ | |
| 15 | 122 static |
| 123 size_t | |
| 75 | 124 findeol(const char *buf, size_t start, size_t limit) |
| 15 | 125 { |
| 126 size_t i; | |
| 75 | 127 int incomment = 0; |
|
81
27c9aafcaca1
Don't recognize comments within double-quote strings.
David A. Holland
parents:
75
diff
changeset
|
128 bool inquote = false; |
|
128
1cda505ddc78
Don't expand macros within character constants.
David A. Holland
parents:
113
diff
changeset
|
129 char quote = '\0'; |
| 75 | 130 |
| 131 for (i=start; i<limit; i++) { | |
| 132 if (incomment) { | |
| 133 if (i+1 < limit && buf[i] == '*' && buf[i+1] == '/') { | |
| 134 i++; | |
| 135 incomment = 0; | |
| 136 } | |
|
81
27c9aafcaca1
Don't recognize comments within double-quote strings.
David A. Holland
parents:
75
diff
changeset
|
137 } else if (!inquote && i+1 < limit && |
|
27c9aafcaca1
Don't recognize comments within double-quote strings.
David A. Holland
parents:
75
diff
changeset
|
138 buf[i] == '/' && buf[i+1] == '*') { |
|
27c9aafcaca1
Don't recognize comments within double-quote strings.
David A. Holland
parents:
75
diff
changeset
|
139 i++; |
|
27c9aafcaca1
Don't recognize comments within double-quote strings.
David A. Holland
parents:
75
diff
changeset
|
140 incomment = 1; |
|
27c9aafcaca1
Don't recognize comments within double-quote strings.
David A. Holland
parents:
75
diff
changeset
|
141 } else if (i+1 < limit && |
|
128
1cda505ddc78
Don't expand macros within character constants.
David A. Holland
parents:
113
diff
changeset
|
142 buf[i] == '\\' && buf[i+1] != '\n') { |
|
81
27c9aafcaca1
Don't recognize comments within double-quote strings.
David A. Holland
parents:
75
diff
changeset
|
143 i++; |
|
128
1cda505ddc78
Don't expand macros within character constants.
David A. Holland
parents:
113
diff
changeset
|
144 } else if (!inquote && (buf[i] == '"' || buf[i] == '\'')) { |
|
1cda505ddc78
Don't expand macros within character constants.
David A. Holland
parents:
113
diff
changeset
|
145 inquote = true; |
|
1cda505ddc78
Don't expand macros within character constants.
David A. Holland
parents:
113
diff
changeset
|
146 quote = buf[i]; |
|
1cda505ddc78
Don't expand macros within character constants.
David A. Holland
parents:
113
diff
changeset
|
147 } else if (inquote && buf[i] == quote) { |
|
1cda505ddc78
Don't expand macros within character constants.
David A. Holland
parents:
113
diff
changeset
|
148 inquote = false; |
|
81
27c9aafcaca1
Don't recognize comments within double-quote strings.
David A. Holland
parents:
75
diff
changeset
|
149 } else if (buf[i] == '\n') { |
|
27c9aafcaca1
Don't recognize comments within double-quote strings.
David A. Holland
parents:
75
diff
changeset
|
150 return i; |
| 75 | 151 } |
| 152 } | |
| 153 return limit; | |
| 154 } | |
| 155 | |
| 156 static | |
| 157 unsigned | |
| 158 countnls(const char *buf, size_t start, size_t limit) | |
| 159 { | |
| 160 size_t i; | |
| 161 unsigned count = 0; | |
| 15 | 162 |
| 163 for (i=start; i<limit; i++) { | |
| 164 if (buf[i] == '\n') { | |
| 75 | 165 count++; |
| 15 | 166 } |
| 167 } | |
| 75 | 168 return count; |
| 15 | 169 } |
| 170 | |
| 171 static | |
| 6 | 172 void |
| 28 | 173 file_read(const struct placefile *pf, int fd, const char *name, bool toplevel) |
| 15 | 174 { |
|
154
a2c2fe8dbea3
Wrap up the current and next line position when invoking directives.
David A. Holland
parents:
143
diff
changeset
|
175 struct lineplace places; |
|
a2c2fe8dbea3
Wrap up the current and next line position when invoking directives.
David A. Holland
parents:
143
diff
changeset
|
176 struct place ptmp; |
| 15 | 177 size_t bufend, bufmax, linestart, lineend, nextlinestart, tmp; |
| 178 ssize_t result; | |
| 179 bool ateof = false; | |
| 180 char *buf; | |
| 181 | |
|
154
a2c2fe8dbea3
Wrap up the current and next line position when invoking directives.
David A. Holland
parents:
143
diff
changeset
|
182 place_setfilestart(&places.current, pf); |
|
a2c2fe8dbea3
Wrap up the current and next line position when invoking directives.
David A. Holland
parents:
143
diff
changeset
|
183 places.nextline = places.current; |
| 15 | 184 |
|
199
1d2bad7151f9
Add a -debuglog option to send an execution trace to a file.
David A. Holland
parents:
187
diff
changeset
|
185 if (name) { |
|
1d2bad7151f9
Add a -debuglog option to send an execution trace to a file.
David A. Holland
parents:
187
diff
changeset
|
186 debuglog(&places.current, "Reading file %s", name); |
|
1d2bad7151f9
Add a -debuglog option to send an execution trace to a file.
David A. Holland
parents:
187
diff
changeset
|
187 } else { |
|
1d2bad7151f9
Add a -debuglog option to send an execution trace to a file.
David A. Holland
parents:
187
diff
changeset
|
188 debuglog(&places.current, "Reading standard input"); |
|
1d2bad7151f9
Add a -debuglog option to send an execution trace to a file.
David A. Holland
parents:
187
diff
changeset
|
189 } |
|
1d2bad7151f9
Add a -debuglog option to send an execution trace to a file.
David A. Holland
parents:
187
diff
changeset
|
190 |
| 15 | 191 bufmax = 128; |
| 192 bufend = 0; | |
| 193 linestart = 0; | |
| 194 lineend = 0; | |
| 195 buf = domalloc(bufmax); | |
| 196 | |
| 197 while (1) { | |
| 198 if (lineend >= bufend) { | |
| 199 /* do not have a whole line in the buffer; read more */ | |
| 75 | 200 assert(bufend >= linestart); |
| 15 | 201 if (linestart > 0 && bufend > linestart) { |
| 202 /* slide to beginning of buffer */ | |
| 203 memmove(buf, buf+linestart, bufend-linestart); | |
| 204 bufend -= linestart; | |
| 205 lineend -= linestart; | |
| 206 linestart = 0; | |
| 207 } | |
| 208 if (bufend >= bufmax) { | |
| 209 /* need bigger buffer */ | |
|
39
337110e7240a
Pass the size to free; it makes debug checking easier.
David A. Holland
parents:
38
diff
changeset
|
210 buf = dorealloc(buf, bufmax, bufmax*2); |
|
337110e7240a
Pass the size to free; it makes debug checking easier.
David A. Holland
parents:
38
diff
changeset
|
211 bufmax = bufmax*2; |
| 15 | 212 } |
| 213 | |
| 214 if (ateof) { | |
| 215 /* don't read again, in case it's a socket */ | |
| 216 result = 0; | |
| 217 } else { | |
| 218 result = read(fd, buf+bufend, bufmax - bufend); | |
| 219 } | |
| 220 | |
| 221 if (result == -1) { | |
| 222 /* read error */ | |
| 143 | 223 complain(NULL, "%s: %s", |
| 224 name, strerror(errno)); | |
| 15 | 225 complain_fail(); |
| 226 } else if (result == 0 && bufend == linestart) { | |
| 227 /* eof */ | |
| 228 ateof = true; | |
| 229 break; | |
| 230 } else if (result == 0) { | |
| 231 /* eof in middle of line */ | |
| 232 ateof = true; | |
|
154
a2c2fe8dbea3
Wrap up the current and next line position when invoking directives.
David A. Holland
parents:
143
diff
changeset
|
233 ptmp = places.current; |
| 15 | 234 ptmp.column += bufend - linestart; |
|
186
9637bf434f8e
Don't report unclosed comments as "no newline at end of file".
David A. Holland
parents:
183
diff
changeset
|
235 if (buf[bufend - 1] == '\n') { |
|
9637bf434f8e
Don't report unclosed comments as "no newline at end of file".
David A. Holland
parents:
183
diff
changeset
|
236 complain(&ptmp, "Unclosed comment"); |
| 187 | 237 complain_fail(); |
|
186
9637bf434f8e
Don't report unclosed comments as "no newline at end of file".
David A. Holland
parents:
183
diff
changeset
|
238 } else { |
|
9637bf434f8e
Don't report unclosed comments as "no newline at end of file".
David A. Holland
parents:
183
diff
changeset
|
239 complain(&ptmp, |
|
9637bf434f8e
Don't report unclosed comments as "no newline at end of file".
David A. Holland
parents:
183
diff
changeset
|
240 "No newline at end of file"); |
|
9637bf434f8e
Don't report unclosed comments as "no newline at end of file".
David A. Holland
parents:
183
diff
changeset
|
241 } |
| 15 | 242 if (mode.werror) { |
| 243 complain_fail(); | |
| 244 } | |
| 245 assert(bufend < bufmax); | |
| 246 lineend = bufend++; | |
| 247 buf[lineend] = '\n'; | |
| 248 } else { | |
| 249 bufend += (size_t)result; | |
|
81
27c9aafcaca1
Don't recognize comments within double-quote strings.
David A. Holland
parents:
75
diff
changeset
|
250 lineend = findeol(buf, linestart, bufend); |
| 15 | 251 } |
| 252 /* loop in case we still don't have a whole line */ | |
| 253 continue; | |
| 254 } | |
| 255 | |
| 256 /* have a line */ | |
| 257 assert(buf[lineend] == '\n'); | |
| 258 buf[lineend] = '\0'; | |
| 259 nextlinestart = lineend+1; | |
|
154
a2c2fe8dbea3
Wrap up the current and next line position when invoking directives.
David A. Holland
parents:
143
diff
changeset
|
260 places.nextline.line++; |
| 15 | 261 |
| 262 /* check for CR/NL */ | |
| 263 if (lineend > 0 && buf[lineend-1] == '\r') { | |
| 264 buf[lineend-1] = '\0'; | |
| 265 lineend--; | |
| 266 } | |
| 267 | |
| 268 /* check for continuation line */ | |
| 269 if (lineend > 0 && buf[lineend-1]=='\\') { | |
| 270 lineend--; | |
| 271 tmp = nextlinestart - lineend; | |
| 272 if (bufend > nextlinestart) { | |
| 273 memmove(buf+lineend, buf+nextlinestart, | |
| 274 bufend - nextlinestart); | |
| 275 } | |
| 276 bufend -= tmp; | |
| 277 nextlinestart -= tmp; | |
|
81
27c9aafcaca1
Don't recognize comments within double-quote strings.
David A. Holland
parents:
75
diff
changeset
|
278 lineend = findeol(buf, linestart, bufend); |
| 15 | 279 /* might not have a whole line, so loop */ |
| 280 continue; | |
| 281 } | |
| 282 | |
| 283 /* line now goes from linestart to lineend */ | |
| 284 assert(buf[lineend] == '\0'); | |
| 75 | 285 |
| 286 /* count how many commented-out newlines we swallowed */ | |
|
154
a2c2fe8dbea3
Wrap up the current and next line position when invoking directives.
David A. Holland
parents:
143
diff
changeset
|
287 places.nextline.line += countnls(buf, linestart, lineend); |
| 75 | 288 |
| 175 | 289 /* process the line (even if it's empty) */ |
| 290 directive_gotline(&places, buf+linestart, lineend-linestart); | |
| 15 | 291 |
| 292 linestart = nextlinestart; | |
| 75 | 293 lineend = findeol(buf, linestart, bufend); |
|
154
a2c2fe8dbea3
Wrap up the current and next line position when invoking directives.
David A. Holland
parents:
143
diff
changeset
|
294 places.current = places.nextline; |
| 15 | 295 } |
| 296 | |
| 28 | 297 if (toplevel) { |
|
154
a2c2fe8dbea3
Wrap up the current and next line position when invoking directives.
David A. Holland
parents:
143
diff
changeset
|
298 directive_goteof(&places.current); |
| 28 | 299 } |
|
39
337110e7240a
Pass the size to free; it makes debug checking easier.
David A. Holland
parents:
38
diff
changeset
|
300 dofree(buf, bufmax); |
| 15 | 301 } |
| 6 | 302 |
| 303 //////////////////////////////////////////////////////////// | |
| 304 // path search | |
| 305 | |
| 306 static | |
| 13 | 307 char * |
| 112 | 308 mkfilename(struct place *place, const char *dir, const char *file) |
| 13 | 309 { |
| 310 size_t dlen, flen, rlen; | |
| 311 char *ret; | |
| 312 bool needslash = false; | |
| 313 | |
| 112 | 314 if (dir == NULL) { |
| 315 dir = place_getparsedir(place); | |
| 316 } | |
| 317 | |
| 13 | 318 dlen = strlen(dir); |
| 319 flen = strlen(file); | |
| 320 if (dlen > 0 && dir[dlen-1] != '/') { | |
| 321 needslash = true; | |
| 322 } | |
| 323 | |
| 324 rlen = dlen + (needslash ? 1 : 0) + flen; | |
| 325 ret = domalloc(rlen + 1); | |
| 326 strcpy(ret, dir); | |
| 327 if (needslash) { | |
| 328 strcat(ret, "/"); | |
| 329 } | |
| 330 strcat(ret, file); | |
| 331 return ret; | |
| 332 } | |
| 333 | |
| 334 static | |
| 6 | 335 int |
| 336 file_tryopen(const char *file) | |
| 337 { | |
| 338 int fd; | |
| 339 | |
| 15 | 340 /* XXX check for non-regular files */ |
| 341 | |
| 6 | 342 fd = open(file, O_RDONLY); |
| 343 if (fd < 0) { | |
|
113
1e7144176a42
Print a warning if we get an unexpected error trying to open a file.
David A. Holland
parents:
112
diff
changeset
|
344 if (errno != ENOENT && errno != ENOTDIR) { |
| 143 | 345 complain(NULL, "%s: %s", file, strerror(errno)); |
|
113
1e7144176a42
Print a warning if we get an unexpected error trying to open a file.
David A. Holland
parents:
112
diff
changeset
|
346 } |
| 6 | 347 return -1; |
| 348 } | |
| 15 | 349 |
| 6 | 350 return fd; |
| 351 } | |
| 352 | |
| 353 static | |
| 354 void | |
| 355 file_search(struct place *place, struct incdirarray *path, const char *name) | |
| 356 { | |
| 357 unsigned i, num; | |
| 358 struct incdir *id; | |
| 13 | 359 const struct placefile *pf; |
| 6 | 360 char *file; |
| 361 int fd; | |
| 362 | |
| 363 assert(place != NULL); | |
| 364 | |
| 104 | 365 if (name[0] == '/') { |
| 366 fd = file_tryopen(name); | |
| 6 | 367 if (fd >= 0) { |
| 104 | 368 pf = place_addfile(place, name, true); |
| 369 file_read(pf, fd, name, false); | |
| 6 | 370 close(fd); |
| 371 return; | |
| 372 } | |
| 104 | 373 } else { |
| 374 num = incdirarray_num(path); | |
| 375 for (i=0; i<num; i++) { | |
| 376 id = incdirarray_get(path, i); | |
| 112 | 377 file = mkfilename(place, id->name, name); |
| 104 | 378 fd = file_tryopen(file); |
| 379 if (fd >= 0) { | |
| 380 pf = place_addfile(place, file, id->issystem); | |
| 381 file_read(pf, fd, file, false); | |
| 382 dostrfree(file); | |
| 383 close(fd); | |
| 384 return; | |
| 385 } | |
| 386 dostrfree(file); | |
| 387 } | |
| 6 | 388 } |
| 389 complain(place, "Include file %s not found", name); | |
| 390 complain_fail(); | |
| 391 } | |
| 392 | |
| 393 void | |
| 394 file_readquote(struct place *place, const char *name) | |
| 395 { | |
| 396 file_search(place, "epath, name); | |
| 397 } | |
| 398 | |
| 399 void | |
| 400 file_readbracket(struct place *place, const char *name) | |
| 401 { | |
| 402 file_search(place, &bracketpath, name); | |
| 403 } | |
| 404 | |
| 405 void | |
| 406 file_readabsolute(struct place *place, const char *name) | |
| 407 { | |
| 13 | 408 const struct placefile *pf; |
| 6 | 409 int fd; |
| 410 | |
| 411 assert(place != NULL); | |
| 412 | |
| 24 | 413 if (name == NULL) { |
| 414 fd = STDIN_FILENO; | |
| 415 pf = place_addfile(place, "<standard-input>", false); | |
| 416 } else { | |
| 417 fd = file_tryopen(name); | |
| 418 if (fd < 0) { | |
| 143 | 419 complain(NULL, "%s: %s", name, strerror(errno)); |
| 24 | 420 die(); |
| 421 } | |
| 422 pf = place_addfile(place, name, false); | |
| 6 | 423 } |
| 24 | 424 |
| 28 | 425 file_read(pf, fd, name, true); |
| 24 | 426 |
| 427 if (name != NULL) { | |
| 428 close(fd); | |
| 429 } | |
| 6 | 430 } |