Planet

navi

home

PPS

about

screenshots

download

development

forum

Context Navigation

source: downloads/boost_1_33_1/boost/wave/grammars/cpp_grammar.hpp @ 12

Last change on this file since 12 was 12, checked in by landauf, 18 years ago
added boost
File size: 27.3 KB

Line
1	/*=============================================================================
2	Boost.Wave: A Standard compliant C++ preprocessor library
3
4	http://www.boost.org/
5
6	Copyright (c) 2001-2005 Hartmut Kaiser. Distributed under the Boost
7	Software License, Version 1.0. (See accompanying file
8	LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
9	=============================================================================*/
10
11	#if !defined(CPP_GRAMMAR_HPP_FEAEBC2E_2734_428B_A7CA_85E5A415E23E_INCLUDED)
12	#define CPP_GRAMMAR_HPP_FEAEBC2E_2734_428B_A7CA_85E5A415E23E_INCLUDED
13
14	#include <boost/spirit/core.hpp>
15	#include <boost/spirit/tree/parse_tree.hpp>
16	#include <boost/spirit/tree/parse_tree_utils.hpp>
17	#include <boost/spirit/utility/confix.hpp>
18	#include <boost/spirit/utility/lists.hpp>
19
20	#include <boost/wave/wave_config.hpp>
21
22	#if BOOST_WAVE_DUMP_PARSE_TREE != 0
23	#include <map>
24	#include <boost/spirit/tree/tree_to_xml.hpp>
25	#endif
26
27	#include <boost/wave/token_ids.hpp>
28	#include <boost/wave/grammars/cpp_grammar_gen.hpp>
29	#include <boost/wave/util/pattern_parser.hpp>
30
31	#include <boost/wave/cpp_exceptions.hpp>
32
33	///////////////////////////////////////////////////////////////////////////////
34	namespace boost {
35	namespace wave {
36	namespace grammars {
37
38	namespace impl {
39
40	///////////////////////////////////////////////////////////////////////////////
41	//
42	// store_position
43	//
44	// The store_position functor extracts the actual file position from the
45	// supplied token.
46	//
47	///////////////////////////////////////////////////////////////////////////////
48
49	template <typename PositionT>
50	struct store_position {
51
52	store_position(PositionT &pos_) : pos(pos_) {}
53
54	template <typename TokenT>
55	void operator()(TokenT const &token) const
56	{
57	pos = token.get_position();
58	}
59
60	PositionT &pos;
61	};
62
63	///////////////////////////////////////////////////////////////////////////////
64	//
65	// store_found_eof
66	//
67	// The store_found_eof functor sets a given flag if the T_EOF token was
68	// found during the parsing process
69	//
70	///////////////////////////////////////////////////////////////////////////////
71
72	struct store_found_eof {
73
74	store_found_eof(bool &found_eof_) : found_eof(found_eof_) {}
75
76	template <typename TokenT>
77	void operator()(TokenT const &token) const
78	{
79	found_eof = true;
80	}
81
82	bool &found_eof;
83	};
84
85	///////////////////////////////////////////////////////////////////////////////
86	//
87	// store_found_directive
88	//
89	// The store_found_directive functor stores the token_id of the recognized
90	// pp directive
91	//
92	///////////////////////////////////////////////////////////////////////////////
93
94	struct store_found_directive {
95
96	store_found_directive(boost::wave::token_id &found_directive_)
97	: found_directive(found_directive_) {}
98
99	template <typename TokenT>
100	void operator()(TokenT const &token) const
101	{
102	found_directive = boost::wave::token_id(token);
103	}
104
105	boost::wave::token_id &found_directive;
106	};
107
108	///////////////////////////////////////////////////////////////////////////////
109	//
110	// flush_underlying_parser
111	//
112	// The flush_underlying_parser flushes the underlying
113	// multi_pass_iterator during the normal parsing process. This is
114	// used at certain points during the parsing process, when it is
115	// clear, that no backtracking is needed anymore and the input
116	// gathered so far may be discarded.
117	//
118	///////////////////////////////////////////////////////////////////////////////
119	struct flush_underlying_parser
120	: public boost::spirit::parser<flush_underlying_parser>
121	{
122	typedef flush_underlying_parser this_t;
123
124	template <typename ScannerT>
125	typename boost::spirit::parser_result<this_t, ScannerT>::type
126	parse(ScannerT const& scan) const
127	{
128	scan.first.clear_queue();
129	return scan.empty_match();
130	}
131	};
132
133	flush_underlying_parser const
134	flush_underlying_parser_p = flush_underlying_parser();
135
136	} // anonymous namespace
137
138	///////////////////////////////////////////////////////////////////////////////
139	// define, whether the rule's should generate some debug output
140	#define TRACE_CPP_GRAMMAR \
141	bool(BOOST_SPIRIT_DEBUG_FLAGS_CPP & BOOST_SPIRIT_DEBUG_FLAGS_CPP_GRAMMAR) \
142	/**/
143
144	///////////////////////////////////////////////////////////////////////////////
145	// Encapsulation of the C++ preprocessor grammar.
146	template <typename PositionT>
147	struct cpp_grammar :
148	public boost::spirit::grammar<cpp_grammar<PositionT> >
149	{
150	typedef cpp_grammar<PositionT> grammar_t;
151	typedef impl::store_position<PositionT> store_pos_t;
152	typedef impl::store_found_eof store_found_eof_t;
153	typedef impl::store_found_directive store_found_directive_t;
154
155	template <typename ScannerT>
156	struct definition
157	{
158	// non-parse_tree generating rule type
159	typedef typename ScannerT::iteration_policy_t iteration_policy_t;
160	typedef boost::spirit::match_policy match_policy_t;
161	typedef typename ScannerT::action_policy_t action_policy_t;
162	typedef
163	boost::spirit::scanner_policies<
164	iteration_policy_t, match_policy_t, action_policy_t>
165	policies_t;
166	typedef
167	boost::spirit::scanner<typename ScannerT::iterator_t, policies_t>
168	non_tree_scanner_t;
169	typedef boost::spirit::rule<non_tree_scanner_t> no_tree_rule_t;
170
171	// 'normal' (parse_tree generating) rule type
172	typedef boost::spirit::rule<ScannerT> rule_t;
173
174	rule_t pp_statement;
175	rule_t include_file, system_include_file, macro_include_file;
176	rule_t plain_define, macro_definition, macro_parameters;
177	rule_t undefine;
178	rule_t ppifdef, ppifndef, ppif, ppelse, ppelif, ppendif;
179	rule_t ppline;
180	rule_t pperror;
181	rule_t ppwarning;
182	rule_t pppragma;
183	rule_t illformed;
184	rule_t ppqualifiedname;
185	rule_t eol_tokens;
186	no_tree_rule_t ppsp;
187	#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0
188	rule_t ppregion;
189	rule_t ppendregion;
190	#endif
191
192	definition(cpp_grammar const &self)
193	{
194	// import the spirit and cpplexer namespaces here
195	using namespace boost::spirit;
196	using namespace boost::wave;
197	using namespace boost::wave::util;
198
199	// save the rule id's for later use
200	self.rule_ids.pp_statement_id = pp_statement.id().to_long();
201	self.rule_ids.include_file_id = include_file.id().to_long();
202	self.rule_ids.sysinclude_file_id = system_include_file.id().to_long();
203	self.rule_ids.macroinclude_file_id = macro_include_file.id().to_long();
204	self.rule_ids.plain_define_id = plain_define.id().to_long();
205	self.rule_ids.macro_parameters_id = macro_parameters.id().to_long();
206	self.rule_ids.macro_definition_id = macro_definition.id().to_long();
207	self.rule_ids.undefine_id = undefine.id().to_long();
208	self.rule_ids.ifdef_id = ppifdef.id().to_long();
209	self.rule_ids.ifndef_id = ppifndef.id().to_long();
210	self.rule_ids.if_id = ppif.id().to_long();
211	self.rule_ids.elif_id = ppelif.id().to_long();
212	self.rule_ids.else_id = ppelse.id().to_long();
213	self.rule_ids.endif_id = ppendif.id().to_long();
214	self.rule_ids.line_id = ppline.id().to_long();
215	self.rule_ids.error_id = pperror.id().to_long();
216	self.rule_ids.warning_id = ppwarning.id().to_long();
217	self.rule_ids.pragma_id = pppragma.id().to_long();
218	self.rule_ids.illformed_id = illformed.id().to_long();
219	self.rule_ids.ppspace_id = ppsp.id().to_long();
220	self.rule_ids.ppqualifiedname_id = ppqualifiedname.id().to_long();
221	#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0
222	self.rule_ids.region_id = ppregion.id().to_long();
223	self.rule_ids.endregion_id = ppendregion.id().to_long();
224	#endif
225
226	#if BOOST_WAVE_DUMP_PARSE_TREE != 0
227	self.map_rule_id_to_name.init_rule_id_to_name_map(self);
228	#endif
229
230	// recognizes preprocessor directives only
231
232	// C++ standard 16.1: A preprocessing directive consists of a sequence
233	// of preprocessing tokens. The first token in the sequence is #
234	// preprocessing token that is either the first character in the source
235	// file (optionally after white space containing no new-line
236	// characters) or that follows white space containing at least one
237	// new-line character. The last token in the sequence is the first
238	// new-line character that follows the first token in the sequence.
239
240	pp_statement
241	= ( include_file
242	\| system_include_file
243	\| macro_include_file
244	\| plain_define
245	\| undefine
246	\| ppifdef
247	\| ppifndef
248	\| ppif
249	\| ppelse
250	\| ppelif
251	\| ppendif
252	\| ppline
253	\| pperror
254	\| ppwarning
255	\| pppragma
256	\| illformed
257	#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0
258	\| ppregion
259	\| ppendregion
260	#endif
261	)
262	>> eol_tokens
263	// In parser debug mode it is useful not to flush the underlying stream
264	// to allow its investigation in the debugger and to see the correct
265	// output in the printed debug log..
266	// Note: this may break the parser, though.
267	#if !(defined(BOOST_SPIRIT_DEBUG) && \
268	(BOOST_SPIRIT_DEBUG_FLAGS_CPP & BOOST_SPIRIT_DEBUG_FLAGS_CPP_GRAMMAR) \
269	)
270	>> impl::flush_underlying_parser_p
271	#endif // !(defined(BOOST_SPIRIT_DEBUG) &&
272	;
273
274	// #include ...
275	include_file // include "..."
276	= ch_p(T_PP_QHEADER)
277	[ store_found_directive_t(self.found_directive) ]
278	#if BOOST_WAVE_SUPPORT_INCLUDE_NEXT != 0
279	\| ch_p(T_PP_QHEADER_NEXT)
280	[ store_found_directive_t(self.found_directive) ]
281	#endif
282	;
283
284	system_include_file // include <...>
285	= ch_p(T_PP_HHEADER)
286	[ store_found_directive_t(self.found_directive) ]
287	#if BOOST_WAVE_SUPPORT_INCLUDE_NEXT != 0
288	\| ch_p(T_PP_HHEADER_NEXT)
289	[ store_found_directive_t(self.found_directive) ]
290	#endif
291	;
292
293	macro_include_file // include ...anything else...
294	= no_node_d
295	[
296	ch_p(T_PP_INCLUDE)
297	[ store_found_directive_t(self.found_directive) ]
298	#if BOOST_WAVE_SUPPORT_INCLUDE_NEXT != 0
299	\| ch_p(T_PP_INCLUDE_NEXT)
300	[ store_found_directive_t(self.found_directive) ]
301	#endif
302	]
303	>> *( anychar_p -
304	(ch_p(T_NEWLINE) \| ch_p(T_CPPCOMMENT) \| ch_p(T_EOF))
305	)
306	;
307
308	// #define FOO foo (with optional parameters)
309	plain_define
310	= no_node_d
311	[
312	ch_p(T_PP_DEFINE)
313	[ store_found_directive_t(self.found_directive) ]
314	>> +ppsp
315	]
316	>> ( ch_p(T_IDENTIFIER)
317	\| pattern_p(KeywordTokenType, TokenTypeMask)
318	\| pattern_p(OperatorTokenType\|AltExtTokenType,
319	ExtTokenTypeMask) // and, bit_and etc.
320	)
321	>> ( ( no_node_d[eps_p(ch_p(T_LEFTPAREN))]
322	>> macro_parameters
323	>> !macro_definition
324	)
325	\| !( no_node_d[+ppsp]
326	>> macro_definition
327	)
328	)
329	;
330
331	// parameter list
332	// normal C++ mode
333	macro_parameters
334	= confix_p(
335	no_node_d[ch_p(T_LEFTPAREN) >> *ppsp],
336	!list_p(
337	( ch_p(T_IDENTIFIER)
338	\| pattern_p(KeywordTokenType, TokenTypeMask)
339	\| pattern_p(OperatorTokenType\|AltExtTokenType,
340	ExtTokenTypeMask) // and, bit_and etc.
341	#if BOOST_WAVE_SUPPORT_VARIADICS_PLACEMARKERS != 0
342	\| ch_p(T_ELLIPSIS)
343	#endif
344	),
345	no_node_d[ppsp >> ch_p(T_COMMA) >> ppsp]
346	),
347	no_node_d[*ppsp >> ch_p(T_RIGHTPAREN)]
348	)
349	;
350
351	// macro body (anything left until eol)
352	macro_definition
353	= no_node_d[*ppsp]
354	>> *( anychar_p -
355	(ch_p(T_NEWLINE) \| ch_p(T_CPPCOMMENT) \| ch_p(T_EOF))
356	)
357	;
358
359	// #undef FOO
360	undefine
361	= no_node_d
362	[
363	ch_p(T_PP_UNDEF)
364	[ store_found_directive_t(self.found_directive) ]
365	>> +ppsp
366	]
367	>> ( ch_p(T_IDENTIFIER)
368	\| pattern_p(KeywordTokenType, TokenTypeMask)
369	\| pattern_p(OperatorTokenType\|AltExtTokenType,
370	ExtTokenTypeMask) // and, bit_and etc.
371	)
372	;
373
374	// #ifdef et.al.
375	ppifdef
376	= no_node_d
377	[
378	ch_p(T_PP_IFDEF)
379	[ store_found_directive_t(self.found_directive) ]
380	>> +ppsp
381	]
382	>> ppqualifiedname
383	;
384
385	ppifndef
386	= no_node_d
387	[
388	ch_p(T_PP_IFNDEF)
389	[ store_found_directive_t(self.found_directive) ]
390	>> +ppsp
391	]
392	>> ppqualifiedname
393	;
394
395	ppif
396	= no_node_d
397	[
398	ch_p(T_PP_IF)
399	[ store_found_directive_t(self.found_directive) ]
400	>> *ppsp
401	]
402	>> +( anychar_p -
403	(ch_p(T_NEWLINE) \| ch_p(T_CPPCOMMENT) \| ch_p(T_EOF))
404	)
405	;
406
407	ppelse
408	= no_node_d
409	[
410	ch_p(T_PP_ELSE)
411	[ store_found_directive_t(self.found_directive) ]
412	]
413	;
414
415	ppelif
416	= no_node_d
417	[
418	ch_p(T_PP_ELIF)
419	[ store_found_directive_t(self.found_directive) ]
420	>> *ppsp
421	]
422	>> +( anychar_p -
423	(ch_p(T_NEWLINE) \| ch_p(T_CPPCOMMENT) \| ch_p(T_EOF))
424	)
425	;
426
427	ppendif
428	= no_node_d
429	[
430	ch_p(T_PP_ENDIF)
431	[ store_found_directive_t(self.found_directive) ]
432	]
433	;
434
435	// #line ...
436	ppline
437	= no_node_d
438	[
439	ch_p(T_PP_LINE)
440	[ store_found_directive_t(self.found_directive) ]
441	>> *ppsp
442	]
443	>> +( anychar_p -
444	(ch_p(T_NEWLINE) \| ch_p(T_CPPCOMMENT) \| ch_p(T_EOF))
445	)
446	;
447
448	#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0
449	// #region ...
450	ppregion
451	= no_node_d
452	[
453	ch_p(T_MSEXT_PP_REGION)
454	[ store_found_directive_t(self.found_directive) ]
455	>> +ppsp
456	]
457	>> ppqualifiedname
458	;
459
460	// #endregion
461	ppendregion
462	= no_node_d
463	[
464	ch_p(T_MSEXT_PP_ENDREGION)
465	[ store_found_directive_t(self.found_directive) ]
466	]
467	;
468	#endif
469
470	// # something else (ill formed preprocessor directive)
471	illformed // for error reporting
472	= no_node_d
473	[
474	pattern_p(T_POUND, MainTokenMask)
475	>> *ppsp
476	]
477	>> ( anychar_p -
478	(ch_p(T_NEWLINE) \| ch_p(T_CPPCOMMENT) \| ch_p(T_EOF))
479	)
480	>> no_node_d
481	[
482	*( anychar_p -
483	(ch_p(T_NEWLINE) \| ch_p(T_CPPCOMMENT) \| ch_p(T_EOF))
484	)
485	]
486	;
487
488	// #error
489	pperror
490	= no_node_d
491	[
492	ch_p(T_PP_ERROR)
493	[ store_found_directive_t(self.found_directive) ]
494	>> *ppsp
495	]
496	>> *( anychar_p -
497	(ch_p(T_NEWLINE) \| ch_p(T_CPPCOMMENT) \| ch_p(T_EOF))
498	)
499	;
500
501	// #warning
502	ppwarning
503	= no_node_d
504	[
505	ch_p(T_PP_WARNING)
506	[ store_found_directive_t(self.found_directive) ]
507	>> *ppsp
508	]
509	>> *( anychar_p -
510	(ch_p(T_NEWLINE) \| ch_p(T_CPPCOMMENT) \| ch_p(T_EOF))
511	)
512	;
513
514	// #pragma ...
515	pppragma
516	= no_node_d
517	[
518	ch_p(T_PP_PRAGMA)
519	[ store_found_directive_t(self.found_directive) ]
520	]
521	>> *( anychar_p -
522	(ch_p(T_NEWLINE) \| ch_p(T_CPPCOMMENT) \| ch_p(T_EOF))
523	)
524	;
525
526	ppqualifiedname
527	= no_node_d[*ppsp]
528	>> ( ch_p(T_IDENTIFIER)
529	\| pattern_p(KeywordTokenType, TokenTypeMask)
530	\| pattern_p(OperatorTokenType\|AltExtTokenType,
531	ExtTokenTypeMask) // and, bit_and etc.
532	)
533	;
534
535	// auxiliary helper rules
536	ppsp // valid space in a line with a preprocessor directive
537	= ch_p(T_SPACE) \| ch_p(T_CCOMMENT)
538	;
539
540	// end of line tokens
541	eol_tokens
542	= no_node_d
543	[
544	*ppsp
545	>> ( ch_p(T_NEWLINE)
546	[ store_pos_t(self.pos_of_newline) ]
547	\| ch_p(T_CPPCOMMENT)
548	[ store_pos_t(self.pos_of_newline) ]
549	\| ch_p(T_EOF)
550	[ store_pos_t(self.pos_of_newline) ]
551	[ store_found_eof_t(self.found_eof) ]
552	)
553	]
554	;
555
556	BOOST_SPIRIT_DEBUG_TRACE_RULE(pp_statement, TRACE_CPP_GRAMMAR);
557	BOOST_SPIRIT_DEBUG_TRACE_RULE(include_file, TRACE_CPP_GRAMMAR);
558	BOOST_SPIRIT_DEBUG_TRACE_RULE(system_include_file, TRACE_CPP_GRAMMAR);
559	BOOST_SPIRIT_DEBUG_TRACE_RULE(macro_include_file, TRACE_CPP_GRAMMAR);
560	BOOST_SPIRIT_DEBUG_TRACE_RULE(plain_define, TRACE_CPP_GRAMMAR);
561	BOOST_SPIRIT_DEBUG_TRACE_RULE(macro_definition, TRACE_CPP_GRAMMAR);
562	BOOST_SPIRIT_DEBUG_TRACE_RULE(macro_parameters, TRACE_CPP_GRAMMAR);
563	BOOST_SPIRIT_DEBUG_TRACE_RULE(undefine, TRACE_CPP_GRAMMAR);
564	BOOST_SPIRIT_DEBUG_TRACE_RULE(ppifdef, TRACE_CPP_GRAMMAR);
565	BOOST_SPIRIT_DEBUG_TRACE_RULE(ppifndef, TRACE_CPP_GRAMMAR);
566	BOOST_SPIRIT_DEBUG_TRACE_RULE(ppif, TRACE_CPP_GRAMMAR);
567	BOOST_SPIRIT_DEBUG_TRACE_RULE(ppelse, TRACE_CPP_GRAMMAR);
568	BOOST_SPIRIT_DEBUG_TRACE_RULE(ppelif, TRACE_CPP_GRAMMAR);
569	BOOST_SPIRIT_DEBUG_TRACE_RULE(ppendif, TRACE_CPP_GRAMMAR);
570	BOOST_SPIRIT_DEBUG_TRACE_RULE(ppline, TRACE_CPP_GRAMMAR);
571	BOOST_SPIRIT_DEBUG_TRACE_RULE(pperror, TRACE_CPP_GRAMMAR);
572	BOOST_SPIRIT_DEBUG_TRACE_RULE(ppwarning, TRACE_CPP_GRAMMAR);
573	BOOST_SPIRIT_DEBUG_TRACE_RULE(illformed, TRACE_CPP_GRAMMAR);
574	BOOST_SPIRIT_DEBUG_TRACE_RULE(ppsp, TRACE_CPP_GRAMMAR);
575	BOOST_SPIRIT_DEBUG_TRACE_RULE(ppqualifiedname, TRACE_CPP_GRAMMAR);
576	#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0
577	BOOST_SPIRIT_DEBUG_TRACE_RULE(ppregion, TRACE_CPP_GRAMMAR);
578	BOOST_SPIRIT_DEBUG_TRACE_RULE(ppendregion, TRACE_CPP_GRAMMAR);
579	#endif
580	}
581
582	// start rule of this grammar
583	rule_t const& start() const
584	{ return pp_statement; }
585	};
586
587	cpp_grammar_rule_ids &rule_ids;
588	PositionT &pos_of_newline;
589	bool &found_eof;
590	boost::wave::token_id &found_directive;
591
592	cpp_grammar(cpp_grammar_rule_ids &rule_ids_, PositionT &pos_of_newline_,
593	bool &found_eof_, boost::wave::token_id &found_directive_)
594	: rule_ids(rule_ids_), pos_of_newline(pos_of_newline_),
595	found_eof(found_eof_), found_directive(found_directive_)
596	{
597	BOOST_SPIRIT_DEBUG_TRACE_GRAMMAR_NAME(*this, "cpp_grammar",
598	TRACE_CPP_GRAMMAR);
599	}
600
601	#if BOOST_WAVE_DUMP_PARSE_TREE != 0
602	// helper function and data to get readable names of the rules known to us
603	struct map_ruleid_to_name :
604	public std::map<boost::spirit::parser_id, std::string>
605	{
606	typedef std::map<boost::spirit::parser_id, std::string> base_t;
607
608	void init_rule_id_to_name_map(cpp_grammar const &self)
609	{
610	struct {
611	int parser_id;
612	char const *rule_name;
613	}
614	init_ruleid_name_map[] = {
615	{ self.rule_ids.pp_statement_id, "pp_statement" },
616	{ self.rule_ids.include_file_id, "include_file" },
617	{ self.rule_ids.sysinclude_file_id, "system_include_file" },
618	{ self.rule_ids.macroinclude_file_id, "macro_include_file" },
619	{ self.rule_ids.plain_define_id, "plain_define" },
620	{ self.rule_ids.macro_parameters_id, "macro_parameters" },
621	{ self.rule_ids.macro_definition_id, "macro_definition" },
622	{ self.rule_ids.undefine_id, "undefine" },
623	{ self.rule_ids.ifdef_id, "ppifdef" },
624	{ self.rule_ids.ifndef_id, "ppifndef" },
625	{ self.rule_ids.if_id, "ppif" },
626	{ self.rule_ids.elif_id, "ppelif" },
627	{ self.rule_ids.else_id, "ppelse" },
628	{ self.rule_ids.endif_id, "ppendif" },
629	{ self.rule_ids.line_id, "ppline" },
630	{ self.rule_ids.error_id, "pperror" },
631	{ self.rule_ids.warning_id, "ppwarning" },
632	{ self.rule_ids.pragma_id, "pppragma" },
633	{ self.rule_ids.illformed_id, "illformed" },
634	{ self.rule_ids.ppqualifiedname_id, "ppqualifiedname" },
635	#if BOOST_WAVE_SUPPORT_MS_EXTENSIONS != 0
636	{ self.rule_ids.region_id, "ppregion" },
637	{ self.rule_ids.endregion_id, "ppendregion" },
638	#endif
639	{ 0 }
640	};
641
642	// initialize parser_id to rule_name map
643	for (int i = 0; 0 != init_ruleid_name_map[i].parser_id; ++i)
644	base_t::insert(base_t::value_type(
645	boost::spirit::parser_id(init_ruleid_name_map[i].parser_id),
646	std::string(init_ruleid_name_map[i].rule_name))
647	);
648	}
649	};
650	mutable map_ruleid_to_name map_rule_id_to_name;
651	#endif // WAVE_DUMP_PARSE_TREE != 0
652	};
653
654	///////////////////////////////////////////////////////////////////////////////
655	#undef TRACE_CPP_GRAMMAR
656
657	///////////////////////////////////////////////////////////////////////////////
658	//
659	// The following parse function is defined here, to allow the separation of
660	// the compilation of the cpp_grammar from the function using it.
661	//
662	///////////////////////////////////////////////////////////////////////////////
663
664	#if BOOST_WAVE_SEPARATE_GRAMMAR_INSTANTIATION != 0
665	#define BOOST_WAVE_GRAMMAR_GEN_INLINE
666	#else
667	#define BOOST_WAVE_GRAMMAR_GEN_INLINE inline
668	#endif
669
670	namespace {
671
672	char const *get_directivename(boost::wave::token_id id)
673	{
674	using namespace boost::wave;
675	switch (static_cast<unsigned int>(id)) {
676	case T_PP_QHEADER:
677	case T_PP_HHEADER:
678	case T_PP_INCLUDE: return "#include";
679	case T_PP_DEFINE: return "#define";
680	case T_PP_UNDEF: return "#undef";
681	case T_PP_IFDEF: return "#ifdef";
682	case T_PP_IFNDEF: return "#ifndef";
683	case T_PP_IF: return "#if";
684	case T_PP_ELSE: return "#else";
685	case T_PP_ELIF: return "#elif";
686	case T_PP_ENDIF: return "#endif";
687	case T_PP_LINE: return "#line";
688	case T_PP_ERROR: return "#error";
689	case T_PP_WARNING: return "#warning";
690	case T_PP_PRAGMA: return "#pragma";
691	default:
692	return "#unknown directive";
693	}
694	}
695	}
696
697	template <typename LexIteratorT>
698	BOOST_WAVE_GRAMMAR_GEN_INLINE
699	boost::spirit::tree_parse_info<LexIteratorT>
700	cpp_grammar_gen<LexIteratorT>::parse_cpp_grammar (
701	LexIteratorT const &first, LexIteratorT const &last,
702	bool &found_eof_, position_type const &act_pos)
703	{
704	using namespace boost::spirit;
705	using namespace boost::wave;
706
707	pos_of_newline = position_type(); // reset position
708	found_eof = false; // reset flag
709	found_directive = T_EOF; // reset found directive
710
711	cpp_grammar<position_type> g(
712	rule_ids, pos_of_newline, found_eof, found_directive);
713
714	tree_parse_info<LexIteratorT> hit = pt_parse (first, last, g);
715
716	#if BOOST_WAVE_DUMP_PARSE_TREE != 0
717	if (hit.match) {
718	tree_to_xml (BOOST_WAVE_DUMP_PARSE_TREE_OUT, hit.trees, "",
719	g.map_rule_id_to_name, &token_type::get_token_id,
720	&token_type::get_token_value);
721	}
722	#endif
723
724	if (!hit.match && found_directive != T_EOF) {
725	// recognized invalid directive
726	std::string directive = get_directivename(found_directive);
727
728	BOOST_WAVE_THROW(preprocess_exception, ill_formed_directive,
729	directive.c_str(), act_pos);
730	}
731
732	found_eof_ = found_eof;
733	return hit;
734	}
735
736	#undef BOOST_WAVE_GRAMMAR_GEN_INLINE
737
738	///////////////////////////////////////////////////////////////////////////////
739	} // namespace grammars
740	} // namespace wave
741	} // namespace boost
742
743	#endif // !defined(CPP_GRAMMAR_HPP_FEAEBC2E_2734_428B_A7CA_85E5A415E23E_INCLUDED)

Note: See TracBrowser for help on using the repository browser.

Download in other formats: