Example #1
0
/**
* @brief Returns all local variables, including parameters.
*/
VarSet VarsHandler::getLocalVars() const {
	VarSet result;
	for (const auto &p : localVars) {
		result.insert(p.second);
	}
	return result;
}
Example #2
0
VarSet WhySemiring::getVars() const {
  VarSet res;
  for (auto ws : val) {
    res.insert(ws.begin(), ws.end());
  }
  return res;
}
Example #3
0
void RIFActVarBind::getVars(VarSet &vars, const bool include_act_var) const
    throw() {
  if (include_act_var) {
    vars.insert(this->var);
  }
  if (this->frame != NULL) {
    this->frame->getVars(vars);
  }
}
Example #4
0
WhySemiring::WhySemiring(std::string str_val)
{
  if(0 == str_val.compare("1")) {
    this->val = WhySet();
    val.insert(VarSet());
  }
  else if (0 == str_val.compare("0")) {
    this->val = WhySet();
  }
  else {
    this->val = WhySet();
    VarSet tmp = VarSet();
    tmp.insert(Var::GetVarId(str_val));
    val.emplace(tmp);
  }
}
Example #5
0
void RIFTerm::getVars(VarSet &vars) const throw() {
  if (this->type == VARIABLE) {
    RIFVar *v = (RIFVar*)this->state;
    RIFVar v2 = *v;
    vars.insert(v2);
  } else if (this->type == FUNCTION) {
    func_state *f = (func_state*) this->state;
    if (f->args != NULL) {
      RIFTerm *mark = f->args->dptr();
      RIFTerm *end = mark + f->args->size();
      for (; mark != end; ++mark) {
        mark->getVars(vars);
      }
    }
  }
}
/**
* @brief Precomputes @c funcInfo->isAlwaysModifiedBeforeRead for @c traversedFunc.
*/
void OptimFuncInfoCFGTraversal::precomputeAlwaysModifiedVarsBeforeRead() {
	// Initialization.
	funcInfo->varsAlwaysModifiedBeforeRead.clear();
	// Global variables which are read during the computation.
	VarSet readVars;

	// Currently, we only traverse the function's body up to the first compound
	// statement. Moreover, we only consider global variables as the computed
	// piece of information is useless for local variables.
	// TODO Use a CFG traversal for this to improve the analysis.
	ShPtr<Statement> stmt(traversedFunc->getBody());
	while (stmt) {
		if (stmt->isCompound()) {
			// As we are not using a CFG traversal, this is the end of the
			// computation.
			break;
		}

		ShPtr<ValueData> stmtData(va->getValueData(stmt));

		// Handle directly read variables.
		addToSet(stmtData->getDirReadVars(), readVars);

		// Handle function calls (indirectly accessed variables).
		for (auto i = stmtData->call_begin(), e = stmtData->call_end(); i != e; ++i) {
			ShPtr<CallInfo> callInfo(cio->computeCallInfo(*i, traversedFunc));
			for (const auto &var : globalVars) {
				if (callInfo->mayBeRead(var)) {
					readVars.insert(var);
				}
			}
		}

		// Handle directly written variables.
		for (auto i = stmtData->dir_written_begin(), e = stmtData->dir_written_end();
				i != e; ++i) {
			if (hasItem(globalVars, *i) && !hasItem(readVars, *i)) {
				// This global variable is modified before read.
				funcInfo->varsAlwaysModifiedBeforeRead.insert(*i);
			}
		}

		// TODO What about indirectly accessed variables?

		stmt = stmt->getSuccessor();
	}
}
Example #7
0
void ParityAggrLit::index(Grounder *g, Groundable *gr, VarSet &bound)
{
	(void)g;
	if(assign_)
	{
		VarSet vars;
		VarVec bind;
		lower_->vars(vars);
		std::set_difference(vars.begin(), vars.end(), bound.begin(), bound.end(), std::back_insert_iterator<VarVec>(bind));
		if(bind.size() > 0)
		{
			bound.insert(bind.begin(), bind.end());
			return;
		}
	}
	gr->instantiator()->append(new MatchIndex(this));
}
Example #8
0
/* Convert cell vector of Matlab sets to vector<VarSet> */
vector<VarSet> mx2VarSets(const mxArray *vs, const FactorGraph &fg, long verbose, vector<Permute> &perms) {
    vector<VarSet> varsets;

    int n1 = mxGetM(vs);
    int n2 = mxGetN(vs);
    if( n2 != 1 && n1 != 1 )
        mexErrMsgTxt("varsets should be a Nx1 or 1xN cell matrix.");
    size_t nr_vs = n1;
    if( n1 == 1 )
        nr_vs = n2;

    // interpret vs, linear cell array of varsets
    varsets.reserve( nr_vs );
    perms.clear();
    perms.reserve( nr_vs );
    for( size_t cellind = 0; cellind < nr_vs; cellind++ ) {
        if( verbose >= 3 )
            cerr << "reading varset " << cellind << ": " << endl;
        mxArray *cell = mxGetCell(vs, cellind);
        if( verbose >= 3 )
            cerr << "  got cell " << endl;
        size_t nr_mem = mxGetN(cell);
        if( verbose >= 3 )
            cerr << "  number members: " << nr_mem << endl;
        double *members = mxGetPr(cell);
        if( verbose >= 3 )
            cerr << "  got them! " << endl;

        // add variables
        VarSet vsvars;
        if( verbose >= 3 )
            cerr << "  vars: ";
        vector<long> labels(nr_mem,0);
        vector<size_t> dims(nr_mem,0);
        for( size_t mi = 0; mi < nr_mem; mi++ ) {
            labels[mi] = (long)members[mi];
            dims[mi] = fg.var(labels[mi]).states();
            if( verbose >= 3 )
                cerr << labels[mi] << " ";
            vsvars.insert( fg.var(labels[mi]) );
        }
        if( verbose >= 3 )
            cerr << endl;
        DAI_ASSERT( nr_mem == vsvars.size() );
        varsets.push_back(vsvars);

        // calculate permutation matrix
        vector<size_t> perm(nr_mem,0);
        VarSet::iterator j = vsvars.begin();
        for( size_t mi = 0; mi < nr_mem; mi++,j++ ) {
            long gezocht = j->label();
            vector<long>::iterator piet = find(labels.begin(),labels.end(),gezocht);
            perm[mi] = piet - labels.begin();
        }
        if( verbose >= 3 ) {
            cerr << endl << "  perm: ";
            for( vector<size_t>::iterator r=perm.begin(); r!=perm.end(); r++ )
                cerr << *r << " ";
            cerr << endl;
        }
        // create Permute object
        vector<size_t> di(nr_mem,0);
        size_t prod = 1;
        for( size_t k = 0; k < nr_mem; k++ ) {
            di[k] = dims[k];
            prod *= dims[k];
        }
        Permute permindex( di, perm );
        perms.push_back( permindex );
    }

    if( verbose >= 3 ) {
        for(vector<VarSet>::const_iterator I=varsets.begin(); I!=varsets.end(); I++ )
            cerr << *I << endl;
    }

    return( varsets );
}
Example #9
0
void VarTerm::vars(VarSet &vars) const
{
	vars.insert(index_);
}
Example #10
0
void Variable::getVars(VarSet &vars) const
{
	vars.insert(uid_);
}