Geant4 9.6.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4UIparameter.cc
Go to the documentation of this file.
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// $Id$
28//
29
30#include "G4UIparameter.hh"
31#include "G4UIcommandStatus.hh"
32#include "G4Tokenizer.hh"
33#include "G4ios.hh"
34#include <sstream>
35
36
37G4UIparameter::G4UIparameter():paramERR(0)
38{
39 G4String nullString;
40 parameterName = nullString;
41 parameterType = '\0';
42 omittable = false;
43 parameterGuidance = nullString;
44 defaultValue = nullString;
45 parameterRange = nullString;
46 currentAsDefaultFlag = false;
47 parameterCandidate = nullString;
48 widget = 0;
49 bp = 0;
50 token = NONE;
51}
52
53G4UIparameter::G4UIparameter(char theType):paramERR(0)
54{
55 G4String nullString;
56 parameterName = nullString;
57 parameterType = theType;
58 omittable = false;
59 parameterGuidance = nullString;
60 defaultValue = nullString;
61 parameterRange = nullString;
62 currentAsDefaultFlag = false;
63 parameterCandidate = nullString;
64 widget = 0;
65 bp = 0;
66 token = NONE;
67}
68
69G4UIparameter::G4UIparameter(const char * theName, char theType, G4bool theOmittable):paramERR(0)
70{
71 parameterName = theName;
72 parameterType = theType;
73 omittable = theOmittable;
74 G4String nullString;
75 parameterGuidance = nullString;
76 defaultValue = nullString;
77 parameterRange = nullString;
78 currentAsDefaultFlag = false;
79 parameterCandidate = nullString;
80 widget = 0;
81 bp = 0;
82 token = NONE;
83}
84
85G4UIparameter::~G4UIparameter()
86{ }
87
88G4int G4UIparameter::operator==(const G4UIparameter &right) const
89{
90 return ( this == &right );
91}
92
93G4int G4UIparameter::operator!=(const G4UIparameter &right) const
94{
95 return ( this != &right );
96}
97
98void G4UIparameter::List()
99{
100 G4cout << G4endl << "Parameter : " << parameterName << G4endl;
101 if( ! parameterGuidance.isNull() )
102 G4cout << parameterGuidance << G4endl ;
103 G4cout << " Parameter type : " << parameterType << G4endl;
104 if(omittable)
105 { G4cout << " Omittable : True" << G4endl; }
106 else
107 { G4cout << " Omittable : False" << G4endl; }
108 if( currentAsDefaultFlag )
109 { G4cout << " Default value : taken from the current value" << G4endl; }
110 else if( ! defaultValue.isNull() )
111 { G4cout << " Default value : " << defaultValue << G4endl; }
112 if( ! parameterRange.isNull() )
113 G4cout << " Parameter range : " << parameterRange << G4endl;
114 if( ! parameterCandidate.isNull() )
115 G4cout << " Candidates : " << parameterCandidate << G4endl;
116}
117
118void G4UIparameter::SetDefaultValue(G4int theDefaultValue)
119{
120 std::ostringstream os;
121 os << theDefaultValue;
122 defaultValue = os.str();
123}
124
125void G4UIparameter::SetDefaultValue(G4double theDefaultValue)
126{
127 std::ostringstream os;
128 os << theDefaultValue;
129 defaultValue = os.str();
130}
131
132
133// ---------- CheckNewValue() related routines -----------
134#include <ctype.h>
135#include "G4UItokenNum.hh"
136
137//#include "checkNewValue_debug.icc"
138//#define DEBUG 1
139
140G4int G4UIparameter::
141CheckNewValue(const char* newValue ) {
142 if( TypeCheck(newValue) == 0) return fParameterUnreadable;
143 if( ! parameterRange.isNull() )
144 { if( RangeCheck(newValue) == 0 ) return fParameterOutOfRange; }
145 if( ! parameterCandidate.isNull() )
146 { if( CandidateCheck(newValue) == 0 ) return fParameterOutOfCandidates; }
147 return 0; // succeeded
148}
149
150G4int G4UIparameter::
151CandidateCheck(const char* newValue) {
152 G4Tokenizer candidateTokenizer(parameterCandidate);
153 G4String aToken;
154 G4int iToken = 0;
155 while( ! (aToken=candidateTokenizer()).isNull() )
156 {
157 iToken++;
158 if(aToken==newValue) return iToken;
159 }
160 G4cerr << "parameter value is not listed in the candidate List." << G4endl;
161 return 0;
162}
163
164G4int G4UIparameter::
165RangeCheck(const char* newValue) {
166 yystype result;
167 bp = 0; // reset buffer pointer for G4UIpGetc()
168 std::istringstream is(newValue);
169 char type = toupper( parameterType );
170 switch (type) {
171 case 'D': { is >> newVal.D; } break;
172 case 'I': { is >> newVal.I; } break;
173 default: ;
174 }
175 // PrintToken(); // Print tokens (consumes all tokens)
176 token= Yylex();
177 result = Expression();
178 if( paramERR == 1 ) return 0;
179 if( result.type != CONSTINT) {
180 G4cerr << "Illegal Expression in parameter range." << G4endl;
181 return 0;
182 }
183 if ( result.I ) return 1;
184 G4cerr << "parameter out of range: "<< parameterRange << G4endl;
185 return 0;
186}
187
188
189G4int G4UIparameter::
190TypeCheck(const char* newValue)
191{
192 G4String newValueString(newValue);
193 char type = toupper( parameterType );
194 switch(type) {
195 case 'D':
196 if( IsDouble(newValueString.data())== 0) {
197 G4cerr<<newValue<<": double value expected."
198 << G4endl;
199 return 0;
200 } break;
201 case 'I':
202 if( IsInt(newValueString.data(),20)== 0) {
203 G4cerr<<newValue<<": integer expected."
204 << G4endl;
205 return 0;
206 } break;
207 case 'S': break;
208 case 'B':
209 newValueString.toUpper();
210 if ( newValueString == "Y" || newValueString == "N"
211 ||newValueString == "YES" || newValueString == "NO"
212 ||newValueString == "1" || newValueString == "0"
213 ||newValueString == "T" || newValueString == "F"
214 ||newValueString == "TRUE" || newValueString == "FALSE")
215 return 1;
216 else {
217 G4cerr<<newValue<<": bool expected." << G4endl;
218 return 0;
219 }
220 default: ;
221 }
222 return 1;
223}
224
225
226G4int G4UIparameter::
227IsInt(const char* buf, short maxDigits) // do not allow any std::ws
228{
229 const char* p= buf;
230 G4int length=0;
231 if( *p == '+' || *p == '-') { ++p; }
232 if( isdigit( (G4int)(*p) )) {
233 while( isdigit( (G4int)(*p) )) { ++p; ++length; }
234 if( *p == '\0' ) {
235 if( length > maxDigits) {
236 G4cerr <<"digit length exceeds"<<G4endl;
237 return 0;
238 }
239 return 1;
240 } else {
241 // G4cerr <<"illegal character after int:"<<buf<<G4endl;
242 }
243 } else {
244 // G4cerr <<"illegal int:"<<buf<<G4endl;
245 }
246 return 0;
247}
248
249
250G4int G4UIparameter::
251ExpectExponent(const char* str) // used only by IsDouble()
252{
253 G4int maxExplength;
254 if( IsInt( str, maxExplength=7 )) return 1;
255 else return 0;
256}
257
258G4int G4UIparameter::
259IsDouble(const char* buf) // see state diagram for this spec.
260{
261 const char* p= buf;
262 switch( *p) {
263 case '+': case '-': ++p;
264 if( isdigit(*p) ) {
265 while( isdigit( (G4int)(*p) )) { ++p; }
266 switch ( *p ) {
267 case '\0': return 1; //break;
268 case 'E': case 'e':
269 return ExpectExponent(++p ); //break;
270 case '.': ++p;
271 if( *p == '\0' ) return 1;
272 if( *p == 'e' || *p =='E' ) return ExpectExponent(++p );
273 if( isdigit(*p) ) {
274 while( isdigit( (G4int)(*p) )) { ++p; }
275 if( *p == '\0' ) return 1;
276 if( *p == 'e' || *p =='E') return ExpectExponent(++p);
277 } else return 0; break;
278 default: return 0;
279 }
280 }
281 if( *p == '.' ) { ++p;
282 if( isdigit(*p) ) {
283 while( isdigit( (G4int)(*p) )) { ++p; }
284 if( *p == '\0' ) return 1;
285 if( *p == 'e' || *p =='E') return ExpectExponent(++p);
286 }
287 }
288 break;
289 case '.': ++p;
290 if( isdigit(*p) ) {
291 while( isdigit( (G4int)(*p) )) { ++p; }
292 if( *p == '\0' ) return 1;
293 if( *p == 'e' || *p =='E' ) return ExpectExponent(++p);
294 } break;
295 default: // digit is expected
296 if( isdigit(*p) ) {
297 while( isdigit( (G4int)(*p) )) { ++p; }
298 if( *p == '\0' ) return 1;
299 if( *p == 'e' || *p =='E') return ExpectExponent(++p);
300 if( *p == '.' ) { ++p;
301 if( *p == '\0' ) return 1;
302 if( *p == 'e' || *p =='E') return ExpectExponent(++p);
303 if( isdigit(*p) ) {
304 while( isdigit( (G4int)(*p) )) { ++p; }
305 if( *p == '\0' ) return 1;
306 if( *p == 'e' || *p =='E') return ExpectExponent(++p);
307 }
308 }
309 }
310 }
311 return 0;
312}
313
314
315// ------------------ syntax node functions ------------------
316
317yystype G4UIparameter::
318Expression(void)
319{
320 yystype result;
321 #ifdef DEBUG
322 G4cerr << " Expression()" << G4endl;
323 #endif
324 result = LogicalORExpression();
325 return result;
326}
327
328yystype G4UIparameter::
329LogicalORExpression(void)
330{
331 yystype result;
332 yystype p;
333 p = LogicalANDExpression();
334 if( token != LOGICALOR) return p;
335 if( p.type == CONSTSTRING || p.type == IDENTIFIER ) {
336 G4cerr << "Parameter range: illegal type at '||'" << G4endl;
337 paramERR = 1;
338 }
339 result.I = p.I;
340 while (token == LOGICALOR)
341 {
342 token = Yylex();
343 p = LogicalANDExpression();
344 if( p.type == CONSTSTRING || p.type == IDENTIFIER ) {
345 G4cerr << "Parameter range: illegal type at '||'" <<G4endl;
346 paramERR = 1;
347 }
348 switch (p.type) {
349 case CONSTINT:
350 result.I += p.I;
351 result.type = CONSTINT; break;
352 case CONSTDOUBLE:
353 result.I += (p.D != 0.0);
354 result.type = CONSTINT; break;
355 default:
356 G4cerr << "Parameter range: unknown type"<<G4endl;
357 paramERR = 1;
358 }
359 }
360 return result;
361}
362
363yystype G4UIparameter::
364LogicalANDExpression(void)
365{
366 yystype result;
367 yystype p;
368 p = EqualityExpression();
369 if( token != LOGICALAND) return p;
370 if( p.type == CONSTSTRING || p.type == IDENTIFIER ) {
371 G4cerr << "Parameter range: illegal type at '&&'" << G4endl;
372 paramERR = 1;
373 }
374 result.I = p.I;
375 while (token == LOGICALAND)
376 {
377 token = Yylex();
378 p = EqualityExpression();
379 if( p.type == CONSTSTRING || p.type == IDENTIFIER ) {
380 G4cerr << "Parameter range: illegal type at '&&'" << G4endl;
381 paramERR = 1;
382 }
383 switch (p.type) {
384 case CONSTINT:
385 result.I *= p.I;
386 result.type = CONSTINT; break;
387 case CONSTDOUBLE:
388 result.I *= (p.D != 0.0);
389 result.type = CONSTINT; break;
390 default:
391 G4cerr << "Parameter range: unknown type."<< G4endl;
392 paramERR = 1;
393 }
394 }
395 return result;
396}
397
398
399yystype G4UIparameter::
400EqualityExpression(void)
401{
402 yystype arg1, arg2;
403 G4int operat;
404 yystype result;
405 #ifdef DEBUG
406 G4cerr << " EqualityExpression()" <<G4endl;
407 #endif
408 result = RelationalExpression();
409 if( token==EQ || token==NE ) {
410 operat = token;
411 token = Yylex();
412 arg1 = result;
413 arg2 = RelationalExpression();
414 result.I = Eval2( arg1, operat, arg2 ); // semantic action
415 result.type = CONSTINT;
416 #ifdef DEBUG
417 G4cerr << " return code of Eval2(): " << result.I <<G4endl;
418 #endif
419 } else {
420 if (result.type != CONSTINT && result.type != CONSTDOUBLE) {
421 G4cerr << "Parameter range: error at EqualityExpression"
422 << G4endl;
423 paramERR = 1;
424 }
425 }
426 return result;
427}
428
429
430yystype G4UIparameter::
431RelationalExpression(void)
432{
433 yystype arg1, arg2;
434 G4int operat;
435 yystype result;
436 #ifdef DEBUG
437 G4cerr << " RelationalExpression()" <<G4endl;
438 #endif
439
440 arg1 = AdditiveExpression();
441 if( token==GT || token==GE || token==LT || token==LE ) {
442 operat = token;
443 token = Yylex();
444 arg2 = AdditiveExpression();
445 result.I = Eval2( arg1, operat, arg2 ); // semantic action
446 result.type = CONSTINT;
447 #ifdef DEBUG
448 G4cerr << " return Eval2(): " << G4endl;
449 #endif
450 } else {
451 result = arg1;
452 }
453 #ifdef DEBUG
454 G4cerr <<" return RelationalExpression()" <<G4endl;
455 #endif
456 return result;
457}
458
459yystype G4UIparameter::
460AdditiveExpression(void)
461{ yystype result;
462 result = MultiplicativeExpression();
463 if( token != '+' && token != '-' ) return result;
464 G4cerr << "Parameter range: operator "
465 << (char)token
466 << " is not supported." << G4endl;
467 paramERR = 1;
468 return result;
469}
470
471yystype G4UIparameter::
472MultiplicativeExpression(void)
473{ yystype result;
474 result = UnaryExpression();
475 if( token != '*' && token != '/' && token != '%' ) return result;
476 G4cerr << "Parameter range: operator "
477 << (char)token
478 << " is not supported." << G4endl;
479 paramERR = 1;
480 return result;
481}
482
483yystype G4UIparameter::
484UnaryExpression(void)
485{
486 yystype result;
487 yystype p;
488 #ifdef DEBUG
489 G4cerr <<" UnaryExpression"<< G4endl;
490 #endif
491 switch(token) {
492 case '-':
493 token = Yylex();
494 p = UnaryExpression();
495 if (p.type == CONSTINT) {
496 result.I = - p.I;
497 result.type = CONSTINT;
498 }
499 if (p.type == CONSTDOUBLE) {
500 result.D = - p.D;
501 result.type = CONSTDOUBLE;
502 } break;
503 case '+':
504 token = Yylex();
505 result = UnaryExpression(); break;
506 case '!':
507 token = Yylex();
508 G4cerr << "Parameter range error: "
509 << "operator '!' is not supported (sorry)."
510 << G4endl;
511 paramERR = 1;
512 result = UnaryExpression(); break;
513 default:
514 result = PrimaryExpression();
515 }
516 return result;
517}
518
519
520yystype G4UIparameter::
521PrimaryExpression(void)
522{
523 yystype result;
524 #ifdef DEBUG
525 G4cerr <<" PrimaryExpression" << G4endl;
526 #endif
527 switch (token) {
528 case IDENTIFIER:
529 result.S = yylval.S;
530 result.type = token;
531 token = Yylex(); break;
532 case CONSTINT:
533 result.I = yylval.I;
534 result.type = token;
535 token= Yylex(); break;
536 case CONSTDOUBLE:
537 result.D = yylval.D;
538 result.type = token;
539 token = Yylex(); break;
540 case '(' :
541 token= Yylex();
542 result = Expression();
543 if( token != ')' ) {
544 G4cerr << " ')' expected" << G4endl;
545 paramERR = 1;
546 }
547 token = Yylex();
548 break;
549 default:
550 return result;
551 }
552 return result; // never executed
553}
554
555//---------------- semantic routines ---------------------------------
556
557G4int G4UIparameter::
558Eval2(yystype arg1, G4int op, yystype arg2)
559{
560 if( (arg1.type != IDENTIFIER) && (arg2.type != IDENTIFIER)) {
561 G4cerr << parameterName
562 << ": meaningless comparison "
563 << G4int(arg1.type) << " " << G4int(arg2.type) << G4endl;
564 paramERR = 1;
565 }
566 char type = toupper( parameterType );
567 if( arg1.type == IDENTIFIER) {
568 switch (type) {
569 case 'I':
570 if ( arg2.type == CONSTINT ) {
571 return CompareInt( newVal.I, op, arg2.I );
572 } else {
573 G4cerr << "integer operand expected for "
574 << parameterRange << '.'
575 << G4endl;
576 }
577 break;
578 case 'D':
579 if ( arg2.type == CONSTDOUBLE ) {
580 return CompareDouble( newVal.D, op, arg2.D );
581 } else
582 if ( arg2.type == CONSTINT ) { // integral promotion
583 return CompareDouble( newVal.D, op, arg2.I );
584 } break;
585 default: ;
586 }
587 }
588 if( arg2.type == IDENTIFIER) {
589 switch (type) {
590 case 'I':
591 if ( arg1.type == CONSTINT ) {
592 return CompareInt( arg1.I, op, newVal.I );
593 } else {
594 G4cerr << "integer operand expected for "
595 << parameterRange << '.'
596 << G4endl;
597 }
598 break;
599 case 'D':
600 if ( arg1.type == CONSTDOUBLE ) {
601 return CompareDouble( arg1.D, op, newVal.D );
602 } else
603 if ( arg1.type == CONSTINT ) { // integral promotion
604 return CompareDouble( arg1.I, op, newVal.D );
605 } break;
606 default: ;
607 }
608 }
609 G4cerr << "no param name is specified at the param range."<<G4endl;
610 return 0;
611}
612
613G4int G4UIparameter::
614CompareInt(G4int arg1, G4int op, G4int arg2)
615{
616 G4int result=-1;
617 G4String opr;
618 switch (op) {
619 case GT: result = ( arg1 > arg2); opr= ">" ; break;
620 case GE: result = ( arg1 >= arg2); opr= ">="; break;
621 case LT: result = ( arg1 < arg2); opr= "<" ; break;
622 case LE: result = ( arg1 <= arg2); opr= "<="; break;
623 case EQ: result = ( arg1 == arg2); opr= "=="; break;
624 case NE: result = ( arg1 != arg2); opr= "!="; break;
625 default:
626 G4cerr << "Parameter range: error at CompareInt" << G4endl;
627 paramERR = 1;
628 }
629 #ifdef DEBUG
630 G4cerr << "CompareInt "
631 << arg1 << " " << opr << arg2
632 << " result: " << result
633 << G4endl;
634 #endif
635 return result;
636}
637
638G4int G4UIparameter::
639CompareDouble(G4double arg1, G4int op, G4double arg2)
640{
641 G4int result=-1;
642 G4String opr;
643 switch (op) {
644 case GT: result = ( arg1 > arg2); opr= ">"; break;
645 case GE: result = ( arg1 >= arg2); opr= ">="; break;
646 case LT: result = ( arg1 < arg2); opr= "<"; break;
647 case LE: result = ( arg1 <= arg2); opr= "<="; break;
648 case EQ: result = ( arg1 == arg2); opr= "=="; break;
649 case NE: result = ( arg1 != arg2); opr= "!="; break;
650 default:
651 G4cerr << "Parameter range: error at CompareDouble" << G4endl;
652 paramERR = 1;
653 }
654 #ifdef DEBUG
655 G4cerr << "CompareDouble "
656 << arg1 <<" " << opr << " "<< arg2
657 << " result: " << result
658 << G4endl;
659 #endif
660 return result;
661}
662
663// --------------------- utility functions --------------------------
664
665tokenNum G4UIparameter::
666Yylex() // reads input and returns token number KR486
667{ // (returns EOF)
668 G4int c;
669 G4String buf;
670
671 while(( c= G4UIpGetc())==' '|| c=='\t' || c== '\n' )
672 ;
673 if (c== EOF)
674 return (tokenNum)EOF; // KR488
675 buf= "";
676 if (isdigit(c) || c== '.') { // I or D
677 do {
678 buf += G4String((unsigned char)c);
679 c=G4UIpGetc();
680 } while (c=='.' || isdigit(c) ||
681 c=='e' || c=='E' || c=='+' || c=='-');
682 G4UIpUngetc(c);
683 const char* t = buf;
684 std::istringstream is(t);
685 if ( IsInt(buf.data(),20) ) {
686 is >> yylval.I;
687 return CONSTINT;
688 } else
689 if ( IsDouble(buf.data()) ) {
690 is >> yylval.D;
691 return CONSTDOUBLE;
692 } else {
693 G4cerr << buf<<": numeric format error."<<G4endl;
694 }
695 }
696 buf="";
697 if (isalpha(c)|| c=='_') { // IDENTIFIER
698 do {
699 buf += G4String((unsigned char)c);
700 } while ((c=G4UIpGetc()) != EOF && (isalnum(c) || c=='_'));
701 G4UIpUngetc(c);
702 if( buf == parameterName ) {
703 yylval.S =buf;
704 return IDENTIFIER;
705 } else {
706 G4cerr << buf << " is not a parameter name."<< G4endl;
707 paramERR = 1;
708 }
709 }
710 switch (c) {
711 case '>': return (tokenNum) Follow('=', GE, GT);
712 case '<': return (tokenNum) Follow('=', LE, LT);
713 case '=': return (tokenNum) Follow('=', EQ, '=');
714 case '!': return (tokenNum) Follow('=', NE, '!');
715 case '|': return (tokenNum) Follow('|', LOGICALOR, '|');
716 case '&': return (tokenNum) Follow('&', LOGICALAND, '&');
717 default:
718 return (tokenNum) c;
719 }
720}
721
722
723G4int G4UIparameter::
724Follow(G4int expect, G4int ifyes, G4int ifno)
725{
726 G4int c = G4UIpGetc();
727 if ( c== expect)
728 return ifyes;
729 G4UIpUngetc(c);
730 return ifno;
731}
732
733//------------------ low level routines -----------------------------
734G4int G4UIparameter::
735G4UIpGetc() { // emulation of getc()
736 G4int length = parameterRange.length();
737 if( bp < length)
738 return parameterRange(bp++);
739 else
740 return EOF;
741}
742G4int G4UIparameter::
743G4UIpUngetc(G4int c) { // emulation of ungetc()
744 if (c<0) return -1;
745 if (bp >0 && c == parameterRange(bp-1)) {
746 --bp;
747 } else {
748 G4cerr << "G4UIpUngetc() failed." << G4endl;
749 G4cerr << "bp="<<bp <<" c="<<c
750 << " pR(bp-1)=" << parameterRange(bp-1)
751 << G4endl;
752 paramERR = 1;
753 return -1;
754 }
755 return 0;
756}
757// ***** end of CheckNewValue() related code ******
758
GT
@ GT
Definition: Evaluator.cc:66
LT
@ LT
Definition: Evaluator.cc:66
NE
@ NE
Definition: Evaluator.cc:66
GE
@ GE
Definition: Evaluator.cc:66
LE
@ LE
Definition: Evaluator.cc:66
EQ
@ EQ
Definition: Evaluator.cc:66
G4double
double G4double
Definition: G4Types.hh:64
G4int
int G4int
Definition: G4Types.hh:66
G4bool
bool G4bool
Definition: G4Types.hh:67
fParameterOutOfCandidates
@ fParameterOutOfCandidates
Definition: G4UIcommandStatus.hh:40
fParameterUnreadable
@ fParameterUnreadable
Definition: G4UIcommandStatus.hh:39
fParameterOutOfRange
@ fParameterOutOfRange
Definition: G4UIcommandStatus.hh:38
tokenNum
tokenNum
Definition: G4UItokenNum.hh:37
LOGICALOR
@ LOGICALOR
Definition: G4UItokenNum.hh:51
IDENTIFIER
@ IDENTIFIER
Definition: G4UItokenNum.hh:39
LOGICALAND
@ LOGICALAND
Definition: G4UItokenNum.hh:52
NONE
@ NONE
Definition: G4UItokenNum.hh:38
CONSTSTRING
@ CONSTSTRING
Definition: G4UItokenNum.hh:43
CONSTINT
@ CONSTINT
Definition: G4UItokenNum.hh:40
CONSTDOUBLE
@ CONSTDOUBLE
Definition: G4UItokenNum.hh:41
G4endl
#define G4endl
Definition: G4ios.hh:52
G4cerr
G4DLLIMPORT std::ostream G4cerr
G4cout
G4DLLIMPORT std::ostream G4cout
G4String::isNull
G4bool isNull() const
G4String::data
const char * data() const
G4UIparameter::SetDefaultValue
void SetDefaultValue(const char *theDefaultValue)
Definition: G4UIparameter.hh:83
G4UIparameter::CheckNewValue
G4int CheckNewValue(const char *newValue)
Definition: G4UIparameter.cc:141
G4UIparameter::operator==
G4int operator==(const G4UIparameter &right) const
Definition: G4UIparameter.cc:88
G4UIparameter::operator!=
G4int operator!=(const G4UIparameter &right) const
Definition: G4UIparameter.cc:93
yystype::I
G4int I
Definition: G4UItokenNum.hh:64
yystype::type
tokenNum type
Definition: G4UItokenNum.hh:62
yystype::D
G4double D
Definition: G4UItokenNum.hh:63
yystype::S
G4String S
Definition: G4UItokenNum.hh:66