Fix some easy to fix warnings
[scilab.git] / scilab / modules / ast / includes / analysis / gvn / SymbolicList.hxx
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2015 - Scilab Enterprises - Calixte DENIZET
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 #ifndef __SYMBOLIC_LIST_HXX__
17 #define __SYMBOLIC_LIST_HXX__
18
19 #include <iostream>
20
21 #include "GVN.hxx"
22 #include "TIType.hxx"
23
24 namespace analysis
25 {
26
27 /**
28  * \class SymbolicList
29  * \brief Manage a symbolic list
30  */
31 class SymbolicList
32 {
33
34     union Value
35     {
36         GVN::Value * gvnVal;
37         double dval;
38
39         Value() { }
40         Value(GVN::Value * val) : gvnVal(val) { }
41         Value(double val) : dval(val) { }
42     };
43
44     bool symbolic;
45
46     Value start;
47     Value step;
48     Value end;
49
50 public:
51
52     /**
53      * \brief default constructor
54      */
55     SymbolicList() : symbolic(false), start(0.), step(0.), end(0.) { }
56
57     /**
58      * \brief constructor
59      * \param _gvn the GVN to use
60      * \param _start the starting value
61      * \param _end the ending value
62      */
63     SymbolicList(GVN::Value * _start, GVN::Value * _step, GVN::Value * _end) : symbolic(true), start(_start), step(_step), end(_end) { }
64
65     /**
66      * \brief constructor
67      * \param _gvn the GVN to use
68      * \param _start the starting value
69      * \param _end the ending value
70      */
71     SymbolicList(double _start, double _step, double _end) : symbolic(false), start(_start), step(_step), end(_end) { }
72
73     /**
74      * \brief constructor
75      */
76     SymbolicList(SymbolicList && sl) : symbolic(sl.symbolic), start(sl.start), step(sl.step), end(sl.end) { }
77
78     inline SymbolicList & operator=(SymbolicList && sl)
79     {
80         symbolic = sl.symbolic;
81         start = sl.start;
82         step = sl.step;
83         end = sl.end;
84
85         return *this;
86     }
87
88     inline bool isSymbolic() const
89     {
90         return symbolic;
91     }
92
93     inline void setStart(GVN::Value * val)
94     {
95         start.gvnVal = val;
96     }
97
98     inline void setStep(GVN::Value * val)
99     {
100         step.gvnVal = val;
101     }
102
103     inline void setEnd(GVN::Value * val)
104     {
105         end.gvnVal = val;
106     }
107
108     inline GVN::Value * getStart() const
109     {
110         return start.gvnVal;
111     }
112
113     inline GVN::Value * getStep() const
114     {
115         return step.gvnVal;
116     }
117
118     inline GVN::Value * getEnd() const
119     {
120         return end.gvnVal;
121     }
122
123     inline double getStart(double) const
124     {
125         return start.dval;
126     }
127
128     inline double getStep(double) const
129     {
130         return step.dval;
131     }
132
133     inline double getEnd(double) const
134     {
135         return end.dval;
136     }
137
138     bool getType(GVN & gvn, TIType & type) const;
139     void evalDollar(GVN & gvn, const GVN::Value * dollarVal);
140     bool checkAsIndex(const GVN::Value * dim);
141
142     static bool get(AnalysisVisitor & visitor, ast::ListExp & le, SymbolicList & sl);
143
144     /**
145      * \brief Overload of the << operator
146      */
147     friend inline std::wostream & operator<<(std::wostream & out, const SymbolicList & sl)
148     {
149         if (sl.symbolic)
150         {
151             out << *sl.start.gvnVal->poly << L" : " << *sl.step.gvnVal->poly << L" : " << *sl.end.gvnVal->poly;
152         }
153         else
154         {
155             out << sl.start.dval << L" : " << sl.step.dval << L" : " << sl.end.dval;
156         }
157         return out;
158     }
159
160     inline static GVN::Value * evalDollar(GVN & gvn, const GVN::Value * value, const GVN::Value * dollar, const GVN::Value * dollarVal)
161     {
162         if (value->poly->contains(dollar->value))
163         {
164             const MultivariatePolynomial & mp = value->poly->eval(std::pair<unsigned long long, const MultivariatePolynomial *>(dollar->value, dollarVal->poly));
165             return gvn.getValue(mp);
166         }
167
168         return nullptr;
169     }
170 };
171
172 } // namespace analysis
173
174 #endif // __SYMBOLIC_LIST_HXX__