app.c revision 60484
129088Smarkm/* This is the Assembler Pre-Processor 229088Smarkm Copyright (C) 1987, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000 329088Smarkm Free Software Foundation, Inc. 429088Smarkm 529088Smarkm This file is part of GAS, the GNU Assembler. 629088Smarkm 729088Smarkm GAS is free software; you can redistribute it and/or modify 829088Smarkm it under the terms of the GNU General Public License as published by 929088Smarkm the Free Software Foundation; either version 2, or (at your option) 1029088Smarkm any later version. 1129088Smarkm 1229088Smarkm GAS is distributed in the hope that it will be useful, 1329088Smarkm but WITHOUT ANY WARRANTY; without even the implied warranty of 1429088Smarkm MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 1529088Smarkm GNU General Public License for more details. 1629088Smarkm 1729088Smarkm You should have received a copy of the GNU General Public License 1829088Smarkm along with GAS; see the file COPYING. If not, write to the Free 1929088Smarkm Software Foundation, 59 Temple Place - Suite 330, Boston, MA 2029088Smarkm 02111-1307, USA. */ 2129088Smarkm 2229088Smarkm/* Modified by Allen Wirfs-Brock, Instantiations Inc 2/90 */ 2329088Smarkm/* App, the assembler pre-processor. This pre-processor strips out excess 2429088Smarkm spaces, turns single-quoted characters into a decimal constant, and turns 2529088Smarkm # <number> <filename> <garbage> into a .line <number>\n.file <filename> 2629088Smarkm pair. This needs better error-handling. */ 2729088Smarkm 2829088Smarkm#include <stdio.h> 2929088Smarkm#include "as.h" /* For BAD_CASE() only */ 3029088Smarkm 3129088Smarkm#if (__STDC__ != 1) 3229088Smarkm#ifndef const 3329088Smarkm#define const /* empty */ 3463248Speter#endif 3529088Smarkm#endif 3629088Smarkm 3729088Smarkm#ifdef TC_M68K 3829088Smarkm/* Whether we are scrubbing in m68k MRI mode. This is different from 3929088Smarkm flag_m68k_mri, because the two flags will be affected by the .mri 4029088Smarkm pseudo-op at different times. */ 4129088Smarkmstatic int scrub_m68k_mri; 4229088Smarkm#else 4329088Smarkm#define scrub_m68k_mri 0 4429088Smarkm#endif 4529088Smarkm 4629088Smarkm/* The pseudo-op which switches in and out of MRI mode. See the 4729088Smarkm comment in do_scrub_chars. */ 4829088Smarkmstatic const char mri_pseudo[] = ".mri 0"; 4929088Smarkm 5029088Smarkm#if defined TC_ARM && defined OBJ_ELF 5129088Smarkm/* The pseudo-op for which we need to special-case `@' characters. 5229088Smarkm See the comment in do_scrub_chars. */ 5329088Smarkmstatic const char symver_pseudo[] = ".symver"; 5429088Smarkmstatic const char * symver_state; 5529088Smarkm#endif 5629088Smarkm 5729088Smarkmstatic char lex[256]; 5887139Smarkmstatic const char symbol_chars[] = 5987139Smarkm"$._ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"; 6087139Smarkm 6187139Smarkm#define LEX_IS_SYMBOL_COMPONENT 1 6287139Smarkm#define LEX_IS_WHITESPACE 2 6387139Smarkm#define LEX_IS_LINE_SEPARATOR 3 6487139Smarkm#define LEX_IS_COMMENT_START 4 6587139Smarkm#define LEX_IS_LINE_COMMENT_START 5 6687139Smarkm#define LEX_IS_TWOCHAR_COMMENT_1ST 6 6787139Smarkm#define LEX_IS_STRINGQUOTE 8 6887139Smarkm#define LEX_IS_COLON 9 6987139Smarkm#define LEX_IS_NEWLINE 10 7087139Smarkm#define LEX_IS_ONECHAR_QUOTE 11 7187139Smarkm#ifdef TC_V850 7287139Smarkm#define LEX_IS_DOUBLEDASH_1ST 12 7387139Smarkm#endif 7487139Smarkm#ifdef TC_M32R 7587139Smarkm#define DOUBLEBAR_PARALLEL 7687139Smarkm#endif 7787139Smarkm#ifdef DOUBLEBAR_PARALLEL 7887139Smarkm#define LEX_IS_DOUBLEBAR_1ST 13 7987139Smarkm#endif 8087139Smarkm#define IS_SYMBOL_COMPONENT(c) (lex[c] == LEX_IS_SYMBOL_COMPONENT) 8187139Smarkm#define IS_WHITESPACE(c) (lex[c] == LEX_IS_WHITESPACE) 8287139Smarkm#define IS_LINE_SEPARATOR(c) (lex[c] == LEX_IS_LINE_SEPARATOR) 8387139Smarkm#define IS_COMMENT(c) (lex[c] == LEX_IS_COMMENT_START) 8487139Smarkm#define IS_LINE_COMMENT(c) (lex[c] == LEX_IS_LINE_COMMENT_START) 8587139Smarkm#define IS_NEWLINE(c) (lex[c] == LEX_IS_NEWLINE) 8629088Smarkm 8787139Smarkmstatic int process_escape PARAMS ((int)); 8829088Smarkm 8987139Smarkm/* FIXME-soon: The entire lexer/parser thingy should be 9087139Smarkm built statically at compile time rather than dynamically 9187139Smarkm each and every time the assembler is run. xoxorich. */ 9287139Smarkm 9387139Smarkmvoid 9487139Smarkmdo_scrub_begin (m68k_mri) 9587139Smarkm int m68k_mri ATTRIBUTE_UNUSED; 9629088Smarkm{ 9787139Smarkm const char *p; 9887139Smarkm int c; 9987139Smarkm 10087139Smarkm lex[' '] = LEX_IS_WHITESPACE; 10187139Smarkm lex['\t'] = LEX_IS_WHITESPACE; 10287139Smarkm lex['\r'] = LEX_IS_WHITESPACE; 10387139Smarkm lex['\n'] = LEX_IS_NEWLINE; 10487139Smarkm lex[';'] = LEX_IS_LINE_SEPARATOR; 10529088Smarkm lex[':'] = LEX_IS_COLON; 10687139Smarkm 10787139Smarkm#ifdef TC_M68K 10887139Smarkm scrub_m68k_mri = m68k_mri; 10987139Smarkm 11087139Smarkm if (! m68k_mri) 11187139Smarkm#endif 11287139Smarkm { 11387139Smarkm lex['"'] = LEX_IS_STRINGQUOTE; 11487139Smarkm 11529088Smarkm#if ! defined (TC_HPPA) && ! defined (TC_I370) 11687139Smarkm /* I370 uses single-quotes to delimit integer, float constants */ 11787139Smarkm lex['\''] = LEX_IS_ONECHAR_QUOTE; 11887139Smarkm#endif 11987139Smarkm 12087139Smarkm#ifdef SINGLE_QUOTE_STRINGS 12187139Smarkm lex['\''] = LEX_IS_STRINGQUOTE; 12287139Smarkm#endif 12387139Smarkm } 12487139Smarkm 12587139Smarkm /* Note: if any other character can be LEX_IS_STRINGQUOTE, the loop 12629088Smarkm in state 5 of do_scrub_chars must be changed. */ 127 128 /* Note that these override the previous defaults, e.g. if ';' is a 129 comment char, then it isn't a line separator. */ 130 for (p = symbol_chars; *p; ++p) 131 { 132 lex[(unsigned char) *p] = LEX_IS_SYMBOL_COMPONENT; 133 } /* declare symbol characters */ 134 135 for (c = 128; c < 256; ++c) 136 lex[c] = LEX_IS_SYMBOL_COMPONENT; 137 138#ifdef tc_symbol_chars 139 /* This macro permits the processor to specify all characters which 140 may appears in an operand. This will prevent the scrubber from 141 discarding meaningful whitespace in certain cases. The i386 142 backend uses this to support prefixes, which can confuse the 143 scrubber as to whether it is parsing operands or opcodes. */ 144 for (p = tc_symbol_chars; *p; ++p) 145 lex[(unsigned char) *p] = LEX_IS_SYMBOL_COMPONENT; 146#endif 147 148 /* The m68k backend wants to be able to change comment_chars. */ 149#ifndef tc_comment_chars 150#define tc_comment_chars comment_chars 151#endif 152 for (p = tc_comment_chars; *p; p++) 153 { 154 lex[(unsigned char) *p] = LEX_IS_COMMENT_START; 155 } /* declare comment chars */ 156 157 for (p = line_comment_chars; *p; p++) 158 { 159 lex[(unsigned char) *p] = LEX_IS_LINE_COMMENT_START; 160 } /* declare line comment chars */ 161 162 for (p = line_separator_chars; *p; p++) 163 { 164 lex[(unsigned char) *p] = LEX_IS_LINE_SEPARATOR; 165 } /* declare line separators */ 166 167 /* Only allow slash-star comments if slash is not in use. 168 FIXME: This isn't right. We should always permit them. */ 169 if (lex['/'] == 0) 170 { 171 lex['/'] = LEX_IS_TWOCHAR_COMMENT_1ST; 172 } 173 174#ifdef TC_M68K 175 if (m68k_mri) 176 { 177 lex['\''] = LEX_IS_STRINGQUOTE; 178 lex[';'] = LEX_IS_COMMENT_START; 179 lex['*'] = LEX_IS_LINE_COMMENT_START; 180 /* The MRI documentation says '!' is LEX_IS_COMMENT_START, but 181 then it can't be used in an expression. */ 182 lex['!'] = LEX_IS_LINE_COMMENT_START; 183 } 184#endif 185 186#ifdef TC_V850 187 lex['-'] = LEX_IS_DOUBLEDASH_1ST; 188#endif 189#ifdef DOUBLEBAR_PARALLEL 190 lex['|'] = LEX_IS_DOUBLEBAR_1ST; 191#endif 192#ifdef TC_D30V 193 /* must do this is we want VLIW instruction with "->" or "<-" */ 194 lex['-'] = LEX_IS_SYMBOL_COMPONENT; 195#endif 196} /* do_scrub_begin() */ 197 198/* Saved state of the scrubber */ 199static int state; 200static int old_state; 201static char *out_string; 202static char out_buf[20]; 203static int add_newlines; 204static char *saved_input; 205static int saved_input_len; 206static char input_buffer[32 * 1024]; 207static const char *mri_state; 208static char mri_last_ch; 209 210/* Data structure for saving the state of app across #include's. Note that 211 app is called asynchronously to the parsing of the .include's, so our 212 state at the time .include is interpreted is completely unrelated. 213 That's why we have to save it all. */ 214 215struct app_save 216 { 217 int state; 218 int old_state; 219 char * out_string; 220 char out_buf[sizeof (out_buf)]; 221 int add_newlines; 222 char * saved_input; 223 int saved_input_len; 224#ifdef TC_M68K 225 int scrub_m68k_mri; 226#endif 227 const char * mri_state; 228 char mri_last_ch; 229#if defined TC_ARM && defined OBJ_ELF 230 const char * symver_state; 231#endif 232 }; 233 234char * 235app_push () 236{ 237 register struct app_save *saved; 238 239 saved = (struct app_save *) xmalloc (sizeof (*saved)); 240 saved->state = state; 241 saved->old_state = old_state; 242 saved->out_string = out_string; 243 memcpy (saved->out_buf, out_buf, sizeof (out_buf)); 244 saved->add_newlines = add_newlines; 245 if (saved_input == NULL) 246 saved->saved_input = NULL; 247 else 248 { 249 saved->saved_input = xmalloc (saved_input_len); 250 memcpy (saved->saved_input, saved_input, saved_input_len); 251 saved->saved_input_len = saved_input_len; 252 } 253#ifdef TC_M68K 254 saved->scrub_m68k_mri = scrub_m68k_mri; 255#endif 256 saved->mri_state = mri_state; 257 saved->mri_last_ch = mri_last_ch; 258#if defined TC_ARM && defined OBJ_ELF 259 saved->symver_state = symver_state; 260#endif 261 262 /* do_scrub_begin() is not useful, just wastes time. */ 263 264 state = 0; 265 saved_input = NULL; 266 267 return (char *) saved; 268} 269 270void 271app_pop (arg) 272 char *arg; 273{ 274 register struct app_save *saved = (struct app_save *) arg; 275 276 /* There is no do_scrub_end (). */ 277 state = saved->state; 278 old_state = saved->old_state; 279 out_string = saved->out_string; 280 memcpy (out_buf, saved->out_buf, sizeof (out_buf)); 281 add_newlines = saved->add_newlines; 282 if (saved->saved_input == NULL) 283 saved_input = NULL; 284 else 285 { 286 assert (saved->saved_input_len <= (int) (sizeof input_buffer)); 287 memcpy (input_buffer, saved->saved_input, saved->saved_input_len); 288 saved_input = input_buffer; 289 saved_input_len = saved->saved_input_len; 290 free (saved->saved_input); 291 } 292#ifdef TC_M68K 293 scrub_m68k_mri = saved->scrub_m68k_mri; 294#endif 295 mri_state = saved->mri_state; 296 mri_last_ch = saved->mri_last_ch; 297#if defined TC_ARM && defined OBJ_ELF 298 symver_state = saved->symver_state; 299#endif 300 301 free (arg); 302} /* app_pop() */ 303 304/* @@ This assumes that \n &c are the same on host and target. This is not 305 necessarily true. */ 306static int 307process_escape (ch) 308 int ch; 309{ 310 switch (ch) 311 { 312 case 'b': 313 return '\b'; 314 case 'f': 315 return '\f'; 316 case 'n': 317 return '\n'; 318 case 'r': 319 return '\r'; 320 case 't': 321 return '\t'; 322 case '\'': 323 return '\''; 324 case '"': 325 return '\"'; 326 default: 327 return ch; 328 } 329} 330 331/* This function is called to process input characters. The GET 332 parameter is used to retrieve more input characters. GET should 333 set its parameter to point to a buffer, and return the length of 334 the buffer; it should return 0 at end of file. The scrubbed output 335 characters are put into the buffer starting at TOSTART; the TOSTART 336 buffer is TOLEN bytes in length. The function returns the number 337 of scrubbed characters put into TOSTART. This will be TOLEN unless 338 end of file was seen. This function is arranged as a state 339 machine, and saves its state so that it may return at any point. 340 This is the way the old code used to work. */ 341 342int 343do_scrub_chars (get, tostart, tolen) 344 int (*get) PARAMS ((char *, int)); 345 char *tostart; 346 int tolen; 347{ 348 char *to = tostart; 349 char *toend = tostart + tolen; 350 char *from; 351 char *fromend; 352 int fromlen; 353 register int ch, ch2 = 0; 354 355 /*State 0: beginning of normal line 356 1: After first whitespace on line (flush more white) 357 2: After first non-white (opcode) on line (keep 1white) 358 3: after second white on line (into operands) (flush white) 359 4: after putting out a .line, put out digits 360 5: parsing a string, then go to old-state 361 6: putting out \ escape in a "d string. 362 7: After putting out a .appfile, put out string. 363 8: After putting out a .appfile string, flush until newline. 364 9: After seeing symbol char in state 3 (keep 1white after symchar) 365 10: After seeing whitespace in state 9 (keep white before symchar) 366 11: After seeing a symbol character in state 0 (eg a label definition) 367 -1: output string in out_string and go to the state in old_state 368 -2: flush text until a '*' '/' is seen, then go to state old_state 369#ifdef TC_V850 370 12: After seeing a dash, looking for a second dash as a start of comment. 371#endif 372#ifdef DOUBLEBAR_PARALLEL 373 13: After seeing a vertical bar, looking for a second vertical bar as a parallel expression seperator. 374#endif 375 */ 376 377 /* I added states 9 and 10 because the MIPS ECOFF assembler uses 378 constructs like ``.loc 1 20''. This was turning into ``.loc 379 120''. States 9 and 10 ensure that a space is never dropped in 380 between characters which could appear in a identifier. Ian 381 Taylor, ian@cygnus.com. 382 383 I added state 11 so that something like "Lfoo add %r25,%r26,%r27" works 384 correctly on the PA (and any other target where colons are optional). 385 Jeff Law, law@cs.utah.edu. 386 387 I added state 13 so that something like "cmp r1, r2 || trap #1" does not 388 get squashed into "cmp r1,r2||trap#1", with the all important space 389 between the 'trap' and the '#1' being eliminated. nickc@cygnus.com */ 390 391 /* This macro gets the next input character. */ 392 393#define GET() \ 394 (from < fromend \ 395 ? * (unsigned char *) (from++) \ 396 : (saved_input = NULL, \ 397 fromlen = (*get) (input_buffer, sizeof input_buffer), \ 398 from = input_buffer, \ 399 fromend = from + fromlen, \ 400 (fromlen == 0 \ 401 ? EOF \ 402 : * (unsigned char *) (from++)))) 403 404 /* This macro pushes a character back on the input stream. */ 405 406#define UNGET(uch) (*--from = (uch)) 407 408 /* This macro puts a character into the output buffer. If this 409 character fills the output buffer, this macro jumps to the label 410 TOFULL. We use this rather ugly approach because we need to 411 handle two different termination conditions: EOF on the input 412 stream, and a full output buffer. It would be simpler if we 413 always read in the entire input stream before processing it, but 414 I don't want to make such a significant change to the assembler's 415 memory usage. */ 416 417#define PUT(pch) \ 418 do \ 419 { \ 420 *to++ = (pch); \ 421 if (to >= toend) \ 422 goto tofull; \ 423 } \ 424 while (0) 425 426 if (saved_input != NULL) 427 { 428 from = saved_input; 429 fromend = from + saved_input_len; 430 } 431 else 432 { 433 fromlen = (*get) (input_buffer, sizeof input_buffer); 434 if (fromlen == 0) 435 return 0; 436 from = input_buffer; 437 fromend = from + fromlen; 438 } 439 440 while (1) 441 { 442 /* The cases in this switch end with continue, in order to 443 branch back to the top of this while loop and generate the 444 next output character in the appropriate state. */ 445 switch (state) 446 { 447 case -1: 448 ch = *out_string++; 449 if (*out_string == '\0') 450 { 451 state = old_state; 452 old_state = 3; 453 } 454 PUT (ch); 455 continue; 456 457 case -2: 458 for (;;) 459 { 460 do 461 { 462 ch = GET (); 463 464 if (ch == EOF) 465 { 466 as_warn (_("end of file in comment")); 467 goto fromeof; 468 } 469 470 if (ch == '\n') 471 PUT ('\n'); 472 } 473 while (ch != '*'); 474 475 while ((ch = GET ()) == '*') 476 ; 477 478 if (ch == EOF) 479 { 480 as_warn (_("end of file in comment")); 481 goto fromeof; 482 } 483 484 if (ch == '/') 485 break; 486 487 UNGET (ch); 488 } 489 490 state = old_state; 491 UNGET (' '); 492 continue; 493 494 case 4: 495 ch = GET (); 496 if (ch == EOF) 497 goto fromeof; 498 else if (ch >= '0' && ch <= '9') 499 PUT (ch); 500 else 501 { 502 while (ch != EOF && IS_WHITESPACE (ch)) 503 ch = GET (); 504 if (ch == '"') 505 { 506 UNGET (ch); 507 if (scrub_m68k_mri) 508 out_string = "\n\tappfile "; 509 else 510 out_string = "\n\t.appfile "; 511 old_state = 7; 512 state = -1; 513 PUT (*out_string++); 514 } 515 else 516 { 517 while (ch != EOF && ch != '\n') 518 ch = GET (); 519 state = 0; 520 PUT (ch); 521 } 522 } 523 continue; 524 525 case 5: 526 /* We are going to copy everything up to a quote character, 527 with special handling for a backslash. We try to 528 optimize the copying in the simple case without using the 529 GET and PUT macros. */ 530 { 531 char *s; 532 int len; 533 534 for (s = from; s < fromend; s++) 535 { 536 ch = *s; 537 /* This condition must be changed if the type of any 538 other character can be LEX_IS_STRINGQUOTE. */ 539 if (ch == '\\' 540 || ch == '"' 541 || ch == '\'' 542 || ch == '\n') 543 break; 544 } 545 len = s - from; 546 if (len > toend - to) 547 len = toend - to; 548 if (len > 0) 549 { 550 memcpy (to, from, len); 551 to += len; 552 from += len; 553 } 554 } 555 556 ch = GET (); 557 if (ch == EOF) 558 { 559 as_warn (_("end of file in string: inserted '\"'")); 560 state = old_state; 561 UNGET ('\n'); 562 PUT ('"'); 563 } 564 else if (lex[ch] == LEX_IS_STRINGQUOTE) 565 { 566 state = old_state; 567 PUT (ch); 568 } 569#ifndef NO_STRING_ESCAPES 570 else if (ch == '\\') 571 { 572 state = 6; 573 PUT (ch); 574 } 575#endif 576 else if (scrub_m68k_mri && ch == '\n') 577 { 578 /* Just quietly terminate the string. This permits lines like 579 bne label loop if we haven't reach end yet 580 */ 581 state = old_state; 582 UNGET (ch); 583 PUT ('\''); 584 } 585 else 586 { 587 PUT (ch); 588 } 589 continue; 590 591 case 6: 592 state = 5; 593 ch = GET (); 594 switch (ch) 595 { 596 /* Handle strings broken across lines, by turning '\n' into 597 '\\' and 'n'. */ 598 case '\n': 599 UNGET ('n'); 600 add_newlines++; 601 PUT ('\\'); 602 continue; 603 604 case '"': 605 case '\\': 606 case 'b': 607 case 'f': 608 case 'n': 609 case 'r': 610 case 't': 611 case 'v': 612 case 'x': 613 case 'X': 614 case '0': 615 case '1': 616 case '2': 617 case '3': 618 case '4': 619 case '5': 620 case '6': 621 case '7': 622 break; 623#if defined(IGNORE_NONSTANDARD_ESCAPES) | defined(ONLY_STANDARD_ESCAPES) 624 default: 625 as_warn (_("Unknown escape '\\%c' in string: Ignored"), ch); 626 break; 627#else /* ONLY_STANDARD_ESCAPES */ 628 default: 629 /* Accept \x as x for any x */ 630 break; 631#endif /* ONLY_STANDARD_ESCAPES */ 632 633 case EOF: 634 as_warn (_("End of file in string: '\"' inserted")); 635 PUT ('"'); 636 continue; 637 } 638 PUT (ch); 639 continue; 640 641 case 7: 642 ch = GET (); 643 state = 5; 644 old_state = 8; 645 if (ch == EOF) 646 goto fromeof; 647 PUT (ch); 648 continue; 649 650 case 8: 651 do 652 ch = GET (); 653 while (ch != '\n' && ch != EOF); 654 if (ch == EOF) 655 goto fromeof; 656 state = 0; 657 PUT (ch); 658 continue; 659 } 660 661 /* OK, we are somewhere in states 0 through 4 or 9 through 11 */ 662 663 /* flushchar: */ 664 ch = GET (); 665 666 recycle: 667 668#if defined TC_ARM && defined OBJ_ELF 669 /* We need to watch out for .symver directives. See the comment later 670 in this function. */ 671 if (symver_state == NULL) 672 { 673 if ((state == 0 || state == 1) && ch == symver_pseudo[0]) 674 symver_state = symver_pseudo + 1; 675 } 676 else 677 { 678 /* We advance to the next state if we find the right 679 character. */ 680 if (ch != '\0' && (*symver_state == ch)) 681 ++symver_state; 682 else if (*symver_state != '\0') 683 /* We did not get the expected character, or we didn't 684 get a valid terminating character after seeing the 685 entire pseudo-op, so we must go back to the beginning. */ 686 symver_state = NULL; 687 else 688 { 689 /* We've read the entire pseudo-op. If this is the end 690 of the line, go back to the beginning. */ 691 if (IS_NEWLINE (ch)) 692 symver_state = NULL; 693 } 694 } 695#endif /* TC_ARM && OBJ_ELF */ 696 697#ifdef TC_M68K 698 /* We want to have pseudo-ops which control whether we are in 699 MRI mode or not. Unfortunately, since m68k MRI mode affects 700 the scrubber, that means that we need a special purpose 701 recognizer here. */ 702 if (mri_state == NULL) 703 { 704 if ((state == 0 || state == 1) 705 && ch == mri_pseudo[0]) 706 mri_state = mri_pseudo + 1; 707 } 708 else 709 { 710 /* We advance to the next state if we find the right 711 character, or if we need a space character and we get any 712 whitespace character, or if we need a '0' and we get a 713 '1' (this is so that we only need one state to handle 714 ``.mri 0'' and ``.mri 1''). */ 715 if (ch != '\0' 716 && (*mri_state == ch 717 || (*mri_state == ' ' 718 && lex[ch] == LEX_IS_WHITESPACE) 719 || (*mri_state == '0' 720 && ch == '1'))) 721 { 722 mri_last_ch = ch; 723 ++mri_state; 724 } 725 else if (*mri_state != '\0' 726 || (lex[ch] != LEX_IS_WHITESPACE 727 && lex[ch] != LEX_IS_NEWLINE)) 728 { 729 /* We did not get the expected character, or we didn't 730 get a valid terminating character after seeing the 731 entire pseudo-op, so we must go back to the 732 beginning. */ 733 mri_state = NULL; 734 } 735 else 736 { 737 /* We've read the entire pseudo-op. mips_last_ch is 738 either '0' or '1' indicating whether to enter or 739 leave MRI mode. */ 740 do_scrub_begin (mri_last_ch == '1'); 741 mri_state = NULL; 742 743 /* We continue handling the character as usual. The 744 main gas reader must also handle the .mri pseudo-op 745 to control expression parsing and the like. */ 746 } 747 } 748#endif 749 750 if (ch == EOF) 751 { 752 if (state != 0) 753 { 754 as_warn (_("end of file not at end of a line; newline inserted")); 755 state = 0; 756 PUT ('\n'); 757 } 758 goto fromeof; 759 } 760 761 switch (lex[ch]) 762 { 763 case LEX_IS_WHITESPACE: 764 do 765 { 766 ch = GET (); 767 } 768 while (ch != EOF && IS_WHITESPACE (ch)); 769 if (ch == EOF) 770 goto fromeof; 771 772 if (state == 0) 773 { 774 /* Preserve a single whitespace character at the 775 beginning of a line. */ 776 state = 1; 777 UNGET (ch); 778 PUT (' '); 779 break; 780 } 781 782#ifdef KEEP_WHITE_AROUND_COLON 783 if (lex[ch] == LEX_IS_COLON) 784 { 785 /* only keep this white if there's no white *after* the colon */ 786 ch2 = GET (); 787 UNGET (ch2); 788 if (!IS_WHITESPACE (ch2)) 789 { 790 state = 9; 791 UNGET (ch); 792 PUT (' '); 793 break; 794 } 795 } 796#endif 797 if (IS_COMMENT (ch) 798 || ch == '/' 799 || IS_LINE_SEPARATOR (ch)) 800 { 801 if (scrub_m68k_mri) 802 { 803 /* In MRI mode, we keep these spaces. */ 804 UNGET (ch); 805 PUT (' '); 806 break; 807 } 808 goto recycle; 809 } 810 811 /* If we're in state 2 or 11, we've seen a non-white 812 character followed by whitespace. If the next character 813 is ':', this is whitespace after a label name which we 814 normally must ignore. In MRI mode, though, spaces are 815 not permitted between the label and the colon. */ 816 if ((state == 2 || state == 11) 817 && lex[ch] == LEX_IS_COLON 818 && ! scrub_m68k_mri) 819 { 820 state = 1; 821 PUT (ch); 822 break; 823 } 824 825 switch (state) 826 { 827 case 0: 828 state++; 829 goto recycle; /* Punted leading sp */ 830 case 1: 831 /* We can arrive here if we leave a leading whitespace 832 character at the beginning of a line. */ 833 goto recycle; 834 case 2: 835 state = 3; 836 if (to + 1 < toend) 837 { 838 /* Optimize common case by skipping UNGET/GET. */ 839 PUT (' '); /* Sp after opco */ 840 goto recycle; 841 } 842 UNGET (ch); 843 PUT (' '); 844 break; 845 case 3: 846 if (scrub_m68k_mri) 847 { 848 /* In MRI mode, we keep these spaces. */ 849 UNGET (ch); 850 PUT (' '); 851 break; 852 } 853 goto recycle; /* Sp in operands */ 854 case 9: 855 case 10: 856 if (scrub_m68k_mri) 857 { 858 /* In MRI mode, we keep these spaces. */ 859 state = 3; 860 UNGET (ch); 861 PUT (' '); 862 break; 863 } 864 state = 10; /* Sp after symbol char */ 865 goto recycle; 866 case 11: 867 if (LABELS_WITHOUT_COLONS || flag_m68k_mri) 868 state = 1; 869 else 870 { 871 /* We know that ch is not ':', since we tested that 872 case above. Therefore this is not a label, so it 873 must be the opcode, and we've just seen the 874 whitespace after it. */ 875 state = 3; 876 } 877 UNGET (ch); 878 PUT (' '); /* Sp after label definition. */ 879 break; 880 default: 881 BAD_CASE (state); 882 } 883 break; 884 885 case LEX_IS_TWOCHAR_COMMENT_1ST: 886 ch2 = GET (); 887 if (ch2 == '*') 888 { 889 for (;;) 890 { 891 do 892 { 893 ch2 = GET (); 894 if (ch2 != EOF && IS_NEWLINE (ch2)) 895 add_newlines++; 896 } 897 while (ch2 != EOF && ch2 != '*'); 898 899 while (ch2 == '*') 900 ch2 = GET (); 901 902 if (ch2 == EOF || ch2 == '/') 903 break; 904 905 /* This UNGET will ensure that we count newlines 906 correctly. */ 907 UNGET (ch2); 908 } 909 910 if (ch2 == EOF) 911 as_warn (_("end of file in multiline comment")); 912 913 ch = ' '; 914 goto recycle; 915 } 916 else 917 { 918 if (ch2 != EOF) 919 UNGET (ch2); 920 if (state == 9 || state == 10) 921 state = 3; 922 PUT (ch); 923 } 924 break; 925 926 case LEX_IS_STRINGQUOTE: 927 if (state == 10) 928 { 929 /* Preserve the whitespace in foo "bar" */ 930 UNGET (ch); 931 state = 3; 932 PUT (' '); 933 934 /* PUT didn't jump out. We could just break, but we 935 know what will happen, so optimize a bit. */ 936 ch = GET (); 937 old_state = 3; 938 } 939 else if (state == 9) 940 old_state = 3; 941 else 942 old_state = state; 943 state = 5; 944 PUT (ch); 945 break; 946 947#ifndef IEEE_STYLE 948 case LEX_IS_ONECHAR_QUOTE: 949 if (state == 10) 950 { 951 /* Preserve the whitespace in foo 'b' */ 952 UNGET (ch); 953 state = 3; 954 PUT (' '); 955 break; 956 } 957 ch = GET (); 958 if (ch == EOF) 959 { 960 as_warn (_("end of file after a one-character quote; \\0 inserted")); 961 ch = 0; 962 } 963 if (ch == '\\') 964 { 965 ch = GET (); 966 if (ch == EOF) 967 { 968 as_warn (_("end of file in escape character")); 969 ch = '\\'; 970 } 971 else 972 ch = process_escape (ch); 973 } 974 sprintf (out_buf, "%d", (int) (unsigned char) ch); 975 976 /* None of these 'x constants for us. We want 'x'. */ 977 if ((ch = GET ()) != '\'') 978 { 979#ifdef REQUIRE_CHAR_CLOSE_QUOTE 980 as_warn (_("Missing close quote: (assumed)")); 981#else 982 if (ch != EOF) 983 UNGET (ch); 984#endif 985 } 986 if (strlen (out_buf) == 1) 987 { 988 PUT (out_buf[0]); 989 break; 990 } 991 if (state == 9) 992 old_state = 3; 993 else 994 old_state = state; 995 state = -1; 996 out_string = out_buf; 997 PUT (*out_string++); 998 break; 999#endif 1000 1001 case LEX_IS_COLON: 1002#ifdef KEEP_WHITE_AROUND_COLON 1003 state = 9; 1004#else 1005 if (state == 9 || state == 10) 1006 state = 3; 1007 else if (state != 3) 1008 state = 1; 1009#endif 1010 PUT (ch); 1011 break; 1012 1013 case LEX_IS_NEWLINE: 1014 /* Roll out a bunch of newlines from inside comments, etc. */ 1015 if (add_newlines) 1016 { 1017 --add_newlines; 1018 UNGET (ch); 1019 } 1020 /* fall thru into... */ 1021 1022 case LEX_IS_LINE_SEPARATOR: 1023 state = 0; 1024 PUT (ch); 1025 break; 1026 1027#ifdef TC_V850 1028 case LEX_IS_DOUBLEDASH_1ST: 1029 ch2 = GET(); 1030 if (ch2 != '-') 1031 { 1032 UNGET (ch2); 1033 goto de_fault; 1034 } 1035 /* read and skip to end of line */ 1036 do 1037 { 1038 ch = GET (); 1039 } 1040 while (ch != EOF && ch != '\n'); 1041 if (ch == EOF) 1042 { 1043 as_warn (_("end of file in comment; newline inserted")); 1044 } 1045 state = 0; 1046 PUT ('\n'); 1047 break; 1048#endif 1049#ifdef DOUBLEBAR_PARALLEL 1050 case LEX_IS_DOUBLEBAR_1ST: 1051 ch2 = GET(); 1052 if (ch2 != '|') 1053 { 1054 UNGET (ch2); 1055 goto de_fault; 1056 } 1057 /* Reset back to state 1 and pretend that we are parsing a line from 1058 just after the first white space. */ 1059 state = 1; 1060 PUT ('|'); 1061 PUT ('|'); 1062 break; 1063#endif 1064 case LEX_IS_LINE_COMMENT_START: 1065 /* FIXME-someday: The two character comment stuff was badly 1066 thought out. On i386, we want '/' as line comment start 1067 AND we want C style comments. hence this hack. The 1068 whole lexical process should be reworked. xoxorich. */ 1069 if (ch == '/') 1070 { 1071 ch2 = GET (); 1072 if (ch2 == '*') 1073 { 1074 old_state = 3; 1075 state = -2; 1076 break; 1077 } 1078 else 1079 { 1080 UNGET (ch2); 1081 } 1082 } /* bad hack */ 1083 1084 if (state == 0 || state == 1) /* Only comment at start of line. */ 1085 { 1086 int startch; 1087 1088 startch = ch; 1089 1090 do 1091 { 1092 ch = GET (); 1093 } 1094 while (ch != EOF && IS_WHITESPACE (ch)); 1095 if (ch == EOF) 1096 { 1097 as_warn (_("end of file in comment; newline inserted")); 1098 PUT ('\n'); 1099 break; 1100 } 1101 if (ch < '0' || ch > '9' || state != 0 || startch != '#') 1102 { 1103 /* Not a cpp line. */ 1104 while (ch != EOF && !IS_NEWLINE (ch)) 1105 ch = GET (); 1106 if (ch == EOF) 1107 as_warn (_("EOF in Comment: Newline inserted")); 1108 state = 0; 1109 PUT ('\n'); 1110 break; 1111 } 1112 /* Loks like `# 123 "filename"' from cpp. */ 1113 UNGET (ch); 1114 old_state = 4; 1115 state = -1; 1116 if (scrub_m68k_mri) 1117 out_string = "\tappline "; 1118 else 1119 out_string = "\t.appline "; 1120 PUT (*out_string++); 1121 break; 1122 } 1123 1124#ifdef TC_D10V 1125 /* All insns end in a char for which LEX_IS_SYMBOL_COMPONENT is true. 1126 Trap is the only short insn that has a first operand that is 1127 neither register nor label. 1128 We must prevent exef0f ||trap #1 to degenerate to exef0f ||trap#1 . 1129 We can't make '#' LEX_IS_SYMBOL_COMPONENT because it is already 1130 LEX_IS_LINE_COMMENT_START. However, it is the only character in 1131 line_comment_chars for d10v, hence we can recognize it as such. */ 1132 /* An alternative approach would be to reset the state to 1 when 1133 we see '||', '<'- or '->', but that seems to be overkill. */ 1134 if (state == 10) PUT (' '); 1135#endif 1136 /* We have a line comment character which is not at the 1137 start of a line. If this is also a normal comment 1138 character, fall through. Otherwise treat it as a default 1139 character. */ 1140 if (strchr (tc_comment_chars, ch) == NULL 1141 && (! scrub_m68k_mri 1142 || (ch != '!' && ch != '*'))) 1143 goto de_fault; 1144 if (scrub_m68k_mri 1145 && (ch == '!' || ch == '*' || ch == '#') 1146 && state != 1 1147 && state != 10) 1148 goto de_fault; 1149 /* Fall through. */ 1150 case LEX_IS_COMMENT_START: 1151#if defined TC_ARM && defined OBJ_ELF 1152 /* On the ARM, `@' is the comment character. 1153 Unfortunately this is also a special character in ELF .symver 1154 directives (and .type, though we deal with those another way). So 1155 we check if this line is such a directive, and treat the character 1156 as default if so. This is a hack. */ 1157 if ((symver_state != NULL) && (*symver_state == 0)) 1158 goto de_fault; 1159#endif 1160 do 1161 { 1162 ch = GET (); 1163 } 1164 while (ch != EOF && !IS_NEWLINE (ch)); 1165 if (ch == EOF) 1166 as_warn (_("end of file in comment; newline inserted")); 1167 state = 0; 1168 PUT ('\n'); 1169 break; 1170 1171 case LEX_IS_SYMBOL_COMPONENT: 1172 if (state == 10) 1173 { 1174 /* This is a symbol character following another symbol 1175 character, with whitespace in between. We skipped 1176 the whitespace earlier, so output it now. */ 1177 UNGET (ch); 1178 state = 3; 1179 PUT (' '); 1180 break; 1181 } 1182 1183 if (state == 3) 1184 state = 9; 1185 1186 /* This is a common case. Quickly copy CH and all the 1187 following symbol component or normal characters. */ 1188 if (to + 1 < toend 1189 && mri_state == NULL 1190#if defined TC_ARM && defined OBJ_ELF 1191 && symver_state == NULL 1192#endif 1193 ) 1194 { 1195 char *s; 1196 int len; 1197 1198 for (s = from; s < fromend; s++) 1199 { 1200 int type; 1201 1202 ch2 = * (unsigned char *) s; 1203 type = lex[ch2]; 1204 if (type != 0 1205 && type != LEX_IS_SYMBOL_COMPONENT) 1206 break; 1207 } 1208 if (s > from) 1209 { 1210 /* Handle the last character normally, for 1211 simplicity. */ 1212 --s; 1213 } 1214 len = s - from; 1215 if (len > (toend - to) - 1) 1216 len = (toend - to) - 1; 1217 if (len > 0) 1218 { 1219 PUT (ch); 1220 if (len > 8) 1221 { 1222 memcpy (to, from, len); 1223 to += len; 1224 from += len; 1225 } 1226 else 1227 { 1228 switch (len) 1229 { 1230 case 8: *to++ = *from++; 1231 case 7: *to++ = *from++; 1232 case 6: *to++ = *from++; 1233 case 5: *to++ = *from++; 1234 case 4: *to++ = *from++; 1235 case 3: *to++ = *from++; 1236 case 2: *to++ = *from++; 1237 case 1: *to++ = *from++; 1238 } 1239 } 1240 ch = GET (); 1241 } 1242 } 1243 1244 /* Fall through. */ 1245 default: 1246 de_fault: 1247 /* Some relatively `normal' character. */ 1248 if (state == 0) 1249 { 1250 state = 11; /* Now seeing label definition */ 1251 } 1252 else if (state == 1) 1253 { 1254 state = 2; /* Ditto */ 1255 } 1256 else if (state == 9) 1257 { 1258 if (lex[ch] != LEX_IS_SYMBOL_COMPONENT) 1259 state = 3; 1260 } 1261 else if (state == 10) 1262 { 1263 if (ch == '\\') 1264 { 1265 /* Special handling for backslash: a backslash may 1266 be the beginning of a formal parameter (of a 1267 macro) following another symbol character, with 1268 whitespace in between. If that is the case, we 1269 output a space before the parameter. Strictly 1270 speaking, correct handling depends upon what the 1271 macro parameter expands into; if the parameter 1272 expands into something which does not start with 1273 an operand character, then we don't want to keep 1274 the space. We don't have enough information to 1275 make the right choice, so here we are making the 1276 choice which is more likely to be correct. */ 1277 PUT (' '); 1278 } 1279 1280 state = 3; 1281 } 1282 PUT (ch); 1283 break; 1284 } 1285 } 1286 1287 /*NOTREACHED*/ 1288 1289 fromeof: 1290 /* We have reached the end of the input. */ 1291 return to - tostart; 1292 1293 tofull: 1294 /* The output buffer is full. Save any input we have not yet 1295 processed. */ 1296 if (fromend > from) 1297 { 1298 saved_input = from; 1299 saved_input_len = fromend - from; 1300 } 1301 else 1302 saved_input = NULL; 1303 1304 return to - tostart; 1305} 1306 1307/* end of app.c */ 1308