char Term::charAt(size_t i) const {
if (i >= getExpression().size()) {
return '0';
}
return getExpression().at(getExpression().length() - i - 1);
}
void analyseCommand(char *cmd) {
char *program = NULL;
int start, end;
int canExecute = 0;
if(setExpressionDelimiters(cmd, "^( *[^&<> ]+)+", &start, &end)) {
/* command begins from the start */
program = getExpression(cmd, start, end, 0);
canExecute = 1;
} else if (setExpressionDelimiters(cmd, "[^<> ] ( *[^<> ]+)+", &start, &end)) {
/* command begins from somewhere else */
program = getExpression(cmd, start, end, 1);
canExecute = 1;
}
if(!canExecute) {
exit(EXIT_FAILURE);
}
if(redirectInput(cmd)) {
exit(EXIT_FAILURE);
}
redirectOutput(cmd);
free(cmd);
executeProgram(program);
}
bool DlgSetRDRPropertyByExpressionEditor::saveWidget(QSettings *settings, const QString &prefix)
{
settings->setValue(prefix+"expression", getExpression());
settings->setValue(prefix+"type", getType());
settings->setValue(prefix+"property", getPropertyName());
return true;
}
QSizeF QgsTextDiagram::diagramSize( const QgsFeature& feature, const QgsRenderContext& c, const QgsDiagramSettings& s, const QgsDiagramInterpolationSettings& is )
{
QgsExpressionContext expressionContext = c.expressionContext();
expressionContext.setFeature( feature );
if ( feature.fields() )
expressionContext.setFields( *feature.fields() );
QVariant attrVal;
if ( is.classificationAttributeIsExpression )
{
QgsExpression* expression = getExpression( is.classificationAttributeExpression, expressionContext );
attrVal = expression->evaluate( &expressionContext );
}
else
{
attrVal = feature.attributes().at( is.classificationAttribute );
}
bool ok = false;
double val = attrVal.toDouble( &ok );
if ( !ok )
{
return QSizeF(); //zero size if attribute is missing
}
return sizeForValue( val, s, is );
}
Result UApplyUpdates::createResult(DynamicContext* context, int flags) const
{
AutoDelete<UpdateFactory> ufactory(context->createUpdateFactory());
ufactory->applyUpdates(getExpression()->createUpdateList(context), context,
getRevalidationMode());
return 0;
}
Result XQNameExpression::createResult(DynamicContext* context, int flags) const
{
AnyAtomicType::Ptr itemName = getExpression()->createResult(context)->next(context);
switch(itemName->getPrimitiveTypeIndex()) {
case AnyAtomicType::QNAME:
return (Item::Ptr)itemName;
case AnyAtomicType::STRING:
case AnyAtomicType::UNTYPED_ATOMIC:
try {
return (Item::Ptr)context->getItemFactory()->createDerivedFromAtomicType(AnyAtomicType::QNAME, itemName->asString(context), context);
}
catch(XQException &) {
XQThrow(ASTException,X("XQNameExpression::NameExpressionResult::createResult"),
X("The name expression cannot be converted to a xs:QName [err:XQDY0074]"));
}
default:
break;
}
XMLBuffer buf;
buf.set(X("The name expression must be a single xs:QName, xs:string or xs:untypedAtomic"));
buf.append(X(" - found item of type "));
itemName->typeToBuffer(context, buf);
buf.append(X(" [err:XPTY0004]"));
XQThrow(XPath2TypeMatchException, X("XQNameExpression::NameExpressionResult::createResult"), buf.getRawBuffer());
}
void
UndoSpeciesData::fillObject(CModel *)
{
CMetab * pSpecies =
dynamic_cast<CMetab*>(CCopasiRootContainer::getKeyFactory()->get(mKey));
if (pSpecies == NULL) return;
if (getStatus() != CModelEntity::ASSIGNMENT)
{
pSpecies->setInitialConcentration(getIConc());
pSpecies->setInitialValue(getINumber());
}
if (getStatus() == CModelEntity::ODE || getStatus() == CModelEntity::ASSIGNMENT)
{
pSpecies->setExpression(getExpression());
}
// set initial expression
if (getStatus() != CModelEntity::ASSIGNMENT)
{
pSpecies->setInitialExpression(getInitialExpression());
}
}
static OrderItem* constructOrderItem( BuildSQLState* state, dbi_result result ) {
int id = dbi_result_get_int_idx( result, 1 );
int stored_query_id = dbi_result_get_int_idx( result, 2 );
int seq_no = dbi_result_get_int_idx( result, 3 );
int expression_id = dbi_result_get_int_idx( result, 4 );
// Allocate a SelectItem: from the free list if possible, from the heap if necessary
// Construct an Expression
Expression* expression = getExpression( state, expression_id );
if( !expression ) {
osrfLogError( OSRF_LOG_MARK, sqlAddMsg( state,
"Unable to fetch ORDER BY expression for id = %d", expression_id ));
return NULL;
};
// Allocate an OrderItem; from the free list if possible, or from the heap if necessary.
OrderItem* ord;
if( free_order_item_list ) {
ord = free_order_item_list;
free_order_item_list = free_order_item_list->next;
} else
ord = safe_malloc( sizeof( OrderItem ));
ord->next = NULL;
ord->id = id;
ord->stored_query_id = stored_query_id;
ord->seq_no = seq_no;
ord->expression = expression;
return ord;
}
bool ftParser::getSystem(void)
{
// need to check for end of input
std::string systemName = getName();
if (systemName.empty()) {
reportError("expected system name", 1);
return false;
}
bool exists;
int index = m_systemNames->addName(systemName, &exists);
if (exists) {
reportError("duplicate system name");
return false;
}
m_reader->skipWhiteSpace();
char c = m_reader->getCurrentCharacter();
if (c != '=') {
reportError("expected '=' after system name", 1);
return false;
}
m_reader->advancePosition();
ftNode *systemExpression = getExpression();
if (systemExpression == NULL) {
return false; // error already reported
}
m_systemNodes.resize(index + 1);
m_systemNodes[index] = systemExpression;
// input ready for reading next system
return true;
}
tree * getFactor(token ** tokenPtr,char *buffer) {
assert((*tokenPtr) != NULL);
if ((*tokenPtr)->type==LPAREN) {
(*tokenPtr)=nextToken((*tokenPtr),buffer,true);
if ((*tokenPtr)==NULL) {
printf("Syntax error... incomplete expression, expected an expression after open parens\n");
exit(1);
}
tree * result=getExpression(tokenPtr,buffer);
if ((*tokenPtr)->type != RPAREN) {
tokenError("Syntax error... expected closing parenthesis after expression",buffer,(*tokenPtr));
exit(1);
}
(*tokenPtr)=nextToken((*tokenPtr),buffer,true);
return result;
}
if ((*tokenPtr)->type==INTEGER || (*tokenPtr)->type==VARIABLE ) {
tree * result=newTree();
result->action=(*tokenPtr);
(*tokenPtr)=nextToken((*tokenPtr),buffer,false);
return result;
}
printf("Syntax error... expected a factor\n");
exit(1);
}
int redirectInput(char *line) {
char *input = NULL;
int start, end;
int file;
if(setExpressionDelimiters(line, "< *[^<>| ]+", &start, &end)) {
/* get one input redirection */
input = getExpression(line, start, end, 1);
file = open(input, O_RDONLY, 0);
if(file < 0) {
perror("Failed to open input file");
return 1;
}
/* try to redirect input */
if(dup2(file, STDIN_FILENO) < 0) {
perror("Failed to duplicate input file descriptor");
return 2;
}
close(file);
free(input);
}
return 0;
}
double Variable::getDouble() {
double value;
if (getExpression() != NULL) {
if (getIsMemberVariable()) {
getSymbol()->get_game_object_value(getExpression()->eval_int())->get_member_variable(member,value);
} else {
return getSymbol()->get_double_value(getExpression()->eval_int());
}
} else {
if (getIsMemberVariable()) {
getSymbol()->get_game_object_value()->get_member_variable(member,value);
} else {
return getSymbol()->get_double_value();
}
}
return value;
}
Expression DifferentialEquation::getODEexpansion( const int &order ) const{
if ( order < 0 ){ ACADOERROR( RET_INDEX_OUT_OF_BOUNDS ); return 0; }
Expression rhs;
getExpression(rhs);
return rhs.getODEexpansion( order, component );
}
void
UndoEventAssignmentData::addToEvent(CEvent *pEvent) const
{
CEventAssignment *eventAssign =
new CEventAssignment(getKey(), pEvent->getObjectParent());
eventAssign->setExpression(getExpression());
eventAssign->getExpressionPtr()->compile();
pEvent->getAssignments().add(eventAssign);
}
QString InitCompletion::className(const QString &text)
{
Scope sc;
Expression exp = getExpression(text, sc);
if (exp.access == ParseError)
return QString();
return exp.className;
}
void ExprShortEdit::controlChanged(int id) {
if (controls) {
QString newText = getExpression();
controls->updateText(id, newText);
edit->setText(newText);
checkErrors();
emit exprChanged();
}
}
string* Variable::getString() {
string* value = new string();
if (getExpression() != NULL) {
if (getIsMemberVariable()) {
getSymbol()->get_game_object_value(getExpression()->eval_int())->get_member_variable(member,*value);
} else {
return getSymbol()->getStringValue(getExpression()->eval_int());
}
} else {
if (getIsMemberVariable()) {
getSymbol()->get_game_object_value()->get_member_variable(member,*value);
return value;
} else {
return getSymbol()->getStringValue();
}
}
return value;
}
void QgsDataDefinedButton::updateDataDefined( QgsDataDefined *dd ) const
{
if ( !dd )
return;
dd->setActive( isActive() );
dd->setExpressionString( getExpression() );
dd->setField( getField() );
dd->setUseExpression( useExpression() );
}
QSizeF QgsTextDiagram::diagramSize( const QgsFeature& feature, const QgsRenderContext& c, const QgsDiagramSettings& s, const QgsDiagramInterpolationSettings& is )
{
Q_UNUSED( c );
QVariant attrVal;
if ( is.classificationAttributeIsExpression )
{
QgsExpression* expression = getExpression( is.classificationAttributeExpression, feature.fields() );
attrVal = expression->evaluate( feature );
}
else
{
attrVal = feature.attributes()[is.classificationAttribute];
}
if ( !attrVal.isValid() )
{
return QSizeF(); //zero size if attribute is missing
}
double scaledValue = attrVal.toDouble();
double scaledLowerValue = is.lowerValue;
double scaledUpperValue = is.upperValue;
double scaledLowerSizeWidth = is.lowerSize.width();
double scaledLowerSizeHeight = is.lowerSize.height();
double scaledUpperSizeWidth = is.upperSize.width();
double scaledUpperSizeHeight = is.upperSize.height();
// interpolate the squared value if scale by area
if ( s.scaleByArea )
{
scaledValue = sqrt( scaledValue );
scaledLowerValue = sqrt( scaledLowerValue );
scaledUpperValue = sqrt( scaledUpperValue );
scaledLowerSizeWidth = sqrt( scaledLowerSizeWidth );
scaledLowerSizeHeight = sqrt( scaledLowerSizeHeight );
scaledUpperSizeWidth = sqrt( scaledUpperSizeWidth );
scaledUpperSizeHeight = sqrt( scaledUpperSizeHeight );
}
//interpolate size
double scaledRatio = ( scaledValue - scaledLowerValue ) / ( scaledUpperValue - scaledLowerValue );
QSizeF size = QSizeF( is.upperSize.width() * scaledRatio + is.lowerSize.width() * ( 1 - scaledRatio ),
is.upperSize.height() * scaledRatio + is.lowerSize.height() * ( 1 - scaledRatio ) );
// Scale, if extension is smaller than the specified minimum
if ( size.width() <= s.minimumSize && size.height() <= s.minimumSize )
{
size.scale( s.minimumSize, s.minimumSize, Qt::KeepAspectRatio );
}
return size;
}
QList<Tag> InitCompletion::startParse(const QString &text, bool showAllResults)
{
Scope sc;
Expression exp = getExpression(text, sc, showAllResults);
/* we have all relevant information, so just list the entries */
if (exp.access == ParseError)
return QList <Tag> ();
return Tree::findEntries(&exp, &sc);
}
void generateCode(){
string tempName,tempVar;
if(match(REGISTER)){
tempName.assign(yytext,yytext+yyleng);
advance();
if(match(EQUALS)){
advance();
tempVar = getExpression();
}
}
}
void ForLoopNode::generateIntermediateCode(IntermediateCode *intermediateCode, vector<Instruction *>*instructionVector)
{
int increment_label = intermediateCode->getNextLabelNumber();
int expression_label = intermediateCode->getNextLabelNumber();
int after_loop_label = (this->getNextLabelNumber()==LABEL_FALL)?intermediateCode->getNextLabelNumber():this->getNextLabelNumber();
//getStatement()->setNextLabelNumber(LABEL_FALL);
getInitialisingStatement()->setNextLabelNumber(LABEL_FALL);
getLoopBodyStatement()->setNextLabelNumber(increment_label);
getIncrementStatement()->setNextLabelNumber(expression_label);
getExpression()->setFalseLabelNumber( after_loop_label );
getInitialisingStatement()->generateIntermediateCode(intermediateCode, instructionVector);
InstructionLabel *expressionInstructionLabel = new InstructionLabel(expression_label);
intermediateCode->addInstruction(instructionVector, new GotoInstruction( expressionInstructionLabel ));
if(intermediateCode->getPendingLabelNumber()==LABEL_NONE){
getExpression()->setTrueLabelNumber( intermediateCode->getNextLabelNumber() );
intermediateCode->setPendingLabelNumber( getExpression()->getTrueLabelNumber() );
}else{
getExpression()->setTrueLabelNumber( intermediateCode->getPendingLabelNumber() );
}
getLoopBodyStatement()->setBreakLabelNumber( after_loop_label );
getLoopBodyStatement()->setContinueLabelNumber( increment_label );
getLoopBodyStatement()->generateIntermediateCode(intermediateCode, instructionVector);
intermediateCode->setPendingLabelNumber( increment_label );
getIncrementStatement()->generateIntermediateCode(intermediateCode, instructionVector);
intermediateCode->setPendingLabelNumber( expression_label );
getExpression()->generateIntermediateCode( intermediateCode, instructionVector );
if(this->getNextLabelNumber()==LABEL_FALL)
intermediateCode->setPendingLabelNumber( after_loop_label );
intermediateCode->addInstructionArgumentToCleanUpList( expressionInstructionLabel );
}
void ForLoopNode::generateCCode(ostream &out)
{
out << "for (";
this->getInitialisingStatement()->generateCCode(out);
out << "; ";
getExpression()->generateCCode(out);
out << "; ";
this->getIncrementStatement()->generateCCode(out);
out << ") {" << endl;
getLoopBodyStatement()->generateCCode(out);
out << "}" << endl;
}
void DlgSetRDRPropertyByExpressionEditor::updateTest()
{
ui->cmbPropertyName->setEnabled(ui->cmbOutput->currentIndex()==4);
QFRawDataRecord* rdr=par->currentRDR();
QString error;
if (rdr) {
QVariant txt=par->getResult(getExpression(), rdr, NULL, &error);
ui->labTest->setText(txt.toString());//QString("<tt>%1</tt>").arg(getResult(rdr)));
if (error.isEmpty()) ui->labError->setText(QString("<font color=\"darkgreen\"><b>OK</b></font>"));
else ui->labError->setText(QString("<font color=\"red\"><b>ERROR: %1</b></font>").arg(error));
}
}
void FileScope::setFileLevel(StatementListPtr stmtList) {
for (int i = 0; i < stmtList->getCount(); i++) {
StatementPtr stmt = (*stmtList)[i];
stmt->setFileLevel();
if (stmt->is(Statement::KindOfExpStatement)) {
auto expStmt = dynamic_pointer_cast<ExpStatement>(stmt);
ExpressionPtr exp = expStmt->getExpression();
exp->setFileLevel();
}
if (stmt->is(Statement::KindOfStatementList)) {
setFileLevel(dynamic_pointer_cast<StatementList>(stmt));
}
}
}
tree * getWhile(token **tokenPtr,char *buffer) {
assert((*tokenPtr)!=NULL);
if ((*tokenPtr)->type!=WHILE) return NULL;
tree * result=newTree();
result->action=(*tokenPtr);
if ((*tokenPtr)!=NULL) (*tokenPtr)=nextToken((*tokenPtr),buffer,false);
result->left=getExpression(tokenPtr,buffer);
if ((*tokenPtr)==NULL) {
printf("Syntax error... expected expression + statement after while\n");
exit(1);
}
result->right=getStatement(tokenPtr,buffer);
return result;
}
void redirectOutput(char *line) {
char *output = NULL;
int start, end;
int file;
int mode = 0;
/* 0 = overwrite
1 = concatenate
2 = overwrite and error redirection */
if(setExpressionDelimiters(line, "> *[^<>| ]+", &start, &end)) {
if(start == 0) {
mode = 0;
} else if(line[start - 1] == '>') {
mode = 1;
} else {
/* line[start - 1] == '&' */
mode = 2;
}
/* get one output redirection */
output = getExpression(line, start, end, 1);
if(mode == 1) {
file = open(output, O_WRONLY|O_APPEND|O_CREAT, 0644);
} else {
remove(output);
file = open(output, O_WRONLY|O_CREAT, 0644);
if (mode == 2) {
/* try to redirect output */
if(dup2(file, STDERR_FILENO) < 0) {
perror("Failed to duplicate output file descriptor");
}
}
}
if (file < 0) {
perror("Failed to create output file");
}
if (dup2(file, STDOUT_FILENO) < 0) {
perror("Failed to duplicate output file descriptor");
}
close(file);
free(output);
}
}
int getFgBg(char *line) {
int start, end;
char *expression = NULL; /* '&' or '&[^>]', it's not an error redirection */
if(setExpressionDelimiters(line, "&($|[^>])", &start, &end)) {
expression = getExpression(line, start, end, 0); /* find start */
line[start] = ' ';
free(expression);
return BACKGROUND;
}
return FOREGROUND;
}
void QgsDataDefinedButton::showExpressionDialog()
{
QgsExpressionBuilderDialog d( const_cast<QgsVectorLayer*>( mVectorLayer ), getExpression() );
if ( d.exec() == QDialog::Accepted )
{
QString newExp = d.expressionText();
setExpression( d.expressionText().trimmed() );
bool hasExp = !newExp.isEmpty();
setUseExpression( hasExp );
setActive( hasExp );
updateGui();
}
activateWindow(); // reset focus to parent window
}
Gpl_type Variable::getType() {
Gpl_type type;
if (getIsMemberVariable()){
if (getExpression() != NULL) {
getSymbol()->get_game_object_value(getExpression()->eval_int())->get_member_variable_type(member,type);
return type;
} else {
getSymbol()->get_game_object_value()->get_member_variable_type(member,type);
return type;
}
} else {
if (getSymbol()->get_type() == INT || getSymbol()->get_type() == INT_ARRAY) {
return INT;
} else if (getSymbol()->get_type() == DOUBLE || getSymbol()->get_type() == DOUBLE_ARRAY) {
return DOUBLE;
} else if (getSymbol()->get_type() == STRING || getSymbol()->get_type() == STRING_ARRAY) {
return STRING;
} else if (getSymbol()->get_type() & GAME_OBJECT) {
return GAME_OBJECT;
} else {
return ANIMATION_BLOCK;
}
}
}
