![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to app.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple XNU] / GNUtools / cctools / as|
Return to app.c CVS log | Up to [Apple XNU] / GNUtools / cctools / as |
1.1 root 1: /* This is the Assembler Pre-Processor
2: Copyright (C) 1987 Free Software Foundation, Inc.
3:
4: This file is part of GAS, the GNU Assembler.
5:
6: GAS is free software; you can redistribute it and/or modify
7: it under the terms of the GNU General Public License as published by
8: the Free Software Foundation; either version 1, or (at your option)
9: any later version.
10:
11: GAS is distributed in the hope that it will be useful,
12: but WITHOUT ANY WARRANTY; without even the implied warranty of
13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14: GNU General Public License for more details.
15:
16: You should have received a copy of the GNU General Public License
17: along with GAS; see the file COPYING. If not, write to
18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
19:
20: /* App, the assembler pre-processor. This pre-processor strips out excess
21: spaces, turns single-quoted characters into a decimal constant, and turns
22: # <number> <filename> <garbage> into a .line <number>;.file <filename> pair.
23: This needs better error-handling.
24: */
25: #include <stdio.h>
26: #include <string.h>
27: #include "as.h"
28: #include "md.h"
29: #include "app.h"
30: #include "messages.h"
31:
32: FILE *scrub_file = NULL;
33: char *scrub_string = NULL;
34: char *scrub_last_string = NULL;
35:
36: #ifdef NeXT /* .include feature */
37: /* These are moved out of do_scrub() so save_scrub_context() can save them */
38: static state;
39: static old_state;
40: static char *out_string;
41: static char out_buf[20];
42: static add_newlines = 0;
43: #endif /* NeXT .include feature */
44:
45: static char lex [256];
46: static char symbol_chars[] =
47: "$._ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789";
48:
49: #define LEX_IS_SYMBOL_COMPONENT (1)
50: #define LEX_IS_WHITESPACE (2)
51: #define LEX_IS_LINE_SEPERATOR (4)
52: #define LEX_IS_COMMENT_START (8) /* JF added these two */
53: #define LEX_IS_LINE_COMMENT_START (16)
54: #define IS_SYMBOL_COMPONENT(c) (lex [c] & LEX_IS_SYMBOL_COMPONENT)
55: #define IS_WHITESPACE(c) (lex [c] & LEX_IS_WHITESPACE)
56: #define IS_LINE_SEPERATOR(c) (lex [c] & LEX_IS_LINE_SEPERATOR)
57: #define IS_COMMENT(c) (lex [c] & LEX_IS_COMMENT_START)
58: #define IS_LINE_COMMENT(c) (lex [c] & LEX_IS_LINE_COMMENT_START)
59:
60: void
61: do_scrub_begin(
62: void)
63: {
64: char *p;
65: const char *q;
66:
67: memset(lex, '\0', sizeof(lex)); /* Trust NOBODY! */
68: lex [' '] |= LEX_IS_WHITESPACE;
69: lex ['\t'] |= LEX_IS_WHITESPACE;
70: for (p =symbol_chars;*p;++p)
71: lex [(int)*p] |= LEX_IS_SYMBOL_COMPONENT;
72: lex ['\n'] |= LEX_IS_LINE_SEPERATOR;
73: #ifndef DONTDEF
74: #ifdef NeXT
75: /*
76: * This DOES not cause ':' to be a LINE SEPERATOR but does make the
77: * second if logic after flushchar: in do_scrub_next_char() to handle
78: * "foo :" and strip the blanks. This is the way has always been and
79: * must be this way to work.
80: */
81: #endif /* NeXT */
82: lex [':'] |= LEX_IS_LINE_SEPERATOR;
83: #endif /* !defined(DONTDEF) */
84:
85: #if defined(M88K) || defined(M98K) || defined(HPPA)
86: lex ['@'] |= LEX_IS_LINE_SEPERATOR;
87: #else
88: lex [';'] |= LEX_IS_LINE_SEPERATOR;
89: #endif
90: for (q=md_comment_chars;*q;q++)
91: lex[(int)*q] |= LEX_IS_COMMENT_START;
92: for (q=md_line_comment_chars;*q;q++)
93: lex[(int)*q] |= LEX_IS_LINE_COMMENT_START;
94: }
95:
96: int
97: scrub_from_file(
98: void)
99: {
100: return getc(scrub_file);
101: }
102:
103: void
104: scrub_to_file(
105: int ch)
106: {
107: ungetc(ch, scrub_file);
108: }
109:
110: int
111: scrub_from_string(
112: void)
113: {
114: return scrub_string == scrub_last_string ? EOF : *scrub_string++;
115: }
116:
117: void
118: scrub_to_string(
119: int ch)
120: {
121: *--scrub_string = ch;
122: }
123:
124: int
125: do_scrub_next_char(
126: int (*get)(void),
127: void (*unget)(int ch))
128: /* FILE *fp; */
129: {
130: /* State 0: beginning of normal line
131: 1: After first whitespace on normal line (flush more white)
132: 2: After first non-white on normal line (keep 1white)
133: 3: after second white on normal line (flush white)
134: 4: after putting out a .line, put out digits
135: 5: parsing a string, then go to old-state
136: 6: putting out \ escape in a "d string.
137: 7: After putting out a .file, put out string.
138: 8: After putting out a .file string, flush until newline.
139: -1: output string in out_string and go to the state in old_state
140: -2: flush text until a '*' '/' is seen, then go to state old_state
141: */
142:
143: #ifndef NeXT /* .include feature */
144: static state;
145: static old_state;
146: static char *out_string;
147: static char out_buf[20];
148: static add_newlines = 0;
149: #endif /* NeXT .include feature */
150: int ch;
151:
152: if(state==-1) {
153: ch= *out_string++;
154: if(*out_string==0) {
155: state=old_state;
156: old_state=3;
157: }
158: return ch;
159: }
160: if(state==-2) {
161: for(;;) {
162: do ch=(*get)();
163: while(ch!=EOF && ch!='\n' && ch!='*');
164: if(ch=='\n' || ch==EOF)
165: return ch;
166: ch=(*get)();
167: if(ch==EOF || ch=='/')
168: break;
169: (*unget)(ch);
170: }
171: state=old_state;
172: return ' ';
173: }
174: if(state==4) {
175: ch=(*get)();
176: if(ch==EOF || (ch>='0' && ch<='9'))
177: return ch;
178: else {
179: while(ch!=EOF && IS_WHITESPACE(ch))
180: ch=(*get)();
181: if(ch=='"') {
182: (*unget)(ch);
183: #if defined(M88K) || defined(M98K) || defined(HPPA)
184: out_string="@ .file ";
185: #else
186: out_string="; .file ";
187: #endif
188: old_state=7;
189: state= -1;
190: return *out_string++;
191: } else {
192: while(ch!=EOF && ch!='\n')
193: ch=(*get)();
194: #ifdef NeXT
195: /* bug fix for bug #8918, which was when
196: * a full line comment line this:
197: * # 40 MP1 = M + 1
198: * got confused with a cpp output like:
199: * # 1 "hello.c" 1
200: */
201: state = 0;
202: #endif /* NeXT */
203: return ch;
204: }
205: }
206: }
207: if(state==5) {
208: ch=(*get)();
209: if(ch=='"') {
210: state=old_state;
211: return '"';
212: } else if(ch=='\\') {
213: state=6;
214: return ch;
215: } else if(ch==EOF) {
216: as_warn("End of file in string: inserted '\"'");
217: state=old_state;
218: (*unget)('\n');
219: return '"';
220: } else {
221: return ch;
222: }
223: }
224: if(state==6) {
225: state=5;
226: ch=(*get)();
227: switch(ch) {
228: /* This is neet. Turn "string
229: more string" into "string\n more string"
230: */
231: case '\n':
232: (*unget)('n');
233: add_newlines++;
234: return '\\';
235:
236: case '"':
237: case '\\':
238: case 'b':
239: case 'f':
240: case 'n':
241: case 'r':
242: case 't':
243: case '0':
244: case '1':
245: case '2':
246: case '3':
247: case '4':
248: case '5':
249: case '6':
250: case '7':
251: break;
252: default:
253: as_warn("Unknown escape '\\%c' in string: Ignored",ch);
254: break;
255:
256: case EOF:
257: as_warn("End of file in string: '\"' inserted");
258: return '"';
259: }
260: return ch;
261: }
262:
263: if(state==7) {
264: ch=(*get)();
265: state=5;
266: old_state=8;
267: return ch;
268: }
269:
270: if(state==8) {
271: do ch= (*get)();
272: while(ch!='\n');
273: state=0;
274: return ch;
275: }
276:
277: flushchar:
278: ch=(*get)();
279: switch(ch) {
280: case ' ':
281: case '\t':
282: do ch=(*get)();
283: while(ch!=EOF && IS_WHITESPACE(ch));
284: if(ch==EOF)
285: return ch;
286: if(IS_COMMENT(ch) || (state==0 && IS_LINE_COMMENT(ch)) || ch=='/' || IS_LINE_SEPERATOR(ch)) {
287: (*unget)(ch);
288: goto flushchar;
289: }
290: (*unget)(ch);
291: if(state==0 || state==2) {
292: state++;
293: return ' ';
294: } else goto flushchar;
295:
296: case '/':
297: ch=(*get)();
298: if(ch=='*') {
299: for(;;) {
300: do {
301: ch=(*get)();
302: if(ch=='\n')
303: add_newlines++;
304: } while(ch!=EOF && ch!='*');
305: ch=(*get)();
306: if(ch==EOF || ch=='/')
307: break;
308: (*unget)(ch);
309: }
310: if(ch==EOF)
311: as_warn("End of file in '/' '*' string: */ inserted");
312:
313: (*unget)(' ');
314: goto flushchar;
315: } else {
316: #if defined(I860) || defined(M88K) || defined(M98K) || defined(I386) || \
317: defined(HPPA) || defined (SPARC)
318: if (ch == '/') {
319: do {
320: ch=(*get)();
321: } while (ch != EOF && (ch != '\n'));
322: if (ch == EOF)
323: as_warn("End of file before newline in // comment");
324: if ( ch == '\n' ) /* Push NL back so we can complete state */
325: (*unget)(ch);
326: goto flushchar;
327: }
328: #endif
329: if(IS_COMMENT('/') || (state==0 && IS_LINE_COMMENT('/'))) {
330: (*unget)(ch);
331: ch='/';
332: goto deal_misc;
333: }
334: if(ch!=EOF)
335: (*unget)(ch);
336: return '/';
337: }
338: break;
339:
340: case '"':
341: old_state=state;
342: state=5;
343: return '"';
344: break;
345:
346: case '\'':
347: ch=(*get)();
348: if(ch==EOF) {
349: as_warn("End-of-file after a ': \\000 inserted");
350: ch=0;
351: }
352: sprintf(out_buf,"(%d)",ch&0xff);
353: old_state=state;
354: state= -1;
355: out_string=out_buf;
356: return *out_string++;
357:
358: case ':':
359: if(state!=3)
360: state=0;
361: return ch;
362:
363: case '\n':
364: if(add_newlines) {
365: --add_newlines;
366: (*unget)(ch);
367: }
368: /* Fall through. */
369: #if defined(M88K) || defined(M98K) || defined(HPPA)
370: case '@':
371: #else
372: case ';':
373: #endif
374: state=0;
375: return ch;
376:
377: default:
378: deal_misc:
379: if(state==0 && IS_LINE_COMMENT(ch)) {
380: do ch=(*get)();
381: while(ch!=EOF && IS_WHITESPACE(ch));
382: if(ch==EOF) {
383: as_warn("EOF in comment: Newline inserted");
384: return '\n';
385: }
386: if(ch<'0' || ch>'9') {
387: do ch=(*get)();
388: while(ch!=EOF && ch!='\n');
389: if(ch==EOF)
390: as_warn("EOF in Comment: Newline inserted");
391: state=0;
392: return '\n';
393: }
394: (*unget)(ch);
395: old_state=4;
396: state= -1;
397: out_string=".line ";
398: return *out_string++;
399:
400: } else if(IS_COMMENT(ch)) {
401: do ch=(*get)();
402: while(ch!=EOF && ch!='\n');
403: if(ch==EOF)
404: as_warn("EOF in comment: Newline inserted");
405: state=0;
406: return '\n';
407:
408: } else if(state==0) {
409: state=2;
410: return ch;
411: } else if(state==1) {
412: state=2;
413: return ch;
414: } else {
415: return ch;
416:
417: }
418: case EOF:
419: if(state==0)
420: return ch;
421: as_warn("End-of-File not at end of a line");
422: }
423: return -1;
424: }
425:
426: #ifdef NeXT /* .include feature */
427: void
428: save_scrub_context(
429: scrub_context_data *save_buffer_ptr)
430: {
431: save_buffer_ptr->last_scrub_file = scrub_file;
432: save_buffer_ptr->last_state = state;
433: save_buffer_ptr->last_old_state = old_state;
434: save_buffer_ptr->last_out_string = out_string;
435: memcpy(save_buffer_ptr->last_out_buf, out_buf, sizeof(out_buf));
436: save_buffer_ptr->last_add_newlines = add_newlines;
437:
438: state = 0;
439: old_state = 0;
440: out_string = NULL;
441: memset(out_buf, '\0', sizeof(out_buf));
442: add_newlines = 0;
443: }
444:
445: void
446: restore_scrub_context(
447: scrub_context_data *save_buffer_ptr)
448: {
449: scrub_file = save_buffer_ptr->last_scrub_file;
450: state = save_buffer_ptr->last_state;
451: old_state = save_buffer_ptr->last_old_state;
452: out_string = save_buffer_ptr->last_out_string;
453: memcpy(out_buf, save_buffer_ptr->last_out_buf, sizeof(out_buf));
454: add_newlines = save_buffer_ptr->last_add_newlines;
455: }
456: #endif /* NeXT .include feature */
457:
458: #ifdef TEST
459:
460: const char md_comment_chars[] = "|";
461: const char md_line_comment_chars[] = "#";
462:
463: int
464: get(
465: void)
466: {
467: return(getc(stdin));
468: }
469:
470: void
471: unget(
472: int ch)
473: {
474: ungetc(ch, stdin);
475: }
476:
477: void
478: main(
479: int argc,
480: char *argv[],
481: char *envp[])
482: {
483: int ch;
484:
485: while((ch = do_scrub_next_char(get, unget)) != EOF)
486: putc(ch, stdout);
487: }
488:
489: void
490: as_warn(
491: const char *format,
492: ...)
493: {
494: va_list ap;
495:
496: va_start(ap, format);
497: vfprintf(stderr, format, ap);
498: fprintf(stderr, "\n");
499: va_end(ap);
500: }
501: #endif /* TEST */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.