1/* Separate lexical analyzer for GNU C++. 2 Copyright (C) 1987-2015 Free Software Foundation, Inc. 3 Hacked by Michael Tiemann (tiemann@cygnus.com) 4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify 8it under the terms of the GNU General Public License as published by 9the Free Software Foundation; either version 3, or (at your option) 10any later version. 11 12GCC is distributed in the hope that it will be useful, 13but WITHOUT ANY WARRANTY; without even the implied warranty of 14MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 15GNU General Public License for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING3. If not see 19<http://www.gnu.org/licenses/>. */ 20 21 22/* This file is the lexical analyzer for GNU C++. */ 23 24#include "config.h" 25#include "system.h" 26#include "coretypes.h" 27#include "tm.h" 28#include "input.h" 29#include "hash-set.h" 30#include "machmode.h" 31#include "vec.h" 32#include "double-int.h" 33#include "input.h" 34#include "alias.h" 35#include "symtab.h" 36#include "wide-int.h" 37#include "inchash.h" 38#include "tree.h" 39#include "stringpool.h" 40#include "cp-tree.h" 41#include "cpplib.h" 42#include "flags.h" 43#include "c-family/c-pragma.h" 44#include "c-family/c-objc.h" 45#include "tm_p.h" 46#include "timevar.h" 47 48static int interface_strcmp (const char *); 49static void init_cp_pragma (void); 50 51static tree parse_strconst_pragma (const char *, int); 52static void handle_pragma_vtable (cpp_reader *); 53static void handle_pragma_unit (cpp_reader *); 54static void handle_pragma_interface (cpp_reader *); 55static void handle_pragma_implementation (cpp_reader *); 56static void handle_pragma_java_exceptions (cpp_reader *); 57 58static void init_operators (void); 59static void copy_lang_type (tree); 60 61/* A constraint that can be tested at compile time. */ 62#define CONSTRAINT(name, expr) extern int constraint_##name [(expr) ? 1 : -1] 63 64/* Functions and data structures for #pragma interface. 65 66 `#pragma implementation' means that the main file being compiled 67 is considered to implement (provide) the classes that appear in 68 its main body. I.e., if this is file "foo.cc", and class `bar' 69 is defined in "foo.cc", then we say that "foo.cc implements bar". 70 71 All main input files "implement" themselves automagically. 72 73 `#pragma interface' means that unless this file (of the form "foo.h" 74 is not presently being included by file "foo.cc", the 75 CLASSTYPE_INTERFACE_ONLY bit gets set. The effect is that none 76 of the vtables nor any of the inline functions defined in foo.h 77 will ever be output. 78 79 There are cases when we want to link files such as "defs.h" and 80 "main.cc". In this case, we give "defs.h" a `#pragma interface', 81 and "main.cc" has `#pragma implementation "defs.h"'. */ 82 83struct impl_files 84{ 85 const char *filename; 86 struct impl_files *next; 87}; 88 89static struct impl_files *impl_file_chain; 90 91/* True if we saw "#pragma GCC java_exceptions". */ 92bool pragma_java_exceptions; 93 94void 95cxx_finish (void) 96{ 97 c_common_finish (); 98} 99 100/* A mapping from tree codes to operator name information. */ 101operator_name_info_t operator_name_info[(int) MAX_TREE_CODES]; 102/* Similar, but for assignment operators. */ 103operator_name_info_t assignment_operator_name_info[(int) MAX_TREE_CODES]; 104 105/* Initialize data structures that keep track of operator names. */ 106 107#define DEF_OPERATOR(NAME, C, M, AR, AP) \ 108 CONSTRAINT (C, sizeof "operator " + sizeof NAME <= 256); 109#include "operators.def" 110#undef DEF_OPERATOR 111 112static void 113init_operators (void) 114{ 115 tree identifier; 116 char buffer[256]; 117 struct operator_name_info_t *oni; 118 119#define DEF_OPERATOR(NAME, CODE, MANGLING, ARITY, ASSN_P) \ 120 sprintf (buffer, ISALPHA (NAME[0]) ? "operator %s" : "operator%s", NAME); \ 121 identifier = get_identifier (buffer); \ 122 IDENTIFIER_OPNAME_P (identifier) = 1; \ 123 \ 124 oni = (ASSN_P \ 125 ? &assignment_operator_name_info[(int) CODE] \ 126 : &operator_name_info[(int) CODE]); \ 127 oni->identifier = identifier; \ 128 oni->name = NAME; \ 129 oni->mangled_name = MANGLING; \ 130 oni->arity = ARITY; 131 132#include "operators.def" 133#undef DEF_OPERATOR 134 135 operator_name_info[(int) ERROR_MARK].identifier 136 = get_identifier ("<invalid operator>"); 137 138 /* Handle some special cases. These operators are not defined in 139 the language, but can be produced internally. We may need them 140 for error-reporting. (Eventually, we should ensure that this 141 does not happen. Error messages involving these operators will 142 be confusing to users.) */ 143 144 operator_name_info [(int) INIT_EXPR].name 145 = operator_name_info [(int) MODIFY_EXPR].name; 146 operator_name_info [(int) EXACT_DIV_EXPR].name = "(ceiling /)"; 147 operator_name_info [(int) CEIL_DIV_EXPR].name = "(ceiling /)"; 148 operator_name_info [(int) FLOOR_DIV_EXPR].name = "(floor /)"; 149 operator_name_info [(int) ROUND_DIV_EXPR].name = "(round /)"; 150 operator_name_info [(int) CEIL_MOD_EXPR].name = "(ceiling %)"; 151 operator_name_info [(int) FLOOR_MOD_EXPR].name = "(floor %)"; 152 operator_name_info [(int) ROUND_MOD_EXPR].name = "(round %)"; 153 operator_name_info [(int) ABS_EXPR].name = "abs"; 154 operator_name_info [(int) TRUTH_AND_EXPR].name = "strict &&"; 155 operator_name_info [(int) TRUTH_OR_EXPR].name = "strict ||"; 156 operator_name_info [(int) RANGE_EXPR].name = "..."; 157 operator_name_info [(int) UNARY_PLUS_EXPR].name = "+"; 158 159 assignment_operator_name_info [(int) EXACT_DIV_EXPR].name 160 = "(exact /=)"; 161 assignment_operator_name_info [(int) CEIL_DIV_EXPR].name 162 = "(ceiling /=)"; 163 assignment_operator_name_info [(int) FLOOR_DIV_EXPR].name 164 = "(floor /=)"; 165 assignment_operator_name_info [(int) ROUND_DIV_EXPR].name 166 = "(round /=)"; 167 assignment_operator_name_info [(int) CEIL_MOD_EXPR].name 168 = "(ceiling %=)"; 169 assignment_operator_name_info [(int) FLOOR_MOD_EXPR].name 170 = "(floor %=)"; 171 assignment_operator_name_info [(int) ROUND_MOD_EXPR].name 172 = "(round %=)"; 173} 174 175/* Initialize the reserved words. */ 176 177void 178init_reswords (void) 179{ 180 unsigned int i; 181 tree id; 182 int mask = 0; 183 184 if (cxx_dialect < cxx11) 185 mask |= D_CXX0X; 186 if (flag_no_asm) 187 mask |= D_ASM | D_EXT; 188 if (flag_no_gnu_keywords) 189 mask |= D_EXT; 190 191 /* The Objective-C keywords are all context-dependent. */ 192 mask |= D_OBJC; 193 194 ridpointers = ggc_cleared_vec_alloc<tree> ((int) RID_MAX); 195 for (i = 0; i < num_c_common_reswords; i++) 196 { 197 if (c_common_reswords[i].disable & D_CONLY) 198 continue; 199 id = get_identifier (c_common_reswords[i].word); 200 C_SET_RID_CODE (id, c_common_reswords[i].rid); 201 ridpointers [(int) c_common_reswords[i].rid] = id; 202 if (! (c_common_reswords[i].disable & mask)) 203 C_IS_RESERVED_WORD (id) = 1; 204 } 205 206 for (i = 0; i < NUM_INT_N_ENTS; i++) 207 { 208 char name[50]; 209 sprintf (name, "__int%d", int_n_data[i].bitsize); 210 id = get_identifier (name); 211 C_SET_RID_CODE (id, RID_FIRST_INT_N + i); 212 C_IS_RESERVED_WORD (id) = 1; 213 } 214} 215 216static void 217init_cp_pragma (void) 218{ 219 c_register_pragma (0, "vtable", handle_pragma_vtable); 220 c_register_pragma (0, "unit", handle_pragma_unit); 221 c_register_pragma (0, "interface", handle_pragma_interface); 222 c_register_pragma (0, "implementation", handle_pragma_implementation); 223 c_register_pragma ("GCC", "interface", handle_pragma_interface); 224 c_register_pragma ("GCC", "implementation", handle_pragma_implementation); 225 c_register_pragma ("GCC", "java_exceptions", handle_pragma_java_exceptions); 226} 227 228/* TRUE if a code represents a statement. */ 229 230bool statement_code_p[MAX_TREE_CODES]; 231 232/* Initialize the C++ front end. This function is very sensitive to 233 the exact order that things are done here. It would be nice if the 234 initialization done by this routine were moved to its subroutines, 235 and the ordering dependencies clarified and reduced. */ 236bool 237cxx_init (void) 238{ 239 location_t saved_loc; 240 unsigned int i; 241 static const enum tree_code stmt_codes[] = { 242 CTOR_INITIALIZER, TRY_BLOCK, HANDLER, 243 EH_SPEC_BLOCK, USING_STMT, TAG_DEFN, 244 IF_STMT, CLEANUP_STMT, FOR_STMT, 245 RANGE_FOR_STMT, WHILE_STMT, DO_STMT, 246 BREAK_STMT, CONTINUE_STMT, SWITCH_STMT, 247 EXPR_STMT 248 }; 249 250 memset (&statement_code_p, 0, sizeof (statement_code_p)); 251 for (i = 0; i < ARRAY_SIZE (stmt_codes); i++) 252 statement_code_p[stmt_codes[i]] = true; 253 254 saved_loc = input_location; 255 input_location = BUILTINS_LOCATION; 256 257 init_reswords (); 258 init_tree (); 259 init_cp_semantics (); 260 init_operators (); 261 init_method (); 262 init_error (); 263 264 current_function_decl = NULL; 265 266 class_type_node = ridpointers[(int) RID_CLASS]; 267 268 cxx_init_decl_processing (); 269 270 if (c_common_init () == false) 271 { 272 input_location = saved_loc; 273 return false; 274 } 275 276 init_cp_pragma (); 277 278 init_repo (); 279 280 input_location = saved_loc; 281 return true; 282} 283 284/* Return nonzero if S is not considered part of an 285 INTERFACE/IMPLEMENTATION pair. Otherwise, return 0. */ 286 287static int 288interface_strcmp (const char* s) 289{ 290 /* Set the interface/implementation bits for this scope. */ 291 struct impl_files *ifiles; 292 const char *s1; 293 294 for (ifiles = impl_file_chain; ifiles; ifiles = ifiles->next) 295 { 296 const char *t1 = ifiles->filename; 297 s1 = s; 298 299 if (*s1 == 0 || filename_ncmp (s1, t1, 1) != 0) 300 continue; 301 302 while (*s1 != 0 && filename_ncmp (s1, t1, 1) == 0) 303 s1++, t1++; 304 305 /* A match. */ 306 if (*s1 == *t1) 307 return 0; 308 309 /* Don't get faked out by xxx.yyy.cc vs xxx.zzz.cc. */ 310 if (strchr (s1, '.') || strchr (t1, '.')) 311 continue; 312 313 if (*s1 == '\0' || s1[-1] != '.' || t1[-1] != '.') 314 continue; 315 316 /* A match. */ 317 return 0; 318 } 319 320 /* No matches. */ 321 return 1; 322} 323 324 325 326/* Parse a #pragma whose sole argument is a string constant. 327 If OPT is true, the argument is optional. */ 328static tree 329parse_strconst_pragma (const char* name, int opt) 330{ 331 tree result, x; 332 enum cpp_ttype t; 333 334 t = pragma_lex (&result); 335 if (t == CPP_STRING) 336 { 337 if (pragma_lex (&x) != CPP_EOF) 338 warning (0, "junk at end of #pragma %s", name); 339 return result; 340 } 341 342 if (t == CPP_EOF && opt) 343 return NULL_TREE; 344 345 error ("invalid #pragma %s", name); 346 return error_mark_node; 347} 348 349static void 350handle_pragma_vtable (cpp_reader* /*dfile*/) 351{ 352 parse_strconst_pragma ("vtable", 0); 353 sorry ("#pragma vtable no longer supported"); 354} 355 356static void 357handle_pragma_unit (cpp_reader* /*dfile*/) 358{ 359 /* Validate syntax, but don't do anything. */ 360 parse_strconst_pragma ("unit", 0); 361} 362 363static void 364handle_pragma_interface (cpp_reader* /*dfile*/) 365{ 366 tree fname = parse_strconst_pragma ("interface", 1); 367 struct c_fileinfo *finfo; 368 const char *filename; 369 370 if (fname == error_mark_node) 371 return; 372 else if (fname == 0) 373 filename = lbasename (LOCATION_FILE (input_location)); 374 else 375 filename = TREE_STRING_POINTER (fname); 376 377 finfo = get_fileinfo (LOCATION_FILE (input_location)); 378 379 if (impl_file_chain == 0) 380 { 381 /* If this is zero at this point, then we are 382 auto-implementing. */ 383 if (main_input_filename == 0) 384 main_input_filename = LOCATION_FILE (input_location); 385 } 386 387 finfo->interface_only = interface_strcmp (filename); 388 /* If MULTIPLE_SYMBOL_SPACES is set, we cannot assume that we can see 389 a definition in another file. */ 390 if (!MULTIPLE_SYMBOL_SPACES || !finfo->interface_only) 391 finfo->interface_unknown = 0; 392} 393 394/* Note that we have seen a #pragma implementation for the key MAIN_FILENAME. 395 We used to only allow this at toplevel, but that restriction was buggy 396 in older compilers and it seems reasonable to allow it in the headers 397 themselves, too. It only needs to precede the matching #p interface. 398 399 We don't touch finfo->interface_only or finfo->interface_unknown; 400 the user must specify a matching #p interface for this to have 401 any effect. */ 402 403static void 404handle_pragma_implementation (cpp_reader* /*dfile*/) 405{ 406 tree fname = parse_strconst_pragma ("implementation", 1); 407 const char *filename; 408 struct impl_files *ifiles = impl_file_chain; 409 410 if (fname == error_mark_node) 411 return; 412 413 if (fname == 0) 414 { 415 if (main_input_filename) 416 filename = main_input_filename; 417 else 418 filename = LOCATION_FILE (input_location); 419 filename = lbasename (filename); 420 } 421 else 422 { 423 filename = TREE_STRING_POINTER (fname); 424 if (cpp_included_before (parse_in, filename, input_location)) 425 warning (0, "#pragma implementation for %qs appears after " 426 "file is included", filename); 427 } 428 429 for (; ifiles; ifiles = ifiles->next) 430 { 431 if (! filename_cmp (ifiles->filename, filename)) 432 break; 433 } 434 if (ifiles == 0) 435 { 436 ifiles = XNEW (struct impl_files); 437 ifiles->filename = xstrdup (filename); 438 ifiles->next = impl_file_chain; 439 impl_file_chain = ifiles; 440 } 441} 442 443/* Indicate that this file uses Java-personality exception handling. */ 444static void 445handle_pragma_java_exceptions (cpp_reader* /*dfile*/) 446{ 447 tree x; 448 if (pragma_lex (&x) != CPP_EOF) 449 warning (0, "junk at end of #pragma GCC java_exceptions"); 450 451 choose_personality_routine (lang_java); 452 pragma_java_exceptions = true; 453} 454 455/* Issue an error message indicating that the lookup of NAME (an 456 IDENTIFIER_NODE) failed. Returns the ERROR_MARK_NODE. */ 457 458tree 459unqualified_name_lookup_error (tree name) 460{ 461 if (IDENTIFIER_OPNAME_P (name)) 462 { 463 if (name != ansi_opname (ERROR_MARK)) 464 error ("%qD not defined", name); 465 } 466 else 467 { 468 if (!objc_diagnose_private_ivar (name)) 469 { 470 error ("%qD was not declared in this scope", name); 471 suggest_alternatives_for (location_of (name), name); 472 } 473 /* Prevent repeated error messages by creating a VAR_DECL with 474 this NAME in the innermost block scope. */ 475 if (local_bindings_p ()) 476 { 477 tree decl; 478 decl = build_decl (input_location, 479 VAR_DECL, name, error_mark_node); 480 DECL_CONTEXT (decl) = current_function_decl; 481 push_local_binding (name, decl, 0); 482 /* Mark the variable as used so that we do not get warnings 483 about it being unused later. */ 484 TREE_USED (decl) = 1; 485 } 486 } 487 488 return error_mark_node; 489} 490 491/* Like unqualified_name_lookup_error, but NAME is an unqualified-id 492 used as a function. Returns an appropriate expression for 493 NAME. */ 494 495tree 496unqualified_fn_lookup_error (tree name) 497{ 498 if (processing_template_decl) 499 { 500 /* In a template, it is invalid to write "f()" or "f(3)" if no 501 declaration of "f" is available. Historically, G++ and most 502 other compilers accepted that usage since they deferred all name 503 lookup until instantiation time rather than doing unqualified 504 name lookup at template definition time; explain to the user what 505 is going wrong. 506 507 Note that we have the exact wording of the following message in 508 the manual (trouble.texi, node "Name lookup"), so they need to 509 be kept in synch. */ 510 permerror (input_location, "there are no arguments to %qD that depend on a template " 511 "parameter, so a declaration of %qD must be available", 512 name, name); 513 514 if (!flag_permissive) 515 { 516 static bool hint; 517 if (!hint) 518 { 519 inform (input_location, "(if you use %<-fpermissive%>, G++ will accept your " 520 "code, but allowing the use of an undeclared name is " 521 "deprecated)"); 522 hint = true; 523 } 524 } 525 return name; 526 } 527 528 return unqualified_name_lookup_error (name); 529} 530 531/* Wrapper around build_lang_decl_loc(). Should gradually move to 532 build_lang_decl_loc() and then rename build_lang_decl_loc() back to 533 build_lang_decl(). */ 534 535tree 536build_lang_decl (enum tree_code code, tree name, tree type) 537{ 538 return build_lang_decl_loc (input_location, code, name, type); 539} 540 541/* Build a decl from CODE, NAME, TYPE declared at LOC, and then add 542 DECL_LANG_SPECIFIC info to the result. */ 543 544tree 545build_lang_decl_loc (location_t loc, enum tree_code code, tree name, tree type) 546{ 547 tree t; 548 549 t = build_decl (loc, code, name, type); 550 retrofit_lang_decl (t); 551 552 return t; 553} 554 555/* Add DECL_LANG_SPECIFIC info to T. Called from build_lang_decl 556 and pushdecl (for functions generated by the back end). */ 557 558void 559retrofit_lang_decl (tree t) 560{ 561 struct lang_decl *ld; 562 size_t size; 563 int sel; 564 565 if (TREE_CODE (t) == FUNCTION_DECL) 566 sel = 1, size = sizeof (struct lang_decl_fn); 567 else if (TREE_CODE (t) == NAMESPACE_DECL) 568 sel = 2, size = sizeof (struct lang_decl_ns); 569 else if (TREE_CODE (t) == PARM_DECL) 570 sel = 3, size = sizeof (struct lang_decl_parm); 571 else if (LANG_DECL_HAS_MIN (t)) 572 sel = 0, size = sizeof (struct lang_decl_min); 573 else 574 gcc_unreachable (); 575 576 ld = (struct lang_decl *) ggc_internal_cleared_alloc (size); 577 578 ld->u.base.selector = sel; 579 580 DECL_LANG_SPECIFIC (t) = ld; 581 if (current_lang_name == lang_name_cplusplus 582 || decl_linkage (t) == lk_none) 583 SET_DECL_LANGUAGE (t, lang_cplusplus); 584 else if (current_lang_name == lang_name_c) 585 SET_DECL_LANGUAGE (t, lang_c); 586 else if (current_lang_name == lang_name_java) 587 SET_DECL_LANGUAGE (t, lang_java); 588 else 589 gcc_unreachable (); 590 591 if (GATHER_STATISTICS) 592 { 593 tree_node_counts[(int)lang_decl] += 1; 594 tree_node_sizes[(int)lang_decl] += size; 595 } 596} 597 598void 599cxx_dup_lang_specific_decl (tree node) 600{ 601 int size; 602 struct lang_decl *ld; 603 604 if (! DECL_LANG_SPECIFIC (node)) 605 return; 606 607 if (TREE_CODE (node) == FUNCTION_DECL) 608 size = sizeof (struct lang_decl_fn); 609 else if (TREE_CODE (node) == NAMESPACE_DECL) 610 size = sizeof (struct lang_decl_ns); 611 else if (TREE_CODE (node) == PARM_DECL) 612 size = sizeof (struct lang_decl_parm); 613 else if (LANG_DECL_HAS_MIN (node)) 614 size = sizeof (struct lang_decl_min); 615 else 616 gcc_unreachable (); 617 618 ld = (struct lang_decl *) ggc_internal_alloc (size); 619 memcpy (ld, DECL_LANG_SPECIFIC (node), size); 620 DECL_LANG_SPECIFIC (node) = ld; 621 622 if (GATHER_STATISTICS) 623 { 624 tree_node_counts[(int)lang_decl] += 1; 625 tree_node_sizes[(int)lang_decl] += size; 626 } 627} 628 629/* Copy DECL, including any language-specific parts. */ 630 631tree 632copy_decl (tree decl) 633{ 634 tree copy; 635 636 copy = copy_node (decl); 637 cxx_dup_lang_specific_decl (copy); 638 return copy; 639} 640 641/* Replace the shared language-specific parts of NODE with a new copy. */ 642 643static void 644copy_lang_type (tree node) 645{ 646 int size; 647 struct lang_type *lt; 648 649 if (! TYPE_LANG_SPECIFIC (node)) 650 return; 651 652 if (TYPE_LANG_SPECIFIC (node)->u.h.is_lang_type_class) 653 size = sizeof (struct lang_type); 654 else 655 size = sizeof (struct lang_type_ptrmem); 656 lt = (struct lang_type *) ggc_internal_alloc (size); 657 memcpy (lt, TYPE_LANG_SPECIFIC (node), size); 658 TYPE_LANG_SPECIFIC (node) = lt; 659 660 if (GATHER_STATISTICS) 661 { 662 tree_node_counts[(int)lang_type] += 1; 663 tree_node_sizes[(int)lang_type] += size; 664 } 665} 666 667/* Copy TYPE, including any language-specific parts. */ 668 669tree 670copy_type (tree type) 671{ 672 tree copy; 673 674 copy = copy_node (type); 675 copy_lang_type (copy); 676 return copy; 677} 678 679tree 680cxx_make_type (enum tree_code code) 681{ 682 tree t = make_node (code); 683 684 /* Create lang_type structure. */ 685 if (RECORD_OR_UNION_CODE_P (code) 686 || code == BOUND_TEMPLATE_TEMPLATE_PARM) 687 { 688 struct lang_type *pi 689 = (struct lang_type *) ggc_internal_cleared_alloc 690 (sizeof (struct lang_type)); 691 692 TYPE_LANG_SPECIFIC (t) = pi; 693 pi->u.c.h.is_lang_type_class = 1; 694 695 if (GATHER_STATISTICS) 696 { 697 tree_node_counts[(int)lang_type] += 1; 698 tree_node_sizes[(int)lang_type] += sizeof (struct lang_type); 699 } 700 } 701 702 /* Set up some flags that give proper default behavior. */ 703 if (RECORD_OR_UNION_CODE_P (code)) 704 { 705 struct c_fileinfo *finfo = \ 706 get_fileinfo (LOCATION_FILE (input_location)); 707 SET_CLASSTYPE_INTERFACE_UNKNOWN_X (t, finfo->interface_unknown); 708 CLASSTYPE_INTERFACE_ONLY (t) = finfo->interface_only; 709 } 710 711 return t; 712} 713 714tree 715make_class_type (enum tree_code code) 716{ 717 tree t = cxx_make_type (code); 718 SET_CLASS_TYPE_P (t, 1); 719 return t; 720} 721 722/* Returns true if we are currently in the main source file, or in a 723 template instantiation started from the main source file. */ 724 725bool 726in_main_input_context (void) 727{ 728 struct tinst_level *tl = outermost_tinst_level(); 729 730 if (tl) 731 return filename_cmp (main_input_filename, 732 LOCATION_FILE (tl->locus)) == 0; 733 else 734 return filename_cmp (main_input_filename, LOCATION_FILE (input_location)) == 0; 735} 736