G4UIparameter Class Reference

#include <G4UIparameter.hh>

Collaboration diagram for G4UIparameter:

Public Member Functions
	G4UIparameter ()
	G4UIparameter (char theType)
	G4UIparameter (const char *theName, char theType, G4bool theOmittable)
	~G4UIparameter ()
G4int	operator== (const G4UIparameter &right) const
G4int	operator!= (const G4UIparameter &right) const
G4int	CheckNewValue (const char *newValue)
void	List ()
void	SetDefaultValue (const char *theDefaultValue)
void	SetDefaultValue (G4int theDefaultValue)
void	SetDefaultValue (G4double theDefaultValue)
G4String	GetDefaultValue () const
char	GetParameterType () const
void	SetParameterRange (const char *theRange)
G4String	GetParameterRange () const
void	SetParameterName (const char *theName)
G4String	GetParameterName () const
void	SetParameterCandidates (const char *theString)
G4String	GetParameterCandidates () const
void	SetOmittable (G4bool om)
G4bool	IsOmittable () const
void	SetCurrentAsDefault (G4bool val)
G4bool	GetCurrentAsDefault () const
void	SetWidget (G4int theWidget)
const G4String	GetParameterGuidance () const
void	SetGuidance (const char *theGuidance)

Private Member Functions
G4int	TypeCheck (const char *newValue)
G4int	RangeCheck (const char *newValue)
G4int	CandidateCheck (const char *newValue)
G4int	IsInt (const char *str, short maxDigit)
G4int	IsDouble (const char *str)
G4int	ExpectExponent (const char *str)
yystype	Expression (void)
yystype	LogicalORExpression (void)
yystype	LogicalANDExpression (void)
yystype	EqualityExpression (void)
yystype	RelationalExpression (void)
yystype	AdditiveExpression (void)
yystype	MultiplicativeExpression (void)
yystype	UnaryExpression (void)
yystype	PrimaryExpression (void)
G4int	Eval2 (yystype arg1, G4int op, yystype arg2)
G4int	CompareInt (G4int arg1, G4int op, G4int arg2)
G4int	CompareDouble (double arg1, G4int op, double arg2)
tokenNum	Yylex (void)
G4int	G4UIpGetc (void)
G4int	G4UIpUngetc (G4int c)
G4int	Backslash (G4int c)
G4int	Follow (G4int expect, G4int ifyes, G4int ifno)
G4String	TokenToStr (G4int token)

Private Attributes
G4String	parameterName
G4String	parameterGuidance
G4String	defaultValue
G4String	parameterRange
G4String	parameterCandidate
char	parameterType
G4bool	omittable
G4bool	currentAsDefaultFlag
G4int	widget
G4String	rangeBuf
G4int	bp
tokenNum	token
yystype	yylval
yystype	newVal
G4int	paramERR

Detailed Description

Definition at line 47 of file G4UIparameter.hh.

Constructor & Destructor Documentation

G4UIparameter() [1/3]

G4UIparameter::G4UIparameter

(

)

Definition at line 37 of file G4UIparameter.cc.

                            :paramERR(0)
{
  G4String nullString;
  parameterName = nullString;
  parameterType = '\0';
  omittable = false;
  parameterGuidance = nullString;
  defaultValue = nullString;
  parameterRange = nullString;
  currentAsDefaultFlag = false;
  parameterCandidate = nullString;
  widget = 0;
  bp = 0;
  token = NONE;
}

G4UIparameter() [2/3]

G4UIparameter::G4UIparameter

(

char

theType

)

Definition at line 53 of file G4UIparameter.cc.

                                        :paramERR(0)
{
  G4String nullString;
  parameterName = nullString;
  parameterType = theType;
  omittable = false;
  parameterGuidance = nullString;
  defaultValue = nullString;
  parameterRange = nullString;
  currentAsDefaultFlag = false;
  parameterCandidate = nullString;
  widget = 0;
  bp = 0;
  token = NONE;
}

G4UIparameter() [3/3]

G4UIparameter::G4UIparameter	(	const char *	theName,
		char	theType,
		G4bool	theOmittable
	)

Definition at line 69 of file G4UIparameter.cc.

                                                                                   :paramERR(0)
{
  parameterName = theName;
  parameterType = theType;
  omittable = theOmittable;
  G4String nullString;
  parameterGuidance = nullString;
  defaultValue = nullString;
  parameterRange = nullString;
  currentAsDefaultFlag = false;
  parameterCandidate = nullString;
  widget = 0;
  bp = 0;
  token = NONE;
}

~G4UIparameter()

G4UIparameter::~G4UIparameter

(

)

Definition at line 85 of file G4UIparameter.cc.

{ }

Member Function Documentation

AdditiveExpression()

yystype G4UIparameter::AdditiveExpression ( void  )

private

Definition at line 461 of file G4UIparameter.cc.

{   yystype result;
    result = MultiplicativeExpression();
    if( token != '+' && token != '-' )  return result;
    G4cerr << "Parameter range: operator " 
         << (char)token 
         << " is not supported." << G4endl;
    paramERR = 1;
    return  result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Backslash()

G4int G4UIparameter::Backslash ( G4int  c )

private

Here is the caller graph for this function:

CandidateCheck()

G4int G4UIparameter::CandidateCheck ( const char *  newValue )

private

Definition at line 151 of file G4UIparameter.cc.

                                     {
    G4Tokenizer candidateTokenizer(parameterCandidate);
    G4String aToken;
    G4int iToken = 0;
    while( ! (aToken=candidateTokenizer()).isNull() )
    {
      iToken++;
      if(aToken==newValue) return iToken;
    } 
    G4cerr << "parameter value (" << newValue
           << ") is not listed in the candidate List." << G4endl;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CheckNewValue()

G4int G4UIparameter::CheckNewValue

(

const char *

newValue

)

Definition at line 141 of file G4UIparameter.cc.

                                     {
    if( TypeCheck(newValue) == 0) return fParameterUnreadable;
    if( ! parameterRange.isNull() )
    { if( RangeCheck(newValue) == 0 ) return fParameterOutOfRange; }
    if( ! parameterCandidate.isNull() )
    { if( CandidateCheck(newValue) == 0 ) return fParameterOutOfCandidates; }
    return 0;   // succeeded
}

Here is the call graph for this function:

Here is the caller graph for this function:

CompareDouble()

G4int G4UIparameter::CompareDouble ( double  arg1, G4int  op, double  arg2  )

private

Definition at line 640 of file G4UIparameter.cc.

{   
    G4int result=-1;
    G4String opr;
    switch (op) {
        case GT:  result = ( arg1 >  arg2); opr= ">";   break;
        case GE:  result = ( arg1 >= arg2); opr= ">=";  break;
        case LT:  result = ( arg1 <  arg2); opr= "<";   break;
        case LE:  result = ( arg1 <= arg2); opr= "<=";  break;
        case EQ:  result = ( arg1 == arg2); opr= "==";  break;
        case NE:  result = ( arg1 != arg2); opr= "!=";  break;
        default:
           G4cerr << "Parameter range: error at CompareDouble" << G4endl;
           paramERR = 1;
    }
    #ifdef DEBUG
        G4cerr << "CompareDouble " 
             << arg1 <<" " << opr << " "<< arg2
             << " result: " << result
             << G4endl;
    #endif
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

CompareInt()

G4int G4UIparameter::CompareInt ( G4int  arg1, G4int  op, G4int  arg2  )

private

Definition at line 615 of file G4UIparameter.cc.

{   
    G4int result=-1;
    G4String opr;
    switch (op) {
       case GT:  result = ( arg1 >  arg2); opr= ">" ;  break;
       case GE:  result = ( arg1 >= arg2); opr= ">=";  break;
       case LT:  result = ( arg1 <  arg2); opr= "<" ;  break;
       case LE:  result = ( arg1 <= arg2); opr= "<=";  break;
       case EQ:  result = ( arg1 == arg2); opr= "==";  break;
       case NE:  result = ( arg1 != arg2); opr= "!=";  break;
       default: 
           G4cerr << "Parameter range: error at CompareInt" << G4endl;
           paramERR = 1;
    }
    #ifdef DEBUG
        G4cerr << "CompareInt "
             << arg1 << " " << opr << arg2 
             << " result: " << result
             << G4endl;
    #endif
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EqualityExpression()

yystype G4UIparameter::EqualityExpression ( void  )

private

Definition at line 401 of file G4UIparameter.cc.

{ 
    yystype  arg1, arg2;
    G4int operat;
    yystype result;
    #ifdef DEBUG
        G4cerr << " EqualityExpression()" <<G4endl;
    #endif
    result = RelationalExpression();
    if( token==EQ || token==NE ) {
        operat = token;
        token =  Yylex();
        arg1 = result;
        arg2 = RelationalExpression();
        result.I = Eval2( arg1, operat, arg2 );   // semantic action
        result.type = CONSTINT;
        #ifdef DEBUG
            G4cerr << " return code of Eval2(): " << result.I <<G4endl;
        #endif
    } else {
        if (result.type != CONSTINT && result.type != CONSTDOUBLE) {  
            G4cerr << "Parameter range: error at EqualityExpression"
                 << G4endl;
            paramERR = 1;
        }
    }
    return  result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Eval2()

G4int G4UIparameter::Eval2 ( yystype  arg1, G4int  op, yystype  arg2  )

private

Definition at line 559 of file G4UIparameter.cc.

{
    if( (arg1.type != IDENTIFIER) && (arg2.type != IDENTIFIER)) {
        G4cerr << parameterName
             << ": meaningless comparison "
             << G4int(arg1.type) << " " << G4int(arg2.type) << G4endl;
        paramERR = 1;
    }
    char type = toupper( parameterType );
    if( arg1.type == IDENTIFIER) {
        switch (type) {
            case 'I':
                if ( arg2.type == CONSTINT ) {
                    return CompareInt( newVal.I, op, arg2.I );
                } else {
                    G4cerr << "integer operand expected for "
                         << parameterRange << '.' 
                         << G4endl; 
                }
                 break;
            case 'D': 
                if ( arg2.type == CONSTDOUBLE ) {
                    return CompareDouble( newVal.D, op, arg2.D );
                } else
                if ( arg2.type == CONSTINT ) { // integral promotion
                    return CompareDouble( newVal.D, op, arg2.I );
                } break;
            default: ;
        }
    }
    if( arg2.type == IDENTIFIER) {
        switch (type) {
            case 'I':
                if ( arg1.type == CONSTINT ) {
                    return CompareInt( arg1.I, op, newVal.I );
                } else {
                    G4cerr << "integer operand expected for "
                         << parameterRange << '.' 
                         << G4endl; 
                }
                 break;
            case 'D': 
                if ( arg1.type == CONSTDOUBLE ) {
                    return CompareDouble( arg1.D, op, newVal.D );
                } else
                if ( arg1.type == CONSTINT ) { // integral promotion
                    return CompareDouble( arg1.I, op, newVal.D );
                } break;
            default: ;
        }
    }
    G4cerr << "no param name is specified at the param range."<<G4endl;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ExpectExponent()

G4int G4UIparameter::ExpectExponent ( const char *  str )

private

Definition at line 252 of file G4UIparameter.cc.

{
    G4int maxExplength;
    if( IsInt( str, maxExplength=7 )) return 1;
    else return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Expression()

yystype G4UIparameter::Expression ( void  )

private

Definition at line 319 of file G4UIparameter.cc.

{
    yystype result;
    #ifdef DEBUG
        G4cerr << " Expression()" << G4endl;
    #endif
    result = LogicalORExpression();
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Follow()

G4int G4UIparameter::Follow ( G4int  expect, G4int  ifyes, G4int  ifno  )

private

Definition at line 725 of file G4UIparameter.cc.

{
    G4int c = G4UIpGetc();
    if ( c== expect)
          return ifyes;
    G4UIpUngetc(c);
    return ifno;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4UIpGetc()

G4int G4UIparameter::G4UIpGetc ( void  )

private

Definition at line 736 of file G4UIparameter.cc.

            {                        // emulation of getc() 
    G4int length = parameterRange.length();
    if( bp < length)
        return  parameterRange(bp++);
    else 
        return EOF;
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4UIpUngetc()

G4int G4UIparameter::G4UIpUngetc ( G4int  c )

private

Definition at line 744 of file G4UIparameter.cc.

                     {                 // emulation of ungetc() 
    if (c<0) return -1;
    if (bp >0 && c == parameterRange(bp-1)) {
         --bp;
    } else {
         G4cerr << "G4UIpUngetc() failed." << G4endl;
         G4cerr << "bp="<<bp <<" c="<<c
              << " pR(bp-1)=" << parameterRange(bp-1)
              << G4endl;
         paramERR = 1;
         return -1;
    }
    return 0;
}

Here is the caller graph for this function:

GetCurrentAsDefault()

G4bool G4UIparameter::GetCurrentAsDefault ( ) const

inline

Definition at line 130 of file G4UIparameter.hh.

      { return currentAsDefaultFlag; }

Here is the caller graph for this function:

GetDefaultValue()

G4String G4UIparameter::GetDefaultValue ( ) const

inline

Definition at line 89 of file G4UIparameter.hh.

      { return defaultValue; }

Here is the caller graph for this function:

GetParameterCandidates()

G4String G4UIparameter::GetParameterCandidates ( ) const

inline

Definition at line 118 of file G4UIparameter.hh.

      { return parameterCandidate; }

Here is the caller graph for this function:

GetParameterGuidance()

const G4String G4UIparameter::GetParameterGuidance ( ) const

inline

Definition at line 136 of file G4UIparameter.hh.

      { return parameterGuidance; }

Here is the caller graph for this function:

GetParameterName()

G4String G4UIparameter::GetParameterName ( ) const

inline

Definition at line 109 of file G4UIparameter.hh.

      { return parameterName; }

Here is the caller graph for this function:

GetParameterRange()

G4String G4UIparameter::GetParameterRange ( ) const

inline

Definition at line 103 of file G4UIparameter.hh.

      { return parameterRange; }

Here is the caller graph for this function:

GetParameterType()

char G4UIparameter::GetParameterType ( ) const

inline

Definition at line 91 of file G4UIparameter.hh.

      { return parameterType; }

Here is the caller graph for this function:

IsDouble()

G4int G4UIparameter::IsDouble ( const char *  str )

private

Definition at line 260 of file G4UIparameter.cc.

{
    const char* p= buf;
    switch( *p) {
        case '+':  case '-': ++p;
            if( isdigit(*p) ) {
                 while( isdigit( (G4int)(*p) )) { ++p; }
                 switch ( *p ) {
                     case '\0':    return 1;  //break;
                     case 'E':  case 'e':
                         return ExpectExponent(++p );  //break;
                     case '.':  ++p;
                         if( *p == '\0' )  return 1;
                         if( *p == 'e' || *p =='E' ) return ExpectExponent(++p );
                         if( isdigit(*p) ) {
                             while( isdigit( (G4int)(*p) )) { ++p; }
                             if( *p == '\0' )  return 1;
                             if( *p == 'e' || *p =='E') return ExpectExponent(++p);
                         } else return 0;   break;
                     default: return 0;
                 }
            }
            if( *p == '.' ) { ++p;
                 if( isdigit(*p) ) {
                     while( isdigit( (G4int)(*p) )) { ++p; }
                     if( *p == '\0' )  return 1;
                     if( *p == 'e' || *p =='E')  return ExpectExponent(++p);
                 }
            }
            break;
        case '.':  ++p;
            if( isdigit(*p) ) {
                 while( isdigit( (G4int)(*p) )) { ++p; }
                 if( *p == '\0' )  return 1;
                 if( *p == 'e' || *p =='E' )  return ExpectExponent(++p);
            }    break;
        default: // digit is expected
            if( isdigit(*p) ) {
                 while( isdigit( (G4int)(*p) )) { ++p; }
                 if( *p == '\0' )  return 1;
                 if( *p == 'e' || *p =='E')  return ExpectExponent(++p);
                 if( *p == '.' ) { ++p;
                      if( *p == '\0' )  return 1;
                      if( *p == 'e' || *p =='E')  return ExpectExponent(++p);
                      if( isdigit(*p) ) {
                          while( isdigit( (G4int)(*p) )) { ++p; }
                          if( *p == '\0' )  return 1;
                          if( *p == 'e' || *p =='E') return ExpectExponent(++p);
                      }
                 }
            }
     }
     return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsInt()

G4int G4UIparameter::IsInt ( const char *  str, short  maxDigit  )

private

Definition at line 228 of file G4UIparameter.cc.

{
    const char* p= buf;
    G4int length=0;
    if( *p == '+' || *p == '-') { ++p; }
    if( isdigit( (G4int)(*p) )) {
        while( isdigit( (G4int)(*p) )) { ++p;  ++length; }
        if( *p == '\0' ) {
            if( length > maxDigits) {
                G4cerr <<"digit length exceeds"<<G4endl;
                return 0;
            }
            return 1;
        } else {
            // G4cerr <<"illegal character after int:"<<buf<<G4endl;
        }
    } else {
        // G4cerr <<"illegal int:"<<buf<<G4endl;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsOmittable()

G4bool G4UIparameter::IsOmittable ( ) const

inline

Definition at line 124 of file G4UIparameter.hh.

      { return omittable; }

Here is the caller graph for this function:

List()

void G4UIparameter::List

(

)

Definition at line 98 of file G4UIparameter.cc.

{
  G4cout << G4endl << "Parameter : " << parameterName << G4endl;
  if( ! parameterGuidance.isNull() )
  G4cout << parameterGuidance << G4endl ;
  G4cout << " Parameter type  : " << parameterType << G4endl;
  if(omittable)
  { G4cout << " Omittable       : True" << G4endl; }
  else
  { G4cout << " Omittable       : False" << G4endl; }
  if( currentAsDefaultFlag )
  { G4cout << " Default value   : taken from the current value" << G4endl; }
  else if( ! defaultValue.isNull() )
  { G4cout << " Default value   : " << defaultValue << G4endl; }
  if( ! parameterRange.isNull() )
  G4cout << " Parameter range : " << parameterRange << G4endl;
  if( ! parameterCandidate.isNull() )
  G4cout << " Candidates      : " << parameterCandidate << G4endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

LogicalANDExpression()

yystype G4UIparameter::LogicalANDExpression ( void  )

private

Definition at line 365 of file G4UIparameter.cc.

{
    yystype result;
    yystype p;
    p = EqualityExpression();
    if( token != LOGICALAND)  return p;
    if( p.type == CONSTSTRING || p.type == IDENTIFIER ) {
        G4cerr << "Parameter range: illegal type at '&&'" << G4endl;
        paramERR = 1;
    }
    result.I = p.I;
    while (token == LOGICALAND)
    {
        token = Yylex();
        p = EqualityExpression();
        if( p.type == CONSTSTRING || p.type == IDENTIFIER ) {
            G4cerr << "Parameter range: illegal type at '&&'" << G4endl;
            paramERR = 1;
        }
        switch (p.type) {
            case CONSTINT:
                result.I  *= p.I;
                result.type = CONSTINT;      break;
            case CONSTDOUBLE:
                result.I *= (p.D != 0.0);
                result.type = CONSTINT;      break;
            default:
                G4cerr << "Parameter range: unknown type."<< G4endl;
                paramERR = 1;
        } 
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

LogicalORExpression()

yystype G4UIparameter::LogicalORExpression ( void  )

private

Definition at line 330 of file G4UIparameter.cc.

{
    yystype result;
    yystype p;
    p = LogicalANDExpression();
    if( token != LOGICALOR)  return p;
    if( p.type == CONSTSTRING || p.type == IDENTIFIER ) {
        G4cerr << "Parameter range: illegal type at '||'" << G4endl;
        paramERR = 1;
    }
    result.I = p.I;
    while (token == LOGICALOR) 
    {  
        token = Yylex();
        p = LogicalANDExpression();
        if( p.type == CONSTSTRING || p.type == IDENTIFIER ) {
            G4cerr << "Parameter range: illegal type at '||'" <<G4endl;
            paramERR = 1;
        }
        switch (p.type) {
            case CONSTINT: 
                result.I  += p.I; 
                result.type = CONSTINT;      break;
            case CONSTDOUBLE:
                result.I += (p.D != 0.0); 
                result.type = CONSTINT;      break;
            default: 
                G4cerr << "Parameter range: unknown type"<<G4endl; 
                paramERR = 1;
        } 
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

MultiplicativeExpression()

yystype G4UIparameter::MultiplicativeExpression ( void  )

private

Definition at line 473 of file G4UIparameter.cc.

{   yystype result;
    result = UnaryExpression();
    if( token != '*' && token != '/' && token != '%' ) return result;
    G4cerr << "Parameter range: operator "
         << (char)token
         << " is not supported." << G4endl;
    paramERR = 1;
    return  result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

operator!=()

G4int G4UIparameter::operator!=

(

const G4UIparameter &

right

)

const

Definition at line 93 of file G4UIparameter.cc.

{
  return ( this != &right );
}

operator==()

G4int G4UIparameter::operator==

(

const G4UIparameter &

right

)

const

Definition at line 88 of file G4UIparameter.cc.

{
  return ( this == &right );
}

PrimaryExpression()

yystype G4UIparameter::PrimaryExpression ( void  )

private

Definition at line 522 of file G4UIparameter.cc.

{
     yystype result;
     #ifdef DEBUG
         G4cerr <<" PrimaryExpression" << G4endl;
     #endif
     switch (token) {
         case IDENTIFIER:
              result.S = yylval.S;
              result.type =  token;
              token = Yylex();           break;
         case CONSTINT:
              result.I = yylval.I;
              result.type =  token;
              token= Yylex();            break;
         case CONSTDOUBLE:
              result.D = yylval.D;
              result.type =  token;
              token = Yylex();           break;
         case '(' :
              token= Yylex();
              result = Expression();
              if( token !=  ')'  ) {
                  G4cerr << " ')' expected" << G4endl;
                  paramERR = 1;
              }
              token = Yylex();
                                         break;
         default:
         return result;
    }
    return result; // never executed
}

Here is the call graph for this function:

Here is the caller graph for this function:

RangeCheck()

G4int G4UIparameter::RangeCheck ( const char *  newValue )

private

Definition at line 166 of file G4UIparameter.cc.

                                 {
    yystype result;
    bp = 0;                   // reset buffer pointer for G4UIpGetc()
    std::istringstream is(newValue); 
    char type = toupper( parameterType );
    switch (type) {
        case 'D': { is >> newVal.D; } break;
        case 'I': { is >> newVal.I; } break;
        default:   ;
    }
   // PrintToken();          // Print tokens (consumes all tokens)
   token= Yylex();
   result = Expression();
   if( paramERR == 1 ) return 0;
   if( result.type != CONSTINT) {
      G4cerr << "Illegal Expression in parameter range." << G4endl;
      return 0;
   }
   if ( result.I ) return 1;
   G4cerr << "parameter out of range: "<< parameterRange << G4endl;
   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RelationalExpression()

yystype G4UIparameter::RelationalExpression ( void  )

private

Definition at line 432 of file G4UIparameter.cc.

{ 
    yystype  arg1, arg2;
    G4int operat;
    yystype result;
    #ifdef DEBUG
        G4cerr << " RelationalExpression()" <<G4endl;
    #endif

    arg1 = AdditiveExpression();
    if( token==GT || token==GE || token==LT || token==LE  ) {
        operat = token;
        token =  Yylex();
        arg2 = AdditiveExpression();
        result.I = Eval2( arg1, operat, arg2 );    // semantic action
        result.type = CONSTINT;
        #ifdef DEBUG
            G4cerr << " return  Eval2(): " << G4endl;
        #endif
    } else {
        result = arg1;
    }
    #ifdef DEBUG
       G4cerr <<" return RelationalExpression()" <<G4endl;
    #endif
    return  result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

SetCurrentAsDefault()

void G4UIparameter::SetCurrentAsDefault ( G4bool  val )

inline

Definition at line 128 of file G4UIparameter.hh.

      { currentAsDefaultFlag = val; }

Here is the caller graph for this function:

SetDefaultValue() [1/3]

void G4UIparameter::SetDefaultValue ( const char *  theDefaultValue )

inline

Definition at line 83 of file G4UIparameter.hh.

      { defaultValue = theDefaultValue; }

SetDefaultValue() [2/3]

void G4UIparameter::SetDefaultValue

(

G4int

theDefaultValue

)

Definition at line 118 of file G4UIparameter.cc.

{
  std::ostringstream os;
  os << theDefaultValue;
  defaultValue = os.str();
}

SetDefaultValue() [3/3]

void G4UIparameter::SetDefaultValue

(

G4double

theDefaultValue

)

Definition at line 125 of file G4UIparameter.cc.

{
  std::ostringstream os;
  os << theDefaultValue;
  defaultValue = os.str();
}

Here is the call graph for this function:

SetGuidance()

void G4UIparameter::SetGuidance ( const char *  theGuidance )

inline

Definition at line 138 of file G4UIparameter.hh.

      { parameterGuidance = theGuidance; }

Here is the call graph for this function:

Here is the caller graph for this function:

SetOmittable()

void G4UIparameter::SetOmittable ( G4bool  om )

inline

Definition at line 122 of file G4UIparameter.hh.

      { omittable = om; }

Here is the caller graph for this function:

SetParameterCandidates()

void G4UIparameter::SetParameterCandidates ( const char *  theString )

inline

Definition at line 113 of file G4UIparameter.hh.

      { parameterCandidate = theString; }

Here is the caller graph for this function:

SetParameterName()

void G4UIparameter::SetParameterName ( const char *  theName )

inline

Definition at line 107 of file G4UIparameter.hh.

      { parameterName = theName; }

Here is the caller graph for this function:

SetParameterRange()

void G4UIparameter::SetParameterRange ( const char *  theRange )

inline

Definition at line 95 of file G4UIparameter.hh.

      { parameterRange = theRange; }

Here is the caller graph for this function:

SetWidget()

void G4UIparameter::SetWidget ( G4int  theWidget )

inline

Definition at line 134 of file G4UIparameter.hh.

      { widget = theWidget; }

TokenToStr()

G4String G4UIparameter::TokenToStr ( G4int  token )

private

Here is the caller graph for this function:

TypeCheck()

G4int G4UIparameter::TypeCheck ( const char *  newValue )

private

Definition at line 191 of file G4UIparameter.cc.

{
    G4String newValueString(newValue);
    char type = toupper( parameterType );
    switch(type) {
        case 'D':
            if( IsDouble(newValueString.data())== 0) {
                G4cerr<<newValue<<": double value expected."
                    << G4endl;
                return 0;
             } break;
        case 'I':
            if( IsInt(newValueString.data(),20)== 0) {
                G4cerr<<newValue<<": integer expected."
                    << G4endl;
                return 0;
             } break;
        case 'S': break;
        case 'B':
             newValueString.toUpper();
             if (  newValueString == "Y" || newValueString == "N"
                  ||newValueString == "YES" || newValueString == "NO"
                  ||newValueString == "1"   || newValueString == "0"
                  ||newValueString == "T" || newValueString == "F"
                  ||newValueString == "TRUE" || newValueString == "FALSE") 
                  return 1;
             else {
                    G4cerr<<newValue<<": bool expected." << G4endl;
                    return 0; 
             } 
        default: ;
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

UnaryExpression()

yystype G4UIparameter::UnaryExpression ( void  )

private

Definition at line 485 of file G4UIparameter.cc.

{
    yystype result;
    yystype p;
    #ifdef DEBUG
        G4cerr <<" UnaryExpression"<< G4endl;
    #endif
    switch(token) {
        case '-':
            token = Yylex();
            p = UnaryExpression();
            if (p.type == CONSTINT) {
                result.I = - p.I;
                result.type = CONSTINT;
            }
            if (p.type == CONSTDOUBLE) {
                result.D = - p.D;
                result.type = CONSTDOUBLE;
            }                              break;
        case '+':
            token = Yylex();
            result = UnaryExpression();   break;
        case '!':
            token = Yylex();
            G4cerr << "Parameter range error: "
                 << "operator '!' is not supported (sorry)."
                 << G4endl;
            paramERR = 1;
            result = UnaryExpression();   break;
        default:
            result = PrimaryExpression();
    }
    return result;
}

Here is the call graph for this function:

Here is the caller graph for this function:

Yylex()

tokenNum G4UIparameter::Yylex ( void  )

private

Definition at line 667 of file G4UIparameter.cc.

{               // (returns EOF)
    G4int c;             
    G4String buf;

    while(( c= G4UIpGetc())==' '|| c=='\t' || c== '\n' )
        ;
    if (c== EOF)
        return (tokenNum)EOF;            // KR488 
    buf= "";
    if (isdigit(c) || c== '.') {         // I or D
        do {
             buf += G4String((unsigned char)c);
             c=G4UIpGetc();
         }  while (c=='.' || isdigit(c) || 
                   c=='e' || c=='E' || c=='+' || c=='-');
         G4UIpUngetc(c);
     const char* t = buf;
     std::istringstream is(t);
         if ( IsInt(buf.data(),20) ) {
             is >> yylval.I;
             return  CONSTINT;
         } else 
         if ( IsDouble(buf.data()) ) {
             is >> yylval.D;
             return  CONSTDOUBLE;
         } else {
             G4cerr << buf<<": numeric format error."<<G4endl;
         }
    }
    buf="";
    if (isalpha(c)|| c=='_') {           // IDENTIFIER
        do {
            buf += G4String((unsigned char)c); 
        } while ((c=G4UIpGetc()) != EOF && (isalnum(c) || c=='_'));
        G4UIpUngetc(c);
        if( buf == parameterName ) {
            yylval.S =buf;
            return IDENTIFIER;
        } else {
            G4cerr << buf << " is not a parameter name."<< G4endl;
            paramERR = 1;
       }
    }
    switch (c) {
      case '>':   return (tokenNum) Follow('=', GE,        GT);
      case '<':   return (tokenNum) Follow('=', LE,        LT);
      case '=':   return (tokenNum) Follow('=', EQ,        '=');
      case '!':   return (tokenNum) Follow('=', NE,        '!');
      case '|':   return (tokenNum) Follow('|', LOGICALOR, '|');
      case '&':   return (tokenNum) Follow('&', LOGICALAND, '&');
      default:
          return (tokenNum) c;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Member Data Documentation

bp

G4int G4UIparameter::bp

private

Definition at line 173 of file G4UIparameter.hh.

currentAsDefaultFlag

G4bool G4UIparameter::currentAsDefaultFlag

private

Definition at line 79 of file G4UIparameter.hh.

defaultValue

G4String G4UIparameter::defaultValue

private

Definition at line 74 of file G4UIparameter.hh.

newVal

yystype G4UIparameter::newVal

private

Definition at line 176 of file G4UIparameter.hh.

omittable

G4bool G4UIparameter::omittable

private

Definition at line 78 of file G4UIparameter.hh.

paramERR

G4int G4UIparameter::paramERR

private

Definition at line 177 of file G4UIparameter.hh.

parameterCandidate

G4String G4UIparameter::parameterCandidate

private

Definition at line 76 of file G4UIparameter.hh.

parameterGuidance

G4String G4UIparameter::parameterGuidance

private

Definition at line 73 of file G4UIparameter.hh.

parameterName

G4String G4UIparameter::parameterName

private

Definition at line 72 of file G4UIparameter.hh.

parameterRange

G4String G4UIparameter::parameterRange

private

Definition at line 75 of file G4UIparameter.hh.

parameterType

char G4UIparameter::parameterType

private

Definition at line 77 of file G4UIparameter.hh.

rangeBuf

G4String G4UIparameter::rangeBuf

private

Definition at line 172 of file G4UIparameter.hh.

token

tokenNum G4UIparameter::token

private

Definition at line 174 of file G4UIparameter.hh.

widget

G4int G4UIparameter::widget

private

Definition at line 80 of file G4UIparameter.hh.

yylval

yystype G4UIparameter::yylval

private

Definition at line 175 of file G4UIparameter.hh.

---

The documentation for this class was generated from the following files:

• G4UIparameter.hh
• G4UIparameter.cc