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