1	/* Mainly the interface between cpplib and the C front ends.
2	Copyright (C) 1987-2023 Free Software Foundation, Inc.
3
4	This file is part of GCC.
5
6	GCC is free software; you can redistribute it and/or modify it under
7	the terms of the GNU General Public License as published by the Free
8	Software Foundation; either version 3, or (at your option) any later
9	version.
10
11	GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12	WARRANTY; without even the implied warranty of MERCHANTABILITY or
13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
14	for more details.
15
16	You should have received a copy of the GNU General Public License
17	along with GCC; see the file COPYING3. If not see
18	<http://www.gnu.org/licenses/>. */
19
20	#include "config.h"
21	#include "system.h"
22	#include "coretypes.h"
23	#include "target.h"
24	#include "c-common.h"
25	#include "timevar.h"
26	#include "stringpool.h"
27	#include "stor-layout.h"
28	#include "c-pragma.h"
29	#include "debug.h"
30	#include "flags.h"
31	#include "file-prefix-map.h" /* remap_macro_filename() */
32	#include "langhooks.h"
33	#include "attribs.h"
34
35	/* We may keep statistics about how long which files took to compile. */
36	static int header_time, body_time;
37	static splay_tree file_info_tree;
38
39	int pending_lang_change; /* If we need to switch languages - C++ only */
40	int c_header_level; /* depth in C headers - C++ only */
41
42	static tree interpret_integer (const cpp_token *, unsigned int,
43	enum overflow_type *);
44	static tree interpret_float (const cpp_token *, unsigned int, const char *,
45	enum overflow_type *);
46	static tree interpret_fixed (const cpp_token *, unsigned int);
47	static enum integer_type_kind narrowest_unsigned_type
48	(const widest_int &, unsigned int);
49	static enum integer_type_kind narrowest_signed_type
50	(const widest_int &, unsigned int);
51	static enum cpp_ttype lex_string (const cpp_token *, tree *, bool, bool);
52	static tree lex_charconst (const cpp_token *);
53	static void update_header_times (const char *);
54	static int dump_one_header (splay_tree_node, void *);
55	static void cb_line_change (cpp_reader *, const cpp_token *, int);
56	static void cb_ident (cpp_reader *, unsigned int, const cpp_string *);
57	static void cb_def_pragma (cpp_reader *, unsigned int);
58	static void cb_define (cpp_reader *, unsigned int, cpp_hashnode *);
59	static void cb_undef (cpp_reader *, unsigned int, cpp_hashnode *);
60
61	void
62	init_c_lex (void)
63	{
64	struct c_fileinfo *toplevel;
65
66	/* The get_fileinfo data structure must be initialized before
67	cpp_read_main_file is called. */
68	toplevel = get_fileinfo ("<top level>");
69	if (flag_detailed_statistics)
70	{
71	header_time = 0;
72	body_time = get_run_time ();
73	toplevel->time = body_time;
74	}
75
76	struct cpp_callbacks *cb = cpp_get_callbacks (parse_in);
77
78	cb->line_change = cb_line_change;
79	cb->ident = cb_ident;
80	cb->def_pragma = cb_def_pragma;
81	cb->valid_pch = c_common_valid_pch;
82	cb->read_pch = c_common_read_pch;
83	cb->has_attribute = c_common_has_attribute;
84	cb->has_builtin = c_common_has_builtin;
85	cb->get_source_date_epoch = cb_get_source_date_epoch;
86	cb->get_suggestion = cb_get_suggestion;
87	cb->remap_filename = remap_macro_filename;
88
89	/* Set the debug callbacks if we can use them. */
90	if ((debug_info_level == DINFO_LEVEL_VERBOSE
91	&& dwarf_debuginfo_p ())
92	|| flag_dump_go_spec != NULL)
93	{
94	cb->define = cb_define;
95	cb->undef = cb_undef;
96	}
97	}
98
99	struct c_fileinfo *
100	get_fileinfo (const char *name)
101	{
102	splay_tree_node n;
103	struct c_fileinfo *fi;
104
105	if (!file_info_tree)
106	file_info_tree = splay_tree_new (splay_tree_compare_strings,
107	0,
108	splay_tree_delete_pointers);
109
110	n = splay_tree_lookup (file_info_tree, (splay_tree_key) name);
111	if (n)
112	return (struct c_fileinfo *) n->value;
113
114	fi = XNEW (struct c_fileinfo);
115	fi->time = 0;
116	fi->interface_only = 0;
117	fi->interface_unknown = 1;
118	splay_tree_insert (file_info_tree, (splay_tree_key) name,
119	(splay_tree_value) fi);
120	return fi;
121	}
122
123	static void
124	update_header_times (const char *name)
125	{
126	/* Changing files again. This means currently collected time
127	is charged against header time, and body time starts back at 0. */
128	if (flag_detailed_statistics)
129	{
130	int this_time = get_run_time ();
131	struct c_fileinfo *file = get_fileinfo (name);
132	header_time += this_time - body_time;
133	file->time += this_time - body_time;
134	body_time = this_time;
135	}
136	}
137
138	static int
139	dump_one_header (splay_tree_node n, void * ARG_UNUSED (dummy))
140	{
141	print_time ((const char *) n->key,
142	((struct c_fileinfo *) n->value)->time);
143	return 0;
144	}
145
146	void
147	dump_time_statistics (void)
148	{
149	struct c_fileinfo *file = get_fileinfo (LOCATION_FILE (input_location));
150	int this_time = get_run_time ();
151	file->time += this_time - body_time;
152
153	fprintf (stderr, format: "\n******\n");
154	print_time ("header files (total)", header_time);
155	print_time ("main file (total)", this_time - body_time);
156	fprintf (stderr, format: "ratio = %g : 1\n",
157	(double) header_time / (double) (this_time - body_time));
158	fprintf (stderr, format: "\n******\n");
159
160	splay_tree_foreach (file_info_tree, dump_one_header, 0);
161	}
162
163	static void
164	cb_ident (cpp_reader * ARG_UNUSED (pfile),
165	unsigned int ARG_UNUSED (line),
166	const cpp_string * ARG_UNUSED (str))
167	{
168	if (!flag_no_ident)
169	{
170	/* Convert escapes in the string. */
171	cpp_string cstr = { .len: 0, .text: 0 };
172	if (cpp_interpret_string (pfile, str, 1, &cstr, CPP_STRING))
173	{
174	targetm.asm_out.output_ident ((const char *) cstr.text);
175	free (CONST_CAST (unsigned char *, cstr.text));
176	}
177	}
178	}
179
180	/* Called at the start of every non-empty line. TOKEN is the first
181	lexed token on the line. Used for diagnostic line numbers. */
182	static void
183	cb_line_change (cpp_reader * ARG_UNUSED (pfile), const cpp_token *token,
184	int parsing_args)
185	{
186	if (token->type != CPP_EOF && !parsing_args)
187	input_location = token->src_loc;
188	}
189
190	void
191	fe_file_change (const line_map_ordinary *new_map)
192	{
193	if (new_map == NULL)
194	return;
195
196	if (new_map->reason == LC_ENTER)
197	{
198	/* Don't stack the main buffer on the input stack;
199	we already did in compile_file. */
200	if (!MAIN_FILE_P (ord_map: new_map))
201	{
202	location_t included_at = linemap_included_from (ord_map: new_map);
203	int line = 0;
204	if (included_at > BUILTINS_LOCATION)
205	line = SOURCE_LINE (ord_map: new_map - 1, loc: included_at);
206
207	input_location = new_map->start_location;
208	(*debug_hooks->start_source_file) (line, LINEMAP_FILE (ord_map: new_map));
209	#ifdef SYSTEM_IMPLICIT_EXTERN_C
210	if (c_header_level)
211	++c_header_level;
212	else if (LINEMAP_SYSP (new_map) == 2)
213	{
214	c_header_level = 1;
215	++pending_lang_change;
216	}
217	#endif
218	}
219	}
220	else if (new_map->reason == LC_LEAVE)
221	{
222	#ifdef SYSTEM_IMPLICIT_EXTERN_C
223	if (c_header_level && --c_header_level == 0)
224	{
225	if (LINEMAP_SYSP (new_map) == 2)
226	warning (0, "badly nested C headers from preprocessor");
227	--pending_lang_change;
228	}
229	#endif
230	input_location = new_map->start_location;
231
232	(*debug_hooks->end_source_file) (LINEMAP_LINE (ord_map: new_map));
233	}
234
235	update_header_times (name: LINEMAP_FILE (ord_map: new_map));
236	input_location = new_map->start_location;
237	}
238
239	static void
240	cb_def_pragma (cpp_reader *pfile, location_t loc)
241	{
242	/* Issue a warning message if we have been asked to do so. Ignore
243	unknown pragmas in system headers unless an explicit
244	-Wunknown-pragmas has been given. */
245	if (warn_unknown_pragmas > in_system_header_at (loc: input_location))
246	{
247	const unsigned char *space, *name;
248	const cpp_token *s;
249	location_t fe_loc = loc;
250
251	space = name = (const unsigned char *) "";
252
253	/* N.B. It's fine to call cpp_get_token () directly here (rather than our
254	local wrapper get_token ()), because this callback is not used with
255	flag_preprocess_only==true. */
256	s = cpp_get_token (pfile);
257	if (s->type != CPP_EOF)
258	{
259	space = cpp_token_as_text (pfile, s);
260	s = cpp_get_token (pfile);
261	if (s->type == CPP_NAME)
262	name = cpp_token_as_text (pfile, s);
263	}
264
265	warning_at (fe_loc, OPT_Wunknown_pragmas, "ignoring %<#pragma %s %s%>",
266	space, name);
267	}
268	}
269
270	/* #define callback for DWARF and DWARF2 debug info. */
271	static void
272	cb_define (cpp_reader *pfile, location_t loc, cpp_hashnode *node)
273	{
274	const struct line_map *map = linemap_lookup (line_table, loc);
275	(*debug_hooks->define) (SOURCE_LINE (ord_map: linemap_check_ordinary (map), loc),
276	(const char *) cpp_macro_definition (pfile, node));
277	}
278
279	/* #undef callback for DWARF and DWARF2 debug info. */
280	static void
281	cb_undef (cpp_reader *pfile, location_t loc, cpp_hashnode *node)
282	{
283	if (lang_hooks.preprocess_undef)
284	lang_hooks.preprocess_undef (pfile, loc, node);
285
286	const struct line_map *map = linemap_lookup (line_table, loc);
287	(*debug_hooks->undef) (SOURCE_LINE (ord_map: linemap_check_ordinary (map), loc),
288	(const char *) NODE_NAME (node));
289	}
290
291	/* Wrapper around cpp_get_token_with_location to stream the token to the
292	preprocessor so it can output it. This is necessary with
293	flag_preprocess_only if we are obtaining tokens here instead of from the loop
294	in c-ppoutput.cc, such as while processing a #pragma. */
295
296	static const cpp_token *
297	get_token (cpp_reader *pfile, location_t *loc = nullptr)
298	{
299	if (flag_preprocess_only)
300	{
301	location_t x;
302	if (!loc)
303	loc = &x;
304	const auto tok = cpp_get_token_with_location (pfile, loc);
305	c_pp_stream_token (pfile, tok, loc: *loc);
306	return tok;
307	}
308	else
309	return cpp_get_token_with_location (pfile, loc);
310	}
311
312	/* Wrapper around cpp_get_token to skip CPP_PADDING tokens
313	and not consume CPP_EOF. This does not perform the optional
314	streaming in preprocess_only mode, so is suitable to be used
315	when processing builtin expansions such as c_common_has_attribute. */
316
317	static const cpp_token *
318	get_token_no_padding (cpp_reader *pfile)
319	{
320	for (;;)
321	{
322	const cpp_token *ret = cpp_peek_token (pfile, 0);
323	if (ret->type == CPP_EOF)
324	return ret;
325	ret = cpp_get_token (pfile);
326	if (ret->type != CPP_PADDING)
327	return ret;
328	}
329	}
330
331	/* Callback for has_attribute. */
332	int
333	c_common_has_attribute (cpp_reader *pfile, bool std_syntax)
334	{
335	int result = 0;
336	tree attr_name = NULL_TREE;
337	const cpp_token *token;
338
339	token = get_token_no_padding (pfile);
340	if (token->type != CPP_OPEN_PAREN)
341	{
342	cpp_error (pfile, CPP_DL_ERROR,
343	msgid: "missing '(' after \"__has_attribute\"");
344	return 0;
345	}
346	token = get_token_no_padding (pfile);
347	if (token->type == CPP_NAME)
348	{
349	attr_name = get_identifier ((const char *)
350	cpp_token_as_text (pfile, token));
351	attr_name = canonicalize_attr_name (attr_name);
352	bool have_scope = false;
353	int idx = 0;
354	const cpp_token *nxt_token;
355	do
356	nxt_token = cpp_peek_token (pfile, idx++);
357	while (nxt_token->type == CPP_PADDING);
358	if (nxt_token->type == CPP_SCOPE)
359	{
360	have_scope = true;
361	get_token_no_padding (pfile); // Eat scope.
362	nxt_token = get_token_no_padding (pfile);
363	if (nxt_token->type == CPP_NAME)
364	{
365	tree attr_ns = attr_name;
366	tree attr_id
367	= get_identifier ((const char *)
368	cpp_token_as_text (pfile, nxt_token));
369	attr_id = canonicalize_attr_name (attr_name: attr_id);
370	/* OpenMP attributes need special handling. */
371	if ((flag_openmp || flag_openmp_simd)
372	&& is_attribute_p (attr_name: "omp", ident: attr_ns)
373	&& (is_attribute_p (attr_name: "directive", ident: attr_id)
374	|| is_attribute_p (attr_name: "sequence", ident: attr_id)
375	|| is_attribute_p (attr_name: "decl", ident: attr_id)))
376	result = 1;
377	if (result)
378	attr_name = NULL_TREE;
379	else
380	attr_name = build_tree_list (attr_ns, attr_id);
381	}
382	else
383	{
384	cpp_error (pfile, CPP_DL_ERROR,
385	msgid: "attribute identifier required after scope");
386	attr_name = NULL_TREE;
387	}
388	}
389	else
390	{
391	/* Some standard attributes need special handling. */
392	if (c_dialect_cxx ())
393	{
394	if (is_attribute_p (attr_name: "noreturn", ident: attr_name))
395	result = 200809;
396	else if (is_attribute_p (attr_name: "deprecated", ident: attr_name))
397	result = 201309;
398	else if (is_attribute_p (attr_name: "maybe_unused", ident: attr_name)
399	|| is_attribute_p (attr_name: "fallthrough", ident: attr_name))
400	result = 201603;
401	else if (is_attribute_p (attr_name: "no_unique_address", ident: attr_name)
402	|| is_attribute_p (attr_name: "likely", ident: attr_name)
403	|| is_attribute_p (attr_name: "unlikely", ident: attr_name))
404	result = 201803;
405	else if (is_attribute_p (attr_name: "nodiscard", ident: attr_name))
406	result = 201907;
407	else if (is_attribute_p (attr_name: "assume", ident: attr_name))
408	result = 202207;
409	else if (is_attribute_p (attr_name: "init_priority", ident: attr_name))
410	{
411	/* The (non-standard) init_priority attribute is always
412	included in the attribute table, but we don't want to
413	advertise the attribute unless the target actually
414	supports init priorities. */
415	result = SUPPORTS_INIT_PRIORITY ? 1 : 0;
416	attr_name = NULL_TREE;
417	}
418	}
419	else
420	{
421	if (is_attribute_p (attr_name: "deprecated", ident: attr_name)
422	|| is_attribute_p (attr_name: "fallthrough", ident: attr_name)
423	|| is_attribute_p (attr_name: "maybe_unused", ident: attr_name)
424	|| is_attribute_p (attr_name: "nodiscard", ident: attr_name)
425	|| is_attribute_p (attr_name: "noreturn", ident: attr_name)
426	|| is_attribute_p (attr_name: "_Noreturn", ident: attr_name))
427	result = 202311;
428	}
429	if (result)
430	attr_name = NULL_TREE;
431	}
432	if (attr_name && (have_scope || !std_syntax))
433	{
434	init_attributes ();
435	const struct attribute_spec *attr = lookup_attribute_spec (attr_name);
436	if (attr)
437	result = 1;
438	}
439	}
440	else
441	{
442	cpp_error (pfile, CPP_DL_ERROR,
443	msgid: "macro \"__has_attribute\" requires an identifier");
444	return 0;
445	}
446
447	if (get_token_no_padding (pfile)->type != CPP_CLOSE_PAREN)
448	cpp_error (pfile, CPP_DL_ERROR,
449	msgid: "missing ')' after \"__has_attribute\"");
450
451	return result;
452	}
453
454	/* Callback for has_builtin. */
455
456	int
457	c_common_has_builtin (cpp_reader *pfile)
458	{
459	const cpp_token *token = get_token_no_padding (pfile);
460	if (token->type != CPP_OPEN_PAREN)
461	{
462	cpp_error (pfile, CPP_DL_ERROR,
463	msgid: "missing '(' after \"__has_builtin\"");
464	return 0;
465	}
466
467	const char *name = "";
468	token = get_token_no_padding (pfile);
469	if (token->type == CPP_NAME)
470	{
471	name = (const char *) cpp_token_as_text (pfile, token);
472	token = get_token_no_padding (pfile);
473	if (token->type != CPP_CLOSE_PAREN)
474	{
475	cpp_error (pfile, CPP_DL_ERROR,
476	msgid: "expected ')' after \"%s\"", name);
477	name = "";
478	}
479	}
480	else
481	{
482	cpp_error (pfile, CPP_DL_ERROR,
483	msgid: "macro \"__has_builtin\" requires an identifier");
484	if (token->type == CPP_CLOSE_PAREN)
485	return 0;
486	}
487
488	/* Consume tokens up to the closing parenthesis, including any nested
489	pairs of parentheses, to avoid confusing redundant errors. */
490	for (unsigned nparen = 1; ; token = get_token_no_padding (pfile))
491	{
492	if (token->type == CPP_OPEN_PAREN)
493	++nparen;
494	else if (token->type == CPP_CLOSE_PAREN)
495	--nparen;
496	else if (token->type == CPP_EOF)
497	break;
498	if (!nparen)
499	break;
500	}
501
502	return names_builtin_p (name);
503	}
504
505
506	/* Read a token and return its type. Fill *VALUE with its value, if
507	applicable. Fill *CPP_FLAGS with the token's flags, if it is
508	non-NULL. */
509
510	enum cpp_ttype
511	c_lex_with_flags (tree *value, location_t *loc, unsigned char *cpp_flags,
512	int lex_flags)
513	{
514	const cpp_token *tok;
515	enum cpp_ttype type;
516	unsigned char add_flags = 0;
517	enum overflow_type overflow = OT_NONE;
518
519	timevar_push (tv: TV_CPP);
520	retry:
521	tok = get_token (pfile: parse_in, loc);
522	type = tok->type;
523
524	retry_after_at:
525	switch (type)
526	{
527	case CPP_PADDING:
528	goto retry;
529
530	case CPP_NAME:
531	*value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
532	break;
533
534	case CPP_NUMBER:
535	{
536	const char *suffix = NULL;
537	unsigned int flags = cpp_classify_number (parse_in, tok, &suffix, *loc);
538
539	switch (flags & CPP_N_CATEGORY)
540	{
541	case CPP_N_INVALID:
542	/* cpplib has issued an error. */
543	*value = error_mark_node;
544	break;
545
546	case CPP_N_INTEGER:
547	/* C++ uses '0' to mark virtual functions as pure.
548	Set PURE_ZERO to pass this information to the C++ parser. */
549	if (tok->val.str.len == 1 && *tok->val.str.text == '0')
550	add_flags = PURE_ZERO | DECIMAL_INT;
551	else if ((flags & CPP_N_INTEGER) && (flags & CPP_N_DECIMAL))
552	/* -Wxor-used-as-pow is only active for LHS of ^ expressed
553	as a decimal integer. */
554	add_flags = DECIMAL_INT;
555	*value = interpret_integer (tok, flags, &overflow);
556	break;
557
558	case CPP_N_FLOATING:
559	*value = interpret_float (tok, flags, suffix, &overflow);
560	break;
561
562	default:
563	gcc_unreachable ();
564	}
565
566	if (flags & CPP_N_USERDEF)
567	{
568	char *str;
569	tree literal;
570	tree suffix_id = get_identifier (suffix);
571	int len = tok->val.str.len - strlen (s: suffix);
572	/* If this is going to be used as a C string to pass to a
573	raw literal operator, we need to add a trailing NUL. */
574	tree num_string = build_string (len + 1,
575	(const char *) tok->val.str.text);
576	TREE_TYPE (num_string) = char_array_type_node;
577	num_string = fix_string_type (num_string);
578	str = CONST_CAST (char *, TREE_STRING_POINTER (num_string));
579	str[len] = '\0';
580	literal = build_userdef_literal (suffix_id, value: *value, overflow,
581	num_string);
582	*value = literal;
583	}
584	}
585	break;
586
587	case CPP_ATSIGN:
588	/* An @ may give the next token special significance in Objective-C. */
589	if (c_dialect_objc ())
590	{
591	location_t atloc = *loc;
592	location_t newloc;
593
594	retry_at:
595	tok = get_token (pfile: parse_in, loc: &newloc);
596	type = tok->type;
597	switch (type)
598	{
599	case CPP_PADDING:
600	goto retry_at;
601
602	case CPP_STRING:
603	case CPP_WSTRING:
604	case CPP_STRING16:
605	case CPP_STRING32:
606	case CPP_UTF8STRING:
607	type = lex_string (tok, value, true, true);
608	break;
609
610	case CPP_NAME:
611	*value = HT_IDENT_TO_GCC_IDENT (HT_NODE (tok->val.node.node));
612	if (OBJC_IS_AT_KEYWORD (C_RID_CODE (*value))
613	|| OBJC_IS_CXX_KEYWORD (C_RID_CODE (*value)))
614	{
615	type = CPP_AT_NAME;
616	/* Note the complication: if we found an OBJC_CXX
617	keyword, for example, 'class', we will be
618	returning a token of type CPP_AT_NAME and rid
619	code RID_CLASS (not RID_AT_CLASS). The language
620	parser needs to convert that to RID_AT_CLASS.
621	However, we've now spliced the '@' together with the
622	keyword that follows; Adjust the location so that we
623	get a source range covering the composite.
624	*/
625	*loc = make_location (caret: atloc, start: atloc, finish: newloc);
626	break;
627	}
628	/* FALLTHROUGH */
629
630	default:
631	/* ... or not. */
632	error_at (atloc, "stray %<@%> in program");
633	*loc = newloc;
634	goto retry_after_at;
635	}
636	break;
637	}
638
639	/* FALLTHROUGH */
640	case CPP_HASH:
641	case CPP_PASTE:
642	{
643	unsigned char name[8];
644
645	*cpp_spell_token (parse_in, tok, name, true) = 0;
646
647	error_at (*loc, "stray %qs in program", name);
648	}
649
650	goto retry;
651
652	case CPP_OTHER:
653	{
654	cppchar_t c = tok->val.str.text[0];
655
656	if (c == '"' || c == '\'')
657	error_at (*loc, "missing terminating %c character", (int) c);
658	else if (ISGRAPH (c))
659	error_at (*loc, "stray %qc in program", (int) c);
660	else
661	{
662	rich_location rich_loc (line_table, *loc);
663	rich_loc.set_escape_on_output (true);
664	error_at (&rich_loc, "stray %<\\%o%> in program", (int) c);
665	}
666	}
667	goto retry;
668
669	case CPP_CHAR_USERDEF:
670	case CPP_WCHAR_USERDEF:
671	case CPP_CHAR16_USERDEF:
672	case CPP_CHAR32_USERDEF:
673	case CPP_UTF8CHAR_USERDEF:
674	{
675	tree literal;
676	cpp_token temp_tok = *tok;
677	const char *suffix = cpp_get_userdef_suffix (tok);
678	temp_tok.val.str.len -= strlen (s: suffix);
679	temp_tok.type = cpp_userdef_char_remove_type (type);
680	literal = build_userdef_literal (get_identifier (suffix),
681	value: lex_charconst (&temp_tok),
682	overflow: OT_NONE, NULL_TREE);
683	*value = literal;
684	}
685	break;
686
687	case CPP_CHAR:
688	case CPP_WCHAR:
689	case CPP_CHAR16:
690	case CPP_CHAR32:
691	case CPP_UTF8CHAR:
692	*value = lex_charconst (tok);
693	break;
694
695	case CPP_STRING_USERDEF:
696	case CPP_WSTRING_USERDEF:
697	case CPP_STRING16_USERDEF:
698	case CPP_STRING32_USERDEF:
699	case CPP_UTF8STRING_USERDEF:
700	{
701	tree literal, string;
702	const char *suffix = cpp_get_userdef_suffix (tok);
703	string = build_string (tok->val.str.len - strlen (s: suffix),
704	(const char *) tok->val.str.text);
705	literal = build_userdef_literal (get_identifier (suffix),
706	value: string, overflow: OT_NONE, NULL_TREE);
707	*value = literal;
708	}
709	break;
710
711	case CPP_STRING:
712	case CPP_WSTRING:
713	case CPP_STRING16:
714	case CPP_STRING32:
715	case CPP_UTF8STRING:
716	if ((lex_flags & C_LEX_STRING_NO_JOIN) == 0)
717	{
718	type = lex_string (tok, value, false,
719	(lex_flags & C_LEX_STRING_NO_TRANSLATE) == 0);
720	break;
721	}
722	*value = build_string (tok->val.str.len, (const char *) tok->val.str.text);
723	break;
724
725	case CPP_PRAGMA:
726	*value = build_int_cst (integer_type_node, tok->val.pragma);
727	break;
728
729	case CPP_HEADER_NAME:
730	*value = build_string (tok->val.str.len, (const char *)tok->val.str.text);
731	break;
732
733	/* This token should not be visible outside cpplib. */
734	case CPP_MACRO_ARG:
735	gcc_unreachable ();
736
737	/* CPP_COMMENT will appear when compiling with -C. Ignore, except
738	when it is a FALLTHROUGH comment, in that case set
739	PREV_FALLTHROUGH flag on the next non-comment token. */
740	case CPP_COMMENT:
741	if (tok->flags & PREV_FALLTHROUGH)
742	{
743	do
744	{
745	tok = get_token (pfile: parse_in, loc);
746	type = tok->type;
747	}
748	while (type == CPP_PADDING || type == CPP_COMMENT);
749	add_flags |= PREV_FALLTHROUGH;
750	goto retry_after_at;
751	}
752	goto retry;
753
754	default:
755	*value = NULL_TREE;
756	break;
757	}
758
759	if (cpp_flags)
760	*cpp_flags = tok->flags | add_flags;
761
762	timevar_pop (tv: TV_CPP);
763
764	return type;
765	}
766
767	/* Returns the narrowest C-visible unsigned type, starting with the
768	minimum specified by FLAGS, that can fit HIGH:LOW, or itk_none if
769	there isn't one. */
770
771	static enum integer_type_kind
772	narrowest_unsigned_type (const widest_int &val, unsigned int flags)
773	{
774	int itk;
775
776	if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
777	itk = itk_unsigned_int;
778	else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
779	itk = itk_unsigned_long;
780	else
781	itk = itk_unsigned_long_long;
782
783	for (; itk < itk_none; itk += 2 /* skip unsigned types */)
784	{
785	tree upper;
786
787	if (integer_types[itk] == NULL_TREE)
788	continue;
789	upper = TYPE_MAX_VALUE (integer_types[itk]);
790
791	if (wi::geu_p (x: wi::to_widest (t: upper), y: val))
792	return (enum integer_type_kind) itk;
793	}
794
795	return itk_none;
796	}
797
798	/* Ditto, but narrowest signed type. */
799	static enum integer_type_kind
800	narrowest_signed_type (const widest_int &val, unsigned int flags)
801	{
802	int itk;
803
804	if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
805	itk = itk_int;
806	else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
807	itk = itk_long;
808	else
809	itk = itk_long_long;
810
811	for (; itk < itk_none; itk += 2 /* skip signed types */)
812	{
813	tree upper;
814
815	if (integer_types[itk] == NULL_TREE)
816	continue;
817	upper = TYPE_MAX_VALUE (integer_types[itk]);
818
819	if (wi::geu_p (x: wi::to_widest (t: upper), y: val))
820	return (enum integer_type_kind) itk;
821	}
822
823	return itk_none;
824	}
825
826	/* Interpret TOKEN, an integer with FLAGS as classified by cpplib. */
827	static tree
828	interpret_integer (const cpp_token *token, unsigned int flags,
829	enum overflow_type *overflow)
830	{
831	tree value, type;
832	enum integer_type_kind itk;
833	cpp_num integer;
834	HOST_WIDE_INT ival[3];
835
836	*overflow = OT_NONE;
837
838	if (UNLIKELY (flags & CPP_N_BITINT))
839	{
840	unsigned int suffix_len = 2 + ((flags & CPP_N_UNSIGNED) ? 1 : 0);
841	int max_bits_per_digit = 4; // ceil (log2 (10))
842	unsigned int prefix_len = 0;
843	bool hex = false;
844	const int bitint_maxwidth = WIDE_INT_MAX_PRECISION - 1;
845	if ((flags & CPP_N_RADIX) == CPP_N_OCTAL)
846	{
847	max_bits_per_digit = 3;
848	prefix_len = 1;
849	}
850	else if ((flags & CPP_N_RADIX) == CPP_N_HEX)
851	{
852	max_bits_per_digit = 4;
853	prefix_len = 2;
854	hex = true;
855	}
856	else if ((flags & CPP_N_RADIX) == CPP_N_BINARY)
857	{
858	max_bits_per_digit = 1;
859	prefix_len = 2;
860	}
861	int max_digits
862	= TYPE_PRECISION (intmax_type_node) >> max_bits_per_digit;
863	const int max_buf = 128;
864	if (max_digits > max_buf)
865	max_digits = max_buf;
866
867	widest_int wval;
868	unsigned int prec;
869	gcc_checking_assert (token->val.str.len > prefix_len + suffix_len
870	|| token->val.str.len == 1 + suffix_len);
871	if (token->val.str.len - (prefix_len + suffix_len)
872	<= (unsigned) max_digits)
873	{
874	integer = cpp_interpret_integer (parse_in, token,
875	(flags & CPP_N_RADIX)
876	| CPP_N_UNSIGNED);
877	ival[0] = integer.low;
878	ival[1] = integer.high;
879	ival[2] = 0;
880	wval = widest_int::from_array (val: ival, len: 3);
881	}
882	else
883	{
884	unsigned char buf[3 + max_buf];
885	memcpy (dest: buf, src: token->val.str.text, n: prefix_len);
886	wval = 0U;
887	const unsigned char *p = token->val.str.text + prefix_len;
888	cpp_token tok = *token;
889	tok.val.str.text = buf;
890	if (!prefix_len)
891	max_digits = 19;
892	do
893	{
894	unsigned char *q = buf + prefix_len;
895	do
896	{
897	unsigned char c = *p++;
898	if (ISDIGIT (c) || (hex && ISXDIGIT (c)))
899	{
900	*q++ = c;
901	if (q == buf + prefix_len + max_digits)
902	break;
903	}
904	else if (c != '\'')
905	{
906	--p;
907	break;
908	}
909	}
910	while (1);
911	if (q == buf + prefix_len)
912	break;
913	else
914	{
915	wi::overflow_type wioverflow;
916	*q = '\0';
917	tok.val.str.len = q - buf;
918	if (wval == 0)
919	;
920	else if (prefix_len)
921	{
922	prec = wi::min_precision (x: wval, sgn: UNSIGNED);
923	unsigned HOST_WIDE_INT shift
924	= (tok.val.str.len - prefix_len) * max_bits_per_digit;
925	if (prec + shift > bitint_maxwidth)
926	goto bitint_overflow;
927	wval = wi::lshift (x: wval, y: shift);
928	}
929	else
930	{
931	static unsigned HOST_WIDE_INT tens[]
932	= { 1U, 10U, 100U, 1000U,
933	HOST_WIDE_INT_UC (10000),
934	HOST_WIDE_INT_UC (100000),
935	HOST_WIDE_INT_UC (1000000),
936	HOST_WIDE_INT_UC (10000000),
937	HOST_WIDE_INT_UC (100000000),
938	HOST_WIDE_INT_UC (1000000000),
939	HOST_WIDE_INT_UC (10000000000),
940	HOST_WIDE_INT_UC (100000000000),
941	HOST_WIDE_INT_UC (1000000000000),
942	HOST_WIDE_INT_UC (10000000000000),
943	HOST_WIDE_INT_UC (100000000000000),
944	HOST_WIDE_INT_UC (1000000000000000),
945	HOST_WIDE_INT_UC (10000000000000000),
946	HOST_WIDE_INT_UC (100000000000000000),
947	HOST_WIDE_INT_UC (1000000000000000000),
948	HOST_WIDE_INT_UC (10000000000000000000) };
949	widest_int ten = tens[q - buf];
950	wval = wi::umul (x: wval, y: ten, overflow: &wioverflow);
951	if (wioverflow)
952	goto bitint_overflow;
953	}
954	integer = cpp_interpret_integer (parse_in, &tok,
955	(flags & CPP_N_RADIX)
956	| CPP_N_UNSIGNED);
957	ival[0] = integer.low;
958	ival[1] = integer.high;
959	ival[2] = 0;
960	if (prefix_len)
961	wval = wval + widest_int::from_array (val: ival, len: 3);
962	else
963	{
964	widest_int addend = widest_int::from_array (val: ival, len: 3);
965	wval = wi::add (x: wval, y: addend, sgn: UNSIGNED, overflow: &wioverflow);
966	if (wioverflow)
967	goto bitint_overflow;
968	}
969	}
970	}
971	while (1);
972	}
973
974	prec = wi::min_precision (x: wval, sgn: UNSIGNED);
975	if (prec == 0)
976	prec = 1;
977	if ((flags & CPP_N_UNSIGNED) == 0)
978	++prec;
979	if (prec > bitint_maxwidth)
980	{
981	bitint_overflow:
982	if ((flags & CPP_N_UNSIGNED) != 0)
983	error ("integer constant is too large for "
984	"%<unsigned _BitInt(%d)%> type", bitint_maxwidth);
985	else
986	error ("integer constant is too large for "
987	"%<_BitInt(%d)%> type", bitint_maxwidth);
988	return integer_zero_node;
989	}
990
991	struct bitint_info info;
992	if (!targetm.c.bitint_type_info (prec, &info))
993	{
994	sorry ("%<_BitInt(%d)%> is not supported on this target", prec);
995	return integer_zero_node;
996	}
997
998	type = build_bitint_type (prec, (flags & CPP_N_UNSIGNED) != 0);
999	return wide_int_to_tree (type, cst: wval);
1000	}
1001
1002	integer = cpp_interpret_integer (parse_in, token, flags);
1003	if (integer.overflow)
1004	*overflow = OT_OVERFLOW;
1005
1006	ival[0] = integer.low;
1007	ival[1] = integer.high;
1008	ival[2] = 0;
1009	widest_int wval = widest_int::from_array (val: ival, len: 3);
1010
1011	/* The type of a constant with a U suffix is straightforward. */
1012	if (flags & CPP_N_UNSIGNED)
1013	itk = narrowest_unsigned_type (val: wval, flags);
1014	else
1015	{
1016	/* The type of a potentially-signed integer constant varies
1017	depending on the base it's in, the standard in use, and the
1018	length suffixes. */
1019	enum integer_type_kind itk_u
1020	= narrowest_unsigned_type (val: wval, flags);
1021	enum integer_type_kind itk_s
1022	= narrowest_signed_type (val: wval, flags);
1023
1024	/* In both C89 and C99, octal and hex constants may be signed or
1025	unsigned, whichever fits tighter. We do not warn about this
1026	choice differing from the traditional choice, as the constant
1027	is probably a bit pattern and either way will work. */
1028	if ((flags & CPP_N_RADIX) != CPP_N_DECIMAL)
1029	itk = MIN (itk_u, itk_s);
1030	else
1031	{
1032	/* In C99, decimal constants are always signed.
1033	In C89, decimal constants that don't fit in long have
1034	undefined behavior; we try to make them unsigned long.
1035	In GCC's extended C89, that last is true of decimal
1036	constants that don't fit in long long, too. */
1037
1038	itk = itk_s;
1039	if (itk_s > itk_u && itk_s > itk_long)
1040	{
1041	if (!flag_isoc99)
1042	{
1043	if (itk_u < itk_unsigned_long)
1044	itk_u = itk_unsigned_long;
1045	itk = itk_u;
1046	warning (0, "this decimal constant is unsigned only in ISO C90");
1047	}
1048	else
1049	warning (OPT_Wtraditional,
1050	"this decimal constant would be unsigned in ISO C90");
1051	}
1052	}
1053	}
1054
1055	if (itk == itk_none)
1056	/* cpplib has already issued a warning for overflow. */
1057	type = ((flags & CPP_N_UNSIGNED)
1058	? widest_unsigned_literal_type_node
1059	: widest_integer_literal_type_node);
1060	else if (flags & CPP_N_SIZE_T)
1061	{
1062	/* itk refers to fundamental types not aliased size types. */
1063	if (flags & CPP_N_UNSIGNED)
1064	type = size_type_node;
1065	else
1066	type = signed_size_type_node;
1067	}
1068	else
1069	{
1070	type = integer_types[itk];
1071	if (itk > itk_unsigned_long
1072	&& (flags & CPP_N_WIDTH) != CPP_N_LARGE)
1073	emit_diagnostic
1074	((c_dialect_cxx () ? cxx_dialect == cxx98 : !flag_isoc99)
1075	? DK_PEDWARN : DK_WARNING,
1076	input_location, OPT_Wlong_long,
1077	(flags & CPP_N_UNSIGNED)
1078	? "integer constant is too large for %<unsigned long%> type"
1079	: "integer constant is too large for %<long%> type");
1080	}
1081
1082	value = wide_int_to_tree (type, cst: wval);
1083
1084	/* Convert imaginary to a complex type. */
1085	if (flags & CPP_N_IMAGINARY)
1086	value = build_complex (NULL_TREE, build_int_cst (type, 0), value);
1087
1088	return value;
1089	}
1090
1091	/* Interpret TOKEN, a floating point number with FLAGS as classified
1092	by cpplib. For C++11 SUFFIX may contain a user-defined literal suffix. */
1093	static tree
1094	interpret_float (const cpp_token *token, unsigned int flags,
1095	const char *suffix, enum overflow_type *overflow)
1096	{
1097	tree type;
1098	tree const_type;
1099	tree value;
1100	REAL_VALUE_TYPE real;
1101	REAL_VALUE_TYPE real_trunc;
1102	char *copy;
1103	size_t copylen;
1104
1105	*overflow = OT_NONE;
1106
1107	/* Default (no suffix) depends on whether the FLOAT_CONST_DECIMAL64
1108	pragma has been used and is either double or _Decimal64. Types
1109	that are not allowed with decimal float default to double. */
1110	if (flags & CPP_N_DEFAULT)
1111	{
1112	flags ^= CPP_N_DEFAULT;
1113	flags |= CPP_N_MEDIUM;
1114
1115	if (((flags & CPP_N_HEX) == 0) && ((flags & CPP_N_IMAGINARY) == 0))
1116	{
1117	warning (OPT_Wunsuffixed_float_constants,
1118	"unsuffixed floating constant");
1119	if (float_const_decimal64_p ())
1120	flags |= CPP_N_DFLOAT;
1121	}
1122	}
1123
1124	/* Decode _Fract and _Accum. */
1125	if (flags & CPP_N_FRACT || flags & CPP_N_ACCUM)
1126	return interpret_fixed (token, flags);
1127
1128	/* Decode type based on width and properties. */
1129	if (flags & CPP_N_DFLOAT)
1130	if (!targetm.decimal_float_supported_p ())
1131	{
1132	error ("decimal floating-point not supported for this target");
1133	return error_mark_node;
1134	}
1135	else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
1136	type = dfloat128_type_node;
1137	else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
1138	type = dfloat32_type_node;
1139	else
1140	type = dfloat64_type_node;
1141	else
1142	if (flags & CPP_N_WIDTH_MD)
1143	{
1144	char suffix;
1145	machine_mode mode;
1146
1147	if ((flags & CPP_N_WIDTH_MD) == CPP_N_MD_W)
1148	suffix = 'w';
1149	else
1150	suffix = 'q';
1151
1152	mode = targetm.c.mode_for_suffix (suffix);
1153	if (mode == VOIDmode)
1154	{
1155	error ("unsupported non-standard suffix on floating constant");
1156
1157	return error_mark_node;
1158	}
1159	else
1160	pedwarn (input_location, OPT_Wpedantic, "non-standard suffix on floating constant");
1161
1162	type = c_common_type_for_mode (mode, 0);
1163	/* For Q suffix, prefer float128t_type_node (__float128) type
1164	over float128_type_node (_Float128) type if they are distinct. */
1165	if (type == float128_type_node && float128t_type_node)
1166	type = float128t_type_node;
1167	gcc_assert (type);
1168	}
1169	else if ((flags & (CPP_N_FLOATN | CPP_N_FLOATNX)) != 0)
1170	{
1171	unsigned int n = (flags & CPP_N_WIDTH_FLOATN_NX) >> CPP_FLOATN_SHIFT;
1172	bool extended = (flags & CPP_N_FLOATNX) != 0;
1173	type = NULL_TREE;
1174	for (int i = 0; i < NUM_FLOATN_NX_TYPES; i++)
1175	if (floatn_nx_types[i].n == (int) n
1176	&& floatn_nx_types[i].extended == extended)
1177	{
1178	type = FLOATN_NX_TYPE_NODE (i);
1179	break;
1180	}
1181	if (type == NULL_TREE)
1182	{
1183	error ("unsupported non-standard suffix on floating constant");
1184	return error_mark_node;
1185	}
1186	else if (!c_dialect_cxx ())
1187	{
1188	if (warn_c11_c23_compat > 0)
1189	{
1190	if (pedantic && !flag_isoc23)
1191	pedwarn (input_location, OPT_Wc11_c23_compat,
1192	"non-standard suffix on floating constant "
1193	"before C23");
1194	else
1195	warning (OPT_Wc11_c23_compat,
1196	"non-standard suffix on floating constant "
1197	"before C23");
1198	}
1199	else if (warn_c11_c23_compat != 0 && pedantic && !flag_isoc23)
1200	pedwarn (input_location, OPT_Wpedantic,
1201	"non-standard suffix on floating constant "
1202	"before C23");
1203	}
1204	else if (!extended)
1205	{
1206	if (cxx_dialect < cxx23)
1207	pedwarn (input_location, OPT_Wpedantic,
1208	"%<f%d%> or %<F%d%> suffix on floating constant only "
1209	"available with %<-std=c++2b%> or %<-std=gnu++2b%>",
1210	n, n);
1211	}
1212	else
1213	pedwarn (input_location, OPT_Wpedantic,
1214	"non-standard suffix on floating constant");
1215	}
1216	else if ((flags & CPP_N_BFLOAT16) != 0)
1217	{
1218	type = bfloat16_type_node;
1219	if (type == NULL_TREE)
1220	{
1221	error ("unsupported non-standard suffix on floating constant");
1222	return error_mark_node;
1223	}
1224	if (!c_dialect_cxx ())
1225	pedwarn (input_location, OPT_Wpedantic,
1226	"non-standard suffix on floating constant");
1227	else if (cxx_dialect < cxx23)
1228	pedwarn (input_location, OPT_Wpedantic,
1229	"%<bf16%> or %<BF16%> suffix on floating constant only "
1230	"available with %<-std=c++2b%> or %<-std=gnu++2b%>");
1231	}
1232	else if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
1233	type = long_double_type_node;
1234	else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL
1235	|| flag_single_precision_constant)
1236	type = float_type_node;
1237	else
1238	type = double_type_node;
1239
1240	const_type = excess_precision_type (type);
1241	if (!const_type)
1242	const_type = type;
1243
1244	/* Copy the constant to a nul-terminated buffer. If the constant
1245	has any suffixes, cut them off; REAL_VALUE_ATOF/ REAL_VALUE_HTOF
1246	can't handle them. */
1247	copylen = token->val.str.len;
1248	if (flags & CPP_N_USERDEF)
1249	copylen -= strlen (s: suffix);
1250	else if (flags & CPP_N_DFLOAT)
1251	copylen -= 2;
1252	else
1253	{
1254	if ((flags & CPP_N_WIDTH) != CPP_N_MEDIUM)
1255	/* Must be an F or L or machine defined suffix. */
1256	copylen--;
1257	if (flags & CPP_N_IMAGINARY)
1258	/* I or J suffix. */
1259	copylen--;
1260	if (flags & CPP_N_FLOATNX)
1261	copylen--;
1262	if (flags & (CPP_N_FLOATN | CPP_N_FLOATNX))
1263	{
1264	unsigned int n = (flags & CPP_N_WIDTH_FLOATN_NX) >> CPP_FLOATN_SHIFT;
1265	while (n > 0)
1266	{
1267	copylen--;
1268	n /= 10;
1269	}
1270	}
1271	}
1272
1273	copy = (char *) alloca (copylen + 1);
1274	if (c_dialect_cxx () ? cxx_dialect > cxx11 : flag_isoc23)
1275	{
1276	size_t maxlen = 0;
1277	for (size_t i = 0; i < copylen; ++i)
1278	if (token->val.str.text[i] != '\'')
1279	copy[maxlen++] = token->val.str.text[i];
1280	copy[maxlen] = '\0';
1281	}
1282	else
1283	{
1284	memcpy (dest: copy, src: token->val.str.text, n: copylen);
1285	copy[copylen] = '\0';
1286	}
1287
1288	real_from_string3 (&real, copy, TYPE_MODE (const_type));
1289	if (const_type != type)
1290	/* Diagnosing if the result of converting the value with excess
1291	precision to the semantic type would overflow (with associated
1292	double rounding) is more appropriate than diagnosing if the
1293	result of converting the string directly to the semantic type
1294	would overflow. */
1295	real_convert (&real_trunc, TYPE_MODE (type), &real);
1296
1297	/* Both C and C++ require a diagnostic for a floating constant
1298	outside the range of representable values of its type. Since we
1299	have __builtin_inf* to produce an infinity, this is now a
1300	mandatory pedwarn if the target does not support infinities. */
1301	if (REAL_VALUE_ISINF (real)
1302	|| (const_type != type && REAL_VALUE_ISINF (real_trunc)))
1303	{
1304	*overflow = OT_OVERFLOW;
1305	if (!(flags & CPP_N_USERDEF))
1306	{
1307	if (!MODE_HAS_INFINITIES (TYPE_MODE (type)))
1308	pedwarn (input_location, 0,
1309	"floating constant exceeds range of %qT", type);
1310	else
1311	warning (OPT_Woverflow,
1312	"floating constant exceeds range of %qT", type);
1313	}
1314	}
1315	/* We also give a warning if the value underflows. */
1316	else if (real_equal (&real, &dconst0)
1317	|| (const_type != type
1318	&& real_equal (&real_trunc, &dconst0)))
1319	{
1320	REAL_VALUE_TYPE realvoidmode;
1321	int oflow = real_from_string (&realvoidmode, copy);
1322	*overflow = (oflow == 0 ? OT_NONE
1323	: (oflow < 0 ? OT_UNDERFLOW : OT_OVERFLOW));
1324	if (!(flags & CPP_N_USERDEF))
1325	{
1326	if (oflow < 0 || !real_equal (&realvoidmode, &dconst0))
1327	warning (OPT_Woverflow, "floating constant truncated to zero");
1328	}
1329	}
1330
1331	/* Create a node with determined type and value. */
1332	value = build_real (const_type, real);
1333	if (flags & CPP_N_IMAGINARY)
1334	{
1335	value = build_complex (NULL_TREE,
1336	fold_convert (const_type,
1337	integer_zero_node), value);
1338	if (type != const_type)
1339	{
1340	const_type = TREE_TYPE (value);
1341	type = build_complex_type (type);
1342	}
1343	}
1344
1345	if (type != const_type)
1346	value = build1_loc (loc: token->src_loc, code: EXCESS_PRECISION_EXPR, type, arg1: value);
1347
1348	return value;
1349	}
1350
1351	/* Interpret TOKEN, a fixed-point number with FLAGS as classified
1352	by cpplib. */
1353
1354	static tree
1355	interpret_fixed (const cpp_token *token, unsigned int flags)
1356	{
1357	tree type;
1358	tree value;
1359	FIXED_VALUE_TYPE fixed;
1360	char *copy;
1361	size_t copylen;
1362
1363	copylen = token->val.str.len;
1364
1365	if (flags & CPP_N_FRACT) /* _Fract. */
1366	{
1367	if (flags & CPP_N_UNSIGNED) /* Unsigned _Fract. */
1368	{
1369	if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
1370	{
1371	type = unsigned_long_long_fract_type_node;
1372	copylen -= 4;
1373	}
1374	else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
1375	{
1376	type = unsigned_long_fract_type_node;
1377	copylen -= 3;
1378	}
1379	else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
1380	{
1381	type = unsigned_short_fract_type_node;
1382	copylen -= 3;
1383	}
1384	else
1385	{
1386	type = unsigned_fract_type_node;
1387	copylen -= 2;
1388	}
1389	}
1390	else /* Signed _Fract. */
1391	{
1392	if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
1393	{
1394	type = long_long_fract_type_node;
1395	copylen -= 3;
1396	}
1397	else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
1398	{
1399	type = long_fract_type_node;
1400	copylen -= 2;
1401	}
1402	else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
1403	{
1404	type = short_fract_type_node;
1405	copylen -= 2;
1406	}
1407	else
1408	{
1409	type = fract_type_node;
1410	copylen --;
1411	}
1412	}
1413	}
1414	else /* _Accum. */
1415	{
1416	if (flags & CPP_N_UNSIGNED) /* Unsigned _Accum. */
1417	{
1418	if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
1419	{
1420	type = unsigned_long_long_accum_type_node;
1421	copylen -= 4;
1422	}
1423	else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
1424	{
1425	type = unsigned_long_accum_type_node;
1426	copylen -= 3;
1427	}
1428	else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
1429	{
1430	type = unsigned_short_accum_type_node;
1431	copylen -= 3;
1432	}
1433	else
1434	{
1435	type = unsigned_accum_type_node;
1436	copylen -= 2;
1437	}
1438	}
1439	else /* Signed _Accum. */
1440	{
1441	if ((flags & CPP_N_WIDTH) == CPP_N_LARGE)
1442	{
1443	type = long_long_accum_type_node;
1444	copylen -= 3;
1445	}
1446	else if ((flags & CPP_N_WIDTH) == CPP_N_MEDIUM)
1447	{
1448	type = long_accum_type_node;
1449	copylen -= 2;
1450	}
1451	else if ((flags & CPP_N_WIDTH) == CPP_N_SMALL)
1452	{
1453	type = short_accum_type_node;
1454	copylen -= 2;
1455	}
1456	else
1457	{
1458	type = accum_type_node;
1459	copylen --;
1460	}
1461	}
1462	}
1463
1464	copy = (char *) alloca (copylen + 1);
1465	memcpy (dest: copy, src: token->val.str.text, n: copylen);
1466	copy[copylen] = '\0';
1467
1468	fixed_from_string (&fixed, copy, SCALAR_TYPE_MODE (type));
1469
1470	/* Create a node with determined type and value. */
1471	value = build_fixed (type, fixed);
1472
1473	return value;
1474	}
1475
1476	/* Convert a series of STRING, WSTRING, STRING16, STRING32 and/or
1477	UTF8STRING tokens into a tree, performing string constant
1478	concatenation. TOK is the first of these. VALP is the location to
1479	write the string into. OBJC_STRING indicates whether an '@' token
1480	preceded the incoming token (in that case, the strings can either
1481	be ObjC strings, preceded by a single '@', or normal strings, not
1482	preceded by '@'. The result will be a CPP_OBJC_STRING). Returns
1483	the CPP token type of the result (CPP_STRING, CPP_WSTRING,
1484	CPP_STRING32, CPP_STRING16, CPP_UTF8STRING, or CPP_OBJC_STRING).
1485
1486	This is unfortunately more work than it should be. If any of the
1487	strings in the series has an L prefix, the result is a wide string
1488	(6.4.5p4). Whether or not the result is a wide string affects the
1489	meaning of octal and hexadecimal escapes (6.4.4.4p6,9). But escape
1490	sequences do not continue across the boundary between two strings in
1491	a series (6.4.5p7), so we must not lose the boundaries. Therefore
1492	cpp_interpret_string takes a vector of cpp_string structures, which
1493	we must arrange to provide. */
1494
1495	static enum cpp_ttype
1496	lex_string (const cpp_token *tok, tree *valp, bool objc_string, bool translate)
1497	{
1498	tree value;
1499	size_t concats = 0;
1500	struct obstack str_ob;
1501	struct obstack loc_ob;
1502	cpp_string istr;
1503	enum cpp_ttype type = tok->type;
1504
1505	/* Try to avoid the overhead of creating and destroying an obstack
1506	for the common case of just one string. */
1507	cpp_string str = tok->val.str;
1508	location_t init_loc = tok->src_loc;
1509	cpp_string *strs = &str;
1510	location_t *locs = NULL;
1511
1512	/* objc_at_sign_was_seen is only used when doing Objective-C string
1513	concatenation. It is 'true' if we have seen an '@' before the
1514	current string, and 'false' if not. We must see exactly one or
1515	zero '@' before each string. */
1516	bool objc_at_sign_was_seen = false;
1517
1518	retry:
1519	tok = get_token (pfile: parse_in);
1520	switch (tok->type)
1521	{
1522	case CPP_PADDING:
1523	goto retry;
1524	case CPP_ATSIGN:
1525	if (objc_string)
1526	{
1527	if (objc_at_sign_was_seen)
1528	error ("repeated %<@%> before Objective-C string");
1529
1530	objc_at_sign_was_seen = true;
1531	goto retry;
1532	}
1533	/* FALLTHROUGH */
1534
1535	default:
1536	break;
1537
1538	case CPP_WSTRING:
1539	case CPP_STRING16:
1540	case CPP_STRING32:
1541	case CPP_UTF8STRING:
1542	if (type != tok->type)
1543	{
1544	if (type == CPP_STRING)
1545	type = tok->type;
1546	else
1547	error ("unsupported non-standard concatenation of string literals");
1548	}
1549	/* FALLTHROUGH */
1550
1551	case CPP_STRING:
1552	if (!concats)
1553	{
1554	gcc_obstack_init (&str_ob);
1555	gcc_obstack_init (&loc_ob);
1556	obstack_grow (&str_ob, &str, sizeof (cpp_string));
1557	obstack_grow (&loc_ob, &init_loc, sizeof (location_t));
1558	}
1559
1560	concats++;
1561	obstack_grow (&str_ob, &tok->val.str, sizeof (cpp_string));
1562	obstack_grow (&loc_ob, &tok->src_loc, sizeof (location_t));
1563
1564	if (objc_string)
1565	objc_at_sign_was_seen = false;
1566	goto retry;
1567	}
1568
1569	/* It is an error if we saw a '@' with no following string. */
1570	if (objc_at_sign_was_seen)
1571	error ("stray %<@%> in program");
1572
1573	/* We have read one more token than we want. */
1574	_cpp_backup_tokens (parse_in, 1);
1575	if (concats)
1576	{
1577	strs = XOBFINISH (&str_ob, cpp_string *);
1578	locs = XOBFINISH (&loc_ob, location_t *);
1579	}
1580
1581	if (concats && !objc_string && !in_system_header_at (loc: input_location))
1582	warning (OPT_Wtraditional,
1583	"traditional C rejects string constant concatenation");
1584
1585	if ((translate
1586	? cpp_interpret_string : cpp_interpret_string_notranslate)
1587	(parse_in, strs, concats + 1, &istr, type))
1588	{
1589	value = build_string (istr.len, (const char *) istr.text);
1590	free (CONST_CAST (unsigned char *, istr.text));
1591	if (concats)
1592	{
1593	gcc_assert (locs);
1594	gcc_assert (g_string_concat_db);
1595	g_string_concat_db->record_string_concatenation (num: concats + 1, locs);
1596	}
1597	}
1598	else
1599	{
1600	/* Callers cannot generally handle error_mark_node in this context,
1601	so return the empty string instead. cpp_interpret_string has
1602	issued an error. */
1603	switch (type)
1604	{
1605	default:
1606	case CPP_STRING:
1607	case CPP_UTF8STRING:
1608	if (type == CPP_UTF8STRING && flag_char8_t)
1609	{
1610	value = build_string (TYPE_PRECISION (char8_type_node)
1611	/ TYPE_PRECISION (char_type_node),
1612	""); /* char8_t is 8 bits */
1613	}
1614	else
1615	value = build_string (1, "");
1616	break;
1617	case CPP_STRING16:
1618	value = build_string (TYPE_PRECISION (char16_type_node)
1619	/ TYPE_PRECISION (char_type_node),
1620	"\0"); /* char16_t is 16 bits */
1621	break;
1622	case CPP_STRING32:
1623	value = build_string (TYPE_PRECISION (char32_type_node)
1624	/ TYPE_PRECISION (char_type_node),
1625	"\0\0\0"); /* char32_t is 32 bits */
1626	break;
1627	case CPP_WSTRING:
1628	value = build_string (TYPE_PRECISION (wchar_type_node)
1629	/ TYPE_PRECISION (char_type_node),
1630	"\0\0\0"); /* widest supported wchar_t
1631	is 32 bits */
1632	break;
1633	}
1634	}
1635
1636	switch (type)
1637	{
1638	default:
1639	case CPP_STRING:
1640	TREE_TYPE (value) = char_array_type_node;
1641	break;
1642	case CPP_UTF8STRING:
1643	if (flag_char8_t)
1644	TREE_TYPE (value) = char8_array_type_node;
1645	else
1646	TREE_TYPE (value) = char_array_type_node;
1647	break;
1648	case CPP_STRING16:
1649	TREE_TYPE (value) = char16_array_type_node;
1650	break;
1651	case CPP_STRING32:
1652	TREE_TYPE (value) = char32_array_type_node;
1653	break;
1654	case CPP_WSTRING:
1655	TREE_TYPE (value) = wchar_array_type_node;
1656	}
1657	*valp = fix_string_type (value);
1658
1659	if (concats)
1660	{
1661	obstack_free (&str_ob, 0);
1662	obstack_free (&loc_ob, 0);
1663	}
1664
1665	return objc_string ? CPP_OBJC_STRING : type;
1666	}
1667
1668	/* Converts a (possibly wide) character constant token into a tree. */
1669	static tree
1670	lex_charconst (const cpp_token *token)
1671	{
1672	cppchar_t result;
1673	tree type, value;
1674	unsigned int chars_seen;
1675	int unsignedp = 0;
1676
1677	result = cpp_interpret_charconst (parse_in, token,
1678	&chars_seen, &unsignedp);
1679
1680	if (token->type == CPP_WCHAR)
1681	type = wchar_type_node;
1682	else if (token->type == CPP_CHAR32)
1683	type = char32_type_node;
1684	else if (token->type == CPP_CHAR16)
1685	type = char16_type_node;
1686	else if (token->type == CPP_UTF8CHAR)
1687	{
1688	if (flag_char8_t)
1689	type = char8_type_node;
1690	else
1691	type = char_type_node;
1692	}
1693	/* In C, a character constant has type 'int'.
1694	In C++ 'char', but multi-char charconsts have type 'int'. */
1695	else if (!c_dialect_cxx () || chars_seen > 1)
1696	type = integer_type_node;
1697	else
1698	type = char_type_node;
1699
1700	/* Cast to cppchar_signed_t to get correct sign-extension of RESULT
1701	before possibly widening to HOST_WIDE_INT for build_int_cst. */
1702	if (unsignedp || (cppchar_signed_t) result >= 0)
1703	value = build_int_cst (type, result);
1704	else
1705	value = build_int_cst (type, (cppchar_signed_t) result);
1706
1707	return value;
1708	}
1709
1710	/* Helper function for c_parser_peek_conflict_marker
1711	and cp_lexer_peek_conflict_marker.
1712	Given a possible conflict marker token of kind TOK1_KIND
1713	consisting of a pair of characters, get the token kind for the
1714	standalone final character. */
1715
1716	enum cpp_ttype
1717	conflict_marker_get_final_tok_kind (enum cpp_ttype tok1_kind)
1718	{
1719	switch (tok1_kind)
1720	{
1721	default: gcc_unreachable ();
1722	case CPP_LSHIFT:
1723	/* "<<" and '<' */
1724	return CPP_LESS;
1725
1726	case CPP_EQ_EQ:
1727	/* "==" and '=' */
1728	return CPP_EQ;
1729
1730	case CPP_RSHIFT:
1731	/* ">>" and '>' */
1732	return CPP_GREATER;
1733	}
1734	}
1735