Expression::Ptr ExpressionFactory::createExpression(const QString &expr, const StaticContext::Ptr &context, const QXmlQuery::QueryLanguage lang, const SequenceType::Ptr &requiredType, const QUrl &queryURI, const QXmlName &initialTemplateName) { if(lang == QXmlQuery::XSLT20) { QByteArray query(expr.toUtf8()); QBuffer buffer(&query); buffer.open(QIODevice::ReadOnly); return createExpression(&buffer, context, lang, requiredType, queryURI, initialTemplateName); } else { return createExpression(Tokenizer::Ptr(new XQueryTokenizer(expr, queryURI)), context, lang, requiredType, queryURI, initialTemplateName); } }
Expression::Ptr ExpressionFactory::createExpression(QIODevice *const device, const StaticContext::Ptr &context, const QXmlQuery::QueryLanguage lang, const SequenceType::Ptr &requiredType, const QUrl &queryURI, const QXmlName &initialTemplateName) { Q_ASSERT(device); Q_ASSERT(device->isReadable()); Tokenizer::Ptr tokenizer; if(lang == QXmlQuery::XQuery10) { tokenizer = Tokenizer::Ptr(new XQueryTokenizer(QString::fromUtf8(device->readAll()), queryURI)); } else { Q_ASSERT(lang == QXmlQuery::XSLT20); tokenizer = Tokenizer::Ptr(new XSLTTokenizer(device, queryURI, context, context->namePool())); } return createExpression(tokenizer, context, lang, requiredType, queryURI, initialTemplateName); }
/*! \reimp */ void QThemeLevelItem::loadAttributes(QXmlStreamReader &reader) { QThemeImageItem::loadAttributes(reader); if (!reader.attributes().value("count").isEmpty()) d->count = reader.attributes().value("count").toString().toInt(); if (!reader.attributes().value("min").isEmpty()) d->min = reader.attributes().value("min").toString().toInt(); if (!reader.attributes().value("max").isEmpty()) d->max = reader.attributes().value("max").toString().toInt(); if (!reader.attributes().value("loop").isEmpty()) d->loop = reader.attributes().value("loop").toString().toInt(); if (!reader.attributes().value("looprev").isEmpty()) d->looprev = reader.attributes().value("looprev").toString().toInt(); if (d->animInfo) delete d->animInfo; d->animInfo = new QThemeAnimationFrameInfo(this, reader.attributes().value("delay").toString().toInt()); if (!reader.attributes().value("play").isEmpty()) { QString play = reader.attributes().value("play").toString(); if (isExpression(play)) { d->playExpression = createExpression(strippedExpression(play)); if (d->playExpression) expressionChanged(d->playExpression); } else if (play != "no") { /* if (!attribute("playing"))*/ start(); } } }
QgsScaleExpression::QgsScaleExpression( Type type, const QString& baseExpression, double minValue, double maxValue, double minSize, double maxSize, double nullSize, double exponent ) : QgsExpression( createExpression( type, baseExpression, minValue, maxValue, minSize, maxSize, nullSize, exponent ) ) , mExpression( baseExpression ) , mType( type ) , mMinSize( minSize ) , mMaxSize( maxSize ) , mMinValue( minValue ) , mMaxValue( maxValue ) , mNullSize( nullSize ) , mExponent( 1 ) { switch ( type ) { case Linear: mExponent = 1; break; case Area: mExponent = .5; break; case Flannery: mExponent = .57; break; case Exponential: mExponent = exponent; break; case Unknown: break; } }
struct memorycontainer* appendLetWithOperatorStatement(char * identifier, struct memorycontainer* expressionContainer, unsigned char operator) { unsigned char token=0; if (operator == 0) { token=ADD_TOKEN; } else if (operator == 1) { token=SUB_TOKEN; } else if (operator == 2) { token=MUL_TOKEN; } else if (operator == 3 || operator == 6) { token=DIV_TOKEN; } else if (operator == 4) { token=MOD_TOKEN; } else if (operator == 5) { token=POW_TOKEN; } else { fprintf(stderr, "Can not find operator with id of %c\n", operator); } struct memorycontainer* rhs=createExpression(token, createIdentifierExpression(identifier), expressionContainer); if (operator == 6) { // Floor struct memorycontainer* mathCommand=createIntegerExpression(FLOOR_MATHS_OP); struct stack_t * argStack=getNewStack(); pushExpression(argStack, mathCommand); pushExpression(argStack, rhs); rhs=appendNativeCallFunctionStatement(NATIVE_RTL_MATH_STR, argStack, NULL); } return appendLetStatement(identifier, rhs); }
/* getPhiFunction * * This function will compare the liveness list from two parent * and create a phifunction in SSA form without the condition * * @listA a list of subscripts that was living at parent A * @listB a list of subscripts that was living at parent B * @subs The subscript that required a phiFunction * */ Expression* getPhiFunction(LinkedList* listA, LinkedList* listB, Subscript* subs){ Subscript *subsA = NULL; Subscript *subsB = NULL; ListElement *ptrA, *ptrB; ptrA = listA->head; ptrB = listB->head; int subsName = subs->name; /***************************************************************** * Find the latest index for operand A and operand B at this point *****************************************************************/ while(ptrA != NULL && ((Subscript*)ptrA->node)->name != subsName) ptrA = ptrA->next; if(ptrA != NULL) subsA = ptrA->node; else ThrowError(ERR_UNDECLARE_VARIABLE, "Undefine reference to Subscript %c", subsName); while(ptrB != NULL && ((Subscript*)ptrB->node)->name != subsName) ptrB = ptrB->next; if(ptrB != NULL) subsB = ptrB->node; else ThrowError(ERR_UNDECLARE_VARIABLE, "Undefine reference to Subscript %c", subsName); //Create the phifunction without the condition yet Expression* phiFunction = createExpression(subs->name, PHI_FUNC, subsA->name, subsB->name, 0); phiFunction->id.index = subs->index + 1; phiFunction->oprdA.index = subsA->index; phiFunction->oprdB.index = subsB->index; return phiFunction; }
struct memorycontainer* createFloorDivExpression(struct memorycontainer* expression1, struct memorycontainer* expression2) { struct memorycontainer* divExpr=createExpression(DIV_TOKEN, expression1, expression2); struct memorycontainer* mathCommand=createIntegerExpression(FLOOR_MATHS_OP); struct stack_t * argStack=getNewStack(); pushExpression(argStack, mathCommand); pushExpression(argStack, divExpr); divExpr=appendNativeCallFunctionStatement(NATIVE_RTL_MATH_STR, argStack, NULL); return divExpr; }
static void createRules( strus::PatternMatcherInstanceInterface* ptinst, const GlobalContext* ctx, const std::vector<TreeNode*> treear) { std::vector<TreeNode*>::const_iterator ti = treear.begin(), te = treear.end(); for (unsigned int tidx=0; ti != te; ++ti,++tidx) { createExpression( ptinst, ctx, *ti); ptinst->definePattern( (*ti)->name(), ""/*formatstring*/, true); } }
QgsScaleExpression::QgsScaleExpression( Type type, const QString& baseExpression, double minValue, double maxValue, double minSize, double maxSize ) : QgsExpression( createExpression( type, baseExpression, minValue, maxValue, minSize, maxSize ) ) , mExpression( baseExpression ) , mType( type ) , mMinSize( minSize ) , mMaxSize( maxSize ) , mMinValue( minValue ) , mMaxValue( maxValue ) { }
Expression::Ptr ExpressionFactory::createExpression(QIODevice *const device, const StaticContext::Ptr &context, const LanguageAccent lang, const SequenceType::Ptr &requiredType, const QUrl &queryURI) { Q_ASSERT(device); Q_ASSERT(device->isReadable()); // TODO We need to do encoding detection. return createExpression(QString::fromUtf8(device->readAll()), context, lang, requiredType, queryURI); }
/*! \reimp */ void QThemeLevelItem::constructionComplete() { if (!d->text.isEmpty()) { if (isExpression(d->text)) { d->frameExpression = createExpression(strippedExpression(d->text)); if (d->frameExpression != 0) expressionChanged(d->frameExpression); } else { setFrame(d->text.toInt()); } d->text = QString(); } QThemeImageItem::constructionComplete(); }
static void createExpression( strus::PatternMatcherInstanceInterface* ptinst, const GlobalContext* ctx, const TreeNode* tree) { if (tree->term() && tree->args().empty()) { ptinst->pushTerm( tree->term()); } else { std::vector<TreeNode*>::const_iterator ti = tree->args().begin(), te = tree->args().end(); for (; ti != te; ++ti) { createExpression( ptinst, ctx, *ti); } ptinst->pushExpression( tree->op(), tree->args().size(), tree->range(), tree->cardinality()); } if (tree->variable()) { ptinst->attachVariable( tree->variable()); } }
void QgsSizeScaleWidget::updatePreview() { if ( !mSymbol || !mLayer ) return; QScopedPointer<QgsScaleExpression> expr( createExpression() ); QList<double> breaks = QgsSymbolLayerV2Utils::prettyBreaks( expr->minValue(), expr->maxValue(), 4 ); treeView->setIconSize( QSize( 512, 512 ) ); mPreviewList.clear(); int widthMax = 0; for ( int i = 0; i < breaks.length(); i++ ) { QScopedPointer< QgsMarkerSymbolV2 > symbol( dynamic_cast<QgsMarkerSymbolV2*>( mSymbol->clone() ) ); symbol->setDataDefinedSize( QgsDataDefined() ); symbol->setDataDefinedAngle( QgsDataDefined() ); // to avoid symbol not beeing drawn symbol->setSize( expr->size( breaks[i] ) ); QgsSymbolV2LegendNode node( mLayerTreeLayer, QgsLegendSymbolItemV2( symbol.data(), QString::number( i ), 0 ) ); const QSize sz( node.minimumIconSize() ); node.setIconSize( sz ); QScopedPointer< QStandardItem > item( new QStandardItem( node.data( Qt::DecorationRole ).value<QPixmap>(), QString::number( breaks[i] ) ) ); widthMax = qMax( sz.width(), widthMax ); mPreviewList.appendRow( item.take() ); } // center icon and align text left by giving icons the same width // @todo maybe add some space so that icons don't touch for ( int i = 0; i < breaks.length(); i++ ) { QPixmap img( mPreviewList.item( i )->icon().pixmap( mPreviewList.item( i )->icon().actualSize( QSize( 512, 512 ) ) ) ); QPixmap enlarged( widthMax, img.height() ); // fill transparent and add original image enlarged.fill( Qt::transparent ); QPainter p( &enlarged ); p.drawPixmap( QPoint(( widthMax - img.width() ) / 2, 0 ), img ); p.end(); mPreviewList.item( i )->setIcon( enlarged ); } }
struct memorycontainer* createLeqExpression(struct memorycontainer* expression1, struct memorycontainer* expression2) { return createExpression(LEQ_TOKEN, expression1, expression2); }
static int compute_prob(void) /* this is the function that implements the compute_prob predicate used in pp.pl */ { YAP_Term out,arg1,arg2,arg3,arg4; variables vars; expr expression; DdNode * function; DdManager * mgr; int nBVar,i,intBits,create_dot; FILE * file; DdNode * array[1]; double prob; char * onames[1]; char inames[1000][20]; char * names[1000]; tablerow * nodes; arg1=YAP_ARG1; arg2=YAP_ARG2; arg3=YAP_ARG3; arg4=YAP_ARG4; mgr=Cudd_Init(0,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0); create_dot=YAP_IntOfTerm(arg4); vars=createVars(arg1,mgr,create_dot,inames); //Cudd_PrintInfo(mgr,stderr); /* automatic variable reordering, default method CUDD_REORDER_SIFT used */ //printf("status %d\n",Cudd_ReorderingStatus(mgr,&order)); //printf("order %d\n",order); Cudd_AutodynEnable(mgr,CUDD_REORDER_SAME); /* Cudd_AutodynEnable(mgr, CUDD_REORDER_RANDOM_PIVOT); printf("status %d\n",Cudd_ReorderingStatus(mgr,&order)); printf("order %d\n",order); printf("%d",CUDD_REORDER_RANDOM_PIVOT); */ expression=createExpression(arg2); function=retFunction(mgr,expression,vars); /* the BDD build by retFunction is converted to an ADD (algebraic decision diagram) because it is easier to interpret and to print */ //add=Cudd_BddToAdd(mgr,function); //Cudd_PrintInfo(mgr,stderr); if (create_dot) /* if specified by the user, a dot file for the BDD is written to cpl.dot */ { nBVar=vars.nBVar; for(i=0; i<nBVar; i++) names[i]=inames[i]; array[0]=function; onames[0]="Out"; file = open_file("cpl.dot", "w"); Cudd_DumpDot(mgr,1,array,names,onames,file); fclose(file); } nodes=init_table(vars.nBVar); intBits=sizeof(unsigned int)*8; prob=Prob(function,vars,nodes); out=YAP_MkFloatTerm(prob); destroy_table(nodes,vars.nBVar); Cudd_Quit(mgr); for(i=0; i<vars.nVar; i++) { free(vars.varar[i].probabilities); free(vars.varar[i].booleanVars); } free(vars.varar); free(vars.bVar2mVar); for(i=0; i<expression.nTerms; i++) { free(expression.terms[i].factors); } free(expression.terms); return(YAP_Unify(out,arg3)); }
QgsDataDefined QgsSizeScaleWidget::dataDefined() const { QScopedPointer<QgsScaleExpression> exp( createExpression() ); return QgsDataDefined( exp.data() ); }
struct memorycontainer* createModExpression(struct memorycontainer* expression1, struct memorycontainer* expression2) { return createExpression(MOD_TOKEN, expression1, expression2); }
struct memorycontainer* createDivExpression(struct memorycontainer* expression1, struct memorycontainer* expression2) { return createExpression(DIV_TOKEN, expression1, expression2); }
struct memorycontainer* createSubExpression(struct memorycontainer* expression1, struct memorycontainer* expression2) { return createExpression(SUB_TOKEN, expression1, expression2); }
struct memorycontainer* createGtExpression(struct memorycontainer* expression1, struct memorycontainer* expression2) { return createExpression(GT_TOKEN, expression1, expression2); }
struct memorycontainer* createPowExpression(struct memorycontainer* expression1, struct memorycontainer* expression2) { return createExpression(POW_TOKEN, expression1, expression2); }
static int compute_prob(void) /* this is the function that implements the compute_prob predicate used in pp.pl */ { YAP_Term out,arg1,arg2,arg3,arg4; array_t * variables,* expression, * bVar2mVar; DdNode * function, * add; DdManager * mgr; int nBVar,i,j,intBits,create_dot; FILE * file; DdNode * array[1]; char * onames[1]; char inames[1000][20]; char * names[1000]; GHashTable * nodes; /* hash table that associates nodes with their probability if already computed, it is defined in glib */ Cudd_ReorderingType order; arg1=YAP_ARG1; arg2=YAP_ARG2; arg3=YAP_ARG3; arg4=YAP_ARG4; mgr=Cudd_Init(0,0,CUDD_UNIQUE_SLOTS,CUDD_CACHE_SLOTS,0); variables=array_alloc(variable,0); bVar2mVar=array_alloc(int,0); create_dot=YAP_IntOfTerm(arg4); createVars(variables,arg1,mgr,bVar2mVar,create_dot,inames); //Cudd_PrintInfo(mgr,stderr); /* automatic variable reordering, default method CUDD_REORDER_SIFT used */ //printf("status %d\n",Cudd_ReorderingStatus(mgr,&order)); //printf("order %d\n",order); Cudd_AutodynEnable(mgr,CUDD_REORDER_SAME); /* Cudd_AutodynEnable(mgr, CUDD_REORDER_RANDOM_PIVOT); printf("status %d\n",Cudd_ReorderingStatus(mgr,&order)); printf("order %d\n",order); printf("%d",CUDD_REORDER_RANDOM_PIVOT); */ expression=array_alloc(array_t *,0); createExpression(expression,arg2); function=retFunction(mgr,expression,variables); /* the BDD build by retFunction is converted to an ADD (algebraic decision diagram) because it is easier to interpret and to print */ add=Cudd_BddToAdd(mgr,function); //Cudd_PrintInfo(mgr,stderr); if (create_dot) /* if specified by the user, a dot file for the BDD is written to cpl.dot */ { nBVar=array_n(bVar2mVar); for(i=0;i<nBVar;i++) names[i]=inames[i]; array[0]=add; onames[0]="Out"; file = open_file("cpl.dot", "w"); Cudd_DumpDot(mgr,1,array,names,onames,file); fclose(file); } nodes=g_hash_table_new(my_hash,my_equal); intBits=sizeof(unsigned int)*8; /* dividend is a global variable used by my_hash it is equal to an unsigned int with binary representation 11..1 */ dividend=1; for(j=1;j<intBits;j++) { dividend=(dividend<<1)+1; } out=YAP_MkFloatTerm(Prob(add,variables,bVar2mVar,nodes)); g_hash_table_foreach (nodes,dealloc,NULL); g_hash_table_destroy(nodes); Cudd_Quit(mgr); array_free(variables); array_free(bVar2mVar); array_free(expression); return(YAP_Unify(out,arg3)); }