Analysis: infer when a refcount is required and add colors in DebugVisitor
[scilab.git] / scilab / modules / ast / includes / exps / exp.hxx
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2007-2008 - DIGITEO - Bruno JOFRET
4  *
5  *  This file must be used under the terms of the CeCILL.
6  *  This source file is licensed as described in the file COPYING, which
7  *  you should have received as part of this distribution.  The terms
8  *  are also available at
9  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12
13 /**
14 ** \file exp.hxx
15 ** Define the Expression mother class.
16 */
17
18 #ifndef AST_EXP_HXX
19 #define AST_EXP_HXX
20
21 #include <list>
22 #include <vector>
23 #include <algorithm>
24 #include "ast.hxx"
25
26 namespace ast
27 {
28
29 /** \brief Define a shorthand for list of Exp* manipulation. */
30 typedef std::vector<Exp *> exps_t;
31
32 /** \brief Abstract an Expression node. */
33 class Exp : public Ast
34 {
35
36     /** \name Ctor & dtor.
37     ** \{ */
38 public:
39     /** \brief Construct an Expression node.
40     ** \param location scanner position informations */
41     Exp (const Location& location)
42         : Ast (location),
43           _verbose(false),
44           _bBreak(false),
45           _bBreakable(false),
46           _bReturn(false),
47           _bReturnable(false),
48           _bContinue(false),
49           _bContinuable(false),
50           parent(NULL),
51           original(NULL)
52     {
53         original = this;
54     }
55     /** \brief Destroys an Expression node. */
56     virtual ~Exp ()
57     {
58         for (exps_t::const_iterator it = _exps.begin(); it != _exps.end(); ++it)
59         {
60             if (*it != NULL)
61             {
62                 delete *it;
63             }
64         }
65
66         if (original && original != this)
67         {
68             delete original;
69         }
70     }
71     /** \} */
72
73     virtual Exp* clone() = 0;
74
75     virtual bool equal(const Exp & e) const
76     {
77         if (getType() == e.getType() && _exps.size() == e._exps.size())
78         {
79             for (exps_t::const_iterator i = _exps.begin(), j = e._exps.begin(), _e = _exps.end(); i != _e; ++i, ++j)
80             {
81                 if (!(*i)->equal(**j))
82                 {
83                     return false;
84                 }
85             }
86             return true;
87         }
88         return false;
89     }
90
91     inline bool operator==(const Exp & R) const
92     {
93         return equal(R);
94     }
95
96     inline bool operator!=(const Exp & R) const
97     {
98         return !equal(R);
99     }
100
101 public:
102     /** \brief Return if an expression should be displayed or not. */
103     inline void mute(void)
104     {
105         _verbose = false;
106     }
107
108     /** \brief Return if an expression should be displayed or not. */
109     inline void setVerbose(bool verbose)
110     {
111         _verbose = verbose;
112     }
113
114     /** \brief Return if an expression should be displayed or not. */
115     inline virtual bool isVerbose(void) const
116     {
117         return _verbose;
118     }
119
120     //manage break instruction
121     inline void setBreak(void)
122     {
123         _bBreak = true;
124     }
125
126     inline void resetBreak(void)
127     {
128         _bBreak = false;
129     }
130
131     inline virtual bool isBreak(void) const
132     {
133         return _bBreak;
134     }
135
136     virtual inline void setBreakable(void)
137     {
138         _bBreakable = true;
139     }
140
141     inline void resetBreakable(void)
142     {
143         _bBreakable = false;
144     }
145
146     inline virtual bool isBreakable(void) const
147     {
148         return _bBreakable;
149     }
150
151     //manage return instruction
152     inline void setReturn(void)
153     {
154         _bReturn = true;
155     }
156
157     inline void resetReturn(void)
158     {
159         _bReturn = false;
160     }
161
162     inline virtual bool isReturn(void) const
163     {
164         return _bReturn;
165     }
166
167     virtual inline void setReturnable(void)
168     {
169         _bReturnable = true;
170     }
171
172     inline void resetReturnable(void)
173     {
174         _bReturnable = false;
175     }
176
177     inline virtual bool isReturnable(void) const
178     {
179         return _bReturnable;
180     }
181
182     //manage continue instruction
183     inline void setContinue(void)
184     {
185         _bContinue = true;
186     }
187
188     inline void resetContinue(void)
189     {
190         _bContinue = false;
191     }
192
193     inline virtual bool isContinue(void) const
194     {
195         return _bContinue;
196     }
197
198     virtual inline void setContinuable(void)
199     {
200         _bContinuable = true;
201     }
202
203     inline void resetContinuable(void)
204     {
205         _bContinuable = false;
206     }
207
208     inline virtual bool isContinuable(void) const
209     {
210         return _bContinuable;
211     }
212
213     //manage derived exp
214     enum ExpType
215     {
216         SIMPLEVAR,
217         DOLLARVAR,
218         COLONVAR,
219         ARRAYLISTVAR,
220         DOUBLEEXP,
221         BOOLEXP,
222         STRINGEXP,
223         COMMENTEXP,
224         CONSTEXP,
225         NILEXP,
226         CALLEXP,
227         CELLCALLEXP,
228         OPEXP,
229         LOGICALOPEXP,
230         ASSIGNEXP,
231         IFEXP,
232         WHILEEXP,
233         FOREXP,
234         BREAKEXP,
235         CONTINUEEXP,
236         TRYCATCHEXP,
237         SELECTEXP,
238         CASEEXP,
239         RETURNEXP,
240         FIELDEXP,
241         NOTEXP,
242         TRANSPOSEEXP,
243         MATRIXEXP,
244         MATRIXLINEEXP,
245         CELLEXP,
246         SEQEXP,
247         ARRAYLISTEXP,
248         ASSIGNLISTEXP,
249         VARDEC,
250         FUNCTIONDEC,
251         LISTEXP,
252         OPTIMIZEDEXP,
253         MEMFILLEXP,
254         DAXPYEXP,
255         STRINGSELECTEXP,
256         TABLEINTSELECTEXP,
257         MAPINTSELECTEXP,
258         SMALLINTSELECTEXP,
259     };
260
261     const std::wstring getTypeString() const
262     {
263         switch (getType())
264         {
265             case SIMPLEVAR:
266                 return L"SimpleVar";
267             case DOLLARVAR:
268                 return L"DollarVar";
269             case COLONVAR:
270                 return L"ColonVar";
271             case ARRAYLISTVAR:
272                 return L"ArrayListVar";
273             case DOUBLEEXP:
274                 return L"DoubleExp";
275             case BOOLEXP:
276                 return L"BoolExp";
277             case STRINGEXP:
278                 return L"StringExp";
279             case COMMENTEXP:
280                 return L"CommentExp";
281             case CONSTEXP:
282                 return L"ConstExp";
283             case NILEXP:
284                 return L"NilExp";
285             case CALLEXP:
286                 return L"CallExp";
287             case CELLCALLEXP:
288                 return L"CellCallExp";
289             case OPEXP:
290                 return L"OpExp";
291             case LOGICALOPEXP:
292                 return L"LogicalOpExp";
293             case ASSIGNEXP:
294                 return L"AssignExp";
295             case IFEXP:
296                 return L"IfExp";
297             case WHILEEXP:
298                 return L"WhileExp";
299             case FOREXP:
300                 return L"ForExp";
301             case BREAKEXP:
302                 return L"BreakExp";
303             case CONTINUEEXP:
304                 return L"ContinueExp";
305             case TRYCATCHEXP:
306                 return L"TryCatchExp";
307             case SELECTEXP:
308                 return L"SelectExp";
309             case CASEEXP:
310                 return L"CaseExp";
311             case RETURNEXP:
312                 return L"ReturnExp";
313             case FIELDEXP:
314                 return L"FieldExp";
315             case NOTEXP:
316                 return L"NotExp";
317             case TRANSPOSEEXP:
318                 return L"TransposeExp";
319             case MATRIXEXP:
320                 return L"MatrixExp";
321             case MATRIXLINEEXP:
322                 return L"MatrixLineExp";
323             case CELLEXP:
324                 return L"CellExp";
325             case SEQEXP:
326                 return L"SeqExp";
327             case ARRAYLISTEXP:
328                 return L"ArrayListExp";
329             case ASSIGNLISTEXP:
330                 return L"AssignListExp";
331             case VARDEC:
332                 return L"VarDec";
333             case FUNCTIONDEC:
334                 return L"FunctionDec";
335             case LISTEXP:
336                 return L"ListExp";
337             case OPTIMIZEDEXP:
338                 return L"OptimizedExp";
339             case MEMFILLEXP:
340                 return L"MemfillExp";
341             case DAXPYEXP:
342                 return L"DAXPYExp";
343             case STRINGSELECTEXP:
344                 return L"StringSelectExp";
345             case TABLEINTSELECTEXP:
346                 return L"TableIntSelectExp";
347             case MAPINTSELECTEXP:
348                 return L"MapIntSelectExp";
349             case SMALLINTSELECTEXP:
350                 return L"SmallIntSelectExp";
351             default:
352                 return L"????Exp";
353         }
354     }
355
356     virtual ExpType getType() const = 0;
357
358     template <class T>
359     inline T* getAs(void)
360     {
361         return static_cast<T*>(this);
362     }
363
364     template <class T>
365     inline const T* getAs(void) const
366     {
367         return static_cast<const T*>(this);
368     }
369
370     inline virtual bool isSimpleVar() const
371     {
372         return false;
373     }
374
375     inline virtual bool isDollarVar() const
376     {
377         return false;
378     }
379
380     inline virtual bool isColonVar() const
381     {
382         return false;
383     }
384
385     inline virtual bool isArrayListVar() const
386     {
387         return false;
388     }
389
390     inline virtual bool isDoubleExp() const
391     {
392         return false;
393     }
394
395     inline virtual bool isBoolExp() const
396     {
397         return false;
398     }
399
400     inline virtual bool isStringExp() const
401     {
402         return false;
403     }
404
405     inline virtual bool isCommentExp() const
406     {
407         return false;
408     }
409
410     inline virtual bool isConstExp() const
411     {
412         return false;
413     }
414
415     inline virtual bool isNilExp() const
416     {
417         return false;
418     }
419
420     inline virtual bool isCallExp() const
421     {
422         return false;
423     }
424
425     inline virtual bool isCellCallExp() const
426     {
427         return false;
428     }
429
430     inline virtual bool isOpExp() const
431     {
432         return false;
433     }
434
435     inline virtual bool isLogicalOpExp() const
436     {
437         return false;
438     }
439
440     inline virtual bool isAssignExp() const
441     {
442         return false;
443     }
444
445     inline virtual bool isIfExp() const
446     {
447         return false;
448     }
449
450     inline virtual bool isWhileExp() const
451     {
452         return false;
453     }
454
455     inline virtual bool isForExp() const
456     {
457         return false;
458     }
459
460     inline virtual bool isBreakExp() const
461     {
462         return false;
463     }
464
465     inline virtual bool isContinueExp() const
466     {
467         return false;
468     }
469
470     inline virtual bool isTryCatchExp() const
471     {
472         return false;
473     }
474
475     inline virtual bool isSelectExp() const
476     {
477         return false;
478     }
479
480     inline virtual bool isCaseExp() const
481     {
482         return false;
483     }
484
485     inline virtual bool isReturnExp() const
486     {
487         return false;
488     }
489
490     inline virtual bool isFieldExp() const
491     {
492         return false;
493     }
494
495     inline virtual bool isNotExp() const
496     {
497         return false;
498     }
499
500     inline virtual bool isTransposeExp() const
501     {
502         return false;
503     }
504
505     inline virtual bool isMatrixExp() const
506     {
507         return false;
508     }
509
510     inline virtual bool isMatrixLineExp() const
511     {
512         return false;
513     }
514
515     inline virtual bool isCellExp() const
516     {
517         return false;
518     }
519
520     inline virtual bool isSeqExp() const
521     {
522         return false;
523     }
524
525     inline virtual bool isArrayListExp() const
526     {
527         return false;
528     }
529
530     inline virtual bool isAssignListExp() const
531     {
532         return false;
533     }
534
535     inline virtual bool isVarDec() const
536     {
537         return false;
538     }
539
540     inline virtual bool isFunctionDec() const
541     {
542         return false;
543     }
544
545     inline virtual bool isListExp() const
546     {
547         return false;
548     }
549
550     inline virtual bool isOptimizedExp() const
551     {
552         return false;
553     }
554
555     inline virtual bool isMemfillExp() const
556     {
557         return false;
558     }
559
560     inline virtual bool isFastSelectExp() const
561     {
562         return false;
563     }
564
565     inline virtual bool isStringSelectExp() const
566     {
567         return false;
568     }
569
570     inline virtual bool isIntSelectExp() const
571     {
572         return false;
573     }
574
575     inline virtual bool isTableIntSelectExp() const
576     {
577         return false;
578     }
579
580     inline virtual bool isMapIntSelectExp() const
581     {
582         return false;
583     }
584
585     inline virtual bool isSmallIntSelectExp() const
586     {
587         return false;
588     }
589
590     inline Exp* getParent() const
591     {
592         return parent;
593     }
594
595     inline Exp* getParent()
596     {
597         return parent;
598     }
599
600     inline void setParent(Exp* _ast)
601     {
602         parent = _ast;
603     }
604
605     inline Exp* getOriginal() const
606     {
607         return original;
608     }
609
610     inline Exp* getOriginal()
611     {
612         return original;
613     }
614
615     inline void setOriginal(Exp* _ast)
616     {
617         original = _ast;
618     }
619
620     inline void replace(Exp* _new)
621     {
622         if (parent && _new)
623         {
624             parent->replace(this, _new);
625         }
626     }
627
628     inline void replace(Exp* _old, Exp* _new)
629     {
630         if (_old && _new)
631         {
632             for (exps_t::iterator it = _exps.begin(), itEnd = _exps.end(); it != itEnd; ++it)
633             {
634                 if (*it == _old)
635                 {
636                     _new->setOriginal(_old);
637                     *it = _new;
638                     _new->setParent(this);
639                     return;
640                 }
641             }
642         }
643     }
644
645     inline const exps_t & getExps() const
646     {
647         return _exps;
648     }
649
650     inline exps_t & getExps()
651     {
652         return _exps;
653     }
654
655 private:
656     bool _verbose;
657     bool _bBreak;
658     bool _bBreakable;
659     bool _bReturn;
660     bool _bReturnable;
661     bool _bContinue;
662     bool _bContinuable;
663 protected:
664     exps_t _exps;
665     Exp* parent;
666     Exp* original;
667 };
668 } // namespace ast
669
670 #endif // !AST_EXP_HXX