ECCE @ EIC Software
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Groups Pages
CexmcCustomFilter.hh
Go to the documentation of this file. Or view the newest version in sPHENIX GitHub for file CexmcCustomFilter.hh
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 /*
27  * =============================================================================
28  *
29  * Filename: CexmcCustomFilter.hh
30  *
31  * Description: custom filter grammar and compiler
32  *
33  * Version: 1.0
34  * Created: 17.07.2010 15:31:43
35  * Revision: none
36  * Compiler: gcc
37  *
38  * Author: Alexey Radkov (),
39  * Company: PNPI
40  *
41  * =============================================================================
42  */
43 
44 #ifndef CEXMC_CUSTOM_FILTER_HH
45 #define CEXMC_CUSTOM_FILTER_HH
46 
47 #ifdef CEXMC_USE_CUSTOM_FILTER
48 
49 #include <string>
50 #include <boost/spirit/include/qi.hpp>
51 #include <boost/spirit/include/phoenix_core.hpp>
52 #include <boost/spirit/include/phoenix_operator.hpp>
53 #include <boost/spirit/include/phoenix_function.hpp>
54 #include "CexmcAST.hh"
55 
56 
57 namespace CexmcCustomFilter
58 {
59  using namespace boost::spirit;
60  using namespace boost::spirit::qi;
61  using namespace boost::spirit::ascii;
62  using namespace boost::phoenix;
63  using namespace CexmcAST;
64  using boost::spirit::qi::rule;
65  using boost::spirit::ascii::space;
66  using boost::spirit::ascii::space_type;
67  using boost::spirit::ascii::alpha;
68  using boost::spirit::ascii::alnum;
69  using boost::spirit::unused_type;
70 
71 
72  enum Action
73  {
74  KeepTPT,
75  KeepEDT,
76  DeleteTPT,
77  DeleteEDT
78  };
79 
80 
81  struct ParseResult
82  {
83  ParseResult() : action( KeepTPT )
84  {}
85 
86  void Initialize( void )
87  {
88  action = KeepTPT;
89  expression.children.clear();
90  expression.type = Operator( Uninitialized );
91  }
92 
93  Action action;
94 
95  Subtree expression;
96  };
97 
98 
99  struct Compiler
100  {
101  template < typename A, typename B = unused_type,
102  typename C = unused_type, typename D = unused_type >
103  struct result { typedef void type; };
104 
105  void operator()( ParseResult & parseResult, Action value ) const;
106 
107  void operator()( ParseResult & parseResult, Subtree & value ) const;
108 
109  void operator()( Subtree & ast, Node & node ) const;
110 
111  void operator()( Node & self, Node & left, Node & right,
112  Operator value ) const;
113 
114  void operator()( Node & self, Node & child, Operator value ) const;
115 
116  void operator()( Node & self, Node & primary ) const;
117 
118  void operator()( Node & self, Node & child, std::string & value )
119  const;
120 
121  void operator()( Leaf & self, std::string & name ) const;
122 
123  void operator()( Leaf & self, int value, size_t index ) const;
124  };
125 
126 
127  template < typename Iterator >
128  struct Grammar : grammar< Iterator, ParseResult(), space_type >
129  {
130  Grammar();
131 
132  rule< Iterator, ParseResult(), space_type > statement;
133 
134  rule< Iterator, Action(), space_type > action;
135 
136  rule< Iterator, Subtree(), space_type > condition;
137 
138  rule< Iterator, Node(), space_type > expression;
139 
140  rule< Iterator, Node(), space_type > primary_expr;
141 
142  rule< Iterator, Node(), space_type > function1;
143 
144  rule< Iterator, std::string(), space_type > identifier;
145 
146  rule< Iterator, Leaf(), space_type > leaf_operand;
147 
148  rule< Iterator, Leaf(), space_type > constant;
149 
150  rule< Iterator, Leaf(), space_type > variable;
151 
152  rule< Iterator, Node(), space_type > or_expr;
153 
154  rule< Iterator, Node(), space_type > and_expr;
155 
156  rule< Iterator, Node(), space_type > relation;
157 
158  rule< Iterator, Node(), space_type > addition;
159 
160  rule< Iterator, Node(), space_type > multiplication;
161 
162  rule< Iterator, Node(), space_type > unary_expr;
163 
164  rule< Iterator, Operator(), space_type > unary_op;
165 
166  rule< Iterator, Operator(), space_type > mult_op;
167 
168  rule< Iterator, Operator(), space_type > add_op;
169 
170  rule< Iterator, Operator(), space_type > rel_op;
171 
172  real_parser< double, strict_real_policies< double > > strict_double;
173 
174  function< Compiler > op;
175  };
176 
177 
178  template < typename Iterator >
179  Grammar< Iterator >::Grammar() : Grammar::base_type( statement )
180  {
181  statement = action[ op( _val, _1 ) ] >>
182  *( condition[ op( _val, _1 ) ] );
183 
184  action = lit( "keep" ) >>
185  ( lit( "tpt" )[ _val = KeepTPT ] |
186  lit( "edt" )[ _val = KeepEDT ] ) |
187  lit( "delete" ) >>
188  ( lit( "tpt" )[ _val = DeleteTPT ] |
189  lit( "edt" )[ _val = DeleteEDT ] );
190 
191  condition = lit( "if" ) >> expression[ op( _val, _1 ) ];
192 
193  expression %= or_expr;
194 
195  identifier %= raw[ lexeme[ alpha >> *( alnum | '_' ) ] ];
196 
197  primary_expr = function1[ _val = _1 ] |
198  lit( '(' ) >> expression[ op( _val, _1 ) ] >> lit( ')' ) |
199  leaf_operand[ _val = _1 ];
200 
201  leaf_operand %= constant | variable;
202 
203  constant %= strict_double | int_;
204 
205  variable = identifier[ op( _val, _1 ) ] >>
206  -( lit( '[' ) >> ( uint_[ op( _val, _1, 0 ) ] - lit( '0' ) ) >>
207  -( lit( ',' ) >> ( uint_[ op( _val, _1, 1 ) ] -
208  lit( '0' ) ) ) >> lit( ']' ) );
209 
210  function1 = ( identifier >> lit( '(' ) >> expression >> lit( ')' ) )
211  [ op( _val, _2, _1 ) ];
212 
213  or_expr = ( and_expr >> lit( '|' ) >> or_expr )
214  [ op( _val, _1, _2, Operator( Or, 1 ) ) ] |
215  and_expr[ _val = _1 ];
216 
217  and_expr = ( relation >> lit( '&' ) >> and_expr )
218  [ op( _val, _1, _2, Operator( And, 2 ) ) ] |
219  relation[ _val = _1 ];
220 
221  relation = ( addition >> rel_op >> addition )
222  [ op( _val, _1, _3, _2 ) ] |
223  addition[ _val = _1 ];
224 
225  addition = ( multiplication >> add_op >> addition )
226  [ op( _val, _1, _3, _2 ) ] |
227  multiplication[ _val = _1 ];
228 
229  multiplication = ( unary_expr >> mult_op >> multiplication )
230  [ op( _val, _1, _3, _2 ) ] |
231  unary_expr[ _val = _1 ];
232 
233  unary_expr = ( unary_op >> primary_expr )[ op( _val, _2, _1 ) ] |
234  primary_expr[ _val = _1 ];
235 
236  unary_op = lit( '-' )[ _val = Operator( UMinus, 6, true ) ] |
237  lit( '!' )[ _val = Operator( Not, 6, true ) ];
238 
239  mult_op = lit( '*' )[ _val = Operator( Mult, 5 ) ] |
240  lit( '/' )[ _val = Operator( Div, 5 ) ];
241 
242  add_op = lit( '+' )[ _val = Operator( Plus, 4 ) ] |
243  lit( '-' )[ _val = Operator( Minus, 4 ) ];
244 
245  rel_op = lit( "<=" )[ _val = Operator( LessEq, 3 ) ] |
246  lit( ">=" )[ _val = Operator( MoreEq, 3 ) ] |
247  lit( "!=" )[ _val = Operator( NotEq, 3 ) ] |
248  lit( '<' )[ _val = Operator( Less, 3 ) ] |
249  lit( '>' )[ _val = Operator( More, 3 ) ] |
250  lit( '=' )[ _val = Operator( Eq, 3 ) ];
251  }
252 }
253 
254 #endif
255 
256 #endif
257