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