Exemplo n.º 1
0
void Function::reinit(const Eref &e, ProcPtr p)
{
    if (!_valid){
        cout << "Error: Function::reinit() - invalid parser state. Will do nothing." << endl;
        return;
    }
    if (trim(_parser.GetExpr(), " \t\n\r").length() == 0){
        cout << "Error: no expression set. Will do nothing." << endl;
        setExpr(e, "0.0");
        _valid = false;
    }
    _value = 0.0;
    _lastValue = 0.0;
    _rate = 0.0;
    switch (_mode){
        case 1: {
            valueOut()->send(e, _value);
            break;
        }
        case 2: {
            derivativeOut()->send(e, 0.0);
            break;
        }
        case 3: {
            rateOut()->send(e, _rate);
            break;
        }
        default: {
            valueOut()->send(e, _value);
            derivativeOut()->send(e, 0.0);
            rateOut()->send(e, _rate);
            break;
        }
    }
}
Exemplo n.º 2
0
Function::Function(const Function& rhs): _numVar(rhs._numVar),
                                         _lastValue(rhs._lastValue),
                                         _value(rhs._value), _rate(rhs._rate),
                                         _mode(rhs._mode), _stoich(0)
{
	static Eref er;
    _independent = rhs._independent;
    _parser.SetVarFactory(_functionAddVar, this);
    // Adding pi and e, the defaults are `_pi` and `_e`
    _parser.DefineConst(_T("pi"), (mu::value_type)M_PI);
    _parser.DefineConst(_T("e"), (mu::value_type)M_E);
    // Copy the constants
    mu::valmap_type cmap = rhs._parser.GetConst();
    if (cmap.size()){
        mu::valmap_type::const_iterator item = cmap.begin();
        for (; item!=cmap.end(); ++item){
            _parser.DefineConst(item->first, item->second);
        }
    }
    setExpr(er, rhs.getExpr( er ));
    // Copy the values from the var pointers in rhs
    assert(_varbuf.size() == rhs._varbuf.size());
    for (unsigned int ii = 0; ii < rhs._varbuf.size(); ++ii){
        _varbuf[ii]->value = rhs._varbuf[ii]->value;
    }
    assert(_pullbuf.size() == rhs._pullbuf.size());
    for (unsigned int ii = 0; ii < rhs._pullbuf.size(); ++ii){
        *_pullbuf[ii] = *(rhs._pullbuf[ii]);
    }
}
Exemplo n.º 3
0
Function& Function::operator=(const Function rhs)
{
	static Eref er;
    _clearBuffer();
    _mode = rhs._mode;
    _lastValue = rhs._lastValue;
    _value = rhs._value;
    _rate = rhs._rate;
    _independent = rhs._independent;
    // Adding pi and e, the defaults are `_pi` and `_e`
    _parser.DefineConst(_T("pi"), (mu::value_type)M_PI);
    _parser.DefineConst(_T("e"), (mu::value_type)M_E);
    // Copy the constants
    mu::valmap_type cmap = rhs._parser.GetConst();
    if (cmap.size()){
        mu::valmap_type::const_iterator item = cmap.begin();
        for (; item!=cmap.end(); ++item){
            _parser.DefineConst(item->first, item->second);
        }
    }
    // Copy the values from the var pointers in rhs
    setExpr(er, rhs.getExpr( er ));
    assert(_varbuf.size() == rhs._varbuf.size());
    for (unsigned int ii = 0; ii < rhs._varbuf.size(); ++ii){
        _varbuf[ii]->value = rhs._varbuf[ii]->value;
    }
    assert(_pullbuf.size() == rhs._pullbuf.size());
    for (unsigned int ii = 0; ii < rhs._pullbuf.size(); ++ii){
        *_pullbuf[ii] = *(rhs._pullbuf[ii]);
    }
    return *this;
}
Exemplo n.º 4
0
CDGNode *copyToPathNode(CDGNode * pathNode, CDGNode * node) {
  assert(NULL != pathNode);
  setID(pathNode, getID(node));
  setExpr(pathNode, getExpr(node));
  setOutcome(pathNode, getOutcome(node));
  return pathNode;
}
Exemplo n.º 5
0
void Func::reinit(const Eref &e, ProcPtr p)
{
    if (!_valid){
        cout << "Error: Func::reinit() - invalid parser state. Will do nothing." << endl;
        return;
    }
    if (trim(_parser.GetExpr(), " \t\n\r").length() == 0){
        cout << "Error: no expression set. Will do nothing." << endl;
        setExpr("0.0");
        _valid = false;
    }
}
Exemplo n.º 6
0
Func::Func(const Func& rhs): _mode(rhs._mode)
{
    _varbuf.reserve(VARMAX);
    _parser.SetVarFactory(_addVar, this);
    // Adding pi and e, the defaults are `_pi` and `_e`
    _parser.DefineConst(_T("pi"), (mu::value_type)M_PI);
    _parser.DefineConst(_T("e"), (mu::value_type)M_E);
    setExpr(rhs.getExpr());
    vector <string> vars = rhs.getVars();
    for (unsigned int ii = 0; ii < vars.size(); ++ii){
        setVar(vars[ii], rhs.getVar(vars[ii]));
    }
}
Exemplo n.º 7
0
Func& Func::operator=(const Func rhs)
{
    _clearBuffer();
    _mode = rhs._mode;
    // Adding pi and e, the defaults are `_pi` and `_e`
    _parser.DefineConst(_T("pi"), (mu::value_type)M_PI);
    _parser.DefineConst(_T("e"), (mu::value_type)M_E);
    setExpr(rhs.getExpr());
    vector <string> vars = rhs.getVars();
    for (unsigned int ii = 0; ii < vars.size(); ++ii){
        setVar(vars[ii], rhs.getVar(vars[ii]));
    }
    return *this;
}
Exemplo n.º 8
0
CDGNode *newNode(int id, int score, int outcome, const char *expr, CDGNode * trueNodeSet, CDGNode * falseNodeSet, CDGNode * parent, CDGNode * next) {
  CDGNode *node;
  node = (CDGNode *) malloc(sizeof(CDGNode));
  assert(NULL != node);
  setID(node, id);
  setScore(node, score);
  setOutcome(node, outcome);
  setExpr(node, expr);
  setTrueNodeSet(node, trueNodeSet);
  setFalseNodeSet(node, falseNodeSet);
  setParent(node, parent);
  setNextNode(node, next);
  return node;
}
Exemplo n.º 9
0
FloatDatum::FloatDatum(QString name, QString expr, QObject *parent)
    : FloatDatum(name, parent)
{
    setExpr(expr);
}
Exemplo n.º 10
0
void setArray(int id, const char *expr) {
    setExpr(nodes[id], expr);
}
void OOOperatorDescriptorList::initializeWithDefaultOperators()
{
	using OD = OOOperatorDescriptor;
	// Unary operators
	add(new OD("preincrement", "++ expr", 1, 2, OD::RightAssociative,	OD::unary<UnaryOperation::PREINCREMENT>));
	add(new OD("predecrement", "-- expr", 1, 2, OD::RightAssociative,	OD::unary<UnaryOperation::PREDECREMENT>));
	add(new OD("postincrement", "expr ++", 1, 2, OD::LeftAssociative, OD::unary<UnaryOperation::POSTINCREMENT>));
	add(new OD("postdecrement", "expr --", 1, 2, OD::LeftAssociative, OD::unary<UnaryOperation::POSTDECREMENT>));
	add(new OD("unary plus", "+ expr", 1, 2, OD::RightAssociative,	OD::unary<UnaryOperation::PLUS>));
	add(new OD("unary minus", "- expr", 1, 2, OD::RightAssociative, OD::unary<UnaryOperation::MINUS>));
	add(new OD("not", "! expr", 1, 2, OD::RightAssociative, OD::unary<UnaryOperation::NOT>));
	add(new OD("complement", "~ expr", 1, 2, OD::RightAssociative, OD::unary<UnaryOperation::COMPLEMENT>));
	add(new OD("parenthesis", "( expr )", 1, 1, OD::NotAssociative, OD::unary<UnaryOperation::PARENTHESIS>));
	add(new OD("dereference", "* expr", 1, 2, OD::RightAssociative, OD::unary<UnaryOperation::DEREFERENCE>));
	add(new OD("addressof", "& expr", 1, 2, OD::RightAssociative, OD::unary<UnaryOperation::ADDRESSOF>));

	// Binary operators
	add(new OD("times", "expr * expr", 2, 3, OD::LeftAssociative, OD::binary<BinaryOperation::TIMES>));
	add(new OD("divide", "expr / expr", 2, 3, OD::LeftAssociative, OD::binary<BinaryOperation::DIVIDE>));
	add(new OD("remainder", "expr % expr", 2, 3, OD::LeftAssociative, OD::binary<BinaryOperation::REMAINDER>));
	add(new OD("plus", "expr + expr", 2, 4, OD::LeftAssociative, OD::binary<BinaryOperation::PLUS>));
	add(new OD("minus", "expr - expr", 2, 4, OD::LeftAssociative, OD::binary<BinaryOperation::MINUS>));
	add(new OD("left shift", "expr << expr", 2, 5, OD::LeftAssociative, OD::binary<BinaryOperation::LEFT_SHIFT>));
	add(new OD("right shift signed", "expr >> expr", 2, 5, OD::LeftAssociative,
			OD::binary<BinaryOperation::RIGHT_SHIFT_SIGNED>));
	add(new OD("righ shift unsigned", "expr >>> expr", 2, 5, OD::LeftAssociative,
			OD::binary<BinaryOperation::RIGHT_SHIFT_UNSIGNED>));
	add(new OD("less", "expr < expr", 2, 6, OD::LeftAssociative, OD::binary<BinaryOperation::LESS>));
	add(new OD("greater", "expr > expr", 2, 6, OD::LeftAssociative, OD::binary<BinaryOperation::GREATER>));
	add(new OD("less equals", "expr <= expr", 2, 6, OD::LeftAssociative, OD::binary<BinaryOperation::LESS_EQUALS>));
	add(new OD("greater equals", "expr >= expr", 2, 6, OD::LeftAssociative,
			OD::binary<BinaryOperation::GREATER_EQUALS>));
	add(new OD("equals", "expr == expr", 2, 7, OD::LeftAssociative, OD::binary<BinaryOperation::EQUALS>));
	add(new OD("not equals", "expr != expr", 2, 7, OD::LeftAssociative, OD::binary<BinaryOperation::NOT_EQUALS>));
	add(new OD("bitwise xor", "expr ^ expr", 2, 9, OD::LeftAssociative, OD::binary<BinaryOperation::XOR>));
	add(new OD("bitwise and", "expr & expr", 2, 8, OD::LeftAssociative, OD::binary<BinaryOperation::AND>));
	add(new OD("bitwise or", "expr | expr", 2, 10, OD::LeftAssociative, OD::binary<BinaryOperation::OR>));
	add(new OD("conditional and", "expr && expr", 2, 11, OD::LeftAssociative,
			OD::binary<BinaryOperation::CONDITIONAL_AND>));
	add(new OD("conditional or", "expr || expr", 2, 12, OD::LeftAssociative,
			OD::binary<BinaryOperation::CONDITIONAL_OR>));
	add(new OD("array index", "expr [ expr ]", 2, 1, OD::LeftAssociative, OD::binary<BinaryOperation::ARRAY_INDEX>));

	// Ternary operator
	add(new OD("conditional expression", "expr ? expr : expr", 3, 13, OD::RightAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto opr = new ConditionalExpression();
		opr->setCondition(operands.first());
		opr->setTrueExpression(operands.at(1));
		opr->setFalseExpression(operands.last());
		return opr;
	}));

	// Assignment
	add(new OD("assign", "expr = expr", 2, 14, OD::RightAssociative,
			OD::assignment<AssignmentExpression::ASSIGN>));
	add(new OD("assign", "expr += expr", 2, 14, OD::RightAssociative,
			OD::assignment<AssignmentExpression::PLUS_ASSIGN>));
	add(new OD("assign", "expr -= expr", 2, 14, OD::RightAssociative,
			OD::assignment<AssignmentExpression::MINUS_ASSIGN>));
	add(new OD("assign", "expr *= expr", 2, 14, OD::RightAssociative,
			OD::assignment<AssignmentExpression::TIMES_ASSIGN>));
	add(new OD("assign", "expr /= expr", 2, 14, OD::RightAssociative,
			OD::assignment<AssignmentExpression::DIVIDE_ASSIGN>));
	add(new OD("assign", "expr &= expr", 2, 14, OD::RightAssociative,
			OD::assignment<AssignmentExpression::BIT_AND_ASSIGN>));
	add(new OD("assign", "expr |= expr", 2, 14, OD::RightAssociative,
			OD::assignment<AssignmentExpression::BIT_OR_ASSIGN>));
	add(new OD("assign", "expr ^= expr", 2, 14, OD::RightAssociative,
			OD::assignment<AssignmentExpression::BIT_XOR_ASSIGN>));
	add(new OD("assign", "expr %= expr", 2, 14, OD::RightAssociative,
			OD::assignment<AssignmentExpression::REMAINDER_ASSIGN>));
	add(new OD("assign", "expr <<= expr", 2, 14, OD::RightAssociative,
			OD::assignment<AssignmentExpression::LEFT_SHIFT_ASSIGN>));
	add(new OD("assign", "expr >>= expr", 2, 14, OD::RightAssociative,
			OD::assignment<AssignmentExpression::RIGHT_SHIFT_SIGNED_ASSIGN>));
	add(new OD("assign", "expr >>>= expr", 2, 14, OD::RightAssociative,
			OD::assignment<AssignmentExpression::RIGHT_SHIFT_UNSIGNED_ASSIGN>));

	// Others
	add(new OD( "cast", "( expr ) expr", 2, 2, OD::RightAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto opr = new OOModel::CastExpression();
		opr->setType(operands.first());
		opr->setExpr(operands.last());
		return opr;
	}));

	add(new OD( "comma", "expr , expr", 2, 50, OD::LeftAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto opr = new OOModel::CommaExpression();
		opr->setLeft(operands.first());
		opr->setRight(operands.last());
		return opr;
	}));

	add(new OD( "initializer", "{ expr }", 1, 0, OD::NotAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto opr = new OOModel::ArrayInitializer();

		for(auto e: operands)
		{
			if (auto comma = dynamic_cast<OOModel::CommaExpression*>(e))
			{
				for(auto ee : comma->allSubOperands(true))
					opr->values()->append(ee);

				SAFE_DELETE(comma);
			}
			else
				opr->values()->append(e);
		}

		return opr;
	}));

	add(new OD( "new object", "new SPACE expr", 1, 2, OD::RightAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto opr = new OOModel::NewExpression();
		opr->setNewType( operands.first());
		return opr;
	}));

	add(new OD( "new array", "new SPACE expr [ expr ]", 2, 2, OD::RightAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto opr = new OOModel::NewExpression();
		opr->setNewType( operands.first());
		opr->setAmount(operands.last());
		return opr;
	}));

	add(new OD( "delete object", "delete SPACE expr", 1, 2, OD::RightAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto expr = new OOModel::DeleteExpression();
		expr->setExpr( operands.first());
		return expr;
	}));

	add(new OD( "delete array", "delete [] SPACE expr", 1, 2, OD::RightAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto expr = new OOModel::DeleteExpression();
		expr->setIsArray(true);
		expr->setExpr( operands.first());
		return expr;
	}));

	add(new OD( "member", "expr . id", 2, 1, OD::LeftAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		Q_ASSERT(operands.size() == 2);
		auto ref = dynamic_cast<OOModel::ReferenceExpression*>( operands[1]);
		Q_ASSERT(ref);

		auto r = new OOModel::ReferenceExpression( ref->name(), operands.first() );
		SAFE_DELETE(ref);
		return r;
	}));

	add(new OD( "member", "expr . id < expr >", 3, 1, OD::LeftAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		Q_ASSERT(operands.size() == 3 );
		auto ref = dynamic_cast<OOModel::ReferenceExpression*>( operands[1]);
		Q_ASSERT(ref);

		auto r = new OOModel::ReferenceExpression( ref->name(), operands.first() );
		SAFE_DELETE(ref);

		if (auto comma = dynamic_cast<OOModel::CommaExpression*>(operands.last()))
		{
			for(auto arg : comma->allSubOperands(true))
				r->typeArguments()->append(arg);

			SAFE_DELETE(comma);
		}
		else
			if (!dynamic_cast<OOModel::EmptyExpression*>(operands.last()) )
				r->typeArguments()->append(operands.last());

		return r;
	}));

	add(new OD( "call", "expr ( expr )", 2, 1, OD::LeftAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		Q_ASSERT(operands.size() == 2);
		auto ref = dynamic_cast<OOModel::ReferenceExpression*>( operands.first());
		Q_ASSERT(ref);

		auto opr = new OOModel::MethodCallExpression();
		opr->setRef(ref);

		if (auto comma = dynamic_cast<OOModel::CommaExpression*>(operands.last()))
		{
			for(auto arg : comma->allSubOperands(true))
				opr->arguments()->append(arg);

			SAFE_DELETE(comma);
		}
		else
			if (!dynamic_cast<OOModel::EmptyExpression*>(operands.last()) )
					opr->arguments()->append(operands.last());

		return opr;
	}));

	add(new OD( "type arguments", "id < expr >", 2, 0, OD::LeftAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		Q_ASSERT(operands.size() == 2);
		auto ref = dynamic_cast<OOModel::ReferenceExpression*>( operands.first());
		Q_ASSERT(ref);

		if (auto comma = dynamic_cast<OOModel::CommaExpression*>(operands.last()))
		{
			for(auto arg : comma->allSubOperands(true))
				ref->typeArguments()->append(arg);

			SAFE_DELETE(comma);
		}
		else
			if (!dynamic_cast<OOModel::EmptyExpression*>(operands.last()) )
					ref->typeArguments()->append(operands.last());

		return ref;
	}));

	add(new OD( "array type", "expr []", 1, 1, OD::LeftAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto at = new OOModel::ArrayTypeExpression();
		at->setTypeExpression(operands.first());
		return at;
	}));

	add(new OD( "pointer type", "expr *", 1, 1, OD::LeftAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto at = new OOModel::PointerTypeExpression();
		at->setTypeExpression(operands.first());
		return at;
	}));

	add(new OD( "reference type", "expr &", 1, 1, OD::LeftAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto at = new OOModel::ReferenceTypeExpression();
		at->setTypeExpression(operands.first());
		return at;
	}));

	add(new OD( "const qualifier", "const SPACE expr", 1, 1, OD::RightAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto at = new OOModel::TypeQualifierExpression();
		at->setQualifier(OOModel::Type::CONST);
		at->setTypeExpression(operands.first());
		return at;
	}));

	add(new OD( "volatile qualifier", "volatile SPACE expr", 1, 1, OD::RightAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto at = new OOModel::TypeQualifierExpression();
		at->setQualifier(OOModel::Type::VOLATILE);
		at->setTypeExpression(operands.first());
		return at;
	}));

	// Variable declaration
	auto varDeclFunction = [](const QList<Expression*>& operands) -> Expression*
	{
		auto vd = new OOModel::VariableDeclarationExpression();

		vd->decl()->setTypeExpression( operands.first() );
		auto ref = dynamic_cast<OOModel::ReferenceExpression*>(operands[1]);
		vd->decl()->setName( ref->name());
		SAFE_DELETE(ref);

		if (operands.size() > 2) vd->decl()->setInitialValue(operands[2]);
		return vd;
	};
	add(new OD( "variable decl", "expr SPACE id", 2, 40, OD::RightAssociative, varDeclFunction));
	add(new OD( "variable decl and initialization", "expr SPACE id = expr", 3, 40,
			OD::RightAssociative, varDeclFunction));

	add(new OD( "throw", "throw SPACE expr", 1, 30, OD::RightAssociative,
			[](const QList<Expression*>& operands) -> Expression* {
		auto expr = new OOModel::ThrowExpression();
		expr->setExpr( operands.first());
		return expr;
	}));

	// Command descriptors
	add(new CommandDescriptor( "command without params", "\\ id SPACE", 1, 0, OD::NotAssociative));
	add(new CommandDescriptor( "command with params", "\\ id ( expr )", 2, 0, OD::NotAssociative));

	add(new CompoundObjectDescriptor( "compound object",
			CompoundObjectDescriptor::compoundSignature(), 1, 0, OD::NotAssociative));
}