#include <mathp.h>

Collaboration diagram for MathParser:

Classes
class	ErrGeneric

class	MathArg_t

class	MathArgPriv_t

class	MathArgVoid_t

struct	MathFunc_t

class	NameSpace

class	PlugIn

struct	PlugInRegister

class	PlugInVar

class	StaticNameSpace

struct	TokenVal

Public Types
enum	ArgType { AT_PRIVATE, AT_TYPE, AT_ANY, AT_VOID, AT_BOOL, AT_INT, AT_REAL, AT_STRING }

enum	ArgFlag { AF_NONE = 0x0U, AF_OPTIONAL = 0x1U, AF_OPTIONAL_NON_PRESENT = 0x2U, AF_CONST = 0x10U }

enum	Token { ENDOFFILE = -2, UNKNOWNTOKEN = -1, MP_INT = TypedValue::VAR_INT, MP_REAL = TypedValue::VAR_REAL, MP_STRING = TypedValue::VAR_STRING, NUM, NAME, EXP, MULT, DIV, MOD, MINUS, PLUS, GT, GE, EQ, LE, LT, NE, NOT, AND, OR, XOR, OBR, CBR, OPGIN, CPGIN, STMTSEP, ARGSEP, NAMESPACESEP, ASSIGN, LASTTOKEN }

enum	DeclarationModifier { DMOD_UNKNOWN = -1, DMOD_IFNDEF, DMOD_LAST }

typedef MathArgPriv_t< ArgType, AT_TYPE >	MathArgType_t

typedef MathArgPriv_t < TypedValue, AT_ANY >	MathArgAny_t

typedef MathArgPriv_t< bool, AT_BOOL >	MathArgBool_t

typedef MathArgPriv_t< Int, AT_INT >	MathArgInt_t

typedef MathArgPriv_t< Real, AT_REAL >	MathArgReal_t

typedef MathArgPriv_t < std::string, AT_STRING >	MathArgString_t

typedef std::vector< MathArg_t * >	MathArgs

typedef int(*	MathFunc_f )(const MathArgs &args)

typedef int(*	MathFuncTest_f )(const MathArgs &args)

typedef std::map< std::string, NameSpace * >	NameSpaceMap

Public Member Functions
Table &	GetSymbolTable (void) const

void	PutSymbolTable (Table &T)

int	GetLineNumber (void) const

const NameSpaceMap &	GetNameSpaceMap (void) const

	MathParser (const InputStream &strm, Table &t, bool bRedefineVars=false)

	MathParser (Table &t, bool bRedefineVars=false)

	~MathParser (void)

NamedValue *	InsertSym (const char *const s, const Real &v, int redefine=0)

NamedValue *	InsertSym (const char *const s, const Int &v, int redefine=0)

Real	GetLastStmt (Real d=0., Token t=ARGSEP)

Real	GetLastStmt (const InputStream &strm, Real d=0., Token t=ARGSEP)

Real	Get (Real d=0.)

Real	Get (const InputStream &strm, Real d=0.)

TypedValue	Get (const TypedValue &v)

TypedValue	Get (const InputStream &strm, const TypedValue &v)

void	GetForever (std::ostream &out, const char *const sep="\n")

void	GetForever (const InputStream &strm, std::ostream &out, const char *const sep="\n")

int	RegisterPlugIn (const char name, MathParser::PlugIn ()(MathParser &, void ), void *arg)

int	RegisterNameSpace (NameSpace *ns)

NameSpace *	GetNameSpace (const std::string &name) const

bool	bNameValidate (const std::string &s) const

Public Attributes
Table &	table

bool	bRedefineVars

InputStream *	in

Static Public Attributes
static const char	ONE_LINE_REMARK = '#'

Protected Member Functions
void	TokenPush (enum Token t)

int	TokenPop (void)

TypedValue::Type	GetType (const char *const s) const

TypedValue::TypeModifier	GetTypeModifier (const char *const s) const

MathParser::DeclarationModifier	GetDeclarationModifier (const char *const s) const

bool	IsType (const char *const s) const

bool	IsTypeModifier (const char *const s) const

bool	IsDeclarationModifier (const char *const s) const

bool	IsKeyWord (NameSpace ns, const char const s) const

enum Token	GetToken (void)

void	trim_arg (char *const s)

TypedValue	logical (void)

TypedValue	logical (TypedValue d)

TypedValue	logical_int (TypedValue d)

TypedValue	relational (void)

TypedValue	relational (TypedValue d)

TypedValue	relational_int (TypedValue d)

TypedValue	binary (void)

TypedValue	binary (TypedValue d)

TypedValue	binary_int (TypedValue d)

TypedValue	mult (void)

TypedValue	mult (TypedValue d)

TypedValue	mult_int (TypedValue d)

TypedValue	power (void)

TypedValue	power (TypedValue d)

TypedValue	power_int (TypedValue d)

TypedValue	unary (void)

TypedValue	evalfunc (MathParser::NameSpace ns, MathParser::MathFunc_t f)

TypedValue	expr (void)

TypedValue	stmt (void)

TypedValue	stmtlist (void)

TypedValue	readplugin (void)

Protected Attributes
struct MathParser::PlugInRegister *	PlugIns

StaticNameSpace *	defaultNameSpace

NameSpaceMap	nameSpaceMap

std::string	namebuf

TypedValue	value

enum Token	currtoken

std::stack< TokenVal >	TokenStack

Private Member Functions
	MathParser (const MathParser &)

Detailed Description

Definition at line 63 of file mathp.h.

Member Typedef Documentation

typedef MathArgPriv_t<TypedValue, AT_ANY> MathParser::MathArgAny_t

Definition at line 152 of file mathp.h.

typedef MathArgPriv_t<bool, AT_BOOL> MathParser::MathArgBool_t

Definition at line 153 of file mathp.h.

typedef MathArgPriv_t<Int, AT_INT> MathParser::MathArgInt_t

Definition at line 154 of file mathp.h.

typedef MathArgPriv_t<Real, AT_REAL> MathParser::MathArgReal_t

Definition at line 155 of file mathp.h.

typedef std::vector<MathArg_t*> MathParser::MathArgs

Definition at line 158 of file mathp.h.

typedef MathArgPriv_t<std::string, AT_STRING> MathParser::MathArgString_t

Definition at line 156 of file mathp.h.

typedef MathArgPriv_t<ArgType, AT_TYPE> MathParser::MathArgType_t

Definition at line 150 of file mathp.h.

typedef int(* MathParser::MathFunc_f)(const MathArgs &args)

Definition at line 159 of file mathp.h.

typedef int(* MathParser::MathFuncTest_f)(const MathArgs &args)

Definition at line 160 of file mathp.h.

typedef std::map<std::string, NameSpace *> MathParser::NameSpaceMap

Definition at line 351 of file mathp.h.

Member Enumeration Documentation

enum MathParser::ArgFlag

Enumerator
AF_NONE
AF_OPTIONAL
AF_OPTIONAL_NON_PRESENT
AF_CONST

Definition at line 81 of file mathp.h.

                      {
                 AF_NONE                 = 0x0U,
                 AF_OPTIONAL             = 0x1U,
                 AF_OPTIONAL_NON_PRESENT = 0x2U,
                 AF_CONST                = 0x10U
         };

enum MathParser::ArgType

Enumerator
AT_PRIVATE
AT_TYPE
AT_ANY
AT_VOID
AT_BOOL
AT_INT
AT_REAL
AT_STRING

Definition at line 65 of file mathp.h.

                      {
                 /* AT_PRIVATE means only who created that type
                  * is supposed to deal with it (the default);
                  * the MathParser only knows how to deal with
                  * the remaining types */
                 AT_PRIVATE,
 
                 AT_TYPE,
                 AT_ANY,
                 AT_VOID,
                 AT_BOOL,
                 AT_INT,
                 AT_REAL,
                 AT_STRING
         };

enum MathParser::DeclarationModifier

Enumerator
DMOD_UNKNOWN
DMOD_IFNDEF
DMOD_LAST

Definition at line 340 of file mathp.h.

                                  {
                 DMOD_UNKNOWN = -1,
                 DMOD_IFNDEF,
                 DMOD_LAST
         };

enum MathParser::Token

Enumerator
ENDOFFILE
UNKNOWNTOKEN
MP_INT
MP_REAL
MP_STRING
NUM
NAME
EXP
MULT
DIV
MOD
MINUS
PLUS
GT
GE
EQ
LE
LT
NE
NOT
AND
OR
XOR
OBR
CBR
OPGIN
CPGIN
STMTSEP
ARGSEP
NAMESPACESEP
ASSIGN
LASTTOKEN

Definition at line 301 of file mathp.h.

                    {
                 ENDOFFILE = -2,
                 UNKNOWNTOKEN = -1,
         
                 MP_INT = TypedValue::VAR_INT,
                 MP_REAL = TypedValue::VAR_REAL, 
                 MP_STRING = TypedValue::VAR_STRING,     
         
                 NUM,            /* Numero */
                 NAME,           /* Nome */
                 EXP,            /* '^'  : Elevamento a potenza */
                 MULT,           /* '*'  : Moltiplicazione */
                 DIV,            /* '/'  : Divisione */
                 MOD,            /* '%'  : Divisione */
                 MINUS,          /* '-'  : Meno */
                 PLUS,           /* '+'  : Piu' */
                 GT,             /* '>'  : Maggiore di */
                 GE,             /* '>=' : Maggiore o uguale */
                 EQ,             /* '==' : Uguale */
                 LE,             /* '<=' : Minore o uguale */
                 LT,             /* '<'  : Minore di */
                 NE,             /* '!=' : Diverso da */
                 NOT,            /* '!'  : Negazione (operatore logico) */
                 AND,            /* '&&' : AND (operatore logico) */
                 OR,             /* '||' : OR (operatore logico) */
                 XOR,            /* '~|' : XOR, o OR esclusivo (op. logico) */
                 
                 OBR,            /* '('  : Parentesi aperta */
                 CBR,            /* ')'  : Parentesi chiusa */
                 OPGIN,          /* '['  : Apertura di plugin statement */
                 CPGIN,          /* ']'  : Chiusura di plugin statement */
                 STMTSEP,        /* ';'  : Separatore di statements */
                 ARGSEP,         /* ','  : Separatore di argomenti */
                 NAMESPACESEP,   /* '::' : Separatore di namespace */
                 ASSIGN,         /* '='  : Assegnazione */
 
                 LASTTOKEN       
         };

Constructor & Destructor Documentation

MathParser::MathParser ( const MathParser & )

private

MathParser::MathParser	(	const InputStream &	strm,
		Table &	t,
		bool	bRedefineVars = `false`
	)

Definition at line 4266 of file mathp.cc.

References DEBUGCOUTFNAME, defaultNameSpace, MBDYN_EXCEPT_ARGS, RegisterNameSpace(), and MathParser::NameSpace::sGetName().

 : PlugIns(0),
 table(t),
 bRedefineVars(bRedefineVars),
 in(const_cast<InputStream*>(&strm)),
 defaultNameSpace(0),
 value(),
 currtoken(UNKNOWNTOKEN)
 {
         DEBUGCOUTFNAME("MathParser::MathParser");
 
         // namebuf.resize(4);
 
         defaultNameSpace = new StaticNameSpace(&t);
         if (RegisterNameSpace(defaultNameSpace)) {
                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                         std::string("unable to register namespace \"") + defaultNameSpace->sGetName() + "\"");
         }
 
         time_t tm;
         time(&tm);
         srand(tm);
 }

Here is the call graph for this function:

MathParser::MathParser	(	Table &	t,
		bool	bRedefineVars = `false`
	)

Definition at line 4290 of file mathp.cc.

References DEBUGCOUTFNAME, defaultNameSpace, MBDYN_EXCEPT_ARGS, RegisterNameSpace(), and MathParser::NameSpace::sGetName().

 : PlugIns(0),
 table(t),
 bRedefineVars(bRedefineVars),
 in(0),
 defaultNameSpace(0),
 value(),
 currtoken(UNKNOWNTOKEN)
 {
         DEBUGCOUTFNAME("MathParser::MathParser");
 
         // namebuf.resize(4);
 
         defaultNameSpace = new StaticNameSpace(&t);
         if (RegisterNameSpace(defaultNameSpace)) {
                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                         std::string("unable to register namespace \"") + defaultNameSpace->sGetName() + "\"");
         }
 
         time_t tm;
         time(&tm);
         srand(tm);
 }

Here is the call graph for this function:

MathParser::~MathParser ( void )

Definition at line 4385 of file mathp.cc.

References DEBUGCOUTFNAME, MathParser::PlugInRegister::name, nameSpaceMap, MathParser::PlugInRegister::next, PlugIns, SAFEDELETE, and SAFEDELETEARR.

 {
         DEBUGCOUTFNAME("MathParser::~MathParser");
 
         while (PlugIns) {
                 PlugInRegister *next = PlugIns->next;
                 SAFEDELETEARR(PlugIns->name);
                 SAFEDELETE(PlugIns);
                 PlugIns = next;
         }
 
         for (NameSpaceMap::iterator i = nameSpaceMap.begin(); i != nameSpaceMap.end(); ++i) {
                 delete i->second;
         }
 }

Member Function Documentation

TypedValue MathParser::binary ( void )

protected

Definition at line 3403 of file mathp.cc.

References binary_int(), and mult().

Referenced by relational(), and relational_int().

 {
         return binary_int(mult());
 }

Here is the call graph for this function:

TypedValue MathParser::binary ( TypedValue d )

protected

Definition at line 3409 of file mathp.cc.

References binary_int(), and mult().

 {
         return binary_int(mult(d));
 }

Here is the call graph for this function:

TypedValue MathParser::binary_int ( TypedValue d )

protected

Definition at line 3415 of file mathp.cc.

References currtoken, GetToken(), MINUS, mult(), and PLUS.

Referenced by binary().

 {
         while (true) {
                 switch (currtoken) {
                 case PLUS:
                         GetToken();
                         d += mult();
                         break;
 
                 case MINUS:
                         GetToken();
                         d -= mult();
                         break;
 
                 default:
                         return d;
                 }
         }
 }

Here is the call graph for this function:

bool MathParser::bNameValidate ( const std::string & s ) const

Definition at line 3292 of file mathp.cc.

Referenced by module_init(), and NameSpaceDR::Read().

 {
         std::string::const_iterator i = s.begin();
         if (*i != '_' && !isalpha(*i)) {
                 return false;
         }
 
         while (++i != s.end()) {
                 if (*i != '_' && !isalnum(*i)) {
                         return false;
                 }
         }
 
         return true;
 }

TypedValue MathParser::evalfunc	(	MathParser::NameSpace *	ns,
		MathParser::MathFunc_t *	f
	)

protected

Definition at line 3576 of file mathp.cc.

References AF_OPTIONAL, AF_OPTIONAL_NON_PRESENT, MathParser::MathFunc_t::args, ARGSEP, AT_ANY, AT_BOOL, AT_INT, AT_PRIVATE, AT_REAL, AT_STRING, CBR, currtoken, DEBUGCERR, MathParser::MathFunc_t::errmsg, MathParser::NameSpace::EvalFunc(), MathParser::MathFunc_t::fname, TypedValue::GetBool(), TypedValue::GetInt(), TypedValue::GetReal(), TypedValue::GetString(), GetToken(), MBDYN_EXCEPT_ARGS, MathParser::NameSpace::sGetName(), stmtlist(), and MathParser::MathFunc_t::t.

Referenced by expr(), and stmt().

 {
         for (unsigned i = 1; i < f->args.size(); i++) {
                 switch (f->args[i]->Type()) {
                 case MathParser::AT_ANY:
                         if (currtoken == CBR) {
                                 if (!f->args[i]->IsFlag(MathParser::AF_OPTIONAL)) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "argument expected");
                                 }
                                 (*dynamic_cast<MathArgAny_t*>(f->args[i]))() = (*dynamic_cast<MathArgAny_t*>(f->args[i]))();
                                 f->args[i]->SetFlag(MathParser::AF_OPTIONAL_NON_PRESENT);
 
                         } else {
                                 (*dynamic_cast<MathArgAny_t*>(f->args[i]))() = stmtlist();
                         }
                         break;
 
                 case MathParser::AT_BOOL:
                         if (currtoken == CBR) {
                                 if (!f->args[i]->IsFlag(MathParser::AF_OPTIONAL)) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "bool argument expected");
                                 }
                                 (*dynamic_cast<MathArgBool_t*>(f->args[i]))() = (*dynamic_cast<MathArgBool_t*>(f->args[i]))();
                                 f->args[i]->SetFlag(MathParser::AF_OPTIONAL_NON_PRESENT);
 
                         } else {
                                 (*dynamic_cast<MathArgBool_t*>(f->args[i]))() = stmtlist().GetBool();
                         }
                         break;
 
                 case MathParser::AT_INT:
                         if (currtoken == CBR) {
                                 if (!f->args[i]->IsFlag(MathParser::AF_OPTIONAL)) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "integer argument expected");
                                 }
                                 (*dynamic_cast<MathArgInt_t*>(f->args[i]))() = (*dynamic_cast<MathArgInt_t*>(f->args[i]))();
                                 f->args[i]->SetFlag(MathParser::AF_OPTIONAL_NON_PRESENT);
 
                         } else {
                                 (*dynamic_cast<MathArgInt_t*>(f->args[i]))() = stmtlist().GetInt();
                         }
                         break;
 
                 case MathParser::AT_REAL:
                         if (currtoken == CBR) {
                                 if (!f->args[i]->IsFlag(MathParser::AF_OPTIONAL)) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "real argument expected");
                                 }
                                 (*dynamic_cast<MathArgReal_t*>(f->args[i]))() = (*dynamic_cast<MathArgReal_t*>(f->args[i]))();
                                 f->args[i]->SetFlag(MathParser::AF_OPTIONAL_NON_PRESENT);
 
                         } else {
                                 (*dynamic_cast<MathArgReal_t*>(f->args[i]))() = stmtlist().GetReal();
                         }
                         break;
 
                 case MathParser::AT_STRING:
                         if (currtoken == CBR) {
                                 if (!f->args[i]->IsFlag(MathParser::AF_OPTIONAL)) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "string argument expected");
                                 }
                                 (*dynamic_cast<MathArgString_t*>(f->args[i]))() = (*dynamic_cast<MathArgString_t*>(f->args[i]))();
                                 f->args[i]->SetFlag(MathParser::AF_OPTIONAL_NON_PRESENT);
 
                         } else {
                                 (*dynamic_cast<MathArgString_t*>(f->args[i]))() = stmtlist().GetString();
                         }
                         break;
 
                 case MathParser::AT_PRIVATE:
                         /* ignore */
                         break;
 
                 default:
                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
 
                 if (i < f->args.size() - 1) {
                         if (f->args[i + 1]->Type() != AT_PRIVATE) {
                                 switch (currtoken) {
                                 case CBR:
                                         if (!f->args[i + 1]->IsFlag(MathParser::AF_OPTIONAL)) {
                                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                         "mandatory argument expected");
                                         }
                                         break;
 
                                 case ARGSEP:
                                         GetToken();
                                         break;
 
                                 default:
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                 "argument separator expected");
                                 }
                         }
                 }
         }
 
         if (f->t != 0) {
                 if (f->t(f->args)) {
                         DEBUGCERR("error in function "
                                 << ns->sGetName() << "::" << f->fname 
                                 << " " "(msg: " << f->errmsg << ")"
                                 << " in evalfunc()" << std::endl);
                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, f->fname + ": error " + f->errmsg);
                 }
         }
 
         TypedValue val = ns->EvalFunc(f);
 
         return val;
 }

Here is the call graph for this function:

TypedValue MathParser::expr ( void )

protected

Definition at line 3691 of file mathp.cc.

References CBR, CPGIN, currtoken, defaultNameSpace, ENDOFFILE, evalfunc(), MathParser::MathFunc_t::fname, Table::Get(), MathParser::NameSpace::GetFunc(), MathParser::NameSpace::GetTable(), GetToken(), NamedValue::GetVal(), MBDYN_EXCEPT_ARGS, NAME, namebuf, nameSpaceMap, NAMESPACESEP, NUM, OBR, OPGIN, readplugin(), stmtlist(), table, and value.

Referenced by unary().

 {
         if (currtoken == NUM) {
                 GetToken();
                 return value;
         }
 
         if (currtoken == OBR) {
                 GetToken();
                 TypedValue d = stmtlist();
                 if (currtoken != CBR) {
                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "closing parenthesis expected");
                 }
                 GetToken();
                 return d;
         }
 
         if (currtoken == OPGIN) {
                 TypedValue d = readplugin();
                 if (currtoken != CPGIN) {
                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "closing plugin expected");
                 }
                 GetToken();
                 return d;
         }
 
         if (currtoken == NAME) {
                 std::string name(namebuf);
                 MathParser::NameSpace *currNameSpace = defaultNameSpace;
                 Table *currTable = &table;
 
                 GetToken();
                 if (currtoken == NAMESPACESEP) {
                         NameSpaceMap::iterator i = nameSpaceMap.find(name);
                         if (i == nameSpaceMap.end()) {
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                         std::string("unable to find namespace \"") + namebuf + "\"");
                         }
                         currNameSpace = i->second;
                         currTable = currNameSpace->GetTable();
                         GetToken();
                         if (currtoken != NAME) {
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "name expected after namespace");
                         }
                         name += "::";
                         name += namebuf;
                         GetToken();
                 }
 
                 if (currtoken == OBR) {
                         /* in futuro ci potranno essere magari i dati strutturati */
                         MathParser::MathFunc_t* f = currNameSpace->GetFunc(namebuf);
                         if (f == NULL) {
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                         std::string("function \"") + namebuf + "\" not found");
                         }
                         GetToken();
                         TypedValue d = evalfunc(currNameSpace, f);
                         delete f;
                         if (currtoken != CBR) {
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                         std::string("closing parenthesis expected after function \"")
                                         + f->fname + "\" in expr()");
                         }
                         GetToken();
                         return d;
                         
                 } else {
                         NamedValue* v = 0;
                         if (currTable) {
                                 v = currTable->Get(namebuf);
                         }
 
                         if (v != NULL) {
                                 return v->GetVal();
                         }
                 }
 
                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, std::string("unknown name \"") + name + "\"");
         }
 
         /* invalid expr */
         if (currtoken != ENDOFFILE) {
                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "unknown token");
         }
 
         return TypedValue(0.);
 }

Here is the call graph for this function:

Real MathParser::Get ( Real d = 0. )

Definition at line 4496 of file mathp.cc.

References TypedValue::GetReal().

Referenced by Get(), GetForever(), HighParser::GetValue(), DofPlugIn::ReadLabel(), and PrivPlugIn::ReadLabel().

 {
         TypedValue v(d);
         v = Get(v);
         return v.GetReal();
 }

Here is the call graph for this function:

Real MathParser::Get	(	const InputStream &	strm,
		Real	d = `0.`
	)

Definition at line 4504 of file mathp.cc.

References Get(), and TypedValue::GetReal().

 {
         TypedValue v(d);
         v = Get(strm, v);
         return v.GetReal();
 }

Here is the call graph for this function:

TypedValue MathParser::Get ( const TypedValue & v )

Definition at line 4512 of file mathp.cc.

References currtoken, ENDOFFILE, ExpressionElement::Eval(), GetToken(), MBDYN_EXCEPT_ARGS, ExpressionElement::Output(), stmt(), and STMTSEP.

 {
         GetToken();
 #ifdef USE_EE
         ExpressionElement *e = stmt();
         TypedValue vv = e->Eval();
         if (pedantic_out) {
                 std::cout << "Get: \"", e->Output(std::cout) << "\" = " << vv << std::endl;
         }
         delete e;
 #else // ! USE_EE
         TypedValue vv = stmt();
 #endif // ! USE_EE
         if (currtoken != STMTSEP && currtoken != ENDOFFILE) {
                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "statement separator expected");
         }
         return vv;
 }

Here is the call graph for this function:

TypedValue MathParser::Get	(	const InputStream &	strm,
		const TypedValue &	v
	)

Definition at line 4532 of file mathp.cc.

References ARGSEP, currtoken, ExpressionElement::Eval(), GetToken(), in, MBDYN_EXCEPT_ARGS, ExpressionElement::Output(), InputStream::putback(), stmt(), and STMTSEP.

 {
         const InputStream* p = in;
         in = (InputStream*)&strm;
         GetToken();
         TypedValue vv = v;
         if (currtoken != STMTSEP && currtoken != ARGSEP) {
 #ifdef USE_EE
                 ExpressionElement *e = stmt();
                 vv = e->Eval();
                 if (pedantic_out) {
                         std::cout << "Get: \"", e->Output(std::cout) << "\" = " << vv << std::endl;
                 }
                 delete e;
 #else // ! USE_EE
                 vv = stmt();
 #endif // ! USE_EE
         }
         if (currtoken == STMTSEP) {
                 in->putback(';');
 
         } else if (currtoken == ARGSEP) {
                 in->putback(',');
 
         } else {
                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "separator expected");
         }
         in = const_cast<InputStream *>(p);
 
         return vv;
 }

Here is the call graph for this function:

MathParser::DeclarationModifier MathParser::GetDeclarationModifier ( const char *const s ) const

protected

Definition at line 2915 of file mathp.cc.

References DMOD_UNKNOWN, declarationmodifiernames::name, and declarationmodifiernames::type.

Referenced by IsDeclarationModifier(), and stmt().

 {
         for (Int i = 0; DeclarationModifierNames[i].name != NULL; i++) {
                 if (strcmp(s, DeclarationModifierNames[i].name) == 0) {
                         return DeclarationModifierNames[i].type;
                 }
         }
 
         return DMOD_UNKNOWN;
 }

void MathParser::GetForever	(	std::ostream &	out,
		const char *const	sep = `"\n"`
	)

Definition at line 4565 of file mathp.cc.

References currtoken, Get(), and STMTSEP.

Referenced by GetForever(), and main().

 {
         do {
                 TypedValue val(0.);
                 out << Get(val) << sep;
         } while (currtoken == STMTSEP);
 }

Here is the call graph for this function:

void MathParser::GetForever	(	const InputStream &	strm,
		std::ostream &	out,
		const char *const	sep = `"\n"`
	)

Definition at line 4574 of file mathp.cc.

References GetForever(), and in.

 {
         InputStream *p = in;
         in = const_cast<InputStream *>(&strm);
         GetForever(out);
         in = p;
 }

Here is the call graph for this function:

Real MathParser::GetLastStmt	(	Real	d = `0.`,
		Token	t = `ARGSEP`
	)

Definition at line 4402 of file mathp.cc.

References currtoken, ENDOFFILE, ExpressionElement::Eval(), TypedValue::GetReal(), GetToken(), MBDYN_EXCEPT_ARGS, ExpressionElement::Output(), stmtlist(), and STMTSEP.

Referenced by DriveHandler::dGet(), GetEnviron(), and GetLastStmt().

 {
         if (GetToken() == t) {
                 return d;
         }
 
         for (;;) {
 #ifdef USE_EE
                 ExpressionElement *e = stmtlist();
                 d = e->Eval().GetReal();
                 if (pedantic_out) {
                         std::cout << "GetLastStmt: \"", e->Output(std::cout) << "\" = " << d << std::endl;
                 }
                 delete e;
 #else // ! USE_EE
                 d = stmtlist().GetReal();
 #endif // ! USE_EE
                 if (currtoken == ENDOFFILE || currtoken == t) {
                         break;
                 }
                 if (currtoken != STMTSEP) {
                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "statement separator expected");
                 }
         }
 
         return d;
 }

Here is the call graph for this function:

Real MathParser::GetLastStmt	(	const InputStream &	strm,
		Real	d = `0.`,
		Token	t = `ARGSEP`
	)

Definition at line 4431 of file mathp.cc.

References currtoken, GetLastStmt(), in, and UNKNOWNTOKEN.

 {
         const InputStream* save_in = in;
         Token save_currtoken = currtoken;
 
         in = const_cast<InputStream *>(&strm);
         currtoken = UNKNOWNTOKEN;
 
         d = GetLastStmt(d, t);
 
         in = const_cast<InputStream *>(save_in);
         currtoken = save_currtoken;
 
         return d;
 }

Here is the call graph for this function:

int MathParser::GetLineNumber ( void ) const

Definition at line 1943 of file mathp.cc.

References ASSERT, InputStream::GetLineNumber(), and in.

Referenced by MathParser::ErrGeneric::ErrGeneric(), and GetToken().

 {
         ASSERT(in != NULL);
         return in->GetLineNumber();
 }

Here is the call graph for this function:

MathParser::NameSpace * MathParser::GetNameSpace ( const std::string & name ) const

Definition at line 4620 of file mathp.cc.

References nameSpaceMap.

Referenced by DataManager::PopCurrData(), DataManager::PushCurrData(), and PrintSymbolTableDR::Read().

 {
         NameSpaceMap::const_iterator i = nameSpaceMap.find(name);
         if (i == nameSpaceMap.end()) {
                 return 0;
         }
 
         return i->second;
 }

const MathParser::NameSpaceMap & MathParser::GetNameSpaceMap ( void ) const

Definition at line 1984 of file mathp.cc.

References nameSpaceMap.

Referenced by PrintSymbolTableDR::Read().

 {
         return nameSpaceMap;
 }

Table & MathParser::GetSymbolTable ( void ) const

Definition at line 1931 of file mathp.cc.

References table.

Referenced by DataManager::DataManager(), DriveHandler::DriveHandler(), GetEnviron(), mbdyn_program(), InverseSolver::Prepare(), Solver::Prepare(), PrintSymbolTableDR::Read(), and DataManager::SetTime().

 {
         return table;
 }

MathParser::Token MathParser::GetToken ( void )

protected

Definition at line 2960 of file mathp.cc.

References AND, ARGSEP, ASSERT, ASSIGN, c, CBR, CPGIN, currtoken, DIV, ENDOFFILE, InputStream::eof(), EQ, EXP, GE, InputStream::get(), GetLineNumber(), InputStream::GetStream(), GT, in, LE, LT, MBDYN_EXCEPT_ARGS, MINUS, MOD, MULT, NAME, namebuf, NAMESPACESEP, NE, NO_OP, NOT, NUM, OBR, ONE_LINE_REMARK, OPGIN, OR, PLUS, InputStream::putback(), TypedValue::Set(), TypedValue::SetType(), STMTSEP, TokenPop(), UNKNOWNTOKEN, value, TypedValue::VAR_INT, TypedValue::VAR_REAL, TypedValue::VAR_STRING, and XOR.

Referenced by binary_int(), evalfunc(), expr(), Get(), GetLastStmt(), logical_int(), mult_int(), power_int(), readplugin(), relational_int(), stmt(), stmtlist(), and unary().

 {
         ASSERT(in != NULL);
 
         if (TokenPop()) {
                 /* se lo trova! */
                 return currtoken;
         }
 
         int c = 0;
 
 start_parsing:;
         /* skip spaces */
         while ((c = in->get()), isspace(c)) {
                 NO_OP;
         };
 
         if (c == EOF || in->eof()) {
                 return (currtoken = ENDOFFILE);
         }
 
         if (c == ONE_LINE_REMARK) {
                 for (c = in->get(); c != '\n'; c = in->get()) {
                         /* a trailing '\' continues the one-line remark
                          * on the following line
                          * FIXME: are we sure we want this? */
                         if (c == '\\') {
                                 c = in->get();
                                 if (c == '\r') {
                                         c = in->get();
                                 }
                         }
                 }
                 goto start_parsing;
         }
 
         /* number? */
         if (c == '.' || isdigit(c)) {
                 // lot of space...
                 char s[BUFSIZ];
                 bool f = false;
                 unsigned i = 0;
 
                 // FIXME: need to check for overflow
 
                 s[i++] = char(c);
 
                 if (c == '.') {
                         f = true;
                 }
                 while ((c = in->get()) == '.' || isdigit(c)) {
                         s[i++] = char(c);
                         if (c == '.') {
                                 if (f) {
                                         return (currtoken = UNKNOWNTOKEN);
                                 }
                                 f = true;
                         }
                         if (i >= sizeof(s)) {
                                 // buffer about to overflow
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "value too long");
                         }
                 }
                 if (std::strchr("efdgEFDG", c) != 0) {
                         f = true;
                         // use 'e' because strtod only understands 'e' or 'E'
                         s[i++] = 'e';
                         if (i >= sizeof(s)) {
                                 // buffer about to overflow
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "value too long");
                         }
                         if ((c = in->get()) == '-' || c == '+') {
                                 s[i++] = char(c);
                                 if (i >= sizeof(s)) {
                                         // buffer about to overflow
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "value too long");
                                 }
                                 c = in->get();
                         }
                         if (isdigit(c)) {
                                 s[i++] = char(c);
                                 if (i >= sizeof(s)) {
                                         // buffer about to overflow
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "value too long");
                                 }
 
                         } else {
                                 return (currtoken = UNKNOWNTOKEN);
                         }
                         while (isdigit((c = in->get()))) {
                                 s[i++] = char(c);
                                 if (i >= sizeof(s)) {
                                         // buffer about to overflow
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "value too long");
                                 }
                         }
                 }
                 s[i] = '\0';
                 if (in->eof()) {
                         // force EOF because on some archs (e.g. arm) char is unsigned,
                         // thus putback won't restore EOF
                         in->putback(char(c));
                         in->GetStream().setstate(std::ios::eofbit);
                 } else {
                         in->putback(char(c));
                 }
                 char *endptr = 0;
                 if (!f) {
                         value.SetType(TypedValue::VAR_INT);
 #ifdef HAVE_STRTOL
                         errno = 0;
                         long l = strtol(s, &endptr, 10);
                         int save_errno = errno;
                         if (endptr == s || endptr[0] != '\0') {
                                 silent_cerr(" MathParser - unable to parse \"" << s << "\" as integer"
                                         << " at line " << GetLineNumber() << std::endl);
                                 return (currtoken = UNKNOWNTOKEN);
                         }
 
                         if (save_errno == ERANGE) {
                                 // over/under-flow
                                 if (l == LONG_MIN) {
                                         throw ErrGeneric(this,
                                                 MBDYN_EXCEPT_ARGS,
                                                 std::string("integer value ") + std::string(s, endptr - s) + " underflow");
                                 }
 
                                 if (l == LONG_MAX) {
                                         throw ErrGeneric(this,
                                                 MBDYN_EXCEPT_ARGS,
                                                 std::string("integer value ") + std::string(s, endptr - s) + " overflow");
                                 }
 
                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                         }
                         value.Set(Int(l));
 #else /* !HAVE_STRTOL */
                         value.Set(Int(atoi(s)));
 #endif /* !HAVE_STRTOL */
 
                 } else {
                         value.SetType(TypedValue::VAR_REAL);
 #ifdef HAVE_STRTOD
                         errno = 0;
                         double d = strtod(s, &endptr);
                         int save_errno = errno;
                         if (endptr == s || endptr[0] != '\0') {
                                 silent_cerr(" MathParser - unable to parse \"" << s << "\" as real"
                                         << " at line " << GetLineNumber() << std::endl);
                                 return (currtoken = UNKNOWNTOKEN);
                         }
 
                         if (save_errno == ERANGE) {
                                 // over/under-flow
                                 if (std::abs(d) == HUGE_VAL) {
                                         throw ErrGeneric(this,
                                                 MBDYN_EXCEPT_ARGS,
                                                 std::string("real value ") + std::string(s, endptr - s) + " overflow");
                                 }
 
                                 if (d == 0.) {
                                         throw ErrGeneric(this,
                                                 MBDYN_EXCEPT_ARGS,
                                                 std::string("real value ") + std::string(s, endptr - s) + " underflow");
                                 }
 
                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                         }
                         value.Set(Real(d));
 #else /* !HAVE_STRTOD */
                         value.Set(Real(atof(s)));
 #endif /* !HAVE_STRTOD */
                 }
 
                 return (currtoken = NUM);
         }
 
         /* name? */
         if (isalpha(c) || c == '_') {
                 namebuf.clear();
                 namebuf.push_back(char(c));
                 while ((c = in->get())) {
                         if (!(c == '_'
                                 || isalnum(c)
                                 || ((currtoken == NAMESPACESEP) && c == ':')))
                         {
                                 break;
                         }
 
                         namebuf.push_back(char(c));
                 }
                 in->putback(char(c));
                 return (currtoken = NAME);
         }
 
         switch (c) {
         case '^':
                 return (currtoken = EXP);
 
         case '*':
                 return (currtoken = MULT);
 
         case '/':
                 if ((c = in->get()) == '*') {
                         for (c = in->get();; c = in->get()) {
                                 if (c == '*') {
 end_of_comment:;
                                         c = in->get();
                                         if (c == '/') {
                                                 goto start_parsing;
                                         }
                                 } else if (c == '/') {
                                         c = in->get();
                                         if (c == '*') {
                                                 silent_cerr("warning: '/*' "
                                                         "inside a comment at line "
                                                         << GetLineNumber()
                                                         << std::endl);
                                                 goto end_of_comment;
                                         }
                                 }
                         }
 
                 } else {
                         in->putback(char(c));
                         return (currtoken = DIV);
                 }
 
         case '%':
                 return (currtoken = MOD);
 
         case '-':
                 return (currtoken = MINUS);
 
         case '+':
                 return (currtoken = PLUS);
 
         case '>':
                 if ((c = in->get()), c == '=') {
                         return (currtoken = GE);
                 }
                 in->putback(char(c));
                 return (currtoken = GT);
 
         case '=':
                 if ((c = in->get()), c == '=') {
                         return (currtoken = EQ);
                 }
                 in->putback(char(c));
                 return (currtoken = ASSIGN);
 
         case '<':
                 if ((c = in->get()), c == '=') {
                         return (currtoken = LE);
                 }
                 in->putback(char(c));
                 return (currtoken = LT);
 
         case '!':
                 if ((c = in->get()), c == '=') {
                         return (currtoken = NE);
                 }
                 in->putback(char(c));
                 return (currtoken = NOT);
 
         case '&':
                 if ((c = in->get()), c != '&') {
                         return (currtoken = UNKNOWNTOKEN);
                 }
                 return (currtoken = AND);
 
         case '|':
                 if ((c = in->get()), c != '|') {
                         return (currtoken = UNKNOWNTOKEN);
                 }
                 return (currtoken = OR);
 
         case '~':
                 if ((c = in->get()), c != '|') {
                         return (currtoken = UNKNOWNTOKEN);
                 }
                 return (currtoken = XOR);
 
         case '(':
                 return (currtoken = OBR);
 
         case ')':
                 return (currtoken = CBR);
 
         case '[':
                 return (currtoken = OPGIN);
 
         case ']':
                 return (currtoken = CPGIN);
 
         case ';':
                 return (currtoken = STMTSEP);
 
         case ',':
                 return (currtoken = ARGSEP);
 
         case ':':
                 if ((c = in->get()), c != ':') {
                         return (currtoken = UNKNOWNTOKEN);
                 }
                 return (currtoken = NAMESPACESEP);
 
         case '"': {
                 namebuf.clear();
                 while ((c = in->get()) != '"') {
                         if (c == '\\') {
                                 c = in->get();
                                 if (c == '\0') {
                                         return (currtoken = UNKNOWNTOKEN);
                                 }
                                 if (c == EOF || in->eof()) {
                                         return (currtoken = ENDOFFILE);
                                 }
                         }
                         namebuf.push_back(char(c));
                 }
                 value.SetType(TypedValue::VAR_STRING);
                 value.Set(namebuf);
                 return (currtoken = NUM);
                 }
 
         default:
                 return (currtoken = UNKNOWNTOKEN);
         }
 }

Here is the call graph for this function:

TypedValue::Type MathParser::GetType ( const char *const s ) const

protected

Definition at line 2891 of file mathp.cc.

References TypeName_t::name, TypeName_t::type, and TypedValue::VAR_UNKNOWN.

Referenced by IsType(), and stmt().

 {
         for (Int i = 0; TypeNames[i].name != NULL; i++) {
                 if (strcmp(s, TypeNames[i].name) == 0) {
                         return TypeNames[i].type;
                 }
         }
 
         return TypedValue::VAR_UNKNOWN;
 }

TypedValue::TypeModifier MathParser::GetTypeModifier ( const char *const s ) const

protected

Definition at line 2903 of file mathp.cc.

References TypedValue::MOD_UNKNOWN, typemodifiernames::name, and typemodifiernames::type.

Referenced by IsTypeModifier(), and stmt().

 {
         for (Int i = 0; TypeModifierNames[i].name != NULL; i++) {
                 if (strcmp(s, TypeModifierNames[i].name) == 0) {
                         return TypeModifierNames[i].type;
                 }
         }
 
         return TypedValue::MOD_UNKNOWN;
 }

NamedValue * MathParser::InsertSym	(	const char *const	s,
		const Real &	v,
		int	redefine = `0`
	)

Definition at line 4315 of file mathp.cc.

References Table::Get(), NamedValue::GetName(), NamedValue::IsVar(), MBDYN_EXCEPT_ARGS, Table::Put(), and table.

Referenced by DataManager::InsertSym().

 {
         /* cerco la variabile */
         NamedValue* var = table.Get(s);
 
         if (var == 0) {
                 /* Se non c'e' la inserisco */
                 var = table.Put(s, TypedValue(v));
         } else {
                 /* altrimenti, se la posso ridefinire, mi limito
                  * ad assegnarle il nuovo valore */
                 if (redefine) {
                         if (var->IsVar()) {
                                 dynamic_cast<Var *>(var)->SetVal(TypedValue(v));
                         } else {
                                 throw MathParser::ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                         std::string("cannot redefine non-var named value \"") + var->GetName() + "\"");
                         }
 
                 } else {
                         /* altrimenti la reinserisco, cosi' 
                          * da provocare l'errore di table */
                         var = table.Put(s, TypedValue(v));
                 }
         }
 
         if (var == NULL) {
                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, std::string("error while adding real var \"") + s + "\"");
         }
 
         return var;
 }

Here is the call graph for this function:

NamedValue * MathParser::InsertSym	(	const char *const	s,
		const Int &	v,
		int	redefine = `0`
	)

Definition at line 4349 of file mathp.cc.

References Table::Get(), NamedValue::GetName(), NamedValue::IsVar(), MBDYN_EXCEPT_ARGS, Table::Put(), and table.

 {
         /* cerco la variabile */
         NamedValue* var = table.Get(s);
 
         if (var == NULL) {
                 /* Se non c'e' la inserisco */
                 var = table.Put(s, TypedValue(v));
 
         } else {
                 /* altrimenti, se la posso ridefinire, mi limito
                  * ad assegnarle il nuovo valore */
                 if (redefine) {
                         if (var->IsVar()) {
                                 dynamic_cast<Var *>(var)->SetVal(TypedValue(v));
 
                         } else {
                                 throw MathParser::ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                         std::string("cannot redefine non-var named value \"") + var->GetName() + "\"");
                         }
 
                 } else {
                         /* altrimenti la reinserisco, cosi' 
                          * da provocare l'errore di table */
                         var = table.Put(s, TypedValue(v));
                 }
         }
 
         if (var == NULL) {
                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                         std::string("error while adding integer var \"") + s + "\"");
         }
 
         return var;
 }

Here is the call graph for this function:

bool MathParser::IsDeclarationModifier ( const char *const s ) const

protected

Definition at line 2939 of file mathp.cc.

References DMOD_UNKNOWN, and GetDeclarationModifier().

 {
         return GetDeclarationModifier(s) != DMOD_UNKNOWN;
 }

Here is the call graph for this function:

bool MathParser::IsKeyWord	(	MathParser::NameSpace *	ns,
		const char *const	s
	)		const

protected

Definition at line 2945 of file mathp.cc.

References MathParser::NameSpace::IsFunc(), IsType(), and IsTypeModifier().

Referenced by stmt().

 {
         if (IsTypeModifier(s)) {
                 return true;
         }
         if (IsType(s)) {
                 return true;
         }
         if (ns->IsFunc(s)) {
                 return true;
         }
         return false;
 }

Here is the call graph for this function:

bool MathParser::IsType ( const char *const s ) const

protected

Definition at line 2927 of file mathp.cc.

References GetType(), and TypedValue::VAR_UNKNOWN.

Referenced by IsKeyWord().

 {
         return GetType(s) != TypedValue::VAR_UNKNOWN;
 }

Here is the call graph for this function:

bool MathParser::IsTypeModifier ( const char *const s ) const

protected

Definition at line 2933 of file mathp.cc.

References GetTypeModifier(), and TypedValue::MOD_UNKNOWN.

Referenced by IsKeyWord().

 {
         return GetTypeModifier(s) != TypedValue::MOD_UNKNOWN;
 }

Here is the call graph for this function:

TypedValue MathParser::logical ( void )

protected

Definition at line 3310 of file mathp.cc.

References logical_int(), and relational().

Referenced by stmt().

 {
         return logical_int(relational());
 }

Here is the call graph for this function:

TypedValue MathParser::logical ( TypedValue d )

protected

Definition at line 3316 of file mathp.cc.

References logical_int(), and relational().

 {
         return logical_int(relational(d));
 }

Here is the call graph for this function:

TypedValue MathParser::logical_int ( TypedValue d )

protected

Definition at line 3322 of file mathp.cc.

References AND, currtoken, GetToken(), OR, relational(), and XOR.

Referenced by logical().

 {
         while (true) {
                 switch (currtoken) {
                 case AND:
                         GetToken();
                         d = (d && relational());
                         break;
 
                 case OR:
                         GetToken();
                         d = (d || relational());
                         break;
 
                 case XOR: {
                         GetToken();
                         TypedValue e = relational();
                         d = ((!(d && e)) && (d || e));
                         break;
                 }
 
                 default:
                         return d;
                 }
         }
 }

Here is the call graph for this function:

TypedValue MathParser::mult ( void )

protected

Definition at line 3436 of file mathp.cc.

References mult_int(), and power().

Referenced by binary(), and binary_int().

 {
         return mult_int(power());
 }

Here is the call graph for this function:

TypedValue MathParser::mult ( TypedValue d )

protected

Definition at line 3442 of file mathp.cc.

References mult_int(), and power().

 {
         return mult_int(power(d));
 }

Here is the call graph for this function:

TypedValue MathParser::mult_int ( TypedValue d )

protected

Definition at line 3448 of file mathp.cc.

References currtoken, DIV, GetToken(), MBDYN_EXCEPT_ARGS, MOD, MULT, and power().

Referenced by mult().

 {
         while (true) {
                 switch (currtoken) {
                 case MULT:
                         GetToken();
                         d *= power();
                         break;
                 
                 case DIV: {
                         GetToken();
                         TypedValue e = power();
                         if (e == 0.) {
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "divide by zero in mult()");
                         }
                         d /= e;
                         break;
                 }
 
                 case MOD: {
                         GetToken();
                         TypedValue e = power();
                         if (e == 0.) {
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "divide by zero in mult()");
                         }
                         d %= e;
                         break;
                 }
 
                 default:
                         return d;
                 }
         }
 }

Here is the call graph for this function:

TypedValue MathParser::power ( void )

protected

Definition at line 3485 of file mathp.cc.

References power_int(), and unary().

Referenced by mult(), mult_int(), and power_int().

 {
         return power_int(unary());
 }

Here is the call graph for this function:

TypedValue MathParser::power ( TypedValue d )

protected

Definition at line 3491 of file mathp.cc.

References power_int().

 {
         return power_int(d);
 }

Here is the call graph for this function:

TypedValue MathParser::power_int ( TypedValue d )

protected

Definition at line 3497 of file mathp.cc.

References currtoken, DEBUGCERR, EXP, TypedValue::GetInt(), TypedValue::GetReal(), GetToken(), TypedValue::GetType(), MBDYN_EXCEPT_ARGS, grad::pow(), power(), TypedValue::SetType(), TypedValue::VAR_INT, and TypedValue::VAR_REAL.

Referenced by power().

 {
         if (currtoken == EXP) {
                 GetToken();
 
                 /*
                  * Per l'esponente chiamo di nuovo power cosi' richiama unary;
                  * se per caso dopo unary c'e' di nuovo un esponente,
                  * l'associazione avviene correttamente da destra:
                  *
                  *      d^e1^e2 == d^(e1^e2)
                  */
                 TypedValue e = power();
 
                 if (d < 0. && e <= 0.) {
                         DEBUGCERR("can't compute (" << d << ")^("
                                         << e << ") in power()" << std::endl);
                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "invalid operands in power()");
                 }
 
                 /*
                  * Se sono entrambi interi, uso la sequenza di prodotti
                  * (maggiore accuratezza? comunque va in overflow
                  * correttamente)
                  */
                 if (e.GetType() == TypedValue::VAR_INT
                                 && d.GetType() == TypedValue::VAR_INT)
                 {
                         Int i = e.GetInt();
                         Int j = d.GetInt();
                         Int r = j;
                         if (i == 0) {
                                 r = 1;
                         } else if (i < 0) {
                                 r = 0;
                         } else {
                                 for (Int k = i-1; k-- > 0; ) {
                                         r *= j;
                                 }
                         }
                         d = TypedValue(r);
                 /*
                  * Altrimenti li forzo entrambi a reale e uso pow
                  * (ottimizzata di suo)
                  */
                 } else {
                         Real r = e.GetReal();
                         Real b = d.GetReal();
                         d.SetType(TypedValue::VAR_REAL);
                         d = TypedValue(Real(std::pow(b, r)));
                 }
         }
 
         return d;
 }

Here is the call graph for this function:

void MathParser::PutSymbolTable ( Table & T )

Definition at line 1937 of file mathp.cc.

References table.

Referenced by DriveHandler::PutSymbolTable().

 {
         table = T;
 }

TypedValue MathParser::readplugin ( void )

protected

Definition at line 4063 of file mathp.cc.

References buf, c, InputStream::eof(), Table::Get(), InputStream::get(), GetToken(), NamedValue::GetVal(), in, MBDYN_EXCEPT_ARGS, MathParser::PlugInRegister::next, NO_OP, PlugIns, Table::Put(), InputStream::putback(), MathParser::PlugIn::Read(), SAFEDELETEARR, SAFENEWWITHCONSTRUCTOR, SAFESTRDUP, table, and trim_arg().

Referenced by expr().

 {
         /*
          * parse plugin:
          *      - arg[0]: nome plugin
          *      - arg[1]: nome variabile
          *      - arg[2]->arg[n]: dati da passare al costrutture
          */
         std::vector<char *> argv(1);
         char c, buf[1024];
         int argc = 0;
         unsigned int i = 0, in_quotes = 0;
 
         /*
          * inizializzo l'array degli argomenti
          */
         argv[0] = NULL;
 
         /*
          * parserizzo la stringa:
          * <plugin> ::= '[' <type> ',' <var_name> <list_of_args> ']'
          * <type> ::= <registered_type>
          * <var_name> ::= <legal_var_name>
          * <list_of_args> ::= ',' <arg> <list_of_args> | ''
          * <arg> ::= <legal_string> (no unescaped ']' or ','!)
          */
         while ((c = in->get()), !in->eof()) {
                 switch (c) {
                 case '\\':
                         c = in->get();
                         if (in_quotes) {
                                 switch (c) {
                                 case 'n':
                                         c = '\n';
                                         break;
 
                                 default:
                                         in->putback(c);
                                         c = '\\';
                                         break;
                                 }
                         }
                         buf[i++] = c;
                         break;
 
                 case '"':
                         if (in_quotes == 0) {
                                 in_quotes = 1;
                                 break;
                         }
                         in_quotes = 0;
                         while (isspace((c = in->get()))) {
                                 NO_OP;
                         }
                         if (c != ',' && c != ']') {
                                 silent_cerr("need a separator "
                                         "after closing quotes" << std::endl);
                                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                         }
                         in->putback(c);
                         break;
 
                 case ',':
                 case ']':
                         if (in_quotes) {
                                 buf[i++] = c;
                                 break;
                         }
                         buf[i] = '\0';
                         argv.resize(argc + 2);
                         trim_arg(buf);
                         SAFESTRDUP(argv[argc], buf);
                         ++argc;
                         argv[argc] = NULL;
                         if (c == ']') {
                                 goto last_arg;
                         }
                         i = 0;
                         break;
 
                 default:
                         buf[i++] = c;
                         break;
                 }
 
                 /*
                  * FIXME: rendere dinamico il buffer ...
                  */
                 if (i >= sizeof(buf)) {
                         silent_cerr("MathParser::readplugin(): buffer overflow" << std::endl);
                         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
                 }
         }
 
 last_arg:
         if (in->eof()) {
                 silent_cerr("eof encountered while parsing plugin"
                         << std::endl);
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         /*
          * put the close plugin token back
          */
         in->putback(c);
         buf[i] = '\0';
 
         /*
          * argomenti comuni a tutti i plugin
          */
         char *pginname = argv[0];
         char *varname = argv[1];
         trim_arg(pginname);
         trim_arg(varname);
 
         /*
          * verifiche di validita' argomenti
          */
         if (pginname == NULL || *pginname == '\0') {
                 silent_cerr("illegal or missing plugin name" << std::endl);
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         if (varname == NULL || *varname == '\0') {
                 silent_cerr("illegal or missing plugin variable name"
                         << std::endl);
                 throw ErrGeneric(MBDYN_EXCEPT_ARGS);
         }
 
         /*
          * verifica esistenza nome
          */
         NamedValue* v = table.Get(varname);
         if (v != NULL) {
                 silent_cerr("variable \"" << varname << "\" already defined"
                         << std::endl);
                 throw Table::ErrNameAlreadyDefined(MBDYN_EXCEPT_ARGS, varname);
         }
 
         /*
          * ricerca registrazione plugin
          */
         for (struct PlugInRegister *p = PlugIns; p != NULL; p = p->next) {
                 if (strcasecmp(p->name, pginname) != 0) {
                         continue;
                 }
 #ifdef DEBUG
                 for (int i = 0; argv[i] != NULL; i++) {
                         silent_cout("argv[" << i << "]=" << argv[i]
                                         << std::endl);
                 }
 #endif /* DEBUG */
 
                 /*
                  * costruisce il plugin e gli fa interpretare gli argomenti
                  */
                 MathParser::PlugIn *pgin = (*p->constructor)(*this, p->arg);
                 pgin->Read(argc - 2, &argv[2]);
 
                 /*
                  * riporta il parser nello stato corretto
                  */
                 GetToken();
 
                 /*
                  * costruisce la variabile, la inserisce nella tabella
                  * e ne ritorna il valore (prima esecuzione)
                  */
                 SAFENEWWITHCONSTRUCTOR(v, PlugInVar,
                                 PlugInVar(varname, pgin));
                 table.Put(v);
 
                 /*
                  * pulizia ...
                  */
                 for (int i = 0; argv[i] != NULL; i++) {
                         SAFEDELETEARR(argv[i]);
                 }
 
                 return v->GetVal();
         }
 
         /*
          * si arriva qui solo se il plugin non e' stato registrato
          */
         silent_cerr(" plugin '" << pginname << "' not supported" << std::endl);
         throw ErrGeneric(MBDYN_EXCEPT_ARGS);
 }

Here is the call graph for this function:

int MathParser::RegisterNameSpace ( MathParser::NameSpace * ns )

Definition at line 4602 of file mathp.cc.

References ASSERT, nameSpaceMap, and MathParser::NameSpace::sGetName().

Referenced by DataManager::DataManager(), MathParser(), module_init(), and NameSpaceDR::Read().

 {
         ASSERT(ns != 0);
 
         pedantic_cout("MathParser::RegisterNameSpace: "
                 "registering namespace \"" << ns->sGetName() << "\""
                 << std::endl);
 
         if (nameSpaceMap.find(ns->sGetName()) != nameSpaceMap.end()) {
                 return 1;
         }
 
         nameSpaceMap[ns->sGetName()] = ns;
 
         return 0;
 }

Here is the call graph for this function:

int MathParser::RegisterPlugIn	(	const char *	name,
		MathParser::PlugIn *	)(MathParser &, void ,
		void *	arg
	)

Definition at line 4584 of file mathp.cc.

References MathParser::PlugInRegister::arg, MathParser::PlugInRegister::constructor, MathParser::PlugInRegister::name, MathParser::PlugInRegister::next, PlugIns, SAFENEW, and SAFESTRDUP.

Referenced by DataManager::DataManager(), and module_init().

 {
         pedantic_cout("registering plugin \"" << name << "\"" << std::endl);
 
         PlugInRegister *p = NULL;
         SAFENEW(p, PlugInRegister);
         SAFESTRDUP(p->name, name);
         p->constructor = constructor;
         p->arg = arg;
         p->next = PlugIns;
         PlugIns = p;
 
         return 0;
 }

TypedValue MathParser::relational ( void )

protected

Definition at line 3350 of file mathp.cc.

References binary(), and relational_int().

Referenced by logical(), and logical_int().

 {
         return relational_int(binary());
 }

Here is the call graph for this function:

TypedValue MathParser::relational ( TypedValue d )

protected

Definition at line 3356 of file mathp.cc.

References binary(), and relational_int().

 {
         return relational_int(binary(d));
 }

Here is the call graph for this function:

TypedValue MathParser::relational_int ( TypedValue d )

protected

Definition at line 3362 of file mathp.cc.

References binary(), currtoken, EQ, GE, GetToken(), GT, LE, LT, and NE.

Referenced by relational().

 {
         while (true) {
                 switch (currtoken) {
                 case GT:
                         GetToken();
                         d = (d > binary());
                         break;
 
                 case GE:
                         GetToken();
                         d = (d >= binary());
                         break;
 
                 case EQ:
                         GetToken();
                         d = (d == binary());
                         break;
 
                 case LE:
                         GetToken();
                         d = (d <= binary());
                         break;
 
                 case LT:
                         GetToken();
                         d = (d < binary());
                         break;
 
                 case NE:
                         GetToken();
                         d = (d != binary());
                         break;
 
                 default:
                         return d;
                 }
         }
 }

Here is the call graph for this function:

TypedValue MathParser::stmt ( void )

protected

Definition at line 3781 of file mathp.cc.

References ASSIGN, bRedefineVars, TypedValue::Cast(), CBR, NamedValue::Const(), currtoken, defaultNameSpace, DMOD_IFNDEF, DMOD_UNKNOWN, evalfunc(), MathParser::MathFunc_t::fname, Table::Get(), GetDeclarationModifier(), MathParser::NameSpace::GetFunc(), MathParser::NameSpace::GetTable(), GetToken(), NamedValue::GetType(), GetType(), GetTypeModifier(), TypedValue::GetTypeName(), NamedValue::GetTypeName(), NamedValue::GetVal(), IsKeyWord(), NamedValue::IsVar(), logical(), MBDYN_EXCEPT_ARGS, mbdyn_get_line_data(), TypedValue::MOD_CONST, TypedValue::MOD_UNKNOWN, NAME, namebuf, nameSpaceMap, NAMESPACESEP, OBR, Table::Put(), TypedValue::SetConst(), MathParser::NameSpace::sGetName(), STMTSEP, table, TokenPush(), and TypedValue::VAR_UNKNOWN.

Referenced by Get(), and stmtlist().

 {
         if (currtoken == NAME) {
                 bool isIfndef = false;
                 bool isConst = false;
 
                 DeclarationModifier declarationmodifier = GetDeclarationModifier(namebuf.c_str());
                 if (declarationmodifier != DMOD_UNKNOWN) {
                         switch (declarationmodifier) {
                         case DMOD_IFNDEF:
                                 isIfndef = true;
                                 break;
 
                         default:
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                         std::string("unhandled definition modifier \"") + namebuf + "\"");
                         }
 
                         if (GetToken() != NAME) {
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "type (modifier) expected "
                                         "after definition modifier in declaration");
                         }
                 }
 
                 TypedValue::TypeModifier typemodifier = GetTypeModifier(namebuf.c_str());
                 if (typemodifier != TypedValue::MOD_UNKNOWN) {
                         switch (typemodifier) {
                         case TypedValue::MOD_CONST:
                                 isConst = true;
                                 break;
 
                         default:
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                         std::string("unhandled type modifier \"") + namebuf + "\"");
                         }
 
                         if (GetToken() != NAME) {
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "type expected "
                                         "after type modifier in declaration");
                         }
                 }
 
                 /* declaration? */
                 TypedValue::Type type = GetType(namebuf.c_str());
                 if (type != TypedValue::VAR_UNKNOWN) {
                         switch (GetToken()) {
                         case OBR:
                                 // explicit cast?
                                 TokenPush(currtoken);
                                 currtoken = NAME;
                                 return logical();
                                 
                         case NAME:
                                 break;
 
                         default:
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "name expected "
                                         "after type in declaration");
                         }
 
                         if (IsKeyWord(defaultNameSpace, namebuf.c_str())) {
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, std::string("name \"")
                                         + namebuf + "\" is a keyword");
                         }
 
                         MathParser::NameSpace *currNameSpace = defaultNameSpace;
                         Table *currTable = &table;
                         std::string name(namebuf);
 
                         GetToken();
                         if (currtoken == NAMESPACESEP) {
                                 NameSpaceMap::iterator i = nameSpaceMap.find(name);
                                 if (i == nameSpaceMap.end()) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                 std::string("unable to find namespace \"") + namebuf + "\"");
                                 }
                                 currNameSpace = i->second;
                                 currTable = currNameSpace->GetTable();
                                 GetToken();
                                 if (currtoken != NAME) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "name expected after namespace");
                                 }
                                 name += "::";
                                 name += namebuf;
                                 GetToken();
                         }
 
                         /* with assign? */
                         if (currtoken == ASSIGN) {
                                 if (currTable == 0) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                 std::string("namespace \"") + currNameSpace->sGetName()
                                                 + "\" does not support variables");
                                 }
 
                                 /* faccio una copia del nome! */
                                 std::string varname(namebuf);
 
                                 GetToken();
                                 TypedValue d = logical();
                                 /* set const'ness of newly gotten value */
                                 if (isConst) {
                                         d.SetConst();
                                 }
                                 /* cerco la variabile */
                                 NamedValue* v = currTable->Get(varname.c_str());
 
                                 if (v == NULL) {
                                         /* create new var with assigned type */
                                         TypedValue newvar(type);
                                         /* assign new var, so that it internally
                                          * takes care of casting, while it inherits
                                          * const'ness from d */
                                         newvar.Cast(d);
                                         v = currTable->Put(varname.c_str(), newvar);
 
                                         if (isIfndef) {
                                                 silent_cerr("warning, ifndef variable " << v->GetTypeName() << " \"" << name
                                                         << "\" not yet defined; set to \"" << newvar << "\" at line " << mbdyn_get_line_data() << std::endl);
                                         }
 
                                 } else {
                                         /* altrimenti, se la posso ridefinire, mi limito
                                          * ad assegnarle il nuovo valore */
                                         if (!bRedefineVars && !isIfndef) {
                                                 throw MathParser::ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                         std::string("cannot redefine var \"") + name + "\"");
                                         }
 
                                         if (v->Const() && !isIfndef) {
                                                 // TODO: check redefinition of const'ness
                                                 throw MathParser::ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                         std::string("cannot redefine const named value \"") + name + "\"");
                                         }
 
                                         if (!v->IsVar()) {
                                                 throw MathParser::ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                         std::string("cannot redefine non-var named value \"") + name + "\"");
                                         }
 
                                         if (!isIfndef) {
                                                 dynamic_cast<Var *>(v)->SetVal(d);
 
                                         } else {
                                                 if (v->GetType() != type) {
                                                         silent_cerr("warning, skipping redefinition of \"" << name.c_str() << "\""
                                                                 << " from " << v->GetTypeName() << " to " << TypedValue::GetTypeName(type)
                                                                 << " (orig=" << v->GetVal() << ", unchanged; new=" << d << ")"
                                                                 << " at line " << mbdyn_get_line_data() << std::endl);
 
                                                 } else {
                                                         silent_cerr("warning, skipping redefinition of " << v->GetTypeName() << " \"" << name.c_str() << "\""
                                                                 << " (orig=" << v->GetVal() << ", unchanged; new=" << d << ")"
                                                                 << " at line " << mbdyn_get_line_data() << std::endl);
                                                 }
                                         }
                                 }
                                 return v->GetVal();
 
                         } else if (currtoken == STMTSEP) {
                                 if (currTable == 0) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                 std::string("namespace \"") + currNameSpace->sGetName()
                                                 + "\" does not support variables");
                                 }
                                 
                                 NamedValue* v = currTable->Get(namebuf);
                                 if (v == NULL || (!bRedefineVars && !isIfndef)) {
                                         if (isConst) {
                                                 /* cannot insert a const var
                                                  * with no value */
                                                 throw MathParser::ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                         std::string("cannot create const named value \"")
                                                         + namebuf + "\" with no value");
                                         }
                                         /* se la var non esiste, la inserisco;
                                          * se invece esiste e non vale 
                                          * la ridefinizione, tento
                                          * di inserirla comunque, cosi'
                                          * table da' errore */
                                         v = currTable->Put(namebuf, TypedValue(type));
                                 }
 
                                 return v->GetVal();
                         }
 
                 } else {
                         if (declarationmodifier != DMOD_UNKNOWN) {
                                 throw MathParser::ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                         "definition modifier without type");
                         }
 
                         if (typemodifier != TypedValue::MOD_UNKNOWN) {
                                 throw MathParser::ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                         "type modifier without type");
                         }
 
                         MathParser::NameSpace *currNameSpace = defaultNameSpace;
                         Table *currTable = &table;
                         std::string name(namebuf);
 
                         GetToken();
                         if (currtoken == NAMESPACESEP) {
                                 NameSpaceMap::iterator i = nameSpaceMap.find(name);
                                 if (i == nameSpaceMap.end()) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                 std::string("unable to find namespace \"") + namebuf + "\"");
                                 }
                                 currNameSpace = i->second;
                                 currTable = currNameSpace->GetTable();
                                 GetToken();
                                 if (currtoken != NAME) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, "name expected after namespace");
                                 }
                                 name += "::";
                                 name += namebuf;
                                 GetToken();
                         }
 
                         if (currtoken == OBR) {
                                 /* in futuro ci potranno essere magari i dati strutturati */
                                 MathParser::MathFunc_t* f = currNameSpace->GetFunc(namebuf);
                                 if (f == NULL) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                 std::string("function \"") + namebuf + "\" not found");
                                 }
                                 GetToken();
                                 TypedValue d = evalfunc(currNameSpace, f);
                                 delete f;
                                 if (currtoken != CBR) {
                                         throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                 std::string("closing parenthesis expected after function \"")
                                                 + f->fname + "\" in expr()");
                                 }
                                 GetToken();
 
                                 return logical(d);
                         }
 
                         /* assignment? */
                         if (currTable == 0) {
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                         std::string("namespace \"") + currNameSpace->sGetName()
                                         + "\" does not support variables");
                         }
                         NamedValue* v = currTable->Get(namebuf);
                         if (v == NULL) {
                                 throw ErrGeneric(this, MBDYN_EXCEPT_ARGS, std::string("var \"") + namebuf + "\" not found");
                         }
 
                         if (currtoken == ASSIGN) {
                                 GetToken();
                                 TypedValue d = logical();
                                 if (v->Const()) {
                                         throw MathParser::ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                 std::string("cannot assign const named value \"") + name + "\"");
                                 }
 
                                 if (!v->IsVar()) {
                                         throw MathParser::ErrGeneric(this, MBDYN_EXCEPT_ARGS,
                                                 std::string("cannot assign non-var named value \"") + name + "\"");
                                 }
                                 dynamic_cast<Var *>(v)->Cast(d);
                                 return v->GetVal();
 
                         } else {
                                 // NOTE: fails if <name> is actually <namespace>::<name>
                                 // ASSERT(currtoken != NAME);
                                 // TokenPush(currtoken);
                                 // currtoken = NAME;
 
                                 // NOTE: fails if <name> is not the complete <stmt>
                                 // return v->GetVal();
 
                                 return logical(v->GetVal());
                         }
                 }
         }
         return logical();
 }

Here is the call graph for this function:

TypedValue MathParser::stmtlist ( void )

protected

Definition at line 4253 of file mathp.cc.

References currtoken, GetToken(), stmt(), and STMTSEP.

Referenced by evalfunc(), expr(), and GetLastStmt().

 {
         TypedValue d = stmt();
         if (currtoken == STMTSEP) {
                 GetToken();
                 return stmtlist();
         }
         return d;
 }

Here is the call graph for this function:

int MathParser::TokenPop ( void )

protected

Definition at line 1963 of file mathp.cc.

References currtoken, TypedValue::GetString(), MathParser::TokenVal::m_t, MathParser::TokenVal::m_v, NAME, namebuf, NUM, TokenStack, and value.

Referenced by GetToken().

 {
         if (TokenStack.empty()) {
                 return 0;
         }
 
         TokenVal tv = TokenStack.top();
         TokenStack.pop();
 
         currtoken = tv.m_t;
         if (currtoken == NUM) {
                 value = tv.m_v;
         } else if (currtoken == NAME) {
                 // note: namebuf is expected to be large enough for value
                 namebuf = tv.m_v.GetString();
         }
 
         return 1;
 }

Here is the call graph for this function:

void MathParser::TokenPush ( enum Token t )

protected

Definition at line 1950 of file mathp.cc.

References MathParser::TokenVal::m_t, MathParser::TokenVal::m_v, NAME, namebuf, NUM, TokenStack, and value.

Referenced by stmt().

 {
         TokenVal tv;
         tv.m_t = t;
         if (t == NUM) {
                 tv.m_v = value;
         } else if (t == NAME) {
                 tv.m_v = TypedValue(namebuf);
         }
         TokenStack.push(tv);
 }

void MathParser::trim_arg ( char *const s )

protected

Definition at line 1865 of file mathp.cc.

References NO_OP.

Referenced by readplugin().

 {
         int i, l;
 
         for (i = 0; isspace(s[i]); ++i) {
                 NO_OP;
         }
 
         l = strlen(&s[i]);
         if (i > 0) {
                 memmove(s, &s[i], l + 1);
         }
 
         for (i = l - 1; isspace(s[i]); --i) {
                 NO_OP;
         }
         s[i + 1] = '\0';
 }

TypedValue MathParser::unary ( void )

protected

Definition at line 3555 of file mathp.cc.

References currtoken, expr(), GetToken(), MINUS, NOT, and PLUS.

Referenced by power().

 {
         switch (currtoken) {
         case MINUS:
                 GetToken();
                 return -expr();
 
         case PLUS:
                 GetToken();
                 return expr();
 
         case NOT:
                 GetToken();
                 return !expr();
 
         default:
                 return expr();
         }
 }