d2a6d35cea3efc066c47be58d6b3a81c653a95d0
[Faustine.git] / interpretor / preprocessor / faust-0.9.47mr3 / compiler / signals / sigtyperules.cpp
1 /************************************************************************
2 ************************************************************************
3 FAUST compiler
4 Copyright (C) 2003-2004 GRAME, Centre National de Creation Musicale
5 ---------------------------------------------------------------------
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2 of the License, or
9 (at your option) any later version.
10
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software
18 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
19 ************************************************************************
20 ************************************************************************/
21
22
23
24 #include <stdio.h>
25 #include <assert.h>
26 #include <iostream>
27 #include <fstream>
28 #include <time.h>
29
30
31 #include "sigtype.hh"
32 #include "sigprint.hh"
33 #include "ppsig.hh"
34 //#include "prim.hh"
35 #include "prim2.hh"
36 #include "tlib.hh"
37 #include "sigtyperules.hh"
38 #include "xtended.hh"
39 #include "recursivness.hh"
40 #include "sigraterules.hh"
41
42
43 //--------------------------------------------------------------------------
44 // Uncomment to activate type inference tracing
45
46 //#define TRACE(x) x
47 #define TRACE(x) 0;
48
49
50
51 //--------------------------------------------------------------------------
52 // prototypes
53 static ostream& printRateEnvironment(ostream& fout, Tree E);
54 static Tree inferreMultiRates(Tree lsig, bool& success);
55 static ostream& printRateEnvironmentList(ostream& fout, Tree LE);
56
57 static void setSigType(Tree sig, Type t);
58 static Type getSigType(Tree sig);
59 static Type initialRecType(Tree t);
60
61 static Type T(Tree term, Tree env);
62
63 static Type infereSigType(Tree term, Tree env);
64 static Type infereFFType (Tree ff, Tree ls, Tree env);
65 static Type infereFConstType (Tree type);
66 static Type infereFVarType (Tree type);
67 static Type infereRecType (Tree var, Tree body, Tree env);
68 static Type infereReadTableType(Type tbl, Type ri);
69 static Type infereWriteTableType(Type tbl, Type wi, Type wd);
70 static Type infereProjType(Type t, int i, int vec);
71 static Type infereXType(Tree sig, Tree env);
72 static Type infereDocConstantTblType(Type size, Type init);
73 static Type infereDocWriteTblType(Type size, Type init, Type widx, Type wsig);
74 static Type infereDocAccessTblType(Type tbl, Type ridx);
75 static interval arithmetic (int opcode, const interval& x, const interval& y);
76
77
78 static Type infereVectorizeType(Tree sig, Type T, Type Tsize);
79 static Type infereSerializeType(Tree sig, Type Tvec);
80 static Type infereConcatType(Type Tvec1, Type Tvec2);
81 static Type infereVectorAtType(Type Tvec, Type Tidx);
82
83
84
85
86 /**
87 * The empty type environment (also property key for closed term type)
88 */
89 static Tree NULLTYPEENV = tree(symbol("NullTypeEnv"));
90
91 static int countInferences;
92 static int countMaximal;
93
94
95
96 /**
97 * Fully annotate every subtree of term with type information.
98 * @param sig the signal term tree to annotate
99 */
100
101 void typeAnnotation(Tree sig)
102 {
103 Tree sl = symlist(sig);
104 int n = len(sl);
105
106 vector<Tree> vrec, vdef;
107 vector<Type> vtype;
108
109 //cerr << "Symlist " << *sl << endl;
110 for (Tree l=sl; isList(l); l=tl(l)) {
111 Tree id, body;
112 assert(isRec(hd(l), id, body));
113
114 vrec.push_back(hd(l));
115 vdef.push_back(body);
116 }
117
118 // init recursive types
119 for (int i=0; i<n; i++) {
120 vtype.push_back(initialRecType(vdef[i]));
121 }
122
123 assert (int(vrec.size())==n);
124 assert (int(vdef.size())==n);
125 assert (int(vtype.size())==n);
126
127 // find least fixpoint
128 for (bool finished = false; !finished; ) {
129
130 // init recursive types
131 CTree::startNewVisit();
132 for (int i=0; i<n; i++) {
133 setSigType(vrec[i], vtype[i]);
134 vrec[i]->setVisited();
135 }
136
137 // compute recursive types
138 for (int i=0; i<n; i++) {
139 vtype[i] = T(vdef[i], NULLTYPEENV);
140 }
141
142 // check finished
143 finished = true;
144 for (int i=0; i<n; i++) {
145 //cerr << i << "-" << *vrec[i] << ":" << *getSigType(vrec[i]) << " => " << *vtype[i] << endl;
146 finished = finished & (getSigType(vrec[i]) == vtype[i]);
147 }
148 }
149
150 // type full term
151 T(sig, NULLTYPEENV);
152
153 #if 0
154 //cerr << TABBER << "COUNT INFERENCE " << countInferences << " AT TIME " << clock()/CLOCKS_PER_SEC << 's' << endl;
155 fixInferredType(sig, NULLTYPEENV);
156 //cerr << --TABBER << "EXIT TYPE ANNOTATION OF " << *sig << " AT TIME " << clock()/CLOCKS_PER_SEC << 's' << endl;
157
158 #if 0
159 bool success;
160 Tree RE = inferreMultiRates(sig, success);
161 if (success) {
162 printRateEnvironment(cerr, RE); cerr << endl;
163 } else {
164 cerr << "ERROR can't inferre rate environment of " << ppsig(sig) << endl;
165 }
166 #else
167 //RateInferrer R(sig);
168
169 #endif
170 #endif
171
172 }
173
174
175 void annotationStatistics()
176 {
177 cerr << TABBER << "COUNT INFERENCE " << countInferences << " AT TIME " << clock()/CLOCKS_PER_SEC << 's' << endl;
178 cerr << TABBER << "COUNT ALLOCATION " << AudioType::gAllocationCount << endl;
179 cerr << TABBER << "COUNT MAXIMAL " << countMaximal << endl;
180 }
181
182 /**
183 * Retrieve the type of sig and check it exists. Produces an
184 * error if the signal has no type associated
185 * @param sig the signal we want to know the type
186 * @return the type of the signal
187 */
188 Type getCertifiedSigType(Tree sig)
189 {
190 Type ty = getSigType(sig);
191 assert(ty);
192 return ty;
193 }
194
195
196
197 /***********************************************
198 * Set and get the type property of a signal
199 * (we suppose the signal have been previously
200 * annotated with type information)
201 ***********************************************/
202
203 /**
204 * Set the type annotation of sig
205 * @param sig the signal we want to type
206 * @param t the type of the signal
207 */
208 static void setSigType(Tree sig, Type t)
209 {
210 TRACE(cerr << TABBER << "SET FIX TYPE OF " << *sig << " TO TYPE " << *t << endl;)
211 sig->setType(t);
212 }
213
214
215 /**
216 * Retrieve the type annotation of sig
217 * @param sig the signal we want to know the type
218 */
219 static Type getSigType(Tree sig)
220 {
221 AudioType* ty = (AudioType*) sig->getType();
222 if (ty == 0)
223 TRACE(cerr << TABBER << "GET FIX TYPE OF " << *sig << " HAS NO TYPE YET" << endl;)
224 else
225 TRACE(cerr << TABBER << "GET FIX TYPE OF " << *sig << " IS TYPE " << *ty << endl;)
226 return ty;
227 }
228
229
230
231
232
233 /**************************************************************************
234
235 Type Inference System
236
237 ***************************************************************************/
238
239
240 /**************************************************************************
241
242 Infered Type property
243
244 ***************************************************************************/
245
246 /**
247 * Shortcut to getOrInferType, retrieve or infere the type of a term according to its surrounding type environment
248 * @param sig the signal to analyze
249 * @param env the type environment
250 * @return the type of sig according to environment env
251 * @see getCertifiedSigType
252 */
253 static Type T(Tree term, Tree ignoreenv)
254 {
255 TRACE(cerr << ++TABBER << "ENTER T() " << *term << endl;)
256
257 if (term->isAlreadyVisited()) {
258 Type ty = getSigType(term);
259 TRACE(cerr << --TABBER << "EXIT 1 T() " << *term << " AS TYPE " << *ty << endl);
260 return ty;
261
262 } else {
263 Type ty = infereSigType(term, ignoreenv);
264 setSigType(term,ty);
265 term->setVisited();
266 TRACE(cerr << --TABBER << "EXIT 2 T() " << *term << " AS TYPE " << *ty << endl);
267 return ty;
268 }
269 }
270
271
272 /**
273 * Infere the type of a term according to its surrounding type environment
274 * @param sig the signal to aanlyze
275 * @param env the type environment
276 * @return the type of sig according to environment env
277 */
278
279 static Type infereSigType(Tree sig, Tree env)
280 {
281 int i;
282 double r;
283 Tree sel, s1, s2, s3, ff, id, ls, l, x, y, z, u, var, body, type, name, file;
284 Tree label, cur, min, max, step;
285
286 countInferences++;
287
288 if ( getUserData(sig) ) return infereXType(sig, env);
289
290 else if (isSigInt(sig, &i)) { Type t = makeSimpleType(kInt, kKonst, kComp, kVect, kNum, interval(i));
291 /*sig->setType(t);*/ return t; }
292
293 else if (isSigReal(sig, &r)) { Type t = makeSimpleType(kReal, kKonst, kComp, kVect, kNum, interval(r));
294 /*sig->setType(t);*/ return t; }
295
296 else if (isSigInput(sig, &i)) { /*sig->setType(TINPUT);*/ return TINPUT; }
297
298 else if (isSigOutput(sig, &i, s1)) return sampCast(T(s1,env));
299
300 else if (isSigDelay1(sig, s1)) {
301 Type t = T(s1,env);
302 return castInterval(sampCast(t), reunion(t->getInterval(), interval(0,0)));
303 }
304
305 else if (isSigPrefix(sig, s1, s2)) {
306 Type t1 = T(s1,env);
307 Type t2 = T(s2,env);
308 checkInit(t1);
309 return castInterval(sampCast(t1|t2), reunion(t1->getInterval(), t2->getInterval()));
310 }
311
312 else if (isSigFixDelay(sig, s1, s2)) {
313 Type vt1 = T(s1,env);
314 vector<int> dim;
315 Type t1 = vt1->dimensions(dim);
316 Type t2 = T(s2,env);
317 interval i = t2->getInterval();
318
319 // cerr << "for sig fix delay : s1 = "
320 // << t1 << ':' << ppsig(s1) << ", s2 = "
321 // << t2 << ':' << ppsig(s2) << endl;
322 if (!i.valid) {
323 cerr << "ERROR : can't compute the min and max values of : " << ppsig(s2) << endl;
324 cerr << " used in delay expression : " << ppsig(sig) << endl;
325 cerr << " (probably a recursive signal)" << endl;
326 exit(1);
327 } else if (i.lo < 0) {
328 cerr << "ERROR : possible negative values of : " << ppsig(s2) << endl;
329 cerr << " used in delay expression : " << ppsig(sig) << endl;
330 cerr << " " << i << endl;
331 exit(1);
332 }
333
334 Type nt1 = castInterval(sampCast(t1), reunion(t1->getInterval(), interval(0,0)));
335 return makeVectorType(nt1,dim);
336 }
337
338 else if (isSigBinOp(sig, &i, s1, s2)) {
339
340 Type t1 = T(s1,env);
341 Type t2 = T(s2,env);
342
343 vector<int> D1, D2, D3;
344 Type b1 = t1->dimensions(D1);
345 Type b2 = t2->dimensions(D2);
346
347 if (maxdimensions(D1, D2, D3)) {
348 Type b3 = castInterval(b1 | b2, arithmetic(i, b1->getInterval(), b2->getInterval()));
349 if ((i>=kGT) && (i<=kNE)) b3 = intCast(b3);
350 Type t3 = makeVectorType(b3, D3);
351 return t3;
352 } else {
353 cerr << "ERROR operation on incompatible types : " << *t1 << " and " << *t2
354 << " in expression : " << ppsig(sig) << endl;
355 exit(1);
356 }
357 //cerr <<"type rule for : " << ppsig(sig) << " -> " << *t3 << endl;
358 //return (!gVectorSwitch && (i>=kGT) && (i<=kNE)) ? intCast(t3) : t3; // for comparaison operation the result is int
359 //return ((i>=kGT) && (i<=kNE)) ? intCast(t3) : t3; // for comparaison operation the result is int
360 }
361
362 else if (isSigIntCast(sig, s1)) return intCast(T(s1,env));
363
364 else if (isSigFloatCast(sig, s1)) return floatCast(T(s1,env));
365
366 else if (isSigFFun(sig, ff, ls)) return infereFFType(ff,ls,env);
367
368 else if (isSigFConst(sig,type,name,file)) return infereFConstType(type);
369
370 else if (isSigFVar(sig,type,name,file)) return infereFVarType(type);
371
372 else if (isSigButton(sig)) { /*sig->setType(TGUI01);*/ return TGUI01; }
373
374 else if (isSigCheckbox(sig)) { /*sig->setType(TGUI01);*/ return TGUI01; }
375
376 else if (isSigVSlider(sig,label,cur,min,max,step))
377 return castInterval(TGUI,interval(tree2float(min),tree2float(max)));
378
379 else if (isSigHSlider(sig,label,cur,min,max,step))
380 return castInterval(TGUI,interval(tree2float(min),tree2float(max)));
381
382 else if (isSigNumEntry(sig,label,cur,min,max,step))
383 return castInterval(TGUI,interval(tree2float(min),tree2float(max)));
384
385 else if (isSigHBargraph(sig, l, x, y, s1)) return T(s1,env);
386
387 else if (isSigVBargraph(sig, l, x, y, s1)) return T(s1,env);
388
389 else if (isSigAttach(sig, s1, s2)) { T(s2,env); return T(s1,env); }
390
391 else if (isRec(sig, var, body)) return infereRecType(sig, body, env);
392
393 else if (isProj(sig, &i, s1)) return infereProjType(T(s1,env),i,kScal);
394
395 else if (isSigTable(sig, id, s1, s2)) { checkInt(checkInit(T(s1,env))); return makeTableType(checkInit(T(s2,env))); }
396
397 else if (isSigWRTbl(sig, id, s1, s2, s3)) return infereWriteTableType(T(s1,env), T(s2,env), T(s3,env));
398
399 else if (isSigRDTbl(sig, s1, s2)) return infereReadTableType(T(s1,env), T(s2,env));
400
401 else if (isSigGen(sig, s1)) return T(s1,NULLTYPEENV);
402
403 else if ( isSigDocConstantTbl(sig, x, y) ) return infereDocConstantTblType(T(x,env), T(y,env));
404 else if ( isSigDocWriteTbl(sig,x,y,z,u) ) return infereDocWriteTblType(T(x,env), T(y,env), T(z,env), T(u,env));
405 else if ( isSigDocAccessTbl(sig, x, y) ) return infereDocAccessTblType(T(x,env), T(y,env));
406
407 else if (isSigSelect2(sig,sel,s1,s2)) {
408 SimpleType *st1, *st2, *stsel;
409
410 st1 = isSimpleType(T(s1,env));
411 st2 = isSimpleType(T(s2,env));
412 stsel = isSimpleType(T(sel,env));
413
414 return makeSimpleType( st1->nature()|st2->nature(),
415 st1->variability()|st2->variability()|stsel->variability(),
416 st1->computability()|st2->computability()|stsel->computability(),
417 st1->vectorability()|st2->vectorability()|stsel->vectorability(),
418 st1->boolean()|st2->boolean(),
419 reunion(st1->getInterval(), st2->getInterval())
420 );
421 }
422
423 else if (isSigSelect3(sig,sel,s1,s2,s3)) { return T(sel,env)|T(s1,env)|T(s2,env)|T(s3,env); }
424
425 else if (isNil(sig)) { Type t = new TupletType(); /*sig->setType(t);*/ return t; }
426
427 else if (isList(sig)) { return T( hd(sig),env ) * T( tl(sig),env ); }
428
429 else if ( isSigVectorize(sig, x, y) ) return infereVectorizeType(sig, T(x,env), T(y,env));
430 else if ( isSigSerialize(sig, x) ) return infereSerializeType(sig, T(x,env));
431 else if ( isSigConcat(sig, x, y) ) return infereConcatType(T(x,env), T(y,env));
432 else if ( isSigVectorAt(sig, x, y) ) return infereVectorAtType(T(x,env), T(y,env));
433
434 else if ( isSigUpSample(sig, x, y) ) { T(x,env); return T(y,env); }
435 else if ( isSigDownSample(sig, x, y) ) { T(x,env); return T(y,env); }
436
437 // unrecognized signal here
438 fprintf(stderr, "ERROR in ***infereSigType()***, unrecognized signal : "); print(sig, stderr); fprintf(stderr, "\n");
439 exit(1);
440 return 0;
441 }
442
443
444 /**
445 * Infere the type of a projection (selection) of a tuplet element
446 */
447 static Type infereProjType(Type t, int i, int vec)
448 {
449 TupletType* tt = isTupletType(t);
450 if (tt == 0) {
451 cerr << "ERROR infering projection type, not a tuplet type : " << t << endl;
452 exit(1);
453 }
454 //return (*tt)[i] ->promoteVariability(t->variability())
455 // ->promoteComputability(t->computability());
456 Type temp = (*tt)[i] ->promoteVariability(t->variability())
457 ->promoteComputability(t->computability())
458 ->promoteVectorability(vec/*t->vectorability()*/);
459 //->promoteBooleanity(t->boolean());
460
461 if(vec==kVect) temp = vecCast(temp);
462 //cerr << "infereProjType(" << t << ',' << i << ',' << vec << ")" << " -> " << temp << endl;
463
464 return temp;
465 }
466
467
468
469 /**
470 * Infere the type of the result of writing into a table
471 */
472 static Type infereWriteTableType(Type tbl, Type wi, Type wd)
473 {
474 TableType* tt = isTableType(tbl);
475 if (tt == 0) {
476 cerr << "ERROR infering write table type, wrong table type : " << tbl << endl;
477 exit(1);
478 }
479 SimpleType* st = isSimpleType(wi);
480 if (st == 0 || st->nature() > kInt) {
481 cerr << "ERROR infering write table type, wrong write index type : " << wi << endl;
482 exit(1);
483 }
484
485 int n = tt->nature();
486 int v = wi->variability() | wd->variability();
487 int c = wi->computability() | wd->computability();
488 int vec = wi->vectorability() | wd->vectorability();
489
490 return makeTableType(tt->content(), n, v, c, vec);
491
492 }
493
494
495
496 /**
497 * Infere the type of the result of reading a table
498 */
499 static Type infereReadTableType(Type tbl, Type ri)
500 {
501 TableType* tt = isTableType(tbl);
502 if (tt == 0) {
503 cerr << "ERROR infering read table type, wrong table type : " << tbl << endl;
504 exit(1);
505 }
506 SimpleType* st = isSimpleType(ri);
507 if (st == 0 || st->nature() > kInt) {
508 cerr << "ERROR infering read table type, wrong write index type : " << ri << endl;
509 exit(1);
510 }
511
512 Type temp = tt->content()->promoteVariability(ri->variability()|tt->variability())
513 ->promoteComputability(ri->computability()|tt->computability())
514 ->promoteVectorability(ri->vectorability()|tt->vectorability())
515 ->promoteBoolean(ri->boolean()|tt->boolean())
516 ;
517
518 return temp;
519
520 }
521
522
523 static Type infereDocConstantTblType(Type size, Type init)
524 {
525 checkKonst(checkInt(checkInit(size)));
526
527 return init;
528 }
529
530 static Type infereDocWriteTblType(Type size, Type init, Type widx, Type wsig)
531 {
532 checkKonst(checkInt(checkInit(size)));
533
534 Type temp = init
535 ->promoteVariability(kSamp) // difficult to tell, therefore kSamp to be safe
536 ->promoteComputability(widx->computability()|wsig->computability())
537 ->promoteVectorability(kScal) // difficult to tell, therefore kScal to be safe
538 ->promoteNature(wsig->nature()) // nature of the initial and written signal
539 ->promoteBoolean(wsig->boolean()) // booleanity of the initial and written signal
540 ;
541 return temp;
542 }
543
544 static Type infereDocAccessTblType(Type tbl, Type ridx)
545 {
546 Type temp = tbl
547 ->promoteVariability(ridx->variability())
548 ->promoteComputability(ridx->computability())
549 ->promoteVectorability(ridx->vectorability())
550 ;
551 return temp;
552 }
553
554
555 /**
556 * Compute an initial type solution for a recursive block
557 * E1,E2,...En -> TREC,TREC,...TREC
558 */
559 static Type initialRecType(Tree t)
560 {
561 assert (isList(t));
562
563 vector<Type> v;
564 while (isList(t)) { v.push_back(TREC); t = tl(t); };
565 return new TupletType(v);
566 }
567
568
569 /**
570 * Infere the type of e recursive block by trying solutions of
571 * increasing generality
572 */
573 static Type infereRecType (Tree sig, Tree body, Tree env)
574 {
575 assert(false); // we should not come here
576 return 0;
577 }
578
579
580 /**
581 * Infere the type of a foreign function call
582 */
583 static Type infereFFType (Tree ff, Tree ls, Tree env)
584 {
585 // une primitive externe ne peut pas se calculer au plus tot qu'a
586 // l'initialisation. Sa variabilite depend de celle de ses arguments
587 // sauf si elle n'en pas, auquel cas on considere que c'est comme
588 // rand() c'est a dire que le resultat varie a chaque appel.
589 if (ffarity(ff)==0) {
590 // case of functions like rand()
591 return makeSimpleType(ffrestype(ff),kSamp,kInit,kVect,kNum, interval());
592 } else {
593 // otherwise variability and computability depends
594 // arguments (OR of all arg types)
595 Type t = makeSimpleType(kInt,kKonst,kInit,kVect,kNum, interval());
596 while (isList(ls)) { t = t|T(hd(ls),env); ls=tl(ls); }
597 // but the result type is defined by the function
598
599 //return t;
600 return makeSimpleType( ffrestype(ff),
601 t->variability(),
602 t->computability(),
603 t->vectorability(),
604 t->boolean(),
605 interval() );
606 }
607 }
608
609
610 /**
611 * Infere the type of a foreign constant
612 */
613 static Type infereFConstType (Tree type)
614 {
615 // une constante externe ne peut pas se calculer au plus tot qu'a
616 // l'initialisation. Elle est constante, auquel cas on considere que c'est comme
617 // rand() c'est a dire que le resultat varie a chaque appel.
618 return makeSimpleType(tree2int(type),kKonst,kInit,kVect,kNum, interval());
619 }
620
621
622 /**
623 * Infere the type of a foreign variable
624 */
625 static Type infereFVarType (Tree type)
626 {
627 // une variable externe ne peut pas se calculer au plus tot qu'a
628 // l'execution. Elle est varie par blocs comme les éléments d'interface utilisateur.
629 return makeSimpleType(tree2int(type),kBlock,kExec,kVect,kNum, interval());
630 }
631
632
633 /**
634 * Infere the type of an extended (primitive) block
635 */
636 static Type infereXType(Tree sig, Tree env)
637 {
638 //cerr << "infereXType :" << endl;
639 //cerr << "infereXType of " << *sig << endl;
640 xtended* p = (xtended*) getUserData(sig);
641 vector<Type> vt;
642
643 for (int i = 0; i < sig->arity(); i++) vt.push_back(T(sig->branch(i), env));
644 return p->infereSigType(vt);
645 }
646
647
648
649
650
651 /**
652 * Compute the resulting interval of an arithmetic operation
653 * @param op code of the operation
654 * @param s1 interval of the left operand
655 * @param s2 interval of the right operand
656 * @return the resulting interval
657 */
658
659 static interval arithmetic (int opcode, const interval& x, const interval& y)
660 {
661 switch (opcode) {
662 case kAdd: return x+y;
663 case kSub: return x-y;
664 case kMul: return x*y;
665 case kDiv: return x/y;
666 case kRem: return x%y;
667 case kLsh: return x<<y;
668 case kRsh: return x>>y;
669 case kGT: return x>y;
670 case kLT: return x<y;
671 case kGE: return x>=y;
672 case kLE: return x<=y;
673 case kEQ: return x==y;
674 case kNE: return x!=y;
675 case kAND: return x&y;
676 case kOR: return x|y;
677 case kXOR: return x^y;
678 default:
679 cerr << "Unrecognized opcode : " << opcode << endl;
680 exit(1);
681 }
682
683 return interval();
684 }
685
686
687
688 static Type infereVectorizeType(Tree sig, Type Tsize, Type T)
689 {
690 SimpleType* st = isSimpleType(Tsize);
691 if (st && st->nature()==kInt) {
692 interval i = Tsize->getInterval();
693 if (i.valid && i.lo >= 0 && i.lo == i.hi) {
694 return new VectorType(int(i.lo+0.5), T);
695 }
696 }
697 cerr << "ERROR in expression : " << ppsig(sig) << endl;
698 cerr << "the size of the vector is not of a valide type : " << *Tsize << endl;
699 exit(1);
700 }
701
702 static Type infereSerializeType(Tree sig, Type Tvec)
703 {
704 VectorType* vt = isVectorType(Tvec);
705 if (vt) {
706 return vt->content();
707 } else {
708 cerr << "ERROR in expression : " << ppsig(sig) << endl;
709 cerr << "the 'serialize' operation can only be used on vectorized signals" << endl;
710 exit(1);
711 }
712 }
713
714 static Type infereConcatType(Type Tvec1, Type Tvec2)
715 {
716 VectorType* vt1 = isVectorType(Tvec1);
717 VectorType* vt2 = isVectorType(Tvec2);
718
719 if (vt1 && vt2) {
720 Type ct1 = vt1->content();
721 Type ct2 = vt2->content();
722 if (ct1 == ct2) {
723 return new VectorType(vt1->size()+vt2->size(), ct1);
724 }
725 }
726 cerr << "ERROR in vector concatenation, the types : " << Tvec1 << " and " << Tvec2 << " are incompatible" << endl;
727 exit(1);
728 }
729
730 static Type infereVectorAtType(Type Tvec, Type Tidx)
731 {
732 VectorType* vt = isVectorType(Tvec);
733 SimpleType* it = isSimpleType(Tidx);
734
735 if (vt && it) {
736 Type ct = vt->content();
737 int n = vt->size();
738 interval i = it->getInterval();
739 if (i.valid && i.lo >= 0 && i.hi <= n) {
740 return ct;
741 }
742 }
743 cerr << "ERROR in vector access, with types : " << Tvec << " and " << Tidx << endl;
744 exit(1);
745 }