error.c 9.6 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623
  1. /*
  2. * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
  3. * See the copyright notice in the ACK home directory, in the file "Copyright".
  4. */
  5. /* $Id$ */
  6. /* E R R O R A N D D I A G N O S T I C R O U T I N E S */
  7. #include "lint.h"
  8. #if __STDC__
  9. #include <stdio.h>
  10. #include <stdarg.h>
  11. #else
  12. #include <varargs.h>
  13. #endif
  14. #include <system.h>
  15. #ifndef LINT
  16. #include <em.h>
  17. #else
  18. #include "l_em.h"
  19. #endif /* LINT */
  20. #include "debug.h"
  21. #include "lint.h"
  22. #include "nopp.h"
  23. #include "errout.h"
  24. #include "print.h"
  25. #include "tokenname.h"
  26. #include <flt_arith.h>
  27. #include "arith.h"
  28. #include "label.h"
  29. #include "expr.h"
  30. #include "def.h"
  31. #include "LLlex.h"
  32. #include "error.h"
  33. /* This file contains the error-message and diagnostic
  34. functions. Beware, they are called with a variable number of
  35. arguments!
  36. */
  37. static void _error(int class, char *fn, unsigned int ln, char *fmt, va_list ap);
  38. /* error classes */
  39. #define STRICT 1
  40. #define WARNING 2
  41. #define ERROR 3
  42. #define CRASH 4
  43. #define FATAL 5
  44. #define DO_DEBUG 6
  45. int err_occurred = 0;
  46. extern char options[];
  47. #ifdef LINT
  48. extern char loptions[];
  49. #endif /* LINT */
  50. /* There are three general error-message functions:
  51. lexerror() lexical and pre-processor error messages
  52. error() syntactic and semantic error messages
  53. expr_error() errors in expressions
  54. The difference lies in the place where the file name and line
  55. number come from.
  56. Lexical errors report from the global variables LineNumber and
  57. FileName, expression errors get their information from the
  58. expression, whereas other errors use the information in the token.
  59. */
  60. #if __STDC__
  61. /*VARARGS*/
  62. void error(char *fmt, ...)
  63. {
  64. va_list ap;
  65. va_start(ap, fmt);
  66. {
  67. _error(ERROR, dot.tk_file, dot.tk_line, fmt, ap);
  68. }
  69. va_end(ap);
  70. }
  71. /*VARARGS*/
  72. void expr_error(struct expr *expr, char *fmt, ...)
  73. {
  74. va_list ap;
  75. va_start(ap, fmt);
  76. {
  77. if (!(expr->ex_flags & EX_ERROR)) {
  78. /* to prevent proliferation */
  79. _error(ERROR, expr->ex_file, expr->ex_line, fmt, ap);
  80. expr->ex_flags |= EX_ERROR;
  81. }
  82. }
  83. va_end(ap);
  84. }
  85. /*VARARGS*/
  86. void lexstrict(char *fmt, ...)
  87. {
  88. va_list ap;
  89. va_start(ap, fmt);
  90. {
  91. _error(STRICT, FileName, LineNumber, fmt, ap);
  92. }
  93. va_end(ap);
  94. }
  95. /*VARARGS*/
  96. void strict(char *fmt, ...)
  97. {
  98. va_list ap;
  99. va_start(ap, fmt);
  100. {
  101. _error(STRICT, dot.tk_file, dot.tk_line, fmt, ap);
  102. }
  103. va_end(ap);
  104. }
  105. /*VARARGS*/
  106. void expr_strict(struct expr *expr, char *fmt, ...)
  107. {
  108. va_list ap;
  109. va_start(ap, fmt);
  110. {
  111. if (!(expr->ex_flags & EX_ERROR)) {
  112. /* to prevent proliferation */
  113. _error(STRICT, expr->ex_file, expr->ex_line, fmt, ap);
  114. }
  115. }
  116. va_end(ap);
  117. }
  118. #ifdef DEBUG
  119. /*VARARGS*/
  120. void debug(char *fmt, ...)
  121. {
  122. va_list ap;
  123. va_start(ap, fmt);
  124. {
  125. _error(DO_DEBUG, dot.tk_file, dot.tk_line, fmt, ap);
  126. }
  127. va_end(ap);
  128. }
  129. #endif /* DEBUG */
  130. /*VARARGS*/
  131. void warning(char *fmt, ...)
  132. {
  133. va_list ap;
  134. va_start(ap, fmt);
  135. {
  136. _error(WARNING, dot.tk_file, dot.tk_line, fmt, ap);
  137. }
  138. va_end(ap);
  139. }
  140. /*VARARGS*/
  141. void expr_warning(struct expr *expr, char *fmt, ...)
  142. {
  143. va_list ap;
  144. va_start(ap, fmt);
  145. {
  146. if (!(expr->ex_flags & EX_ERROR)) {
  147. /* to prevent proliferation */
  148. _error(WARNING, expr->ex_file, expr->ex_line, fmt, ap);
  149. }
  150. }
  151. va_end(ap);
  152. }
  153. #ifdef LINT
  154. /*VARARGS*/
  155. void def_warning(struct def *def, char *fmt, ...)
  156. {
  157. va_list ap;
  158. va_start(ap, fmt);
  159. {
  160. _error(WARNING, def->df_file, def->df_line, fmt, ap);
  161. }
  162. va_end(ap);
  163. }
  164. /*VARARGS*/
  165. void hwarning(char *fmt, ...)
  166. {
  167. va_list ap;
  168. va_start(ap, fmt);
  169. {
  170. if (loptions['h'])
  171. _error(WARNING, dot.tk_file, dot.tk_line, fmt, ap);
  172. }
  173. va_end(ap);
  174. }
  175. /*VARARGS*/
  176. void awarning(char *fmt, ...)
  177. {
  178. va_list ap;
  179. va_start(ap, fmt);
  180. {
  181. if (loptions['a'])
  182. _error(WARNING, dot.tk_file, dot.tk_line, fmt, ap);
  183. }
  184. va_end(ap);
  185. }
  186. #endif /* LINT */
  187. /*VARARGS*/
  188. void lexerror(char *fmt, ...)
  189. {
  190. va_list ap;
  191. va_start(ap, fmt);
  192. {
  193. _error(ERROR, FileName, LineNumber, fmt, ap);
  194. }
  195. va_end(ap);
  196. }
  197. /*VARARGS*/
  198. void lexwarning(char *fmt, ...)
  199. {
  200. va_list ap;
  201. va_start(ap, fmt);
  202. {
  203. _error(WARNING, FileName, LineNumber, fmt, ap);
  204. }
  205. va_end(ap);
  206. }
  207. /*VARARGS*/
  208. void crash(char *fmt, ...)
  209. {
  210. va_list ap;
  211. va_start(ap, fmt);
  212. {
  213. _error(CRASH, FileName, LineNumber, fmt, ap);
  214. }
  215. va_end(ap);
  216. C_close();
  217. #ifdef DEBUG
  218. sys_stop(S_ABORT);
  219. #else /* DEBUG */
  220. sys_stop(S_EXIT);
  221. #endif /* DEBUG */
  222. /* NOTREACHED */
  223. }
  224. /*VARARGS*/
  225. void fatal(char *fmt, ...)
  226. {
  227. va_list ap;
  228. va_start(ap, fmt);
  229. {
  230. _error(FATAL, FileName, LineNumber, fmt, ap);
  231. }
  232. va_end(ap);
  233. if (C_busy()) C_close();
  234. sys_stop(S_EXIT);
  235. /*NOTREACHED*/
  236. }
  237. #else
  238. /*VARARGS*/
  239. error(va_alist) /* fmt, args */
  240. va_dcl
  241. {
  242. va_list ap;
  243. va_start(ap);
  244. {
  245. char *fmt = va_arg(ap, char *);
  246. _error(ERROR, dot.tk_file, dot.tk_line, fmt, ap);
  247. }
  248. va_end(ap);
  249. }
  250. /*VARARGS*/
  251. expr_error(va_alist) /* expr, fmt, args */
  252. va_dcl
  253. {
  254. va_list ap;
  255. va_start(ap);
  256. {
  257. register struct expr *expr = va_arg(ap, struct expr *);
  258. char *fmt = va_arg(ap, char *);
  259. if (!(expr->ex_flags & EX_ERROR)) {
  260. /* to prevent proliferation */
  261. _error(ERROR, expr->ex_file, expr->ex_line, fmt, ap);
  262. expr->ex_flags |= EX_ERROR;
  263. }
  264. }
  265. va_end(ap);
  266. }
  267. /*VARARGS*/
  268. lexstrict(va_alist)
  269. va_dcl
  270. {
  271. va_list ap;
  272. va_start(ap);
  273. {
  274. char *fmt = va_arg(ap, char *);
  275. _error(STRICT, FileName, LineNumber, fmt, ap);
  276. }
  277. va_end(ap);
  278. }
  279. /*VARARGS*/
  280. strict(va_alist)
  281. va_dcl
  282. {
  283. va_list ap;
  284. va_start(ap);
  285. {
  286. char *fmt = va_arg(ap, char *);
  287. _error(STRICT, dot.tk_file, dot.tk_line, fmt, ap);
  288. }
  289. va_end(ap);
  290. }
  291. /*VARARGS*/
  292. expr_strict(va_alist) /* expr, fmt, args */
  293. va_dcl
  294. {
  295. va_list ap;
  296. va_start(ap);
  297. {
  298. struct expr *expr = va_arg(ap, struct expr *);
  299. char *fmt = va_arg(ap, char *);
  300. if (!(expr->ex_flags & EX_ERROR)) {
  301. /* to prevent proliferation */
  302. _error(STRICT, expr->ex_file, expr->ex_line, fmt, ap);
  303. }
  304. }
  305. va_end(ap);
  306. }
  307. #ifdef DEBUG
  308. /*VARARGS*/
  309. debug(va_alist)
  310. va_dcl
  311. {
  312. va_list ap;
  313. va_start(ap);
  314. {
  315. char *fmt = va_arg(ap, char *);
  316. _error(DO_DEBUG, dot.tk_file, dot.tk_line, fmt, ap);
  317. }
  318. va_end(ap);
  319. }
  320. #endif /* DEBUG */
  321. /*VARARGS*/
  322. warning(va_alist)
  323. va_dcl
  324. {
  325. va_list ap;
  326. va_start(ap);
  327. {
  328. char *fmt = va_arg(ap, char *);
  329. _error(WARNING, dot.tk_file, dot.tk_line, fmt, ap);
  330. }
  331. va_end(ap);
  332. }
  333. /*VARARGS*/
  334. expr_warning(va_alist) /* expr, fmt, args */
  335. va_dcl
  336. {
  337. va_list ap;
  338. va_start(ap);
  339. {
  340. struct expr *expr = va_arg(ap, struct expr *);
  341. char *fmt = va_arg(ap, char *);
  342. if (!(expr->ex_flags & EX_ERROR)) {
  343. /* to prevent proliferation */
  344. _error(WARNING, expr->ex_file, expr->ex_line, fmt, ap);
  345. }
  346. }
  347. va_end(ap);
  348. }
  349. #ifdef LINT
  350. /*VARARGS*/
  351. def_warning(va_alist) /* def, fmt, args */
  352. va_dcl
  353. {
  354. va_list ap;
  355. va_start(ap);
  356. {
  357. register struct def *def = va_arg(ap, struct def *);
  358. char *fmt = va_arg(ap, char *);
  359. _error(WARNING, def->df_file, def->df_line, fmt, ap);
  360. }
  361. va_end(ap);
  362. }
  363. /*VARARGS*/
  364. hwarning(va_alist) /* fmt, args */
  365. va_dcl
  366. {
  367. va_list ap;
  368. va_start(ap);
  369. {
  370. char *fmt = va_arg(ap, char *);
  371. if (loptions['h'])
  372. _error(WARNING, dot.tk_file, dot.tk_line, fmt, ap);
  373. }
  374. va_end(ap);
  375. }
  376. /*VARARGS*/
  377. awarning(va_alist) /* fmt, args */
  378. va_dcl
  379. {
  380. va_list ap;
  381. va_start(ap);
  382. {
  383. char *fmt = va_arg(ap, char *);
  384. if (loptions['a'])
  385. _error(WARNING, dot.tk_file, dot.tk_line, fmt, ap);
  386. }
  387. va_end(ap);
  388. }
  389. #endif /* LINT */
  390. /*VARARGS*/
  391. lexerror(va_alist) /* fmt, args */
  392. va_dcl
  393. {
  394. va_list ap;
  395. va_start(ap);
  396. {
  397. char *fmt = va_arg(ap, char *);
  398. _error(ERROR, FileName, LineNumber, fmt, ap);
  399. }
  400. va_end(ap);
  401. }
  402. /*VARARGS*/
  403. lexwarning(va_alist) /* fmt, args */
  404. va_dcl
  405. {
  406. va_list ap;
  407. va_start(ap);
  408. {
  409. char *fmt = va_arg(ap, char *);
  410. _error(WARNING, FileName, LineNumber, fmt, ap);
  411. }
  412. va_end(ap);
  413. }
  414. /*VARARGS*/
  415. crash(va_alist) /* fmt, args */
  416. va_dcl
  417. {
  418. va_list ap;
  419. va_start(ap);
  420. {
  421. char *fmt = va_arg(ap, char *);
  422. _error(CRASH, FileName, LineNumber, fmt, ap);
  423. }
  424. va_end(ap);
  425. C_close();
  426. #ifdef DEBUG
  427. sys_stop(S_ABORT);
  428. #else /* DEBUG */
  429. sys_stop(S_EXIT);
  430. #endif /* DEBUG */
  431. /* NOTREACHED */
  432. }
  433. /*VARARGS*/
  434. fatal(va_alist) /* fmt, args */
  435. va_dcl
  436. {
  437. va_list ap;
  438. va_start(ap);
  439. {
  440. char *fmt = va_arg(ap, char *);
  441. _error(FATAL, FileName, LineNumber, fmt, ap);
  442. }
  443. va_end(ap);
  444. if (C_busy()) C_close();
  445. sys_stop(S_EXIT);
  446. /*NOTREACHED*/
  447. }
  448. #endif
  449. static void _error(int class, char *fn, unsigned int ln, char *fmt, va_list ap)
  450. {
  451. char *remark = NULL;
  452. /* check visibility of message */
  453. switch (class) {
  454. case WARNING:
  455. case ERROR:
  456. case STRICT:
  457. if (token_nmb < tk_nmb_at_last_syn_err + ERR_SHADOW)
  458. /* warning or error message overshadowed */
  459. return;
  460. break;
  461. }
  462. /* Since name and number are gathered from different places
  463. depending on the class, we first collect the relevant
  464. values and then decide what to print.
  465. */
  466. /* preliminaries */
  467. switch (class) {
  468. case WARNING:
  469. if (options['w'])
  470. return;
  471. break;
  472. case STRICT:
  473. if (options['s'])
  474. return;
  475. break;
  476. case ERROR:
  477. case CRASH:
  478. case FATAL:
  479. if (C_busy())
  480. C_ms_err();
  481. err_occurred = 1;
  482. break;
  483. }
  484. /* the remark */
  485. switch (class) {
  486. case STRICT:
  487. remark = "(strict)";
  488. break;
  489. case WARNING:
  490. #ifndef LINT
  491. remark = "(warning)";
  492. #else /* LINT */
  493. remark = 0;
  494. #endif /* LINT */
  495. break;
  496. case ERROR:
  497. remark = 0;
  498. break;
  499. case CRASH:
  500. remark = "CRASH\007";
  501. break;
  502. case FATAL:
  503. remark = "fatal error --";
  504. break;
  505. #ifdef DEBUG
  506. case DO_DEBUG:
  507. remark = "(debug)";
  508. break;
  509. #endif /* DEBUG */
  510. default:
  511. /*NOTREACHED*/;
  512. }
  513. #ifdef LINT
  514. if ( /* there is a file name */
  515. fn
  516. && /* the file name is global */
  517. fn[0] == '/'
  518. && /* it is not a .c file */
  519. strcmp(&fn[strlen(fn)-2], ".c") != 0
  520. ) {
  521. /* we skip this message */
  522. return;
  523. }
  524. #endif /* LINT */
  525. if (fn)
  526. fprintf(stderr, "\"%s\", line %u: ", fn, ln);
  527. if (remark)
  528. fprintf(stderr, "%s ", remark);
  529. doprnt(ERROUT, fmt, ap); /* contents of error */
  530. fprintf(stderr, "\n");
  531. }