c-lex.c (132727) | c-lex.c (169699) |
---|---|
1/* Mainly the interface between cpplib and the C front ends. 2 Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997 | 1/* Mainly the interface between cpplib and the C front ends. 2 Copyright (C) 1987, 1988, 1989, 1992, 1994, 1995, 1996, 1997 |
3 1998, 1999, 2000, 2001, 2002, 2003, 2004 Free Software Foundation, Inc. | 3 1998, 1999, 2000, 2001, 2002, 2003, 2004, 2005 4 Free Software Foundation, Inc. |
4 5This file is part of GCC. 6 7GCC is free software; you can redistribute it and/or modify it under 8the terms of the GNU General Public License as published by the Free 9Software Foundation; either version 2, or (at your option) any later 10version. 11 12GCC is distributed in the hope that it will be useful, but WITHOUT ANY 13WARRANTY; without even the implied warranty of MERCHANTABILITY or 14FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 15for more details. 16 17You should have received a copy of the GNU General Public License 18along with GCC; see the file COPYING. If not, write to the Free | 5 6This file is part of GCC. 7 8GCC is free software; you can redistribute it and/or modify it under 9the terms of the GNU General Public License as published by the Free 10Software Foundation; either version 2, or (at your option) any later 11version. 12 13GCC is distributed in the hope that it will be useful, but WITHOUT ANY 14WARRANTY; without even the implied warranty of MERCHANTABILITY or 15FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License 16for more details. 17 18You should have received a copy of the GNU General Public License 19along with GCC; see the file COPYING. If not, write to the Free |
19Software Foundation, 59 Temple Place - Suite 330, Boston, MA 2002111-1307, USA. */ | 20Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA 2102110-1301, USA. */ |
21 22#include "config.h" 23#include "system.h" 24#include "coretypes.h" 25#include "tm.h" 26 27#include "real.h" 28#include "rtl.h" 29#include "tree.h" | 22 23#include "config.h" 24#include "system.h" 25#include "coretypes.h" 26#include "tm.h" 27 28#include "real.h" 29#include "rtl.h" 30#include "tree.h" |
30#include "expr.h" | |
31#include "input.h" 32#include "output.h" 33#include "c-tree.h" 34#include "c-common.h" 35#include "flags.h" 36#include "timevar.h" 37#include "cpplib.h" 38#include "c-pragma.h" 39#include "toplev.h" 40#include "intl.h" 41#include "tm_p.h" 42#include "splay-tree.h" 43#include "debug.h" 44 | 31#include "input.h" 32#include "output.h" 33#include "c-tree.h" 34#include "c-common.h" 35#include "flags.h" 36#include "timevar.h" 37#include "cpplib.h" 38#include "c-pragma.h" 39#include "toplev.h" 40#include "intl.h" 41#include "tm_p.h" 42#include "splay-tree.h" 43#include "debug.h" 44 |
45/* The current line map. */ 46static const struct line_map *map; 47 | |
48/* We may keep statistics about how long which files took to compile. */ 49static int header_time, body_time; 50static splay_tree file_info_tree; 51 | 45/* We may keep statistics about how long which files took to compile. */ 46static int header_time, body_time; 47static splay_tree file_info_tree; 48 |
52#undef WCHAR_TYPE_SIZE 53#define WCHAR_TYPE_SIZE TYPE_PRECISION (wchar_type_node) 54 55/* Number of bytes in a wide character. */ 56#define WCHAR_BYTES (WCHAR_TYPE_SIZE / BITS_PER_UNIT) 57 | |
58int pending_lang_change; /* If we need to switch languages - C++ only */ 59int c_header_level; /* depth in C headers - C++ only */ 60 | 49int pending_lang_change; /* If we need to switch languages - C++ only */ 50int c_header_level; /* depth in C headers - C++ only */ 51 |
52/* If we need to translate characters received. This is tri-state: 53 0 means use only the untranslated string; 1 means use only 54 the translated string; -1 means chain the translated string 55 to the untranslated one. */ 56int c_lex_string_translate = 1; 57 58/* True if strings should be passed to the caller of c_lex completely 59 unmolested (no concatenation, no translation). */ 60bool c_lex_return_raw_strings = false; 61 |
|
61static tree interpret_integer (const cpp_token *, unsigned int); 62static tree interpret_float (const cpp_token *, unsigned int); | 62static tree interpret_integer (const cpp_token *, unsigned int); 63static tree interpret_float (const cpp_token *, unsigned int); |
63static enum integer_type_kind 64 narrowest_unsigned_type (tree, unsigned int); 65static enum integer_type_kind 66 narrowest_signed_type (tree, unsigned int); | 64static enum integer_type_kind narrowest_unsigned_type 65 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int); 66static enum integer_type_kind narrowest_signed_type 67 (unsigned HOST_WIDE_INT, unsigned HOST_WIDE_INT, unsigned int); |
67static enum cpp_ttype lex_string (const cpp_token *, tree *, bool); 68static tree lex_charconst (const cpp_token *); 69static void update_header_times (const char *); 70static int dump_one_header (splay_tree_node, void *); 71static void cb_line_change (cpp_reader *, const cpp_token *, int); 72static void cb_ident (cpp_reader *, unsigned int, const cpp_string *); 73static void cb_def_pragma (cpp_reader *, unsigned int); 74static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *); 75static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *); 76 77void 78init_c_lex (void) 79{ 80 struct cpp_callbacks *cb; 81 struct c_fileinfo *toplevel; 82 | 68static enum cpp_ttype lex_string (const cpp_token *, tree *, bool); 69static tree lex_charconst (const cpp_token *); 70static void update_header_times (const char *); 71static int dump_one_header (splay_tree_node, void *); 72static void cb_line_change (cpp_reader *, const cpp_token *, int); 73static void cb_ident (cpp_reader *, unsigned int, const cpp_string *); 74static void cb_def_pragma (cpp_reader *, unsigned int); 75static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *); 76static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *); 77 78void 79init_c_lex (void) 80{ 81 struct cpp_callbacks *cb; 82 struct c_fileinfo *toplevel; 83 |
83 /* Set up filename timing. Must happen before cpp_read_main_file. */ 84 file_info_tree = splay_tree_new ((splay_tree_compare_fn)strcmp, 85 0, 86 (splay_tree_delete_value_fn)free); | 84 /* The get_fileinfo data structure must be initialized before 85 cpp_read_main_file is called. */ |
87 toplevel = get_fileinfo ("<top level>"); 88 if (flag_detailed_statistics) 89 { 90 header_time = 0; 91 body_time = get_run_time (); 92 toplevel->time = body_time; 93 } 94 95 cb = cpp_get_callbacks (parse_in); 96 97 cb->line_change = cb_line_change; 98 cb->ident = cb_ident; 99 cb->def_pragma = cb_def_pragma; 100 cb->valid_pch = c_common_valid_pch; 101 cb->read_pch = c_common_read_pch; 102 103 /* Set the debug callbacks if we can use them. */ 104 if (debug_info_level == DINFO_LEVEL_VERBOSE | 86 toplevel = get_fileinfo ("<top level>"); 87 if (flag_detailed_statistics) 88 { 89 header_time = 0; 90 body_time = get_run_time (); 91 toplevel->time = body_time; 92 } 93 94 cb = cpp_get_callbacks (parse_in); 95 96 cb->line_change = cb_line_change; 97 cb->ident = cb_ident; 98 cb->def_pragma = cb_def_pragma; 99 cb->valid_pch = c_common_valid_pch; 100 cb->read_pch = c_common_read_pch; 101 102 /* Set the debug callbacks if we can use them. */ 103 if (debug_info_level == DINFO_LEVEL_VERBOSE |
105 && (write_symbols == DWARF_DEBUG || write_symbols == DWARF2_DEBUG 106 || write_symbols == VMS_AND_DWARF2_DEBUG)) | 104 && (write_symbols == DWARF2_DEBUG 105 || write_symbols == VMS_AND_DWARF2_DEBUG)) |
107 { 108 cb->define = cb_define; 109 cb->undef = cb_undef; 110 } 111} 112 113struct c_fileinfo * 114get_fileinfo (const char *name) 115{ 116 splay_tree_node n; 117 struct c_fileinfo *fi; 118 | 106 { 107 cb->define = cb_define; 108 cb->undef = cb_undef; 109 } 110} 111 112struct c_fileinfo * 113get_fileinfo (const char *name) 114{ 115 splay_tree_node n; 116 struct c_fileinfo *fi; 117 |
118 if (!file_info_tree) 119 file_info_tree = splay_tree_new ((splay_tree_compare_fn) strcmp, 120 0, 121 (splay_tree_delete_value_fn) free); 122 |
|
119 n = splay_tree_lookup (file_info_tree, (splay_tree_key) name); 120 if (n) 121 return (struct c_fileinfo *) n->value; 122 | 123 n = splay_tree_lookup (file_info_tree, (splay_tree_key) name); 124 if (n) 125 return (struct c_fileinfo *) n->value; 126 |
123 fi = xmalloc (sizeof (struct c_fileinfo)); | 127 fi = XNEW (struct c_fileinfo); |
124 fi->time = 0; 125 fi->interface_only = 0; 126 fi->interface_unknown = 1; 127 splay_tree_insert (file_info_tree, (splay_tree_key) name, 128 (splay_tree_value) fi); 129 return fi; 130} 131 --- 8 unchanged lines hidden (view full) --- 140 struct c_fileinfo *file = get_fileinfo (name); 141 header_time += this_time - body_time; 142 file->time += this_time - body_time; 143 body_time = this_time; 144 } 145} 146 147static int | 128 fi->time = 0; 129 fi->interface_only = 0; 130 fi->interface_unknown = 1; 131 splay_tree_insert (file_info_tree, (splay_tree_key) name, 132 (splay_tree_value) fi); 133 return fi; 134} 135 --- 8 unchanged lines hidden (view full) --- 144 struct c_fileinfo *file = get_fileinfo (name); 145 header_time += this_time - body_time; 146 file->time += this_time - body_time; 147 body_time = this_time; 148 } 149} 150 151static int |
148dump_one_header (splay_tree_node n, void *dummy ATTRIBUTE_UNUSED) | 152dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy)) |
149{ 150 print_time ((const char *) n->key, 151 ((struct c_fileinfo *) n->value)->time); 152 return 0; 153} 154 155void 156dump_time_statistics (void) 157{ 158 struct c_fileinfo *file = get_fileinfo (input_filename); 159 int this_time = get_run_time (); 160 file->time += this_time - body_time; 161 162 fprintf (stderr, "\n******\n"); 163 print_time ("header files (total)", header_time); 164 print_time ("main file (total)", this_time - body_time); 165 fprintf (stderr, "ratio = %g : 1\n", | 153{ 154 print_time ((const char *) n->key, 155 ((struct c_fileinfo *) n->value)->time); 156 return 0; 157} 158 159void 160dump_time_statistics (void) 161{ 162 struct c_fileinfo *file = get_fileinfo (input_filename); 163 int this_time = get_run_time (); 164 file->time += this_time - body_time; 165 166 fprintf (stderr, "\n******\n"); 167 print_time ("header files (total)", header_time); 168 print_time ("main file (total)", this_time - body_time); 169 fprintf (stderr, "ratio = %g : 1\n", |
166 (double)header_time / (double)(this_time - body_time)); | 170 (double) header_time / (double) (this_time - body_time)); |
167 fprintf (stderr, "\n******\n"); 168 169 splay_tree_foreach (file_info_tree, dump_one_header, 0); 170} 171 172static void | 171 fprintf (stderr, "\n******\n"); 172 173 splay_tree_foreach (file_info_tree, dump_one_header, 0); 174} 175 176static void |
173cb_ident (cpp_reader *pfile ATTRIBUTE_UNUSED, 174 unsigned int line ATTRIBUTE_UNUSED, 175 const cpp_string *str ATTRIBUTE_UNUSED) | 177cb_ident (cpp_reader * ARG_UNUSED (pfile), 178 unsigned int ARG_UNUSED (line), 179 const cpp_string * ARG_UNUSED (str)) |
176{ 177#ifdef ASM_OUTPUT_IDENT | 180{ 181#ifdef ASM_OUTPUT_IDENT |
178 if (! flag_no_ident) | 182 if (!flag_no_ident) |
179 { 180 /* Convert escapes in the string. */ 181 cpp_string cstr = { 0, 0 }; 182 if (cpp_interpret_string (pfile, str, 1, &cstr, false)) 183 { 184 ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text); | 183 { 184 /* Convert escapes in the string. */ 185 cpp_string cstr = { 0, 0 }; 186 if (cpp_interpret_string (pfile, str, 1, &cstr, false)) 187 { 188 ASM_OUTPUT_IDENT (asm_out_file, (const char *) cstr.text); |
185 free ((void *)cstr.text); | 189 free ((void *) cstr.text); |
186 } 187 } 188#endif 189} 190 191/* Called at the start of every non-empty line. TOKEN is the first 192 lexed token on the line. Used for diagnostic line numbers. */ 193static void | 190 } 191 } 192#endif 193} 194 195/* Called at the start of every non-empty line. TOKEN is the first 196 lexed token on the line. Used for diagnostic line numbers. */ 197static void |
194cb_line_change (cpp_reader *pfile ATTRIBUTE_UNUSED, const cpp_token *token, | 198cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token, |
195 int parsing_args) 196{ | 199 int parsing_args) 200{ |
197 if (token->type == CPP_EOF || parsing_args) 198 return; 199 200 input_line = SOURCE_LINE (map, token->line); | 201 if (token->type != CPP_EOF && !parsing_args) 202#ifdef USE_MAPPED_LOCATION 203 input_location = token->src_loc; 204#else 205 { 206 source_location loc = token->src_loc; 207 const struct line_map *map = linemap_lookup (&line_table, loc); 208 input_line = SOURCE_LINE (map, loc); 209 } 210#endif |
201} 202 203void 204fe_file_change (const struct line_map *new_map) 205{ 206 if (new_map == NULL) | 211} 212 213void 214fe_file_change (const struct line_map *new_map) 215{ 216 if (new_map == NULL) |
207 { 208 map = NULL; 209 return; 210 } | 217 return; |
211 212 if (new_map->reason == LC_ENTER) 213 { 214 /* Don't stack the main buffer on the input stack; 215 we already did in compile_file. */ | 218 219 if (new_map->reason == LC_ENTER) 220 { 221 /* Don't stack the main buffer on the input stack; 222 we already did in compile_file. */ |
216 if (map != NULL) | 223 if (!MAIN_FILE_P (new_map)) |
217 { | 224 { |
218 int included_at = SOURCE_LINE (new_map - 1, new_map->from_line - 1); | 225#ifdef USE_MAPPED_LOCATION 226 int included_at = LAST_SOURCE_LINE_LOCATION (new_map - 1); |
219 | 227 |
228 input_location = included_at; 229 push_srcloc (new_map->start_location); 230#else 231 int included_at = LAST_SOURCE_LINE (new_map - 1); 232 |
|
220 input_line = included_at; 221 push_srcloc (new_map->to_file, 1); | 233 input_line = included_at; 234 push_srcloc (new_map->to_file, 1); |
235#endif |
|
222 (*debug_hooks->start_source_file) (included_at, new_map->to_file); 223#ifndef NO_IMPLICIT_EXTERN_C 224 if (c_header_level) 225 ++c_header_level; 226 else if (new_map->sysp == 2) 227 { 228 c_header_level = 1; 229 ++pending_lang_change; 230 } 231#endif 232 } 233 } 234 else if (new_map->reason == LC_LEAVE) 235 { 236#ifndef NO_IMPLICIT_EXTERN_C 237 if (c_header_level && --c_header_level == 0) 238 { 239 if (new_map->sysp == 2) | 236 (*debug_hooks->start_source_file) (included_at, new_map->to_file); 237#ifndef NO_IMPLICIT_EXTERN_C 238 if (c_header_level) 239 ++c_header_level; 240 else if (new_map->sysp == 2) 241 { 242 c_header_level = 1; 243 ++pending_lang_change; 244 } 245#endif 246 } 247 } 248 else if (new_map->reason == LC_LEAVE) 249 { 250#ifndef NO_IMPLICIT_EXTERN_C 251 if (c_header_level && --c_header_level == 0) 252 { 253 if (new_map->sysp == 2) |
240 warning ("badly nested C headers from preprocessor"); | 254 warning (0, "badly nested C headers from preprocessor"); |
241 --pending_lang_change; 242 } 243#endif 244 pop_srcloc (); 245 246 (*debug_hooks->end_source_file) (new_map->to_line); 247 } 248 249 update_header_times (new_map->to_file); 250 in_system_header = new_map->sysp != 0; | 255 --pending_lang_change; 256 } 257#endif 258 pop_srcloc (); 259 260 (*debug_hooks->end_source_file) (new_map->to_line); 261 } 262 263 update_header_times (new_map->to_file); 264 in_system_header = new_map->sysp != 0; |
265#ifdef USE_MAPPED_LOCATION 266 input_location = new_map->start_location; 267#else |
|
251 input_filename = new_map->to_file; 252 input_line = new_map->to_line; | 268 input_filename = new_map->to_file; 269 input_line = new_map->to_line; |
253 map = new_map; 254 255 /* Hook for C++. */ 256 extract_interface_info (); | 270#endif |
257} 258 259static void | 271} 272 273static void |
260cb_def_pragma (cpp_reader *pfile, unsigned int line) | 274cb_def_pragma (cpp_reader *pfile, source_location loc) |
261{ 262 /* Issue a warning message if we have been asked to do so. Ignore 263 unknown pragmas in system headers unless an explicit 264 -Wunknown-pragmas has been given. */ 265 if (warn_unknown_pragmas > in_system_header) 266 { 267 const unsigned char *space, *name; 268 const cpp_token *s; | 275{ 276 /* Issue a warning message if we have been asked to do so. Ignore 277 unknown pragmas in system headers unless an explicit 278 -Wunknown-pragmas has been given. */ 279 if (warn_unknown_pragmas > in_system_header) 280 { 281 const unsigned char *space, *name; 282 const cpp_token *s; |
283#ifndef USE_MAPPED_LOCATION 284 location_t fe_loc; 285 const struct line_map *map = linemap_lookup (&line_table, loc); 286 fe_loc.file = map->to_file; 287 fe_loc.line = SOURCE_LINE (map, loc); 288#else 289 location_t fe_loc = loc; 290#endif |
|
269 270 space = name = (const unsigned char *) ""; 271 s = cpp_get_token (pfile); 272 if (s->type != CPP_EOF) 273 { 274 space = cpp_token_as_text (pfile, s); 275 s = cpp_get_token (pfile); 276 if (s->type == CPP_NAME) 277 name = cpp_token_as_text (pfile, s); 278 } 279 | 291 292 space = name = (const unsigned char *) ""; 293 s = cpp_get_token (pfile); 294 if (s->type != CPP_EOF) 295 { 296 space = cpp_token_as_text (pfile, s); 297 s = cpp_get_token (pfile); 298 if (s->type == CPP_NAME) 299 name = cpp_token_as_text (pfile, s); 300 } 301 |
280 input_line = SOURCE_LINE (map, line); 281 warning ("ignoring #pragma %s %s", space, name); | 302 warning (OPT_Wunknown_pragmas, "%Hignoring #pragma %s %s", 303 &fe_loc, space, name); |
282 } 283} 284 285/* #define callback for DWARF and DWARF2 debug info. */ 286static void | 304 } 305} 306 307/* #define callback for DWARF and DWARF2 debug info. */ 308static void |
287cb_define (cpp_reader *pfile, unsigned int line, cpp_hashnode *node) | 309cb_define (cpp_reader *pfile, source_location loc, cpp_hashnode *node) |
288{ | 310{ |
289 (*debug_hooks->define) (SOURCE_LINE (map, line), | 311 const struct line_map *map = linemap_lookup (&line_table, loc); 312 (*debug_hooks->define) (SOURCE_LINE (map, loc), |
290 (const char *) cpp_macro_definition (pfile, node)); 291} 292 293/* #undef callback for DWARF and DWARF2 debug info. */ 294static void | 313 (const char *) cpp_macro_definition (pfile, node)); 314} 315 316/* #undef callback for DWARF and DWARF2 debug info. */ 317static void |
295cb_undef (cpp_reader *pfile ATTRIBUTE_UNUSED, unsigned int line, | 318cb_undef (cpp_reader * ARG_UNUSED (pfile), source_location loc, |
296 cpp_hashnode *node) 297{ | 319 cpp_hashnode *node) 320{ |
298 (*debug_hooks->undef) (SOURCE_LINE (map, line), | 321 const struct line_map *map = linemap_lookup (&line_table, loc); 322 (*debug_hooks->undef) (SOURCE_LINE (map, loc), |
299 (const char *) NODE_NAME (node)); 300} 301 | 323 (const char *) NODE_NAME (node)); 324} 325 |
302static inline const cpp_token * 303get_nonpadding_token (void) 304{ 305 const cpp_token *tok; 306 timevar_push (TV_CPP); 307 do 308 tok = cpp_get_token (parse_in); 309 while (tok->type == CPP_PADDING); 310 timevar_pop (TV_CPP); | 326/* Read a token and return its type. Fill *VALUE with its value, if 327 applicable. Fill *CPP_FLAGS with the token's flags, if it is 328 non-NULL. */ |
311 | 329 |
312 return tok; 313} 314 315int 316c_lex_with_flags (tree *value, unsigned char *cpp_flags) | 330enum cpp_ttype 331c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags) |
317{ | 332{ |
318 const cpp_token *tok; 319 location_t atloc; | |
320 static bool no_more_pch; | 333 static bool no_more_pch; |
334 const cpp_token *tok; 335 enum cpp_ttype type; 336 unsigned char add_flags = 0; |
|
321 | 337 |
338 timevar_push (TV_CPP); |
|
322 retry: | 339 retry: |
323 tok = get_nonpadding_token (); | 340 tok = cpp_get_token (parse_in); 341 type = tok->type; |
324 325 retry_after_at: | 342 343 retry_after_at: |
326 switch (tok->type) | 344#ifdef USE_MAPPED_LOCATION 345 *loc = tok->src_loc; 346#else 347 *loc = input_location; 348#endif 349 switch (type) |
327 { | 350 { |
351 case CPP_PADDING: 352 goto retry; 353 |
|
328 case CPP_NAME: 329 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node)); 330 break; 331 332 case CPP_NUMBER: 333 { 334 unsigned int flags = cpp_classify_number (parse_in, tok); 335 336 switch (flags & CPP_N_CATEGORY) 337 { 338 case CPP_N_INVALID: 339 /* cpplib has issued an error. */ 340 *value = error_mark_node; | 354 case CPP_NAME: 355 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node)); 356 break; 357 358 case CPP_NUMBER: 359 { 360 unsigned int flags = cpp_classify_number (parse_in, tok); 361 362 switch (flags & CPP_N_CATEGORY) 363 { 364 case CPP_N_INVALID: 365 /* cpplib has issued an error. */ 366 *value = error_mark_node; |
367 errorcount++; |
|
341 break; 342 343 case CPP_N_INTEGER: | 368 break; 369 370 case CPP_N_INTEGER: |
371 /* C++ uses '0' to mark virtual functions as pure. 372 Set PURE_ZERO to pass this information to the C++ parser. */ 373 if (tok->val.str.len == 1 && *tok->val.str.text == '0') 374 add_flags = PURE_ZERO; |
|
344 *value = interpret_integer (tok, flags); 345 break; 346 347 case CPP_N_FLOATING: 348 *value = interpret_float (tok, flags); 349 break; 350 351 default: | 375 *value = interpret_integer (tok, flags); 376 break; 377 378 case CPP_N_FLOATING: 379 *value = interpret_float (tok, flags); 380 break; 381 382 default: |
352 abort (); | 383 gcc_unreachable (); |
353 } 354 } 355 break; 356 357 case CPP_ATSIGN: 358 /* An @ may give the next token special significance in Objective-C. */ | 384 } 385 } 386 break; 387 388 case CPP_ATSIGN: 389 /* An @ may give the next token special significance in Objective-C. */ |
359 atloc = input_location; 360 tok = get_nonpadding_token (); | |
361 if (c_dialect_objc ()) 362 { | 390 if (c_dialect_objc ()) 391 { |
363 tree val; 364 switch (tok->type) | 392 location_t atloc = input_location; 393 394 retry_at: 395 tok = cpp_get_token (parse_in); 396 type = tok->type; 397 switch (type) |
365 { | 398 { |
366 case CPP_NAME: 367 val = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node)); 368 if (C_IS_RESERVED_WORD (val) 369 && OBJC_IS_AT_KEYWORD (C_RID_CODE (val))) 370 { 371 *value = val; 372 return CPP_AT_NAME; 373 } 374 break; | 399 case CPP_PADDING: 400 goto retry_at; |
375 376 case CPP_STRING: 377 case CPP_WSTRING: | 401 402 case CPP_STRING: 403 case CPP_WSTRING: |
378 return lex_string (tok, value, true); | 404 type = lex_string (tok, value, true); 405 break; |
379 | 406 |
380 default: break; | 407 case CPP_NAME: 408 *value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node)); 409 if (objc_is_reserved_word (*value)) 410 { 411 type = CPP_AT_NAME; 412 break; 413 } 414 /* FALLTHROUGH */ 415 416 default: 417 /* ... or not. */ 418 error ("%Hstray %<@%> in program", &atloc); 419 goto retry_after_at; |
381 } | 420 } |
421 break; |
|
382 } 383 | 422 } 423 |
384 /* ... or not. */ 385 error ("%Hstray '@' in program", &atloc); 386 goto retry_after_at; | 424 /* FALLTHROUGH */ 425 case CPP_HASH: 426 case CPP_PASTE: 427 { 428 unsigned char name[4]; |
387 | 429 |
430 *cpp_spell_token (parse_in, tok, name, true) = 0; 431 432 error ("stray %qs in program", name); 433 } 434 435 goto retry; 436 |
|
388 case CPP_OTHER: 389 { 390 cppchar_t c = tok->val.str.text[0]; 391 392 if (c == '"' || c == '\'') 393 error ("missing terminating %c character", (int) c); 394 else if (ISGRAPH (c)) | 437 case CPP_OTHER: 438 { 439 cppchar_t c = tok->val.str.text[0]; 440 441 if (c == '"' || c == '\'') 442 error ("missing terminating %c character", (int) c); 443 else if (ISGRAPH (c)) |
395 error ("stray '%c' in program", (int) c); | 444 error ("stray %qc in program", (int) c); |
396 else | 445 else |
397 error ("stray '\\%o' in program", (int) c); | 446 error ("stray %<\\%o%> in program", (int) c); |
398 } 399 goto retry; 400 401 case CPP_CHAR: 402 case CPP_WCHAR: 403 *value = lex_charconst (tok); 404 break; 405 406 case CPP_STRING: 407 case CPP_WSTRING: | 447 } 448 goto retry; 449 450 case CPP_CHAR: 451 case CPP_WCHAR: 452 *value = lex_charconst (tok); 453 break; 454 455 case CPP_STRING: 456 case CPP_WSTRING: |
408 return lex_string (tok, value, false); | 457 if (!c_lex_return_raw_strings) 458 { 459 type = lex_string (tok, value, false); 460 break; 461 } 462 *value = build_string (tok->val.str.len, (char *) tok->val.str.text); |
409 break; | 463 break; |
464 465 case CPP_PRAGMA: 466 *value = build_int_cst (NULL, tok->val.pragma); 467 break; |
|
410 411 /* These tokens should not be visible outside cpplib. */ 412 case CPP_HEADER_NAME: 413 case CPP_COMMENT: 414 case CPP_MACRO_ARG: | 468 469 /* These tokens should not be visible outside cpplib. */ 470 case CPP_HEADER_NAME: 471 case CPP_COMMENT: 472 case CPP_MACRO_ARG: |
415 abort (); | 473 gcc_unreachable (); |
416 417 default: 418 *value = NULL_TREE; 419 break; 420 } 421 | 474 475 default: 476 *value = NULL_TREE; 477 break; 478 } 479 |
422 if (! no_more_pch) | 480 if (cpp_flags) 481 *cpp_flags = tok->flags | add_flags; 482 483 if (!no_more_pch) |
423 { 424 no_more_pch = true; 425 c_common_no_more_pch (); 426 } 427 | 484 { 485 no_more_pch = true; 486 c_common_no_more_pch (); 487 } 488 |
428 if (cpp_flags) 429 *cpp_flags = tok->flags; 430 return tok->type; 431} | 489 timevar_pop (TV_CPP); |
432 | 490 |
433int 434c_lex (tree *value) 435{ 436 return c_lex_with_flags (value, NULL); | 491 return type; |
437} 438 439/* Returns the narrowest C-visible unsigned type, starting with the | 492} 493 494/* Returns the narrowest C-visible unsigned type, starting with the |
440 minimum specified by FLAGS, that can fit VALUE, or itk_none if | 495 minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if |
441 there isn't one. */ | 496 there isn't one. */ |
497 |
|
442static enum integer_type_kind | 498static enum integer_type_kind |
443narrowest_unsigned_type (tree value, unsigned int flags) | 499narrowest_unsigned_type (unsigned HOST_WIDE_INT low, 500 unsigned HOST_WIDE_INT high, 501 unsigned int flags) |
444{ 445 enum integer_type_kind itk; 446 447 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL) 448 itk = itk_unsigned_int; 449 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM) 450 itk = itk_unsigned_long; 451 else 452 itk = itk_unsigned_long_long; 453 | 502{ 503 enum integer_type_kind itk; 504 505 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL) 506 itk = itk_unsigned_int; 507 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM) 508 itk = itk_unsigned_long; 509 else 510 itk = itk_unsigned_long_long; 511 |
454 /* int_fits_type_p must think the type of its first argument is 455 wider than its second argument, or it won't do the proper check. */ 456 TREE_TYPE (value) = widest_unsigned_literal_type_node; 457 | |
458 for (; itk < itk_none; itk += 2 /* skip unsigned types */) | 512 for (; itk < itk_none; itk += 2 /* skip unsigned types */) |
459 if (int_fits_type_p (value, integer_types[itk])) 460 return itk; | 513 { 514 tree upper = TYPE_MAX_VALUE (integer_types[itk]); |
461 | 515 |
516 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high 517 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high 518 && TREE_INT_CST_LOW (upper) >= low)) 519 return itk; 520 } 521 |
|
462 return itk_none; 463} 464 465/* Ditto, but narrowest signed type. */ 466static enum integer_type_kind | 522 return itk_none; 523} 524 525/* Ditto, but narrowest signed type. */ 526static enum integer_type_kind |
467narrowest_signed_type (tree value, unsigned int flags) | 527narrowest_signed_type (unsigned HOST_WIDE_INT low, 528 unsigned HOST_WIDE_INT high, unsigned int flags) |
468{ 469 enum integer_type_kind itk; 470 471 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL) 472 itk = itk_int; 473 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM) 474 itk = itk_long; 475 else 476 itk = itk_long_long; 477 | 529{ 530 enum integer_type_kind itk; 531 532 if ((flags & CPP_N_WIDTH) == CPP_N_SMALL) 533 itk = itk_int; 534 else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM) 535 itk = itk_long; 536 else 537 itk = itk_long_long; 538 |
478 /* int_fits_type_p must think the type of its first argument is 479 wider than its second argument, or it won't do the proper check. */ 480 TREE_TYPE (value) = widest_unsigned_literal_type_node; | |
481 482 for (; itk < itk_none; itk += 2 /* skip signed types */) | 539 540 for (; itk < itk_none; itk += 2 /* skip signed types */) |
483 if (int_fits_type_p (value, integer_types[itk])) 484 return itk; | 541 { 542 tree upper = TYPE_MAX_VALUE (integer_types[itk]); |
485 | 543 |
544 if ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) > high 545 || ((unsigned HOST_WIDE_INT) TREE_INT_CST_HIGH (upper) == high 546 && TREE_INT_CST_LOW (upper) >= low)) 547 return itk; 548 } 549 |
|
486 return itk_none; 487} 488 489/* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */ 490static tree 491interpret_integer (const cpp_token *token, unsigned int flags) 492{ 493 tree value, type; 494 enum integer_type_kind itk; 495 cpp_num integer; 496 cpp_options *options = cpp_get_options (parse_in); 497 498 integer = cpp_interpret_integer (parse_in, token, flags); 499 integer = cpp_num_sign_extend (integer, options->precision); | 550 return itk_none; 551} 552 553/* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */ 554static tree 555interpret_integer (const cpp_token *token, unsigned int flags) 556{ 557 tree value, type; 558 enum integer_type_kind itk; 559 cpp_num integer; 560 cpp_options *options = cpp_get_options (parse_in); 561 562 integer = cpp_interpret_integer (parse_in, token, flags); 563 integer = cpp_num_sign_extend (integer, options->precision); |
500 value = build_int_2_wide (integer.low, integer.high); | |
501 502 /* The type of a constant with a U suffix is straightforward. */ 503 if (flags & CPP_N_UNSIGNED) | 564 565 /* The type of a constant with a U suffix is straightforward. */ 566 if (flags & CPP_N_UNSIGNED) |
504 itk = narrowest_unsigned_type (value, flags); | 567 itk = narrowest_unsigned_type (integer.low, integer.high, flags); |
505 else 506 { 507 /* The type of a potentially-signed integer constant varies 508 depending on the base it's in, the standard in use, and the 509 length suffixes. */ | 568 else 569 { 570 /* The type of a potentially-signed integer constant varies 571 depending on the base it's in, the standard in use, and the 572 length suffixes. */ |
510 enum integer_type_kind itk_u = narrowest_unsigned_type (value, flags); 511 enum integer_type_kind itk_s = narrowest_signed_type (value, flags); | 573 enum integer_type_kind itk_u 574 = narrowest_unsigned_type (integer.low, integer.high, flags); 575 enum integer_type_kind itk_s 576 = narrowest_signed_type (integer.low, integer.high, flags); |
512 513 /* In both C89 and C99, octal and hex constants may be signed or 514 unsigned, whichever fits tighter. We do not warn about this 515 choice differing from the traditional choice, as the constant 516 is probably a bit pattern and either way will work. */ 517 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL) 518 itk = MIN (itk_u, itk_s); 519 else --- 7 unchanged lines hidden (view full) --- 527 itk = itk_s; 528 if (itk_s > itk_u && itk_s > itk_long) 529 { 530 if (!flag_isoc99) 531 { 532 if (itk_u < itk_unsigned_long) 533 itk_u = itk_unsigned_long; 534 itk = itk_u; | 577 578 /* In both C89 and C99, octal and hex constants may be signed or 579 unsigned, whichever fits tighter. We do not warn about this 580 choice differing from the traditional choice, as the constant 581 is probably a bit pattern and either way will work. */ 582 if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL) 583 itk = MIN (itk_u, itk_s); 584 else --- 7 unchanged lines hidden (view full) --- 592 itk = itk_s; 593 if (itk_s > itk_u && itk_s > itk_long) 594 { 595 if (!flag_isoc99) 596 { 597 if (itk_u < itk_unsigned_long) 598 itk_u = itk_unsigned_long; 599 itk = itk_u; |
535 warning ("this decimal constant is unsigned only in ISO C90"); | 600 warning (0, "this decimal constant is unsigned only in ISO C90"); |
536 } | 601 } |
537 else if (warn_traditional) 538 warning ("this decimal constant would be unsigned in ISO C90"); | 602 else 603 warning (OPT_Wtraditional, 604 "this decimal constant would be unsigned in ISO C90"); |
539 } 540 } 541 } 542 543 if (itk == itk_none) 544 /* cpplib has already issued a warning for overflow. */ 545 type = ((flags & CPP_N_UNSIGNED) 546 ? widest_unsigned_literal_type_node 547 : widest_integer_literal_type_node); 548 else 549 type = integer_types[itk]; 550 551 if (itk > itk_unsigned_long 552 && (flags & CPP_N_WIDTH) != CPP_N_LARGE | 605 } 606 } 607 } 608 609 if (itk == itk_none) 610 /* cpplib has already issued a warning for overflow. */ 611 type = ((flags & CPP_N_UNSIGNED) 612 ? widest_unsigned_literal_type_node 613 : widest_integer_literal_type_node); 614 else 615 type = integer_types[itk]; 616 617 if (itk > itk_unsigned_long 618 && (flags & CPP_N_WIDTH) != CPP_N_LARGE |
553 && ! in_system_header && ! flag_isoc99) 554 pedwarn ("integer constant is too large for \"%s\" type", | 619 && !in_system_header && !flag_isoc99) 620 pedwarn ("integer constant is too large for %qs type", |
555 (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long"); 556 | 621 (flags & CPP_N_UNSIGNED) ? "unsigned long" : "long"); 622 |
557 TREE_TYPE (value) = type; | 623 value = build_int_cst_wide (type, integer.low, integer.high); |
558 559 /* Convert imaginary to a complex type. */ 560 if (flags & CPP_N_IMAGINARY) | 624 625 /* Convert imaginary to a complex type. */ 626 if (flags & CPP_N_IMAGINARY) |
561 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value); | 627 value = build_complex (NULL_TREE, build_int_cst (type, 0), value); |
562 563 return value; 564} 565 566/* Interpret TOKEN, a floating point number with FLAGS as classified 567 by cpplib. */ 568static tree 569interpret_float (const cpp_token *token, unsigned int flags) 570{ 571 tree type; 572 tree value; 573 REAL_VALUE_TYPE real; 574 char *copy; 575 size_t copylen; | 628 629 return value; 630} 631 632/* Interpret TOKEN, a floating point number with FLAGS as classified 633 by cpplib. */ 634static tree 635interpret_float (const cpp_token *token, unsigned int flags) 636{ 637 tree type; 638 tree value; 639 REAL_VALUE_TYPE real; 640 char *copy; 641 size_t copylen; |
576 const char *typename; | |
577 | 642 |
578 /* FIXME: make %T work in error/warning, then we don't need typename. */ 579 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE) 580 { | 643 /* Decode type based on width and properties. */ 644 if (flags & CPP_N_DFLOAT) 645 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE) 646 type = dfloat128_type_node; 647 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL) 648 type = dfloat32_type_node; 649 else 650 type = dfloat64_type_node; 651 else 652 if ((flags & CPP_N_WIDTH) == CPP_N_LARGE) |
581 type = long_double_type_node; | 653 type = long_double_type_node; |
582 typename = "long double"; 583 } 584 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL 585 || flag_single_precision_constant) 586 { | 654 else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL 655 || flag_single_precision_constant) |
587 type = float_type_node; | 656 type = float_type_node; |
588 typename = "float"; 589 } 590 else 591 { | 657 else |
592 type = double_type_node; | 658 type = double_type_node; |
593 typename = "double"; 594 } | |
595 596 /* Copy the constant to a nul-terminated buffer. If the constant 597 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF 598 can't handle them. */ 599 copylen = token->val.str.len; | 659 660 /* Copy the constant to a nul-terminated buffer. If the constant 661 has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF 662 can't handle them. */ 663 copylen = token->val.str.len; |
600 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM) 601 /* Must be an F or L suffix. */ 602 copylen--; 603 if (flags & CPP_N_IMAGINARY) 604 /* I or J suffix. */ 605 copylen--; | 664 if (flags & CPP_N_DFLOAT) 665 copylen -= 2; 666 else 667 { 668 if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM) 669 /* Must be an F or L suffix. */ 670 copylen--; 671 if (flags & CPP_N_IMAGINARY) 672 /* I or J suffix. */ 673 copylen--; 674 } |
606 | 675 |
607 copy = alloca (copylen + 1); | 676 copy = (char *) alloca (copylen + 1); |
608 memcpy (copy, token->val.str.text, copylen); 609 copy[copylen] = '\0'; 610 | 677 memcpy (copy, token->val.str.text, copylen); 678 copy[copylen] = '\0'; 679 |
611 real_from_string (&real, copy); 612 real_convert (&real, TYPE_MODE (type), &real); | 680 real_from_string3 (&real, copy, TYPE_MODE (type)); |
613 | 681 |
614 /* A diagnostic is required for "soft" overflow by some ISO C 615 testsuites. This is not pedwarn, because some people don't want 616 an error for this. 617 ??? That's a dubious reason... is this a mandatory diagnostic or 618 isn't it? -- zw, 2001-08-21. */ | 682 /* Both C and C++ require a diagnostic for a floating constant 683 outside the range of representable values of its type. Since we 684 have __builtin_inf* to produce an infinity, it might now be 685 appropriate for this to be a mandatory pedwarn rather than 686 conditioned on -pedantic. */ |
619 if (REAL_VALUE_ISINF (real) && pedantic) | 687 if (REAL_VALUE_ISINF (real) && pedantic) |
620 warning ("floating constant exceeds range of \"%s\"", typename); | 688 pedwarn ("floating constant exceeds range of %qT", type); |
621 622 /* Create a node with determined type and value. */ 623 value = build_real (type, real); 624 if (flags & CPP_N_IMAGINARY) 625 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value); 626 627 return value; 628} --- 14 unchanged lines hidden (view full) --- 643 cpp_interpret_string takes a vector of cpp_string structures, which 644 we must arrange to provide. */ 645 646static enum cpp_ttype 647lex_string (const cpp_token *tok, tree *valp, bool objc_string) 648{ 649 tree value; 650 bool wide = false; | 689 690 /* Create a node with determined type and value. */ 691 value = build_real (type, real); 692 if (flags & CPP_N_IMAGINARY) 693 value = build_complex (NULL_TREE, convert (type, integer_zero_node), value); 694 695 return value; 696} --- 14 unchanged lines hidden (view full) --- 711 cpp_interpret_string takes a vector of cpp_string structures, which 712 we must arrange to provide. */ 713 714static enum cpp_ttype 715lex_string (const cpp_token *tok, tree *valp, bool objc_string) 716{ 717 tree value; 718 bool wide = false; |
651 size_t count = 1; | 719 size_t concats = 0; |
652 struct obstack str_ob; 653 cpp_string istr; 654 655 /* Try to avoid the overhead of creating and destroying an obstack 656 for the common case of just one string. */ 657 cpp_string str = tok->val.str; 658 cpp_string *strs = &str; 659 660 if (tok->type == CPP_WSTRING) 661 wide = true; 662 | 720 struct obstack str_ob; 721 cpp_string istr; 722 723 /* Try to avoid the overhead of creating and destroying an obstack 724 for the common case of just one string. */ 725 cpp_string str = tok->val.str; 726 cpp_string *strs = &str; 727 728 if (tok->type == CPP_WSTRING) 729 wide = true; 730 |
663 tok = get_nonpadding_token (); 664 if (c_dialect_objc () && tok->type == CPP_ATSIGN) | 731 retry: 732 tok = cpp_get_token (parse_in); 733 switch (tok->type) |
665 { | 734 { |
666 objc_string = true; 667 tok = get_nonpadding_token (); 668 } 669 if (tok->type == CPP_STRING || tok->type == CPP_WSTRING) 670 { 671 gcc_obstack_init (&str_ob); 672 obstack_grow (&str_ob, &str, sizeof (cpp_string)); | 735 case CPP_PADDING: 736 goto retry; 737 case CPP_ATSIGN: 738 if (c_dialect_objc ()) 739 { 740 objc_string = true; 741 goto retry; 742 } 743 /* FALLTHROUGH */ |
673 | 744 |
674 do | 745 default: 746 break; 747 748 case CPP_WSTRING: 749 wide = true; 750 /* FALLTHROUGH */ 751 752 case CPP_STRING: 753 if (!concats) |
675 { | 754 { |
676 count++; 677 if (tok->type == CPP_WSTRING) 678 wide = true; 679 obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string)); 680 681 tok = get_nonpadding_token (); 682 if (c_dialect_objc () && tok->type == CPP_ATSIGN) 683 { 684 objc_string = true; 685 tok = get_nonpadding_token (); 686 } | 755 gcc_obstack_init (&str_ob); 756 obstack_grow (&str_ob, &str, sizeof (cpp_string)); |
687 } | 757 } |
688 while (tok->type == CPP_STRING || tok->type == CPP_WSTRING); 689 strs = obstack_finish (&str_ob); | 758 759 concats++; 760 obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string)); 761 goto retry; |
690 } 691 692 /* We have read one more token than we want. */ 693 _cpp_backup_tokens (parse_in, 1); | 762 } 763 764 /* We have read one more token than we want. */ 765 _cpp_backup_tokens (parse_in, 1); |
766 if (concats) 767 strs = XOBFINISH (&str_ob, cpp_string *); |
|
694 | 768 |
695 if (count > 1 && !objc_string && warn_traditional && !in_system_header) 696 warning ("traditional C rejects string constant concatenation"); | 769 if (concats && !objc_string && !in_system_header) 770 warning (OPT_Wtraditional, 771 "traditional C rejects string constant concatenation"); |
697 | 772 |
698 if (cpp_interpret_string (parse_in, strs, count, &istr, wide)) | 773 if ((c_lex_string_translate 774 ? cpp_interpret_string : cpp_interpret_string_notranslate) 775 (parse_in, strs, concats + 1, &istr, wide)) |
699 { | 776 { |
700 value = build_string (istr.len, (char *)istr.text); 701 free ((void *)istr.text); | 777 value = build_string (istr.len, (char *) istr.text); 778 free ((void *) istr.text); 779 780 if (c_lex_string_translate == -1) 781 { 782 int xlated = cpp_interpret_string_notranslate (parse_in, strs, 783 concats + 1, 784 &istr, wide); 785 /* Assume that, if we managed to translate the string above, 786 then the untranslated parsing will always succeed. */ 787 gcc_assert (xlated); 788 789 if (TREE_STRING_LENGTH (value) != (int) istr.len 790 || 0 != strncmp (TREE_STRING_POINTER (value), (char *) istr.text, 791 istr.len)) 792 { 793 /* Arrange for us to return the untranslated string in 794 *valp, but to set up the C type of the translated 795 one. */ 796 *valp = build_string (istr.len, (char *) istr.text); 797 valp = &TREE_CHAIN (*valp); 798 } 799 free ((void *) istr.text); 800 } |
702 } 703 else 704 { 705 /* Callers cannot generally handle error_mark_node in this context, 706 so return the empty string instead. cpp_interpret_string has 707 issued an error. */ 708 if (wide) 709 value = build_string (TYPE_PRECISION (wchar_type_node) 710 / TYPE_PRECISION (char_type_node), 711 "\0\0\0"); /* widest supported wchar_t 712 is 32 bits */ 713 else 714 value = build_string (1, ""); 715 } 716 717 TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node; 718 *valp = fix_string_type (value); 719 | 801 } 802 else 803 { 804 /* Callers cannot generally handle error_mark_node in this context, 805 so return the empty string instead. cpp_interpret_string has 806 issued an error. */ 807 if (wide) 808 value = build_string (TYPE_PRECISION (wchar_type_node) 809 / TYPE_PRECISION (char_type_node), 810 "\0\0\0"); /* widest supported wchar_t 811 is 32 bits */ 812 else 813 value = build_string (1, ""); 814 } 815 816 TREE_TYPE (value) = wide ? wchar_array_type_node : char_array_type_node; 817 *valp = fix_string_type (value); 818 |
720 if (strs != &str) | 819 if (concats) |
721 obstack_free (&str_ob, 0); 722 723 return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING; 724} 725 726/* Converts a (possibly wide) character constant token into a tree. */ 727static tree 728lex_charconst (const cpp_token *token) 729{ 730 cppchar_t result; 731 tree type, value; 732 unsigned int chars_seen; 733 int unsignedp; 734 735 result = cpp_interpret_charconst (parse_in, token, 736 &chars_seen, &unsignedp); 737 | 820 obstack_free (&str_ob, 0); 821 822 return objc_string ? CPP_OBJC_STRING : wide ? CPP_WSTRING : CPP_STRING; 823} 824 825/* Converts a (possibly wide) character constant token into a tree. */ 826static tree 827lex_charconst (const cpp_token *token) 828{ 829 cppchar_t result; 830 tree type, value; 831 unsigned int chars_seen; 832 int unsignedp; 833 834 result = cpp_interpret_charconst (parse_in, token, 835 &chars_seen, &unsignedp); 836 |
738 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT 739 before possibly widening to HOST_WIDE_INT for build_int_2. */ 740 if (unsignedp || (cppchar_signed_t) result >= 0) 741 value = build_int_2 (result, 0); 742 else 743 value = build_int_2 ((cppchar_signed_t) result, -1); 744 | |
745 if (token->type == CPP_WCHAR) 746 type = wchar_type_node; 747 /* In C, a character constant has type 'int'. 748 In C++ 'char', but multi-char charconsts have type 'int'. */ 749 else if (!c_dialect_cxx () || chars_seen > 1) 750 type = integer_type_node; 751 else 752 type = char_type_node; 753 | 837 if (token->type == CPP_WCHAR) 838 type = wchar_type_node; 839 /* In C, a character constant has type 'int'. 840 In C++ 'char', but multi-char charconsts have type 'int'. */ 841 else if (!c_dialect_cxx () || chars_seen > 1) 842 type = integer_type_node; 843 else 844 type = char_type_node; 845 |
754 TREE_TYPE (value) = type; | 846 /* Cast to cppchar_signed_t to get correct sign-extension of RESULT 847 before possibly widening to HOST_WIDE_INT for build_int_cst. */ 848 if (unsignedp || (cppchar_signed_t) result >= 0) 849 value = build_int_cst_wide (type, result, 0); 850 else 851 value = build_int_cst_wide (type, (cppchar_signed_t) result, -1); 852 |
755 return value; 756} | 853 return value; 854} |