de22ce451a73e75755c2466af9d0f8dcc00ab035
[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 static void DEBUG_START_NODE(const ast::Ast& e)
21 {
22     wcerr << L"(" << e.getNodeNumber() << L") ";
23     ++level;
24 }
25
26 static void DEBUG_END_NODE(void)
27 {
28     --level;
29 }
30
31 static void DEBUG(wstring str)
32 {
33     for (int i = 0 ; i < level; ++i)
34     {
35         wcerr << L"  ";
36     }
37     if (level > 0)
38     {
39         wcerr << L"     ";
40     }
41     wcerr << str << endl;
42 }
43
44 static void DEBUG(wstring str, const Exp &e)
45 {
46     for (int i = 0 ; i < level; ++i)
47     {
48         wcerr << L"  ";
49     }
50     if (level > 0)
51     {
52         wcerr << L"|_./ ";
53     }
54     wcerr << str;
55
56     Location loc = e.getLocation();
57     wcerr << L" @(" << loc.first_line << L"." << loc.first_column << L" -> ";
58     wcerr << loc.last_line << L"." << loc.last_column << L")" << endl;
59 }
60
61
62 void DebugVisitor::visit (const MatrixExp &e)
63 {
64     DEBUG_START_NODE(e);
65     DEBUG(L"Exec MatrixExp", e);
66     list<MatrixLineExp *>::const_iterator       i;
67     for (i = e.getLines().begin() ; i != e.getLines().end() ; ++i )
68     {
69         (*i)->accept (*this);
70     }
71     DEBUG_END_NODE();
72 }
73
74 void DebugVisitor::visit (const MatrixLineExp &e)
75 {
76     DEBUG_START_NODE(e);
77     DEBUG(L"Exec MatrixLineExp", e);
78     list<Exp *>::const_iterator i;
79     for (i = e.getColumns().begin() ; i != e.getColumns().end() ; ++i)
80     {
81         (*i)->accept (*this);
82     }
83     DEBUG_END_NODE();
84 }
85 /** \} */
86
87 void DebugVisitor::visit (const CellExp &e)
88 {
89     DEBUG_START_NODE(e);
90     DEBUG(L"Exec CellExp", e);
91     list<MatrixLineExp *>::const_iterator       i;
92     for (i = e.getLines().begin() ; i != e.getLines().end() ; ++i )
93     {
94         (*i)->accept (*this);
95     }
96     DEBUG_END_NODE();
97 }
98
99 /** \} */
100
101 /** \name Visit Constant Expressions nodes.
102 ** \{ */
103 void DebugVisitor::visit (const StringExp &e)
104 {
105     DEBUG_START_NODE(e);
106     DEBUG(L"Exec StringExp : " + e.getValue(), e);
107     DEBUG_END_NODE();
108 }
109
110 void DebugVisitor::visit (const CommentExp &e)
111 {
112     DEBUG_START_NODE(e);
113     DEBUG(L"Exec CommentExp : " + e.getComment(), e);
114     DEBUG_END_NODE();
115 }
116
117 void DebugVisitor::visit (const DoubleExp  &e)
118 {
119     DEBUG_START_NODE(e);
120     wostringstream stream;
121     stream << e.getValue();
122     DEBUG(L"Exec DoubleExp : " + stream.str(), e);
123     DEBUG_END_NODE();
124 }
125
126 void DebugVisitor::visit (const BoolExp  &e)
127 {
128     DEBUG_START_NODE(e);
129     wostringstream stream;
130     stream << e.getValue();
131     DEBUG(L"Exec getv    : " + stream.str(), e);
132     DEBUG_END_NODE();
133 }
134
135 void DebugVisitor::visit (const NilExp &e)
136 {
137     DEBUG_START_NODE(e);
138     DEBUG(L"Exec NilExp", e);
139     DEBUG_END_NODE();
140 }
141 /** \} */
142
143 /** \name Visit Variable related nodes.
144 ** \{ */
145 void DebugVisitor::visit (const SimpleVar &e)
146 {
147     DEBUG_START_NODE(e);
148     DEBUG(L"Exec SimpleVar : " + e.getSymbol().getName(), e);
149     DEBUG_END_NODE();
150 }
151
152 void DebugVisitor::visit (const ColonVar &e)
153 {
154     DEBUG_START_NODE(e);
155     DEBUG(L"Exec ColonVar", e);
156     DEBUG_END_NODE();
157 }
158
159 void DebugVisitor::visit (const DollarVar &e)
160 {
161     DEBUG_START_NODE(e);
162     DEBUG(L"Exec DollarVar", e);
163     DEBUG_END_NODE();
164 }
165
166 void DebugVisitor::visit (const ArrayListVar &e)
167 {
168     DEBUG_START_NODE(e);
169     DEBUG(L"Exec ArrayListVar", e);
170     list<Var *>::const_iterator i;
171     for (i = e.getVars().begin() ; i != e.getVars().end() ; ++i)
172     {
173         (*i)->accept (*this);
174     }
175     DEBUG_END_NODE();
176 }
177 /** \} */
178
179 /** \name Visit Control Expressions or Instructions nodes.
180 ** \{ */
181
182 void DebugVisitor::visit (const FieldExp &e)
183 {
184     DEBUG_START_NODE(e);
185     DEBUG(L"Exec FieldExp", e);
186     // FIXME
187     {
188         e.getHead()->accept(*this);
189         e.getTail()->accept(*this);
190     }
191     DEBUG_END_NODE();
192 }
193
194 void DebugVisitor::visit(const OpExp &e)
195 {
196     DEBUG_START_NODE(e);
197     DEBUG(L"Exec OpExp", e);
198     // FIXME
199     {
200         e.getLeft().accept(*this);
201         //e.oper_get();
202         e.getRight().accept(*this);
203     }
204     DEBUG_END_NODE();
205 }
206
207 void DebugVisitor::visit(const LogicalOpExp &e)
208 {
209     DEBUG_START_NODE(e);
210     DEBUG(L"Exec LogicalOpExp", e);
211     // FIXME
212     {
213         e.getLeft().accept(*this);
214         //e.oper_get();
215         e.getRight().accept(*this);
216     }
217     DEBUG_END_NODE();
218 }
219
220 void DebugVisitor::visit (const AssignExp  &e)
221 {
222     DEBUG_START_NODE(e);
223     DEBUG(L"Exec AssignExp", e);
224     //FIXME
225     {
226         e.getLeftExp().accept (*this);
227         e.getRightExp().accept (*this);
228     }
229     DEBUG_END_NODE();
230 }
231
232 void DebugVisitor::visit(const CellCallExp &e)
233 {
234     DEBUG_START_NODE(e);
235     DEBUG(L"Exec CellCallExp", e);
236     e.getName().accept (*this);
237     // FIXME
238     {
239         list<Exp *>::const_iterator     i;
240
241         for (i = e.getArgs().begin (); i != e.getArgs().end (); ++i)
242         {
243             (*i)->accept (*this);
244         }
245     }
246     DEBUG_END_NODE();
247 }
248
249 void DebugVisitor::visit(const CallExp &e)
250 {
251     DEBUG_START_NODE(e);
252     DEBUG(L"Exec CallExp", e);
253     e.getName().accept (*this);
254     // FIXME
255     {
256         list<Exp *>::const_iterator     i;
257
258         for (i = e.getArgs().begin (); i != e.getArgs().end (); ++i)
259         {
260             (*i)->accept (*this);
261         }
262     }
263     DEBUG_END_NODE();
264 }
265
266 void DebugVisitor::visit (const IfExp  &e)
267 {
268     DEBUG_START_NODE(e);
269     DEBUG(L"Exec IfExp", e);
270     // FIXME
271     {
272         e.getTest ().accept(*this);
273         e.getThen ().accept(*this);
274         if (e.hasElse())
275         {
276             e.getElse ().accept(*this);
277         }
278     }
279     DEBUG_END_NODE();
280 }
281
282 void DebugVisitor::visit (const TryCatchExp  &e)
283 {
284     DEBUG_START_NODE(e);
285     DEBUG(L"Exec TryCatchExp", e);
286     // FIXME
287     {
288         e.getTry ().accept(*this);
289         e.getCatch ().accept(*this);
290     }
291     DEBUG_END_NODE();
292 }
293
294 void DebugVisitor::visit (const WhileExp  &e)
295 {
296     DEBUG_START_NODE(e);
297     DEBUG(L"Exec WhileExp", e);
298     // FIMXE
299     e.getTest().accept (*this);
300     e.getBody().accept (*this);
301     DEBUG_END_NODE();
302 }
303
304 void DebugVisitor::visit (const ForExp  &e)
305 {
306     DEBUG_START_NODE(e);
307     DEBUG(L"Exec ForExp", e);
308     e.getVardec().accept(*this);
309     e.getBody().accept (*this);
310     DEBUG_END_NODE();
311 }
312
313 void DebugVisitor::visit (const ContinueExp &e)
314 {
315     DEBUG_START_NODE(e);
316     DEBUG(L"Exec ContinueExp", e);
317     DEBUG_END_NODE();
318 }
319
320 void DebugVisitor::visit (const BreakExp &e)
321 {
322     DEBUG_START_NODE(e);
323     DEBUG(L"Exec BreakExp", e);
324     DEBUG_END_NODE();
325 }
326
327 void DebugVisitor::visit (const ReturnExp &e)
328 {
329     DEBUG_START_NODE(e);
330     DEBUG(L"Exec ReturnExp", e);
331     if (!e.isGlobal())
332     {
333         e.getExp().accept(*this);
334     }
335     DEBUG_END_NODE();
336 }
337
338 void DebugVisitor::visit (const SelectExp &e)
339 {
340     DEBUG_START_NODE(e);
341     DEBUG(L"Exec SelectExp", e);
342     e.getSelect()->accept(*this);
343     ast::cases_t::iterator it;
344     for (it = e.getCases()->begin() ; it !=  e.getCases()->end() ; ++it)
345     {
346         (*it)->accept(*this);
347     }
348     if (e.getDefaultCase() != NULL)
349     {
350         e.getDefaultCase()->accept(*this);
351     }
352     DEBUG_END_NODE();
353 }
354
355 void DebugVisitor::visit (const CaseExp &e)
356 {
357     DEBUG_START_NODE(e);
358     DEBUG(L"Exec CaseExp", e);
359     e.getTest()->accept(*this);
360     e.getBody()->accept(*this);
361     DEBUG_END_NODE();
362 }
363
364 void DebugVisitor::visit (const SeqExp  &e)
365 {
366     DEBUG_START_NODE(e);
367     DEBUG(L"Exec SeqExp", e);
368     list<Exp *>::const_iterator i;
369     for (i = e.getExps().begin (); i != e.getExps().end (); ++i)
370     {
371         if (!(*i)->isVerbose())
372         {
373             DEBUG(L"__MUTE__");
374         }
375         (*i)->accept (*this);
376     }
377     DEBUG_END_NODE();
378 }
379
380 void DebugVisitor::visit (const ArrayListExp  &e)
381 {
382     DEBUG_START_NODE(e);
383     DEBUG(L"Exec ArrayListExp", e);
384     list<Exp *>::const_iterator i;
385     for (i = e.getExps().begin (); i != e.getExps().end (); ++i)
386     {
387         (*i)->accept (*this);
388     }
389     DEBUG_END_NODE();
390 }
391
392 void DebugVisitor::visit (const AssignListExp  &e)
393 {
394     DEBUG_START_NODE(e);
395     DEBUG(L"Exec AssignListExp", e);
396     list<Exp *>::const_iterator i;
397     for (i = e.getExps().begin (); i != e.getExps().end (); ++i)
398     {
399         (*i)->accept (*this);
400     }
401     DEBUG_END_NODE();
402 }
403 /** \} */
404
405 /** \name Visit Single Operation nodes.
406 ** \{ */
407 void DebugVisitor::visit (const NotExp &e)
408 {
409     DEBUG_START_NODE(e);
410     DEBUG(L"Exec NotExp", e);
411     e.getExp().accept (*this);
412     DEBUG_END_NODE();
413 }
414
415 void DebugVisitor::visit (const TransposeExp &e)
416 {
417     DEBUG_START_NODE(e);
418     DEBUG(L"Exec TransposeExp", e);
419     e.getExp().accept (*this);
420     DEBUG_END_NODE();
421 }
422 /** \} */
423
424 /** \name Visit Declaration nodes.
425 ** \{ */
426 /** \brief Visit Var declarations. */
427 void DebugVisitor::visit (const VarDec  &e)
428 {
429     DEBUG_START_NODE(e);
430     DEBUG(L"Exec VarDec", e);
431     {
432         DEBUG_START_NODE(e);
433         DEBUG(L"Exec Symbol : " + e.getSymbol().getName(), e);
434         DEBUG_END_NODE();
435     }
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
462 /** \name Visit Type dedicated Expressions related node.
463 ** \{ */
464 void DebugVisitor::visit(const ListExp &e)
465 {
466     DEBUG_START_NODE(e);
467     DEBUG(L"Exec ListExp", e);
468     e.getStart().accept(*this);
469     e.getStep().accept(*this);
470     e.getEnd().accept(*this);
471     DEBUG_END_NODE();
472 }
473 /** \} */
474 }