?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
acc: remove quite pointless comments
[acc.git] / main.c
blobcfc3736a888058d4c44980283ca3b94714d6e007
1 /* Alexey's C compiler. */
2 #include <stdlib.h>
3 #include <sys/types.h>
4 #include <sys/stat.h>
5 #include <fcntl.h>
6 #include <stdio.h>
7 #include <errno.h>
8 #include <unistd.h>
9 #include <stdarg.h>
10 #include <stdint.h>
11 #include <inttypes.h>
12 #include <string.h>
13 #include <limits.h>
14
15 struct pos {
16 unsigned int line, column;
17 };
18
19 #ifdef __GNUC__
20 #define __noreturn __attribute((noreturn))
21 #define __printf(a, b) __attribute__((format(printf, a, b)))
22 #else
23 #define __noreturn
24 #define __printf(a, b)
25 #endif
26
27 static void warning(struct pos *pos, const char *fmt, ...) __printf(2, 3);
28 static void warning(struct pos *pos, const char *fmt, ...)
29 {
30 va_list args;
31
32 fprintf(stderr, "%u:%u: warning: ", pos->line, pos->column);
33 va_start(args, fmt);
34 vfprintf(stderr, fmt, args);
35 va_end(args);
36 fputc('\n', stderr);
37 }
38
39 static void error_exit(struct pos *pos, const char *fmt, ...) __printf(2, 3) __noreturn;
40 static void error_exit(struct pos *pos, const char *fmt, ...)
41 {
42 va_list args;
43
44 fprintf(stderr, "%u:%u: error: ", pos->line, pos->column);
45 va_start(args, fmt);
46 vfprintf(stderr, fmt, args);
47 va_end(args);
48 fputc('\n', stderr);
49 exit(EXIT_FAILURE);
50 }
51
52 static void perror_exit(const char *fmt, ...) __printf(1, 2) __noreturn;
53 static void perror_exit(const char *fmt, ...)
54 {
55 int old_errno = errno;
56 va_list args;
57
58 fputs("acc: ", stderr);
59 va_start(args, fmt);
60 vfprintf(stderr, fmt, args);
61 va_end(args);
62 fputs(": ", stderr);
63 errno = old_errno;
64 perror(NULL);
65 exit(EXIT_FAILURE);
66 }
67
68 static void _error_exit(const char *fmt, ...) __printf(1, 2) __noreturn;
69 static void _error_exit(const char *fmt, ...)
70 {
71 va_list args;
72
73 fputs("acc: error: ", stderr);
74 va_start(args, fmt);
75 vfprintf(stderr, fmt, args);
76 va_end(args);
77 fputc('\n', stderr);
78 exit(EXIT_FAILURE);
79 }
80
81 static void *xmalloc(size_t size)
82 {
83 void *p;
84
85 p = malloc(size);
86 if (!p)
87 perror_exit("%s: size %zu", __func__, size);
88 return p;
89 }
90
91 static void *xmemdup(const void *src, size_t n)
92 {
93 void *dst;
94
95 dst = xmalloc(n);
96 memcpy(dst, src, n);
97 return dst;
98 }
99
100 static ssize_t _xread(int fd, void *buf, size_t count)
101 {
102 ssize_t rv;
103
104 do {
105 rv = read(fd, buf, count);
106 } while (rv == -1 && (errno == EAGAIN || errno == EINTR));
107 return rv;
108 }
109
110 static void xread(int fd, void *buf, size_t count)
111 {
112 while (count > 0) {
113 ssize_t rv;
114
115 rv = _xread(fd, buf, count);
116 if (rv == -1)
117 perror_exit("read fd %d, buf %p, count %zu", fd, buf, count);
118 if (rv == 0)
119 _error_exit("fd %d truncated, buf %p, count %zu", fd, buf, count);
120
121 buf = (char *)buf + rv;
122 count -= rv;
123 }
124 }
125
126 static void convert_from_utf8(uint8_t *_c, unsigned int _nr_c, uint32_t **c, unsigned int *nr_c)
127 {
128 unsigned int i;
129
130 if (_nr_c >= 0xffffffff / sizeof(uint32_t))
131 _error_exit("integer overflow _nr_c %"PRIu32, _nr_c);
132
133 /* At worse all data is ASCII. */
134 *c = xmalloc(_nr_c * sizeof(uint32_t));
135 *nr_c = 0;
136
137 i = 0;
138 while (i < _nr_c) {
139 static const struct {
140 uint8_t mask1, res1;
141 uint32_t min;
142 } _mask[] = {
143 { 0x80, 0x00, 0 }, /* 0xxxxxxx */
144 { 0xe0, 0xc0, 0x80 }, /* 110xxxxx 10xxxxxx */
145 { 0xf0, 0xe0, 0x800 }, /* 1110xxxx 10xxxxxx 10xxxxxx */
146 { 0xf8, 0xf0, 0x10000 }, /* 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx */
147 };
148 unsigned int level, j;
149 uint32_t ch;
150
151 level = 0;
152 while (level < sizeof(_mask) / sizeof(_mask[0])) {
153 if ((_c[i] & _mask[level].mask1) == _mask[level].res1)
154 break;
155 level++;
156 }
157 if (level == sizeof(_mask) / sizeof(_mask[0]))
158 _error_exit("invalid UTF-8 octet sequence at %u: %02"PRIx8, i, _c[i]);
159 if (i + level >= _nr_c)
160 _error_exit("truncated UTF-8 octet sequence at %u: %02"PRIx8, i, _c[i]);
161 for (j = 0; j < level; j++) {
162 if ((_c[i + j + 1] & 0xc0) != 0x80)
163 _error_exit("invalid UTF-8 octet sequence at %u: %02"PRIx8" ... %02"PRIx8, i + j + 1, _c[i], _c[i + j + 1]);
164 }
165
166 ch = _c[i] & ~_mask[level].mask1;
167 for (j = 0; j < level; j++)
168 ch = (ch << 6) | (_c[i + j + 1] & ~0xc0);
169
170 if (ch < _mask[level].min)
171 _error_exit("invalid UTF-8 octet sequence at %u: %02"PRIx8, i, _c[i]);
172
173 i += level + 1;
174
175 (*c)[*nr_c] = ch;
176 (*nr_c)++;
177 }
178 }
179
180 /* LINE SEPARATOR to catch \n. */
181 #define LS ((uint32_t)0x2028)
182
183 static void fix_newline(uint32_t *c, unsigned int *nr_c)
184 {
185 unsigned int i;
186
187 i = 0;
188 while (i < *nr_c) {
189 if (c[i] == 0x0d && i + 1 < *nr_c && c[i + 1] == 0x0a) {
190 memmove(&c[i], &c[i + 1], *nr_c - i - 1);
191 (*nr_c)--;
192 }
193 switch (c[i]) {
194 case 0x0d:
195 case 0x0a:
196 case 0x85:
197 case 0x0b:
198 case 0x0c:
199 case 0x2028:
200 case 0x2029:
201 c[i] = LS;
202 }
203 i++;
204 }
205 }
206
207 static struct pos *line_column(const uint32_t *c, unsigned int nr_c)
208 {
209 struct pos *pos;
210 unsigned int line, column;
211 unsigned int i;
212
213 if (nr_c >= 0xffffffff / sizeof(struct pos))
214 _error_exit("integer overflow nr_c %u", nr_c);
215 pos = xmalloc(nr_c * sizeof(struct pos));
216
217 line = 1;
218 column = 1;
219 for (i = 0; i < nr_c; i++) {
220 pos[i].line = line;
221 pos[i].column = column;
222
223 if (c[i] == LS) {
224 line++;
225 column = 1;
226 } else
227 column++;
228 }
229 return pos;
230 }
231
232 static void warn_trigraph(const uint32_t *c, unsigned int nr_c, struct pos *pos)
233 {
234 unsigned int i;
235
236 i = 0;
237 while (i + 2 < nr_c) {
238 if (c[i] == '?' && c[i + 1] == '?') {
239 switch (c[i + 2]) {
240 case '=':case ')':case '!':
241 case '(':case '\'':case '>':
242 case '/':case '<':case '-':
243 warning(&pos[i], "trigraph sequence ??%c, ignoring", c[i + 2]);
244 i += 3;
245 break;
246 default:
247 i++;
248 }
249 } else
250 i++;
251 }
252 }
253
254 static void delete_backslash_newline(uint32_t *c, unsigned int *nr_c, struct pos *pos)
255 {
256 unsigned int i;
257
258 i = 0;
259 while (i + 1 < *nr_c) {
260 if (c[i] == '\\' && c[i + 1] == LS) {
261 unsigned int nr_to_move = *nr_c - i - 2;
262
263 memmove(&c[i], &c[i + 2], nr_to_move * sizeof(uint32_t));
264 memmove(&pos[i], &pos[i + 2], nr_to_move * sizeof(struct pos));
265 (*nr_c) -= 2;
266 } else
267 i++;
268 }
269 }
270
271 struct pp_token {
272 struct pp_token *next;
273 enum pp_token_type {
274 PP_TOKEN_IDENTIFIER = UCHAR_MAX + 1,
275 PP_TOKEN_NUMBER,
276 PP_TOKEN_STRING,
277 PP_TOKEN_CHAR,
278
279 #define _2(c1, c2) ((((uint32_t)c1) << 8) | ((uint32_t)c2))
280 #define _3(c1, c2, c3) ((((uint32_t)c1) << 16)| (((uint32_t)c2) << 8) | ((uint32_t)c3))
281 PP_TOKEN_DOTDOTDOT = _3('.', '.', '.'),
282 PP_TOKEN_DEREFERENCE = _2('-', '>'),
283 PP_TOKEN_SUB_EQ = _2('-', '='),
284 PP_TOKEN_DEC = _2('-', '-'),
285 PP_TOKEN_ADD_EQ = _2('+', '='),
286 PP_TOKEN_INC = _2('+', '+'),
287 PP_TOKEN_AND_EQ = _2('&', '='),
288 PP_TOKEN_AND = _2('&', '&'),
289 PP_TOKEN_MUL_EQ = _2('*', '='),
290 PP_TOKEN_NOT_EQ = _2('!', '='),
291 PP_TOKEN_DIV_EQ = _2('/', '='),
292 PP_TOKEN_REM_EQ = _2('%', '='),
293 PP_TOKEN_LSHIFT_EQ = _3('<', '<', '='),
294 PP_TOKEN_LSHIFT = _2('<', '<'),
295 PP_TOKEN_LEQ = _2('<', '='),
296 PP_TOKEN_RSHIFT_EQ = _3('>', '>', '='),
297 PP_TOKEN_RSHIFT = _2('>', '>'),
298 PP_TOKEN_GEQ = _2('>', '='),
299 PP_TOKEN_EQ = _2('=', '='),
300 PP_TOKEN_XOR_EQ = _2('^', '='),
301 PP_TOKEN_OR_EQ = _2('|', '='),
302 PP_TOKEN_OR = _2('|', '|'),
303 PP_TOKEN_SHARPSHARP = _2('#', '#'),
304 #undef _2
305 #undef _3
306 } type;
307 uint32_t *id; /* string representation, if type is not enough */
308 struct pos pos;
309 };
310
311 static struct pp_token *pp_token_create(enum pp_token_type type, struct pos *pos)
312 {
313 struct pp_token *ppt;
314
315 ppt = xmalloc(sizeof(struct pp_token));
316 ppt->next = NULL;
317 ppt->type = type;
318 ppt->id = NULL;
319 ppt->pos = *pos;
320 return ppt;
321 }
322
323 /* [start, end) */
324 static void pp_token_add(struct pp_token *ppt, const uint32_t *c, unsigned int start, unsigned int end)
325 {
326 ppt->id = xmemdup(&c[start], (end - start) * sizeof(uint32_t));
327 }
328
329 static void pp_token_free(struct pp_token *ppt_head)
330 {
331 struct pp_token *ppt;
332
333 ppt = ppt_head;
334 while (ppt) {
335 struct pp_token *next;
336
337 next = ppt->next;
338 if (ppt->id)
339 free(ppt->id);
340 free(ppt);
341 ppt = next;
342 }
343 }
344
345 static void pp_token_print(struct pp_token *ppt)
346 {
347 printf("%u:%u:\t", ppt->pos.line, ppt->pos.column);
348 switch (ppt->type) {
349 case LS:
350 printf("\\n");
351 break;
352 case ' ':
353 printf("' '");
354 break;
355 case PP_TOKEN_IDENTIFIER:
356 printf("pp-identifier");
357 break;
358 case PP_TOKEN_NUMBER:
359 printf("pp-number");
360 break;
361 case PP_TOKEN_STRING:
362 printf("pp-string");
363 break;
364 case PP_TOKEN_CHAR:
365 printf("pp-char");
366 break;
367 case PP_TOKEN_DOTDOTDOT:
368 case PP_TOKEN_LSHIFT_EQ:
369 case PP_TOKEN_RSHIFT_EQ:
370 printf("%c%c%c", (ppt->type >> 16) & 0xff, (ppt->type >> 8) & 0xff, ppt->type & 0xff);
371 break;
372 case PP_TOKEN_DEREFERENCE:
373 case PP_TOKEN_SUB_EQ:
374 case PP_TOKEN_DEC:
375 case PP_TOKEN_ADD_EQ:
376 case PP_TOKEN_INC:
377 case PP_TOKEN_AND_EQ:
378 case PP_TOKEN_AND:
379 case PP_TOKEN_MUL_EQ:
380 case PP_TOKEN_NOT_EQ:
381 case PP_TOKEN_DIV_EQ:
382 case PP_TOKEN_REM_EQ:
383 case PP_TOKEN_LSHIFT:
384 case PP_TOKEN_LEQ:
385 case PP_TOKEN_RSHIFT:
386 case PP_TOKEN_GEQ:
387 case PP_TOKEN_EQ:
388 case PP_TOKEN_XOR_EQ:
389 case PP_TOKEN_OR_EQ:
390 case PP_TOKEN_OR:
391 case PP_TOKEN_SHARPSHARP:
392 printf("%c%c", (ppt->type >> 8) & 0xff, ppt->type & 0xff);
393 break;
394 default:
395 printf("%c", ppt->type);
396 }
397 putc('\n', stdout);
398 }
399
400 static int pp_nondigit(const uint32_t c)
401 {
402 return ('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_';
403 }
404
405 static int pp_octdigit(const uint32_t c)
406 {
407 return '0' <= c && c <= '7';
408 }
409
410 static int pp_digit(const uint32_t c)
411 {
412 return '0' <= c && c <= '9';
413 }
414
415 static int pp_hexdigit(const uint32_t c)
416 {
417 return pp_digit(c) || ('a' <= c && c <= 'f') || ('A' <= c && c <= 'F');
418 }
419
420 /* pp-identifier: ([a-zA-Z_]|\u[0-9a-fA-F]{4}|\U[0-9a-fA-F]{8})([a-zA-Z_0-9]|\u[0-9a-fA-F]{4}|\U[0-9a-fA-F]{8})* */
421 static unsigned int _pp_identifier_end(const uint32_t *c, unsigned int nr_c, unsigned int start)
422 {
423 unsigned int i;
424
425 i = start;
426 while (i < nr_c) {
427 if (pp_nondigit(c[i]) || pp_digit(c[i])) {
428 i++;
429 } else if (i + 5 < nr_c && c[i] == '\\' && c[i + 1] == 'u' &&
430 pp_hexdigit(c[i + 2]) && pp_hexdigit(c[i + 3]) && pp_hexdigit(c[i + 4]) && pp_hexdigit(c[i + 5])) {
431 i += 2 + 4;
432 } else if (i + 9 < nr_c && c[i] == '\\' && c[i + 1] == 'U' &&
433 pp_hexdigit(c[i + 2]) && pp_hexdigit(c[i + 3]) && pp_hexdigit(c[i + 4]) && pp_hexdigit(c[i + 5]) &&
434 pp_hexdigit(c[i + 6]) && pp_hexdigit(c[i + 7]) && pp_hexdigit(c[i + 8]) && pp_hexdigit(c[i + 9])) {
435 i += 2 + 4 + 4;
436 } else
437 return i;
438 }
439 return i;
440 }
441
442 /* pp-number: \.?[0-9]([eEpP][+-]|[a-zA-Z_.]|\u[0-9a-fA-F]{4}|\U[0-9a-fA-F]{8})* */
443 static unsigned int pp_number_end(const uint32_t *c, unsigned int nr_c, unsigned int start)
444 {
445 unsigned int i;
446
447 i = start + 1;
448 while (i < nr_c) {
449 if ((c[i] == 'e' || c[i] == 'E' || c[i] == 'p' || c[i] == 'P') &&
450 i + 1 < nr_c && (c[i + 1] == '+' || c[i + 1] == '-')) {
451 i += 2;
452 } else if (pp_digit(c[i]) || pp_nondigit(c[i]) || c[i] == '.') {
453 i++;
454 } else if (c[i] == '\\' && i + 5 < nr_c && c[i + 1] == 'u' &&
455 pp_hexdigit(c[i + 2]) && pp_hexdigit(c[i + 3]) && pp_hexdigit(c[i + 4]) && pp_hexdigit(c[i + 5])) {
456 i += 2 + 4;
457 } else if (c[i] == '\\' && i + 9 < nr_c && c[i + 1] == 'U' &&
458 pp_hexdigit(c[i + 2]) && pp_hexdigit(c[i + 3]) && pp_hexdigit(c[i + 4]) && pp_hexdigit(c[i + 5]) &&
459 pp_hexdigit(c[i + 6]) && pp_hexdigit(c[i + 7]) && pp_hexdigit(c[i + 8]) && pp_hexdigit(c[i + 9])) {
460 i += 2 + 4 + 4;
461 } else
462 return i;
463 }
464 return i;
465 }
466
467 static unsigned int c_comment_end(const uint32_t *c, unsigned int nr_c, unsigned int start)
468 {
469 unsigned int i;
470
471 i = start + 2;
472 while (i + 1 < nr_c) {
473 if (c[i] == '*' && c[i + 1] == '/')
474 return i + 2;
475 i++;
476 }
477 return nr_c;
478 }
479
480 static unsigned int cpp_comment_end(const uint32_t *c, unsigned int nr_c, unsigned int start)
481 {
482 unsigned int i;
483
484 i = start + 2;
485 while (i < nr_c && c[i] != LS)
486 i++;
487 return i;
488 }
489
490 static unsigned int escape_sequence_end(const uint32_t *c, unsigned int nr_c, unsigned int start, struct pos *_pos)
491 {
492 struct pos *pos = &_pos[start];
493 unsigned int i;
494
495 i = start + 1;
496 if (i >= nr_c)
497 error_exit(pos, "incomplete escape sequence");
498 switch (c[i]) {
499 case '\'':case '"':case '?':case '\\':
500 case 'a':case 'b':case 'f':case 'n':case 'r':case 't':case 'v':
501 return i + 1;
502 case '0':case '1':case '2':case '3':case '4':case '6':case '7':
503 if (i + 2 < nr_c && pp_octdigit(c[i + 1]) && pp_octdigit(c[i + 2]))
504 return i + 3;
505 if (i + 1 < nr_c && pp_octdigit(c[i + 1]))
506 return i + 2;
507 return i + 1;
508 case 'x':
509 i++;
510 while (i < nr_c && pp_hexdigit(c[i]))
511 i++;
512 if (i == start + 2)
513 error_exit(pos, "invalid hexadecimal escape sequence");
514 return i;
515 case 'u':
516 if (i + 4 < nr_c &&
517 pp_hexdigit(c[i + 1]) && pp_hexdigit(c[i + 2]) && pp_hexdigit(c[i + 3]) && pp_hexdigit(c[i + 4]))
518 return i + 5;
519 error_exit(pos, "invalid universal character name");
520 case 'U':
521 if (i + 8 < nr_c &&
522 pp_hexdigit(c[i + 1]) && pp_hexdigit(c[i + 2]) && pp_hexdigit(c[i + 3]) && pp_hexdigit(c[i + 4]) &&
523 pp_hexdigit(c[i + 5]) && pp_hexdigit(c[i + 6]) && pp_hexdigit(c[i + 7]) && pp_hexdigit(c[i + 8]))
524 return i + 9;
525 error_exit(pos, "invalid universal character name");
526 default:
527 error_exit(pos, "invalid escape sequence");
528 }
529 }
530
531 static unsigned int pp_string_end(const uint32_t *c, unsigned int nr_c, unsigned int start, struct pos *_pos)
532 {
533 struct pos *pos = &_pos[start];
534 unsigned int i;
535
536 i = start + 1;
537 while (i < nr_c && c[i] != '"') {
538 switch (c[i]) {
539 case LS:
540 goto incomplete;
541 case '\\':
542 i = escape_sequence_end(c, nr_c, i, _pos);
543 break;
544 default:
545 i++;
546 }
547 }
548 if (i >= nr_c)
549 goto incomplete;
550 return i + 1;
551
552 incomplete:
553 error_exit(pos, "incomplete string literal");
554 }
555
556 static unsigned int pp_char_end(const uint32_t *c, unsigned int nr_c, unsigned int start, struct pos *_pos)
557 {
558 struct pos *pos = &_pos[start];
559 unsigned int i;
560
561 i = start + 1;
562 while (i < nr_c && c[i] != '\'') {
563 switch (c[i]) {
564 case LS:
565 goto incomplete;
566 case '\\':
567 i = escape_sequence_end(c, nr_c, i, _pos);
568 break;
569 default:
570 i++;
571 }
572 }
573 if (i >= nr_c)
574 goto incomplete;
575 if (i == start + 1)
576 goto empty;
577 return i + 1;
578
579 incomplete:
580 error_exit(pos, "incomplete character constant");
581 empty:
582 error_exit(pos, "empty character constant");
583 }
584
585 static struct pp_token *pp_tokenize(const uint32_t *c, unsigned int nr_c, struct pos *_pos)
586 {
587 struct pp_token *ppt_head, *ppt_tail;
588 unsigned int i;
589
590 ppt_head = NULL;
591 i = 0;
592 while (i < nr_c) {
593 struct pos *pos = &_pos[i];
594 struct pp_token *ppt;
595
596 switch (c[i]) {
597 unsigned int j;
598
599 case '\t':
600 case ' ':
601 ppt = pp_token_create(' ', pos);
602 i++;
603 break;
604 case LS:
605 ppt = pp_token_create(LS, pos);
606 i++;
607 break;
608 case '[':case ']':
609 case '(':case ')':
610 case '{':case '}':
611 case '~':
612 case '?':
613 case ':':
614 case ';':
615 case ',':
616 pp_token_simple:
617 ppt = pp_token_create(c[i], pos);
618 i++;
619 break;
620 case 'a':case 'b':case 'c':case 'd':case 'e':case 'f':case 'g':
621 case 'h':case 'i':case 'j':case 'k':case 'l':case 'm':case 'n':
622 case 'o':case 'p':case 'q':case 'r':case 's':case 't':case 'u':
623 case 'v':case 'w':case 'x':case 'y':case 'z':
624 case 'A':case 'B':case 'C':case 'D':case 'E':case 'F':case 'G':
625 case 'H':case 'I':case 'J':case 'K':case 'L':case 'M':case 'N':
626 case 'O':case 'P':case 'Q':case 'R':case 'S':case 'T':case 'U':
627 case 'V':case 'W':case 'X':case 'Y':case 'Z':
628 case '_':
629 ppt = pp_token_create(PP_TOKEN_IDENTIFIER, pos);
630 j = _pp_identifier_end(c, nr_c, i + 1);
631 pp_token_add(ppt, c, i, j);
632 i = j;
633 break;
634 case '\\':
635 if (i + 5 < nr_c && c[i + 1] == 'u' &&
636 pp_hexdigit(c[i + 2]) && pp_hexdigit(c[i + 3]) && pp_hexdigit(c[i + 4]) && pp_hexdigit(c[i + 5])) {
637 ppt = pp_token_create(PP_TOKEN_IDENTIFIER, pos);
638 j = _pp_identifier_end(c, nr_c, i + 2 + 4);
639 pp_token_add(ppt, c, i, j);
640 i = j;
641 } else if (i + 9 < nr_c && c[i + 1] == 'U' &&
642 pp_hexdigit(c[i + 2]) && pp_hexdigit(c[i + 3]) && pp_hexdigit(c[i + 4]) && pp_hexdigit(c[i + 5]) &&
643 pp_hexdigit(c[i + 6]) && pp_hexdigit(c[i + 7]) && pp_hexdigit(c[i + 8]) && pp_hexdigit(c[i + 9])) {
644 ppt = pp_token_create(PP_TOKEN_IDENTIFIER, pos);
645 j = _pp_identifier_end(c, nr_c, i + 2 + 4 + 4);
646 pp_token_add(ppt, c, i, j);
647 i = j;
648 } else
649 error_exit(pos, "unknown character %08"PRIx32, c[i]);
650 break;
651 case '0':case '1':case '2':case '3':case '4':
652 case '5':case '6':case '7':case '8':case '9':
653 ppt = pp_token_create(PP_TOKEN_NUMBER, pos);
654 j = pp_number_end(c, nr_c, i);
655 pp_token_add(ppt, c, i, j);
656 i = j;
657 break;
658 case '.':
659 if (i + 2 < nr_c && c[i + 1] == '.' && c[i + 2] == '.') {
660 ppt = pp_token_create(PP_TOKEN_DOTDOTDOT, pos);
661 i += 3;
662 } else if (i + 1 < nr_c && pp_digit(c[i + 1])) {
663 ppt = pp_token_create(PP_TOKEN_NUMBER, pos);
664 j = pp_number_end(c, nr_c, i + 1);
665 pp_token_add(ppt, c, i, j);
666 i = j;
667 } else
668 goto pp_token_simple;
669 break;
670 case '"':
671 ppt = pp_token_create(PP_TOKEN_STRING, pos);
672 j = pp_string_end(c, nr_c, i, _pos);
673 pp_token_add(ppt, c, i + 1, j - 1);
674 i = j;
675 break;
676 case '\'':
677 ppt = pp_token_create(PP_TOKEN_CHAR, pos);
678 j = pp_char_end(c, nr_c, i, _pos);
679 pp_token_add(ppt, c, i + 1, j - 1);
680 i = j;
681 break;
682 case '/':
683 if (i + 1 < nr_c && c[i + 1] == '*') {
684 ppt = pp_token_create(' ', pos);
685 i = c_comment_end(c, nr_c, i);
686 } else if (i + 1 < nr_c && c[i + 1] == '/') {
687 warning(pos, "C++ comment");
688 ppt = pp_token_create(' ', pos);
689 i = cpp_comment_end(c, nr_c, i);
690 } else if (i + 1 < nr_c && c[i + 1] == '=') {
691 ppt = pp_token_create((c[i] << 8) | c[i + 1], pos);
692 i += 2;
693 } else
694 goto pp_token_simple;
695 break;
696 case '-':
697 if (i + 1 < nr_c && (c[i + 1] == '>' || c[i + 1] == '=' || c[i + 1] == '-')) {
698 ppt = pp_token_create((c[i] << 8) | c[i + 1], pos);
699 i += 2;
700 } else
701 goto pp_token_simple;
702 break;
703 case '+':
704 case '&':
705 case '|':
706 if (i + 1 < nr_c && (c[i + 1] == '=' || c[i + 1] == c[i])) {
707 ppt = pp_token_create((c[i] << 8) | c[i + 1], pos);
708 i += 2;
709 } else
710 goto pp_token_simple;
711 break;
712 case '*':
713 case '!':
714 case '%':
715 case '=':
716 case '^':
717 if (i + 1 < nr_c && c[i + 1] == '=') {
718 ppt = pp_token_create((c[i] << 8) | c[i + 1], pos);
719 i += 2;
720 } else
721 goto pp_token_simple;
722 break;
723 case '<':
724 case '>':
725 if (i + 2 < nr_c && c[i + 1] == c[i] && c[i + 2] == '=') {
726 ppt = pp_token_create((c[i] << 16) | (c[i + 1] << 8) | c[i + 2], pos);
727 i += 3;
728 } else if (i + 1 < nr_c && (c[i + 1] == c[i] || c[i + 1] == '=')) {
729 ppt = pp_token_create((c[i] << 8) | c[i + 1], pos);
730 i += 2;
731 } else
732 goto pp_token_simple;
733 break;
734 case '#':
735 if (i + 1 < nr_c && c[i + 1] == '#') {
736 ppt = pp_token_create((c[i] << 8) | c[i + 1], pos);
737 i += 2;
738 } else
739 goto pp_token_simple;
740 break;
741 default:
742 error_exit(pos, "unknown character %08"PRIx32, c[i]);
743 }
744
745 if (!ppt_head)
746 ppt_head = ppt;
747 else
748 ppt_tail->next = ppt;
749 ppt_tail = ppt;
750 }
751 return ppt_head;
752 }
753
754 int main(int argc, char *argv[])
755 {
756 int fd;
757 struct stat st;
758 unsigned int st_size;
759 void *buf;
760 uint8_t *_c;
761 unsigned int _nr_c;
762 uint32_t *c;
763 unsigned int nr_c;
764 struct pos *pos;
765 struct pp_token *ppt_head;
766
767 if (argc < 2)
768 return EXIT_FAILURE;
769
770 fd = open(argv[1], O_RDONLY);
771 if (fd == -1)
772 perror_exit("open %s", argv[1]);
773 if (fstat(fd, &st) == -1)
774 perror_exit("fstat %s", argv[1]);
775 if (st.st_size < 0)
776 _error_exit("%s: negative st_size %"PRIdMAX, argv[1], (intmax_t)st.st_size);
777 st_size = (unsigned int)(uintmax_t)(intmax_t)st.st_size;
778 if ((uintmax_t)(intmax_t)st.st_size != (uintmax_t)st_size)
779 _error_exit("%s: too big st_size %"PRIdMAX, argv[1], (intmax_t)st.st_size);
780
781 buf = xmalloc(st_size);
782 xread(fd, buf, st_size);
783 close(fd);
784
785 _c = buf;
786 _nr_c = st_size;
787 /* Skip UTF-8 "BOM" if any. */
788 if (st_size >= 3 && _c[0] == 0xef && _c[1] == 0xbb && _c[2] == 0xbf) {
789 _c += 3;
790 _nr_c -= 3;
791 }
792 convert_from_utf8(_c, _nr_c, &c, &nr_c);
793 free(buf);
794
795 fix_newline(c, &nr_c);
796 pos = line_column(c, nr_c);
797 warn_trigraph(c, nr_c, pos);
798 delete_backslash_newline(c, &nr_c, pos);
799
800 ppt_head = pp_tokenize(c, nr_c, pos);
801 free(c);
802 free(pos);
803
804 {
805 struct pp_token *ppt;
806
807 for (ppt = ppt_head; ppt; ppt = ppt->next)
808 pp_token_print(ppt);
809 }
810
811 pp_token_free(ppt_head);
812
813 return EXIT_SUCCESS;
814 }
Alexey's C compiler