G4UIcommand Class Reference

#include <G4UIcommand.hh>

Inheritance diagram for G4UIcommand:

Collaboration diagram for G4UIcommand:

Public Member Functions
	G4UIcommand ()
	G4UIcommand (const char *theCommandPath, G4UImessenger *theMessenger, G4bool tBB=true)
virtual	~G4UIcommand ()
G4int	operator== (const G4UIcommand &right) const
G4int	operator!= (const G4UIcommand &right) const
virtual G4int	DoIt (G4String parameterList)
G4String	GetCurrentValue ()
void	AvailableForStates (G4ApplicationState s1)
void	AvailableForStates (G4ApplicationState s1, G4ApplicationState s2)
void	AvailableForStates (G4ApplicationState s1, G4ApplicationState s2, G4ApplicationState s3)
void	AvailableForStates (G4ApplicationState s1, G4ApplicationState s2, G4ApplicationState s3, G4ApplicationState s4)
void	AvailableForStates (G4ApplicationState s1, G4ApplicationState s2, G4ApplicationState s3, G4ApplicationState s4, G4ApplicationState s5)
G4bool	IsAvailable ()
virtual void	List ()
void	SetRange (const char *rs)
const G4String &	GetRange () const
G4int	GetGuidanceEntries () const
const G4String &	GetGuidanceLine (G4int i) const
const G4String &	GetCommandPath () const
const G4String &	GetCommandName () const
G4int	GetParameterEntries () const
G4UIparameter *	GetParameter (G4int i) const
std::vector< G4ApplicationState > *	GetStateList ()
G4UImessenger *	GetMessenger () const
void	SetParameter (G4UIparameter *const newParameter)
void	SetGuidance (const char *aGuidance)
const G4String	GetTitle () const
void	SetToBeBroadcasted (G4bool val)
G4bool	ToBeBroadcasted () const
void	SetToBeFlushed (G4bool val)
G4bool	ToBeFlushed () const
void	SetWorkerThreadOnly (G4bool val=true)
G4bool	IsWorkerThreadOnly () const

Static Public Member Functions
static G4String	ConvertToString (G4bool boolVal)
static G4String	ConvertToString (G4int intValue)
static G4String	ConvertToString (G4double doubleValue)
static G4String	ConvertToString (G4double doubleValue, const char *unitName)
static G4String	ConvertToString (G4ThreeVector vec)
static G4String	ConvertToString (G4ThreeVector vec, const char *unitName)
static G4bool	ConvertToBool (const char *st)
static G4int	ConvertToInt (const char *st)
static G4double	ConvertToDouble (const char *st)
static G4double	ConvertToDimensionedDouble (const char *st)
static G4ThreeVector	ConvertTo3Vector (const char *st)
static G4ThreeVector	ConvertToDimensioned3Vector (const char *st)
static G4double	ValueOf (const char *unitName)
static G4String	CategoryOf (const char *unitName)
static G4String	UnitsList (const char *unitCategory)

Protected Member Functions
G4int	CheckNewValue (const char *newValue)

Protected Attributes
G4bool	toBeBroadcasted
G4bool	toBeFlushed
G4bool	workerThreadOnly

Private Member Functions
void	G4UIcommandCommonConstructorCode (const char *theCommandPath)
G4int	TypeCheck (const char *t)
G4int	RangeCheck (const char *t)
G4int	IsInt (const char *str, short maxLength)
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 (G4double arg1, G4int op, G4double arg2)
tokenNum	Yylex (void)
unsigned	IndexOf (const char *)
unsigned	IsParameter (const char *)
G4int	G4UIpGetc (void)
G4int	G4UIpUngetc (G4int c)
G4int	Backslash (G4int c)
G4int	Follow (G4int expect, G4int ifyes, G4int ifno)
G4String	TokenToStr (G4int token)
void	PrintToken (void)

Private Attributes
G4UImessenger *	messenger
G4String	commandPath
G4String	commandName
G4String	rangeString
std::vector< G4UIparameter * >	parameter
std::vector< G4String >	commandGuidance
std::vector< G4ApplicationState >	availabelStateList
G4String	rangeBuf
G4int	bp
tokenNum	token
yystype	yylval
std::vector< yystype >	newVal
G4int	paramERR

Detailed Description

Definition at line 51 of file G4UIcommand.hh.

Constructor & Destructor Documentation

G4UIcommand() [1/2]

G4UIcommand::G4UIcommand

(

)

Definition at line 41 of file G4UIcommand.cc.

  : messenger(0), toBeBroadcasted(false), toBeFlushed(false), workerThreadOnly(false),
    bp(0), token(IDENTIFIER), paramERR(0)
{
}

G4UIcommand() [2/2]

G4UIcommand::G4UIcommand	(	const char *	theCommandPath,
		G4UImessenger *	theMessenger,
		G4bool	tBB = true
	)

Definition at line 47 of file G4UIcommand.cc.

:messenger(theMessenger),toBeBroadcasted(tBB),toBeFlushed(false), workerThreadOnly(false),
token(IDENTIFIER),paramERR(0)
{
  G4String comStr = theCommandPath;
  if(!theMessenger)
  { // this must be a directory
    if(comStr(comStr.length()-1)!='/')
    {
      G4cerr << "G4UIcommand Warning : " << G4endl;
      G4cerr << "  <" << theCommandPath << "> must be a directory." << G4endl;
      G4cerr << "  '/' is appended." << G4endl;
      comStr += "/";
    }
  }
  G4UIcommandCommonConstructorCode (comStr);
  G4String nullString;
  availabelStateList.clear();
  availabelStateList.push_back(G4State_PreInit);
  availabelStateList.push_back(G4State_Init);
  availabelStateList.push_back(G4State_Idle);
  availabelStateList.push_back(G4State_GeomClosed);
  availabelStateList.push_back(G4State_EventProc);
  availabelStateList.push_back(G4State_Abort);
}

Here is the call graph for this function:

~G4UIcommand()

G4UIcommand::~G4UIcommand ( )

virtual

Definition at line 99 of file G4UIcommand.cc.

{
  G4UImanager* fUImanager = G4UImanager::GetUIpointer();
  if(fUImanager) fUImanager->RemoveCommand(this);
  
  G4int n_parameterEntry = parameter.size();
  for( G4int i_thParameter=0; i_thParameter < n_parameterEntry; i_thParameter++ )
  { delete parameter[i_thParameter]; }
  parameter.clear();
}

Here is the call graph for this function:

Member Function Documentation

AdditiveExpression()

yystype G4UIcommand::AdditiveExpression ( void  )

private

Definition at line 815 of file G4UIcommand.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:

AvailableForStates() [1/5]

void G4UIcommand::AvailableForStates

(

G4ApplicationState

s1

)

Definition at line 239 of file G4UIcommand.cc.

{
  availabelStateList.clear();
  availabelStateList.push_back(s1);
}

AvailableForStates() [2/5]

void G4UIcommand::AvailableForStates	(	G4ApplicationState	s1,
		G4ApplicationState	s2
	)

Definition at line 245 of file G4UIcommand.cc.

{
  availabelStateList.clear();
  availabelStateList.push_back(s1);
  availabelStateList.push_back(s2);
}

AvailableForStates() [3/5]

void G4UIcommand::AvailableForStates	(	G4ApplicationState	s1,
		G4ApplicationState	s2,
		G4ApplicationState	s3
	)

Definition at line 253 of file G4UIcommand.cc.

{
  availabelStateList.clear();
  availabelStateList.push_back(s1);
  availabelStateList.push_back(s2);
  availabelStateList.push_back(s3);
}

AvailableForStates() [4/5]

void G4UIcommand::AvailableForStates	(	G4ApplicationState	s1,
		G4ApplicationState	s2,
		G4ApplicationState	s3,
		G4ApplicationState	s4
	)

Definition at line 263 of file G4UIcommand.cc.

{
  availabelStateList.clear();
  availabelStateList.push_back(s1);
  availabelStateList.push_back(s2);
  availabelStateList.push_back(s3);
  availabelStateList.push_back(s4);
}

AvailableForStates() [5/5]

void G4UIcommand::AvailableForStates	(	G4ApplicationState	s1,
		G4ApplicationState	s2,
		G4ApplicationState	s3,
		G4ApplicationState	s4,
		G4ApplicationState	s5
	)

Definition at line 275 of file G4UIcommand.cc.

{
  availabelStateList.clear();
  availabelStateList.push_back(s1);
  availabelStateList.push_back(s2);
  availabelStateList.push_back(s3);
  availabelStateList.push_back(s4);
  availabelStateList.push_back(s5);
}

Backslash()

G4int G4UIcommand::Backslash ( G4int  c )

private

Here is the caller graph for this function:

CategoryOf()

G4String G4UIcommand::CategoryOf ( const char *  unitName )

static

Definition at line 315 of file G4UIcommand.cc.

{
   return G4UnitDefinition::GetCategory(unitName);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CheckNewValue()

G4int G4UIcommand::CheckNewValue ( const char *  newValue )

protected

Definition at line 496 of file G4UIcommand.cc.

{
   yystype result;
   // if( TypeCheck(newValue) == 0 ) return 1;
   if( ! rangeString.isNull() )
   { if( RangeCheck(newValue) == 0 ) return fParameterOutOfRange; }
   return 0;  // succeeded
}

Here is the call graph for this function:

Here is the caller graph for this function:

CompareDouble()

G4int G4UIcommand::CompareDouble ( G4double  arg1, G4int  op, G4double  arg2  )

private

Definition at line 996 of file G4UIcommand.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 G4UIcommand::CompareInt ( G4int  arg1, G4int  op, G4int  arg2  )

private

Definition at line 971 of file G4UIcommand.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:

ConvertTo3Vector()

G4ThreeVector G4UIcommand::ConvertTo3Vector ( const char *  st )

static

Definition at line 463 of file G4UIcommand.cc.

{
  G4double vx;
  G4double vy;
  G4double vz;
  std::istringstream is(st);
  is >> vx >> vy >> vz;
  return G4ThreeVector(vx,vy,vz);
}

Here is the caller graph for this function:

ConvertToBool()

G4bool G4UIcommand::ConvertToBool ( const char *  st )

static

Definition at line 425 of file G4UIcommand.cc.

{
  G4String v = st;
  v.toUpper();
  G4bool vl = false;
  if( v=="Y" || v=="YES" || v=="1" || v=="T" || v=="TRUE" )
  { vl = true; }
  return vl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConvertToDimensioned3Vector()

G4ThreeVector G4UIcommand::ConvertToDimensioned3Vector ( const char *  st )

static

Definition at line 473 of file G4UIcommand.cc.

{
  G4double vx;
  G4double vy;
  G4double vz;
  char unts[30];
  std::istringstream is(st);
  is >> vx >> vy >> vz >> unts;
  G4String unt = unts;
  G4double uv = ValueOf(unt);
  return G4ThreeVector(vx*uv,vy*uv,vz*uv);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConvertToDimensionedDouble()

G4double G4UIcommand::ConvertToDimensionedDouble ( const char *  st )

static

Definition at line 451 of file G4UIcommand.cc.

{
  G4double vl;
  char unts[30];

  std::istringstream is(st);
  is >> vl >> unts;
  G4String unt = unts;

  return (vl*ValueOf(unt));
}

Here is the call graph for this function:

Here is the caller graph for this function:

ConvertToDouble()

G4double G4UIcommand::ConvertToDouble ( const char *  st )

static

Definition at line 443 of file G4UIcommand.cc.

{
  G4double vl;
  std::istringstream is(st);
  is >> vl;
  return vl;
}

Here is the caller graph for this function:

ConvertToInt()

G4int G4UIcommand::ConvertToInt ( const char *  st )

static

Definition at line 435 of file G4UIcommand.cc.

{
  G4int vl;
  std::istringstream is(st);
  is >> vl;
  return vl;
}

Here is the caller graph for this function:

ConvertToString() [1/6]

G4String G4UIcommand::ConvertToString ( G4bool  boolVal )

static

Definition at line 371 of file G4UIcommand.cc.

{
  G4String vl = "0";
  if(boolVal) vl = "1";
  return vl;
}

ConvertToString() [2/6]

G4String G4UIcommand::ConvertToString ( G4int  intValue )

static

Definition at line 378 of file G4UIcommand.cc.

{
  std::ostringstream os;
  os << intValue;
  G4String vl = os.str();
  return vl;
}

ConvertToString() [3/6]

G4String G4UIcommand::ConvertToString ( G4double  doubleValue )

static

Definition at line 386 of file G4UIcommand.cc.

{
  std::ostringstream os;
  os << doubleValue;
  G4String vl = os.str();
  return vl;
}

ConvertToString() [4/6]

G4String G4UIcommand::ConvertToString ( G4double  doubleValue, const char *  unitName  )

static

Definition at line 394 of file G4UIcommand.cc.

{
  G4String unt = unitName;
  G4double uv = ValueOf(unitName);

  std::ostringstream os;
  os << doubleValue/uv << " " << unitName;
  G4String vl = os.str();
  return vl;
}

Here is the call graph for this function:

ConvertToString() [5/6]

G4String G4UIcommand::ConvertToString ( G4ThreeVector  vec )

static

Definition at line 405 of file G4UIcommand.cc.

{
  std::ostringstream os;
  os << vec.x() << " " << vec.y() << " " << vec.z();
  G4String vl = os.str();
  return vl;
}

Here is the call graph for this function:

ConvertToString() [6/6]

G4String G4UIcommand::ConvertToString ( G4ThreeVector  vec, const char *  unitName  )

static

Definition at line 413 of file G4UIcommand.cc.

{
  G4String unt = unitName;
  G4double uv = ValueOf(unitName);

  std::ostringstream os;
  os << vec.x()/uv << " " << vec.y()/uv << " " << vec.z()/uv
     << " " << unitName;
  G4String vl = os.str();
  return vl;
}

Here is the call graph for this function:

DoIt()

G4int G4UIcommand::DoIt ( G4String  parameterList )

virtual

Reimplemented in G4UIcmdWith3VectorAndUnit, and G4UIcmdWithADoubleAndUnit.

Definition at line 122 of file G4UIcommand.cc.

{
  G4String correctParameters;
  G4int n_parameterEntry = parameter.size();
  if( n_parameterEntry != 0 )
  {
    G4String aToken;
    G4String correctToken;
    G4Tokenizer parameterToken( parameterList );
    for( G4int i_thParameter=0; i_thParameter<n_parameterEntry; i_thParameter++ )
    {
      if(i_thParameter > 0)
      {
        correctParameters.append(" ");
      }
      aToken = parameterToken();
      if( aToken.length()>0 && aToken(0)=='"' )
      {
        while( aToken(aToken.length()-1) != '"'
               || ( aToken.length()==1 && aToken(0)=='"' ))
        {
          G4String additionalToken = parameterToken();
          if( additionalToken.isNull() )
          { return fParameterUnreadable+i_thParameter; }
          aToken += " ";
          aToken += additionalToken;
        }
      }
      else if(i_thParameter==n_parameterEntry-1 && parameter[i_thParameter]->GetParameterType()=='s')
      {
        G4String anotherToken;
        while(!((anotherToken=parameterToken()).isNull()))
        {
          G4int idxs = anotherToken.index("#");
          if(idxs==G4int(std::string::npos))
          {
            aToken += " ";
            aToken += anotherToken;
          }
          else if(idxs>0)
          {
            aToken += " ";
            aToken += anotherToken(0,idxs);
            break;
          }
          else
          { break; }
        }
      }

      if( aToken.isNull() || aToken == "!" )
      {
        if(parameter[i_thParameter]->IsOmittable())
        { 
          if(parameter[i_thParameter]->GetCurrentAsDefault())
          {
            G4Tokenizer cvSt(messenger->GetCurrentValue(this));
            G4String parVal;
            for(G4int ii=0;ii<i_thParameter;ii++)
            {
          parVal = cvSt();
          if (parVal(0)=='"')
        {
          while( parVal(parVal.length()-1) != '"' )
            {
              G4String additionalToken = cvSt();
              if( additionalToken.isNull() )
            { return fParameterUnreadable+i_thParameter; }
              parVal += " ";
              parVal += additionalToken;
            }
        }
        }
        G4String aCVToken = cvSt();
        if (aCVToken(0)=='"')
        {
          while( aCVToken(aCVToken.length()-1) != '"' )
          {
        G4String additionalToken = cvSt();
        if( additionalToken.isNull() )
        { return fParameterUnreadable+i_thParameter; }
        aCVToken += " ";
        aCVToken += additionalToken;
          }
          // aCVToken.strip(G4String::both,'"');
        }
            correctParameters.append(aCVToken);
          }
          else
          { correctParameters.append(parameter[i_thParameter]->GetDefaultValue()); }
        }
        else
        { return fParameterUnreadable+i_thParameter; }
      }
      else
      {
        G4int stat = parameter[i_thParameter]->CheckNewValue( aToken );
        if(stat) return stat+i_thParameter;
        correctParameters.append(aToken);
      }
    }
  }

  if(CheckNewValue( correctParameters ))
  { return fParameterOutOfRange+99; }

  if(workerThreadOnly && G4Threading::IsMasterThread()) return 0;

  messenger->SetNewValue( this, correctParameters );
  return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

EqualityExpression()

yystype G4UIcommand::EqualityExpression ( void  )

private

Definition at line 755 of file G4UIcommand.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 G4UIcommand::Eval2 ( yystype  arg1, G4int  op, yystype  arg2  )

private

Definition at line 913 of file G4UIcommand.cc.

{
    char newValtype;
    if( (arg1.type != IDENTIFIER) && (arg2.type != IDENTIFIER)) {
        G4cerr << commandName
             << ": meaningless comparison"
             << G4endl;
        paramERR = 1;
    }

    if( arg1.type == IDENTIFIER) {
        unsigned i = IndexOf( arg1.S );
        newValtype = toupper(parameter[i]->GetParameterType());
        switch ( newValtype ) {
            case 'I': 
                if( arg2.type == CONSTINT ) {
                    return CompareInt( newVal[i].I, op, arg2.I );
                } else {
                    G4cerr << "integer operand expected for "
                         <<  rangeString 
                         << '.' << G4endl;
                } break;
            case 'D':
                if( arg2.type == CONSTDOUBLE ) {
                    return CompareDouble( newVal[i].D, op, arg2.D );
                } else
                if ( arg2.type == CONSTINT ) {  // integral promotion
                    return CompareDouble( newVal[i].D, op, arg2.I );
                } break;
            default: ;
        }
    }
    if( arg2.type == IDENTIFIER) {
        unsigned i = IndexOf( arg2.S );
        newValtype = toupper(parameter[i]->GetParameterType());
        switch ( newValtype ) {
            case 'I': 
                if( arg1.type == CONSTINT ) {
                    return CompareInt( arg1.I, op, newVal[i].I );
                } else {
                    G4cerr << "integer operand expected for "
                         <<  rangeString
                         << '.' << G4endl;
                } break;
            case 'D':
                if( arg1.type == CONSTDOUBLE ) {
                    return CompareDouble( arg1.D, op, newVal[i].D );
                } else
                if ( arg1.type == CONSTINT ) {  // integral promotion
                    return CompareDouble( arg1.I, op, newVal[i].D );
                } break;
            default: ;
        }
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ExpectExponent()

G4int G4UIcommand::ExpectExponent ( const char *  str )

private

Definition at line 573 of file G4UIcommand.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 G4UIcommand::Expression ( void  )

private

Definition at line 673 of file G4UIcommand.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 G4UIcommand::Follow ( G4int  expect, G4int  ifyes, G4int  ifno  )

private

Definition at line 1113 of file G4UIcommand.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:

G4UIcommandCommonConstructorCode()

void G4UIcommand::G4UIcommandCommonConstructorCode ( const char *  theCommandPath )

private

Definition at line 79 of file G4UIcommand.cc.

{ 
  commandPath = theCommandPath;
  commandName = theCommandPath;
  G4int commandNameIndex = commandName.last('/');
  commandName.remove(0,commandNameIndex+1);
#ifdef G4MULTITHREADED
  if(messenger && messenger->CommandsShouldBeInMaster()
     && G4Threading::IsWorkerThread())
  {
    toBeBroadcasted = false;
    G4UImanager::GetMasterUIpointer()->AddNewCommand(this);
  }
  else
  { G4UImanager::GetUIpointer()->AddNewCommand(this); }
#else
  G4UImanager::GetUIpointer()->AddNewCommand(this);
#endif
}

Here is the call graph for this function:

Here is the caller graph for this function:

G4UIpGetc()

G4int G4UIcommand::G4UIpGetc ( void  )

private

Definition at line 1124 of file G4UIcommand.cc.

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

Here is the call graph for this function:

Here is the caller graph for this function:

G4UIpUngetc()

G4int G4UIcommand::G4UIpUngetc ( G4int  c )

private

Definition at line 1132 of file G4UIcommand.cc.

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

Here is the caller graph for this function:

GetCommandName()

const G4String& G4UIcommand::GetCommandName ( ) const

inline

Definition at line 141 of file G4UIcommand.hh.

      { return commandName; }

Here is the caller graph for this function:

GetCommandPath()

const G4String& G4UIcommand::GetCommandPath ( ) const

inline

Definition at line 139 of file G4UIcommand.hh.

      { return commandPath; }

Here is the caller graph for this function:

GetCurrentValue()

G4String G4UIcommand::GetCurrentValue

(

)

Definition at line 234 of file G4UIcommand.cc.

{
  return messenger->GetCurrentValue(this);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetGuidanceEntries()

G4int G4UIcommand::GetGuidanceEntries ( ) const

inline

Definition at line 135 of file G4UIcommand.hh.

      { return commandGuidance.size(); }

Here is the caller graph for this function:

GetGuidanceLine()

const G4String& G4UIcommand::GetGuidanceLine ( G4int  i ) const

inline

Definition at line 137 of file G4UIcommand.hh.

      { return commandGuidance[i]; }

Here is the caller graph for this function:

GetMessenger()

G4UImessenger* G4UIcommand::GetMessenger ( ) const

inline

Definition at line 149 of file G4UIcommand.hh.

      { return messenger; }

GetParameter()

G4UIparameter* G4UIcommand::GetParameter ( G4int  i ) const

inline

Definition at line 145 of file G4UIcommand.hh.

      { return parameter[i]; }

Here is the caller graph for this function:

GetParameterEntries()

G4int G4UIcommand::GetParameterEntries ( ) const

inline

Definition at line 143 of file G4UIcommand.hh.

      { return parameter.size(); }

Here is the caller graph for this function:

GetRange()

const G4String& G4UIcommand::GetRange ( ) const

inline

Definition at line 133 of file G4UIcommand.hh.

      { return rangeString; };

Here is the caller graph for this function:

GetStateList()

std::vector<G4ApplicationState>* G4UIcommand::GetStateList ( )

inline

Definition at line 147 of file G4UIcommand.hh.

      { return &availabelStateList; }

Here is the caller graph for this function:

GetTitle()

const G4String G4UIcommand::GetTitle ( ) const

inline

Definition at line 170 of file G4UIcommand.hh.

      {
      if(commandGuidance.size() == 0)
      { return G4String("...Title not available..."); }
      else
      { return commandGuidance[0]; }
      }

Here is the caller graph for this function:

IndexOf()

unsigned G4UIcommand::IndexOf ( const char *  nam )

private

Definition at line 1022 of file G4UIcommand.cc.

{
    unsigned i;
    G4String pname;
    for( i=0;  i<parameter.size(); i++)
    {
        pname = parameter[i]-> GetParameterName();
        if( pname == nam ) {
            return i;
        }
    }
    paramERR = 1;
    G4cerr << "parameter name:"<<nam<<" not found."<< G4endl;
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsAvailable()

G4bool G4UIcommand::IsAvailable

(

)

Definition at line 289 of file G4UIcommand.cc.

{
  G4bool av = false;
  G4ApplicationState currentState 
   = G4StateManager::GetStateManager()->GetCurrentState();
   
  G4int nState = availabelStateList.size();
  for(G4int i=0;i<nState;i++)
  {
    if(availabelStateList[i]==currentState)
    {
      av = true;
      break;
    }
  }

  return av;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsDouble()

G4int G4UIcommand::IsDouble ( const char *  str )

private

Definition at line 582 of file G4UIcommand.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 G4UIcommand::IsInt ( const char *  str, short  maxLength  )

private

Definition at line 549 of file G4UIcommand.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:

IsParameter()

unsigned G4UIcommand::IsParameter ( const char *  nam )

private

Definition at line 1040 of file G4UIcommand.cc.

{
    G4String pname;
    for(unsigned i=0;  i<parameter.size(); i++)  
    {
        pname = parameter[i]-> GetParameterName();
        if( pname == nam ) return 1;
    }
    return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

IsWorkerThreadOnly()

G4bool G4UIcommand::IsWorkerThreadOnly ( ) const

inline

Definition at line 194 of file G4UIcommand.hh.

    { return workerThreadOnly; }

Here is the call graph for this function:

Here is the caller graph for this function:

List()

void G4UIcommand::List ( )

virtual

Definition at line 348 of file G4UIcommand.cc.

{
  G4cout << G4endl;
  G4cout << G4endl;
  if(commandPath(commandPath.length()-1)!='/')
  { G4cout << "Command " << commandPath << G4endl; }
  if(workerThreadOnly)
  { G4cout << "    ---- available only in worker thread" << G4endl; }
  G4cout << "Guidance :" << G4endl;
  G4int n_guidanceEntry = commandGuidance.size();
  for( G4int i_thGuidance=0; i_thGuidance < n_guidanceEntry; i_thGuidance++ )
  { G4cout << commandGuidance[i_thGuidance] << G4endl; }
  if( ! rangeString.isNull() )
  { G4cout << " Range of parameters : " << rangeString << G4endl; }
  G4int n_parameterEntry = parameter.size();
  if( n_parameterEntry > 0 )
  {
    for( G4int i_thParameter=0; i_thParameter<n_parameterEntry; i_thParameter++ )
    { parameter[i_thParameter]->List(); }
  }
  G4cout << G4endl;
}

Here is the call graph for this function:

Here is the caller graph for this function:

LogicalANDExpression()

yystype G4UIcommand::LogicalANDExpression ( void  )

private

Definition at line 719 of file G4UIcommand.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 G4UIcommand::LogicalORExpression ( void  )

private

Definition at line 684 of file G4UIcommand.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 G4UIcommand::MultiplicativeExpression ( void  )

private

Definition at line 827 of file G4UIcommand.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 G4UIcommand::operator!=

(

const G4UIcommand &

right

)

const

Definition at line 115 of file G4UIcommand.cc.

{
  return ( commandPath != right.GetCommandPath() );
}

Here is the call graph for this function:

operator==()

G4int G4UIcommand::operator==

(

const G4UIcommand &

right

)

const

Definition at line 110 of file G4UIcommand.cc.

{
  return ( commandPath == right.GetCommandPath() );
}

Here is the call graph for this function:

PrimaryExpression()

yystype G4UIcommand::PrimaryExpression ( void  )

private

Definition at line 876 of file G4UIcommand.cc.

{
     yystype result;
     #ifdef DEBUG
         G4cerr <<" primary_exp"<<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:

PrintToken()

void G4UIcommand::PrintToken ( void  )

private

Here is the caller graph for this function:

RangeCheck()

G4int G4UIcommand::RangeCheck ( const char *  t )

private

Definition at line 642 of file G4UIcommand.cc.

                          {
    yystype result;
    char type;
    bp = 0;                 // reset buffer pointer for G4UIpGetc()
    std::istringstream is(t);
    for (unsigned i=0; i< parameter.size(); i++) {
        type= toupper(parameter[i]->GetParameterType());
        switch ( type ) {
            case 'D':  is >> newVal[i].D;  break;
            case 'I':  is >> newVal[i].I;  break;
            case 'S':
            case 'B':
            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: "<< rangeString << G4endl;
   return 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

RelationalExpression()

yystype G4UIcommand::RelationalExpression ( void  )

private

Definition at line 786 of file G4UIcommand.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 code of Eval2(): " << result.I << 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:

SetGuidance()

void G4UIcommand::SetGuidance ( const char *  aGuidance )

inline

Definition at line 161 of file G4UIcommand.hh.

      {
        commandGuidance.push_back( G4String( aGuidance ) );
      }

SetParameter()

void G4UIcommand::SetParameter ( G4UIparameter *const  newParameter )

inline

Definition at line 152 of file G4UIcommand.hh.

      {
  parameter.push_back( newParameter );
  newVal.resize( parameter.size() );
      }

SetRange()

void G4UIcommand::SetRange ( const char *  rs )

inline

Definition at line 125 of file G4UIcommand.hh.

      { rangeString = rs; }

SetToBeBroadcasted()

void G4UIcommand::SetToBeBroadcasted ( G4bool  val )

inline

Definition at line 184 of file G4UIcommand.hh.

    { toBeBroadcasted = val; }

Here is the caller graph for this function:

SetToBeFlushed()

void G4UIcommand::SetToBeFlushed ( G4bool  val )

inline

Definition at line 188 of file G4UIcommand.hh.

    { toBeFlushed = val; }

Here is the caller graph for this function:

SetWorkerThreadOnly()

void G4UIcommand::SetWorkerThreadOnly ( G4bool  val = true )

inline

Definition at line 192 of file G4UIcommand.hh.

    { workerThreadOnly = val; }

Here is the caller graph for this function:

ToBeBroadcasted()

G4bool G4UIcommand::ToBeBroadcasted ( ) const

inline

Definition at line 186 of file G4UIcommand.hh.

    { return toBeBroadcasted; }

Here is the caller graph for this function:

ToBeFlushed()

G4bool G4UIcommand::ToBeFlushed ( ) const

inline

Definition at line 190 of file G4UIcommand.hh.

    { return toBeFlushed; }

TokenToStr()

G4String G4UIcommand::TokenToStr ( G4int  token )

private

Here is the caller graph for this function:

TypeCheck()

G4int G4UIcommand::TypeCheck ( const char *  t )

private

Definition at line 508 of file G4UIcommand.cc.

{
    G4String aNewValue;
    char type;
    std::istringstream is(t);
    for (unsigned i=0; i< parameter.size(); i++) {
        is >> aNewValue;
        type = toupper(parameter[i]->GetParameterType());
        switch ( type ) {
            case 'D':
                if( IsDouble(aNewValue)==0 ){
                    G4cerr << aNewValue << ": double value expected."
                         << G4endl;
                    return 0;
                } break;
            case 'I':
                if( IsInt(aNewValue,20)==0 ){
                    G4cerr <<aNewValue<<": integer expected."
                         <<G4endl;
                     return 0;
                } break;
            case 'S':
                break;
            case 'B':
                aNewValue.toUpper(); 
                if (aNewValue == "Y"   || aNewValue == "N"
                  ||aNewValue == "YES" || aNewValue == "NO"
                  ||aNewValue == "1"   || aNewValue == "0"
                  ||aNewValue == "T"   || aNewValue == "F"
                  ||aNewValue == "TRUE" || aNewValue == "FALSE")
                return 1;
                else return 0; 
                break;
            default:  ;
        }
    }
    return 1;
}

Here is the call graph for this function:

Here is the caller graph for this function:

UnaryExpression()

yystype G4UIcommand::UnaryExpression ( void  )

private

Definition at line 839 of file G4UIcommand.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:

UnitsList()

G4String G4UIcommand::UnitsList ( const char *  unitCategory )

static

Definition at line 320 of file G4UIcommand.cc.

{
  G4String retStr;
  G4UnitsTable& UTbl = G4UnitDefinition::GetUnitsTable();
  size_t i;
  for(i=0;i<UTbl.size();i++)
  { if(UTbl[i]->GetName()==unitCategory) break; }
  if(i==UTbl.size())
  { 
    G4cerr << "Unit category <" << unitCategory << "> is not defined." << G4endl;
    return retStr;
  }
  G4UnitsContainer& UCnt = UTbl[i]->GetUnitsList();
  retStr = UCnt[0]->GetSymbol();
  G4int je = UCnt.size();
  for(G4int j=1;j<je;j++)
  {
    retStr += " ";
    retStr += UCnt[j]->GetSymbol();
  }
  for(G4int k=0;k<je;k++)
  {
    retStr += " ";
    retStr += UCnt[k]->GetName();
  }
  return retStr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

ValueOf()

G4double G4UIcommand::ValueOf ( const char *  unitName )

static

Definition at line 308 of file G4UIcommand.cc.

{
   G4double value = 0.;
   value = G4UnitDefinition::GetValueOf(unitName);
   return value;              
}

Here is the call graph for this function:

Here is the caller graph for this function:

Yylex()

tokenNum G4UIcommand::Yylex ( void  )

private

Definition at line 1055 of file G4UIcommand.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( IsParameter(buf) ) {
            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

availabelStateList

std::vector<G4ApplicationState> G4UIcommand::availabelStateList

private

Definition at line 122 of file G4UIcommand.hh.

bp

G4int G4UIcommand::bp

private

Definition at line 233 of file G4UIcommand.hh.

commandGuidance

std::vector<G4String> G4UIcommand::commandGuidance

private

Definition at line 121 of file G4UIcommand.hh.

commandName

G4String G4UIcommand::commandName

private

Definition at line 118 of file G4UIcommand.hh.

commandPath

G4String G4UIcommand::commandPath

private

Definition at line 117 of file G4UIcommand.hh.

messenger

G4UImessenger* G4UIcommand::messenger

private

Definition at line 116 of file G4UIcommand.hh.

newVal

std::vector<yystype> G4UIcommand::newVal

private

Definition at line 236 of file G4UIcommand.hh.

paramERR

G4int G4UIcommand::paramERR

private

Definition at line 237 of file G4UIcommand.hh.

parameter

std::vector<G4UIparameter*> G4UIcommand::parameter

private

Definition at line 120 of file G4UIcommand.hh.

rangeBuf

G4String G4UIcommand::rangeBuf

private

Definition at line 232 of file G4UIcommand.hh.

rangeString

G4String G4UIcommand::rangeString

private

Definition at line 119 of file G4UIcommand.hh.

toBeBroadcasted

G4bool G4UIcommand::toBeBroadcasted

protected

Definition at line 179 of file G4UIcommand.hh.

toBeFlushed

G4bool G4UIcommand::toBeFlushed

protected

Definition at line 180 of file G4UIcommand.hh.

token

tokenNum G4UIcommand::token

private

Definition at line 234 of file G4UIcommand.hh.

workerThreadOnly

G4bool G4UIcommand::workerThreadOnly

protected

Definition at line 181 of file G4UIcommand.hh.

yylval

yystype G4UIcommand::yylval

private

Definition at line 235 of file G4UIcommand.hh.

---

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

• G4UIcommand.hh
• G4UIcommand.cc