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