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