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