Analysis: fix bugs found with Coverity
[scilab.git] / scilab / modules / ast / includes / analysis / gvn / TestGVNVisitor.hxx
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2014 - Scilab Enterprises - Calixte DENIZET
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 #ifndef __TEST_GVN_VISITOR_HXX__
14 #define __TEST_GVN_VISITOR_HXX__
15
16 #include <iostream>
17 #include <string>
18 #include <map>
19
20 #include "visitor.hxx"
21 #include "execvisitor.hxx"
22 #include "allexp.hxx"
23 #include "allvar.hxx"
24 //#include "Chrono.hxx"
25 #include "GVN.hxx"
26
27 namespace analysis
28 {
29
30 class TestGVNVisitor : public ast::Visitor /*, public Chrono */
31 {
32
33     GVN gvn;
34     const GVN::Value * _result;
35
36 public:
37
38     TestGVNVisitor() : _result(nullptr)
39     {
40         //start_chrono();
41     }
42
43     virtual ~TestGVNVisitor()
44     {
45     }
46
47     inline void print_info()
48     {
49         //stop_chrono();
50         std::wcout << L"GVN: " << /* *static_cast<Chrono *>(this) << */ std::endl;
51         std::wcout << gvn << std::endl;
52     }
53
54     inline void setResult(const GVN::Value * val)
55     {
56         _result = val;
57     }
58
59     inline const GVN::Value & getResult()
60     {
61         return *_result;
62     }
63
64     inline std::map<std::wstring, uint64_t> getSymMap() const
65     {
66         return gvn.getSymMap();
67     }
68
69 private:
70
71     void visit(ast::SimpleVar & e)
72     {
73         setResult(gvn.getValue(e.getSymbol()));
74     }
75
76     void visit(ast::DollarVar & e)
77     {
78         // nothing to do
79     }
80
81     void visit(ast::ColonVar & e)
82     {
83         // nothing to do
84     }
85
86     void visit(ast::ArrayListVar & e)
87     {
88     }
89
90     void visit(ast::DoubleExp & e)
91     {
92         setResult(gvn.getValue(e.getValue()));
93     }
94
95     void visit(ast::BoolExp & e)
96     {
97     }
98
99     void visit(ast::StringExp & e)
100     {
101     }
102
103     void visit(ast::CommentExp & e)
104     {
105         // ignored
106     }
107
108     void visit(ast::NilExp & e)
109     {
110         // nothing to do
111     }
112
113     void visit(ast::CallExp & e)
114     {
115     }
116
117     void visit(ast::CellCallExp & e)
118     {
119     }
120
121     void visit(ast::OpExp & e)
122     {
123         e.getLeft().accept(*this);
124         const GVN::Value & LV = getResult();
125         e.getRight().accept(*this);
126         const GVN::Value & RV = getResult();
127
128         switch (e.getOper())
129         {
130             case ast::OpExp::plus:
131                 setResult(gvn.getValue(OpValue::PLUS, LV, RV));
132                 break;
133             case ast::OpExp::minus:
134                 setResult(gvn.getValue(OpValue::MINUS, LV, RV));
135                 break;
136             case ast::OpExp::unaryMinus:
137                 setResult(gvn.getValue(OpValue::UNARYMINUS, RV));
138                 break;
139             case ast::OpExp::rdivide:
140                 setResult(gvn.getValue(OpValue::RDIV, LV, RV));
141                 break;
142             case ast::OpExp::dotrdivide:
143                 setResult(gvn.getValue(OpValue::DOTRDIV, LV, RV));
144                 break;
145             case ast::OpExp::times:
146                 setResult(gvn.getValue(OpValue::TIMES, LV, RV));
147                 break;
148             case ast::OpExp::dottimes:
149                 setResult(gvn.getValue(OpValue::DOTTIMES, LV, RV));
150                 break;
151             case ast::OpExp::power:
152                 setResult(gvn.getValue(OpValue::POWER, LV, RV));
153                 break;
154             case ast::OpExp::dotpower:
155                 setResult(gvn.getValue(OpValue::DOTPOWER, LV, RV));
156                 break;
157             case ast::OpExp::eq:
158                 if (LV.value == RV.value)
159                 {
160                     setResult(gvn.getValue(1));
161                 }
162                 else
163                 {
164                     setResult(gvn.getValue(0));
165                 }
166                 break;
167             case ast::OpExp::ne:
168                 if (LV.value != RV.value)
169                 {
170                     setResult(gvn.getValue(1));
171                 }
172                 else
173                 {
174                     setResult(gvn.getValue(0));
175                 }
176                 break;
177         }
178     }
179
180     void visit(ast::LogicalOpExp & e)
181     {
182     }
183
184     void visit(ast::AssignExp & e)
185     {
186         if (e.getLeftExp().isSimpleVar())
187         {
188             ast::SimpleVar & Lvar = static_cast<ast::SimpleVar &>(e.getLeftExp());
189             symbol::Symbol & Lsym = Lvar.getSymbol();
190
191             if (e.getRightExp().isCallExp())
192             {
193                 ast::CallExp & ce = static_cast<ast::CallExp &>(e.getRightExp());
194                 std::unordered_map<uint64_t, const MultivariatePolynomial *> args;
195                 const symbol::Symbol & sym = static_cast<ast::SimpleVar &>(ce.getName()).getSymbol();
196                 for (auto & arg : ce.getExps())
197                 {
198                     if (arg->isAssignExp())
199                     {
200                         ast::AssignExp & ae = static_cast<ast::AssignExp &>(*arg);
201                         const symbol::Symbol & _Lsym = static_cast<ast::SimpleVar &>(ae.getLeftExp()).getSymbol();
202                         ae.getRightExp().accept(*this);
203                         args[gvn.getValue(_Lsym)->value] = getResult().poly;
204                     }
205                 }
206                 const GVN::Value * callee = gvn.getValue(sym);
207                 gvn.setValue(Lsym, callee->poly->eval(args));
208             }
209             else
210             {
211                 e.getRightExp().accept(*this);
212                 gvn.setValue(Lsym, getResult());
213             }
214         }
215     }
216
217     void visit(ast::IfExp & e)
218     {
219     }
220
221     void visit(ast::WhileExp & e)
222     {
223     }
224
225     void visit(ast::ForExp & e)
226     {
227     }
228
229     void visit(ast::BreakExp & e)
230     {
231         // nothing to do
232     }
233
234     void visit(ast::ContinueExp & e)
235     {
236         // nothing to do
237     }
238
239     void visit(ast::TryCatchExp & e)
240     {
241     }
242
243     void visit(ast::SelectExp & e)
244     {
245     }
246
247     void visit(ast::CaseExp & e)
248     {
249     }
250
251     void visit(ast::ReturnExp & e)
252     {
253     }
254
255     void visit(ast::FieldExp & e)
256     {
257     }
258
259     void visit(ast::NotExp & e)
260     {
261     }
262
263     void visit(ast::TransposeExp & e)
264     {
265     }
266
267     void visit(ast::MatrixExp & e)
268     {
269     }
270
271     void visit(ast::MatrixLineExp & e)
272     {
273     }
274
275     void visit(ast::CellExp & e)
276     {
277     }
278
279     void visit(ast::SeqExp & e)
280     {
281         for (auto exp : e.getExps())
282         {
283             exp->accept(*this);
284         }
285     }
286
287     void visit(ast::ArrayListExp & e)
288     {
289     }
290
291     void visit(ast::AssignListExp & e)
292     {
293     }
294
295     void visit(ast::VarDec & e)
296     {
297     }
298
299     void visit(ast::FunctionDec & e)
300     {
301     }
302
303     void visit(ast::ListExp & e)
304     {
305     }
306
307     void visit(ast::OptimizedExp & e)
308     {
309     }
310
311     void visit(ast::MemfillExp & e)
312     {
313     }
314
315     void visit(ast::DAXPYExp & e)
316     {
317     }
318
319     void visit(ast::IntSelectExp & e)
320     {
321     }
322
323     void visit(ast::StringSelectExp & e)
324     {
325     }
326 };
327
328 } // namespace analysis
329
330 #endif // __TEST_GVN_VISITOR_HXX__