![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to c-common.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [GCC 2.x] / gcc|
Return to c-common.c CVS log | Up to [GCC 2.x] / gcc |
1.1 root 1: /* Subroutines shared by all languages that are variants of C. 1.1.1.5 ! root 2: Copyright (C) 1992, 1993 Free Software Foundation, Inc. 1.1 root 3: 4: This file is part of GNU CC. 5: 6: GNU CC is free software; you can redistribute it and/or modify 7: it under the terms of the GNU General Public License as published by 8: the Free Software Foundation; either version 2, or (at your option) 9: any later version. 10: 11: GNU CC is distributed in the hope that it will be useful, 12: but WITHOUT ANY WARRANTY; without even the implied warranty of 13: MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14: GNU General Public License for more details. 15: 16: You should have received a copy of the GNU General Public License 17: along with GNU CC; see the file COPYING. If not, write to 18: the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */ 19: 20: #include "config.h" 21: #include "tree.h" 22: #include "c-lex.h" 23: #include "c-tree.h" 24: #include "flags.h" 1.1.1.4 root 25: #include "obstack.h" 1.1 root 26: #include <stdio.h> 1.1.1.5 ! root 27: #include <ctype.h> 1.1 root 28: 1.1.1.4 root 29: extern struct obstack permanent_obstack; 30: 1.1.1.5 ! root 31: static void declare_hidden_char_array PROTO((char *, char *)); ! 32: 1.1.1.2 root 33: /* Make bindings for __FUNCTION__ and __PRETTY_FUNCTION__. */ 34: 35: void 36: declare_function_name () 37: { 38: char *name, *printable_name; 39: 40: if (current_function_decl == NULL) 41: { 42: name = ""; 43: printable_name = "top level"; 44: } 45: else 46: { 47: char *kind = "function"; 48: if (TREE_CODE (TREE_TYPE (current_function_decl)) == METHOD_TYPE) 49: kind = "method"; 1.1.1.3 root 50: /* Allow functions to be nameless (such as artificial ones). */ 51: if (DECL_NAME (current_function_decl)) 52: name = IDENTIFIER_POINTER (DECL_NAME (current_function_decl)); 53: else 54: name = ""; 1.1.1.2 root 55: printable_name = (*decl_printable_name) (current_function_decl, &kind); 56: } 57: 1.1.1.5 ! root 58: declare_hidden_char_array ("__FUNCTION__", name); ! 59: declare_hidden_char_array ("__PRETTY_FUNCTION__", printable_name); ! 60: } 1.1.1.4 root 61: 1.1.1.5 ! root 62: static void ! 63: declare_hidden_char_array (name, value) ! 64: char *name, *value; ! 65: { ! 66: tree decl, type, init; ! 67: int vlen; 1.1.1.2 root 68: 1.1.1.5 ! root 69: /* If the default size of char arrays isn't big enough for the name, ! 70: make a bigger one. */ ! 71: vlen = strlen (value) + 1; 1.1.1.4 root 72: type = char_array_type_node; 1.1.1.5 ! root 73: if (TREE_INT_CST_LOW (TYPE_MAX_VALUE (TREE_TYPE (type))) < vlen) 1.1.1.4 root 74: type = build_array_type (char_type_node, 1.1.1.5 ! root 75: build_index_type (build_int_2 (vlen, 0))); 1.1.1.4 root 76: 1.1.1.2 root 77: push_obstacks_nochange (); 1.1.1.5 ! root 78: decl = build_decl (VAR_DECL, get_identifier (name), type); 1.1.1.2 root 79: TREE_STATIC (decl) = 1; 80: TREE_READONLY (decl) = 1; 1.1.1.5 ! root 81: TREE_ASM_WRITTEN (decl) = 1; 1.1.1.3 root 82: DECL_SOURCE_LINE (decl) = 0; 83: DECL_IN_SYSTEM_HEADER (decl) = 1; 1.1.1.2 root 84: DECL_IGNORED_P (decl) = 1; 1.1.1.5 ! root 85: init = build_string (vlen, value); 1.1.1.4 root 86: TREE_TYPE (init) = type; 1.1.1.2 root 87: DECL_INITIAL (decl) = init; 88: finish_decl (pushdecl (decl), init, NULL_TREE); 89: } 90: 1.1 root 91: /* Given a chain of STRING_CST nodes, 92: concatenate them into one STRING_CST 93: and give it a suitable array-of-chars data type. */ 94: 95: tree 96: combine_strings (strings) 97: tree strings; 98: { 99: register tree value, t; 100: register int length = 1; 101: int wide_length = 0; 102: int wide_flag = 0; 103: int wchar_bytes = TYPE_PRECISION (wchar_type_node) / BITS_PER_UNIT; 104: int nchars; 105: 106: if (TREE_CHAIN (strings)) 107: { 108: /* More than one in the chain, so concatenate. */ 109: register char *p, *q; 110: 111: /* Don't include the \0 at the end of each substring, 112: except for the last one. 113: Count wide strings and ordinary strings separately. */ 114: for (t = strings; t; t = TREE_CHAIN (t)) 115: { 116: if (TREE_TYPE (t) == wchar_array_type_node) 117: { 118: wide_length += (TREE_STRING_LENGTH (t) - wchar_bytes); 119: wide_flag = 1; 120: } 121: else 122: length += (TREE_STRING_LENGTH (t) - 1); 123: } 124: 125: /* If anything is wide, the non-wides will be converted, 126: which makes them take more space. */ 127: if (wide_flag) 128: length = length * wchar_bytes + wide_length; 129: 130: p = savealloc (length); 131: 132: /* Copy the individual strings into the new combined string. 133: If the combined string is wide, convert the chars to ints 134: for any individual strings that are not wide. */ 135: 136: q = p; 137: for (t = strings; t; t = TREE_CHAIN (t)) 138: { 139: int len = (TREE_STRING_LENGTH (t) 140: - ((TREE_TYPE (t) == wchar_array_type_node) 141: ? wchar_bytes : 1)); 142: if ((TREE_TYPE (t) == wchar_array_type_node) == wide_flag) 143: { 144: bcopy (TREE_STRING_POINTER (t), q, len); 145: q += len; 146: } 147: else 148: { 149: int i; 150: for (i = 0; i < len; i++) 151: ((int *) q)[i] = TREE_STRING_POINTER (t)[i]; 152: q += len * wchar_bytes; 153: } 154: } 155: if (wide_flag) 156: { 157: int i; 158: for (i = 0; i < wchar_bytes; i++) 159: *q++ = 0; 160: } 161: else 162: *q = 0; 163: 164: value = make_node (STRING_CST); 165: TREE_STRING_POINTER (value) = p; 166: TREE_STRING_LENGTH (value) = length; 167: TREE_CONSTANT (value) = 1; 168: } 169: else 170: { 171: value = strings; 172: length = TREE_STRING_LENGTH (value); 173: if (TREE_TYPE (value) == wchar_array_type_node) 174: wide_flag = 1; 175: } 176: 177: /* Compute the number of elements, for the array type. */ 178: nchars = wide_flag ? length / wchar_bytes : length; 179: 180: /* Create the array type for the string constant. 181: -Wwrite-strings says make the string constant an array of const char 182: so that copying it to a non-const pointer will get a warning. */ 183: if (warn_write_strings 184: && (! flag_traditional && ! flag_writable_strings)) 185: { 186: tree elements 187: = build_type_variant (wide_flag ? wchar_type_node : char_type_node, 188: 1, 0); 189: TREE_TYPE (value) 190: = build_array_type (elements, 191: build_index_type (build_int_2 (nchars - 1, 0))); 192: } 193: else 194: TREE_TYPE (value) 195: = build_array_type (wide_flag ? wchar_type_node : char_type_node, 196: build_index_type (build_int_2 (nchars - 1, 0))); 197: TREE_CONSTANT (value) = 1; 198: TREE_STATIC (value) = 1; 199: return value; 200: } 201: 202: /* Process the attributes listed in ATTRIBUTES 203: and install them in DECL. */ 204: 205: void 206: decl_attributes (decl, attributes) 207: tree decl, attributes; 208: { 209: tree a; 210: for (a = attributes; a; a = TREE_CHAIN (a)) 1.1.1.2 root 211: if (TREE_VALUE (a) == get_identifier ("packed")) 212: { 213: if (TREE_CODE (decl) == FIELD_DECL) 214: DECL_PACKED (decl) = 1; 1.1.1.3 root 215: /* We can't set DECL_PACKED for a VAR_DECL, because the bit is 216: used for DECL_REGISTER. It wouldn't mean anything anyway. */ 1.1.1.2 root 217: } 1.1.1.5 ! root 218: else if (TREE_VALUE (a) == get_identifier ("noreturn") ! 219: || TREE_VALUE (a) == get_identifier ("volatile")) ! 220: { ! 221: if (TREE_CODE (decl) == FUNCTION_DECL) ! 222: TREE_THIS_VOLATILE (decl) = 1; ! 223: } ! 224: else if (TREE_VALUE (a) == get_identifier ("const")) ! 225: { ! 226: if (TREE_CODE (decl) == FUNCTION_DECL) ! 227: TREE_READONLY (decl) = 1; ! 228: } 1.1.1.2 root 229: else if (TREE_VALUE (a) != 0 1.1.1.3 root 230: && TREE_CODE (TREE_VALUE (a)) == TREE_LIST 231: && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("mode")) 1.1.1.2 root 232: { 233: int i; 234: char *specified_name 235: = IDENTIFIER_POINTER (TREE_VALUE (TREE_VALUE (a))); 236: 237: /* Give this decl a type with the specified mode. */ 238: for (i = 0; i < NUM_MACHINE_MODES; i++) 239: if (!strcmp (specified_name, GET_MODE_NAME (i))) 240: { 241: tree type 242: = type_for_mode (i, TREE_UNSIGNED (TREE_TYPE (decl))); 243: if (type != 0) 244: { 245: TREE_TYPE (decl) = type; 246: DECL_SIZE (decl) = 0; 1.1.1.3 root 247: layout_decl (decl, 0); 1.1.1.2 root 248: } 249: else 250: error ("no data type for mode `%s'", specified_name); 251: break; 252: } 253: if (i == NUM_MACHINE_MODES) 254: error ("unknown machine mode `%s'", specified_name); 255: } 256: else if (TREE_VALUE (a) != 0 257: && TREE_CODE (TREE_VALUE (a)) == TREE_LIST 258: && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("aligned")) 1.1 root 259: { 260: int align = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (a))) 261: * BITS_PER_UNIT; 262: 263: if (exact_log2 (align) == -1) 1.1.1.2 root 264: error_with_decl (decl, 265: "requested alignment of `%s' is not a power of 2"); 1.1 root 266: else if (TREE_CODE (decl) != VAR_DECL 267: && TREE_CODE (decl) != FIELD_DECL) 1.1.1.2 root 268: error_with_decl (decl, 269: "alignment specified for `%s'"); 1.1 root 270: else 271: DECL_ALIGN (decl) = align; 272: } 273: else if (TREE_VALUE (a) != 0 274: && TREE_CODE (TREE_VALUE (a)) == TREE_LIST 1.1.1.2 root 275: && TREE_PURPOSE (TREE_VALUE (a)) == get_identifier ("format")) 1.1 root 276: { 277: tree list = TREE_VALUE (TREE_VALUE (a)); 278: tree format_type = TREE_PURPOSE (list); 279: int format_num = TREE_INT_CST_LOW (TREE_PURPOSE (TREE_VALUE (list))); 280: int first_arg_num = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (list))); 281: int is_scan; 1.1.1.4 root 282: tree argument; 283: int arg_num; 1.1 root 284: 285: if (TREE_CODE (decl) != FUNCTION_DECL) 286: { 1.1.1.2 root 287: error_with_decl (decl, 288: "argument format specified for non-function `%s'"); 1.1 root 289: return; 290: } 291: 292: if (format_type == get_identifier ("printf")) 293: is_scan = 0; 294: else if (format_type == get_identifier ("scanf")) 295: is_scan = 1; 296: else 297: { 1.1.1.2 root 298: error_with_decl (decl, "unrecognized format specifier for `%s'"); 1.1 root 299: return; 300: } 301: 302: if (first_arg_num != 0 && first_arg_num <= format_num) 303: { 1.1.1.2 root 304: error_with_decl (decl, 1.1 root 305: "format string arg follows the args to be formatted, for `%s'"); 306: return; 307: } 1.1.1.4 root 308: 309: /* Verify that the format_num argument is actually a string, in case 310: the format attribute is in error. */ 311: argument = TYPE_ARG_TYPES (TREE_TYPE (decl)); 312: for (arg_num = 1; ; ++arg_num) 313: { 314: if (argument == 0 || arg_num == format_num) 315: break; 316: argument = TREE_CHAIN (argument); 317: } 318: if (! argument 319: || TREE_CODE (TREE_VALUE (argument)) != POINTER_TYPE 320: || (TYPE_MAIN_VARIANT (TREE_TYPE (TREE_VALUE (argument))) 321: != char_type_node)) 322: { 323: error_with_decl (decl, 324: "format string arg not a string type, for `%s'"); 325: return; 326: } 327: if (first_arg_num != 0) 328: { 329: /* Verify that first_arg_num points to the last arg, the ... */ 330: while (argument) 331: arg_num++, argument = TREE_CHAIN (argument); 332: if (arg_num != first_arg_num) 333: { 334: error_with_decl (decl, 335: "args to be formatted is not ..., for `%s'"); 336: return; 337: } 338: } 1.1.1.5 ! root 339: ! 340: record_function_format (DECL_NAME (decl), DECL_ASSEMBLER_NAME (decl), ! 341: is_scan, format_num, first_arg_num); 1.1 root 342: } 343: } 344: 1.1.1.5 ! root 345: /* Check a printf/fprintf/sprintf/scanf/fscanf/sscanf format against ! 346: a parameter list. */ ! 347: ! 348: #define T_I &integer_type_node ! 349: #define T_L &long_integer_type_node ! 350: #define T_S &short_integer_type_node ! 351: #define T_UI &unsigned_type_node ! 352: #define T_UL &long_unsigned_type_node ! 353: #define T_US &short_unsigned_type_node ! 354: #define T_F &float_type_node ! 355: #define T_D &double_type_node ! 356: #define T_LD &long_double_type_node ! 357: #define T_C &char_type_node ! 358: #define T_V &void_type_node ! 359: #define T_W &wchar_type_node ! 360: ! 361: typedef struct { ! 362: char *format_chars; ! 363: int pointer_count; ! 364: /* Type of argument if no length modifier is used. */ ! 365: tree *nolen; ! 366: /* Type of argument if length modifier for shortening is used. ! 367: If NULL, then this modifier is not allowed. */ ! 368: tree *hlen; ! 369: /* Type of argument if length modifier `l' is used. ! 370: If NULL, then this modifier is not allowed. */ ! 371: tree *llen; ! 372: /* Type of argument if length modifier `L' is used. ! 373: If NULL, then this modifier is not allowed. */ ! 374: tree *bigllen; ! 375: /* List of other modifier characters allowed with these options. */ ! 376: char *flag_chars; ! 377: } format_char_info; ! 378: ! 379: static format_char_info print_char_table[] = { ! 380: { "di", 0, T_I, T_I, T_L, NULL, "-wp0 +" }, ! 381: { "oxX", 0, T_UI, T_UI, T_UL, NULL, "-wp0#" }, ! 382: { "u", 0, T_UI, T_UI, T_UL, NULL, "-wp0" }, ! 383: { "feEgG", 0, T_D, NULL, NULL, T_LD, "-wp0 +#" }, ! 384: { "c", 0, T_I, NULL, T_W, NULL, "-w" }, ! 385: { "C", 0, T_W, NULL, NULL, NULL, "-w" }, ! 386: { "s", 1, T_C, NULL, T_W, NULL, "-wp" }, ! 387: { "S", 1, T_W, NULL, NULL, NULL, "-wp" }, ! 388: { "p", 1, T_V, NULL, NULL, NULL, "-w" }, ! 389: { "n", 1, T_I, T_S, T_L, NULL, "" }, ! 390: { NULL } ! 391: }; ! 392: ! 393: static format_char_info scan_char_table[] = { ! 394: { "di", 1, T_I, T_S, T_L, NULL, "*" }, ! 395: { "ouxX", 1, T_UI, T_US, T_UL, NULL, "*" }, ! 396: { "efgEG", 1, T_F, NULL, T_D, T_LD, "*" }, ! 397: { "sc", 1, T_C, NULL, T_W, NULL, "*" }, ! 398: { "[", 1, T_C, NULL, NULL, NULL, "*" }, ! 399: { "C", 1, T_W, NULL, NULL, NULL, "*" }, ! 400: { "S", 1, T_W, NULL, NULL, NULL, "*" }, ! 401: { "p", 2, T_V, NULL, NULL, NULL, "*" }, ! 402: { "n", 1, T_I, T_S, T_L, NULL, "" }, ! 403: { NULL } ! 404: }; ! 405: ! 406: typedef struct function_format_info { ! 407: struct function_format_info *next; /* next structure on the list */ ! 408: tree name; /* identifier such as "printf" */ ! 409: tree assembler_name; /* optional mangled identifier (for C++) */ ! 410: int is_scan; /* TRUE if *scanf */ ! 411: int format_num; /* number of format argument */ ! 412: int first_arg_num; /* number of first arg (zero for varargs) */ ! 413: } function_format_info; ! 414: ! 415: static function_format_info *function_format_list = NULL; ! 416: ! 417: static void check_format_info PROTO((function_format_info *, tree)); ! 418: ! 419: /* Initialize the table of functions to perform format checking on. ! 420: The ANSI functions are always checked (whether <stdio.h> is ! 421: included or not), since it is common to call printf without ! 422: including <stdio.h>. There shouldn't be a problem with this, ! 423: since ANSI reserves these function names whether you include the ! 424: header file or not. In any case, the checking is harmless. */ ! 425: ! 426: void ! 427: init_function_format_info () ! 428: { ! 429: record_function_format (get_identifier ("printf"), NULL_TREE, 0, 1, 2); ! 430: record_function_format (get_identifier ("fprintf"), NULL_TREE, 0, 2, 3); ! 431: record_function_format (get_identifier ("sprintf"), NULL_TREE, 0, 2, 3); ! 432: record_function_format (get_identifier ("scanf"), NULL_TREE, 1, 1, 2); ! 433: record_function_format (get_identifier ("fscanf"), NULL_TREE, 1, 2, 3); ! 434: record_function_format (get_identifier ("sscanf"), NULL_TREE, 1, 2, 3); ! 435: record_function_format (get_identifier ("vprintf"), NULL_TREE, 0, 1, 0); ! 436: record_function_format (get_identifier ("vfprintf"), NULL_TREE, 0, 2, 0); ! 437: record_function_format (get_identifier ("vsprintf"), NULL_TREE, 0, 2, 0); ! 438: } ! 439: ! 440: /* Record information for argument format checking. FUNCTION_IDENT is ! 441: the identifier node for the name of the function to check (its decl ! 442: need not exist yet). IS_SCAN is true for scanf-type format checking; ! 443: false indicates printf-style format checking. FORMAT_NUM is the number ! 444: of the argument which is the format control string (starting from 1). ! 445: FIRST_ARG_NUM is the number of the first actual argument to check ! 446: against teh format string, or zero if no checking is not be done ! 447: (e.g. for varargs such as vfprintf). */ ! 448: ! 449: void ! 450: record_function_format (name, assembler_name, is_scan, ! 451: format_num, first_arg_num) ! 452: tree name; ! 453: tree assembler_name; ! 454: int is_scan; ! 455: int format_num; ! 456: int first_arg_num; ! 457: { ! 458: function_format_info *info; ! 459: ! 460: /* Re-use existing structure if it's there. */ ! 461: ! 462: for (info = function_format_list; info; info = info->next) ! 463: { ! 464: if (info->name == name && info->assembler_name == assembler_name) ! 465: break; ! 466: } ! 467: if (! info) ! 468: { ! 469: info = (function_format_info *) xmalloc (sizeof (function_format_info)); ! 470: info->next = function_format_list; ! 471: function_format_list = info; ! 472: ! 473: info->name = name; ! 474: info->assembler_name = assembler_name; ! 475: } ! 476: ! 477: info->is_scan = is_scan; ! 478: info->format_num = format_num; ! 479: info->first_arg_num = first_arg_num; ! 480: } ! 481: ! 482: static char tfaff[] = "too few arguments for format"; ! 483: ! 484: /* Check the argument list of a call to printf, scanf, etc. ! 485: NAME is the function identifier. ! 486: ASSEMBLER_NAME is the function's assembler identifier. ! 487: (Either NAME or ASSEMBLER_NAME, but not both, may be NULL_TREE.) ! 488: PARAMS is the list of argument values. */ ! 489: ! 490: void ! 491: check_function_format (name, assembler_name, params) ! 492: tree name; ! 493: tree assembler_name; ! 494: tree params; ! 495: { ! 496: function_format_info *info; ! 497: ! 498: /* See if this function is a format function. */ ! 499: for (info = function_format_list; info; info = info->next) ! 500: { ! 501: if (info->assembler_name ! 502: ? (info->assembler_name == assembler_name) ! 503: : (info->name == name)) ! 504: { ! 505: /* Yup; check it. */ ! 506: check_format_info (info, params); ! 507: break; ! 508: } ! 509: } ! 510: } ! 511: ! 512: /* Check the argument list of a call to printf, scanf, etc. ! 513: INFO points to the function_format_info structure. ! 514: PARAMS is the list of argument values. */ ! 515: ! 516: static void ! 517: check_format_info (info, params) ! 518: function_format_info *info; ! 519: tree params; ! 520: { ! 521: int i; ! 522: int arg_num; ! 523: int suppressed, wide, precise; ! 524: int length_char; ! 525: int format_char; ! 526: int format_length; ! 527: tree format_tree; ! 528: tree cur_param; ! 529: tree cur_type; ! 530: tree wanted_type; ! 531: tree first_fillin_param; ! 532: char *format_chars; ! 533: format_char_info *fci; ! 534: static char message[132]; ! 535: char flag_chars[8]; ! 536: int has_operand_number = 0; ! 537: ! 538: /* Skip to format argument. If the argument isn't available, there's ! 539: no work for us to do; prototype checking will catch the problem. */ ! 540: for (arg_num = 1; ; ++arg_num) ! 541: { ! 542: if (params == 0) ! 543: return; ! 544: if (arg_num == info->format_num) ! 545: break; ! 546: params = TREE_CHAIN (params); ! 547: } ! 548: format_tree = TREE_VALUE (params); ! 549: params = TREE_CHAIN (params); ! 550: if (format_tree == 0) ! 551: return; ! 552: /* We can only check the format if it's a string constant. */ ! 553: while (TREE_CODE (format_tree) == NOP_EXPR) ! 554: format_tree = TREE_OPERAND (format_tree, 0); /* strip coercion */ ! 555: if (format_tree == null_pointer_node) ! 556: { ! 557: warning ("null format string"); ! 558: return; ! 559: } ! 560: if (TREE_CODE (format_tree) != ADDR_EXPR) ! 561: return; ! 562: format_tree = TREE_OPERAND (format_tree, 0); ! 563: if (TREE_CODE (format_tree) != STRING_CST) ! 564: return; ! 565: format_chars = TREE_STRING_POINTER (format_tree); ! 566: format_length = TREE_STRING_LENGTH (format_tree); ! 567: if (format_length <= 1) ! 568: warning ("zero-length format string"); ! 569: if (format_chars[--format_length] != 0) ! 570: { ! 571: warning ("unterminated format string"); ! 572: return; ! 573: } ! 574: /* Skip to first argument to check. */ ! 575: while (arg_num + 1 < info->first_arg_num) ! 576: { ! 577: if (params == 0) ! 578: return; ! 579: params = TREE_CHAIN (params); ! 580: ++arg_num; ! 581: } ! 582: ! 583: first_fillin_param = params; ! 584: while (1) ! 585: { ! 586: if (*format_chars == 0) ! 587: { ! 588: if (format_chars - TREE_STRING_POINTER (format_tree) != format_length) ! 589: warning ("embedded `\\0' in format"); ! 590: if (info->first_arg_num != 0 && params != 0 && ! has_operand_number) ! 591: warning ("too many arguments for format"); ! 592: return; ! 593: } ! 594: if (*format_chars++ != '%') ! 595: continue; ! 596: if (*format_chars == 0) ! 597: { ! 598: warning ("spurious trailing `%%' in format"); ! 599: continue; ! 600: } ! 601: if (*format_chars == '%') ! 602: { ! 603: ++format_chars; ! 604: continue; ! 605: } ! 606: flag_chars[0] = 0; ! 607: suppressed = wide = precise = FALSE; ! 608: if (info->is_scan) ! 609: { ! 610: suppressed = *format_chars == '*'; ! 611: if (suppressed) ! 612: ++format_chars; ! 613: while (isdigit (*format_chars)) ! 614: ++format_chars; ! 615: } ! 616: else ! 617: { ! 618: /* See if we have a number followed by a dollar sign. If we do, ! 619: it is an operand number, so set PARAMS to that operand. */ ! 620: if (*format_chars >= '0' && *format_chars <= '9') ! 621: { ! 622: char *p = format_chars; ! 623: ! 624: while (*p >= '0' && *p++ <= '9') ! 625: ; ! 626: ! 627: if (*p == '$') ! 628: { ! 629: int opnum = atoi (format_chars); ! 630: ! 631: params = first_fillin_param; ! 632: format_chars = p + 1; ! 633: has_operand_number = 1; ! 634: ! 635: for (i = 1; i < opnum && params != 0; i++) ! 636: params = TREE_CHAIN (params); ! 637: ! 638: if (opnum == 0 || params == 0) ! 639: { ! 640: warning ("operand number out of range in format"); ! 641: return; ! 642: } ! 643: } ! 644: } ! 645: ! 646: while (*format_chars != 0 && index (" +#0-", *format_chars) != 0) ! 647: { ! 648: if (index (flag_chars, *format_chars) != 0) ! 649: { ! 650: sprintf (message, "repeated `%c' flag in format", ! 651: *format_chars); ! 652: warning (message); ! 653: } ! 654: i = strlen (flag_chars); ! 655: flag_chars[i++] = *format_chars++; ! 656: flag_chars[i] = 0; ! 657: } ! 658: /* "If the space and + flags both appear, ! 659: the space flag will be ignored." */ ! 660: if (index (flag_chars, ' ') != 0 ! 661: && index (flag_chars, '+') != 0) ! 662: warning ("use of both ` ' and `+' flags in format"); ! 663: /* "If the 0 and - flags both appear, ! 664: the 0 flag will be ignored." */ ! 665: if (index (flag_chars, '0') != 0 ! 666: && index (flag_chars, '-') != 0) ! 667: warning ("use of both `0' and `-' flags in format"); ! 668: if (*format_chars == '*') ! 669: { ! 670: wide = TRUE; ! 671: /* "...a field width...may be indicated by an asterisk. ! 672: In this case, an int argument supplies the field width..." */ ! 673: ++format_chars; ! 674: if (params == 0) ! 675: { ! 676: warning (tfaff); ! 677: return; ! 678: } ! 679: if (info->first_arg_num != 0) ! 680: { ! 681: cur_param = TREE_VALUE (params); ! 682: params = TREE_CHAIN (params); ! 683: ++arg_num; ! 684: /* size_t is generally not valid here. ! 685: It will work on most machines, because size_t and int ! 686: have the same mode. But might as well warn anyway, ! 687: since it will fail on other machines. */ ! 688: if ((TYPE_MAIN_VARIANT (TREE_TYPE (cur_param)) ! 689: != integer_type_node) ! 690: && ! 691: (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param)) ! 692: != unsigned_type_node)) ! 693: { ! 694: sprintf (message, ! 695: "field width is not type int (arg %d)", ! 696: arg_num); ! 697: warning (message); ! 698: } ! 699: } ! 700: } ! 701: else ! 702: { ! 703: while (isdigit (*format_chars)) ! 704: { ! 705: wide = TRUE; ! 706: ++format_chars; ! 707: } ! 708: } ! 709: if (*format_chars == '.') ! 710: { ! 711: precise = TRUE; ! 712: ++format_chars; ! 713: if (*format_chars != '*' && !isdigit (*format_chars)) ! 714: warning ("`.' not followed by `*' or digit in format"); ! 715: /* "...a...precision...may be indicated by an asterisk. ! 716: In this case, an int argument supplies the...precision." */ ! 717: if (*format_chars == '*') ! 718: { ! 719: if (info->first_arg_num != 0) ! 720: { ! 721: ++format_chars; ! 722: if (params == 0) ! 723: { ! 724: warning (tfaff); ! 725: return; ! 726: } ! 727: cur_param = TREE_VALUE (params); ! 728: params = TREE_CHAIN (params); ! 729: ++arg_num; ! 730: if (TYPE_MAIN_VARIANT (TREE_TYPE (cur_param)) ! 731: != integer_type_node) ! 732: { ! 733: sprintf (message, ! 734: "field width is not type int (arg %d)", ! 735: arg_num); ! 736: warning (message); ! 737: } ! 738: } ! 739: } ! 740: else ! 741: { ! 742: while (isdigit (*format_chars)) ! 743: ++format_chars; ! 744: } ! 745: } ! 746: } ! 747: if (*format_chars == 'h' || *format_chars == 'l' || *format_chars == 'L') ! 748: length_char = *format_chars++; ! 749: else ! 750: length_char = 0; ! 751: if (suppressed && length_char != 0) ! 752: { ! 753: sprintf (message, ! 754: "use of `*' and `%c' together in format", ! 755: length_char); ! 756: warning (message); ! 757: } ! 758: format_char = *format_chars; ! 759: if (format_char == 0) ! 760: { ! 761: warning ("conversion lacks type at end of format"); ! 762: continue; ! 763: } ! 764: format_chars++; ! 765: fci = info->is_scan ? scan_char_table : print_char_table; ! 766: while (fci->format_chars != 0 ! 767: && index (fci->format_chars, format_char) == 0) ! 768: ++fci; ! 769: if (fci->format_chars == 0) ! 770: { ! 771: if (format_char >= 040 && format_char < 0177) ! 772: sprintf (message, ! 773: "unknown conversion type character `%c' in format", ! 774: format_char); ! 775: else ! 776: sprintf (message, ! 777: "unknown conversion type character 0x%x in format", ! 778: format_char); ! 779: warning (message); ! 780: continue; ! 781: } ! 782: if (wide && index (fci->flag_chars, 'w') == 0) ! 783: { ! 784: sprintf (message, "width used with `%c' format", ! 785: format_char); ! 786: warning (message); ! 787: } ! 788: if (precise && index (fci->flag_chars, 'p') == 0) ! 789: { ! 790: sprintf (message, "precision used with `%c' format", ! 791: format_char); ! 792: warning (message); ! 793: } ! 794: if (info->is_scan && format_char == '[') ! 795: { ! 796: /* Skip over scan set, in case it happens to have '%' in it. */ ! 797: if (*format_chars == '^') ! 798: ++format_chars; ! 799: /* Find closing bracket; if one is hit immediately, then ! 800: it's part of the scan set rather than a terminator. */ ! 801: if (*format_chars == ']') ! 802: ++format_chars; ! 803: while (*format_chars && *format_chars != ']') ! 804: ++format_chars; ! 805: if (*format_chars != ']') ! 806: /* The end of the format string was reached. */ ! 807: warning ("no closing `]' for `%%[' format"); ! 808: } ! 809: if (suppressed) ! 810: { ! 811: if (index (fci->flag_chars, '*') == 0) ! 812: { ! 813: sprintf (message, ! 814: "suppression of `%c' conversion in format", ! 815: format_char); ! 816: warning (message); ! 817: } ! 818: continue; ! 819: } ! 820: for (i = 0; flag_chars[i] != 0; ++i) ! 821: { ! 822: if (index (fci->flag_chars, flag_chars[i]) == 0) ! 823: { ! 824: sprintf (message, "flag `%c' used with type `%c'", ! 825: flag_chars[i], format_char); ! 826: warning (message); ! 827: } ! 828: } ! 829: if (precise && index (flag_chars, '0') != 0 ! 830: && (format_char == 'd' || format_char == 'i' ! 831: || format_char == 'o' || format_char == 'u' ! 832: || format_char == 'x' || format_char == 'x')) ! 833: { ! 834: sprintf (message, ! 835: "precision and `0' flag not both allowed with `%c' format", ! 836: format_char); ! 837: warning (message); ! 838: } ! 839: switch (length_char) ! 840: { ! 841: default: wanted_type = fci->nolen ? *(fci->nolen) : 0; break; ! 842: case 'h': wanted_type = fci->hlen ? *(fci->hlen) : 0; break; ! 843: case 'l': wanted_type = fci->llen ? *(fci->llen) : 0; break; ! 844: case 'L': wanted_type = fci->bigllen ? *(fci->bigllen) : 0; break; ! 845: } ! 846: if (wanted_type == 0) ! 847: { ! 848: sprintf (message, ! 849: "use of `%c' length character with `%c' type character", ! 850: length_char, format_char); ! 851: warning (message); ! 852: } ! 853: ! 854: /* ! 855: ** XXX -- should kvetch about stuff such as ! 856: ** { ! 857: ** const int i; ! 858: ** ! 859: ** scanf ("%d", &i); ! 860: ** } ! 861: */ ! 862: ! 863: /* Finally. . .check type of argument against desired type! */ ! 864: if (info->first_arg_num == 0) ! 865: continue; ! 866: if (params == 0) ! 867: { ! 868: warning (tfaff); ! 869: return; ! 870: } ! 871: cur_param = TREE_VALUE (params); ! 872: params = TREE_CHAIN (params); ! 873: ++arg_num; ! 874: cur_type = TREE_TYPE (cur_param); ! 875: ! 876: /* Check the types of any additional pointer arguments ! 877: that precede the "real" argument. */ ! 878: for (i = 0; i < fci->pointer_count; ++i) ! 879: { ! 880: if (TREE_CODE (cur_type) == POINTER_TYPE) ! 881: { ! 882: cur_type = TREE_TYPE (cur_type); ! 883: continue; ! 884: } ! 885: sprintf (message, ! 886: "format argument is not a %s (arg %d)", ! 887: ((fci->pointer_count == 1) ? "pointer" : "pointer to a pointer"), ! 888: arg_num); ! 889: warning (message); ! 890: break; ! 891: } ! 892: ! 893: /* Check the type of the "real" argument, if there's a type we want. */ ! 894: if (i == fci->pointer_count && wanted_type != 0 ! 895: && wanted_type != TYPE_MAIN_VARIANT (cur_type) ! 896: /* If we want `void *', allow any pointer type. ! 897: (Anything else would already have got a warning.) */ ! 898: && ! (wanted_type == void_type_node ! 899: && fci->pointer_count > 0) ! 900: /* Don't warn about differences merely in signedness. */ ! 901: && !(TREE_CODE (wanted_type) == INTEGER_TYPE ! 902: && TREE_CODE (TYPE_MAIN_VARIANT (cur_type)) == INTEGER_TYPE ! 903: && (TREE_UNSIGNED (wanted_type) ! 904: ? wanted_type == (cur_type = unsigned_type (cur_type)) ! 905: : wanted_type == (cur_type = signed_type (cur_type)))) ! 906: /* Likewise, "signed char", "unsigned char" and "char" are ! 907: equivalent but the above test won't consider them equivalent. */ ! 908: && ! (wanted_type == char_type_node ! 909: && (TYPE_MAIN_VARIANT (cur_type) == signed_char_type_node ! 910: || TYPE_MAIN_VARIANT (cur_type) == unsigned_char_type_node))) ! 911: { ! 912: register char *this; ! 913: register char *that; ! 914: ! 915: this = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (wanted_type))); ! 916: that = 0; ! 917: if (TREE_CODE (cur_type) != ERROR_MARK ! 918: && TYPE_NAME (cur_type) != 0 ! 919: && TREE_CODE (cur_type) != INTEGER_TYPE ! 920: && !(TREE_CODE (cur_type) == POINTER_TYPE ! 921: && TREE_CODE (TREE_TYPE (cur_type)) == INTEGER_TYPE)) ! 922: { ! 923: if (TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL ! 924: && DECL_NAME (TYPE_NAME (cur_type)) != 0) ! 925: that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type))); ! 926: else ! 927: that = IDENTIFIER_POINTER (TYPE_NAME (cur_type)); ! 928: } ! 929: ! 930: /* A nameless type can't possibly match what the format wants. ! 931: So there will be a warning for it. ! 932: Make up a string to describe vaguely what it is. */ ! 933: if (that == 0) ! 934: { ! 935: if (TREE_CODE (cur_type) == POINTER_TYPE) ! 936: that = "pointer"; ! 937: else ! 938: that = "different type"; ! 939: } ! 940: ! 941: /* Make the warning better in case of mismatch of int vs long. */ ! 942: if (TREE_CODE (cur_type) == INTEGER_TYPE ! 943: && TREE_CODE (wanted_type) == INTEGER_TYPE ! 944: && TYPE_PRECISION (cur_type) == TYPE_PRECISION (wanted_type) ! 945: && TYPE_NAME (cur_type) != 0 ! 946: && TREE_CODE (TYPE_NAME (cur_type)) == TYPE_DECL) ! 947: that = IDENTIFIER_POINTER (DECL_NAME (TYPE_NAME (cur_type))); ! 948: ! 949: if (strcmp (this, that) != 0) ! 950: { ! 951: sprintf (message, "%s format, %s arg (arg %d)", ! 952: this, that, arg_num); ! 953: warning (message); ! 954: } ! 955: } ! 956: } ! 957: } ! 958: 1.1.1.4 root 959: /* Print a warning if a constant expression had overflow in folding. 960: Invoke this function on every expression that the language 961: requires to be a constant expression. 962: Note the ANSI C standard says it is erroneous for a 963: constant expression to overflow. */ 1.1.1.3 root 964: 965: void 966: constant_expression_warning (value) 967: tree value; 968: { 969: if (TREE_CODE (value) == INTEGER_CST && TREE_CONSTANT_OVERFLOW (value)) 1.1.1.5 ! root 970: if (pedantic) ! 971: pedwarn ("overflow in constant expression"); 1.1.1.4 root 972: } 973: 974: /* Print a warning if an expression had overflow in folding. 975: Invoke this function on every expression that 976: (1) appears in the source code, and 977: (2) might be a constant expression that overflowed, and 978: (3) is not already checked by convert_and_check; 979: however, do not invoke this function on operands of explicit casts. */ 980: 981: void 982: overflow_warning (value) 983: tree value; 984: { 1.1.1.5 ! root 985: if (TREE_CODE (value) == INTEGER_CST && TREE_OVERFLOW (value)) 1.1.1.4 root 986: { 1.1.1.5 ! root 987: TREE_OVERFLOW (value) = 0; 1.1.1.4 root 988: warning ("integer overflow in expression"); 989: } 990: } 991: 992: /* Print a warning if a large constant is truncated to unsigned, 993: or if -Wconversion is used and a constant < 0 is converted to unsigned. 994: Invoke this function on every expression that might be implicitly 995: converted to an unsigned type. */ 996: 997: void 998: unsigned_conversion_warning (result, operand) 999: tree result, operand; 1000: { 1001: if (TREE_CODE (operand) == INTEGER_CST 1002: && TREE_CODE (TREE_TYPE (result)) == INTEGER_TYPE 1003: && TREE_UNSIGNED (TREE_TYPE (result)) 1004: && !int_fits_type_p (operand, TREE_TYPE (result))) 1005: { 1006: if (!int_fits_type_p (operand, signed_type (TREE_TYPE (result)))) 1007: /* This detects cases like converting -129 or 256 to unsigned char. */ 1.1.1.5 ! root 1008: warning ("large integer implicitly truncated to unsigned type"); 1.1.1.4 root 1009: else if (warn_conversion) 1.1.1.5 ! root 1010: warning ("negative integer implicitly converted to unsigned type"); 1.1.1.4 root 1011: } 1012: } 1013: 1014: /* Convert EXPR to TYPE, warning about conversion problems with constants. 1015: Invoke this function on every expression that is converted implicitly, 1016: i.e. because of language rules and not because of an explicit cast. */ 1017: 1018: tree 1019: convert_and_check (type, expr) 1020: tree type, expr; 1021: { 1022: tree t = convert (type, expr); 1023: if (TREE_CODE (t) == INTEGER_CST) 1024: { 1.1.1.5 ! root 1025: if (TREE_OVERFLOW (t)) ! 1026: { ! 1027: TREE_OVERFLOW (t) = 0; ! 1028: ! 1029: /* No warning for converting 0x80000000 to int. */ ! 1030: if (!(TREE_UNSIGNED (type) < TREE_UNSIGNED (TREE_TYPE (expr)) ! 1031: && TREE_CODE (TREE_TYPE (expr)) == INTEGER_TYPE ! 1032: && TYPE_PRECISION (type) == TYPE_PRECISION (TREE_TYPE (expr)))) ! 1033: /* If EXPR fits in the unsigned version of TYPE, ! 1034: don't warn unless pedantic. */ ! 1035: if (pedantic ! 1036: || TREE_UNSIGNED (type) ! 1037: || ! int_fits_type_p (expr, unsigned_type (type))) ! 1038: warning ("overflow in implicit constant conversion"); 1.1.1.4 root 1039: } 1040: else 1041: unsigned_conversion_warning (t, expr); 1042: } 1043: return t; 1.1.1.3 root 1044: } 1045: 1.1 root 1046: void 1047: c_expand_expr_stmt (expr) 1048: tree expr; 1049: { 1050: /* Do default conversion if safe and possibly important, 1051: in case within ({...}). */ 1052: if ((TREE_CODE (TREE_TYPE (expr)) == ARRAY_TYPE && lvalue_p (expr)) 1053: || TREE_CODE (TREE_TYPE (expr)) == FUNCTION_TYPE) 1054: expr = default_conversion (expr); 1055: 1056: if (TREE_TYPE (expr) != error_mark_node 1057: && TYPE_SIZE (TREE_TYPE (expr)) == 0 1058: && TREE_CODE (TREE_TYPE (expr)) != ARRAY_TYPE) 1059: error ("expression statement has incomplete type"); 1060: 1061: expand_expr_stmt (expr); 1062: } 1063: 1064: /* Validate the expression after `case' and apply default promotions. */ 1065: 1066: tree 1067: check_case_value (value) 1068: tree value; 1069: { 1070: if (value == NULL_TREE) 1071: return value; 1072: 1073: /* Strip NON_LVALUE_EXPRs since we aren't using as an lvalue. */ 1.1.1.3 root 1074: STRIP_TYPE_NOPS (value); 1.1 root 1075: 1076: if (TREE_CODE (value) != INTEGER_CST 1077: && value != error_mark_node) 1078: { 1079: error ("case label does not reduce to an integer constant"); 1080: value = error_mark_node; 1081: } 1082: else 1083: /* Promote char or short to int. */ 1084: value = default_conversion (value); 1085: 1.1.1.3 root 1086: constant_expression_warning (value); 1087: 1.1 root 1088: return value; 1089: } 1090: 1091: /* Return an integer type with BITS bits of precision, 1092: that is unsigned if UNSIGNEDP is nonzero, otherwise signed. */ 1093: 1094: tree 1095: type_for_size (bits, unsignedp) 1096: unsigned bits; 1097: int unsignedp; 1098: { 1.1.1.3 root 1099: if (bits == TYPE_PRECISION (signed_char_type_node)) 1.1 root 1100: return unsignedp ? unsigned_char_type_node : signed_char_type_node; 1101: 1.1.1.3 root 1102: if (bits == TYPE_PRECISION (short_integer_type_node)) 1.1 root 1103: return unsignedp ? short_unsigned_type_node : short_integer_type_node; 1104: 1.1.1.3 root 1105: if (bits == TYPE_PRECISION (integer_type_node)) 1.1 root 1106: return unsignedp ? unsigned_type_node : integer_type_node; 1107: 1.1.1.3 root 1108: if (bits == TYPE_PRECISION (long_integer_type_node)) 1.1 root 1109: return unsignedp ? long_unsigned_type_node : long_integer_type_node; 1110: 1.1.1.3 root 1111: if (bits == TYPE_PRECISION (long_long_integer_type_node)) 1.1 root 1112: return (unsignedp ? long_long_unsigned_type_node 1113: : long_long_integer_type_node); 1114: 1.1.1.3 root 1115: if (bits <= TYPE_PRECISION (intQI_type_node)) 1116: return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 1117: 1118: if (bits <= TYPE_PRECISION (intHI_type_node)) 1119: return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 1120: 1121: if (bits <= TYPE_PRECISION (intSI_type_node)) 1122: return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 1123: 1124: if (bits <= TYPE_PRECISION (intDI_type_node)) 1125: return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 1126: 1.1 root 1127: return 0; 1128: } 1129: 1130: /* Return a data type that has machine mode MODE. 1131: If the mode is an integer, 1132: then UNSIGNEDP selects between signed and unsigned types. */ 1133: 1134: tree 1135: type_for_mode (mode, unsignedp) 1136: enum machine_mode mode; 1137: int unsignedp; 1138: { 1139: if (mode == TYPE_MODE (signed_char_type_node)) 1140: return unsignedp ? unsigned_char_type_node : signed_char_type_node; 1141: 1142: if (mode == TYPE_MODE (short_integer_type_node)) 1143: return unsignedp ? short_unsigned_type_node : short_integer_type_node; 1144: 1145: if (mode == TYPE_MODE (integer_type_node)) 1146: return unsignedp ? unsigned_type_node : integer_type_node; 1147: 1148: if (mode == TYPE_MODE (long_integer_type_node)) 1149: return unsignedp ? long_unsigned_type_node : long_integer_type_node; 1150: 1151: if (mode == TYPE_MODE (long_long_integer_type_node)) 1152: return unsignedp ? long_long_unsigned_type_node : long_long_integer_type_node; 1153: 1.1.1.3 root 1154: if (mode == TYPE_MODE (intQI_type_node)) 1155: return unsignedp ? unsigned_intQI_type_node : intQI_type_node; 1156: 1157: if (mode == TYPE_MODE (intHI_type_node)) 1158: return unsignedp ? unsigned_intHI_type_node : intHI_type_node; 1159: 1160: if (mode == TYPE_MODE (intSI_type_node)) 1161: return unsignedp ? unsigned_intSI_type_node : intSI_type_node; 1162: 1163: if (mode == TYPE_MODE (intDI_type_node)) 1164: return unsignedp ? unsigned_intDI_type_node : intDI_type_node; 1165: 1.1 root 1166: if (mode == TYPE_MODE (float_type_node)) 1167: return float_type_node; 1168: 1169: if (mode == TYPE_MODE (double_type_node)) 1170: return double_type_node; 1171: 1172: if (mode == TYPE_MODE (long_double_type_node)) 1173: return long_double_type_node; 1174: 1175: if (mode == TYPE_MODE (build_pointer_type (char_type_node))) 1176: return build_pointer_type (char_type_node); 1177: 1178: if (mode == TYPE_MODE (build_pointer_type (integer_type_node))) 1179: return build_pointer_type (integer_type_node); 1180: 1181: return 0; 1182: } 1183: 1184: /* Print an error message for invalid operands to arith operation CODE. 1185: NOP_EXPR is used as a special case (see truthvalue_conversion). */ 1186: 1187: void 1188: binary_op_error (code) 1189: enum tree_code code; 1190: { 1191: register char *opname; 1192: switch (code) 1193: { 1194: case NOP_EXPR: 1195: error ("invalid truth-value expression"); 1196: return; 1197: 1198: case PLUS_EXPR: 1199: opname = "+"; break; 1200: case MINUS_EXPR: 1201: opname = "-"; break; 1202: case MULT_EXPR: 1203: opname = "*"; break; 1204: case MAX_EXPR: 1205: opname = "max"; break; 1206: case MIN_EXPR: 1207: opname = "min"; break; 1208: case EQ_EXPR: 1209: opname = "=="; break; 1210: case NE_EXPR: 1211: opname = "!="; break; 1212: case LE_EXPR: 1213: opname = "<="; break; 1214: case GE_EXPR: 1215: opname = ">="; break; 1216: case LT_EXPR: 1217: opname = "<"; break; 1218: case GT_EXPR: 1219: opname = ">"; break; 1220: case LSHIFT_EXPR: 1221: opname = "<<"; break; 1222: case RSHIFT_EXPR: 1223: opname = ">>"; break; 1224: case TRUNC_MOD_EXPR: 1.1.1.2 root 1225: case FLOOR_MOD_EXPR: 1.1 root 1226: opname = "%"; break; 1227: case TRUNC_DIV_EXPR: 1.1.1.2 root 1228: case FLOOR_DIV_EXPR: 1.1 root 1229: opname = "/"; break; 1230: case BIT_AND_EXPR: 1231: opname = "&"; break; 1232: case BIT_IOR_EXPR: 1233: opname = "|"; break; 1234: case TRUTH_ANDIF_EXPR: 1235: opname = "&&"; break; 1236: case TRUTH_ORIF_EXPR: 1237: opname = "||"; break; 1238: case BIT_XOR_EXPR: 1239: opname = "^"; break; 1.1.1.2 root 1240: case LROTATE_EXPR: 1241: case RROTATE_EXPR: 1242: opname = "rotate"; break; 1.1 root 1243: } 1244: error ("invalid operands to binary %s", opname); 1245: } 1246: 1247: /* Subroutine of build_binary_op, used for comparison operations. 1248: See if the operands have both been converted from subword integer types 1249: and, if so, perhaps change them both back to their original type. 1.1.1.5 ! root 1250: This function is also responsible for converting the two operands ! 1251: to the proper common type for comparison. 1.1 root 1252: 1253: The arguments of this function are all pointers to local variables 1254: of build_binary_op: OP0_PTR is &OP0, OP1_PTR is &OP1, 1255: RESTYPE_PTR is &RESULT_TYPE and RESCODE_PTR is &RESULTCODE. 1256: 1257: If this function returns nonzero, it means that the comparison has 1258: a constant value. What this function returns is an expression for 1259: that value. */ 1260: 1261: tree 1262: shorten_compare (op0_ptr, op1_ptr, restype_ptr, rescode_ptr) 1263: tree *op0_ptr, *op1_ptr; 1264: tree *restype_ptr; 1265: enum tree_code *rescode_ptr; 1266: { 1267: register tree type; 1268: tree op0 = *op0_ptr; 1269: tree op1 = *op1_ptr; 1270: int unsignedp0, unsignedp1; 1271: int real1, real2; 1272: tree primop0, primop1; 1273: enum tree_code code = *rescode_ptr; 1274: 1275: /* Throw away any conversions to wider types 1276: already present in the operands. */ 1277: 1278: primop0 = get_narrower (op0, &unsignedp0); 1279: primop1 = get_narrower (op1, &unsignedp1); 1280: 1281: /* Handle the case that OP0 does not *contain* a conversion 1282: but it *requires* conversion to FINAL_TYPE. */ 1283: 1284: if (op0 == primop0 && TREE_TYPE (op0) != *restype_ptr) 1285: unsignedp0 = TREE_UNSIGNED (TREE_TYPE (op0)); 1286: if (op1 == primop1 && TREE_TYPE (op1) != *restype_ptr) 1287: unsignedp1 = TREE_UNSIGNED (TREE_TYPE (op1)); 1288: 1289: /* If one of the operands must be floated, we cannot optimize. */ 1290: real1 = TREE_CODE (TREE_TYPE (primop0)) == REAL_TYPE; 1291: real2 = TREE_CODE (TREE_TYPE (primop1)) == REAL_TYPE; 1292: 1293: /* If first arg is constant, swap the args (changing operation 1294: so value is preserved), for canonicalization. */ 1295: 1296: if (TREE_CONSTANT (primop0)) 1297: { 1298: register tree tem = primop0; 1299: register int temi = unsignedp0; 1300: primop0 = primop1; 1301: primop1 = tem; 1302: tem = op0; 1303: op0 = op1; 1304: op1 = tem; 1305: *op0_ptr = op0; 1306: *op1_ptr = op1; 1307: unsignedp0 = unsignedp1; 1308: unsignedp1 = temi; 1309: temi = real1; 1310: real1 = real2; 1311: real2 = temi; 1312: 1313: switch (code) 1314: { 1315: case LT_EXPR: 1316: code = GT_EXPR; 1317: break; 1318: case GT_EXPR: 1319: code = LT_EXPR; 1320: break; 1321: case LE_EXPR: 1322: code = GE_EXPR; 1323: break; 1324: case GE_EXPR: 1325: code = LE_EXPR; 1326: break; 1327: } 1328: *rescode_ptr = code; 1329: } 1330: 1331: /* If comparing an integer against a constant more bits wide, 1332: maybe we can deduce a value of 1 or 0 independent of the data. 1333: Or else truncate the constant now 1334: rather than extend the variable at run time. 1335: 1336: This is only interesting if the constant is the wider arg. 1337: Also, it is not safe if the constant is unsigned and the 1338: variable arg is signed, since in this case the variable 1339: would be sign-extended and then regarded as unsigned. 1340: Our technique fails in this case because the lowest/highest 1341: possible unsigned results don't follow naturally from the 1342: lowest/highest possible values of the variable operand. 1343: For just EQ_EXPR and NE_EXPR there is another technique that 1344: could be used: see if the constant can be faithfully represented 1345: in the other operand's type, by truncating it and reextending it 1346: and see if that preserves the constant's value. */ 1347: 1348: if (!real1 && !real2 1349: && TREE_CODE (primop1) == INTEGER_CST 1350: && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr)) 1351: { 1352: int min_gt, max_gt, min_lt, max_lt; 1353: tree maxval, minval; 1354: /* 1 if comparison is nominally unsigned. */ 1355: int unsignedp = TREE_UNSIGNED (*restype_ptr); 1356: tree val; 1357: 1358: type = signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)); 1359: 1360: maxval = TYPE_MAX_VALUE (type); 1361: minval = TYPE_MIN_VALUE (type); 1362: 1363: if (unsignedp && !unsignedp0) 1364: *restype_ptr = signed_type (*restype_ptr); 1365: 1366: if (TREE_TYPE (primop1) != *restype_ptr) 1367: primop1 = convert (*restype_ptr, primop1); 1368: if (type != *restype_ptr) 1369: { 1370: minval = convert (*restype_ptr, minval); 1371: maxval = convert (*restype_ptr, maxval); 1372: } 1373: 1374: if (unsignedp && unsignedp0) 1375: { 1376: min_gt = INT_CST_LT_UNSIGNED (primop1, minval); 1377: max_gt = INT_CST_LT_UNSIGNED (primop1, maxval); 1378: min_lt = INT_CST_LT_UNSIGNED (minval, primop1); 1379: max_lt = INT_CST_LT_UNSIGNED (maxval, primop1); 1380: } 1381: else 1382: { 1383: min_gt = INT_CST_LT (primop1, minval); 1384: max_gt = INT_CST_LT (primop1, maxval); 1385: min_lt = INT_CST_LT (minval, primop1); 1386: max_lt = INT_CST_LT (maxval, primop1); 1387: } 1388: 1389: val = 0; 1390: /* This used to be a switch, but Genix compiler can't handle that. */ 1391: if (code == NE_EXPR) 1392: { 1393: if (max_lt || min_gt) 1394: val = integer_one_node; 1395: } 1396: else if (code == EQ_EXPR) 1397: { 1398: if (max_lt || min_gt) 1399: val = integer_zero_node; 1400: } 1401: else if (code == LT_EXPR) 1402: { 1403: if (max_lt) 1404: val = integer_one_node; 1405: if (!min_lt) 1406: val = integer_zero_node; 1407: } 1408: else if (code == GT_EXPR) 1409: { 1410: if (min_gt) 1411: val = integer_one_node; 1412: if (!max_gt) 1413: val = integer_zero_node; 1414: } 1415: else if (code == LE_EXPR) 1416: { 1417: if (!max_gt) 1418: val = integer_one_node; 1419: if (min_gt) 1420: val = integer_zero_node; 1421: } 1422: else if (code == GE_EXPR) 1423: { 1424: if (!min_lt) 1425: val = integer_one_node; 1426: if (max_lt) 1427: val = integer_zero_node; 1428: } 1429: 1430: /* If primop0 was sign-extended and unsigned comparison specd, 1431: we did a signed comparison above using the signed type bounds. 1432: But the comparison we output must be unsigned. 1433: 1434: Also, for inequalities, VAL is no good; but if the signed 1435: comparison had *any* fixed result, it follows that the 1436: unsigned comparison just tests the sign in reverse 1437: (positive values are LE, negative ones GE). 1438: So we can generate an unsigned comparison 1439: against an extreme value of the signed type. */ 1440: 1441: if (unsignedp && !unsignedp0) 1442: { 1443: if (val != 0) 1444: switch (code) 1445: { 1446: case LT_EXPR: 1447: case GE_EXPR: 1448: primop1 = TYPE_MIN_VALUE (type); 1449: val = 0; 1450: break; 1451: 1452: case LE_EXPR: 1453: case GT_EXPR: 1454: primop1 = TYPE_MAX_VALUE (type); 1455: val = 0; 1456: break; 1457: } 1458: type = unsigned_type (type); 1459: } 1460: 1.1.1.5 ! root 1461: if (!max_gt && !unsignedp0 && TREE_CODE (primop0) != INTEGER_CST) 1.1 root 1462: { 1463: /* This is the case of (char)x >?< 0x80, which people used to use 1464: expecting old C compilers to change the 0x80 into -0x80. */ 1465: if (val == integer_zero_node) 1466: warning ("comparison is always 0 due to limited range of data type"); 1467: if (val == integer_one_node) 1468: warning ("comparison is always 1 due to limited range of data type"); 1469: } 1470: 1.1.1.5 ! root 1471: if (!min_lt && unsignedp0 && TREE_CODE (primop0) != INTEGER_CST) 1.1 root 1472: { 1.1.1.2 root 1473: /* This is the case of (unsigned char)x >?< -1 or < 0. */ 1.1 root 1474: if (val == integer_zero_node) 1475: warning ("comparison is always 0 due to limited range of data type"); 1476: if (val == integer_one_node) 1477: warning ("comparison is always 1 due to limited range of data type"); 1478: } 1479: 1480: if (val != 0) 1481: { 1482: /* Don't forget to evaluate PRIMOP0 if it has side effects. */ 1483: if (TREE_SIDE_EFFECTS (primop0)) 1484: return build (COMPOUND_EXPR, TREE_TYPE (val), primop0, val); 1485: return val; 1486: } 1487: 1488: /* Value is not predetermined, but do the comparison 1489: in the type of the operand that is not constant. 1490: TYPE is already properly set. */ 1491: } 1492: else if (real1 && real2 1.1.1.4 root 1493: && (TYPE_PRECISION (TREE_TYPE (primop0)) 1494: == TYPE_PRECISION (TREE_TYPE (primop1)))) 1.1 root 1495: type = TREE_TYPE (primop0); 1496: 1497: /* If args' natural types are both narrower than nominal type 1498: and both extend in the same manner, compare them 1499: in the type of the wider arg. 1500: Otherwise must actually extend both to the nominal 1501: common type lest different ways of extending 1502: alter the result. 1503: (eg, (short)-1 == (unsigned short)-1 should be 0.) */ 1504: 1505: else if (unsignedp0 == unsignedp1 && real1 == real2 1506: && TYPE_PRECISION (TREE_TYPE (primop0)) < TYPE_PRECISION (*restype_ptr) 1507: && TYPE_PRECISION (TREE_TYPE (primop1)) < TYPE_PRECISION (*restype_ptr)) 1508: { 1509: type = common_type (TREE_TYPE (primop0), TREE_TYPE (primop1)); 1510: type = signed_or_unsigned_type (unsignedp0 1511: || TREE_UNSIGNED (*restype_ptr), 1512: type); 1513: /* Make sure shorter operand is extended the right way 1514: to match the longer operand. */ 1515: primop0 = convert (signed_or_unsigned_type (unsignedp0, TREE_TYPE (primop0)), 1516: primop0); 1517: primop1 = convert (signed_or_unsigned_type (unsignedp1, TREE_TYPE (primop1)), 1518: primop1); 1519: } 1520: else 1521: { 1522: /* Here we must do the comparison on the nominal type 1523: using the args exactly as we received them. */ 1524: type = *restype_ptr; 1525: primop0 = op0; 1526: primop1 = op1; 1527: 1528: if (!real1 && !real2 && integer_zerop (primop1) 1529: && TREE_UNSIGNED (TREE_TYPE (primop0))) 1530: { 1531: tree value = 0; 1532: switch (code) 1533: { 1534: case GE_EXPR: 1535: if (extra_warnings) 1536: warning ("unsigned value >= 0 is always 1"); 1537: value = integer_one_node; 1538: break; 1539: 1540: case LT_EXPR: 1541: if (extra_warnings) 1542: warning ("unsigned value < 0 is always 0"); 1543: value = integer_zero_node; 1544: } 1545: 1546: if (value != 0) 1547: { 1548: /* Don't forget to evaluate PRIMOP0 if it has side effects. */ 1549: if (TREE_SIDE_EFFECTS (primop0)) 1550: return build (COMPOUND_EXPR, TREE_TYPE (value), 1551: primop0, value); 1552: return value; 1553: } 1554: } 1555: } 1556: 1557: *op0_ptr = convert (type, primop0); 1558: *op1_ptr = convert (type, primop1); 1559: 1560: *restype_ptr = integer_type_node; 1561: 1562: return 0; 1563: } 1564: 1565: /* Prepare expr to be an argument of a TRUTH_NOT_EXPR, 1566: or validate its data type for an `if' or `while' statement or ?..: exp. 1567: 1568: This preparation consists of taking the ordinary 1569: representation of an expression expr and producing a valid tree 1570: boolean expression describing whether expr is nonzero. We could 1571: simply always do build_binary_op (NE_EXPR, expr, integer_zero_node, 1), 1572: but we optimize comparisons, &&, ||, and !. 1573: 1574: The resulting type should always be `integer_type_node'. */ 1575: 1576: tree 1577: truthvalue_conversion (expr) 1578: tree expr; 1579: { 1580: register enum tree_code code; 1581: 1.1.1.4 root 1582: if (TREE_CODE (expr) == ERROR_MARK) 1583: return expr; 1584: 1585: #if 0 /* This appears to be wrong for C++. */ 1586: /* These really should return error_mark_node after 2.4 is stable. 1587: But not all callers handle ERROR_MARK properly. */ 1588: switch (TREE_CODE (TREE_TYPE (expr))) 1589: { 1590: case RECORD_TYPE: 1591: error ("struct type value used where scalar is required"); 1592: return integer_zero_node; 1593: 1594: case UNION_TYPE: 1595: error ("union type value used where scalar is required"); 1596: return integer_zero_node; 1597: 1598: case ARRAY_TYPE: 1599: error ("array type value used where scalar is required"); 1600: return integer_zero_node; 1601: 1602: default: 1603: break; 1604: } 1605: #endif /* 0 */ 1606: 1.1 root 1607: switch (TREE_CODE (expr)) 1608: { 1609: /* It is simpler and generates better code to have only TRUTH_*_EXPR 1610: or comparison expressions as truth values at this level. */ 1611: #if 0 1612: case COMPONENT_REF: 1613: /* A one-bit unsigned bit-field is already acceptable. */ 1614: if (1 == TREE_INT_CST_LOW (DECL_SIZE (TREE_OPERAND (expr, 1))) 1615: && TREE_UNSIGNED (TREE_OPERAND (expr, 1))) 1616: return expr; 1617: break; 1618: #endif 1619: 1620: case EQ_EXPR: 1621: /* It is simpler and generates better code to have only TRUTH_*_EXPR 1622: or comparison expressions as truth values at this level. */ 1623: #if 0 1624: if (integer_zerop (TREE_OPERAND (expr, 1))) 1625: return build_unary_op (TRUTH_NOT_EXPR, TREE_OPERAND (expr, 0), 0); 1626: #endif 1627: case NE_EXPR: case LE_EXPR: case GE_EXPR: case LT_EXPR: case GT_EXPR: 1628: case TRUTH_ANDIF_EXPR: 1629: case TRUTH_ORIF_EXPR: 1630: case TRUTH_AND_EXPR: 1631: case TRUTH_OR_EXPR: 1.1.1.4 root 1632: case TRUTH_XOR_EXPR: 1.1 root 1633: case ERROR_MARK: 1634: return expr; 1635: 1636: case INTEGER_CST: 1637: return integer_zerop (expr) ? integer_zero_node : integer_one_node; 1638: 1639: case REAL_CST: 1640: return real_zerop (expr) ? integer_zero_node : integer_one_node; 1641: 1642: case ADDR_EXPR: 1643: if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 0))) 1644: return build (COMPOUND_EXPR, integer_type_node, 1645: TREE_OPERAND (expr, 0), integer_one_node); 1646: else 1647: return integer_one_node; 1648: 1.1.1.4 root 1649: case COMPLEX_EXPR: 1650: return build_binary_op ((TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1)) 1.1.1.5 ! root 1651: ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), 1.1.1.4 root 1652: truthvalue_conversion (TREE_OPERAND (expr, 0)), 1653: truthvalue_conversion (TREE_OPERAND (expr, 1)), 1654: 0); 1655: 1.1 root 1656: case NEGATE_EXPR: 1657: case ABS_EXPR: 1658: case FLOAT_EXPR: 1659: case FFS_EXPR: 1660: /* These don't change whether an object is non-zero or zero. */ 1661: return truthvalue_conversion (TREE_OPERAND (expr, 0)); 1662: 1663: case LROTATE_EXPR: 1664: case RROTATE_EXPR: 1665: /* These don't change whether an object is zero or non-zero, but 1666: we can't ignore them if their second arg has side-effects. */ 1667: if (TREE_SIDE_EFFECTS (TREE_OPERAND (expr, 1))) 1668: return build (COMPOUND_EXPR, integer_type_node, TREE_OPERAND (expr, 1), 1669: truthvalue_conversion (TREE_OPERAND (expr, 0))); 1670: else 1671: return truthvalue_conversion (TREE_OPERAND (expr, 0)); 1672: 1673: case COND_EXPR: 1674: /* Distribute the conversion into the arms of a COND_EXPR. */ 1675: return fold (build (COND_EXPR, integer_type_node, TREE_OPERAND (expr, 0), 1676: truthvalue_conversion (TREE_OPERAND (expr, 1)), 1677: truthvalue_conversion (TREE_OPERAND (expr, 2)))); 1678: 1679: case CONVERT_EXPR: 1680: /* Don't cancel the effect of a CONVERT_EXPR from a REFERENCE_TYPE, 1681: since that affects how `default_conversion' will behave. */ 1682: if (TREE_CODE (TREE_TYPE (expr)) == REFERENCE_TYPE 1683: || TREE_CODE (TREE_TYPE (TREE_OPERAND (expr, 0))) == REFERENCE_TYPE) 1684: break; 1685: /* fall through... */ 1686: case NOP_EXPR: 1687: /* If this is widening the argument, we can ignore it. */ 1688: if (TYPE_PRECISION (TREE_TYPE (expr)) 1689: >= TYPE_PRECISION (TREE_TYPE (TREE_OPERAND (expr, 0)))) 1690: return truthvalue_conversion (TREE_OPERAND (expr, 0)); 1691: break; 1692: 1693: case MINUS_EXPR: 1.1.1.4 root 1694: /* With IEEE arithmetic, x - x may not equal 0, so we can't optimize 1695: this case. */ 1696: if (TARGET_FLOAT_FORMAT == IEEE_FLOAT_FORMAT 1697: && TREE_CODE (TREE_TYPE (expr)) == REAL_TYPE) 1698: break; 1699: /* fall through... */ 1700: case BIT_XOR_EXPR: 1701: /* This and MINUS_EXPR can be changed into a comparison of the 1702: two objects. */ 1.1 root 1703: if (TREE_TYPE (TREE_OPERAND (expr, 0)) 1704: == TREE_TYPE (TREE_OPERAND (expr, 1))) 1705: return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0), 1706: TREE_OPERAND (expr, 1), 1); 1707: return build_binary_op (NE_EXPR, TREE_OPERAND (expr, 0), 1708: fold (build1 (NOP_EXPR, 1709: TREE_TYPE (TREE_OPERAND (expr, 0)), 1710: TREE_OPERAND (expr, 1))), 1); 1.1.1.3 root 1711: 1712: case MODIFY_EXPR: 1713: if (warn_parentheses && C_EXP_ORIGINAL_CODE (expr) == MODIFY_EXPR) 1714: warning ("suggest parentheses around assignment used as truth value"); 1715: break; 1.1 root 1716: } 1717: 1.1.1.4 root 1718: if (TREE_CODE (TREE_TYPE (expr)) == COMPLEX_TYPE) 1719: return (build_binary_op 1720: ((TREE_SIDE_EFFECTS (expr) 1.1.1.5 ! root 1721: ? TRUTH_OR_EXPR : TRUTH_ORIF_EXPR), 1.1.1.4 root 1722: truthvalue_conversion (build_unary_op (REALPART_EXPR, expr, 0)), 1723: truthvalue_conversion (build_unary_op (IMAGPART_EXPR, expr, 0)), 1724: 0)); 1725: 1.1 root 1726: return build_binary_op (NE_EXPR, expr, integer_zero_node, 1); 1727: } 1728: 1729: /* Read the rest of a #-directive from input stream FINPUT. 1730: In normal use, the directive name and the white space after it 1731: have already been read, so they won't be included in the result. 1732: We allow for the fact that the directive line may contain 1733: a newline embedded within a character or string literal which forms 1734: a part of the directive. 1735: 1736: The value is a string in a reusable buffer. It remains valid 1737: only until the next time this function is called. */ 1738: 1739: char * 1740: get_directive_line (finput) 1741: register FILE *finput; 1742: { 1743: static char *directive_buffer = NULL; 1744: static unsigned buffer_length = 0; 1745: register char *p; 1746: register char *buffer_limit; 1747: register int looking_for = 0; 1748: register int char_escaped = 0; 1749: 1750: if (buffer_length == 0) 1751: { 1752: directive_buffer = (char *)xmalloc (128); 1753: buffer_length = 128; 1754: } 1755: 1756: buffer_limit = &directive_buffer[buffer_length]; 1757: 1758: for (p = directive_buffer; ; ) 1759: { 1760: int c; 1761: 1762: /* Make buffer bigger if it is full. */ 1763: if (p >= buffer_limit) 1764: { 1765: register unsigned bytes_used = (p - directive_buffer); 1766: 1767: buffer_length *= 2; 1768: directive_buffer 1769: = (char *)xrealloc (directive_buffer, buffer_length); 1770: p = &directive_buffer[bytes_used]; 1771: buffer_limit = &directive_buffer[buffer_length]; 1772: } 1773: 1774: c = getc (finput); 1775: 1776: /* Discard initial whitespace. */ 1777: if ((c == ' ' || c == '\t') && p == directive_buffer) 1778: continue; 1779: 1780: /* Detect the end of the directive. */ 1781: if (c == '\n' && looking_for == 0) 1782: { 1783: ungetc (c, finput); 1784: c = '\0'; 1785: } 1786: 1787: *p++ = c; 1788: 1789: if (c == 0) 1790: return directive_buffer; 1791: 1792: /* Handle string and character constant syntax. */ 1793: if (looking_for) 1794: { 1795: if (looking_for == c && !char_escaped) 1796: looking_for = 0; /* Found terminator... stop looking. */ 1797: } 1798: else 1799: if (c == '\'' || c == '"') 1800: looking_for = c; /* Don't stop buffering until we see another 1801: another one of these (or an EOF). */ 1802: 1803: /* Handle backslash. */ 1804: char_escaped = (c == '\\' && ! char_escaped); 1805: } 1806: } 1.1.1.4 root 1807: 1808: /* Make a variant type in the proper way for C/C++, propagating qualifiers 1809: down to the element type of an array. */ 1810: 1811: tree 1812: c_build_type_variant (type, constp, volatilep) 1813: tree type; 1814: int constp, volatilep; 1815: { 1816: if (TREE_CODE (type) == ARRAY_TYPE) 1817: { 1818: tree real_main_variant = TYPE_MAIN_VARIANT (type); 1819: 1.1.1.5 ! root 1820: push_obstacks (TYPE_OBSTACK (type), TYPE_OBSTACK (type)); 1.1.1.4 root 1821: type = build_array_type (c_build_type_variant (TREE_TYPE (type), 1822: constp, volatilep), 1823: TYPE_DOMAIN (type)); 1824: TYPE_MAIN_VARIANT (type) = real_main_variant; 1.1.1.5 ! root 1825: pop_obstacks (); 1.1.1.4 root 1826: } 1827: return build_type_variant (type, constp, volatilep); 1828: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.