92fea2e0d0da4308bdd52ddc21edc620401aaeb1
[scilab.git] / scilab / modules / ast / src / cpp / ast / debugvisitor.cpp
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2008-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 #include "debugvisitor.hxx"
14
15
16 namespace ast
17 {
18 static int level = -1;
19
20 void DebugVisitor::START_NODE(const ast::Ast& e)
21 {
22     *ostr << L"(" << e.getNodeNumber() << L") ";
23     ++level;
24 }
25
26 void DebugVisitor::END_NODE(void)
27 {
28     --level;
29 }
30
31 void DebugVisitor::print(const std::wstring& str)
32 {
33     for (int i = 0 ; i < level; ++i)
34     {
35         *ostr << L"  ";
36     }
37     if (level > 0)
38     {
39         *ostr << L"     ";
40     }
41     *ostr << str << std::endl;
42 }
43
44 void DebugVisitor::print(const std::wstring& str, const Exp &e)
45 {
46     for (int i = 0 ; i < level; ++i)
47     {
48         *ostr << L"  ";
49     }
50     if (level > 0)
51     {
52         *ostr << L"|_./ ";
53     }
54     *ostr << str;
55
56     Location loc = e.getLocation();
57     *ostr << L" @(" << loc.first_line << L"." << loc.first_column << L" -> ";
58     *ostr << loc.last_line << L"." << loc.last_column << L")";
59     if (printDecoration)
60     {
61         *ostr << L" Deco(" << e.getDecorator() << L")";
62     }
63     *ostr << std::endl;
64 }
65
66
67 void DebugVisitor::visit (const MatrixExp &e)
68 {
69     START_NODE(e);
70     print(L"Exec MatrixExp", e);
71     exps_t lines = e.getLines();
72     for (exps_t::const_iterator it = lines.begin(), itEnd = lines.end(); it != itEnd ; ++it)
73     {
74         (*it)->accept(*this);
75     }
76     END_NODE();
77 }
78
79 void DebugVisitor::visit (const MatrixLineExp &e)
80 {
81     START_NODE(e);
82     print(L"Exec MatrixLineExp", e);
83     exps_t columns = e.getColumns();
84     for (exps_t::const_iterator it = columns.begin(), itEnd = columns.end(); it != itEnd ; ++it)
85     {
86         (*it)->accept(*this);
87     }
88     END_NODE();
89 }
90
91 void DebugVisitor::visit (const CellExp &e)
92 {
93     START_NODE(e);
94     print(L"Exec CellExp", e);
95     exps_t lines = e.getLines();
96     for (exps_t::const_iterator it = lines.begin(), itEnd = lines.end(); it != itEnd ; ++it)
97     {
98         (*it)->accept(*this);
99     }
100     END_NODE();
101 }
102
103 void DebugVisitor::visit (const StringExp &e)
104 {
105     START_NODE(e);
106     std::wostringstream stream;
107     if (e.getConstant())
108     {
109         printInternalType<types::String>(stream, e.getConstant());
110     }
111     else
112     {
113         stream << e.getValue();
114     }
115     print(L"Exec StringExp : " + stream.str(), e);
116     END_NODE();
117 }
118
119 void DebugVisitor::visit (const CommentExp &e)
120 {
121     START_NODE(e);
122     print(L"Exec CommentExp : " + e.getComment(), e);
123     END_NODE();
124 }
125
126 void DebugVisitor::visit (const DoubleExp  &e)
127 {
128     START_NODE(e);
129     std::wostringstream stream;
130     types::InternalType * pIT = e.getConstant();
131     if (pIT)
132     {
133         if (pIT->isImplicitList())
134         {
135             types::ImplicitList * pIL = static_cast<types::ImplicitList *>(pIT);
136             stream << static_cast<types::Double *>(pIL->getStart())->get(0) << L":"
137                    << static_cast<types::Double *>(pIL->getStep())->get(0) << L":"
138                    << static_cast<types::Double *>(pIL->getEnd())->get(0);
139         }
140         else
141         {
142             printInternalType<types::Double>(stream, pIT);
143         }
144     }
145     else
146     {
147         stream << e.getValue();
148     }
149     print(L"Exec DoubleExp : " + stream.str(), e);
150     END_NODE();
151 }
152
153 void DebugVisitor::visit (const BoolExp  &e)
154 {
155     START_NODE(e);
156     std::wostringstream stream;
157     if (e.getConstant())
158     {
159         printInternalType<types::Bool>(stream, e.getConstant());
160     }
161     else
162     {
163         stream << e.getValue();
164     }
165     print(L"Exec BoolExp : " + stream.str(), e);
166     END_NODE();
167 }
168
169 void DebugVisitor::visit (const NilExp &e)
170 {
171     START_NODE(e);
172     print(L"Exec NilExp", e);
173     END_NODE();
174 }
175
176 void DebugVisitor::visit (const SimpleVar &e)
177 {
178     std::wstring ty;
179     analysis::TIType type = e.getDecorator().getResult().getType();
180     if (type.type != analysis::TIType::UNKNOWN)
181     {
182         if (type.isscalar())
183         {
184             ty = L" (" + analysis::TIType::toString(type.type) + L")";
185         }
186         else
187         {
188             ty = L" (" + analysis::TIType::toString(type.type) + L"*)";
189         }
190     }
191
192     START_NODE(e);
193     print(L"Exec SimpleVar : " + e.getSymbol().getName() + ty, e);
194     END_NODE();
195 }
196
197 void DebugVisitor::visit (const ColonVar &e)
198 {
199     START_NODE(e);
200     print(L"Exec ColonVar", e);
201     END_NODE();
202 }
203
204 void DebugVisitor::visit (const DollarVar &e)
205 {
206     START_NODE(e);
207     print(L"Exec DollarVar", e);
208     END_NODE();
209 }
210
211 void DebugVisitor::visit (const ArrayListVar &e)
212 {
213     START_NODE(e);
214     print(L"Exec ArrayListVar", e);
215     exps_t vars = e.getVars();
216     for (exps_t::const_iterator it = vars.begin (), itEnd = vars.end(); it != itEnd; ++it)
217     {
218         (*it)->accept(*this);
219     }
220     END_NODE();
221 }
222
223 void DebugVisitor::visit (const FieldExp &e)
224 {
225     START_NODE(e);
226     print(L"Exec FieldExp", e);
227     e.getHead()->accept(*this);
228     e.getTail()->accept(*this);
229     END_NODE();
230 }
231
232 void DebugVisitor::visit(const OpExp &e)
233 {
234     START_NODE(e);
235     print(L"Exec OpExp", e);
236     e.getLeft().accept(*this);
237     e.getRight().accept(*this);
238     END_NODE();
239 }
240
241 void DebugVisitor::visit(const LogicalOpExp &e)
242 {
243     START_NODE(e);
244     print(L"Exec LogicalOpExp", e);
245     e.getLeft().accept(*this);
246     e.getRight().accept(*this);
247     END_NODE();
248 }
249
250 void DebugVisitor::visit (const AssignExp  &e)
251 {
252     START_NODE(e);
253     print(L"Exec AssignExp", e);
254     e.getLeftExp().accept(*this);
255     e.getRightExp().accept(*this);
256     END_NODE();
257 }
258
259 void DebugVisitor::visit(const CellCallExp &e)
260 {
261     START_NODE(e);
262     print(L"Exec CellCallExp", e);
263     e.getName().accept(*this);
264
265     exps_t args = e.getArgs();
266     for (auto arg : args)
267     {
268         arg->accept(*this);
269     }
270
271     END_NODE();
272 }
273
274 void DebugVisitor::visit(const CallExp &e)
275 {
276     std::wstring str;
277
278     START_NODE(e);
279     print(L"Exec CallExp" + str, e);
280     e.getName().accept(*this);
281
282     exps_t args = e.getArgs();
283     for (auto arg : args)
284     {
285         arg->accept(*this);
286     }
287
288     END_NODE();
289 }
290
291 void DebugVisitor::visit (const IfExp  &e)
292 {
293     START_NODE(e);
294     print(L"Exec IfExp", e);
295     e.getTest ().accept(*this);
296     e.getThen ().accept(*this);
297     if (e.hasElse())
298     {
299         e.getElse ().accept(*this);
300     }
301     END_NODE();
302 }
303
304 void DebugVisitor::visit (const TryCatchExp  &e)
305 {
306     START_NODE(e);
307     print(L"Exec TryCatchExp", e);
308     e.getTry ().accept(*this);
309     e.getCatch ().accept(*this);
310     END_NODE();
311 }
312
313 void DebugVisitor::visit (const WhileExp  &e)
314 {
315     START_NODE(e);
316     print(L"Exec WhileExp", e);
317     e.getTest().accept(*this);
318     e.getBody().accept(*this);
319     END_NODE();
320 }
321
322 void DebugVisitor::visit (const ForExp  &e)
323 {
324     START_NODE(e);
325     print(L"Exec ForExp", e);
326     e.getVardec().accept(*this);
327     e.getBody().accept(*this);
328     END_NODE();
329 }
330
331 void DebugVisitor::visit (const ContinueExp &e)
332 {
333     START_NODE(e);
334     print(L"Exec ContinueExp", e);
335     END_NODE();
336 }
337
338 void DebugVisitor::visit (const BreakExp &e)
339 {
340     START_NODE(e);
341     print(L"Exec BreakExp", e);
342     END_NODE();
343 }
344
345 void DebugVisitor::visit (const ReturnExp &e)
346 {
347     START_NODE(e);
348     print(L"Exec ReturnExp", e);
349     if (!e.isGlobal())
350     {
351         e.getExp().accept(*this);
352     }
353     END_NODE();
354 }
355
356 void DebugVisitor::visit (const SelectExp &e)
357 {
358     START_NODE(e);
359     print(L"Exec SelectExp", e);
360     e.getSelect()->accept(*this);
361
362     exps_t cases = e.getCases();
363     for (auto exp : cases)
364     {
365         exp->accept(*this);
366     }
367
368     if (e.getDefaultCase() != NULL)
369     {
370         e.getDefaultCase()->accept(*this);
371     }
372     END_NODE();
373 }
374
375 void DebugVisitor::visit (const CaseExp &e)
376 {
377     START_NODE(e);
378     print(L"Exec CaseExp", e);
379     e.getTest()->accept(*this);
380     e.getBody()->accept(*this);
381     END_NODE();
382 }
383
384 void DebugVisitor::visit (const SeqExp  &e)
385 {
386     START_NODE(e);
387     print(L"Exec SeqExp", e);
388     for (exps_t::const_iterator it = e.getExps().begin (), itEnd = e.getExps().end(); it != itEnd; ++it)
389     {
390         (*it)->accept(*this);
391     }
392     END_NODE();
393 }
394
395 void DebugVisitor::visit (const ArrayListExp  &e)
396 {
397     START_NODE(e);
398     print(L"Exec ArrayListExp", e);
399     for (exps_t::const_iterator it = e.getExps().begin (), itEnd = e.getExps().end(); it != itEnd; ++it)
400     {
401         (*it)->accept(*this);
402     }
403     END_NODE();
404 }
405
406 void DebugVisitor::visit (const AssignListExp  &e)
407 {
408     START_NODE(e);
409     print(L"Exec AssignListExp", e);
410     for (exps_t::const_iterator it = e.getExps().begin (), itEnd = e.getExps().end(); it != itEnd; ++it)
411     {
412         (*it)->accept(*this);
413     }
414     END_NODE();
415 }
416
417 void DebugVisitor::visit (const NotExp &e)
418 {
419     START_NODE(e);
420     print(L"Exec NotExp", e);
421     e.getExp().accept(*this);
422     END_NODE();
423 }
424
425 void DebugVisitor::visit (const TransposeExp &e)
426 {
427     START_NODE(e);
428     print(L"Exec TransposeExp", e);
429     e.getExp().accept(*this);
430     END_NODE();
431 }
432
433 void DebugVisitor::visit (const VarDec  &e)
434 {
435     START_NODE(e);
436     print(L"Exec VarDec", e);
437     START_NODE(e);
438     print(L"Exec Symbol : " + e.getSymbol().getName(), e);
439     END_NODE();
440     e.getInit().accept(*this);
441     END_NODE();
442 }
443
444 void DebugVisitor::visit (const FunctionDec  &e)
445 {
446     START_NODE(e);
447     print(L"Exec FunctionDec", e);
448     // FIXME
449
450     // First ask if there are some return values.
451     //visit(e.returns_get());
452
453     // Then get the function name
454     //visit(e.getName());
455
456     // Then get function args
457     //visit(e.args_get());
458
459     // Now debug function body
460     e.getBody().accept(*this);
461
462     END_NODE();
463 }
464
465 void DebugVisitor::visit(const ListExp &e)
466 {
467     START_NODE(e);
468     print(L"Exec ListExp", e);
469     e.getStart().accept(*this);
470     e.getStep().accept(*this);
471     e.getEnd().accept(*this);
472     END_NODE();
473 }
474
475 void DebugVisitor::visit(const OptimizedExp &e)
476 {
477     e.getOriginal()->accept(*this);
478 }
479
480 void DebugVisitor::visit(const MemfillExp &e)
481 {
482     START_NODE(e);
483     print(L"Exec MemfillExp", e);
484     e.getValue().accept(*this);
485
486     exps_t args = e.getArgs();
487     for (auto arg : args)
488     {
489         arg->accept(*this);
490     }
491
492     END_NODE();
493 }
494
495 void DebugVisitor::visit(const DAXPYExp &e)
496 {
497     START_NODE(e);
498     print(L"Exec DAXPYExp", e);
499     e.getA().accept(*this);
500     e.getX().accept(*this);
501     e.getY().accept(*this);
502     END_NODE();
503
504     //e.getOriginal()->accept(*this);
505 }
506
507 void DebugVisitor::visit(const IntSelectExp & e)
508 {
509     e.getOriginal()->accept(*this);
510 }
511
512 void DebugVisitor::visit(const StringSelectExp & e)
513 {
514     e.getOriginal()->accept(*this);
515 }
516
517 }