JIT: Factorize the declaration and remove some comments
[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             std::cout << "coucou" << std::endl;
251             result_get()->dump();
252         }
253     }
254
255     llvm::Value* const llvm_value_one = llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(1.0));
256     llvm::Value* llvm_rec_power (llvm::Value* x, llvm::Value* n)
257     {
258         llvm::ConstantFP* ncfp = llvm::dyn_cast<llvm::ConstantFP>(n);
259
260         if (ncfp->isZero())
261         {
262             // return 1
263             return llvm_value_one;
264         }
265         if (ncfp->isNegative())
266         {
267             llvm::Value* moduloN = Builder->CreateFMul(llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(-1.0)), n);
268             // return 1 / (x * llvm_rec_power(x, (-1 * n)-1))
269             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");
270         }
271         else
272         {
273             // return x * llvm_rec_power(x, n-1)
274             return Builder->CreateFMul(x, llvm_rec_power(x, Builder->CreateFSub(n, llvm_value_one, "OpExp::minus")), "OpExp::times");
275         }
276     }
277     void visitprivate(const OpExp &e)
278     {
279         /*
280           switch (e.kind_get())
281           {
282           case OpExp::invalid_kind :
283           {
284           std::cout << "OpExp::invalid_kind" << std::endl;
285           break;
286           }
287           case OpExp::bool_kind :
288           {
289           std::cout << "OpExp::bool_kind" << std::endl;
290           break;
291           }
292           case OpExp::string_kind :
293           {
294           std::cout << "OpExp::string_kind" << std::endl;
295           break;
296           }
297           case OpExp::integer_kind :
298           {
299           std::cout << "OpExp::integer_kind" << std::endl;
300           break;
301           }
302           case OpExp::float_kind :
303           {
304           std::cout << "OpExp::float_kind" << std::endl;
305           break;
306           }
307           case OpExp::double_kind :
308           {
309           std::cout << "OpExp::double_kind" << std::endl;
310           break;
311           }
312           case OpExp::float_complex_kind :
313           {
314           break;
315           }
316           case OpExp::double_complex_kind :
317           {
318           break;
319           }
320           case OpExp::bool_matrix_kind :
321           {
322           break;
323           }
324           case OpExp::string_matrix_kind :
325           {
326           break;
327           }
328           case OpExp::integer_matrix_kind :
329           {
330           break;
331           }
332           case OpExp::float_matrix_kind :
333           {
334           break;
335           }
336           case OpExp::double_matrix_kind :
337           {
338           break;
339           }
340           case OpExp::float_complex_matrix_kind :
341           {
342           break;
343           }
344           case OpExp::double_complex_matrix_kind :
345           {
346           break;
347           }
348           case OpExp::matrix_kind :
349           {
350           break;
351           }
352           }
353         */
354
355         /*getting what to assign*/
356         e.left_get().accept(*this);
357         llvm::Value *pITL = result_get();
358
359         /*getting what to assign*/
360         e.right_get().accept(*this);
361         llvm::Value *pITR = result_get();
362
363         llvm::Value *pResult = NULL;
364
365         llvm::Value * tmp = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
366
367         switch (e.oper_get())
368         {
369             case OpExp::plus :
370             {
371
372                 Builder->CreateCall3(TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"), pITR, pITL, tmp);
373
374                 break;
375             }
376             case OpExp::minus :
377             {
378                 pResult = Builder->CreateFSub(pITL, pITR, "OpExp::minus");
379                 break;
380             }
381             case OpExp::times :
382             {
383
384                 Builder->CreateCall3(TheModule->getFunction("_Z22MultiplyDoubleByDoublePN5types6DoubleES1_PS1_"), pITR, pITL, tmp);
385
386                 break;
387             }
388             case OpExp::rdivide :
389             {
390                 pResult = Builder->CreateFDiv(pITL, pITR, "OpExp::rdivide");
391                 break;
392             }
393             case OpExp::ldivide :
394             {
395                 pResult = Builder->CreateFDiv(pITR, pITL, "OpExp::ldivide");
396                 break;
397             }
398             case OpExp::power :
399             {
400                 pResult = llvm_rec_power(pITL, pITR);
401                 break;
402             }
403             case OpExp::unaryMinus :
404             {
405                 pResult = Builder->CreateFSub(pITL, pITR, "OpExp::unaryMinus");
406                 break;
407             }
408             case OpExp::eq :
409             {
410                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUEQ(pITL, pITR, "OpExp::eq"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
411                 break;
412             }
413             case OpExp::ne :
414             {
415                 pResult = Builder->CreateUIToFP(Builder->CreateNot(Builder->CreateFCmpUEQ(pITL, pITR, "OpExp::eq"), "not"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
416                 break;
417             }
418             case OpExp::lt :
419             {
420                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpULT(pITL, pITR, "OpExp::lt"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
421                 break;
422             }
423             case OpExp::le :
424             {
425                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpULE(pITL, pITR, "OpExp::le"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
426                 break;
427             }
428             case OpExp::gt :
429             {
430                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUGT(pITL, pITR, "OpExp::gt"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
431                 break;
432             }
433             case OpExp::ge :
434             {
435                 pResult = Builder->CreateUIToFP(Builder->CreateFCmpUGE(pITL, pITR, "OpExp::ge"), llvm::Type::getDoubleTy(llvm::getGlobalContext()), "booltodouble");
436                 break;
437             }
438             default:
439             {
440                 std::cout << "Operation not supported, returning 42..." << std::endl;
441                 pResult = llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(42.0));
442                 break;
443             }
444         }
445         pResult = Builder->CreateLoad(tmp);
446
447         if (pResult == NULL)
448         {
449             result_set(llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(42.0)));
450         }
451         result_set(pResult);
452     }
453
454     void visitprivate (const AssignExp &e)
455     {
456         /*getting what to assign*/
457
458         const SimpleVar *pVar = dynamic_cast<const SimpleVar*>(&e.left_exp_get());
459         if (pVar)
460         {
461             // x = ?
462             /*getting what to assign*/
463             e.right_exp_get().accept(*this);
464
465             llvm::Value *pITR = result_get();
466             //reset result
467             result_set(NULL);
468
469             genLLVMPutSymbol(&pVar->name_get(), pITR);
470
471             //symbol::Context::getInstance()->put(pVar->name_get(), *pIT);
472             return;
473         }
474
475         llvm::Value *pResult = NULL;
476     }
477
478     void visitprivate (const SimpleVar &e)
479     {
480         if (e.is_verbose())
481         {
482             InternalType * pI = symbol::Context::getInstance()->get(e.name_get());
483             if (pI != NULL && pI->isCallable() == false && ConfigVariable::isPromptShow())
484             {
485                 std::wostringstream ostr;
486                 ostr << e.name_get().name_get() << L"  = " << L"(" << pI->getRef() << L")" << std::endl;
487                 ostr << std::endl;
488                 scilabWriteW(ostr.str().c_str());
489                 printScilabVar(pI);
490             }
491             else
492             {
493                 wchar_t szError[bsiz];
494                 os_swprintf(szError, bsiz, _W("Undefined variable: %ls\n"), e.name_get().name_get().c_str());
495                 throw ScilabError(szError, 999, e.location_get());
496                 //Err, SimpleVar doesn't exist in Scilab scopes.
497             }
498         }
499         else // JIT
500         {
501             //mod->getFunction("_ZNK6symbol7Context3getERKNS_6SymbolE")
502             llvm::Value * llvmScilabContext = llvm::ConstantInt::get(uintptrType, (uintptr_t)scilabContext);
503             llvmScilabContext = Builder->CreateIntToPtr(llvmScilabContext, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Context")));
504
505             llvm::Value * llvmSym = llvm::ConstantInt::get(uintptrType, (uintptr_t)&e.name_get());
506             llvmSym = Builder->CreateIntToPtr(llvmSym, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Symbol")));
507
508             llvm::Value * result = Builder->CreateCall2(TheModule->getFunction("_ZNK6symbol7Context3getERKNS_6SymbolE"), llvmScilabContext, llvmSym);
509             result_set(result);
510         }
511     }
512
513     void visitprivate(const ForExp &e)
514     {
515         e.vardec_get().accept(*this);
516         symbol::Symbol& varName = e.vardec_get().name_get();
517
518         llvm::BasicBlock * BBTest = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_test", TheFunction);
519         llvm::BasicBlock * BBBody = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_body", TheFunction);
520         llvm::BasicBlock * BBAfter = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_after", TheFunction);
521
522         llvm::Value* cur = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
523         llvm::Value* tmp = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Bool")));
524         llvm::Value* zero = llvm::ConstantInt::get(llvm::Type::getInt32Ty(*context), 0);
525
526         llvm::Value* start = _result;
527         llvm::Value* step = _result2;
528         llvm::Value* end = _result3;
529
530         Builder->CreateStore(start, cur);
531         Builder->CreateBr(BBTest);
532
533         Builder->SetInsertPoint(BBTest);
534         Builder->CreateCall3(TheModule->getFunction("_Z16DoubleLessDoublePN5types6DoubleES1_PPNS_4BoolE"), end, Builder->CreateLoad(cur), tmp);
535         tmp = Builder->CreateLoad(tmp);
536         tmp = Builder->CreateCall2(TheModule->getFunction("_ZN5types7ArrayOfIiE3getEi"), tmp, zero);
537         Builder->CreateCondBr(tmp, BBAfter, BBBody);
538
539
540         Builder->SetInsertPoint(BBBody);
541         genLLVMPutSymbol(&varName, Builder->CreateLoad(cur));
542         e.body_get().accept(*this);
543         Builder->CreateCall3(TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"), Builder->CreateLoad(cur), step, cur);
544         Builder->CreateBr(BBTest);
545
546         Builder->SetInsertPoint(BBAfter);
547     }
548
549     void visitprivate(const ListExp &e)
550     {
551         e.start_get().accept(*this);
552         llvm::Value * start = result_get();
553
554         e.step_get().accept(*this);
555         llvm::Value * step = result_get();
556
557         e.end_get().accept(*this);
558         llvm::Value * end = result_get();
559
560         _result = start;
561         _result2 = step;
562         _result3 = end;
563     }
564
565     void visitprivate(const VarDec &e)
566     {
567         e.init_get().accept(*this);
568     }
569
570     void visit (const BoolExp &e)
571     {
572         //            visitprivate(e);
573     }
574
575     void visit (const NilExp &e)
576     {
577         //            visitprivate(e);
578     }
579
580     void visit (const ColonVar &e)
581     {
582         //            visitprivate(e);
583     }
584
585     void visit (const DollarVar &e)
586     {
587         //            visitprivate(e);
588     }
589
590     void visit (const ArrayListVar &e)
591     {
592         //            visitprivate(e);
593     }
594
595     void visit (const FieldExp &e)
596     {
597         //            visitprivate(e);
598     }
599
600
601     void visit (const LogicalOpExp &e)
602     {
603         //            visitprivate(e);
604     }
605
606     void visit (const AssignExp &e)
607     {
608         visitprivate(e);
609     }
610
611     void visit (const CellCallExp &e)
612     {
613         //            visitprivate(e);
614     }
615
616     void visit (const CallExp &e)
617     {
618         //            visitprivate(e);
619     }
620
621     void visit (const IfExp &e)
622     {
623         //            visitprivate(e);
624     }
625
626     void visit (const TryCatchExp &e)
627     {
628         //            visitprivate(e);
629     }
630
631     void visit (const WhileExp &e)
632     {
633         //            visitprivate(e);
634     }
635
636     void visit (const ForExp &e)
637     {
638         visitprivate(e);
639     }
640
641     void visit (const BreakExp &e)
642     {
643         //            visitprivate(e);
644     }
645
646     void visit (const ContinueExp &e)
647     {
648         //            visitprivate(e);
649     }
650
651     void visit (const ReturnExp &e)
652     {
653         //            visitprivate(e);
654     }
655
656     void visit (const SelectExp &e)
657     {
658         //            visitprivate(e);
659     }
660
661     void visit (const CaseExp &e)
662     {
663         //            visitprivate(e);
664     }
665
666     void visit (const ArrayListExp &e)
667     {
668         //            visitprivate(e);
669     }
670
671     void visit (const AssignListExp &e)
672     {
673         //            visitprivate(e);
674     }
675
676     void visit (const NotExp &e)
677     {
678         //            visitprivate(e);
679     }
680
681     void visit (const TransposeExp &e)
682     {
683         //            visitprivate(e);
684     }
685
686     void visit (const VarDec &e)
687     {
688         visitprivate(e);
689     }
690
691     void visit (const FunctionDec &e)
692     {
693         //            visitprivate(e);
694     }
695
696     void visit(const ListExp &e)
697     {
698         visitprivate(e);
699     }
700     void visit (const MatrixExp &e)
701     {
702         //            visitprivate(e);
703     }
704
705     void visit (const MatrixLineExp &e)
706     {
707         //            visitprivate(e);
708     }
709
710     void visit (const CellExp &e)
711     {
712         //            visitprivate(e);
713     }
714
715     void visit (const StringExp &e)
716     {
717         //            visitprivate(e);
718     }
719
720     void visit (const CommentExp &e)
721     {
722         //            visitprivate(e);
723     }
724
725     void genLLVMInitialize()
726     {
727         llvm::FunctionType *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(*context), false);
728         TheFunction = llvm::Function::Create(FT, llvm::Function::ExternalLinkage, "TheFunction", TheModule);
729         llvm::BasicBlock *BB = llvm::BasicBlock::Create(llvm::getGlobalContext(), "entry", TheFunction);
730         Builder->SetInsertPoint(BB);
731     }
732
733     void genLLVMFinalize()
734     {
735         Builder->CreateRetVoid();
736         TheFunction->dump();
737     }
738
739     void compileAndExec()
740     {
741         void* res = ee->getPointerToFunction(TheFunction);
742         jitptr_t myJit = (jitptr_t) res;
743         myJit();
744     }
745
746     void genLLVMPutSymbol(const symbol::Symbol * s, llvm::Value * v)
747     {
748         llvm::Value * llvmScilabContext = llvm::ConstantInt::get(uintptrType, (uintptr_t)scilabContext);
749         llvmScilabContext = Builder->CreateIntToPtr(llvmScilabContext, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Context")));
750
751         llvm::Value * llvmSym = llvm::ConstantInt::get(uintptrType, (uintptr_t)s);
752         llvmSym = Builder->CreateIntToPtr(llvmSym, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Symbol")));
753         //llvmSym->dump();
754
755         Builder->CreateCall3(TheModule->getFunction("_ZN6symbol7Context3putERKNS_6SymbolERN5types12InternalTypeE"), llvmScilabContext, llvmSym, v);
756     }
757
758     static void printScilabVar(types::InternalType * pIT)
759     {
760         std::wostringstream ostr;
761
762         //to manage lines information
763         int iLines = ConfigVariable::getConsoleLines();
764
765         bool bFinish = false;
766         do
767         {
768             //block by block
769             bFinish = pIT->toString(ostr);
770             scilabWriteW(ostr.str().c_str());
771             if (bFinish == false && iLines != 0)
772             {
773                 //show message on prompt
774                 bFinish = linesmore() == 1;
775             }
776             ostr.str(L"");
777         }
778         while (bFinish == false);
779
780         pIT->clearPrintState();
781     }
782
783 };
784 }
785 #endif // !AST_JITVISITOR_HXX
786
787