1 /* This is the Assembler Pre-Processor 2 Copyright 1987, 1990, 1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 3 1999, 2000, 2001, 2002, 2003, 2005, 2006, 2007, 2008, 2009, 2010, 2012 4 Free Software Foundation, Inc. 5 6 This file is part of GAS, the GNU Assembler. 7 8 GAS is free software; you can redistribute it and/or modify 9 it under the terms of the GNU General Public License as published by 10 the Free Software Foundation; either version 3, or (at your option) 11 any later version. 12 13 GAS is distributed in the hope that it will be useful, but WITHOUT 14 ANY WARRANTY; without even the implied warranty of MERCHANTABILITY 15 or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public 16 License for more details. 17 18 You should have received a copy of the GNU General Public License 19 along with GAS; see the file COPYING. If not, write to the Free 20 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 21 02110-1301, USA. */ 22 23 /* Modified by Allen Wirfs-Brock, Instantiations Inc 2/90. */ 24 /* App, the assembler pre-processor. This pre-processor strips out 25 excess spaces, turns single-quoted characters into a decimal 26 constant, and turns the # in # <number> <filename> <garbage> into a 27 .linefile. This needs better error-handling. */ 28 29 #include "as.h" 30 31 #if (__STDC__ != 1) 32 #ifndef const 33 #define const /* empty */ 34 #endif 35 #endif 36 37 #ifdef H_TICK_HEX 38 int enable_h_tick_hex = 0; 39 #endif 40 41 #ifdef TC_M68K 42 /* Whether we are scrubbing in m68k MRI mode. This is different from 43 flag_m68k_mri, because the two flags will be affected by the .mri 44 pseudo-op at different times. */ 45 static int scrub_m68k_mri; 46 47 /* The pseudo-op which switches in and out of MRI mode. See the 48 comment in do_scrub_chars. */ 49 static const char mri_pseudo[] = ".mri 0"; 50 #else 51 #define scrub_m68k_mri 0 52 #endif 53 54 #if defined TC_ARM && defined OBJ_ELF 55 /* The pseudo-op for which we need to special-case `@' characters. 56 See the comment in do_scrub_chars. */ 57 static const char symver_pseudo[] = ".symver"; 58 static const char * symver_state; 59 #endif 60 61 static char lex[256]; 62 static const char symbol_chars[] = 63 "$._ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; 64 65 #define LEX_IS_SYMBOL_COMPONENT 1 66 #define LEX_IS_WHITESPACE 2 67 #define LEX_IS_LINE_SEPARATOR 3 68 #define LEX_IS_COMMENT_START 4 69 #define LEX_IS_LINE_COMMENT_START 5 70 #define LEX_IS_TWOCHAR_COMMENT_1ST 6 71 #define LEX_IS_STRINGQUOTE 8 72 #define LEX_IS_COLON 9 73 #define LEX_IS_NEWLINE 10 74 #define LEX_IS_ONECHAR_QUOTE 11 75 #ifdef TC_V850 76 #define LEX_IS_DOUBLEDASH_1ST 12 77 #endif 78 #ifdef TC_M32R 79 #define DOUBLEBAR_PARALLEL 80 #endif 81 #ifdef DOUBLEBAR_PARALLEL 82 #define LEX_IS_DOUBLEBAR_1ST 13 83 #endif 84 #define LEX_IS_PARALLEL_SEPARATOR 14 85 #ifdef H_TICK_HEX 86 #define LEX_IS_H 15 87 #endif 88 #define IS_SYMBOL_COMPONENT(c) (lex[c] == LEX_IS_SYMBOL_COMPONENT) 89 #define IS_WHITESPACE(c) (lex[c] == LEX_IS_WHITESPACE) 90 #define IS_LINE_SEPARATOR(c) (lex[c] == LEX_IS_LINE_SEPARATOR) 91 #define IS_PARALLEL_SEPARATOR(c) (lex[c] == LEX_IS_PARALLEL_SEPARATOR) 92 #define IS_COMMENT(c) (lex[c] == LEX_IS_COMMENT_START) 93 #define IS_LINE_COMMENT(c) (lex[c] == LEX_IS_LINE_COMMENT_START) 94 #define IS_NEWLINE(c) (lex[c] == LEX_IS_NEWLINE) 95 96 static int process_escape (int); 97 98 /* FIXME-soon: The entire lexer/parser thingy should be 99 built statically at compile time rather than dynamically 100 each and every time the assembler is run. xoxorich. */ 101 102 void 103 do_scrub_begin (int m68k_mri ATTRIBUTE_UNUSED) 104 { 105 const char *p; 106 int c; 107 108 lex[' '] = LEX_IS_WHITESPACE; 109 lex['\t'] = LEX_IS_WHITESPACE; 110 lex['\r'] = LEX_IS_WHITESPACE; 111 lex['\n'] = LEX_IS_NEWLINE; 112 lex[':'] = LEX_IS_COLON; 113 114 #ifdef TC_M68K 115 scrub_m68k_mri = m68k_mri; 116 117 if (! m68k_mri) 118 #endif 119 { 120 lex['"'] = LEX_IS_STRINGQUOTE; 121 122 #if ! defined (TC_HPPA) && ! defined (TC_I370) 123 /* I370 uses single-quotes to delimit integer, float constants. */ 124 lex['\''] = LEX_IS_ONECHAR_QUOTE; 125 #endif 126 127 #ifdef SINGLE_QUOTE_STRINGS 128 lex['\''] = LEX_IS_STRINGQUOTE; 129 #endif 130 } 131 132 /* Note: if any other character can be LEX_IS_STRINGQUOTE, the loop 133 in state 5 of do_scrub_chars must be changed. */ 134 135 /* Note that these override the previous defaults, e.g. if ';' is a 136 comment char, then it isn't a line separator. */ 137 for (p = symbol_chars; *p; ++p) 138 lex[(unsigned char) *p] = LEX_IS_SYMBOL_COMPONENT; 139 140 for (c = 128; c < 256; ++c) 141 lex[c] = LEX_IS_SYMBOL_COMPONENT; 142 143 #ifdef tc_symbol_chars 144 /* This macro permits the processor to specify all characters which 145 may appears in an operand. This will prevent the scrubber from 146 discarding meaningful whitespace in certain cases. The i386 147 backend uses this to support prefixes, which can confuse the 148 scrubber as to whether it is parsing operands or opcodes. */ 149 for (p = tc_symbol_chars; *p; ++p) 150 lex[(unsigned char) *p] = LEX_IS_SYMBOL_COMPONENT; 151 #endif 152 153 /* The m68k backend wants to be able to change comment_chars. */ 154 #ifndef tc_comment_chars 155 #define tc_comment_chars comment_chars 156 #endif 157 for (p = tc_comment_chars; *p; p++) 158 lex[(unsigned char) *p] = LEX_IS_COMMENT_START; 159 160 for (p = line_comment_chars; *p; p++) 161 lex[(unsigned char) *p] = LEX_IS_LINE_COMMENT_START; 162 163 for (p = line_separator_chars; *p; p++) 164 lex[(unsigned char) *p] = LEX_IS_LINE_SEPARATOR; 165 166 #ifdef tc_parallel_separator_chars 167 /* This macro permits the processor to specify all characters which 168 separate parallel insns on the same line. */ 169 for (p = tc_parallel_separator_chars; *p; p++) 170 lex[(unsigned char) *p] = LEX_IS_PARALLEL_SEPARATOR; 171 #endif 172 173 /* Only allow slash-star comments if slash is not in use. 174 FIXME: This isn't right. We should always permit them. */ 175 if (lex['/'] == 0) 176 lex['/'] = LEX_IS_TWOCHAR_COMMENT_1ST; 177 178 #ifdef TC_M68K 179 if (m68k_mri) 180 { 181 lex['\''] = LEX_IS_STRINGQUOTE; 182 lex[';'] = LEX_IS_COMMENT_START; 183 lex['*'] = LEX_IS_LINE_COMMENT_START; 184 /* The MRI documentation says '!' is LEX_IS_COMMENT_START, but 185 then it can't be used in an expression. */ 186 lex['!'] = LEX_IS_LINE_COMMENT_START; 187 } 188 #endif 189 190 #ifdef TC_V850 191 lex['-'] = LEX_IS_DOUBLEDASH_1ST; 192 #endif 193 #ifdef DOUBLEBAR_PARALLEL 194 lex['|'] = LEX_IS_DOUBLEBAR_1ST; 195 #endif 196 #ifdef TC_D30V 197 /* Must do this is we want VLIW instruction with "->" or "<-". */ 198 lex['-'] = LEX_IS_SYMBOL_COMPONENT; 199 #endif 200 201 #ifdef H_TICK_HEX 202 if (enable_h_tick_hex) 203 { 204 lex['h'] = LEX_IS_H; 205 lex['H'] = LEX_IS_H; 206 } 207 #endif 208 } 209 210 /* Saved state of the scrubber. */ 211 static int state; 212 static int old_state; 213 static char *out_string; 214 static char out_buf[20]; 215 static int add_newlines; 216 static char *saved_input; 217 static size_t saved_input_len; 218 static char input_buffer[32 * 1024]; 219 static const char *mri_state; 220 static char mri_last_ch; 221 222 /* Data structure for saving the state of app across #include's. Note that 223 app is called asynchronously to the parsing of the .include's, so our 224 state at the time .include is interpreted is completely unrelated. 225 That's why we have to save it all. */ 226 227 struct app_save 228 { 229 int state; 230 int old_state; 231 char * out_string; 232 char out_buf[sizeof (out_buf)]; 233 int add_newlines; 234 char * saved_input; 235 size_t saved_input_len; 236 #ifdef TC_M68K 237 int scrub_m68k_mri; 238 #endif 239 const char * mri_state; 240 char mri_last_ch; 241 #if defined TC_ARM && defined OBJ_ELF 242 const char * symver_state; 243 #endif 244 }; 245 246 char * 247 app_push (void) 248 { 249 register struct app_save *saved; 250 251 saved = (struct app_save *) xmalloc (sizeof (*saved)); 252 saved->state = state; 253 saved->old_state = old_state; 254 saved->out_string = out_string; 255 memcpy (saved->out_buf, out_buf, sizeof (out_buf)); 256 saved->add_newlines = add_newlines; 257 if (saved_input == NULL) 258 saved->saved_input = NULL; 259 else 260 { 261 saved->saved_input = (char *) xmalloc (saved_input_len); 262 memcpy (saved->saved_input, saved_input, saved_input_len); 263 saved->saved_input_len = saved_input_len; 264 } 265 #ifdef TC_M68K 266 saved->scrub_m68k_mri = scrub_m68k_mri; 267 #endif 268 saved->mri_state = mri_state; 269 saved->mri_last_ch = mri_last_ch; 270 #if defined TC_ARM && defined OBJ_ELF 271 saved->symver_state = symver_state; 272 #endif 273 274 /* do_scrub_begin() is not useful, just wastes time. */ 275 276 state = 0; 277 saved_input = NULL; 278 add_newlines = 0; 279 280 return (char *) saved; 281 } 282 283 void 284 app_pop (char *arg) 285 { 286 register struct app_save *saved = (struct app_save *) arg; 287 288 /* There is no do_scrub_end (). */ 289 state = saved->state; 290 old_state = saved->old_state; 291 out_string = saved->out_string; 292 memcpy (out_buf, saved->out_buf, sizeof (out_buf)); 293 add_newlines = saved->add_newlines; 294 if (saved->saved_input == NULL) 295 saved_input = NULL; 296 else 297 { 298 gas_assert (saved->saved_input_len <= sizeof (input_buffer)); 299 memcpy (input_buffer, saved->saved_input, saved->saved_input_len); 300 saved_input = input_buffer; 301 saved_input_len = saved->saved_input_len; 302 free (saved->saved_input); 303 } 304 #ifdef TC_M68K 305 scrub_m68k_mri = saved->scrub_m68k_mri; 306 #endif 307 mri_state = saved->mri_state; 308 mri_last_ch = saved->mri_last_ch; 309 #if defined TC_ARM && defined OBJ_ELF 310 symver_state = saved->symver_state; 311 #endif 312 313 free (arg); 314 } 315 316 /* @@ This assumes that \n &c are the same on host and target. This is not 317 necessarily true. */ 318 319 static int 320 process_escape (int ch) 321 { 322 switch (ch) 323 { 324 case 'b': 325 return '\b'; 326 case 'f': 327 return '\f'; 328 case 'n': 329 return '\n'; 330 case 'r': 331 return '\r'; 332 case 't': 333 return '\t'; 334 case '\'': 335 return '\''; 336 case '"': 337 return '\"'; 338 default: 339 return ch; 340 } 341 } 342 343 /* This function is called to process input characters. The GET 344 parameter is used to retrieve more input characters. GET should 345 set its parameter to point to a buffer, and return the length of 346 the buffer; it should return 0 at end of file. The scrubbed output 347 characters are put into the buffer starting at TOSTART; the TOSTART 348 buffer is TOLEN bytes in length. The function returns the number 349 of scrubbed characters put into TOSTART. This will be TOLEN unless 350 end of file was seen. This function is arranged as a state 351 machine, and saves its state so that it may return at any point. 352 This is the way the old code used to work. */ 353 354 size_t 355 do_scrub_chars (size_t (*get) (char *, size_t), char *tostart, size_t tolen) 356 { 357 char *to = tostart; 358 char *toend = tostart + tolen; 359 char *from; 360 char *fromend; 361 size_t fromlen; 362 register int ch, ch2 = 0; 363 /* Character that started the string we're working on. */ 364 static char quotechar; 365 366 /*State 0: beginning of normal line 367 1: After first whitespace on line (flush more white) 368 2: After first non-white (opcode) on line (keep 1white) 369 3: after second white on line (into operands) (flush white) 370 4: after putting out a .linefile, put out digits 371 5: parsing a string, then go to old-state 372 6: putting out \ escape in a "d string. 373 7: no longer used 374 8: no longer used 375 9: After seeing symbol char in state 3 (keep 1white after symchar) 376 10: After seeing whitespace in state 9 (keep white before symchar) 377 11: After seeing a symbol character in state 0 (eg a label definition) 378 -1: output string in out_string and go to the state in old_state 379 -2: flush text until a '*' '/' is seen, then go to state old_state 380 #ifdef TC_V850 381 12: After seeing a dash, looking for a second dash as a start 382 of comment. 383 #endif 384 #ifdef DOUBLEBAR_PARALLEL 385 13: After seeing a vertical bar, looking for a second 386 vertical bar as a parallel expression separator. 387 #endif 388 #ifdef TC_PREDICATE_START_CHAR 389 14: After seeing a predicate start character at state 0, looking 390 for a predicate end character as predicate. 391 15: After seeing a predicate start character at state 1, looking 392 for a predicate end character as predicate. 393 #endif 394 #ifdef TC_Z80 395 16: After seeing an 'a' or an 'A' at the start of a symbol 396 17: After seeing an 'f' or an 'F' in state 16 397 #endif 398 */ 399 400 /* I added states 9 and 10 because the MIPS ECOFF assembler uses 401 constructs like ``.loc 1 20''. This was turning into ``.loc 402 120''. States 9 and 10 ensure that a space is never dropped in 403 between characters which could appear in an identifier. Ian 404 Taylor, ian@cygnus.com. 405 406 I added state 11 so that something like "Lfoo add %r25,%r26,%r27" works 407 correctly on the PA (and any other target where colons are optional). 408 Jeff Law, law@cs.utah.edu. 409 410 I added state 13 so that something like "cmp r1, r2 || trap #1" does not 411 get squashed into "cmp r1,r2||trap#1", with the all important space 412 between the 'trap' and the '#1' being eliminated. nickc@cygnus.com */ 413 414 /* This macro gets the next input character. */ 415 416 #define GET() \ 417 (from < fromend \ 418 ? * (unsigned char *) (from++) \ 419 : (saved_input = NULL, \ 420 fromlen = (*get) (input_buffer, sizeof input_buffer), \ 421 from = input_buffer, \ 422 fromend = from + fromlen, \ 423 (fromlen == 0 \ 424 ? EOF \ 425 : * (unsigned char *) (from++)))) 426 427 /* This macro pushes a character back on the input stream. */ 428 429 #define UNGET(uch) (*--from = (uch)) 430 431 /* This macro puts a character into the output buffer. If this 432 character fills the output buffer, this macro jumps to the label 433 TOFULL. We use this rather ugly approach because we need to 434 handle two different termination conditions: EOF on the input 435 stream, and a full output buffer. It would be simpler if we 436 always read in the entire input stream before processing it, but 437 I don't want to make such a significant change to the assembler's 438 memory usage. */ 439 440 #define PUT(pch) \ 441 do \ 442 { \ 443 *to++ = (pch); \ 444 if (to >= toend) \ 445 goto tofull; \ 446 } \ 447 while (0) 448 449 if (saved_input != NULL) 450 { 451 from = saved_input; 452 fromend = from + saved_input_len; 453 } 454 else 455 { 456 fromlen = (*get) (input_buffer, sizeof input_buffer); 457 if (fromlen == 0) 458 return 0; 459 from = input_buffer; 460 fromend = from + fromlen; 461 } 462 463 while (1) 464 { 465 /* The cases in this switch end with continue, in order to 466 branch back to the top of this while loop and generate the 467 next output character in the appropriate state. */ 468 switch (state) 469 { 470 case -1: 471 ch = *out_string++; 472 if (*out_string == '\0') 473 { 474 state = old_state; 475 old_state = 3; 476 } 477 PUT (ch); 478 continue; 479 480 case -2: 481 for (;;) 482 { 483 do 484 { 485 ch = GET (); 486 487 if (ch == EOF) 488 { 489 as_warn (_("end of file in comment")); 490 goto fromeof; 491 } 492 493 if (ch == '\n') 494 PUT ('\n'); 495 } 496 while (ch != '*'); 497 498 while ((ch = GET ()) == '*') 499 ; 500 501 if (ch == EOF) 502 { 503 as_warn (_("end of file in comment")); 504 goto fromeof; 505 } 506 507 if (ch == '/') 508 break; 509 510 UNGET (ch); 511 } 512 513 state = old_state; 514 UNGET (' '); 515 continue; 516 517 case 4: 518 ch = GET (); 519 if (ch == EOF) 520 goto fromeof; 521 else if (ch >= '0' && ch <= '9') 522 PUT (ch); 523 else 524 { 525 while (ch != EOF && IS_WHITESPACE (ch)) 526 ch = GET (); 527 if (ch == '"') 528 { 529 quotechar = ch; 530 state = 5; 531 old_state = 3; 532 PUT (ch); 533 } 534 else 535 { 536 while (ch != EOF && ch != '\n') 537 ch = GET (); 538 state = 0; 539 PUT (ch); 540 } 541 } 542 continue; 543 544 case 5: 545 /* We are going to copy everything up to a quote character, 546 with special handling for a backslash. We try to 547 optimize the copying in the simple case without using the 548 GET and PUT macros. */ 549 { 550 char *s; 551 ptrdiff_t len; 552 553 for (s = from; s < fromend; s++) 554 { 555 ch = *s; 556 if (ch == '\\' 557 || ch == quotechar 558 || ch == '\n') 559 break; 560 } 561 len = s - from; 562 if (len > toend - to) 563 len = toend - to; 564 if (len > 0) 565 { 566 memcpy (to, from, len); 567 to += len; 568 from += len; 569 if (to >= toend) 570 goto tofull; 571 } 572 } 573 574 ch = GET (); 575 if (ch == EOF) 576 { 577 /* This buffer is here specifically so 578 that the UNGET below will work. */ 579 static char one_char_buf[1]; 580 581 as_warn (_("end of file in string; '%c' inserted"), quotechar); 582 state = old_state; 583 from = fromend = one_char_buf + 1; 584 fromlen = 1; 585 UNGET ('\n'); 586 PUT (quotechar); 587 } 588 else if (ch == quotechar) 589 { 590 state = old_state; 591 PUT (ch); 592 } 593 #ifndef NO_STRING_ESCAPES 594 else if (ch == '\\') 595 { 596 state = 6; 597 PUT (ch); 598 } 599 #endif 600 else if (scrub_m68k_mri && ch == '\n') 601 { 602 /* Just quietly terminate the string. This permits lines like 603 bne label loop if we haven't reach end yet. */ 604 state = old_state; 605 UNGET (ch); 606 PUT ('\''); 607 } 608 else 609 { 610 PUT (ch); 611 } 612 continue; 613 614 case 6: 615 state = 5; 616 ch = GET (); 617 switch (ch) 618 { 619 /* Handle strings broken across lines, by turning '\n' into 620 '\\' and 'n'. */ 621 case '\n': 622 UNGET ('n'); 623 add_newlines++; 624 PUT ('\\'); 625 continue; 626 627 case EOF: 628 as_warn (_("end of file in string; '%c' inserted"), quotechar); 629 PUT (quotechar); 630 continue; 631 632 case '"': 633 case '\\': 634 case 'b': 635 case 'f': 636 case 'n': 637 case 'r': 638 case 't': 639 case 'v': 640 case 'x': 641 case 'X': 642 case '0': 643 case '1': 644 case '2': 645 case '3': 646 case '4': 647 case '5': 648 case '6': 649 case '7': 650 break; 651 652 default: 653 #ifdef ONLY_STANDARD_ESCAPES 654 as_warn (_("unknown escape '\\%c' in string; ignored"), ch); 655 #endif 656 break; 657 } 658 PUT (ch); 659 continue; 660 661 #ifdef DOUBLEBAR_PARALLEL 662 case 13: 663 ch = GET (); 664 if (ch != '|') 665 abort (); 666 667 /* Reset back to state 1 and pretend that we are parsing a 668 line from just after the first white space. */ 669 state = 1; 670 PUT ('|'); 671 #ifdef TC_TIC6X 672 /* "||^" is used for SPMASKed instructions. */ 673 ch = GET (); 674 if (ch == EOF) 675 goto fromeof; 676 else if (ch == '^') 677 PUT ('^'); 678 else 679 UNGET (ch); 680 #endif 681 continue; 682 #endif 683 #ifdef TC_Z80 684 case 16: 685 /* We have seen an 'a' at the start of a symbol, look for an 'f'. */ 686 ch = GET (); 687 if (ch == 'f' || ch == 'F') 688 { 689 state = 17; 690 PUT (ch); 691 } 692 else 693 { 694 state = 9; 695 break; 696 } 697 case 17: 698 /* We have seen "af" at the start of a symbol, 699 a ' here is a part of that symbol. */ 700 ch = GET (); 701 state = 9; 702 if (ch == '\'') 703 /* Change to avoid warning about unclosed string. */ 704 PUT ('`'); 705 else if (ch != EOF) 706 UNGET (ch); 707 break; 708 #endif 709 } 710 711 /* OK, we are somewhere in states 0 through 4 or 9 through 11. */ 712 713 /* flushchar: */ 714 ch = GET (); 715 716 #ifdef TC_PREDICATE_START_CHAR 717 if (ch == TC_PREDICATE_START_CHAR && (state == 0 || state == 1)) 718 { 719 state += 14; 720 PUT (ch); 721 continue; 722 } 723 else if (state == 14 || state == 15) 724 { 725 if (ch == TC_PREDICATE_END_CHAR) 726 { 727 state -= 14; 728 PUT (ch); 729 ch = GET (); 730 } 731 else 732 { 733 PUT (ch); 734 continue; 735 } 736 } 737 #endif 738 739 recycle: 740 741 #if defined TC_ARM && defined OBJ_ELF 742 /* We need to watch out for .symver directives. See the comment later 743 in this function. */ 744 if (symver_state == NULL) 745 { 746 if ((state == 0 || state == 1) && ch == symver_pseudo[0]) 747 symver_state = symver_pseudo + 1; 748 } 749 else 750 { 751 /* We advance to the next state if we find the right 752 character. */ 753 if (ch != '\0' && (*symver_state == ch)) 754 ++symver_state; 755 else if (*symver_state != '\0') 756 /* We did not get the expected character, or we didn't 757 get a valid terminating character after seeing the 758 entire pseudo-op, so we must go back to the beginning. */ 759 symver_state = NULL; 760 else 761 { 762 /* We've read the entire pseudo-op. If this is the end 763 of the line, go back to the beginning. */ 764 if (IS_NEWLINE (ch)) 765 symver_state = NULL; 766 } 767 } 768 #endif /* TC_ARM && OBJ_ELF */ 769 770 #ifdef TC_M68K 771 /* We want to have pseudo-ops which control whether we are in 772 MRI mode or not. Unfortunately, since m68k MRI mode affects 773 the scrubber, that means that we need a special purpose 774 recognizer here. */ 775 if (mri_state == NULL) 776 { 777 if ((state == 0 || state == 1) 778 && ch == mri_pseudo[0]) 779 mri_state = mri_pseudo + 1; 780 } 781 else 782 { 783 /* We advance to the next state if we find the right 784 character, or if we need a space character and we get any 785 whitespace character, or if we need a '0' and we get a 786 '1' (this is so that we only need one state to handle 787 ``.mri 0'' and ``.mri 1''). */ 788 if (ch != '\0' 789 && (*mri_state == ch 790 || (*mri_state == ' ' 791 && lex[ch] == LEX_IS_WHITESPACE) 792 || (*mri_state == '0' 793 && ch == '1'))) 794 { 795 mri_last_ch = ch; 796 ++mri_state; 797 } 798 else if (*mri_state != '\0' 799 || (lex[ch] != LEX_IS_WHITESPACE 800 && lex[ch] != LEX_IS_NEWLINE)) 801 { 802 /* We did not get the expected character, or we didn't 803 get a valid terminating character after seeing the 804 entire pseudo-op, so we must go back to the 805 beginning. */ 806 mri_state = NULL; 807 } 808 else 809 { 810 /* We've read the entire pseudo-op. mips_last_ch is 811 either '0' or '1' indicating whether to enter or 812 leave MRI mode. */ 813 do_scrub_begin (mri_last_ch == '1'); 814 mri_state = NULL; 815 816 /* We continue handling the character as usual. The 817 main gas reader must also handle the .mri pseudo-op 818 to control expression parsing and the like. */ 819 } 820 } 821 #endif 822 823 if (ch == EOF) 824 { 825 if (state != 0) 826 { 827 as_warn (_("end of file not at end of a line; newline inserted")); 828 state = 0; 829 PUT ('\n'); 830 } 831 goto fromeof; 832 } 833 834 switch (lex[ch]) 835 { 836 case LEX_IS_WHITESPACE: 837 do 838 { 839 ch = GET (); 840 } 841 while (ch != EOF && IS_WHITESPACE (ch)); 842 if (ch == EOF) 843 goto fromeof; 844 845 if (state == 0) 846 { 847 /* Preserve a single whitespace character at the 848 beginning of a line. */ 849 state = 1; 850 UNGET (ch); 851 PUT (' '); 852 break; 853 } 854 855 #ifdef KEEP_WHITE_AROUND_COLON 856 if (lex[ch] == LEX_IS_COLON) 857 { 858 /* Only keep this white if there's no white *after* the 859 colon. */ 860 ch2 = GET (); 861 if (ch2 != EOF) 862 UNGET (ch2); 863 if (!IS_WHITESPACE (ch2)) 864 { 865 state = 9; 866 UNGET (ch); 867 PUT (' '); 868 break; 869 } 870 } 871 #endif 872 if (IS_COMMENT (ch) 873 || ch == '/' 874 || IS_LINE_SEPARATOR (ch) 875 || IS_PARALLEL_SEPARATOR (ch)) 876 { 877 if (scrub_m68k_mri) 878 { 879 /* In MRI mode, we keep these spaces. */ 880 UNGET (ch); 881 PUT (' '); 882 break; 883 } 884 goto recycle; 885 } 886 887 /* If we're in state 2 or 11, we've seen a non-white 888 character followed by whitespace. If the next character 889 is ':', this is whitespace after a label name which we 890 normally must ignore. In MRI mode, though, spaces are 891 not permitted between the label and the colon. */ 892 if ((state == 2 || state == 11) 893 && lex[ch] == LEX_IS_COLON 894 && ! scrub_m68k_mri) 895 { 896 state = 1; 897 PUT (ch); 898 break; 899 } 900 901 switch (state) 902 { 903 case 1: 904 /* We can arrive here if we leave a leading whitespace 905 character at the beginning of a line. */ 906 goto recycle; 907 case 2: 908 state = 3; 909 if (to + 1 < toend) 910 { 911 /* Optimize common case by skipping UNGET/GET. */ 912 PUT (' '); /* Sp after opco */ 913 goto recycle; 914 } 915 UNGET (ch); 916 PUT (' '); 917 break; 918 case 3: 919 #ifndef TC_KEEP_OPERAND_SPACES 920 /* For TI C6X, we keep these spaces as they may separate 921 functional unit specifiers from operands. */ 922 if (scrub_m68k_mri) 923 #endif 924 { 925 /* In MRI mode, we keep these spaces. */ 926 UNGET (ch); 927 PUT (' '); 928 break; 929 } 930 goto recycle; /* Sp in operands */ 931 case 9: 932 case 10: 933 #ifndef TC_KEEP_OPERAND_SPACES 934 if (scrub_m68k_mri) 935 #endif 936 { 937 /* In MRI mode, we keep these spaces. */ 938 state = 3; 939 UNGET (ch); 940 PUT (' '); 941 break; 942 } 943 state = 10; /* Sp after symbol char */ 944 goto recycle; 945 case 11: 946 if (LABELS_WITHOUT_COLONS || flag_m68k_mri) 947 state = 1; 948 else 949 { 950 /* We know that ch is not ':', since we tested that 951 case above. Therefore this is not a label, so it 952 must be the opcode, and we've just seen the 953 whitespace after it. */ 954 state = 3; 955 } 956 UNGET (ch); 957 PUT (' '); /* Sp after label definition. */ 958 break; 959 default: 960 BAD_CASE (state); 961 } 962 break; 963 964 case LEX_IS_TWOCHAR_COMMENT_1ST: 965 ch2 = GET (); 966 if (ch2 == '*') 967 { 968 for (;;) 969 { 970 do 971 { 972 ch2 = GET (); 973 if (ch2 != EOF && IS_NEWLINE (ch2)) 974 add_newlines++; 975 } 976 while (ch2 != EOF && ch2 != '*'); 977 978 while (ch2 == '*') 979 ch2 = GET (); 980 981 if (ch2 == EOF || ch2 == '/') 982 break; 983 984 /* This UNGET will ensure that we count newlines 985 correctly. */ 986 UNGET (ch2); 987 } 988 989 if (ch2 == EOF) 990 as_warn (_("end of file in multiline comment")); 991 992 ch = ' '; 993 goto recycle; 994 } 995 #ifdef DOUBLESLASH_LINE_COMMENTS 996 else if (ch2 == '/') 997 { 998 do 999 { 1000 ch = GET (); 1001 } 1002 while (ch != EOF && !IS_NEWLINE (ch)); 1003 if (ch == EOF) 1004 as_warn ("end of file in comment; newline inserted"); 1005 state = 0; 1006 PUT ('\n'); 1007 break; 1008 } 1009 #endif 1010 else 1011 { 1012 if (ch2 != EOF) 1013 UNGET (ch2); 1014 if (state == 9 || state == 10) 1015 state = 3; 1016 PUT (ch); 1017 } 1018 break; 1019 1020 case LEX_IS_STRINGQUOTE: 1021 quotechar = ch; 1022 if (state == 10) 1023 { 1024 /* Preserve the whitespace in foo "bar". */ 1025 UNGET (ch); 1026 state = 3; 1027 PUT (' '); 1028 1029 /* PUT didn't jump out. We could just break, but we 1030 know what will happen, so optimize a bit. */ 1031 ch = GET (); 1032 old_state = 3; 1033 } 1034 else if (state == 9) 1035 old_state = 3; 1036 else 1037 old_state = state; 1038 state = 5; 1039 PUT (ch); 1040 break; 1041 1042 #ifndef IEEE_STYLE 1043 case LEX_IS_ONECHAR_QUOTE: 1044 #ifdef H_TICK_HEX 1045 if (state == 9 && enable_h_tick_hex) 1046 { 1047 char c; 1048 1049 c = GET (); 1050 as_warn ("'%c found after symbol", c); 1051 UNGET (c); 1052 } 1053 #endif 1054 if (state == 10) 1055 { 1056 /* Preserve the whitespace in foo 'b'. */ 1057 UNGET (ch); 1058 state = 3; 1059 PUT (' '); 1060 break; 1061 } 1062 ch = GET (); 1063 if (ch == EOF) 1064 { 1065 as_warn (_("end of file after a one-character quote; \\0 inserted")); 1066 ch = 0; 1067 } 1068 if (ch == '\\') 1069 { 1070 ch = GET (); 1071 if (ch == EOF) 1072 { 1073 as_warn (_("end of file in escape character")); 1074 ch = '\\'; 1075 } 1076 else 1077 ch = process_escape (ch); 1078 } 1079 sprintf (out_buf, "%d", (int) (unsigned char) ch); 1080 1081 /* None of these 'x constants for us. We want 'x'. */ 1082 if ((ch = GET ()) != '\'') 1083 { 1084 #ifdef REQUIRE_CHAR_CLOSE_QUOTE 1085 as_warn (_("missing close quote; (assumed)")); 1086 #else 1087 if (ch != EOF) 1088 UNGET (ch); 1089 #endif 1090 } 1091 if (strlen (out_buf) == 1) 1092 { 1093 PUT (out_buf[0]); 1094 break; 1095 } 1096 if (state == 9) 1097 old_state = 3; 1098 else 1099 old_state = state; 1100 state = -1; 1101 out_string = out_buf; 1102 PUT (*out_string++); 1103 break; 1104 #endif 1105 1106 case LEX_IS_COLON: 1107 #ifdef KEEP_WHITE_AROUND_COLON 1108 state = 9; 1109 #else 1110 if (state == 9 || state == 10) 1111 state = 3; 1112 else if (state != 3) 1113 state = 1; 1114 #endif 1115 PUT (ch); 1116 break; 1117 1118 case LEX_IS_NEWLINE: 1119 /* Roll out a bunch of newlines from inside comments, etc. */ 1120 if (add_newlines) 1121 { 1122 --add_newlines; 1123 UNGET (ch); 1124 } 1125 /* Fall through. */ 1126 1127 case LEX_IS_LINE_SEPARATOR: 1128 state = 0; 1129 PUT (ch); 1130 break; 1131 1132 case LEX_IS_PARALLEL_SEPARATOR: 1133 state = 1; 1134 PUT (ch); 1135 break; 1136 1137 #ifdef TC_V850 1138 case LEX_IS_DOUBLEDASH_1ST: 1139 ch2 = GET (); 1140 if (ch2 != '-') 1141 { 1142 if (ch2 != EOF) 1143 UNGET (ch2); 1144 goto de_fault; 1145 } 1146 /* Read and skip to end of line. */ 1147 do 1148 { 1149 ch = GET (); 1150 } 1151 while (ch != EOF && ch != '\n'); 1152 1153 if (ch == EOF) 1154 as_warn (_("end of file in comment; newline inserted")); 1155 1156 state = 0; 1157 PUT ('\n'); 1158 break; 1159 #endif 1160 #ifdef DOUBLEBAR_PARALLEL 1161 case LEX_IS_DOUBLEBAR_1ST: 1162 ch2 = GET (); 1163 if (ch2 != EOF) 1164 UNGET (ch2); 1165 if (ch2 != '|') 1166 goto de_fault; 1167 1168 /* Handle '||' in two states as invoking PUT twice might 1169 result in the first one jumping out of this loop. We'd 1170 then lose track of the state and one '|' char. */ 1171 state = 13; 1172 PUT ('|'); 1173 break; 1174 #endif 1175 case LEX_IS_LINE_COMMENT_START: 1176 /* FIXME-someday: The two character comment stuff was badly 1177 thought out. On i386, we want '/' as line comment start 1178 AND we want C style comments. hence this hack. The 1179 whole lexical process should be reworked. xoxorich. */ 1180 if (ch == '/') 1181 { 1182 ch2 = GET (); 1183 if (ch2 == '*') 1184 { 1185 old_state = 3; 1186 state = -2; 1187 break; 1188 } 1189 else 1190 { 1191 UNGET (ch2); 1192 } 1193 } 1194 1195 if (state == 0 || state == 1) /* Only comment at start of line. */ 1196 { 1197 int startch; 1198 1199 startch = ch; 1200 1201 do 1202 { 1203 ch = GET (); 1204 } 1205 while (ch != EOF && IS_WHITESPACE (ch)); 1206 1207 if (ch == EOF) 1208 { 1209 as_warn (_("end of file in comment; newline inserted")); 1210 PUT ('\n'); 1211 break; 1212 } 1213 1214 if (ch < '0' || ch > '9' || state != 0 || startch != '#') 1215 { 1216 /* Not a cpp line. */ 1217 while (ch != EOF && !IS_NEWLINE (ch)) 1218 ch = GET (); 1219 if (ch == EOF) 1220 as_warn (_("end of file in comment; newline inserted")); 1221 state = 0; 1222 PUT ('\n'); 1223 break; 1224 } 1225 /* Looks like `# 123 "filename"' from cpp. */ 1226 UNGET (ch); 1227 old_state = 4; 1228 state = -1; 1229 if (scrub_m68k_mri) 1230 out_string = "\tlinefile "; 1231 else 1232 out_string = "\t.linefile "; 1233 PUT (*out_string++); 1234 break; 1235 } 1236 1237 #ifdef TC_D10V 1238 /* All insns end in a char for which LEX_IS_SYMBOL_COMPONENT is true. 1239 Trap is the only short insn that has a first operand that is 1240 neither register nor label. 1241 We must prevent exef0f ||trap #1 to degenerate to exef0f ||trap#1 . 1242 We can't make '#' LEX_IS_SYMBOL_COMPONENT because it is 1243 already LEX_IS_LINE_COMMENT_START. However, it is the 1244 only character in line_comment_chars for d10v, hence we 1245 can recognize it as such. */ 1246 /* An alternative approach would be to reset the state to 1 when 1247 we see '||', '<'- or '->', but that seems to be overkill. */ 1248 if (state == 10) 1249 PUT (' '); 1250 #endif 1251 /* We have a line comment character which is not at the 1252 start of a line. If this is also a normal comment 1253 character, fall through. Otherwise treat it as a default 1254 character. */ 1255 if (strchr (tc_comment_chars, ch) == NULL 1256 && (! scrub_m68k_mri 1257 || (ch != '!' && ch != '*'))) 1258 goto de_fault; 1259 if (scrub_m68k_mri 1260 && (ch == '!' || ch == '*' || ch == '#') 1261 && state != 1 1262 && state != 10) 1263 goto de_fault; 1264 /* Fall through. */ 1265 case LEX_IS_COMMENT_START: 1266 #if defined TC_ARM && defined OBJ_ELF 1267 /* On the ARM, `@' is the comment character. 1268 Unfortunately this is also a special character in ELF .symver 1269 directives (and .type, though we deal with those another way). 1270 So we check if this line is such a directive, and treat 1271 the character as default if so. This is a hack. */ 1272 if ((symver_state != NULL) && (*symver_state == 0)) 1273 goto de_fault; 1274 #endif 1275 1276 #ifdef TC_ARM 1277 /* For the ARM, care is needed not to damage occurrences of \@ 1278 by stripping the @ onwards. Yuck. */ 1279 if (to > tostart && *(to - 1) == '\\') 1280 /* Do not treat the @ as a start-of-comment. */ 1281 goto de_fault; 1282 #endif 1283 1284 #ifdef WARN_COMMENTS 1285 if (!found_comment) 1286 as_where (&found_comment_file, &found_comment); 1287 #endif 1288 do 1289 { 1290 ch = GET (); 1291 } 1292 while (ch != EOF && !IS_NEWLINE (ch)); 1293 if (ch == EOF) 1294 as_warn (_("end of file in comment; newline inserted")); 1295 state = 0; 1296 PUT ('\n'); 1297 break; 1298 1299 #ifdef H_TICK_HEX 1300 case LEX_IS_H: 1301 /* Look for strings like H'[0-9A-Fa-f] and if found, replace 1302 the H' with 0x to make them gas-style hex characters. */ 1303 if (enable_h_tick_hex) 1304 { 1305 char quot; 1306 1307 quot = GET (); 1308 if (quot == '\'') 1309 { 1310 UNGET ('x'); 1311 ch = '0'; 1312 } 1313 else 1314 UNGET (quot); 1315 } 1316 /* FALL THROUGH */ 1317 #endif 1318 1319 case LEX_IS_SYMBOL_COMPONENT: 1320 if (state == 10) 1321 { 1322 /* This is a symbol character following another symbol 1323 character, with whitespace in between. We skipped 1324 the whitespace earlier, so output it now. */ 1325 UNGET (ch); 1326 state = 3; 1327 PUT (' '); 1328 break; 1329 } 1330 1331 #ifdef TC_Z80 1332 /* "af'" is a symbol containing '\''. */ 1333 if (state == 3 && (ch == 'a' || ch == 'A')) 1334 { 1335 state = 16; 1336 PUT (ch); 1337 ch = GET (); 1338 if (ch == 'f' || ch == 'F') 1339 { 1340 state = 17; 1341 PUT (ch); 1342 break; 1343 } 1344 else 1345 { 1346 state = 9; 1347 if (ch == EOF || !IS_SYMBOL_COMPONENT (ch)) 1348 { 1349 if (ch != EOF) 1350 UNGET (ch); 1351 break; 1352 } 1353 } 1354 } 1355 #endif 1356 if (state == 3) 1357 state = 9; 1358 1359 /* This is a common case. Quickly copy CH and all the 1360 following symbol component or normal characters. */ 1361 if (to + 1 < toend 1362 && mri_state == NULL 1363 #if defined TC_ARM && defined OBJ_ELF 1364 && symver_state == NULL 1365 #endif 1366 ) 1367 { 1368 char *s; 1369 ptrdiff_t len; 1370 1371 for (s = from; s < fromend; s++) 1372 { 1373 int type; 1374 1375 ch2 = *(unsigned char *) s; 1376 type = lex[ch2]; 1377 if (type != 0 1378 && type != LEX_IS_SYMBOL_COMPONENT) 1379 break; 1380 } 1381 1382 if (s > from) 1383 /* Handle the last character normally, for 1384 simplicity. */ 1385 --s; 1386 1387 len = s - from; 1388 1389 if (len > (toend - to) - 1) 1390 len = (toend - to) - 1; 1391 1392 if (len > 0) 1393 { 1394 PUT (ch); 1395 memcpy (to, from, len); 1396 to += len; 1397 from += len; 1398 if (to >= toend) 1399 goto tofull; 1400 ch = GET (); 1401 } 1402 } 1403 1404 /* Fall through. */ 1405 default: 1406 de_fault: 1407 /* Some relatively `normal' character. */ 1408 if (state == 0) 1409 { 1410 state = 11; /* Now seeing label definition. */ 1411 } 1412 else if (state == 1) 1413 { 1414 state = 2; /* Ditto. */ 1415 } 1416 else if (state == 9) 1417 { 1418 if (!IS_SYMBOL_COMPONENT (ch)) 1419 state = 3; 1420 } 1421 else if (state == 10) 1422 { 1423 if (ch == '\\') 1424 { 1425 /* Special handling for backslash: a backslash may 1426 be the beginning of a formal parameter (of a 1427 macro) following another symbol character, with 1428 whitespace in between. If that is the case, we 1429 output a space before the parameter. Strictly 1430 speaking, correct handling depends upon what the 1431 macro parameter expands into; if the parameter 1432 expands into something which does not start with 1433 an operand character, then we don't want to keep 1434 the space. We don't have enough information to 1435 make the right choice, so here we are making the 1436 choice which is more likely to be correct. */ 1437 if (to + 1 >= toend) 1438 { 1439 /* If we're near the end of the buffer, save the 1440 character for the next time round. Otherwise 1441 we'll lose our state. */ 1442 UNGET (ch); 1443 goto tofull; 1444 } 1445 *to++ = ' '; 1446 } 1447 1448 state = 3; 1449 } 1450 PUT (ch); 1451 break; 1452 } 1453 } 1454 1455 /*NOTREACHED*/ 1456 1457 fromeof: 1458 /* We have reached the end of the input. */ 1459 return to - tostart; 1460 1461 tofull: 1462 /* The output buffer is full. Save any input we have not yet 1463 processed. */ 1464 if (fromend > from) 1465 { 1466 saved_input = from; 1467 saved_input_len = fromend - from; 1468 } 1469 else 1470 saved_input = NULL; 1471 1472 return to - tostart; 1473 } 1474