Esempio n. 1
0
Expr const*
Substitution::subst(Abs const* e) const
{
    Var const* v = cast<Var>(subst(e->var()));
    Expr const* d = subst(e->expr());
    return new Abs(e->type(), v, d);
}
Esempio n. 2
0
expr_ref sym_expr::accept(expr* e) {
    ast_manager& m = m_t.get_manager();
    expr_ref result(m);
    switch (m_ty) {
    case t_pred: {
        var_subst subst(m);
        subst(m_t, 1, &e, result);
        break;
    }
    case t_char:
        SASSERT(m.get_sort(e) == m.get_sort(m_t));
        result = m.mk_eq(e, m_t);
        break;
    case t_range: {
        bv_util bv(m);
        rational r1, r2, r3;
        unsigned sz;
        if (bv.is_numeral(m_t, r1, sz) && bv.is_numeral(e, r2, sz) && bv.is_numeral(m_s, r3, sz)) {
            result = m.mk_bool_val((r1 <= r2) && (r2 <= r3));            
        }
        else {
            result = m.mk_and(bv.mk_ule(m_t, e), bv.mk_ule(e, m_s));
        }
        break;
    }
    }
    return result;
}
Esempio n. 3
0
Lateq* DocCompiler::compileLateq(Tree L, Lateq* compiledEqn)
{
  // cerr << "Documentator : compileLateq : L = "; printSignal(L, stdout, 0); cerr << endl;

  fLateq = compiledEqn; ///< Dynamic field !
  int priority = 0;

  for(int i = 0; isList(L); L = tl(L), i++)
  {
    Tree sig = hd(L);
    Tree id;

    if(getSigNickname(sig, id))
    {
      // cerr << "Documentator : compileLateq : NICKNAMEPROPERTY = " << tree2str(id) << endl;
      fLateq->addOutputSigFormula(subst("$0(t) = $1", tree2str(id), CS(sig, priority), docT(i)));
    }
    else
    {
      // cerr << "Documentator : compileLateq : NO NICKNAMEPROPERTY" << endl;
      if(fLateq->outputs() == 1)
      {
        fLateq->addOutputSigFormula(subst("y(t) = $0", CS(sig, priority)));
        gDocNoticeFlagMap["outputsig"] = true;
      }
      else
      {
        fLateq->addOutputSigFormula(subst("$0(t) = $1", getFreshID("y"), CS(sig, priority)));
        gDocNoticeFlagMap["outputsigs"] = true;
      }
    }
  }

  return fLateq;
}
Esempio n. 4
0
/**
 * Generate the equation of a write table, which content is time dependent.
 * It is basically a signal of vectors.
 */
string DocCompiler::generateDocWriteTbl(Tree /*tbl*/, Tree size, Tree isig, Tree widx, Tree wsig)
{
  string vname, ctype;
  string init = CS(isig, 0);
  int n;

  if(!isSigInt(size, &n))
  {
    cerr << "error in DocCompiler::generateDocWriteTbl() : "
         << *size
         << " is not an integer expression and can't be used as a table size' "
         << endl;
  }

  // allocate a name w_i for the table
  getTypedNames(getCertifiedSigType(isig), "w", ctype, vname);

  // add a comment on tables in the notice
  gDocNoticeFlagMap["tablesigs"] = true;

  // describe the table equation
  string ltqRWTableDef;
  ltqRWTableDef += subst("$0(t)[i] = \n", vname);
  ltqRWTableDef += "\\left\\{\\begin{array}{ll}\n";
  ltqRWTableDef += subst("$0 & \\mbox{if \\,} t < 0 \\mbox{\\, and \\,}  i \\in [0,$1] \\\\\n", replaceTimeBy(init, 'i'), T(n - 1));
  ltqRWTableDef += subst("$0 & \\mbox{if \\,} i = $1 \\\\\n", CS(wsig, 0), CS(widx, 0));
  ltqRWTableDef += subst("$0(t\\!-\\!1)[i] & \\mbox{otherwise} \\\\\n", vname);
  ltqRWTableDef += "\\end{array}\\right.";

  // add the table equation
  fLateq->addRWTblSigFormula(ltqRWTableDef); // w(t) = initsig(t)

  // note that the name of the table can never be used outside an sigDocTableAccess
  return vname;
}
Esempio n. 5
0
/* Parse a cursor-full of data */
static int	/* ret 0 or +ve if ok, else -ve error code */
pxl_impl_process(
	pl_interp_instance_t *instance,        /* interp instance to process data job in */
	stream_cursor_read   *cursor           /* data to process */
)
{
	pxl_interp_instance_t *pxli = (pxl_interp_instance_t *)instance;
	int code;

	/* Process some input */
	switch (pxli->processState)
	  {
	case PSDone:
	  return e_ExitLanguage;
	case PSHeader:		/* Input stream header */
	  code = px_stream_header_process(&pxli->headerState, cursor);
	  if (code == 0)
	    break;    /* need more input later */
	  else
	  	 /* stream header termination */
	    if (code < 0)
	      {
	      pxli->processState = PSDone;
	      return code;   /* return error */
	      }
	    else
	      {
	      code = 0;
	      pxli->processState = PSXL;
	      }
	    /* fall thru to PSXL */
	case PSXL:		/* PCL XL */
	  code = px_process(pxli->st, pxli->pxs, cursor);
	  if ( code == e_ExitLanguage )
	    { pxli->processState = PSDone;
	      code = 0;
	    }
	  else if ( code == errorWarningsReported )
	    { /* The parser doesn't skip over the EndSession */
	      /* operator, because an "error" occurred. */
	      cursor->ptr++;
	    }
	  else if (code < 0)
	    /* Map library error codes to PCL XL codes when possible. */
       switch ( code )
	      {
#define subst(gs_error, px_error)\
  case gs_error: code = px_error; break
	      subst(gs_error_invalidfont, errorIllegalFontData);
	      subst(gs_error_limitcheck, errorInternalOverflow);
	      subst(gs_error_nocurrentpoint, errorCurrentCursorUndefined);
	      subst(gs_error_rangecheck, errorIllegalAttributeValue);
	      subst(gs_error_VMerror, errorInsufficientMemory);
#undef subst
 	      }
	  break;   /* may need more input later */
	  }

	return code;
}
Esempio n. 6
0
void VectorCompiler::compileMultiSignal (Tree L)
{
    //contextor recursivness(0);
    L = prepare(L);     // optimize, share and annotate expression

    for (int i = 0; i < fClass->inputs(); i++) {
        fClass->addZone3(subst("$1* input$0 = &input[$0][index];", T(i), xfloat()));
    }
    for (int i = 0; i < fClass->outputs(); i++) {
        fClass->addZone3(subst("$1* output$0 = &output[$0][index];", T(i), xfloat()));
    }

    fClass->addSharedDecl("fullcount");
    fClass->addSharedDecl("input");
    fClass->addSharedDecl("output");

    for (int i = 0; isList(L); L = tl(L), i++) {
        Tree sig = hd(L);
        fClass->openLoop("count");
        fClass->addExecCode(subst("output$0[i] = $2$1;", T(i), CS(sig), xcast()));
        fClass->closeLoop(sig);
    }

    generateUserInterfaceTree(prepareUserInterfaceTree(fUIRoot));
 	generateMacroInterfaceTree("", prepareUserInterfaceTree(fUIRoot));
    if (fDescription) {
        fDescription->ui(prepareUserInterfaceTree(fUIRoot));
    }
}
Esempio n. 7
0
void Description::addGroup(int level, Tree t)
{
  Tree label, elements, varname, sig;
  const char* groupnames[] =
  {
    "vgroup", "hgroup", "tgroup"
  };

  if(isUiFolder(t, label, elements))
  {
    const int orient = tree2int(left(label));

    addLayoutLine(level, subst("<group type=\"$0\">", groupnames[orient]));
    addLayoutLine(level + 1, subst("<label>$0</label>", checkNullLabel(t, xmlize(tree2str(right(label))), false)));

    while(!isNil(elements))
    {
      addGroup(level + 1, right(hd(elements)));
      elements = tl(elements);
    }

    addLayoutLine(level, "</group>");
  }
  else if(isUiWidget(t, label, varname, sig))
  {
    int w = addWidget(label, varname, sig);
    addLayoutLine(level, subst("<widgetref id=\"$0\" />", T(w)));
  }
  else
  {
    fprintf(stderr, "error in user interface generation 2\n");
    exit(1);
  }
}
Esempio n. 8
0
File: cpp.c Progetto: rui314/8cc-old
/*
 * Reads a token from a given preprocessing context, expands it if macro, and
 * returns it.
 */
static Token *expand_one(CppContext *ctx) {
    Token *tok = read_cpp_token(ctx);
    if (!tok) return NULL;
    if (tok->toktype != TOKTYPE_IDENT)
        return tok;
    String *name = tok->val.str;
    Macro *macro = dict_get(ctx->defs, name);
    if (!macro)
        return tok;
    if (list_in(tok->hideset, name))
        return tok;

    switch (macro->type) {
    case MACRO_OBJ: {
        List *ts = subst(ctx, macro, make_list(), list_union1(tok->hideset, name));
        pushback(ctx, ts);
        return expand_one(ctx);
    }
    case MACRO_FUNC: {
        List *args = read_args(ctx, macro);
        Token *rparen = read_cpp_token(ctx);
        List *hideset = list_union1(list_intersect(tok->hideset, rparen->hideset), name);
        List *ts = subst(ctx, macro, args, hideset);
        pushback(ctx, ts);
        return expand_one(ctx);
    }
    case MACRO_SPECIAL:
        macro->fn(ctx, tok);
        return expand_one(ctx);
    }
    panic("should not reach here");
}
Esempio n. 9
0
/**
 * Generate LaTeX code for "prefix", a 1­sample-delay explicitely initialized.
 *
 * @param	sig			The signal expression to treat.
 * @param	x			The initial value for the delay line.
 * @param	e			The value for the delay line, after initialization.
 * @param	priority	The priority of the environment of the expression.
 *
 * @return	<string>	The LaTeX code translation of the signal, cached.
 */
string DocCompiler::generatePrefix(Tree sig, Tree x, Tree e, int priority)
{
  string var = getFreshID("m");
  string exp0 = CS(x, priority);
  string exp1 = CS(e, priority); // ensure exp1 is compiled to have a vector name
  string vecname;

  if(!getVectorNameProperty(e, vecname))
  {
    cerr << "No vector name for : " << ppsig(e) << endl;
    assert(0);
  }

  string ltqPrefixDef;
  ltqPrefixDef += subst("$0(t) = \n", var);
  ltqPrefixDef += "\\left\\{\\begin{array}{ll}\n";
  ltqPrefixDef += subst("$0 & \\mbox{, when \\,} t = 0\\\\\n", exp0);
  ltqPrefixDef += subst("$0 & \\mbox{, when \\,} t > 0\n", subst("$0(t\\!-\\!1)", vecname));
  ltqPrefixDef += "\\end{array}\\right.";

  fLateq->addPrefixSigFormula(ltqPrefixDef);
  gDocNoticeFlagMap["prefixsigs"] = true;

  return generateCacheCode(sig, subst("$0(t)", var));
}
Esempio n. 10
0
void
filter_passwd(struct passwd *pwd, char *buffer, size_t buflen)
{
	/* Ideally we want to add some means of configuring the
	 * filters that we apply here.  For now we'll simply
	 * hard-code a couple of examples. */

	/* N.B. there's no means of returning to your caller how much
	 * of buffer you have used up.  Thus when stacking NSS modules,
	 * you can't rely on buffer's being available for storing your
	 * updated data -- you don't know whether anyone has had at it
	 * already.
	 *
	 * It is /not/ safe to free members that you are replacing, unless
	 * you are certain that they lie outside of buffer[0:buflen].
	 * Is it safe simply to malloc more memory?  We'll try it.
	 */
	printd("pwd = %p, pwd->pw_gecos = %p, buffer = %p[%d]\n", pwd, pwd->pw_gecos, buffer, buflen);

#define CANFREE(p) (((p) < buffer) || ((p) > (buffer + buflen)))

	if (pwd->pw_gecos && strchr(pwd->pw_gecos, '&'))
		subst(&pwd->pw_gecos, "&", pwd->pw_name, CANFREE(pwd->pw_gecos),
		      pass_capitalize);
	if (pwd->pw_dir && strchr(pwd->pw_dir, '&'))
		subst(&pwd->pw_dir, "&", pwd->pw_name, CANFREE(pwd->pw_dir),
		      pass_lowercase);
	if (pwd->pw_shell && strchr(pwd->pw_shell, '&'))
		subst(&pwd->pw_shell, "&", pwd->pw_name, CANFREE(pwd->pw_shell),
		      pass_lowercase);
	return;
}
Esempio n. 11
0
Expr const*
Substitution::subst(Seq const* e) const
{
    Expr const* e1 = subst(e->left());
    Expr const* e2 = subst(e->right());
    return new App(e->type(), e1, e2);
}
Esempio n. 12
0
Expr const*
Substitution::subst(App const* e) const
{
    Expr const* e1 = subst(e->fn());
    Expr const* e2 = subst(e->arg());
    return new App(e->type(), e1, e2);
}
Esempio n. 13
0
void DocCompiler::getTypedNames(Type t, const string& prefix, string& ctype, string& vname)
{
    if (t->nature() == kInt) {
        ctype = "int"; vname = subst("$0", getFreshID(prefix));
    } else {
        ctype = ifloat(); vname = subst("$0", getFreshID(prefix));
    }
}
Esempio n. 14
0
/**
 * Generate code for the delay mecchanism without using temporary variables
 */
void DocCompiler::generateDelayLine(const string& ctype, const string& vname, int mxd, const string& exp)
{
    //faustassert(mxd > 0);
    if (mxd == 0) {
        fLateq->addRecurSigFormula(subst("$0(t) = $1", vname, exp));
    } else {
        fLateq->addRecurSigFormula(subst("$0(t) = $1", vname, exp));
	}
}
Esempio n. 15
0
static void  r_mult(int arg1,int arg2,set index1)
{  char      name0[8],name1[8],name2[8];
   set       mind;
   unsigned  m,mm,maxmm;
   int       pstn[15];
   int       n,l;
   set       index;

   index=index1;
   sprintf(name1,"Vrt_%d",arg1);
   sprintf(name2,"Vrt_%d",arg2);
   if(arg1 < arg2) strcpy(name0,name1); else strcpy(name0,name2);
   mind=set_and(index,setmassindex);
   if(set_eq0(mind)) reducemult(name0,name1,name2,index); else
   {
      reducemult("Vrt_0",name1,name2,index);
      l = 1; n = 0;
      while (!set_eq0(mind))
      {
         if (set_in(l,mind)) pstn[n++] = l;
         set_del1(&mind,l++);
      }
      maxmm =  (1 << n) - 1 ;
      for (mm = 1;mm <= maxmm ; mm++)
      {
         writeF(" Vrt_L:=%s$   Vrt_R:=%s$\n",name1,name2);
         mind=set_constr(_E);
         m = mm; n = 1;
         while (m != 0)
         {
            if ((m & 1) != 0 && (l = pstn[n-1]) != 0)
            {
               writeF(" Vrt_L:=(Vrt_L where %s)$\n",subst(l,arg1));
               writeF(" Vrt_R:=(Vrt_R where %s)$\n",subst(l,arg2));
               set_add1(&mind,l);
            }
            ++(n);
            m >>= 1;
         }
         reducemult("Vrt_0","Vrt_0 + Vrt_L","Vrt_R",set_aun(index,mind));
         writeF(" Clear Vrt_L $    Clear Vrt_R $\n");
      }
      writeF(" %s:=Vrt_0 $    Clear Vrt_0 $\n",name0);
   }
   if (arg1 < arg2)
   {
      writeF(" Clear %s$\n",name2);
      for (n = 1; n <= vcs.sizet; n++)
         if (vertmap[n-1] == arg2) vertmap[n-1] = arg1;
   }
   if (arg2 < arg1)
   {
      writeF(" Clear %s$\n",name1);
      for (n = 1; n <= vcs.sizet; n++)
      if (vertmap[n-1] == arg1) vertmap[n-1] = arg2;
   }
}  /*  R_mult  */
Esempio n. 16
0
string VectorCompiler::generateWaveform(Tree sig)
{
    string  vname;
    int     size;

    declareWaveform(sig, vname, size);
    fClass->addPostCode(subst("idx$0 = (idx$0 + count) % $1;", vname, T(size)) );
    return generateCacheCode(sig, subst("$0[(idx$0+i)%$1]", vname, T(size)));
}
Esempio n. 17
0
Ident
Code_Project::findEquality(Ident x, VarCode vc)
{
  Ident y = -1;
  if (!vc.vars->exists(x))
    return -1;
  x = subst(x, vc.vars, &vc.code->vars);
  if (vc.code->eqlist && vc.code->eqlist->exists(x))
    return -1;
  switch (vc.code->kind) {
  case cAnd: {
    Code_And *c = (Code_And *) vc.code;
    y = findEquality(x, c->vc1);
    if (y == -1) 
      y = findEquality(x, c->vc2);
    break; 
  }
  case cProject:
  case cRestrict:
  case cPredCall: {
    Code_c *c = (Code_c *) vc.code;
    y = findEquality(x, c->vc);
    break; 
  }
  case cEq1:
  case cEq2: {
    Code_nn *c = (Code_nn *) vc.code;
    if (c->id1 == x && c->id2 != x && sameUnivs(c->id1, c->id2))
      y = c->id2;
    else if (c->id2 == x && c->id1 != x && sameUnivs(c->id1, c->id2))
      y = c->id1;
    break;
  }
  case cBiimpl: {
    Code_Biimpl *c = (Code_Biimpl *) vc.code;
    if (c->vc1.code->kind == cBoolVar &&
	c->vc2.code->kind == cBoolVar) {
      Code_BoolVar *c1 = (Code_BoolVar *) c->vc1.code;
      Code_BoolVar *c2 = (Code_BoolVar *) c->vc2.code;
      if (c1->id == x && c2->id != x)
	y = c2->id;
      else if (c2->id == x && c1->id != x)
	y = c1->id;
    }
    break;
  }
  default: ; // no equality found
  }
  if (y != -1)
    y = subst(y, &vc.code->vars, vc.vars);
  if (!vc.code->eqlist)
    vc.code->eqlist = new IdentList;
  vc.code->eqlist->insert(x);
  return y;
}
Esempio n. 18
0
bool
Code_cc::checkExport(Ident x)
{
  if (eqlist && eqlist->exists(x))
    return true;
  if (!eqlist)
    eqlist = new IdentList;
  eqlist->insert(x);
  return vc1.code->checkExport(subst(x, vc1.vars, &vc1.code->vars)) && 
    vc2.code->checkExport(subst(x, vc2.vars, &vc2.code->vars));
}
Esempio n. 19
0
/**
 * Generate the code for a (short) delay line
 * @param k the c++ class where the delay line will be placed.
 * @param l the loop where the code will be placed.
 * @param tname the name of the C++ type (float or int)
 * @param dlname the name of the delay line (vector) to be used.
 * @param delay the maximum delay
 * @param cexp the content of the signal as a C++ expression
 */
void  VectorCompiler::vectorLoop (const string& tname, const string& vecname, const string& cexp)
{
    // -- declare the vector
    fClass->addSharedDecl(vecname);

    // -- variables moved as class fields...
    fClass->addZone1(subst("$0 \t$1[$2];", tname, vecname, T(gVecSize)));

    // -- compute the new samples
    fClass->addExecCode(subst("$0[i] = $1;", vecname, cexp));
}
Esempio n. 20
0
	virtual string 	generateCode (Klass* klass, const vector<string>& args, const vector<Type>& types)
	{
		assert (args.size() == arity());
		assert (types.size() == arity());

        if (types[1]->nature() == kInt) {
            klass->rememberNeedPowerDef();
            return subst("faustpower<$1>($0)", args[0], args[1]);
        } else {
            return subst("pow$2($0,$1)", args[0], args[1], isuffix());
        }
    }
Esempio n. 21
0
QString const externalLineEnding(docstring const & str)
{
#ifdef Q_WS_MACX
	// The MAC clipboard uses \r for lineendings, and we use \n
	return toqstr(subst(str, '\n', '\r'));
#elif defined(Q_WS_WIN)
	// Windows clipboard uses \r\n for lineendings, and we use \n
	return toqstr(subst(str, from_ascii("\n"), from_ascii("\r\n")));
#else
	return toqstr(str);
#endif
}
Esempio n. 22
0
/**
 * Generate buildUserInterface C++ lines of code corresponding 
 * to user interface element t
 */
void Compiler::generateUserInterfaceTree(Tree t)
{
	Tree label, elements, varname, sig;
    
    
	if (isUiFolder(t, label, elements)) {
		const int orient = tree2int(left(label));
        // Empty labels will be renamed with a 0xABCD (address) kind of name that is ignored and not displayed by UI architectures
        const char* str = tree2str(right(label));  
        const char* model;
          
        // extract metadata from group label str resulting in a simplifiedLabel
		// and metadata declarations for fictive zone at address 0
        string  simplifiedLabel;
        map<string, set<string> >   metadata;
        extractMetadata(str, simplifiedLabel, metadata);

        // add metadata if any
        for (map<string, set<string> >::iterator i = metadata.begin(); i != metadata.end(); i++) {
            const string& key = i->first;
            const set<string>& values = i->second;
            for (set<string>::const_iterator j = values.begin(); j != values.end(); j++) {
                fClass->addUICode(subst("interface->declare($0, \"$1\", \"$2\");", "0", wdel(key) ,wdel(*j)));
                fJSON.declare(NULL, wdel(key).c_str(), wdel(*j).c_str());
            }
        }
        
        //-----------------
		switch (orient) {
			case 0 : model = "interface->openVerticalBox(\"$0\");"; fJSON.openVerticalBox(checkNullLabel(t, simplifiedLabel).c_str()); break;
			case 1 : model = "interface->openHorizontalBox(\"$0\");"; fJSON.openHorizontalBox(checkNullLabel(t, simplifiedLabel).c_str()); break;
			case 2 : model = "interface->openTabBox(\"$0\");"; fJSON.openTabBox(checkNullLabel(t, simplifiedLabel).c_str()); break;
			default :
                fprintf(stderr, "error in user interface generation 1\n");
				exit(1);
		}
        fClass->addUICode(subst(model, checkNullLabel(t, simplifiedLabel)));
		generateUserInterfaceElements(elements);
		fClass->addUICode("interface->closeBox();");
        fJSON.closeBox();

	} else if (isUiWidget(t, label, varname, sig)) {

		generateWidgetCode(label, varname, sig);

	} else {

		fprintf(stderr, "error in user interface generation 2\n");
		exit(1);

	}
}
Esempio n. 23
0
static Tree subst (Tree t, Tree propkey, Tree id, Tree val)
{
	Tree p;
	
	if (t==id) {
		return val;
		
	} else if (t->arity() == 0) {
		return t;
	} else if (getProperty(t, propkey, p)) {
		return (isNil(p)) ?  t : p;
	} else {
		Tree r=nil;
		switch (t->arity()) {
			
			case 1 : 
				r = tree(t->node(), 
							subst(t->branch(0), propkey, id, val)); 
				break;
				
			case 2 : 
				r = tree(t->node(), 
							subst(t->branch(0), propkey, id, val), 
							subst(t->branch(1), propkey, id, val)); 
				break;
				
			case 3 : 
				r = tree(t->node(), 
							subst(t->branch(0), propkey, id, val), 
							subst(t->branch(1), propkey, id, val), 
							subst(t->branch(2), propkey, id, val)); 
				break;
				
			case 4 : 
				r = tree(t->node(), 
							subst(t->branch(0), propkey, id, val), 
							subst(t->branch(1), propkey, id, val), 
							subst(t->branch(2), propkey, id, val), 
							subst(t->branch(3), propkey, id, val)); 
				break;
			
		}
		if (r == t) {
			setProperty(t, propkey, nil);
		} else {
			setProperty(t, propkey, r);
		}
		return r;
	}
		
}
Esempio n. 24
0
bool SpecialisedMover::do_copy(FileName const & from, FileName const & to,
			       string const & latex) const
{
	if (command_.empty())
		return Mover::do_copy(from, to, latex);

	string command = command_;
	command = subst(command, "$$i", quoteName(from.toFilesystemEncoding()));
	command = subst(command, "$$o", quoteName(to.toFilesystemEncoding()));
	command = subst(command, "$$l", quoteName(latex));

	Systemcall one;
	return one.startscript(Systemcall::Wait, command) == 0;
}
Esempio n. 25
0
void
Code_Restrict::reduce2()
{
  vc.reduce();

  VarCodeList::iterator i;
  restrconj = new VarCodeList;
  if (vc.code->conj)
    for (i = vc.code->conj->begin(); i != vc.code->conj->end(); i++)
      restrconj->insert(subst((*i).vars, &vc.code->vars, vc.vars), (*i).code);
  if (vc.code->restrconj)
    for (i = vc.code->restrconj->begin(); i != vc.code->restrconj->end(); i++)
      restrconj->insert(subst((*i).vars, &vc.code->vars, vc.vars), (*i).code);
}
Esempio n. 26
0
string DocCompiler::generateInput (Tree sig, const string& idx)
{
	if (fLateq->inputs() == 1) {
		setVectorNameProperty(sig, "x");
		fLateq->addInputSigFormula("x(t)");	
		gGlobal->gDocNoticeFlagMap["inputsig"] = true;
		return generateCacheCode(sig, "x(t)");
	} else {
		setVectorNameProperty(sig, subst("x_{$0}", idx));
		fLateq->addInputSigFormula(subst("x_{$0}(t)", idx));
		gGlobal->gDocNoticeFlagMap["inputsigs"] = true;
		return generateCacheCode(sig, subst("x_{$0}(t)", idx));
	}
}
Esempio n. 27
0
/** Unused for the moment ! */
string DocCompiler::generateOutput (Tree sig, const string& idx, const string& arg)
{
	string dst;
	
	if (fLateq->outputs() == 1) {
		dst = subst("y(t)", idx);
		gGlobal->gDocNoticeFlagMap["outputsig"] = true;
	} else {
		dst = subst("y_{$0}(t)", idx);
		gGlobal->gDocNoticeFlagMap["outputsigs"] = true;
	}
	
	fLateq->addOutputSigFormula(subst("$0 = $1", dst, arg));
	return dst;
}
Esempio n. 28
0
void
Code_Project::reduce2()
{
  Code_c::reduce2();

  // for obscure reasons it is safe to add sublists
  VarCodeList::iterator i;
  restrconj = new VarCodeList;
  if (vc.code->conj)
    for (i = vc.code->conj->begin(); i != vc.code->conj->end(); i++)
      conj->insert(subst((*i).vars, &vc.code->vars, vc.vars), (*i).code);
  if (vc.code->restrconj)
    for (i = vc.code->restrconj->begin(); i != vc.code->restrconj->end(); i++)
      restrconj->insert(subst((*i).vars, &vc.code->vars, vc.vars), (*i).code);
}
Esempio n. 29
0
/**
 * Generate code for the delay mecchanism without using temporary variables
 */
string DocCompiler::generateDelayVecNoTemp(Tree sig, const string& exp, const string& ctype, const string& vname, int mxd)
{
    faustassert(mxd > 0);
	//cerr << "  entering generateDelayVecNoTemp" << endl;
	string vectorname;

	// if generateVariableStore has already tagged sig, no definition is needed.
	if(getVectorNameProperty(sig, vectorname)) { 
		return subst("$0(t)", vectorname);
	} else {
        fLateq->addRecurSigFormula(subst("$0(t) = $1", vname, exp));
        setVectorNameProperty(sig, vname);
        return subst("$0(t)", vname);
	}
}
Esempio n. 30
0
	virtual string 	generateLateq (Lateq* lateq, const vector<string>& args, const vector<Type>& types)
	{
		assert (args.size() == arity());
		assert (types.size() == arity());
        
		return subst("{$0}^{$1}", args[0], args[1]);
	}