![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to lexi.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / pgrm / indent|
Return to lexi.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / pgrm / indent |
1.1 root 1: /*
2: * Copyright (c) 1985 Sun Microsystems, Inc.
3: * Copyright (c) 1980 The Regents of the University of California.
4: * Copyright (c) 1976 Board of Trustees of the University of Illinois.
5: * All rights reserved.
6: *
7: * Redistribution and use in source and binary forms are permitted
8: * provided that: (1) source distributions retain this entire copyright
9: * notice and comment, and (2) distributions including binaries display
10: * the following acknowledgement: ``This product includes software
11: * developed by the University of California, Berkeley and its contributors''
12: * in the documentation or other materials provided with the distribution
13: * and in all advertising materials mentioning features or use of this
14: * software. Neither the name of the University nor the names of its
15: * contributors may be used to endorse or promote products derived
16: * from this software without specific prior written permission.
17: * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
18: * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
19: * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
20: */
21:
22: #ifndef lint
23: static char sccsid[] = "@(#)lexi.c 5.15 (Berkeley) 6/1/90";
24: #endif /* not lint */
25:
26: /*
27: * Here we have the token scanner for indent. It scans off one token and puts
28: * it in the global variable "token". It returns a code, indicating the type
29: * of token scanned.
30: */
31:
32: #include "indent_globs.h"
33: #include "indent_codes.h"
34: #include <ctype.h>
35:
36: #define alphanum 1
37: #define opchar 3
38:
39: struct templ {
40: char *rwd;
41: int rwcode;
42: };
43:
44: struct templ specials[100] =
45: {
46: "switch", 1,
47: "case", 2,
48: "break", 0,
49: "struct", 3,
50: "union", 3,
51: "enum", 3,
52: "default", 2,
53: "int", 4,
54: "char", 4,
55: "float", 4,
56: "double", 4,
57: "long", 4,
58: "short", 4,
59: "typdef", 4,
60: "unsigned", 4,
61: "register", 4,
62: "static", 4,
63: "global", 4,
64: "extern", 4,
65: "void", 4,
66: "goto", 0,
67: "return", 0,
68: "if", 5,
69: "while", 5,
70: "for", 5,
71: "else", 6,
72: "do", 6,
73: "sizeof", 7,
74: 0, 0
75: };
76:
77: char chartype[128] =
78: { /* this is used to facilitate the decision of
79: * what type (alphanumeric, operator) each
80: * character is */
81: 0, 0, 0, 0, 0, 0, 0, 0,
82: 0, 0, 0, 0, 0, 0, 0, 0,
83: 0, 0, 0, 0, 0, 0, 0, 0,
84: 0, 0, 0, 0, 0, 0, 0, 0,
85: 0, 3, 0, 0, 1, 3, 3, 0,
86: 0, 0, 3, 3, 0, 3, 0, 3,
87: 1, 1, 1, 1, 1, 1, 1, 1,
88: 1, 1, 0, 0, 3, 3, 3, 3,
89: 0, 1, 1, 1, 1, 1, 1, 1,
90: 1, 1, 1, 1, 1, 1, 1, 1,
91: 1, 1, 1, 1, 1, 1, 1, 1,
92: 1, 1, 1, 0, 0, 0, 3, 1,
93: 0, 1, 1, 1, 1, 1, 1, 1,
94: 1, 1, 1, 1, 1, 1, 1, 1,
95: 1, 1, 1, 1, 1, 1, 1, 1,
96: 1, 1, 1, 0, 3, 0, 3, 0
97: };
98:
99:
100:
101:
102: int
103: lexi()
104: {
105: int unary_delim; /* this is set to 1 if the current token
106: *
107: * forces a following operator to be unary */
108: static int last_code; /* the last token type returned */
109: static int l_struct; /* set to 1 if the last token was 'struct' */
110: int code; /* internal code to be returned */
111: char qchar; /* the delimiter character for a string */
112:
113: e_token = s_token; /* point to start of place to save token */
114: unary_delim = false;
115: ps.col_1 = ps.last_nl; /* tell world that this token started in
116: * column 1 iff the last thing scanned was nl */
117: ps.last_nl = false;
118:
119: while (*buf_ptr == ' ' || *buf_ptr == '\t') { /* get rid of blanks */
120: ps.col_1 = false; /* leading blanks imply token is not in column
121: * 1 */
122: if (++buf_ptr >= buf_end)
123: fill_buffer();
124: }
125:
126: /* Scan an alphanumeric token */
127: if (chartype[*buf_ptr] == alphanum || buf_ptr[0] == '.' && isdigit(buf_ptr[1])) {
128: /*
129: * we have a character or number
130: */
131: register char *j; /* used for searching thru list of
132: *
133: * reserved words */
134: register struct templ *p;
135:
136: if (isdigit(*buf_ptr) || buf_ptr[0] == '.' && isdigit(buf_ptr[1])) {
137: int seendot = 0,
138: seenexp = 0;
139: if (*buf_ptr == '0' &&
140: (buf_ptr[1] == 'x' || buf_ptr[1] == 'X')) {
141: *e_token++ = *buf_ptr++;
142: *e_token++ = *buf_ptr++;
143: while (isxdigit(*buf_ptr)) {
144: CHECK_SIZE_TOKEN;
145: *e_token++ = *buf_ptr++;
146: }
147: }
148: else
149: while (1) {
150: if (*buf_ptr == '.')
151: if (seendot)
152: break;
153: else
154: seendot++;
155: CHECK_SIZE_TOKEN;
156: *e_token++ = *buf_ptr++;
157: if (!isdigit(*buf_ptr) && *buf_ptr != '.')
158: if ((*buf_ptr != 'E' && *buf_ptr != 'e') || seenexp)
159: break;
160: else {
161: seenexp++;
162: seendot++;
163: CHECK_SIZE_TOKEN;
164: *e_token++ = *buf_ptr++;
165: if (*buf_ptr == '+' || *buf_ptr == '-')
166: *e_token++ = *buf_ptr++;
167: }
168: }
169: if (*buf_ptr == 'L' || *buf_ptr == 'l')
170: *e_token++ = *buf_ptr++;
171: }
172: else
173: while (chartype[*buf_ptr] == alphanum) { /* copy it over */
174: CHECK_SIZE_TOKEN;
175: *e_token++ = *buf_ptr++;
176: if (buf_ptr >= buf_end)
177: fill_buffer();
178: }
179: *e_token++ = '\0';
180: while (*buf_ptr == ' ' || *buf_ptr == '\t') { /* get rid of blanks */
181: if (++buf_ptr >= buf_end)
182: fill_buffer();
183: }
184: ps.its_a_keyword = false;
185: ps.sizeof_keyword = false;
186: if (l_struct) { /* if last token was 'struct', then this token
187: * should be treated as a declaration */
188: l_struct = false;
189: last_code = ident;
190: ps.last_u_d = true;
191: return (decl);
192: }
193: ps.last_u_d = false; /* Operator after indentifier is binary */
194: last_code = ident; /* Remember that this is the code we will
195: * return */
196:
197: /*
198: * This loop will check if the token is a keyword.
199: */
200: for (p = specials; (j = p->rwd) != 0; p++) {
201: register char *p = s_token; /* point at scanned token */
202: if (*j++ != *p++ || *j++ != *p++)
203: continue; /* This test depends on the fact that
204: * identifiers are always at least 1 character
205: * long (ie. the first two bytes of the
206: * identifier are always meaningful) */
207: if (p[-1] == 0)
208: break; /* If its a one-character identifier */
209: while (*p++ == *j)
210: if (*j++ == 0)
211: goto found_keyword; /* I wish that C had a multi-level
212: * break... */
213: }
214: if (p->rwd) { /* we have a keyword */
215: found_keyword:
216: ps.its_a_keyword = true;
217: ps.last_u_d = true;
218: switch (p->rwcode) {
219: case 1: /* it is a switch */
220: return (swstmt);
221: case 2: /* a case or default */
222: return (casestmt);
223:
224: case 3: /* a "struct" */
225: if (ps.p_l_follow)
226: break; /* inside parens: cast */
227: l_struct = true;
228:
229: /*
230: * Next time around, we will want to know that we have had a
231: * 'struct'
232: */
233: case 4: /* one of the declaration keywords */
234: if (ps.p_l_follow) {
235: ps.cast_mask |= 1 << ps.p_l_follow;
236: break; /* inside parens: cast */
237: }
238: last_code = decl;
239: return (decl);
240:
241: case 5: /* if, while, for */
242: return (sp_paren);
243:
244: case 6: /* do, else */
245: return (sp_nparen);
246:
247: case 7:
248: ps.sizeof_keyword = true;
249: default: /* all others are treated like any other
250: * identifier */
251: return (ident);
252: } /* end of switch */
253: } /* end of if (found_it) */
254: if (*buf_ptr == '(' && ps.tos <= 1 && ps.ind_level == 0) {
255: register char *tp = buf_ptr;
256: while (tp < buf_end)
257: if (*tp++ == ')' && (*tp == ';' || *tp == ','))
258: goto not_proc;
259: strncpy(ps.procname, token, sizeof ps.procname - 1);
260: ps.in_parameter_declaration = 1;
261: rparen_count = 1;
262: not_proc:;
263: }
264: /*
265: * The following hack attempts to guess whether or not the current
266: * token is in fact a declaration keyword -- one that has been
267: * typedefd
268: */
269: if (((*buf_ptr == '*' && buf_ptr[1] != '=') || isalpha(*buf_ptr) || *buf_ptr == '_')
270: && !ps.p_l_follow
271: && !ps.block_init
272: && (ps.last_token == rparen || ps.last_token == semicolon ||
273: ps.last_token == decl ||
274: ps.last_token == lbrace || ps.last_token == rbrace)) {
275: ps.its_a_keyword = true;
276: ps.last_u_d = true;
277: last_code = decl;
278: return decl;
279: }
280: if (last_code == decl) /* if this is a declared variable, then
281: * following sign is unary */
282: ps.last_u_d = true; /* will make "int a -1" work */
283: last_code = ident;
284: return (ident); /* the ident is not in the list */
285: } /* end of procesing for alpanum character */
286:
287: /* Scan a non-alphanumeric token */
288:
289: *e_token++ = *buf_ptr; /* if it is only a one-character token, it is
290: * moved here */
291: *e_token = '\0';
292: if (++buf_ptr >= buf_end)
293: fill_buffer();
294:
295: switch (*token) {
296: case '\n':
297: unary_delim = ps.last_u_d;
298: ps.last_nl = true; /* remember that we just had a newline */
299: code = (had_eof ? 0 : newline);
300:
301: /*
302: * if data has been exausted, the newline is a dummy, and we should
303: * return code to stop
304: */
305: break;
306:
307: case '\'': /* start of quoted character */
308: case '"': /* start of string */
309: qchar = *token;
310: if (troff) {
311: e_token[-1] = '`';
312: if (qchar == '"')
313: *e_token++ = '`';
314: e_token = chfont(&bodyf, &stringf, e_token);
315: }
316: do { /* copy the string */
317: while (1) { /* move one character or [/<char>]<char> */
318: if (*buf_ptr == '\n') {
319: printf("%d: Unterminated literal\n", line_no);
320: goto stop_lit;
321: }
322: CHECK_SIZE_TOKEN; /* Only have to do this once in this loop,
323: * since CHECK_SIZE guarantees that there
324: * are at least 5 entries left */
325: *e_token = *buf_ptr++;
326: if (buf_ptr >= buf_end)
327: fill_buffer();
328: if (*e_token == BACKSLASH) { /* if escape, copy extra char */
329: if (*buf_ptr == '\n') /* check for escaped newline */
330: ++line_no;
331: if (troff) {
332: *++e_token = BACKSLASH;
333: if (*buf_ptr == BACKSLASH)
334: *++e_token = BACKSLASH;
335: }
336: *++e_token = *buf_ptr++;
337: ++e_token; /* we must increment this again because we
338: * copied two chars */
339: if (buf_ptr >= buf_end)
340: fill_buffer();
341: }
342: else
343: break; /* we copied one character */
344: } /* end of while (1) */
345: } while (*e_token++ != qchar);
346: if (troff) {
347: e_token = chfont(&stringf, &bodyf, e_token - 1);
348: if (qchar == '"')
349: *e_token++ = '\'';
350: }
351: stop_lit:
352: code = ident;
353: break;
354:
355: case ('('):
356: case ('['):
357: unary_delim = true;
358: code = lparen;
359: break;
360:
361: case (')'):
362: case (']'):
363: code = rparen;
364: break;
365:
366: case '#':
367: unary_delim = ps.last_u_d;
368: code = preesc;
369: break;
370:
371: case '?':
372: unary_delim = true;
373: code = question;
374: break;
375:
376: case (':'):
377: code = colon;
378: unary_delim = true;
379: break;
380:
381: case (';'):
382: unary_delim = true;
383: code = semicolon;
384: break;
385:
386: case ('{'):
387: unary_delim = true;
388:
389: /*
390: * if (ps.in_or_st) ps.block_init = 1;
391: */
392: /* ? code = ps.block_init ? lparen : lbrace; */
393: code = lbrace;
394: break;
395:
396: case ('}'):
397: unary_delim = true;
398: /* ? code = ps.block_init ? rparen : rbrace; */
399: code = rbrace;
400: break;
401:
402: case 014: /* a form feed */
403: unary_delim = ps.last_u_d;
404: ps.last_nl = true; /* remember this so we can set 'ps.col_1'
405: * right */
406: code = form_feed;
407: break;
408:
409: case (','):
410: unary_delim = true;
411: code = comma;
412: break;
413:
414: case '.':
415: unary_delim = false;
416: code = period;
417: break;
418:
419: case '-':
420: case '+': /* check for -, +, --, ++ */
421: code = (ps.last_u_d ? unary_op : binary_op);
422: unary_delim = true;
423:
424: if (*buf_ptr == token[0]) {
425: /* check for doubled character */
426: *e_token++ = *buf_ptr++;
427: /* buffer overflow will be checked at end of loop */
428: if (last_code == ident || last_code == rparen) {
429: code = (ps.last_u_d ? unary_op : postop);
430: /* check for following ++ or -- */
431: unary_delim = false;
432: }
433: }
434: else if (*buf_ptr == '=')
435: /* check for operator += */
436: *e_token++ = *buf_ptr++;
437: else if (*buf_ptr == '>') {
438: /* check for operator -> */
439: *e_token++ = *buf_ptr++;
440: if (!pointer_as_binop) {
441: unary_delim = false;
442: code = unary_op;
443: ps.want_blank = false;
444: }
445: }
446: break; /* buffer overflow will be checked at end of
447: * switch */
448:
449: case '=':
450: if (ps.in_or_st)
451: ps.block_init = 1;
452: #ifdef undef
453: if (chartype[*buf_ptr] == opchar) { /* we have two char assignment */
454: e_token[-1] = *buf_ptr++;
455: if ((e_token[-1] == '<' || e_token[-1] == '>') && e_token[-1] == *buf_ptr)
456: *e_token++ = *buf_ptr++;
457: *e_token++ = '='; /* Flip =+ to += */
458: *e_token = 0;
459: }
460: #else
461: if (*buf_ptr == '=') {/* == */
462: *e_token++ = '='; /* Flip =+ to += */
463: buf_ptr++;
464: *e_token = 0;
465: }
466: #endif
467: code = binary_op;
468: unary_delim = true;
469: break;
470: /* can drop thru!!! */
471:
472: case '>':
473: case '<':
474: case '!': /* ops like <, <<, <=, !=, etc */
475: if (*buf_ptr == '>' || *buf_ptr == '<' || *buf_ptr == '=') {
476: *e_token++ = *buf_ptr;
477: if (++buf_ptr >= buf_end)
478: fill_buffer();
479: }
480: if (*buf_ptr == '=')
481: *e_token++ = *buf_ptr++;
482: code = (ps.last_u_d ? unary_op : binary_op);
483: unary_delim = true;
484: break;
485:
486: default:
487: if (token[0] == '/' && *buf_ptr == '*') {
488: /* it is start of comment */
489: *e_token++ = '*';
490:
491: if (++buf_ptr >= buf_end)
492: fill_buffer();
493:
494: code = comment;
495: unary_delim = ps.last_u_d;
496: break;
497: }
498: while (*(e_token - 1) == *buf_ptr || *buf_ptr == '=') {
499: /*
500: * handle ||, &&, etc, and also things as in int *****i
501: */
502: *e_token++ = *buf_ptr;
503: if (++buf_ptr >= buf_end)
504: fill_buffer();
505: }
506: code = (ps.last_u_d ? unary_op : binary_op);
507: unary_delim = true;
508:
509:
510: } /* end of switch */
511: if (code != newline) {
512: l_struct = false;
513: last_code = code;
514: }
515: if (buf_ptr >= buf_end) /* check for input buffer empty */
516: fill_buffer();
517: ps.last_u_d = unary_delim;
518: *e_token = '\0'; /* null terminate the token */
519: return (code);
520: }
521:
522: /*
523: * Add the given keyword to the keyword table, using val as the keyword type
524: */
525: addkey(key, val)
526: char *key;
527: {
528: register struct templ *p = specials;
529: while (p->rwd)
530: if (p->rwd[0] == key[0] && strcmp(p->rwd, key) == 0)
531: return;
532: else
533: p++;
534: if (p >= specials + sizeof specials / sizeof specials[0])
535: return; /* For now, table overflows are silently
536: * ignored */
537: p->rwd = key;
538: p->rwcode = val;
539: p[1].rwd = 0;
540: p[1].rwcode = 0;
541: return;
542: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.