G4UIparameter Class Reference

#include <G4UIparameter.hh>

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

Protected Types
using	tokenNum = G4UItokenNum::tokenNum
using	yystype = G4UItokenNum::yystype

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

Private Attributes
G4int	bp = 0
G4bool	currentAsDefaultFlag = false
G4String	defaultValue
yystype	newVal
G4bool	omittable = false
G4int	paramERR = 0
G4String	parameterCandidate
G4String	parameterGuidance
G4String	parameterName
G4String	parameterRange
char	parameterType = '\0'
G4String	rangeBuf
tokenNum	token = G4UItokenNum::NONE
G4int	widget = 0
yystype	yylval

Detailed Description

Definition at line 45 of file G4UIparameter.hh.

Member Typedef Documentation

tokenNum

using G4UIparameter::tokenNum = G4UItokenNum::tokenNum

protected

Definition at line 135 of file G4UIparameter.hh.

yystype

using G4UIparameter::yystype = G4UItokenNum::yystype

protected

Definition at line 134 of file G4UIparameter.hh.

Constructor & Destructor Documentation

G4UIparameter() [1/3]

G4UIparameter::G4UIparameter

(

)

Definition at line 43 of file G4UIparameter.cc.

{
}

G4UIparameter() [2/3]

G4UIparameter::G4UIparameter

(

char

theType

)

Definition at line 48 of file G4UIparameter.cc.

{
  parameterType        = theType;
}

References parameterType.

G4UIparameter() [3/3]

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

Definition at line 54 of file G4UIparameter.cc.

{
  parameterName = theName;
  parameterType = theType;
  omittable     = theOmittable;
}

References omittable, parameterName, and parameterType.

~G4UIparameter()

G4UIparameter::~G4UIparameter

(

)

Definition at line 63 of file G4UIparameter.cc.

{
}

Member Function Documentation

AdditiveExpression()

yystype G4UIparameter::AdditiveExpression ( void  )

private

Definition at line 625 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;
}

References G4cerr, G4endl, MultiplicativeExpression(), paramERR, and token.

Referenced by RelationalExpression().

Backslash()

G4int G4UIparameter::Backslash ( G4int  c )

private

CandidateCheck()

G4int G4UIparameter::CandidateCheck ( const char *  newValue )

private

Definition at line 191 of file G4UIparameter.cc.

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

References anonymous_namespace{G4MTcoutDestination.cc}::empty, G4cerr, G4endl, and parameterCandidate.

Referenced by CheckNewValue().

CheckNewValue()

G4int G4UIparameter::CheckNewValue

(

const char *

newValue

)

Definition at line 173 of file G4UIparameter.cc.

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

References CandidateCheck(), fParameterOutOfCandidates, fParameterOutOfRange, fParameterUnreadable, parameterCandidate, parameterRange, RangeCheck(), and TypeCheck().

CompareDouble()

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

private

Definition at line 927 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;
}

References EQ, G4cerr, G4endl, GE, GT, LE, LT, NE, and paramERR.

Referenced by Eval2().

CompareInt()

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

private

Definition at line 843 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;
}

References EQ, G4cerr, G4endl, GE, GT, LE, LT, NE, and paramERR.

Referenced by Eval2().

CompareLong()

G4int G4UIparameter::CompareLong ( G4long  arg1, G4int  op, G4long  arg2  )

private

Definition at line 885 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;
}

References EQ, G4cerr, G4endl, GE, GT, LE, LT, NE, and paramERR.

Referenced by Eval2().

EqualityExpression()

yystype G4UIparameter::EqualityExpression ( void  )

private

Definition at line 560 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;
}

References G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, EQ, Eval2(), G4cerr, G4endl, G4UItokenNum::yystype::I, NE, paramERR, RelationalExpression(), token, G4UItokenNum::yystype::type, and Yylex().

Referenced by LogicalANDExpression().

Eval2()

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

private

Definition at line 743 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 'L':
        if(arg2.type == CONSTLONG)
        {
          return CompareLong(newVal.L, op, arg2.L);
        }
        else
        {
          G4cerr << "long int 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);
        }
        else if(arg2.type == CONSTLONG)
        {
          return CompareDouble(newVal.D, op, arg2.L);
        }
        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 'L':
        if(arg1.type == CONSTLONG)
        {
          return CompareLong(arg1.L, op, newVal.L);
        }
        else
        {
          G4cerr << "long int 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);
        }
        else if(arg1.type == CONSTLONG)
        {  // integral promotion
          return CompareDouble(arg1.L, op, newVal.D);
        }
        break;
      default:;
    }
  }
  G4cerr << "no param name is specified at the param range." << G4endl;
  return 0;
}

References CompareDouble(), CompareInt(), CompareLong(), G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, G4UItokenNum::CONSTLONG, G4UItokenNum::yystype::D, G4cerr, G4endl, G4UItokenNum::yystype::I, G4UItokenNum::IDENTIFIER, G4UItokenNum::yystype::L, newVal, paramERR, parameterName, parameterRange, parameterType, and G4UItokenNum::yystype::type.

Referenced by EqualityExpression(), and RelationalExpression().

ExpectExponent()

G4int G4UIparameter::ExpectExponent ( const char *  str )

private

Definition at line 336 of file G4UIparameter.cc.

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

References IsInt().

Referenced by IsDouble().

Expression()

yystype G4UIparameter::Expression ( void  )

private

Definition at line 459 of file G4UIparameter.cc.

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

References G4cerr, G4endl, and LogicalORExpression().

Referenced by PrimaryExpression(), and RangeCheck().

Follow()

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

private

Definition at line 1045 of file G4UIparameter.cc.

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

References G4UIpGetc(), and G4UIpUngetc().

Referenced by Yylex().

G4UIpGetc()

G4int G4UIparameter::G4UIpGetc ( void  )

private

Definition at line 1056 of file G4UIparameter.cc.

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

References bp, and parameterRange.

Referenced by Follow(), and Yylex().

G4UIpUngetc()

G4int G4UIparameter::G4UIpUngetc ( G4int  c )

private

Definition at line 1066 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;
}

References bp, G4cerr, G4endl, paramERR, and parameterRange.

Referenced by Follow(), and Yylex().

GetCurrentAsDefault()

G4bool G4UIparameter::GetCurrentAsDefault ( ) const

inline

Definition at line 118 of file G4UIparameter.hh.

{ return currentAsDefaultFlag; }

References currentAsDefaultFlag.

Referenced by G4UIQt::CreateCommandWidget(), G4UIcommandTree::CreateHTML(), export_G4UIparameter(), G4UIQt::GetCommandList(), G4OpenGLQtViewer::GetCommandParameterList(), and G4UIQt::updateHelpArea().

GetDefaultValue()

const G4String & G4UIparameter::GetDefaultValue ( ) const

inline

Definition at line 84 of file G4UIparameter.hh.

{ return defaultValue; }

References defaultValue.

Referenced by G4UIcmdWithADoubleAndUnit::ConvertToStringWithDefaultUnit(), G4UIcmdWith3VectorAndUnit::ConvertToStringWithDefaultUnit(), G4UIQt::CreateCommandWidget(), G4UIcommandTree::CreateHTML(), G4UIcmdWith3VectorAndUnit::DoIt(), G4UIcmdWithADoubleAndUnit::DoIt(), export_G4UIparameter(), G4UIQt::GetCommandList(), G4OpenGLQtViewer::GetCommandParameterList(), G4UIQt::updateHelpArea(), and G4OpenGLQtViewer::updateViewerPropertiesTableWidget().

GetParameterCandidates()

const G4String & G4UIparameter::GetParameterCandidates ( ) const

inline

Definition at line 109 of file G4UIparameter.hh.

    {
      return parameterCandidate;
    }

References parameterCandidate.

Referenced by G4UIcmdWithADoubleAndUnit::ConvertToStringWithBestUnit(), G4UIcmdWith3VectorAndUnit::ConvertToStringWithBestUnit(), G4UIQt::CreateCommandWidget(), G4UIcommandTree::CreateHTML(), G4UIterminal::ExecuteCommand(), export_G4UIparameter(), G4UIQt::GetCommandList(), G4OpenGLQtViewer::GetCommandParameterList(), and G4UIQt::updateHelpArea().

GetParameterGuidance()

const G4String & G4UIparameter::GetParameterGuidance ( ) const

inline

Definition at line 123 of file G4UIparameter.hh.

    {
      return parameterGuidance;
    }

References parameterGuidance.

Referenced by G4UIQt::CreateCommandWidget(), export_G4UIparameter(), G4UIQt::GetCommandList(), G4OpenGLQtViewer::GetCommandParameterList(), and G4UIQt::updateHelpArea().

GetParameterName()

const G4String & G4UIparameter::GetParameterName ( ) const

inline

Definition at line 100 of file G4UIparameter.hh.

{ return parameterName; }

References parameterName.

Referenced by G4UIQt::CreateCommandWidget(), G4UIQt::CreateCompleterModel(), G4UIcommandTree::CreateHTML(), export_G4UIparameter(), G4UIQt::GetCommandList(), G4OpenGLQtViewer::GetCommandParameterList(), G4UImanager::GetCurrentStringValue(), G4GenericMessenger::Command::SetUnit(), and G4UIQt::updateHelpArea().

GetParameterRange()

const G4String & G4UIparameter::GetParameterRange ( ) const

inline

Definition at line 97 of file G4UIparameter.hh.

{ return parameterRange; }

References parameterRange.

Referenced by G4UIQt::CreateCommandWidget(), G4UIcommandTree::CreateHTML(), export_G4UIparameter(), G4UIQt::GetCommandList(), G4OpenGLQtViewer::GetCommandParameterList(), and G4UIQt::updateHelpArea().

GetParameterType()

char G4UIparameter::GetParameterType ( ) const

inline

Definition at line 85 of file G4UIparameter.hh.

{ return parameterType; }

References parameterType.

Referenced by G4UIQt::CreateCommandWidget(), G4UIcommandTree::CreateHTML(), export_G4UIparameter(), G4UIQt::GetCommandList(), G4OpenGLQtViewer::GetCommandParameterList(), G4UIQt::IsGUICommand(), and G4UIQt::updateHelpArea().

IsDouble()

G4int G4UIparameter::IsDouble ( const char *  str )

private

Definition at line 346 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;
}

References ExpectExponent().

Referenced by TypeCheck(), and Yylex().

IsInt()

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

private

Definition at line 298 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;
}

References G4cerr, and G4endl.

Referenced by ExpectExponent(), TypeCheck(), and Yylex().

IsOmittable()

G4bool G4UIparameter::IsOmittable ( ) const

inline

Definition at line 115 of file G4UIparameter.hh.

{ return omittable; }

References omittable.

Referenced by G4UIcmdWithADoubleAndUnit::ConvertToStringWithDefaultUnit(), G4UIcmdWith3VectorAndUnit::ConvertToStringWithDefaultUnit(), G4UIQt::CreateCommandWidget(), G4UIQt::CreateCompleterModel(), G4UIcommandTree::CreateHTML(), export_G4UIparameter(), G4UIQt::GetCommandList(), G4OpenGLQtViewer::GetCommandParameterList(), G4GenericMessenger::Command::SetUnit(), and G4UIQt::updateHelpArea().

List()

void G4UIparameter::List

(

)

Definition at line 80 of file G4UIparameter.cc.

{
  G4cout << G4endl << "Parameter : " << parameterName << G4endl;
  if(!parameterGuidance.empty())
    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.empty())
  {
    G4cout << " Default value   : " << defaultValue << G4endl;
  }
  if(!parameterRange.empty())
    G4cout << " Parameter range : " << parameterRange << G4endl;
  if(!parameterCandidate.empty())
    G4cout << " Candidates      : " << parameterCandidate << G4endl;
}

References currentAsDefaultFlag, defaultValue, G4cout, G4endl, omittable, parameterCandidate, parameterGuidance, parameterName, parameterRange, and parameterType.

Referenced by export_G4UIparameter().

LogicalANDExpression()

yystype G4UIparameter::LogicalANDExpression ( void  )

private

Definition at line 515 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 CONSTLONG:
        result.I *= (p.L != 0L);
        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;
}

References G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, G4UItokenNum::CONSTLONG, G4UItokenNum::CONSTSTRING, G4UItokenNum::yystype::D, EqualityExpression(), G4cerr, G4endl, G4UItokenNum::yystype::I, G4UItokenNum::IDENTIFIER, L, G4UItokenNum::yystype::L, G4UItokenNum::LOGICALAND, paramERR, token, G4UItokenNum::yystype::type, and Yylex().

Referenced by LogicalORExpression().

LogicalORExpression()

yystype G4UIparameter::LogicalORExpression ( void  )

private

Definition at line 470 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 CONSTLONG:
        result.I += (p.L != 0L);
        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;
}

References G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, G4UItokenNum::CONSTLONG, G4UItokenNum::CONSTSTRING, G4UItokenNum::yystype::D, G4cerr, G4endl, G4UItokenNum::yystype::I, G4UItokenNum::IDENTIFIER, L, G4UItokenNum::yystype::L, LogicalANDExpression(), G4UItokenNum::LOGICALOR, paramERR, token, G4UItokenNum::yystype::type, and Yylex().

Referenced by Expression().

MultiplicativeExpression()

yystype G4UIparameter::MultiplicativeExpression ( void  )

private

Definition at line 638 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;
}

References G4cerr, G4endl, paramERR, token, and UnaryExpression().

Referenced by AdditiveExpression().

operator!=()

G4bool G4UIparameter::operator!=

(

const G4UIparameter &

right

)

const

Definition at line 74 of file G4UIparameter.cc.

{
  return (this != &right);
}

operator==()

G4bool G4UIparameter::operator==

(

const G4UIparameter &

right

)

const

Definition at line 68 of file G4UIparameter.cc.

{
  return (this == &right);
}

PrimaryExpression()

yystype G4UIparameter::PrimaryExpression ( void  )

private

Definition at line 697 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 CONSTLONG:
      result.L    = yylval.L;
      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
}

References G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, G4UItokenNum::CONSTLONG, G4UItokenNum::yystype::D, Expression(), G4cerr, G4endl, G4UItokenNum::yystype::I, G4UItokenNum::IDENTIFIER, G4UItokenNum::yystype::L, paramERR, G4UItokenNum::yystype::S, token, G4UItokenNum::yystype::type, Yylex(), and yylval.

Referenced by UnaryExpression().

RangeCheck()

G4int G4UIparameter::RangeCheck ( const char *  newValue )

private

Definition at line 216 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;
    case 'L':
      is >> newVal.L;
      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;
}

References bp, G4UItokenNum::CONSTINT, G4UItokenNum::yystype::D, Expression(), G4cerr, G4endl, G4UItokenNum::yystype::I, G4UItokenNum::yystype::L, newVal, paramERR, parameterRange, parameterType, token, G4UItokenNum::yystype::type, and Yylex().

Referenced by CheckNewValue().

RelationalExpression()

yystype G4UIparameter::RelationalExpression ( void  )

private

Definition at line 593 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;
}

References AdditiveExpression(), G4UItokenNum::CONSTINT, Eval2(), G4cerr, G4endl, GE, GT, G4UItokenNum::yystype::I, LE, LT, token, G4UItokenNum::yystype::type, and Yylex().

Referenced by EqualityExpression().

SetCurrentAsDefault()

void G4UIparameter::SetCurrentAsDefault ( G4bool  val )

inline

Definition at line 117 of file G4UIparameter.hh.

{ currentAsDefaultFlag = val; }

References currentAsDefaultFlag.

Referenced by G4UIcmdWithABool::SetParameterName(), G4UIcmdWithADouble::SetParameterName(), G4UIcmdWithADoubleAndUnit::SetParameterName(), G4UIcmdWithALongInt::SetParameterName(), G4UIcmdWithAnInteger::SetParameterName(), G4UIcmdWithAString::SetParameterName(), G4UIcmdWithNucleusLimits::SetParameterName(), G4UIcmdWith3Vector::SetParameterName(), G4UIcmdWith3VectorAndUnit::SetParameterName(), and G4GenericMessenger::Command::SetParameterName().

SetDefaultUnit()

void G4UIparameter::SetDefaultUnit

(

const char *

theDefaultUnit

)

Definition at line 133 of file G4UIparameter.cc.

{
  char type = toupper(parameterType);
  if(type != 'S')
  {
    G4ExceptionDescription ed;
    ed << "This method can be used only for a string-type parameter that is "
          "used to specify a unit.\n"
       << "This parameter <" << parameterName << "> is defined as ";
    switch(type)
    {
      case 'D':
        ed << "double.";
        break;
      case 'I':
        ed << "integer.";
        break;
      case 'L':
        ed << "long int.";
        break;
      case 'B':
        ed << "bool.";
        break;
      default:
        ed << "undefined.";
    }
    G4Exception("G4UIparameter::SetDefaultUnit", "INTERCOM2010", FatalException,
                ed);
  }
  SetDefaultValue(theDefaultUnit);
  SetParameterCandidates(
    G4UIcommand::UnitsList(G4UIcommand::CategoryOf(theDefaultUnit)));
}

References G4UIcommand::CategoryOf(), FatalException, G4Exception(), parameterName, parameterType, SetDefaultValue(), SetParameterCandidates(), and G4UIcommand::UnitsList().

Referenced by G4ScoreQuantityMessenger::FilterCommands(), G4EmExtraParametersMessenger::G4EmExtraParametersMessenger(), G4ScoringMessenger::G4ScoringMessenger(), G4UserPhysicsListMessenger::G4UserPhysicsListMessenger(), and G4ScoreQuantityMessenger::QuantityCommands().

SetDefaultValue() [1/4]

void G4UIparameter::SetDefaultValue ( const char *  theDefaultValue )

inline

Definition at line 70 of file G4UIparameter.hh.

    {
      defaultValue = theDefaultValue;
    }

References defaultValue.

Referenced by G4ScoreQuantityMessenger::FilterCommands(), G4AdjointSimMessenger::G4AdjointSimMessenger(), G4EmExtraParametersMessenger::G4EmExtraParametersMessenger(), G4GeneralParticleSourceMessenger::G4GeneralParticleSourceMessenger(), G4GMocrenMessenger::G4GMocrenMessenger(), G4InteractorMessenger::G4InteractorMessenger(), G4MatScanMessenger::G4MatScanMessenger(), G4OpenGLViewerMessenger::G4OpenGLViewerMessenger(), G4OpticalParametersMessenger::G4OpticalParametersMessenger(), G4ParticleGunMessenger::G4ParticleGunMessenger(), G4PolarizationMessenger::G4PolarizationMessenger(), G4ProcessManagerMessenger::G4ProcessManagerMessenger(), G4ProcessTableMessenger::G4ProcessTableMessenger(), G4RunMessenger::G4RunMessenger(), G4ScoringMessenger::G4ScoringMessenger(), G4UIcontrolMessenger::G4UIcontrolMessenger(), G4UserPhysicsListMessenger::G4UserPhysicsListMessenger(), G4VisCommandGeometrySetColour::G4VisCommandGeometrySetColour(), G4VisCommandGeometrySetDaughtersInvisible::G4VisCommandGeometrySetDaughtersInvisible(), G4VisCommandGeometrySetForceAuxEdgeVisible::G4VisCommandGeometrySetForceAuxEdgeVisible(), G4VisCommandGeometrySetForceCloud::G4VisCommandGeometrySetForceCloud(), G4VisCommandGeometrySetForceLineSegmentsPerCircle::G4VisCommandGeometrySetForceLineSegmentsPerCircle(), G4VisCommandGeometrySetForceSolid::G4VisCommandGeometrySetForceSolid(), G4VisCommandGeometrySetForceWireframe::G4VisCommandGeometrySetForceWireframe(), G4VisCommandGeometrySetLineStyle::G4VisCommandGeometrySetLineStyle(), G4VisCommandGeometrySetLineWidth::G4VisCommandGeometrySetLineWidth(), G4VisCommandGeometrySetVisibility::G4VisCommandGeometrySetVisibility(), G4VisCommandOpen::G4VisCommandOpen(), G4VisCommandSceneAddArrow::G4VisCommandSceneAddArrow(), G4VisCommandSceneAddAxes::G4VisCommandSceneAddAxes(), G4VisCommandSceneAddLine::G4VisCommandSceneAddLine(), G4VisCommandSceneAddLogicalVolume::G4VisCommandSceneAddLogicalVolume(), G4VisCommandSceneAddLogo::G4VisCommandSceneAddLogo(), G4VisCommandSceneAddScale::G4VisCommandSceneAddScale(), G4VisCommandSceneAddText::G4VisCommandSceneAddText(), G4VisCommandSceneAddText2D::G4VisCommandSceneAddText2D(), G4VisCommandSetColour::G4VisCommandSetColour(), G4VisCommandSetTextColour::G4VisCommandSetTextColour(), G4VisCommandSpecify::G4VisCommandSpecify(), G4VisCommandsTouchableSet::G4VisCommandsTouchableSet(), G4VisCommandsViewerSet::G4VisCommandsViewerSet(), G4VisCommandViewerCentreOn::G4VisCommandViewerCentreOn(), G4VisCommandViewerCreate::G4VisCommandViewerCreate(), G4ToolsSGViewer< SG_SESSION, SG_VIEWER >::Messenger::Messenger(), G4ScoreQuantityMessenger::QuantityCommands(), G4UIcmdWith3VectorAndUnit::SetDefaultUnit(), G4UIcmdWithADoubleAndUnit::SetDefaultUnit(), SetDefaultUnit(), G4UIcmdWithAString::SetDefaultValue(), G4UIcmdWithABool::SetDefaultValue(), G4UIcmdWithADouble::SetDefaultValue(), G4UIcmdWithADoubleAndUnit::SetDefaultValue(), G4UIcmdWithAnInteger::SetDefaultValue(), G4GenericMessenger::Command::SetDefaultValue(), G4UIcmdWithALongInt::SetDefaultValue(), G4UIcmdWithNucleusLimits::SetDefaultValue(), G4UIcmdWith3Vector::SetDefaultValue(), and G4UIcmdWith3VectorAndUnit::SetDefaultValue().

SetDefaultValue() [2/4]

void G4UIparameter::SetDefaultValue

(

G4double

theDefaultValue

)

Definition at line 125 of file G4UIparameter.cc.

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

References defaultValue.

SetDefaultValue() [3/4]

void G4UIparameter::SetDefaultValue

(

G4int

theDefaultValue

)

Definition at line 109 of file G4UIparameter.cc.

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

References defaultValue.

SetDefaultValue() [4/4]

void G4UIparameter::SetDefaultValue

(

G4long

theDefaultValue

)

Definition at line 117 of file G4UIparameter.cc.

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

References defaultValue.

SetGuidance()

void G4UIparameter::SetGuidance ( const char *  theGuidance )

inline

Definition at line 127 of file G4UIparameter.hh.

    {
      parameterGuidance = theGuidance;
    }

References parameterGuidance.

Referenced by G4OpenGLViewerMessenger::G4OpenGLViewerMessenger(), G4OpticalParametersMessenger::G4OpticalParametersMessenger(), G4RadioactiveDecayMessenger::G4RadioactiveDecayMessenger(), G4VisCommandGeometrySetColour::G4VisCommandGeometrySetColour(), G4VisCommandGeometrySetDaughtersInvisible::G4VisCommandGeometrySetDaughtersInvisible(), G4VisCommandGeometrySetForceAuxEdgeVisible::G4VisCommandGeometrySetForceAuxEdgeVisible(), G4VisCommandGeometrySetForceCloud::G4VisCommandGeometrySetForceCloud(), G4VisCommandGeometrySetForceLineSegmentsPerCircle::G4VisCommandGeometrySetForceLineSegmentsPerCircle(), G4VisCommandGeometrySetForceSolid::G4VisCommandGeometrySetForceSolid(), G4VisCommandGeometrySetForceWireframe::G4VisCommandGeometrySetForceWireframe(), G4VisCommandGeometrySetLineStyle::G4VisCommandGeometrySetLineStyle(), G4VisCommandGeometrySetLineWidth::G4VisCommandGeometrySetLineWidth(), G4VisCommandGeometrySetVisibility::G4VisCommandGeometrySetVisibility(), G4VisCommandOpen::G4VisCommandOpen(), G4VisCommandSceneAddLogo::G4VisCommandSceneAddLogo(), G4VisCommandSceneAddScale::G4VisCommandSceneAddScale(), G4VisCommandSceneAddText::G4VisCommandSceneAddText(), G4VisCommandSceneAddText2D::G4VisCommandSceneAddText2D(), G4VisCommandSetColour::G4VisCommandSetColour(), G4VisCommandSetTextColour::G4VisCommandSetTextColour(), G4VisCommandSetTouchable::G4VisCommandSetTouchable(), G4VisCommandsViewerSet::G4VisCommandsViewerSet(), G4VisCommandViewerCentreOn::G4VisCommandViewerCentreOn(), and G4VisCommandViewerCreate::G4VisCommandViewerCreate().

SetOmittable()

void G4UIparameter::SetOmittable ( G4bool  om )

inline

Definition at line 114 of file G4UIparameter.hh.

{ omittable = om; }

References G4InuclParticleNames::om, and omittable.

Referenced by G4UIcmdWith3VectorAndUnit::SetDefaultUnit(), G4UIcmdWithADoubleAndUnit::SetDefaultUnit(), G4UIcmdWithABool::SetParameterName(), G4UIcmdWithADouble::SetParameterName(), G4UIcmdWithADoubleAndUnit::SetParameterName(), G4UIcmdWithALongInt::SetParameterName(), G4UIcmdWithAnInteger::SetParameterName(), G4UIcmdWithAString::SetParameterName(), G4UIcmdWithNucleusLimits::SetParameterName(), G4UIcmdWith3Vector::SetParameterName(), G4UIcmdWith3VectorAndUnit::SetParameterName(), and G4GenericMessenger::Command::SetParameterName().

SetParameterCandidates()

void G4UIparameter::SetParameterCandidates ( const char *  theString )

inline

Definition at line 102 of file G4UIparameter.hh.

    {
      parameterCandidate = theString;
    }

References parameterCandidate.

Referenced by G4EmExtraParametersMessenger::G4EmExtraParametersMessenger(), G4EmLowEParametersMessenger::G4EmLowEParametersMessenger(), G4InteractorMessenger::G4InteractorMessenger(), G4MatScanMessenger::G4MatScanMessenger(), G4OpenGLViewerMessenger::G4OpenGLViewerMessenger(), G4OpticalParametersMessenger::G4OpticalParametersMessenger(), G4ParticleGunMessenger::G4ParticleGunMessenger(), G4UIcontrolMessenger::G4UIcontrolMessenger(), G4UserPhysicsListMessenger::G4UserPhysicsListMessenger(), G4VisCommandGeometrySetLineStyle::G4VisCommandGeometrySetLineStyle(), G4VisCommandsViewerSet::G4VisCommandsViewerSet(), G4UIcmdWithAString::SetCandidates(), G4GenericMessenger::Command::SetCandidates(), SetDefaultUnit(), G4UIcmdWith3VectorAndUnit::SetUnitCandidates(), and G4UIcmdWithADoubleAndUnit::SetUnitCandidates().

SetParameterName()

void G4UIparameter::SetParameterName ( const char *  pName )

inline

Definition at line 99 of file G4UIparameter.hh.

{ parameterName = pName; }

References parameterName.

Referenced by G4UIcmdWith3VectorAndUnit::G4UIcmdWith3VectorAndUnit(), G4UIcmdWithADoubleAndUnit::G4UIcmdWithADoubleAndUnit(), G4UIcmdWithABool::SetParameterName(), G4UIcmdWithADouble::SetParameterName(), G4UIcmdWithADoubleAndUnit::SetParameterName(), G4UIcmdWithALongInt::SetParameterName(), G4UIcmdWithAnInteger::SetParameterName(), G4UIcmdWithAString::SetParameterName(), G4UIcmdWithNucleusLimits::SetParameterName(), G4UIcmdWith3Vector::SetParameterName(), G4UIcmdWith3VectorAndUnit::SetParameterName(), and G4GenericMessenger::Command::SetParameterName().

SetParameterRange()

void G4UIparameter::SetParameterRange ( const char *  theRange )

inline

Definition at line 87 of file G4UIparameter.hh.

    {
      parameterRange = theRange;
    }

References parameterRange.

Referenced by G4AdjointSimMessenger::G4AdjointSimMessenger(), G4EmExtraParametersMessenger::G4EmExtraParametersMessenger(), G4GMocrenMessenger::G4GMocrenMessenger(), G4MatScanMessenger::G4MatScanMessenger(), G4RadioactiveDecayMessenger::G4RadioactiveDecayMessenger(), G4RunMessenger::G4RunMessenger(), G4ScoringMessenger::G4ScoringMessenger(), G4UIcontrolMessenger::G4UIcontrolMessenger(), G4UserPhysicsListMessenger::G4UserPhysicsListMessenger(), G4VisCommandsViewerSet::G4VisCommandsViewerSet(), and G4ScoreQuantityMessenger::QuantityCommands().

SetWidget()

void G4UIparameter::SetWidget ( G4int  theWidget )

inline

Definition at line 122 of file G4UIparameter.hh.

{ widget = theWidget; }

References widget.

TypeCheck()

G4int G4UIparameter::TypeCheck ( const char *  newValue )

private

Definition at line 250 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(), 10) == 0)
      {
        G4cerr << newValue << ": integer expected." << G4endl;
        return 0;
      }
      break;
    case 'L':
      if(IsInt(newValueString.data(), 20) == 0)
      {
        G4cerr << newValue << ": long int expected." << G4endl;
        return 0;
      }
      break;
    case 'S':
      break;
    case 'B':
      G4StrUtil::to_upper(newValueString);
      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;
}

References G4cerr, G4endl, IsDouble(), IsInt(), parameterType, and G4StrUtil::to_upper().

Referenced by CheckNewValue().

UnaryExpression()

yystype G4UIparameter::UnaryExpression ( void  )

private

Definition at line 651 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 == CONSTLONG)
      {
        result.L    = -p.L;
        result.type = CONSTLONG;
      }
      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;
}

References G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, G4UItokenNum::CONSTLONG, G4UItokenNum::yystype::D, G4cerr, G4endl, G4UItokenNum::yystype::I, G4UItokenNum::yystype::L, paramERR, PrimaryExpression(), token, G4UItokenNum::yystype::type, UnaryExpression(), and Yylex().

Referenced by MultiplicativeExpression(), and UnaryExpression().

Yylex()

tokenNum G4UIparameter::Yylex ( void  )

private

Definition at line 970 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 += (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 += (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;
  }
}

References G4UItokenNum::CONSTDOUBLE, G4UItokenNum::CONSTINT, G4UItokenNum::yystype::D, EQ, Follow(), G4cerr, G4endl, G4UIpGetc(), G4UIpUngetc(), GE, GT, G4UItokenNum::yystype::I, G4UItokenNum::IDENTIFIER, IsDouble(), IsInt(), LE, G4UItokenNum::LOGICALAND, G4UItokenNum::LOGICALOR, LT, NE, paramERR, parameterName, G4UItokenNum::yystype::S, and yylval.

Referenced by EqualityExpression(), LogicalANDExpression(), LogicalORExpression(), PrimaryExpression(), RangeCheck(), RelationalExpression(), and UnaryExpression().

Field Documentation

bp

G4int G4UIparameter::bp = 0

private

Definition at line 183 of file G4UIparameter.hh.

Referenced by G4UIpGetc(), G4UIpUngetc(), and RangeCheck().

currentAsDefaultFlag

G4bool G4UIparameter::currentAsDefaultFlag = false

private

Definition at line 178 of file G4UIparameter.hh.

Referenced by GetCurrentAsDefault(), List(), and SetCurrentAsDefault().

defaultValue

G4String G4UIparameter::defaultValue

private

Definition at line 173 of file G4UIparameter.hh.

Referenced by GetDefaultValue(), List(), and SetDefaultValue().

newVal

yystype G4UIparameter::newVal

private

Definition at line 186 of file G4UIparameter.hh.

Referenced by Eval2(), and RangeCheck().

omittable

G4bool G4UIparameter::omittable = false

private

Definition at line 177 of file G4UIparameter.hh.

Referenced by G4UIparameter(), IsOmittable(), List(), and SetOmittable().

paramERR

G4int G4UIparameter::paramERR = 0

private

Definition at line 187 of file G4UIparameter.hh.

Referenced by AdditiveExpression(), CompareDouble(), CompareInt(), CompareLong(), EqualityExpression(), Eval2(), G4UIpUngetc(), LogicalANDExpression(), LogicalORExpression(), MultiplicativeExpression(), PrimaryExpression(), RangeCheck(), UnaryExpression(), and Yylex().

parameterCandidate

G4String G4UIparameter::parameterCandidate

private

Definition at line 175 of file G4UIparameter.hh.

Referenced by CandidateCheck(), CheckNewValue(), GetParameterCandidates(), List(), and SetParameterCandidates().

parameterGuidance

G4String G4UIparameter::parameterGuidance

private

Definition at line 172 of file G4UIparameter.hh.

Referenced by GetParameterGuidance(), List(), and SetGuidance().

parameterName

G4String G4UIparameter::parameterName

private

Definition at line 171 of file G4UIparameter.hh.

Referenced by Eval2(), G4UIparameter(), GetParameterName(), List(), SetDefaultUnit(), SetParameterName(), and Yylex().

parameterRange

G4String G4UIparameter::parameterRange

private

Definition at line 174 of file G4UIparameter.hh.

Referenced by CheckNewValue(), Eval2(), G4UIpGetc(), G4UIpUngetc(), GetParameterRange(), List(), RangeCheck(), and SetParameterRange().

parameterType

char G4UIparameter::parameterType = '\0'

private

Definition at line 176 of file G4UIparameter.hh.

Referenced by Eval2(), G4UIparameter(), GetParameterType(), List(), RangeCheck(), SetDefaultUnit(), and TypeCheck().

rangeBuf

G4String G4UIparameter::rangeBuf

private

Definition at line 182 of file G4UIparameter.hh.

token

tokenNum G4UIparameter::token = G4UItokenNum::NONE

private

Definition at line 184 of file G4UIparameter.hh.

Referenced by AdditiveExpression(), EqualityExpression(), LogicalANDExpression(), LogicalORExpression(), MultiplicativeExpression(), PrimaryExpression(), RangeCheck(), RelationalExpression(), and UnaryExpression().

widget

G4int G4UIparameter::widget = 0

private

Definition at line 179 of file G4UIparameter.hh.

Referenced by SetWidget().

yylval

yystype G4UIparameter::yylval

private

Definition at line 185 of file G4UIparameter.hh.

Referenced by PrimaryExpression(), and Yylex().

---

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

• source/intercoms/include/G4UIparameter.hh
• source/intercoms/src/G4UIparameter.cc