//=================================================================================
/*virtual*/ Node::ValueStringError BoundedPointListNode::SetValueFromString( const std::string& valueString )
{
	VarMap varMap;
	if( !ConvertValueStringToVarMap( valueString, varMap ) )
		return VSE_SYNTAX;

	Bounds trialBounds = bounds;
	if( varMap.end() != varMap.find( "xMin" ) )
		trialBounds.min.set_e1( varMap[ "xMin" ] );
	if( varMap.end() != varMap.find( "xMax" ) )
		trialBounds.max.set_e1( varMap[ "xMax" ] );
	if( varMap.end() != varMap.find( "yMin" ) )
		trialBounds.min.set_e2( varMap[ "yMin" ] );
	if( varMap.end() != varMap.find( "yMax" ) )
		trialBounds.max.set_e2( varMap[ "yMax" ] );

	if( trialBounds == bounds )
		return VSE_NO_CHANGE;
	if( !trialBounds.IsValid() )
		return VSE_INVALID;
	if( !SetBounds( trialBounds ) )
		return VSE_INVALID;

	return VSE_NONE;
}
Exemple #2
0
__pu_value *reg_var(Pu *L, const PuString &varname)
{
    __pu_value *got = NULL;
    VarMap *varmap = L->varstack.top();
    VarMap::Bucket_T *it = varmap->find(varname);
    if (it != 0)
    {
        got = &(it->value);
    }
    else 
    {
        VarMap *varmap = L->varstack.bottom();
        VarMap::Bucket_T *it = varmap->find(varname);
        if (it != 0)
        {
            got = &(it->value);
        }
    }

    if (got == NULL)
    {
        VarMap *varmap = L->varstack.top();
        VarMap::Bucket_T *ret = varmap->insert(varname, __pu_value(L));
        got = &(ret->value);
    }

    return got;
}
//=================================================================================
/*virtual*/ Node::ValueStringError BoundedIntegerNode::SetValueFromString( const std::string& valueString )
{
    VarMap varMap;
    if( !ConvertValueStringToVarMap( valueString, varMap ) )
        return VSE_SYNTAX;

    Data trialData = data;
    if( varMap.end() != varMap.find( "min" ) )
        trialData.min = int( varMap[ "min" ] );
    if( varMap.end() != varMap.find( "max" ) )
        trialData.max = int( varMap[ "max" ] );
    if( varMap.end() != varMap.find( "value" ) )
        trialData.value = int( varMap[ "value" ] );
    if( varMap.end() != varMap.find( "multiple" ) )
        trialData.multiple = int( varMap[ "multiple" ] );

    if( !trialData.IsValid() )
        return VSE_INVALID;

    if( trialData == data )
        return VSE_NO_CHANGE;

    data = trialData;
    return VSE_NONE;
}
Exemple #4
0
void get_var(Pu *L, const PuString &name, __pu_value *&v)
{
	VarMap *pvarmap = L->varstack.top();

	VarMap::Bucket_T *ik = pvarmap->find(name);
	if (ik != 0)
	{
		v = &ik->value;
		return;
	}

	pvarmap = L->varstack.bottom();
	ik = pvarmap->find(name);
	if (ik != 0)
	{
		v = &ik->value;
		return;
	}

	if (L->upvalue && L->upvalue != pvarmap)
	{
		pvarmap = L->upvalue;
		ik = pvarmap->find(name);
		if (ik != 0)
		{
			v = &ik->value;
			return;
		}
	}

    MAKE_TEMP_VALUE(v);
	error(L,7);
}
Exemple #5
0
bool generateOutTuple(std::vector<std::string> &s, lindaTuple &newTuple, 
		      VarMap &localVars, 
		      FunctSet &userDefinedFuncs, LoopMap &loopSymbols, int threadNum) {
  for (std::vector<std::string>::iterator it = s.begin(); it != s.end(); it++) {
    if (isExp(*it)) {
      int result = evaluateExp(*it, loopSymbols, userDefinedFuncs, localVars, threadNum);
      if (result != -1) {
	newTuple.push_back(new intObj(result));
      } else {
	// wait and block
      }
    } else if (isVarPattern(*it)) {
      if (localVars.find(*it) != localVars.end()) {
	newTuple.push_back(localVars[*it]);
      } else {
	std::cout<< "Can not find local var " << *it << std::endl;
	return false;
      }
    }
    else if (isString(*it))
      newTuple.push_back(new stringObj(*it));
    else if (isInt(*it))
      newTuple.push_back(new intObj(atoi(it->c_str())));
    else if (isDouble(*it))
      newTuple.push_back(new doubleObj(atof(it->c_str())));
    else {
      std::cout << "Parse input error: " << *it << std::endl;
      exit(EXIT_FAILURE);
    }
  }
  return true;
}
Exemple #6
0
    AstVarScope* createVarSc(AstVarScope* oldvarscp, string name, int width/*0==fromoldvar*/) {
	// Because we've already scoped it, we may need to add both the AstVar and the AstVarScope
	if (!oldvarscp->scopep()) oldvarscp->v3fatalSrc("Var unscoped");
	AstVar* varp;
	AstNodeModule* addmodp = oldvarscp->scopep()->modp();
	// We need a new AstVar, but only one for all scopes, to match the new AstVarScope
	VarMap::iterator iter = m_modVarMap.find(make_pair(addmodp,name));
	if (iter != m_modVarMap.end()) {
	    // Created module's AstVar earlier under some other scope
	    varp = iter->second;
	} else {
	    if (width==0) {
		varp = new AstVar (oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, oldvarscp->varp());
		varp->widthSignedFrom(oldvarscp);
	    } else { // Used for vset and dimensions, so can zero init
		varp = new AstVar (oldvarscp->fileline(), AstVarType::BLOCKTEMP, name, AstBitPacked(), width);
	    }
	    addmodp->addStmtp(varp);
	    m_modVarMap.insert(make_pair(make_pair(addmodp, name), varp));
	}

	AstVarScope* varscp = new AstVarScope (oldvarscp->fileline(), oldvarscp->scopep(), varp);
	oldvarscp->scopep()->addVarp(varscp);
	return varscp;
    }
Exemple #7
0
static __pu_value *get_varref(Pu *L, PuString &name)
{
    VarMap *pvarmap = L->varstack.top();
    VarMap::Bucket_T *ik = pvarmap->find(name);
    if (ik != 0)
    {
        return &(ik->value);
    }

    pvarmap = L->varstack.bottom();
    ik = pvarmap->find(name);
    if (ik != 0)
    {
        return &(ik->value);
    }

    return NULL;
}
//=================================================================================
/*virtual*/ Node::ValueStringError BivectorE3GANode::SetValueFromString( const std::string& valueString )
{
	VarMap varMap;
	if( !ConvertValueStringToVarMap( valueString, varMap ) )
		return VSE_SYNTAX;

	// Get the new bivector.
	c3ga::bivectorE3GA trialBivector = *bivector;
	if( varMap.end() != varMap.find( "yz" ) )
		trialBivector.set_e2_e3( varMap[ "yz" ] );
	if( varMap.end() != varMap.find( "zx" ) )
		trialBivector.set_e3_e1( varMap[ "zx" ] );
	if( varMap.end() != varMap.find( "xy" ) )
		trialBivector.set_e1_e2( varMap[ "xy" ] );
	
	// Validate the new bivector.
	if( c3ga::norm( trialBivector ) > maxArea )
		return VSE_INVALID;

	// Get the new max-area.
	double trialMaxArea = maxArea;
	if( varMap.end() != varMap.find( "maxArea" ) )
		trialMaxArea = varMap[ "maxArea" ];

	// Validate the new max-area.
	if( trialMaxArea <= 0.0 )
		return VSE_INVALID;
	
	// Reject if no change occurred.
	if( c3ga::equals( trialBivector, *bivector, 0.0 ) && trialMaxArea == maxArea )
		return VSE_NO_CHANGE;

	// Accept the new values.
	*bivector = trialBivector;
	maxArea = trialMaxArea;
	return VSE_NONE;
}
Exemple #9
0
    virtual void visit(AstVarRef* nodep, AstNUser*) {
	if (nodep->lvalue() && !nodep->user2()) {
	    nodep->user2(true); // mark this ref as visited
	    AstVar* key = nodep->varp();

	    VarMap::iterator it = m_lhsmapp->find(key);
	    if (it == m_lhsmapp->end()) {
		// this key does not exist yet, so create it
		RefVec* refs = new RefVec();
		refs->push_back(nodep);
		m_lhsmapp->insert(pair<AstVar*, RefVec*>(key, refs));
	    } else {
		(*it).second->push_back(nodep);
	    }
	    nodep->user3p(m_sel); // attach the sel to this varref
	}
	nodep->iterateChildren(*this);
    }
Exemple #10
0
int evaluateExp(std::string expr, LoopMap &loopSymbols, FunctSet &userDefinedFuncs, VarMap &localVars, int threadNum) {
  int result = -1;
  std::string expName = (expr).substr(0, (expr).find("("));
  std::string expNameT = expName + std::to_string(static_cast<long long int>(threadNum));
  size_t start = (expr).find("(") + 1;
  size_t end = (expr).find_last_of(")");
  std::string params = (expr).substr(start, end - start);

  if (userDefinedFuncs.find(expNameT) != userDefinedFuncs.end()) {
    // Case 1: The expression is a user defined function
    if (!isInt(params)) {
      if (loopSymbols.find(params) != loopSymbols.end()) {
	params = std::to_string(static_cast<long long int>(loopSymbols[params]));
      } else if (localVars.find(params) != localVars.end()) {
	intObj *intO = dynamic_cast<intObj *>(localVars[params]);
	params = std::to_string(static_cast<long long int>(intO->get()));
      }
    }
    int status = system(("./" + expNameT + " " + params).c_str());
    result = WEXITSTATUS(status);
  } else {
    // Case 2: The expression is inp or rdp
    //std::cout << "condition is " << expr << std::endl;
    LINDA_TYPE type = findFunctionType(expr);
    //std::cout << "expr type is " << type << std::endl;
    std::vector<std::string> elems;
    if (type == INP) {
      getInOutElems(expr, elems);
      return inp(elems, localVars, userDefinedFuncs, loopSymbols, threadNum);
    } else if (type == RDP) {
      getInOutElems(expr, elems);
      return rdp(elems, localVars, userDefinedFuncs, loopSymbols, threadNum);
    } else {
      std::cout << "Couldn't evaluate expression " << expr << std::endl;
      std::cout << "No boolean return type or couldn't find expr name" << std::endl;
      exit(EXIT_FAILURE);
    } 
  }
  return result;
}
Exemple #11
0
//=================================================================================
/*virtual*/ Node::ValueStringError ConeNode::SetValueFromString( const std::string& valueString )
{
	ValueStringError vse = VectorE3GANode::SetValueFromString( valueString );
	if( !( vse == VSE_NONE || vse == VSE_NO_CHANGE ) )
		return vse;

	VarMap varMap;
	if( !ConvertValueStringToVarMap( valueString, varMap ) )
		return VSE_SYNTAX;

	double trialConeAngle = coneAngle;
	if( varMap.end() != varMap.find( "coneAngle" ) )
		trialConeAngle = varMap[ "coneAngle" ];

	if( trialConeAngle < 0.0 || trialConeAngle > M_PI )
		return VSE_INVALID;

	if( trialConeAngle == coneAngle && vse == VSE_NO_CHANGE )
		return VSE_NO_CHANGE;

	coneAngle = trialConeAngle;
	return VSE_NONE;
}