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