The Gaudi Framework master (9cc87df9)
Loading...
Searching...
No Matches
Parser.cpp
Go to the documentation of this file.
1/***********************************************************************************\
2* (c) Copyright 1998-2026 CERN for the benefit of the LHCb and ATLAS collaborations *
3* *
4* This software is distributed under the terms of the Apache version 2 licence, *
5* copied verbatim in the file "LICENSE". *
6* *
7* In applying this licence, CERN does not waive the privileges and immunities *
8* granted to it by virtue of its status as an Intergovernmental Organization *
9* or submit itself to any jurisdiction. *
10\***********************************************************************************/
11
12// Local includes
13#include "Parser.h"
14#include "IncludedFiles.h"
15#include "Iterator.h"
16#include "Messages.h"
17#include "Node.h"
18#include "Utils.h"
19
20// Framework includes
22
23// Boost includes
24#include <boost/phoenix/core.hpp>
25#include <boost/phoenix/fusion.hpp>
26#include <boost/phoenix/operator.hpp>
27#include <boost/phoenix/stl.hpp>
28#if ( BOOST_VERSION >= 187000 ) && ( BOOST_VERSION < 188000 )
29# define BOOST_ALLOW_DEPRECATED_HEADERS
30#endif
31#include <boost/spirit/include/qi.hpp>
32#undef BOOST_ALLOW_DEPRECATED_HEADERS
33#include <boost/spirit/repository/include/qi_confix.hpp>
34#include <boost/spirit/repository/include/qi_iter_pos.hpp>
35
36// STL includes
37#include <boost/filesystem.hpp>
38#include <format>
39#include <fstream>
40#include <sstream>
41#include <string>
42
43namespace Gaudi {
44 namespace Parsers {
45 namespace sp = boost::spirit;
46 namespace ph = boost::phoenix;
47 namespace qi = sp::qi;
48 namespace enc = sp::ascii;
49 namespace rep = sp::repository;
50
51 template <typename Iterator>
52 struct SkipperGrammar : qi::grammar<Iterator> {
54 comments = enc::space | rep::confix( "/*", "*/" )[*( qi::char_ - "*/" )] |
55 rep::confix( "//", ( sp::eol | sp::eoi ) )[*( qi::char_ - ( sp::eol | sp::eoi ) )];
56 }
57 qi::rule<Iterator> comments;
58 };
59
60 template <typename Iterator, typename Skipper>
61 struct StringGrammar : qi::grammar<Iterator, std::string(), qi::locals<char>, Skipper> {
62 using ResultT = std::string;
63 StringGrammar() : StringGrammar::base_type( str ) {
64 begin_quote = enc::char_( "\"'" );
65 quote = enc::char_( qi::_r1 );
66
67 str = qi::lexeme[begin_quote[qi::_a = qi::_1] >>
68 *( ( enc::char_( '\\' ) >> quote( qi::_a ) )[qi::_val += qi::_a] |
69 ( enc::char_[qi::_val += qi::_1] - quote( qi::_a ) ) ) >>
70 quote( qi::_a )];
71 }
72 qi::rule<Iterator, std::string(), qi::locals<char>, Skipper> str;
73 qi::rule<Iterator, char()> begin_quote;
74 qi::rule<Iterator, void( char )> quote;
75 };
76 template <typename Iterator, typename Skipper>
77 struct IdentifierGrammar : qi::grammar<Iterator, Node(), Skipper> {
78 using ResultT = std::string;
80 ident =
81 rep::qi::iter_pos[op( qi::_val, qi::_1 )] >> str[op( qi::_val, qi::_1 )][op( qi::_val, Node::kIdentifier )];
82 str = -qi::lit( "::" )[qi::_val += "::"] >> inner[qi::_val += qi::_1] >>
83 *( qi::lit( "::" ) >> inner[qi::_val += ( "::" + qi::_1 )] );
84 inner = qi::alpha >> *( qi::alnum | qi::char_( '_' ) );
85 }
86 qi::rule<Iterator, Node(), Skipper> ident;
89 ph::function<NodeOperations> op;
90 };
91 template <typename Iterator, typename Skipper>
92 struct BoolGrammar : qi::grammar<Iterator, bool(), Skipper> {
93 using ResultT = bool;
94 BoolGrammar() : BoolGrammar::base_type( boolean ) {
95 boolean = enc::no_case[qi::lit( "true" )[qi::_val = true] | qi::lit( "false" )[qi::_val = false]];
96 }
97 qi::rule<Iterator, bool(), Skipper> boolean;
98 };
99 template <typename Iterator, typename Skipper>
100 struct RealGrammar : qi::grammar<Iterator, Node(), Skipper> {
101 using ResultT = bool;
102 RealGrammar() : RealGrammar::base_type( real ) {
103 real = qi::raw[qi::double_][op( qi::_val, qi::_1 )][op( qi::_val, Node::kReal )] >> -qi::char_( 'L' ) >>
104 -( -qi::char_( '*' ) >> gunit[op( qi::_val, qi::_1 )] );
105 }
106 qi::rule<Iterator, Node(), Skipper> real;
108 ph::function<NodeOperations> op;
109 };
110 template <typename Iterator, typename Skipper>
111 struct UnitsGrammar : qi::grammar<Iterator, Node(), Skipper> {
112 UnitsGrammar() : UnitsGrammar::base_type( units ) {
113 units = *unit[op( qi::_val, qi::_1 )];
114 unit = rep::qi::iter_pos[op( qi::_val, qi::_1 )] >> val[op( qi::_val, qi::_1 )] >> -qi::lit( '*' ) >>
115 gunit[op( qi::_val, qi::_1 )] >> qi::lit( '=' ) >>
116 val[op( qi::_val, qi::_1 )][op( qi::_val, Node::kUnit )];
117 ;
118 val = qi::raw[qi::double_][op( qi::_val, qi::_1 )][op( qi::_val, Node::kReal )];
119 }
122 ph::function<NodeOperations> op;
123 };
124 template <typename Iterator, typename Skipper>
125 struct FileGrammar : qi::grammar<Iterator, Node(), Skipper> {
126 FileGrammar() : FileGrammar::base_type( file ) {
127 file = -shell[op( qi::_val, qi::_1 )] >> *( statement[op( qi::_val, qi::_1 )] )[op( qi::_val, Node::kRoot )];
128 shell = rep::confix(
129 "#!",
130 qi::eol )[*( qi::char_[qi::_a += qi::_1] - qi::eol )][op( qi::_val, Node::kShell )][op( qi::_val, qi::_a )];
131 statement = rep::qi::iter_pos[qi::_a = qi::_1] >> ( include | assign | units | print_options | pragma |
132 condition )[qi::_val = qi::_1][op( qi::_val, qi::_a )];
133 condition =
134 ( qi::lit( "#ifdef" )[op( qi::_a, Node::kIfdef )] | qi::lit( "#ifndef" )[op( qi::_a, Node::kIfndef )] ) >>
135 property[op( qi::_val, qi::_1 )] >> ( *statement[op( qi::_a, qi::_1 )] )[op( qi::_val, qi::_a )] >>
136 -( qi::lit( "#else" )[op( qi::_b, Node::kElse )] >>
137 *statement[op( qi::_b, qi::_1 )] )[op( qi::_val, qi::_b )] >>
138 qi::lit( "#endif" )[op( qi::_val, Node::kCondition )];
139 include = qi::lit( "#include" ) >> gstring[op( qi::_val, qi::_1 )][op( qi::_val, Node::kInclude )];
140 units = qi::lit( "#units" ) >> gstring[op( qi::_val, qi::_1 )][op( qi::_val, Node::kUnits )];
141 print_options = qi::lit( "#printOptions" ) >> qi::lit( "full" )[op( qi::_val, Node::kPrintOptions )];
142 pragma = qi::lit( "#pragma" ) >> ( pragma_print | pragma_tree | pragma_dump_file );
143 pragma_print = qi::lit( "print" ) >> enc::no_case[qi::lit( "on" )[op( qi::_val, Node::kPrintOn )] |
144 qi::lit( "off" )[op( qi::_val, Node::kPrintOff )]];
145 pragma_tree = enc::no_case[qi::lit( "printtree" )[op( qi::_val, Node::kPrintTree )]];
146 pragma_dump_file = qi::lit( "dumpfile" ) >> gstring[op( qi::_val, qi::_1 )][op( qi::_val, Node::kDumpFile )];
147 assign = property[op( qi::_val, qi::_1 )][op( qi::_val, Node::kAssign )] >> oper[op( qi::_val, qi::_1 )] >>
148 value[op( qi::_val, qi::_1 )] >> ';';
149 property = rep::qi::iter_pos[op( qi::_val, qi::_1 )] >>
150 ( gidentifier[op( qi::_val, qi::_1 )] % '.' )[op( qi::_val, Node::kProperty )];
151 property_ref %= -qi::lit( '@' ) >> property[op( qi::_val, Node::kPropertyRef )];
152 oper = rep::qi::iter_pos[op( qi::_val, qi::_1 )] >>
153 ( qi::lit( "=" )[op( qi::_val, Node::kEqual )] | qi::lit( "+=" )[op( qi::_val, Node::kPlusEqual )] |
154 qi::lit( "-=" )[op( qi::_val, Node::kMinusEqual )] );
155 value = rep::qi::iter_pos[qi::_a = qi::_1] >> ( map_value | vector_value | simple_value | property |
156 property_ref )[qi::_val = qi::_1][op( qi::_val, qi::_a )];
158 enc::char_( '(' )[qi::_val = ')'] | enc::char_( '[' )[qi::_val = ']'] | enc::char_( '{' )[qi::_val = '}'];
159 end_vector = qi::char_( qi::_r1 );
160 vector_value = ( begin_vector[qi::_a = qi::_1] >> -( value[op( qi::_val, qi::_1 )] % ',' ) >>
161 end_vector( qi::_a ) )[op( qi::_val, Node::kVector )];
162 map_value = ( enc::char_( '{' ) >> -( pair[op( qi::_val, qi::_1 )] % ',' ) >>
163 enc::char_( '}' ) )[op( qi::_val, Node::kMap )];
164 pair =
165 simple_value[op( qi::_val, qi::_1 )] >> ':' >> value[op( qi::_val, qi::_1 )][op( qi::_val, Node::kPair )];
166 simple_value = ( gstring[op( qi::_val, qi::_1 )][op( qi::_val, Node::kString )] ) |
167 ( gbool[op( qi::_val, qi::_1 )][op( qi::_val, Node::kBool )] ) | ( greal[qi::_val = qi::_1] );
168 }
171 qi::rule<Iterator, Node(), qi::locals<std::string>> shell;
172 qi::rule<Iterator, Node(), qi::locals<Iterator>, Skipper> statement, value;
173 qi::rule<Iterator, Node(), qi::locals<char>, Skipper> vector_value;
174 qi::rule<Iterator, Node(), qi::locals<Node, Node>, Skipper> condition;
175 qi::rule<Iterator, char()> begin_vector;
176 qi::rule<Iterator, void( char )> end_vector;
181 ph::function<NodeOperations> op;
182 };
183 } // namespace Parsers
184} // namespace Gaudi
185
186namespace bf = boost::filesystem;
187namespace gp = Gaudi::Parsers;
188namespace gpu = Gaudi::Parsers::Utils;
189namespace qi = boost::spirit::qi;
190
191namespace {
192 // Return last line and column number of text in `s` with newline delimiter `delim`
193 std::pair<int, int> GetLastLineAndColumn( std::string_view s, const char delim = '\n' ) {
194 size_t line = 1;
195 for ( size_t p = s.find( delim ); p != s.npos; p = s.find( delim ) ) {
196 s.remove_prefix( p + 1 );
197 ++line;
198 }
199 return { line, s.size() + 1 };
200 }
201
202 template <typename Grammar>
203 bool ParseStream( std::ifstream& stream, const std::string& stream_name, gp::Messages* messages, gp::Node* root ) {
204 // Load input stream
205 const std::string input = ( std::ostringstream{} << stream.rdbuf() ).str();
206
207 auto [last_line, last_column] = GetLastLineAndColumn( input );
208
209 BaseIterator in_begin( input.begin() );
210 // convert input iterator to forward iterator, usable by spirit parser
211 ForwardIterator fwd_begin = boost::spirit::make_default_multi_pass( in_begin );
212 ForwardIterator fwd_end;
213
214 // wrap forward iterator with position iterator, to record the position
215 Iterator position_begin( fwd_begin, fwd_end, stream_name );
216 Iterator position_end;
217
218 Grammar gr;
219 gp::SkipperGrammar<Iterator> skipper;
220
221 root->value = stream_name;
222 bool result = qi::phrase_parse( position_begin, position_end, gr, skipper, *root );
223
224 const IteratorPosition& pos = position_begin.get_position();
225 if ( result && ( pos.line == last_line ) && ( pos.column == last_column ) ) { return true; }
226
227 messages->AddError( gp::Position( stream_name, pos.line, pos.column ), "parse error" );
228 return false;
229 }
230
231 template <typename Grammar>
232 bool ParseFile( const gp::Position& from, std::string_view filename, std::string_view search_path,
233 gp::IncludedFiles* included, gp::Messages* messages, gp::Node* root ) {
234 std::string search_path_with_current_dir = gpu::replaceEnvironments( search_path );
235 if ( !from.filename().empty() ) { // Add current file directory to search_path
236 bf::path file_path( from.filename() );
237 search_path_with_current_dir =
238 file_path.parent_path().string() +
239 ( search_path_with_current_dir.empty() ? "" : ( "," + search_path_with_current_dir ) );
240 }
241 std::string absolute_path =
242 System::PathResolver::find_file_from_list( gpu::replaceEnvironments( filename ), search_path_with_current_dir );
243
244 if ( absolute_path.empty() ) {
245 messages->AddError( from, "Couldn't find a file " + std::string{ filename } + " in search path '" +
246 search_path_with_current_dir + "'" );
247 return false;
248 }
249 const gp::Position* included_from;
250 if ( !included->GetPosition( absolute_path, &included_from ) ) {
251 included->AddFile( absolute_path, from );
252 std::ifstream file{ absolute_path };
253 if ( !file.is_open() ) {
254 messages->AddError( from, std::string{ "Couldn't open a file " }.append( filename ) );
255 return false;
256 }
257 return ParseStream<Grammar>( file, absolute_path, messages, root );
258 } else {
259 assert( included_from != nullptr );
260 messages->AddWarning(
261 from, std::format( "File {} already included from {}", absolute_path, included_from->ToString() ) );
262 return true;
263 }
264 }
265} // namespace
266
267bool gp::Parse( std::string_view filename, std::string_view search_path, IncludedFiles* included, Messages* messages,
268 Node* root ) {
269 return Parse( Position(), filename, search_path, included, messages, root );
270}
271
272bool gp::Parse( const Position& from, std::string_view filename, std::string_view search_path, IncludedFiles* included,
273 Messages* messages, Node* root ) {
275 return ParseFile<Grammar>( from, filename, search_path, included, messages, root );
276}
277
278bool gp::ParseUnits( const Position& from, std::string_view filename, std::string_view search_path,
279 IncludedFiles* included, Messages* messages, Node* root ) {
281 return ParseFile<Grammar>( from, filename, search_path, included, messages, root );
282}
boost::spirit::multi_pass< BaseIterator > ForwardIterator
Definition Iterator.h:17
boost::spirit::classic::position_iterator2< ForwardIterator > Iterator
Definition Iterator.h:18
boost::spirit::classic::file_position_base< std::string > IteratorPosition
Definition Iterator.h:19
std::string::const_iterator BaseIterator
Definition Iterator.h:16
basic_ifstream< char > ifstream
basic_ostringstream< char > ostringstream
basic_string< char > string
iterator begin()
basic_string & append(_InputIterator __first, _InputIterator __last)
bool empty() const noexcept
bool GetPosition(std::string_view filename, const Position **pos) const
bool AddFile(std::string filename, Position from)
void AddError(std::string_view error)
Definition Messages.h:28
void AddWarning(std::string_view warning)
Definition Messages.h:26
std::string ToString() const
Definition Position.cpp:14
const std::string & filename() const
Definition Position.h:22
static std::string find_file_from_list(const std::string &logical_file_name, const std::string &search_list, SearchType search_type=LocalSearch)
std::string replaceEnvironments(std::string_view input)
Definition Utils.cpp:17
bool ParseUnits(const Position &from, std::string_view filename, std::string_view search_path, IncludedFiles *included, Messages *messages, Node *root)
Definition Parser.cpp:278
bool Parse(std::string_view filename, std::string_view search_path, IncludedFiles *included, Messages *messages, Node *root)
Definition Parser.cpp:267
SkipperGrammar< IteratorT > Skipper
Definition Factory.h:20
This file provides a Grammar for the type Gaudi::Accumulators::Axis It allows to use that type from p...
Definition __init__.py:1
stream
Definition Write.py:32
qi::rule< Iterator, bool(), Skipper > boolean
Definition Parser.cpp:97
qi::rule< Iterator, Node(), Skipper > pragma_tree
Definition Parser.cpp:170
qi::rule< Iterator, Node(), qi::locals< Node, Node >, Skipper > condition
Definition Parser.cpp:174
qi::rule< Iterator, Node(), qi::locals< char >, Skipper > vector_value
Definition Parser.cpp:173
qi::rule< Iterator, Node(), Skipper > oper
Definition Parser.cpp:169
qi::rule< Iterator, Node(), Skipper > include
Definition Parser.cpp:169
qi::rule< Iterator, Node(), qi::locals< Iterator >, Skipper > value
Definition Parser.cpp:172
qi::rule< Iterator, Node(), qi::locals< Iterator >, Skipper > statement
Definition Parser.cpp:172
qi::rule< Iterator, Node(), Skipper > print_options
Definition Parser.cpp:170
qi::rule< Iterator, Node(), Skipper > file
Definition Parser.cpp:169
qi::rule< Iterator, Node(), Skipper > pair_value
Definition Parser.cpp:169
qi::rule< Iterator, void(char)> end_vector
Definition Parser.cpp:176
RealGrammar< Iterator, Skipper > greal
Definition Parser.cpp:179
ph::function< NodeOperations > op
Definition Parser.cpp:181
qi::rule< Iterator, Node(), Skipper > property_ref
Definition Parser.cpp:169
qi::rule< Iterator, char()> begin_vector
Definition Parser.cpp:175
qi::rule< Iterator, Node(), qi::locals< std::string > > shell
Definition Parser.cpp:171
BoolGrammar< Iterator, Skipper > gbool
Definition Parser.cpp:178
qi::rule< Iterator, Node(), Skipper > assign
Definition Parser.cpp:169
qi::rule< Iterator, Node(), Skipper > pragma
Definition Parser.cpp:170
qi::rule< Iterator, Node(), Skipper > simple_value
Definition Parser.cpp:170
qi::rule< Iterator, Node(), Skipper > property
Definition Parser.cpp:169
qi::rule< Iterator, Node(), Skipper > map_value
Definition Parser.cpp:169
StringGrammar< Iterator, Skipper > gstring
Definition Parser.cpp:177
qi::rule< Iterator, Node(), Skipper > pragma_dump_file
Definition Parser.cpp:170
qi::rule< Iterator, Node(), Skipper > units
Definition Parser.cpp:170
qi::rule< Iterator, Node(), Skipper > pragma_print
Definition Parser.cpp:170
qi::rule< Iterator, Node(), Skipper > pair
Definition Parser.cpp:170
IdentifierGrammar< Iterator, Skipper > gidentifier
Definition Parser.cpp:180
qi::rule< Iterator, std::string()> inner
Definition Parser.cpp:88
qi::rule< Iterator, Node(), Skipper > ident
Definition Parser.cpp:86
qi::rule< Iterator, std::string(), Skipper > str
Definition Parser.cpp:87
ph::function< NodeOperations > op
Definition Parser.cpp:89
IdentifierGrammar< Iterator, T > gunit
Definition Parser.cpp:107
qi::rule< Iterator, void(char)> quote
Definition Parser.cpp:74
qi::rule< Iterator, char()> begin_quote
Definition Parser.cpp:73
qi::rule< Iterator, std::string(), qi::locals< char >, Skipper > str
Definition Parser.cpp:72
ph::function< NodeOperations > op
Definition Parser.cpp:122
qi::rule< Iterator, Node(), Skipper > units
Definition Parser.cpp:120
qi::rule< Iterator, Node(), Skipper > val
Definition Parser.cpp:120
qi::rule< Iterator, Node(), Skipper > unit
Definition Parser.cpp:120
IdentifierGrammar< Iterator, Skipper > gunit
Definition Parser.cpp:121