Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
•All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros
Evaluator.cc
Go to the documentation of this file.
1// -*- C++ -*-
2// $Id:$
3// ---------------------------------------------------------------------------
4
5#include "CLHEP/Evaluator/Evaluator.h"
6
7#include <iostream>
8#include <sstream>
9#include <cmath> // for std::pow()
10#include "CLHEP/Evaluator/stack.icc"
11#include "CLHEP/Evaluator/string.icc"
12#include "CLHEP/Evaluator/hash_map.icc"
13#include <string.h>
14#include <ctype.h>
15#include <errno.h>
16#include <stdlib.h> // for strtod()
17
18//---------------------------------------------------------------------------
19// Fix non ISO C++ compliant cast from pointer to function
20// to void*, which is a pointer to an object
21typedef void (*voidfuncptr)();
22struct Item {
23 enum { UNKNOWN, VARIABLE, EXPRESSION, FUNCTION } what;
24 double variable;
25 string expression;
26 // Fix non ISO C++ compliant cast from pointer to function
27 // to void*, which is a pointer to an object
28 //void *function;
29 voidfuncptr function;
30
31 Item() : what(UNKNOWN), variable(0),expression(), function(0) {}
32 Item(double x) : what(VARIABLE), variable(x),expression(), function(0) {}
33 Item(string x) : what(EXPRESSION),variable(0),expression(x),function(0) {}
34 Item(voidfuncptr x) : what(FUNCTION), variable(0),expression(), function(x) {}
35};
36
37typedef char * pchar;
38typedef hash_map<string,Item> dic_type;
39
40struct Struct {
41 dic_type theDictionary;
42 pchar theExpression;
43 pchar thePosition;
44 int theStatus;
45 double theResult;
46};
47
48//---------------------------------------------------------------------------
49#define EVAL HepTool::Evaluator
50
51#define REMOVE_BLANKS \
52for(pointer=name;;pointer++) if (!isspace(*pointer)) break; \
53for(n=strlen(pointer);n>0;n--) if (!isspace(*(pointer+n-1))) break
54
55#define SKIP_BLANKS \
56for(;;pointer++) { \
57 c = (pointer > end) ? '\0' : *pointer; \
58 if (!isspace(c)) break; \
59}
60
61#define EVAL_EXIT(STATUS,POSITION) endp = POSITION; return STATUS
62#define MAX_N_PAR 5
63
64static const char sss[MAX_N_PAR+2] = "012345";
65
66enum { ENDL, LBRA, OR, AND, EQ, NE, GE, GT, LE, LT,
67 PLUS, MINUS, UNARY_PLUS, UNARY_MINUS, MULT, DIV, POW, RBRA, VALUE };
68
69static int engine(pchar, pchar, double &, pchar &, const dic_type &);
70
71static int variable(const string & name, double & result,
72 const dic_type & dictionary)
73/***********************************************************************
74 * *
75 * Name: variable Date: 03.10.00 *
76 * Author: Evgeni Chernyaev Revised: *
77 * *
78 * Function: Finds value of the variable. *
79 * This function is used by operand(). *
80 * *
81 * Parameters: *
82 * name - name of the variable. *
83 * result - value of the variable. *
84 * dictionary - dictionary of available variables and functions. *
85 * *
86 ***********************************************************************/
87{
88 dic_type::const_iterator iter = dictionary.find(name);
89 if (iter == dictionary.end())
90 return EVAL::ERROR_UNKNOWN_VARIABLE;
91 Item item = iter->second;
92 switch (item.what) {
93 case Item::VARIABLE:
94 result = item.variable;
95 return EVAL::OK;
96 case Item::EXPRESSION: {
97 pchar exp_begin = (char *)(item.expression.c_str());
98 pchar exp_end = exp_begin + strlen(exp_begin) - 1;
99 if (engine(exp_begin, exp_end, result, exp_end, dictionary) == EVAL::OK)
100 return EVAL::OK;
101 }
102 default:
103 return EVAL::ERROR_CALCULATION_ERROR;
104 }
105}
106
107static int function(const string & name, stack<double> & par,
108 double & result, const dic_type & dictionary)
109/***********************************************************************
110 * *
111 * Name: function Date: 03.10.00 *
112 * Author: Evgeni Chernyaev Revised: *
113 * *
114 * Function: Finds value of the function. *
115 * This function is used by operand(). *
116 * *
117 * Parameters: *
118 * name - name of the function. *
119 * par - stack of parameters. *
120 * result - value of the function. *
121 * dictionary - dictionary of available variables and functions. *
122 * *
123 ***********************************************************************/
124{
125 int npar = par.size();
126 if (npar > MAX_N_PAR) return EVAL::ERROR_UNKNOWN_FUNCTION;
127
128 dic_type::const_iterator iter = dictionary.find(sss[npar]+name);
129 if (iter == dictionary.end()) return EVAL::ERROR_UNKNOWN_FUNCTION;
130 Item item = iter->second;
131
132 double pp[MAX_N_PAR];
133 for(int i=0; i<npar; i++) { pp[i] = par.top(); par.pop(); }
134 errno = 0;
135 if (item.function == 0) return EVAL::ERROR_CALCULATION_ERROR;
136 switch (npar) {
137 case 0:
138 result = ((double (*)())item.function)();
139 break;
140 case 1:
141 result = ((double (*)(double))item.function)(pp[0]);
142 break;
143 case 2:
144 result = ((double (*)(double,double))item.function)(pp[1], pp[0]);
145 break;
146 case 3:
147 result = ((double (*)(double,double,double))item.function)
148 (pp[2],pp[1],pp[0]);
149 break;
150 case 4:
151 result = ((double (*)(double,double,double,double))item.function)
152 (pp[3],pp[2],pp[1],pp[0]);
153 break;
154 case 5:
155 result = ((double (*)(double,double,double,double,double))item.function)
156 (pp[4],pp[3],pp[2],pp[1],pp[0]);
157 break;
158 }
159 return (errno == 0) ? EVAL::OK : EVAL::ERROR_CALCULATION_ERROR;
160}
161
162static int operand(pchar begin, pchar end, double & result,
163 pchar & endp, const dic_type & dictionary)
164/***********************************************************************
165 * *
166 * Name: operand Date: 03.10.00 *
167 * Author: Evgeni Chernyaev Revised: *
168 * *
169 * Function: Finds value of the operand. The operand can be either *
170 * a number or a variable or a function. *
171 * This function is used by engine(). *
172 * *
173 * Parameters: *
174 * begin - pointer to the first character of the operand. *
175 * end - pointer to the last character of the character string. *
176 * result - value of the operand. *
177 * endp - pointer to the character where the evaluation stoped. *
178 * dictionary - dictionary of available variables and functions. *
179 * *
180 ***********************************************************************/
181{
182 pchar pointer = begin;
183 int EVAL_STATUS;
184 char c;
185
186 // G E T N U M B E R
187
188 if (!isalpha(*pointer)) {
189 errno = 0;
190 result = strtod(pointer, (char **)(&pointer));
191 if (errno == 0) {
192 EVAL_EXIT( EVAL::OK, --pointer );
193 }else{
194 EVAL_EXIT( EVAL::ERROR_CALCULATION_ERROR, begin );
195 }
196 }
197
198 // G E T N A M E
199
200 while(pointer <= end) {
201 c = *pointer;
202 if (c != '_' && !isalnum(c)) break;
203 pointer++;
204 }
205 c = *pointer;
206 *pointer = '\0';
207 string name(begin);
208 *pointer = c;
209
210 // G E T V A R I A B L E
211
212 result = 0.0;
213 SKIP_BLANKS;
214 if (c != '(') {
215 EVAL_STATUS = variable(name, result, dictionary);
216 EVAL_EXIT( EVAL_STATUS, (EVAL_STATUS == EVAL::OK) ? --pointer : begin);
217 }
218
219 // G E T F U N C T I O N
220
221 stack<pchar> pos; // position stack
222 stack<double> par; // parameter stack
223 double value;
224 pchar par_begin = pointer+1, par_end;
225
226 for(;;pointer++) {
227 c = (pointer > end) ? '\0' : *pointer;
228 switch (c) {
229 case '\0':
230 EVAL_EXIT( EVAL::ERROR_UNPAIRED_PARENTHESIS, pos.top() );
231 case '(':
232 pos.push(pointer); break;
233 case ',':
234 if (pos.size() == 1) {
235 par_end = pointer-1;
236 EVAL_STATUS = engine(par_begin, par_end, value, par_end, dictionary);
237 if (EVAL_STATUS == EVAL::WARNING_BLANK_STRING)
238 { EVAL_EXIT( EVAL::ERROR_EMPTY_PARAMETER, --par_end ); }
239 if (EVAL_STATUS != EVAL::OK)
240 { EVAL_EXIT( EVAL_STATUS, par_end ); }
241 par.push(value);
242 par_begin = pointer + 1;
243 }
244 break;
245 case ')':
246 if (pos.size() > 1) {
247 pos.pop();
248 break;
249 }else{
250 par_end = pointer-1;
251 EVAL_STATUS = engine(par_begin, par_end, value, par_end, dictionary);
252 switch (EVAL_STATUS) {
253 case EVAL::OK:
254 par.push(value);
255 break;
256 case EVAL::WARNING_BLANK_STRING:
257 if (par.size() != 0)
258 { EVAL_EXIT( EVAL::ERROR_EMPTY_PARAMETER, --par_end ); }
259 break;
260 default:
261 EVAL_EXIT( EVAL_STATUS, par_end );
262 }
263 EVAL_STATUS = function(name, par, result, dictionary);
264 EVAL_EXIT( EVAL_STATUS, (EVAL_STATUS == EVAL::OK) ? pointer : begin);
265 }
266 }
267 }
268}
269
270/***********************************************************************
271 * *
272 * Name: maker Date: 28.09.00 *
273 * Author: Evgeni Chernyaev Revised: *
274 * *
275 * Function: Executes basic arithmetic operations on values in the top *
276 * of the stack. Result is placed back into the stack. *
277 * This function is used by engine(). *
278 * *
279 * Parameters: *
280 * op - code of the operation. *
281 * val - stack of values. *
282 * *
283 ***********************************************************************/
284static int maker(int op, stack<double> & val)
285{
286 if (val.size() < 2) return EVAL::ERROR_SYNTAX_ERROR;
287 double val2 = val.top(); val.pop();
288 double val1 = val.top();
289 switch (op) {
290 case OR: // operator ||
291 val.top() = (val1 || val2) ? 1. : 0.;
292 return EVAL::OK;
293 case AND: // operator &&
294 val.top() = (val1 && val2) ? 1. : 0.;
295 return EVAL::OK;
296 case EQ: // operator ==
297 val.top() = (val1 == val2) ? 1. : 0.;
298 return EVAL::OK;
299 case NE: // operator !=
300 val.top() = (val1 != val2) ? 1. : 0.;
301 return EVAL::OK;
302 case GE: // operator >=
303 val.top() = (val1 >= val2) ? 1. : 0.;
304 return EVAL::OK;
305 case GT: // operator >
306 val.top() = (val1 > val2) ? 1. : 0.;
307 return EVAL::OK;
308 case LE: // operator <=
309 val.top() = (val1 <= val2) ? 1. : 0.;
310 return EVAL::OK;
311 case LT: // operator <
312 val.top() = (val1 < val2) ? 1. : 0.;
313 return EVAL::OK;
314 case PLUS: // operator '+'
315 val.top() = val1 + val2;
316 return EVAL::OK;
317 case MINUS: // operator '-'
318 val.top() = val1 - val2;
319 return EVAL::OK;
320 case MULT: // operator '*'
321 val.top() = val1 * val2;
322 return EVAL::OK;
323 case DIV: // operator '/'
324 if (val2 == 0.0) return EVAL::ERROR_CALCULATION_ERROR;
325 val.top() = val1 / val2;
326 return EVAL::OK;
327 case POW: // operator '^' (or '**')
328 errno = 0;
329 val.top() = std::pow(val1,val2);
330 if (errno == 0) return EVAL::OK;
331 case UNARY_PLUS: // unary operator '+'
332 val.top() = val1 + val2; // val1 is zero
333 return EVAL::OK;
334 case UNARY_MINUS: // unary operator '-'
335 val.top() = val1 - val2; // val1 is zero
336 return EVAL::OK;
337 default:
338 return EVAL::ERROR_CALCULATION_ERROR;
339 }
340}
341
342/***********************************************************************
343 * *
344 * Name: engine Date: 28.09.00 *
345 * Author: Evgeni Chernyaev Revised: *
346 * *
347 * Function: Evaluates arithmetic expression. *
348 * *
349 * Parameters: *
350 * begin - pointer to the character string with expression. *
351 * end - pointer to the end of the character string (it is needed *
352 * for recursive call of engine(), when there is no '\0'). *
353 * result - result of the evaluation. *
354 * endp - pointer to the character where the evaluation stoped. *
355 * dictionary - dictionary of available variables and functions. *
356 * *
357 ***********************************************************************/
358static int engine(pchar begin, pchar end, double & result,
359 pchar & endp, const dic_type & dictionary)
360{
361 enum SyntaxTableEntry {
362 SyntaxError = 0,
363 NumberVariableOrFunction = 1,
364 UnaryPlusOrMinus = 2,
365 AnyOperator = 3
366 };
367 static const int SyntaxTable[19][19] = {
368 //E ( || && == != >= > <= < + - u+ u- * / ^ ) V - current token
369 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // E - previous
370 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // ( token
371 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // ||
372 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // &&
373 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // ==
374 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // !=
375 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // >=
376 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // >
377 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // <=
378 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // <
379 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // +
380 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // -
381 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // unary +
382 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // unary -
383 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // *
384 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // /
385 { 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 1 }, // ^
386 { 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0 }, // )
387 { 3, 0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 0 } // V = {.,N,C}
388 };
389 enum ActionTableEntry {
390 UnbalancedParentheses = -1,
391 ExpressionCompleted = 0,
392 HigherPrecedenceOperator = 1,
393 SamePrecedenceOperator = 2,
394 CloseProcessedParenthesesOrExpression = 3,
395 LowerPrecedenceOperator = 4
396 };
397 static const int ActionTable[17][18] = {
398 //E ( || && == != >= > <= < + - u+ u- * / ^ ) - current operator
399 { 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,-1 }, // E - top operator
400 {-1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3 }, // ( in stack
401 { 4, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 }, // ||
402 { 4, 1, 4, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 }, // &&
403 { 4, 1, 4, 4, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 }, // ==
404 { 4, 1, 4, 4, 2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 4 }, // !=
405 { 4, 1, 4, 4, 4, 4, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 4 }, // >=
406 { 4, 1, 4, 4, 4, 4, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 4 }, // >
407 { 4, 1, 4, 4, 4, 4, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 4 }, // <=
408 { 4, 1, 4, 4, 4, 4, 2, 2, 2, 2, 1, 1, 1, 1, 1, 1, 1, 4 }, // <
409 { 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 1, 1, 1, 1, 1, 4 }, // +
410 { 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 2, 2, 1, 1, 1, 1, 1, 4 }, // -
411 { 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, 4, 4, 1, 4 }, // unary +
412 { 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, 4, 4, 1, 4 }, // unary -
413 { 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, 2, 2, 1, 4 }, // *
414 { 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, 2, 2, 1, 4 }, // /
415 { 4, 1, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 1, 1, 4, 4, 4, 4 } // ^
416 };
417
418 stack<int> op; // operator stack
419 stack<pchar> pos; // position stack
420 stack<double> val; // value stack
421 double value;
422 pchar pointer = begin;
423 int iWhat, iCur, iPrev = 0, iTop, EVAL_STATUS;
424 char c;
425
426 op.push(0); pos.push(pointer); // push EOL to the stack
427 SKIP_BLANKS;
428 if (c == '\0') { EVAL_EXIT( EVAL::WARNING_BLANK_STRING, begin ); }
429 for(;;pointer++) {
430
431 // N E X T T O K E N
432
433 c = (pointer > end) ? '\0' : *pointer;
434 if (isspace(c)) continue; // skip space, tab etc.
435 switch (c) {
436 case '\0': iCur = ENDL; break;
437 case '(': iCur = LBRA; break;
438 case '|':
439 if (*(pointer+1) == '|') {
440 pointer++; iCur = OR; break;
441 }else{
442 EVAL_EXIT( EVAL::ERROR_UNEXPECTED_SYMBOL, pointer );
443 }
444 case '&':
445 if (*(pointer+1) == '&') {
446 pointer++; iCur = AND; break;
447 }else{
448 EVAL_EXIT( EVAL::ERROR_UNEXPECTED_SYMBOL, pointer );
449 }
450 case '=':
451 if (*(pointer+1) == '=') {
452 pointer++; iCur = EQ; break;
453 }else{
454 EVAL_EXIT( EVAL::ERROR_UNEXPECTED_SYMBOL, pointer );
455 }
456 case '!':
457 if (*(pointer+1) == '=') {
458 pointer++; iCur = NE; break;
459 }else{
460 EVAL_EXIT( EVAL::ERROR_UNEXPECTED_SYMBOL, pointer );
461 }
462 case '>':
463 if (*(pointer+1) == '=') { pointer++; iCur = GE; } else { iCur = GT; }
464 break;
465 case '<':
466 if (*(pointer+1) == '=') { pointer++; iCur = LE; } else { iCur = LT; }
467 break;
468 case '+': iCur = PLUS; break;
469 case '-': iCur = MINUS; break;
470 case '*':
471 if (*(pointer+1) == '*') { pointer++; iCur = POW; }else{ iCur = MULT; }
472 break;
473 case '/': iCur = DIV; break;
474 case '^': iCur = POW; break;
475 case ')': iCur = RBRA; break;
476 default:
477 if (c == '.' || isalnum(c)) {
478 iCur = VALUE; break;
479 }else{
480 EVAL_EXIT( EVAL::ERROR_UNEXPECTED_SYMBOL, pointer );
481 }
482 }
483
484 // S Y N T A X A N A L I S Y S
485
486 iWhat = SyntaxTable[iPrev][iCur];
487 iPrev = iCur;
488 switch (iWhat) {
489 case 0: // syntax error
490 EVAL_EXIT( EVAL::ERROR_SYNTAX_ERROR, pointer );
491 case 1: // operand: number, variable, function
492 EVAL_STATUS = operand(pointer, end, value, pointer, dictionary);
493 if (EVAL_STATUS != EVAL::OK) { EVAL_EXIT( EVAL_STATUS, pointer ); }
494 val.push(value);
495 continue;
496 case 2: // unary + or unary -
497 val.push(0.0);
498 if (iCur == PLUS) iCur = UNARY_PLUS;
499 if (iCur == MINUS) iCur = UNARY_MINUS;
500 // Note that for syntax purposes, ordinary + or - are fine.
501 // Thus iPrev need not change when we encounter a unary minus or plus.
502 case 3: default: // next operator
503 break;
504 }
505
506 // N E X T O P E R A T O R
507
508 for(;;) {
509 if (op.size() == 0) { EVAL_EXIT( EVAL::ERROR_SYNTAX_ERROR, pointer ); }
510 iTop = op.top();
511 switch (ActionTable[iTop][iCur]) {
512 case -1: // syntax error
513 if (op.size() > 1) pointer = pos.top();
514 EVAL_EXIT( EVAL::ERROR_UNPAIRED_PARENTHESIS, pointer );
515 case 0: // last operation (assignment)
516 if (val.size() == 1) {
517 result = val.top();
518 EVAL_EXIT( EVAL::OK, pointer );
519 }else{
520 EVAL_EXIT( EVAL::ERROR_SYNTAX_ERROR, pointer );
521 }
522 case 1: // push current operator in stack
523 op.push(iCur); pos.push(pointer);
524 break;
525 case 2: // execute top operator
526 EVAL_STATUS = maker(iTop, val); // put current operator in stack
527 if (EVAL_STATUS != EVAL::OK) {
528 EVAL_EXIT( EVAL_STATUS, pos.top() );
529 }
530 op.top() = iCur; pos.top() = pointer;
531 break;
532 case 3: // delete '(' from stack
533 op.pop(); pos.pop();
534 break;
535 case 4: default: // execute top operator and
536 EVAL_STATUS = maker(iTop, val); // delete it from stack
537 if (EVAL_STATUS != EVAL::OK) { // repete with the same iCur
538 EVAL_EXIT( EVAL_STATUS, pos.top() );
539 }
540 op.pop(); pos.pop();
541 continue;
542 }
543 break;
544 }
545 }
546}
547
548//---------------------------------------------------------------------------
549static void setItem(const char * prefix, const char * name,
550 const Item & item, Struct * s) {
551
552 if (name == 0 || *name == '\0') {
553 s->theStatus = EVAL::ERROR_NOT_A_NAME;
554 return;
555 }
556
557 // R E M O V E L E A D I N G A N D T R A I L I N G S P A C E S
558
559 const char * pointer; int n; REMOVE_BLANKS;
560
561 // C H E C K N A M E
562
563 if (n == 0) {
564 s->theStatus = EVAL::ERROR_NOT_A_NAME;
565 return;
566 }
567 for(int i=0; i<n; i++) {
568 char c = *(pointer+i);
569 if (c != '_' && !isalnum(c)) {
570 s->theStatus = EVAL::ERROR_NOT_A_NAME;
571 return;
572 }
573 }
574
575 // A D D I T E M T O T H E D I C T I O N A R Y
576
577 string item_name = prefix + string(pointer,n);
578 dic_type::iterator iter = (s->theDictionary).find(item_name);
579 if (iter != (s->theDictionary).end()) {
580 iter->second = item;
581 if (item_name == name) {
582 s->theStatus = EVAL::WARNING_EXISTING_VARIABLE;
583 }else{
584 s->theStatus = EVAL::WARNING_EXISTING_FUNCTION;
585 }
586 }else{
587 (s->theDictionary)[item_name] = item;
588 s->theStatus = EVAL::OK;
589 }
590}
591
592//---------------------------------------------------------------------------
593namespace HepTool {
594
595//---------------------------------------------------------------------------
596Evaluator::Evaluator() {
597 Struct * s = new Struct();
598 p = (void *) s;
599 s->theExpression = 0;
600 s->thePosition = 0;
601 s->theStatus = OK;
602 s->theResult = 0.0;
603}
604
605//---------------------------------------------------------------------------
606Evaluator::~Evaluator() {
607 delete (Struct *)(p);
608}
609
610//---------------------------------------------------------------------------
611double Evaluator::evaluate(const char * expression) {
612 Struct * s = (Struct *)(p);
613 if (s->theExpression != 0) { delete[] s->theExpression; }
614 s->theExpression = 0;
615 s->thePosition = 0;
616 s->theStatus = WARNING_BLANK_STRING;
617 s->theResult = 0.0;
618 if (expression != 0) {
619 s->theExpression = new char[strlen(expression)+1];
620 strcpy(s->theExpression, expression);
621 s->theStatus = engine(s->theExpression,
622 s->theExpression+strlen(expression)-1,
623 s->theResult,
624 s->thePosition,
625 s->theDictionary);
626 }
627 return s->theResult;
628}
629
630//---------------------------------------------------------------------------
631int Evaluator::status() const {
632 return ((Struct *)(p))->theStatus;
633}
634
635//---------------------------------------------------------------------------
636int Evaluator::error_position() const {
637 return ((Struct *)(p))->thePosition - ((Struct *)(p))->theExpression;
638}
639
640//---------------------------------------------------------------------------
641void Evaluator::print_error() const {
642 Struct * s = (Struct *) p;
643 if(s->theStatus != OK) {
644 std::cerr << error_name() << std::endl;
645 }
646 return;
647}
648
649//---------------------------------------------------------------------------
650std::string Evaluator::error_name() const
651{
652 char prefix[] = "Evaluator : ";
653 std::ostringstream errn;
654 Struct * s = (Struct *) p;
655 switch (s->theStatus) {
656 case ERROR_NOT_A_NAME:
657 errn << prefix << "invalid name";
658 break;
659 case ERROR_SYNTAX_ERROR:
660 errn << prefix << "syntax error";
661 break;
662 case ERROR_UNPAIRED_PARENTHESIS:
663 errn << prefix << "unpaired parenthesis";
664 break;
665 case ERROR_UNEXPECTED_SYMBOL:
666 errn << prefix << "unexpected symbol";
667 break;
668 case ERROR_UNKNOWN_VARIABLE:
669 errn << prefix << "unknown variable";
670 break;
671 case ERROR_UNKNOWN_FUNCTION:
672 errn << prefix << "unknown function";
673 break;
674 case ERROR_EMPTY_PARAMETER:
675 errn << prefix << "empty parameter in function call";
676 break;
677 case ERROR_CALCULATION_ERROR:
678 errn << prefix << "calculation error";
679 break;
680 default:
681 errn << " ";
682 }
683 return errn.str();
684}
685
686//---------------------------------------------------------------------------
687void Evaluator::setVariable(const char * name, double value)
688{ setItem("", name, Item(value), (Struct *)p); }
689
690void Evaluator::setVariable(const char * name, const char * expression)
691{ setItem("", name, Item(expression), (Struct *)p); }
692
693//---------------------------------------------------------------------------
694// Fix non ISO C++ compliant cast from pointer to function
695// to void*, which is a pointer to an object
696void Evaluator::setFunction(const char * name,
697 double (*fun)())
698{ setItem("0", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }
699
700void Evaluator::setFunction(const char * name,
701 double (*fun)(double))
702{ setItem("1", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }
703
704void Evaluator::setFunction(const char * name,
705 double (*fun)(double,double))
706{ setItem("2", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }
707
708void Evaluator::setFunction(const char * name,
709 double (*fun)(double,double,double))
710{ setItem("3", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }
711
712void Evaluator::setFunction(const char * name,
713 double (*fun)(double,double,double,double))
714{ setItem("4", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }
715
716void Evaluator::setFunction(const char * name,
717 double (*fun)(double,double,double,double,double))
718{ setItem("5", name, Item(reinterpret_cast<voidfuncptr>(fun)), (Struct *)p); }
719
720//---------------------------------------------------------------------------
721bool Evaluator::findVariable(const char * name) const {
722 if (name == 0 || *name == '\0') return false;
723 const char * pointer; int n; REMOVE_BLANKS;
724 if (n == 0) return false;
725 Struct * s = (Struct *)(p);
726 return
727 ((s->theDictionary).find(string(pointer,n)) == (s->theDictionary).end()) ?
728 false : true;
729}
730
731//---------------------------------------------------------------------------
732bool Evaluator::findFunction(const char * name, int npar) const {
733 if (name == 0 || *name == '\0') return false;
734 if (npar < 0 || npar > MAX_N_PAR) return false;
735 const char * pointer; int n; REMOVE_BLANKS;
736 if (n == 0) return false;
737 Struct * s = (Struct *)(p);
738 return ((s->theDictionary).find(sss[npar]+string(pointer,n)) ==
739 (s->theDictionary).end()) ? false : true;
740}
741
742//---------------------------------------------------------------------------
743void Evaluator::removeVariable(const char * name) {
744 if (name == 0 || *name == '\0') return;
745 const char * pointer; int n; REMOVE_BLANKS;
746 if (n == 0) return;
747 Struct * s = (Struct *)(p);
748 (s->theDictionary).erase(string(pointer,n));
749}
750
751//---------------------------------------------------------------------------
752void Evaluator::removeFunction(const char * name, int npar) {
753 if (name == 0 || *name == '\0') return;
754 if (npar < 0 || npar > MAX_N_PAR) return;
755 const char * pointer; int n; REMOVE_BLANKS;
756 if (n == 0) return;
757 Struct * s = (Struct *)(p);
758 (s->theDictionary).erase(sss[npar]+string(pointer,n));
759}
760
761//---------------------------------------------------------------------------
762void Evaluator::clear() {
763 Struct * s = (Struct *) p;
764 s->theDictionary.clear();
765 s->theExpression = 0;
766 s->thePosition = 0;
767 s->theStatus = OK;
768 s->theResult = 0.0;
769}
770
771//---------------------------------------------------------------------------
772} // namespace HepTool
EVAL_EXIT
#define EVAL_EXIT(STATUS, POSITION)
Definition: Evaluator.cc:61
MAX_N_PAR
#define MAX_N_PAR
Definition: Evaluator.cc:62
REMOVE_BLANKS
#define REMOVE_BLANKS
Definition: Evaluator.cc:51
dic_type
hash_map< string, Item > dic_type
Definition: Evaluator.cc:38
pchar
char * pchar
Definition: Evaluator.cc:37
SKIP_BLANKS
#define SKIP_BLANKS
Definition: Evaluator.cc:55
voidfuncptr
void(* voidfuncptr)()
Definition: Evaluator.cc:21
RBRA
@ RBRA
Definition: Evaluator.cc:67
LBRA
@ LBRA
Definition: Evaluator.cc:66
GT
@ GT
Definition: Evaluator.cc:66
MULT
@ MULT
Definition: Evaluator.cc:67
ENDL
@ ENDL
Definition: Evaluator.cc:66
POW
@ POW
Definition: Evaluator.cc:67
UNARY_MINUS
@ UNARY_MINUS
Definition: Evaluator.cc:67
LT
@ LT
Definition: Evaluator.cc:66
NE
@ NE
Definition: Evaluator.cc:66
GE
@ GE
Definition: Evaluator.cc:66
UNARY_PLUS
@ UNARY_PLUS
Definition: Evaluator.cc:67
LE
@ LE
Definition: Evaluator.cc:66
DIV
@ DIV
Definition: Evaluator.cc:67
AND
@ AND
Definition: Evaluator.cc:66
PLUS
@ PLUS
Definition: Evaluator.cc:67
OR
@ OR
Definition: Evaluator.cc:66
EQ
@ EQ
Definition: Evaluator.cc:66
VALUE
@ VALUE
Definition: Evaluator.cc:67
MINUS
@ MINUS
Definition: Evaluator.cc:67
function
G4double(* function)(G4double)
Definition: G4ChebyshevApproximation.hh:126
HepTool::Evaluator::error_position
int error_position() const
Definition: Evaluator.cc:636
HepTool::Evaluator::findFunction
bool findFunction(const char *name, int npar) const
Definition: Evaluator.cc:732
HepTool::Evaluator::print_error
void print_error() const
Definition: Evaluator.cc:641
HepTool::Evaluator::evaluate
double evaluate(const char *expression)
Definition: Evaluator.cc:611
HepTool::Evaluator::error_name
std::string error_name() const
Definition: Evaluator.cc:650
HepTool::Evaluator::removeVariable
void removeVariable(const char *name)
Definition: Evaluator.cc:743
HepTool::Evaluator::removeFunction
void removeFunction(const char *name, int npar)
Definition: Evaluator.cc:752
HepTool::Evaluator::setFunction
void setFunction(const char *name, double(*fun)())
Definition: Evaluator.cc:696
HepTool::Evaluator::setVariable
void setVariable(const char *name, double value)
Definition: Evaluator.cc:687
HepTool::Evaluator::status
int status() const
Definition: Evaluator.cc:631
HepTool::Evaluator::findVariable
bool findVariable(const char *name) const
Definition: Evaluator.cc:721
HepTool::Evaluator::ERROR_UNPAIRED_PARENTHESIS
@ ERROR_UNPAIRED_PARENTHESIS
Definition: Evaluator.h:46
Item::Item
Item()
Definition: Evaluator.cc:31
Item::Item
Item(double x)
Definition: Evaluator.cc:32
Item::function
voidfuncptr function
Definition: Evaluator.cc:29
Item::expression
string expression
Definition: Evaluator.cc:25
Item::Item
Item(string x)
Definition: Evaluator.cc:33
Item::Item
Item(voidfuncptr x)
Definition: Evaluator.cc:34
Item::variable
double variable
Definition: Evaluator.cc:24
Item::VARIABLE
@ VARIABLE
Definition: Evaluator.cc:23
Item::EXPRESSION
@ EXPRESSION
Definition: Evaluator.cc:23
Item::UNKNOWN
@ UNKNOWN
Definition: Evaluator.cc:23
Item::FUNCTION
@ FUNCTION
Definition: Evaluator.cc:23
Item::what
enum Item::@12 what
Struct::thePosition
pchar thePosition
Definition: Evaluator.cc:43
Struct::theExpression
pchar theExpression
Definition: Evaluator.cc:42
Struct::theStatus
int theStatus
Definition: Evaluator.cc:44
Struct::theDictionary
dic_type theDictionary
Definition: Evaluator.cc:41
Struct::theResult
double theResult
Definition: Evaluator.cc:45