23a1d659673f66c53e9ebedebc8c022cb977934e
[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         switch (e.oper_get())
365         {
366             case OpExp::plus :
367             {
368                 //%5 = call i32 @_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_(%"class.types::Double"* %3, %"class.types::Double"* %4, %"class.types::Double"** %pdbl1)
369                 //                      pResult = Builder->CreateFAdd(pITL, pITR, "OpExp::plus");
370
371                 llvm::Value * tmp = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
372
373                 Builder->CreateCall3(TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"), pITR, pITL, tmp);
374
375                 pResult = Builder->CreateLoad(tmp);
376                 break;
377             }
378             case OpExp::minus :
379             {
380                 pResult = Builder->CreateFSub(pITL, pITR, "OpExp::minus");
381                 break;
382             }
383             case OpExp::times :
384             {
385                 pResult = Builder->CreateFMul(pITL, pITR, "OpExp::times");
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
446         if (pResult == NULL)
447         {
448             result_set(llvm::ConstantFP::get(llvm::getGlobalContext(), llvm::APFloat(42.0)));
449         }
450         result_set(pResult);
451     }
452
453     void visitprivate (const AssignExp &e)
454     {
455         /*getting what to assign*/
456
457         const SimpleVar *pVar = dynamic_cast<const SimpleVar*>(&e.left_exp_get());
458         if (pVar)
459         {
460             // x = ?
461             /*getting what to assign*/
462             e.right_exp_get().accept(*this);
463
464             llvm::Value *pITR = result_get();
465             //reset result
466             result_set(NULL);
467
468             genLLVMPutSymbol(&pVar->name_get(), pITR);
469
470             //symbol::Context::getInstance()->put(pVar->name_get(), *pIT);
471             return;
472         }
473
474         llvm::Value *pResult = NULL;
475     }
476
477     void visitprivate (const SimpleVar &e)
478     {
479         if (e.is_verbose())
480         {
481             InternalType * pI = symbol::Context::getInstance()->get(e.name_get());
482             if (pI != NULL && pI->isCallable() == false && ConfigVariable::isPromptShow())
483             {
484                 std::wostringstream ostr;
485                 ostr << e.name_get().name_get() << L"  = " << L"(" << pI->getRef() << L")" << std::endl;
486                 ostr << std::endl;
487                 scilabWriteW(ostr.str().c_str());
488                 printScilabVar(pI);
489             }
490             else
491             {
492                 wchar_t szError[bsiz];
493                 os_swprintf(szError, bsiz, _W("Undefined variable: %ls\n"), e.name_get().name_get().c_str());
494                 throw ScilabError(szError, 999, e.location_get());
495                 //Err, SimpleVar doesn't exist in Scilab scopes.
496             }
497         }
498         else // JIT
499         {
500             //mod->getFunction("_ZNK6symbol7Context3getERKNS_6SymbolE")
501             llvm::Value * llvmScilabContext = llvm::ConstantInt::get(uintptrType, (uintptr_t)scilabContext);
502             llvmScilabContext = Builder->CreateIntToPtr(llvmScilabContext, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Context")));
503
504             llvm::Value * llvmSym = llvm::ConstantInt::get(uintptrType, (uintptr_t)&e.name_get());
505             llvmSym = Builder->CreateIntToPtr(llvmSym, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Symbol")));
506
507             llvm::Value * result = Builder->CreateCall2(TheModule->getFunction("_ZNK6symbol7Context3getERKNS_6SymbolE"), llvmScilabContext, llvmSym);
508             result_set(result);
509         }
510     }
511
512     void visitprivate(const ForExp &e)
513     {
514         e.vardec_get().accept(*this);
515         symbol::Symbol& varName = e.vardec_get().name_get();
516
517         llvm::BasicBlock * BBTest = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_test", TheFunction);
518         llvm::BasicBlock * BBBody = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_body", TheFunction);
519         llvm::BasicBlock * BBAfter = llvm::BasicBlock::Create(llvm::getGlobalContext(), "for_after", TheFunction);
520
521         llvm::Value* cur = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Double")));
522         llvm::Value* tmp = Builder->CreateAlloca(llvm::PointerType::getUnqual(TheModule->getTypeByName("class.types::Bool")));
523         llvm::Value* zero = llvm::ConstantInt::get(llvm::Type::getInt32Ty(*context), 0);
524
525         llvm::Value* start = _result;
526         llvm::Value* step = _result2;
527         llvm::Value* end = _result3;
528
529         Builder->CreateStore(start, cur);
530         Builder->CreateBr(BBTest);
531
532         Builder->SetInsertPoint(BBTest);
533         Builder->CreateCall3(TheModule->getFunction("_Z16DoubleLessDoublePN5types6DoubleES1_PPNS_4BoolE"), end, Builder->CreateLoad(cur), tmp);
534         tmp = Builder->CreateLoad(tmp);
535         tmp = Builder->CreateCall2(TheModule->getFunction("_ZN5types7ArrayOfIiE3getEi"), tmp, zero);
536         Builder->CreateCondBr(tmp, BBAfter, BBBody);
537
538
539         Builder->SetInsertPoint(BBBody);
540         genLLVMPutSymbol(&varName, Builder->CreateLoad(cur));
541         e.body_get().accept(*this);
542         Builder->CreateCall3(TheModule->getFunction("_Z17AddDoubleToDoublePN5types6DoubleES1_PS1_"), Builder->CreateLoad(cur), step, cur);
543         Builder->CreateBr(BBTest);
544
545         Builder->SetInsertPoint(BBAfter);
546     }
547
548     void visitprivate(const ListExp &e)
549     {
550         e.start_get().accept(*this);
551         llvm::Value * start = result_get();
552
553         e.step_get().accept(*this);
554         llvm::Value * step = result_get();
555
556         e.end_get().accept(*this);
557         llvm::Value * end = result_get();
558
559         _result = start;
560         _result2 = step;
561         _result3 = end;
562     }
563
564     void visitprivate(const VarDec &e)
565     {
566         e.init_get().accept(*this);
567     }
568
569     void visit (const BoolExp &e)
570     {
571         //            visitprivate(e);
572     }
573
574     void visit (const NilExp &e)
575     {
576         //            visitprivate(e);
577     }
578
579     void visit (const ColonVar &e)
580     {
581         //            visitprivate(e);
582     }
583
584     void visit (const DollarVar &e)
585     {
586         //            visitprivate(e);
587     }
588
589     void visit (const ArrayListVar &e)
590     {
591         //            visitprivate(e);
592     }
593
594     void visit (const FieldExp &e)
595     {
596         //            visitprivate(e);
597     }
598
599
600     void visit (const LogicalOpExp &e)
601     {
602         //            visitprivate(e);
603     }
604
605     void visit (const AssignExp &e)
606     {
607         visitprivate(e);
608     }
609
610     void visit (const CellCallExp &e)
611     {
612         //            visitprivate(e);
613     }
614
615     void visit (const CallExp &e)
616     {
617         //            visitprivate(e);
618     }
619
620     void visit (const IfExp &e)
621     {
622         //            visitprivate(e);
623     }
624
625     void visit (const TryCatchExp &e)
626     {
627         //            visitprivate(e);
628     }
629
630     void visit (const WhileExp &e)
631     {
632         //            visitprivate(e);
633     }
634
635     void visit (const ForExp &e)
636     {
637         visitprivate(e);
638     }
639
640     void visit (const BreakExp &e)
641     {
642         //            visitprivate(e);
643     }
644
645     void visit (const ContinueExp &e)
646     {
647         //            visitprivate(e);
648     }
649
650     void visit (const ReturnExp &e)
651     {
652         //            visitprivate(e);
653     }
654
655     void visit (const SelectExp &e)
656     {
657         //            visitprivate(e);
658     }
659
660     void visit (const CaseExp &e)
661     {
662         //            visitprivate(e);
663     }
664
665     void visit (const ArrayListExp &e)
666     {
667         //            visitprivate(e);
668     }
669
670     void visit (const AssignListExp &e)
671     {
672         //            visitprivate(e);
673     }
674
675     void visit (const NotExp &e)
676     {
677         //            visitprivate(e);
678     }
679
680     void visit (const TransposeExp &e)
681     {
682         //            visitprivate(e);
683     }
684
685     void visit (const VarDec &e)
686     {
687         visitprivate(e);
688     }
689
690     void visit (const FunctionDec &e)
691     {
692         //            visitprivate(e);
693     }
694
695     void visit(const ListExp &e)
696     {
697         visitprivate(e);
698     }
699     void visit (const MatrixExp &e)
700     {
701         //            visitprivate(e);
702     }
703
704     void visit (const MatrixLineExp &e)
705     {
706         //            visitprivate(e);
707     }
708
709     void visit (const CellExp &e)
710     {
711         //            visitprivate(e);
712     }
713
714     void visit (const StringExp &e)
715     {
716         //            visitprivate(e);
717     }
718
719     void visit (const CommentExp &e)
720     {
721         //            visitprivate(e);
722     }
723
724     void genLLVMInitialize()
725     {
726         llvm::FunctionType *FT = llvm::FunctionType::get(llvm::Type::getVoidTy(*context), false);
727         TheFunction = llvm::Function::Create(FT, llvm::Function::ExternalLinkage, "TheFunction", TheModule);
728         llvm::BasicBlock *BB = llvm::BasicBlock::Create(llvm::getGlobalContext(), "entry", TheFunction);
729         Builder->SetInsertPoint(BB);
730     }
731
732     void genLLVMFinalize()
733     {
734         Builder->CreateRetVoid();
735         TheFunction->dump();
736     }
737
738     void compileAndExec()
739     {
740         void* res = ee->getPointerToFunction(TheFunction);
741         jitptr_t myJit = (jitptr_t) res;
742         myJit();
743     }
744
745     void genLLVMPutSymbol(const symbol::Symbol * s, llvm::Value * v)
746     {
747         llvm::Value * llvmScilabContext = llvm::ConstantInt::get(uintptrType, (uintptr_t)scilabContext);
748         llvmScilabContext = Builder->CreateIntToPtr(llvmScilabContext, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Context")));
749
750         llvm::Value * llvmSym = llvm::ConstantInt::get(uintptrType, (uintptr_t)s);
751         llvmSym = Builder->CreateIntToPtr(llvmSym, llvm::PointerType::getUnqual(TheModule->getTypeByName("class.symbol::Symbol")));
752         //llvmSym->dump();
753
754         Builder->CreateCall3(TheModule->getFunction("_ZN6symbol7Context3putERKNS_6SymbolERN5types12InternalTypeE"), llvmScilabContext, llvmSym, v);
755     }
756
757     static void printScilabVar(types::InternalType * pIT)
758     {
759         std::wostringstream ostr;
760
761         //to manage lines information
762         int iLines = ConfigVariable::getConsoleLines();
763
764         bool bFinish = false;
765         do
766         {
767             //block by block
768             bFinish = pIT->toString(ostr);
769             scilabWriteW(ostr.str().c_str());
770             if (bFinish == false && iLines != 0)
771             {
772                 //show message on prompt
773                 bFinish = linesmore() == 1;
774             }
775             ostr.str(L"");
776         }
777         while (bFinish == false);
778
779         pIT->clearPrintState();
780     }
781
782 };
783 }
784 #endif // !AST_JITVISITOR_HXX
785
786