C++ Val类代码示例

void test_capture_var() {
  template_capture_var<int>(); // OK
  template_capture_var<int&>(); // expected-note{{in instantiation of function template specialization 'template_capture_var<int &>' requested here}}

  Val<float> Obj;
  Obj.set(0.0f); // OK
}

bool
ValHeap::
upheap(int pos)
{
  if(print) cerr << "in Upheap " << pos << " " << array.size() << endl;
  if(pos == 0) return false;
  Val* atp = array[pos];
  assert(atp);
  double merit = atp->fom();
  int   parPos = parent(pos);
  Val* par = array[parPos];
  double pmerit = par->fom();
  if(print) cerr << "merits " << merit << " " << pmerit<< endl;
  if(merit > pmerit)
    {
      array[parPos] = atp;
      array[pos] = par;
      if(print) cerr << "Put " << pos << " in " << parPos << endl;
      upheap(parPos);
      return true;
    }
  else if(print)
    {
      cerr << "upheap of " << merit << "stopped by "
	<< parPos << " " << pmerit << endl;
    }
  return false;
}

Val*
ClassRule::
apply(FullHist* treeh)
{
  Val* trdTree = NULL;
  Bchart* cb = treeh->cb;
  assert(cb);
  Val* curVal = cb->curVal;
  Val* gcurVal = cb->gcurVal;
  int curDir = cb->curDir;
  //int wI = Feature::whichInt;
  //wcerr << "AP " << *this << endl;
  //if(curVal) wcerr << "APCV " << *curVal << endl;
  if(rel_ == 0)
    {
      trdTree = gcurVal;
    }
  else if(rel_ == 1) trdTree = sibling_tree(curVal, curDir);
  else if(rel_ == 2) trdTree = rel2_tree(curVal, curDir);
  else if(rel_ == 4) trdTree = curVal;
  else error(L"bad relation");
  if(!trdTree)
    {
      return NULL;
    }
  int ct = trdTree->trm();
  //wcerr << "foudn " << t_ << " " << ct << " " << *trdTree << endl;
  if(t_ != ct)
    {
      return NULL;
    }
  return trdTree;
}

int Assignement::execute(Env* e, Store* s) {
	Val v = eval(s,e);
	
	if(v.getType() == EMPTY) {
		return 1;
	}
	return 0;
}

bool
operator==(Val& v1, Val& v2)
{
  if(v1.edge() != v2.edge()) return false;
  shortIter si2 = v2.vec().begin();
  for(shortIter si = v1.vec().begin(); si != v1.vec().end() ; si++)
    {
      if((*si) != (*si2)) return false;
      si2++;
    }
  return true;
}

int
tree_ruleHead_third(FullHist* treeh)
{
  Val* specTree = NULL;
  if(Feature::isLM) specTree = tree_ruleTree(treeh, 2);
  if(specTree)
    {
      FullHist* pt = treeh->back;
      if(!pt) return nullWordInt;
      int ans = pt->hd->toInt();
      return ans;
    }
  Val* trdtree = tree_ruleTree(treeh,3);
  if(!trdtree) return nullWordInt;
  else return trdtree->wrd();
}

int
fh_parent_head(FullHist* tree)
{
  Val* spectree = NULL;
  if(Feature::isLM) spectree = tree_ruleTree(tree, 2);
  if(spectree)
    {
      //cerr << "found  st " << endl;
      return spectree->wrd();
    }
  FullHist* pt = tree->back;
  if(!pt) return nullWordInt;
  int ans = pt->hd->toInt();
  assert(ans >= -1);
  return ans;
}

				template<typename T> inline static void toVal(Val& mV, T&& mX)
				{
					Arr result; result.reserve(sizeof...(TArgs));
					// TODO: fwd macro?
					tplFor([&result](auto&& mI){ result.emplace_back(fwd<decltype(mI)>(mI)); }, fwd<T>(mX));
					mV.setArr(std::move(result));
				}

	void AvgAggrLitPrinter::weight(const Val &v)
	{
		int num = v.number();
		min_ = std::min(min_, num);
		max_ = std::max(max_, num);
		output_->addToList(symbol_, v);
	}

 inline static bool SSVU_ATTRIBUTE(pure) areArrItemsOfType(const Val& mV) noexcept
 {
     SSVU_ASSERT(mV.is<Arr>());
     for(const auto& v : mV.getArr())
         if(!v.template isNoNum<T>()) return false;
     return true;
 }

				template<typename T> inline static void toVal(Val& mV, T&& mX)
				{
					mV.setArr(Arr
					{
						Val{moveIfRValue<decltype(mX)>(mX.first)},
						Val{moveIfRValue<decltype(mX)>(mX.second)}
					});
				}

     inline static EnableIf <
     TI<sizeof...(TArgs), bool> isTpl(const Val& mV) noexcept
 {
     SSVU_ASSERT(mV.is<Arr>() && mV.getArr().size() > TI);
     if(!mV[TI].isNoNum<TplArg<TI, Tpl<TArgs...>>>())
         return false;
     return isTpl<TI + 1, TArgs...>(mV);
 }

Val *Parser::parseLitVal(){
	Val *v;
	Type *ty;
	switch( curr() ){
	case T_INTCONST:
		v=new Val( toint(text()) );
		ty=Type::int32;
		break;
	case T_FLOATCONST:
		v=new Val( tofloat(text()) );
		ty=Type::float32;
		break;
	default:
		exp( "integer or floating point literal value" );
	}
	next();
	ty=parseLitType( ty );
	return v->cast( ty );
}

tribool ParityAggrLit::accumulate(Grounder *g, const Val &weight, Lit &lit) throw(const Val*)
{
	(void)g;
	int32_t num = weight.number();
	if(num % 2 == 0 && !head()) return true;
	if(set_ && !lit.testUnique(uniques_)) return true;
	if(!lit.fact()) factOnly_ = false;
	else if (num % 2 != 0) fixed_ = !fixed_;
	return lit.fact() ? tribool(true) : unknown;
}

Val Call::eval(Store* s, Env* e) {
	function::Function *f = NULL; 
	NFunction *nf = NULL; 
	Val v = e->get(this->name);
	if(VERBOSE)
		cout << "call => " << name << endl;
		
	if(v.getType() == FUNCTION) {
		if(v.to_function()->getType() == NATIVE_FUNCTION) {
			nf = dynamic_cast<NFunction*>(v.to_function());
		}
		else {
			f = dynamic_cast<function::Function*>(v.to_function());
		}
	}
	else {		
		f = ::getProgFunction(name);
		nf = ::getNativeFunction(name);
	}
	
	
	
	if(f != NULL) {
		Env *ne = new Env(f->getNbVar());
		if(argument.size() != f->getArity()) {
			cout << "wrong arity during calling " << name << ", expected " << f->getArity() << ", " <<  argument.size() << " given " << endl;
			exit(1);
		}
		for(unsigned int i = 0; i < argument.size(); i++) {			
			ne->set(i, argument[i]->eval(s,e), f->getVarName(i));			
		}
		f->execute(ne, s);
		Val v = ne->get(f->getNbVar()); 
		delete ne;
		return v;		
	}
	if(nf != NULL) {
		return nf->eval(s,e,argument, this->line(), this->file());
	}
	cout << "undefined symbol "  << name << endl;
	return Val();
}