JIT: remove debug message
[scilab.git] / scilab / modules / jit / includes / JITvisitor.hxx
1 /*
2  *  Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  *  Copyright (C) 2013 - Harris Bakiras <harris.bakiras@lip6.fr>,
4  *  Peter Senna Tschudin <peter.senna@lip6.fr>
5  *
6  *  This file must be used under the terms of the CeCILL.
7  *  This source file is licensed as described in the file COPYING, which
8  *  you should have received as part of this distribution.  The terms
9  *  are also available at
10  *  http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
11  *
12  */
13
14 #ifndef AST_JITVISITOR_HXX
15 #define AST_JITVISITOR_HXX
16
17 #include <time.h>
18 #include <string>
19 #include <iostream>
20 #include <sstream>
21 #include <cstdio>
22 #include <iostream>
23
24 #include "visitor_common.hxx"
25 #include "shortcutvisitor.hxx"
26 #include "printvisitor.hxx"
27 #include "mutevisitor.hxx"
28
29 // Needed by visitprivate(const OpExp &)
30 // Needed by visitprivate(const LogicalOpExp &)
31 #include "generic_operations.hxx"
32 #include "types_or_and.hxx"
33 #include "configvariable.hxx"
34 #include "overload.hxx"
35 #include "scilabexception.hxx"
36
37 //#include "matrix_transpose_int.hxx"
38
39 extern "C" {
40 #include "doublecomplex.h"
41 #include "matrix_transpose.h"
42 #include "os_swprintf.h"
43 #include "more.h"
44 #include "sciprint.h"
45     //#include "HandleManagement.h"
46 }
47
48 #include "timer.hxx"
49 #include "localization.h"
50
51 #include "scilabWrite.hxx"
52 #include "context.hxx"
53
54 #include "all.hxx"
55 #include "types.hxx"
56 #include "alltypes.hxx"
57
58 #undef ID
59 #undef LT
60 #undef GT
61
62 #include "llvm/IR/Constants.h"
63 #include "llvm/IR/DerivedTypes.h"
64 #include "llvm/IR/IRBuilder.h"
65 #include "llvm/IR/LLVMContext.h"
66 #include "llvm/IR/Module.h"
67 #include "llvm/IR/Type.h"
68
69 #include "llvm/Analysis/Verifier.h"
70 #include "llvm/Support/TargetSelect.h"
71 #include "llvm/ExecutionEngine/ExecutionEngine.h"
72 #include "llvm/ExecutionEngine/JIT.h"
73 #include "llvm/PassManager.h"
74 #include "llvm/IR/DataLayout.h"
75 #include "vmkit_core.h"
76
77 #undef WHITE
78 #undef Max
79
80 #include <sys/types.h>
81
82 #include "llvm/IR/Attributes.h"
83 #include "llvm/IR/Function.h"
84 #include "llvm/IR/Instructions.h"
85 #include "llvm/CodeGen/GCStrategy.h"
86 #include "llvm/CodeGen/JITCodeEmitter.h"
87 #include "llvm/CodeGen/MachineFunction.h"
88 #include "llvm/ExecutionEngine/ExecutionEngine.h"
89 #include "llvm/Support/CommandLine.h"
90 #include "llvm/Support/ManagedStatic.h"
91 //#include "llvm/Support/Debug.h"
92 //#include "llvm/Support/raw_ostream.h"
93 #include <llvm/LinkAllPasses.h>
94
95 namespace llvm
96 {
97 #include "../src/cpp/llvm-wrapper-generated.cpp"
98 }
99
100 namespace ast
101 {
102 typedef double (*jitptr_t) ();
103
104 class JITVisitor : public ConstVisitor
105 {
106 private:
107     /*
108      * Attributes
109      */
110     llvm::Value* _result;
111     bool m_bSingleResult;
112     llvm::LLVMContext *context;
113     llvm::Module *TheModule;
114     llvm::IRBuilder<> *Builder;
115     llvm::ExecutionEngine* ee;
116     llvm::FunctionPassManager* pm;
117     llvm::Type* uintptrType;
118     symbol::Context * scilabContext;
119     llvm::Function * TheFunction;
120
121     // utilisees par step, end ds la visit de ListExp
122     llvm::Value * _result2;
123     llvm::Value * _result3;
124
125     void visit (const SeqExp  &e)
126     {
127         visitprivate(e);
128     }
129
130     void visit (const IntExp &e)
131     {
132         visitprivate(e);
133     }
134
135     void visit (const FloatExp &e)
136     {
137         visitprivate(e);
138     }
139
140     void visit (const DoubleExp &e)
141     {
142         visitprivate(e);
143     }
144
145     void visit (const OpExp &e)
146     {
147         visitprivate(e);
148     }
149
150     void visit (const SimpleVar &e)
151     {
152         visitprivate(e);
153     }
154
155
156 public:
157     JITVisitor() : ConstVisitor()
158     {
159         llvm::InitializeNativeTarget();
160         context = &llvm::getGlobalContext();
161         Builder = new llvm::IRBuilder<> (*context);
162         _result = NULL;
163         m_bSingleResult = false;
164         TheModule = new llvm::Module("scilab jit", *context);
165
166         std::string err;
167         llvm::EngineBuilder engine (TheModule);
168         llvm::TargetOptions options;
169         options.NoFramePointerElim = true;
170         engine.setTargetOptions(options);
171         engine.setEngineKind(llvm::EngineKind::JIT);
172         engine.setErrorStr(&err);
173
174         ee = engine.create();
175         if (!ee)
176         {
177             fprintf(stderr, "Could not create ExecutionEngine: %s\n", err.c_str());
178             exit(1);
179         }
180         ee->DisableLazyCompilation(0);
181         ee->addModule(TheModule);
182         TheModule->setDataLayout(ee->getDataLayout()->getStringRepresentation());
183         pm = NULL; /* TODO : init */
184
185         uintptrType = TheModule->getPointerSize() == llvm::Module::Pointer32 ?
186                       llvm::Type::getInt32Ty(*context) : llvm::Type::getInt64Ty(*context);
187
188         TheModule = llvm::makeLLVMModuleContents(TheModule);
189         //TheModule->dump();
190
191         for (llvm::Module::iterator cur = TheModule->begin(), end = TheModule->end(); cur != end; cur++)
192         {
193             void* ptr = dlsym(RTLD_DEFAULT, cur->getName().data());
194             //printf("%s ---> %p\n", cur->getName().data(), ptr);
195             if (ptr)
196             {
197                 ee->updateGlobalMapping(cur, ptr);
198             }
199         }
200
201         scilabContext = symbol::Context::getInstance();
202     }
203
204     void result_set(llvm::Value* const gtVal)
205     {
206         m_bSingleResult = true;
207         _result = gtVal;
208     }
209
210     llvm::Value* result_get()
211     {
212         return  _result;
213     }
214
215     void visitprivate(const DoubleExp &e)
216     {
217         if (e.getBigDouble() == NULL)
218         {
219             Double *pdbl = new Double(e.value_get());
220             (const_cast<DoubleExp *>(&e))->setBigDouble(pdbl);
221         }
222
223         //              llvm::Value* res = llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(e.getBigDouble()));
224         llvm::Value* res = llvm::ConstantInt::get(uintptrType, (uintptr_t)e.getBigDouble());
225         res = Builder->CreateIntToPtr(res, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
226
227         result_set(res);
228     }
229
230     void visitprivate(const FloatExp &e)
231     {
232     }
233
234     void visitprivate(const IntExp &e)
235     {
236     }
237
238     void visitprivate(const SeqExp &e)
239     {
240
241         //T execMe;
242         std::list<Exp *>::const_iterator    itExp;
243
244         for (itExp = e.exps_get().begin (); itExp != e.exps_get().end (); ++itExp)
245         {
246             //reset default values
247             result_set(NULL);
248
249             (*itExp)->accept(*this);
250             result_get()->dump();
251         }
252     }
253
254     llvm::Value* const llvm_value_one = llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(1.0));
255     llvm::Value* llvm_rec_power (llvm::Value* x, llvm::Value* n)
256     {
257         llvm::ConstantFP* ncfp = llvm::dyn_cast<llvm::ConstantFP>(n);
258
259         if (ncfp->isZero())
260         {
261             // return 1
262             return llvm_value_one;
263         }
264         if (ncfp->isNegative())
265         {
266             llvm::Value* moduloN = Builder->CreateFMul(llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(-1.0)), n);
267             // return 1 / (x * llvm_rec_power(x, (-1 * n)-1))
268             return Builder->CreateFDiv(llvm_value_one, Builder->CreateFMul(x, llvm_rec_power(x, Builder->CreateFSub(moduloN, llvm_value_one, "OpExp::minus")), "OpExp::times"), "OpExp::rdivide");
269         }
270         else
271         {
272             // return x * llvm_rec_power(x, n-1)
273             return Builder->CreateFMul(x, llvm_rec_power(x, Builder->CreateFSub(n, llvm_value_one, "OpExp::minus")), "OpExp::times");
274         }
275     }
276     void visitprivate(const OpExp &e)
277     {
278         /*
279           switch (e.kind_get())
280           {
281           case OpExp::invalid_kind :
282           {
283           std::cout << "OpExp::invalid_kind" << std::endl;
284           break;
285           }
286           case OpExp::bool_kind :
287           {
288           std::cout << "OpExp::bool_kind" << std::endl;
289           break;
290           }
291           case OpExp::string_kind :
292           {
293           std::cout << "OpExp::string_kind" << std::endl;
294           break;
295           }
296           case OpExp::integer_kind :
297           {
298           std::cout << "OpExp::integer_kind" << std::endl;
299           break;
300           }
301           case OpExp::float_kind :
302           {
303           std::cout << "OpExp::float_kind" << std::endl;
304           break;
305           }
306           case OpExp::double_kind :
307           {
308           std::cout << "OpExp::double_kind" << std::endl;
309           break;
310           }
311           case OpExp::float_complex_kind :
312           {
313           break;
314           }
315           case OpExp::double_complex_kind :
316           {
317           break;
318           }
319           case OpExp::bool_matrix_kind :
320           {
321           break;
322           }
323           case OpExp::string_matrix_kind :
324           {
325           break;
326           }
327           case OpExp::integer_matrix_kind :
328           {
329           break;
330           }
331           case OpExp::float_matrix_kind :
332           {
333           break;
334           }
335           case OpExp::double_matrix_kind :
336           {
337           break;
338           }
339           case OpExp::float_complex_matrix_kind :
340           {
341           break;
342           }
343           case OpExp::double_complex_matrix_kind :
344           {
345           break;
346           }
347           case OpExp::matrix_kind :
348           {
349           break;
350           }
351           }
352         */
353
354         /*getting what to assign*/
355         e.left_get().accept(*this);
356         llvm::Value *pITL = result_get();
357
358         /*getting what to assign*/
359         e.right_get().accept(*this);
360         llvm::Value *pITR = result_get();
361
362         llvm::Value *pResult = NULL;
363
364         llvm::Value * tmp = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
365
366         switch (e.oper_get())
367         {
368             case OpExp::plus :
369             {
370
371                 Builder->CreateCall3(TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"), pITR, pITL, tmp);
372
373                 break;
374             }
375             case OpExp::minus :
376             {
377
378                 Builder->CreateCall3(TheModule->getFunction("_Z23SubstractDoubleToDoublePN5types6DoubleES1_PS1_"), pITR, pITL, tmp);
379
380                 break;
381             }
382             case OpExp::times :
383             {
384
385                 Builder->CreateCall3(TheModule->getFunction("_Z22MultiplyDoubleByDoublePN5types6DoubleES1_PS1_"), pITR, pITL, tmp);
386
387                 break;
388             }
389             case OpExp::rdivide :
390             {
391                 pResult = Builder->CreateFDiv(pITL, pITR, "OpExp::rdivide");
392                 break;
393             }
394             case OpExp::ldivide :
395             {
396                 pResult = Builder->CreateFDiv(pITR, pITL, "OpExp::ldivide");
397                 break;
398             }
399             case OpExp::power :
400             {
401                 pResult = llvm_rec_power(pITL, pITR);
402                 break;
403             }
404             case OpExp::unaryMinus :
405             {
406                 pResult = Builder->CreateFSub(pITL, pITR, "OpExp::unaryMinus");
407                 break;
408             }
409             case OpExp::eq :
410             {
411                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUEQ(pITL, pITR, "OpExp::eq"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
412                 break;
413             }
414             case OpExp::ne :
415             {
416                 pResult = Builder->CreateUIToFP(Builder->CreateNot(Builder->CreateFCmpUEQ(pITL, pITR, "OpExp::eq"), "not"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
417                 break;
418             }
419             case OpExp::lt :
420             {
421                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpULT(pITL, pITR, "OpExp::lt"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
422                 break;
423             }
424             case OpExp::le :
425             {
426                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpULE(pITL, pITR, "OpExp::le"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
427                 break;
428             }
429             case OpExp::gt :
430             {
431                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUGT(pITL, pITR, "OpExp::gt"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
432                 break;
433             }
434             case OpExp::ge :
435             {
436                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUGE(pITL, pITR, "OpExp::ge"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
437                 break;
438             }
439             default:
440             {
441                 std::cout << "Operation not supported, returning 42..." << std::endl;
442                 pResult = llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(42.0));
443                 break;
444             }
445         }
446         pResult = Builder->CreateLoad(tmp);
447
448         if (pResult == NULL)
449         {
450             result_set(llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(42.0)));
451         }
452         result_set(pResult);
453     }
454
455     void visitprivate (const AssignExp &e)
456     {
457         /*getting what to assign*/
458
459         const SimpleVar *pVar = dynamic_cast<const SimpleVar*>(&e.left_exp_get());
460         if (pVar)
461         {
462             // x = ?
463             /*getting what to assign*/
464             e.right_exp_get().accept(*this);
465
466             llvm::Value *pITR = result_get();
467             //reset result
468             result_set(NULL);
469
470             genLLVMPutSymbol(&pVar->name_get(), pITR);
471
472             //symbol::Context::getInstance()->put(pVar->name_get(), *pIT);
473             return;
474         }
475
476         llvm::Value *pResult = NULL;
477     }
478
479     void visitprivate (const SimpleVar &e)
480     {
481         if (e.is_verbose())
482         {
483             InternalType * pI = symbol::Context::getInstance()->get(e.name_get());
484             if (pI != NULL && pI->isCallable() == false && ConfigVariable::isPromptShow())
485             {
486                 std::wostringstream ostr;
487                 ostr << e.name_get().name_get() << L"  = " << L"(" << pI->getRef() << L")" << std::endl;
488                 ostr << std::endl;
489                 scilabWriteW(ostr.str().c_str());
490                 printScilabVar(pI);
491             }
492             else
493             {
494                 wchar_t szError[bsiz];
495                 os_swprintf(szError, bsiz, _W("Undefined variable: %ls\n"), e.name_get().name_get().c_str());
496                 throw ScilabError(szError, 999, e.location_get());
497                 //Err, SimpleVar doesn't exist in Scilab scopes.
498             }
499         }
500         else // JIT
501         {
502             //mod->getFunction("_ZNK6symbol7Context3getERKNS_6SymbolE")
503             llvm::Value * llvmScilabContext = llvm::ConstantInt::get(uintptrType, (uintptr_t)scilabContext);
504             llvmScilabContext = Builder->CreateIntToPtr(llvmScilabContext, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Context")));
505
506             llvm::Value * llvmSym = llvm::ConstantInt::get(uintptrType, (uintptr_t)&e.name_get());
507             llvmSym = Builder->CreateIntToPtr(llvmSym, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Symbol")));
508
509             llvm::Value * result = Builder->CreateCall2(TheModule->getFunction("_ZNK6symbol7Context3getERKNS_6SymbolE"), llvmScilabContext, llvmSym);
510             result_set(result);
511         }
512     }
513
514     void visitprivate(const ForExp &e)
515     {
516         e.vardec_get().accept(*this);
517         symbol::Symbol& varName = e.vardec_get().name_get();
518
519         llvm::BasicBlock * BBTest = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_test", TheFunction);
520         llvm::BasicBlock * BBBody = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_body", TheFunction);
521         llvm::BasicBlock * BBAfter = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_after", TheFunction);
522
523         llvm::Value* cur = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
524         llvm::Value* tmp = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Bool")));
525         llvm::Value* zero = llvm::ConstantInt::get(llvm::Type::getInt32Ty(*context), 0);
526
527         llvm::Value* start = _result;
528         llvm::Value* step = _result2;
529         llvm::Value* end = _result3;
530
531         Builder->CreateStore(start, cur);
532         Builder->CreateBr(BBTest);
533
534         Builder->SetInsertPoint(BBTest);
535         Builder->CreateCall3(TheModule->getFunction("_Z16DoubleLessDoublePN5types6DoubleES1_PPNS_4BoolE"), end, Builder->CreateLoad(cur), tmp);
536         tmp = Builder->CreateLoad(tmp);
537         tmp = Builder->CreateCall2(TheModule->getFunction("_ZN5types7ArrayOfIiE3getEi"), tmp, zero);
538         Builder->CreateCondBr(tmp, BBAfter, BBBody);
539
540
541         Builder->SetInsertPoint(BBBody);
542         genLLVMPutSymbol(&varName, Builder->CreateLoad(cur));
543         e.body_get().accept(*this);
544         Builder->CreateCall3(TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"), Builder->CreateLoad(cur), step, cur);
545         Builder->CreateBr(BBTest);
546
547         Builder->SetInsertPoint(BBAfter);
548     }
549
550     void visitprivate(const ListExp &e)
551     {
552         e.start_get().accept(*this);
553         llvm::Value * start = result_get();
554
555         e.step_get().accept(*this);
556         llvm::Value * step = result_get();
557
558         e.end_get().accept(*this);
559         llvm::Value * end = result_get();
560
561         _result = start;
562         _result2 = step;
563         _result3 = end;
564     }
565
566     void visitprivate(const VarDec &e)
567     {
568         e.init_get().accept(*this);
569     }
570
571     void visit (const BoolExp &e)
572     {
573         //            visitprivate(e);
574     }
575
576     void visit (const NilExp &e)
577     {
578         //            visitprivate(e);
579     }
580
581     void visit (const ColonVar &e)
582     {
583         //            visitprivate(e);
584     }
585
586     void visit (const DollarVar &e)
587     {
588         //            visitprivate(e);
589     }
590
591     void visit (const ArrayListVar &e)
592     {
593         //            visitprivate(e);
594     }
595
596     void visit (const FieldExp &e)
597     {
598         //            visitprivate(e);
599     }
600
601
602     void visit (const LogicalOpExp &e)
603     {
604         //            visitprivate(e);
605     }
606
607     void visit (const AssignExp &e)
608     {
609         visitprivate(e);
610     }
611
612     void visit (const CellCallExp &e)
613     {
614         //            visitprivate(e);
615     }
616
617     void visit (const CallExp &e)
618     {
619         //            visitprivate(e);
620     }
621
622     void visit (const IfExp &e)
623     {
624         //            visitprivate(e);
625     }
626
627     void visit (const TryCatchExp &e)
628     {
629         //            visitprivate(e);
630     }
631
632     void visit (const WhileExp &e)
633     {
634         //            visitprivate(e);
635     }
636
637     void visit (const ForExp &e)
638     {
639         visitprivate(e);
640     }
641
642     void visit (const BreakExp &e)
643     {
644         //            visitprivate(e);
645     }
646
647     void visit (const ContinueExp &e)
648     {
649         //            visitprivate(e);
650     }
651
652     void visit (const ReturnExp &e)
653     {
654         //            visitprivate(e);
655     }
656
657     void visit (const SelectExp &e)
658     {
659         //            visitprivate(e);
660     }
661
662     void visit (const CaseExp &e)
663     {
664         //            visitprivate(e);
665     }
666
667     void visit (const ArrayListExp &e)
668     {
669         //            visitprivate(e);
670     }
671
672     void visit (const AssignListExp &e)
673     {
674         //            visitprivate(e);
675     }
676
677     void visit (const NotExp &e)
678     {
679         //            visitprivate(e);
680     }
681
682     void visit (const TransposeExp &e)
683     {
684         //            visitprivate(e);
685     }
686
687     void visit (const VarDec &e)
688     {
689         visitprivate(e);
690     }
691
692     void visit (const FunctionDec &e)
693     {
694         //            visitprivate(e);
695     }
696
697     void visit(const ListExp &e)
698     {
699         visitprivate(e);
700     }
701     void visit (const MatrixExp &e)
702     {
703         //            visitprivate(e);
704     }
705
706     void visit (const MatrixLineExp &e)
707     {
708         //            visitprivate(e);
709     }
710
711     void visit (const CellExp &e)
712     {
713         //            visitprivate(e);
714     }
715
716     void visit (const StringExp &e)
717     {
718         //            visitprivate(e);
719     }
720
721     void visit (const CommentExp &e)
722     {
723         //            visitprivate(e);
724     }
725
726     void genLLVMInitialize()
727     {
728         llvm::FunctionType *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(*context), false);
729         TheFunction = llvm::Function::Create(FT, llvm::Function::ExternalLinkage, "TheFunction", TheModule);
730         llvm::BasicBlock *BB = llvm::BasicBlock::Create(llvm::getGlobalContext(), "entry", TheFunction);
731         Builder->SetInsertPoint(BB);
732     }
733
734     void genLLVMFinalize()
735     {
736         Builder->CreateRetVoid();
737         TheFunction->dump();
738     }
739
740     void compileAndExec()
741     {
742         void* res = ee->getPointerToFunction(TheFunction);
743         jitptr_t myJit = (jitptr_t) res;
744         myJit();
745     }
746
747     void genLLVMPutSymbol(const symbol::Symbol * s, llvm::Value * v)
748     {
749         llvm::Value * llvmScilabContext = llvm::ConstantInt::get(uintptrType, (uintptr_t)scilabContext);
750         llvmScilabContext = Builder->CreateIntToPtr(llvmScilabContext, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Context")));
751
752         llvm::Value * llvmSym = llvm::ConstantInt::get(uintptrType, (uintptr_t)s);
753         llvmSym = Builder->CreateIntToPtr(llvmSym, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Symbol")));
754         //llvmSym->dump();
755
756         Builder->CreateCall3(TheModule->getFunction("_ZN6symbol7Context3putERKNS_6SymbolERN5types12InternalTypeE"), llvmScilabContext, llvmSym, v);
757     }
758
759     static void printScilabVar(types::InternalType * pIT)
760     {
761         std::wostringstream ostr;
762
763         //to manage lines information
764         int iLines = ConfigVariable::getConsoleLines();
765
766         bool bFinish = false;
767         do
768         {
769             //block by block
770             bFinish = pIT->toString(ostr);
771             scilabWriteW(ostr.str().c_str());
772             if (bFinish == false && iLines != 0)
773             {
774                 //show message on prompt
775                 bFinish = linesmore() == 1;
776             }
777             ostr.str(L"");
778         }
779         while (bFinish == false);
780
781         pIT->clearPrintState();
782     }
783
784 };
785 }
786 #endif // !AST_JITVISITOR_HXX
787
788