f80c9aea363623ab3f60e5f8b36ab43b33e6143b
[scilab.git] / scilab / modules / core / src / cpp / InitScilab.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2013 - Scilab Enterprises - Antoine ELIAS
4  * Copyright (C) 2013 - Scilab Enterprises - Cedric DELAMARRE
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 #include <string>
15 #include <libxml/parser.h>
16
17 #include "inspector.hxx"
18 #include "double.hxx"
19 #include "polynom.hxx"
20 #include "string.hxx"
21 #include "bool.hxx"
22
23 #include "scilabWrite.hxx"
24 #include "tasks.hxx"
25 #include "parser.hxx"
26 #include "context.hxx"
27 #include "configvariable.hxx"
28 #include "filemanager.hxx"
29 #include "runner.hxx"
30 #include "visitor_common.hxx"
31 #include "operations.hxx"
32 #include "threadmanagement.hxx"
33
34 #include "expandPathVariable.h"
35
36 extern "C"
37 {
38 #include "machine.h"
39 #include "InitializeLocalization.h"
40 #include "elem_common.h"
41 #include "InitializeJVM.h"
42 #include "TerminateJVM.h"
43 #include "InitializeGUI.h"
44 #include "graphicModuleLoad.h"
45 #include "TerminateGraphics.h"
46 #include "loadBackGroundClassPath.h"
47 #include "sci_tmpdir.h"
48 #include "configvariable_interface.h"
49 #include "setgetlanguage.h"
50 #include "InitializeConsole.h"
51 #include "InitializeHistoryManager.h"
52 #include "TerminateHistoryManager.h"
53 #include "prompt.h"
54 #include "scilabRead.h"
55 #include "functions_manager.h"
56 #include "InitScilab.h"
57 #include "setenvvar.h"
58 #include "getScilabPreference.h"
59 #include "saveCWDInPreferences.h"
60 #include "h5_fileManagement.h"
61 #include "with_fftw.h"
62 #include "BrowseVarManager.h"
63 #include "scicurdir.h"
64 #include "FileBrowserChDir.h"
65
66
67 #ifdef _MSC_VER
68 #include "InitializeWindows_tools.h"
69 #include "TerminateWindows_tools.h"
70 #include "WndThread.h"
71 #include "console.h"
72 #include "InnosetupMutex.h"
73 #include "MutexClosingScilab.h"
74 #include "WinConsole.h"
75 #else
76 #include "signal_mgmt.h"
77 #include "initConsoleMode.h"
78 #endif
79
80 #if defined(linux) && defined(__i386__)
81 #include "setPrecisionFPU.h"
82 #endif
83
84 #include "storeCommand.h"
85
86     /* Defined without include to avoid useless header dependency */
87     extern BOOL isItTheDisabledLib(void);
88 }
89
90 static void Add_i(void);
91 static void Add_pi(void);
92 static void Add_eps(void);
93 static void Add_e(void);
94 static void Add_s(void);
95 static void Add_z(void);
96 static void Add_gui(void);
97 static void Add_fftw(void);
98 static void Add_Nan(void);
99 static void Add_Inf(void);
100 static void Add_io(void);
101 static void Add_All_Variables(void);
102 static void Add_Double_Constant(std::wstring _szName, double _dblReal, double _dblImg, bool _bComplex);
103 static void Add_Poly_Constant(std::wstring _szName, std::wstring _szPolyVar, int _iRank, types::Double * _pdblReal);
104 static void Add_Boolean_Constant(std::wstring _szName, bool _bBool);
105 static void Add_String_Constant(std::wstring _szName, const char *_pstString);
106 static void checkForLinkerErrors(void);
107
108 static int batchMain(ScilabEngineInfo* _pSEI);
109 static int InitializeEnvironnement(void);
110 static int interactiveMain(ScilabEngineInfo* _pSEI);
111 static void processCommand(ScilabEngineInfo* _pSEI);
112 static void stateShow(Parser::ControlStatus status);
113
114 using namespace ast;
115
116 ScilabEngineInfo* InitScilabEngineInfo()
117 {
118     // Disable all startup flags.
119     ScilabEngineInfo* pSEI = (ScilabEngineInfo*)CALLOC(1, sizeof(ScilabEngineInfo));
120
121     //Active default flags
122     pSEI->iExecAst = 1;
123     pSEI->iNoBanner = 1;
124
125     pSEI->iMultiLine = 0;
126     pSEI->isInterruptible = 1;      // by default all thread are interruptible
127     pSEI->isPrioritary = 0;         // by default all thread are non-prioritary
128     pSEI->iStartConsoleThread = 1;  // used in call_scilab to avoid "prompt" thread execution
129
130     return pSEI;
131 }
132
133 int StartScilabEngine(ScilabEngineInfo* _pSEI)
134 {
135     int iMainRet = 0;
136     ConfigVariable::setStartProcessing(true);
137     ConfigVariable::setForceQuit(false);
138
139     /* This bug only occurs under Linux 32 bits
140      * See: http://wiki.scilab.org/Scilab_precision
141      */
142 #if defined(linux) && defined(__i386__)
143     setFPUToDouble();
144 #endif
145
146 #ifndef _MSC_VER
147     /* Management of the signals (seg fault, floating point exception, etc) */
148     if (getenv("SCI_DISABLE_EXCEPTION_CATCHING") == NULL)
149     {
150         base_error_init();
151     }
152 #endif
153
154 #if defined(netbsd) || defined(freebsd)
155     /* floating point exceptions */
156     fpsetmask(0);
157 #endif
158
159     ThreadManagement::initialize();
160
161     checkForLinkerErrors();
162
163 #ifdef _MSC_VER
164     //get current console window and hide it
165     int scilabMode = getScilabMode();
166     if (scilabMode == SCILAB_STD || scilabMode == SCILAB_NW || scilabMode == SCILAB_API)
167     {
168         CreateScilabHiddenWndThread();
169     }
170
171     if (scilabMode == SCILAB_STD)
172     {
173         //show banner in console window
174         CreateScilabConsole(_pSEI->iNoBanner);
175
176         if (_pSEI->iKeepConsole == 0)
177         {
178             HideScilex(); /* hide console window */
179         }
180         else
181         {
182             ShowScilex();
183         }
184     }
185     else
186     {
187         if (scilabMode == SCILAB_NW || scilabMode == SCILAB_NWNI)
188         {
189             SaveConsoleColors();
190             if (scilabMode == SCILAB_NW)
191             {
192                 RenameConsole();
193                 UpdateConsoleColors();
194             }
195         }
196     }
197
198     //create a thread for innosetup to allow reinstall during scilab running
199     createInnosetupMutex();
200 #endif
201
202     //open scope lvl 0 for gateway from modules and first variables ( SCI, HOME, TMPDIR, ...)
203     symbol::Context::getInstance()->scope_begin();
204
205     /* Scilab Startup */
206     xmlInitParser();
207     InitializeEnvironnement();
208
209     if (_pSEI->pstLang)
210     {
211         wchar_t *pwstLang = to_wide_string(_pSEI->pstLang);
212         setlanguage(pwstLang);
213         FREE(pwstLang);
214     }
215
216 #ifdef _MSC_VER
217     InitializeWindows_tools();
218 #endif
219
220     if (_pSEI->iNoJvm == 0) // With JVM
221     {
222         /* bug 3702 */
223         /* tclsci creates a TK window on Windows */
224         /* it changes focus on previous windows */
225         /* we put InitializeTclTk before InitializeGUI */
226
227         //InitializeTclTk();
228         InitializeJVM();
229         InitializeGUI();
230
231         /* create needed data structure if not already created */
232         loadGraphicModule();
233
234         loadBackGroundClassPath();
235
236         //update %gui to true
237         Add_Boolean_Constant(L"%gui", true);
238     }
239
240     /* Standard mode -> init Java Console */
241     if (_pSEI->iConsoleMode == 0)
242     {
243         /* Initialize console: lines... */
244         InitializeConsole();
245     }
246     else
247     {
248 #ifndef _MSC_VER
249         initConsoleMode(RAW);
250 #endif
251     }
252
253     //set prompt value
254     int pause = 0;
255     C2F(setprlev) (&pause);
256
257     //load gateways
258     LoadModules();
259
260     //open a scope for macros
261     symbol::Context::getInstance()->scope_begin();
262     //execute scilab.start
263     if (_pSEI->iNoStart == 0)
264     {
265         execScilabStartTask(_pSEI->iSerialize != 0);
266     }
267
268     //open console scope
269     symbol::Context::getInstance()->scope_begin();
270
271     ConfigVariable::setStartProcessing(false);
272
273     ConfigVariable::setPromptMode(0);
274     try
275     {
276         if (_pSEI->pstExec)
277         {
278             //-e option
279             Parser parser;
280             parseCommandTask(&parser, _pSEI->iTimed != 0, _pSEI->pstExec);
281
282             if (parser.getExitStatus() == Parser::Failed)
283             {
284                 scilabWriteW(parser.getErrorMessage());
285             }
286             else if (parser.getControlStatus() !=  Parser::AllControlClosed)
287             {
288                 _pSEI->iMultiLine = 1;
289             }
290             else
291             {
292                 StoreConsoleCommand(_pSEI->pstExec);
293             }
294
295             if (parser.getTree())
296             {
297                 delete parser.getTree();
298                 parser.setTree(NULL);
299             }
300             iMainRet = ConfigVariable::getExitStatus();
301         }
302         else if (_pSEI->pstFile)
303         {
304             //-f option execute exec('%s',-1)
305             char *pstCommand = (char *)MALLOC(sizeof(char) * (strlen("exec(\"\",-1)") + strlen(_pSEI->pstFile) + 1));
306             sprintf(pstCommand, "exec(\"%s\",-1)", _pSEI->pstFile);
307
308             StoreConsoleCommand(pstCommand);
309             FREE(pstCommand);
310             iMainRet = ConfigVariable::getExitStatus();
311             _pSEI->pstExec = NULL;
312             _pSEI->pstFile = NULL;
313         }
314     }
315     catch (const ast::ScilabException& se)
316     {
317         scilabErrorW(se.GetErrorMessage().c_str());
318     }
319
320     ConfigVariable::setPromptMode(2);
321     return iMainRet;
322 }
323
324 int RunScilabEngine(ScilabEngineInfo* _pSEI)
325 {
326     if (_pSEI->pstParseFile)
327     {
328         // Only for parsing test, won't execute anything.
329         return batchMain(_pSEI);
330     }
331     else
332     {
333         //always run as interactiveMain even after -e or -f option
334         return interactiveMain(_pSEI);
335     }
336 }
337
338 int ExecExternalCommand(ScilabEngineInfo* _pSEI)
339 {
340     if (_pSEI->pstExec)
341     {
342         StoreConsoleCommand(_pSEI->pstExec);
343         ThreadManagement::WaitForConsoleExecDoneSignal();
344         return ConfigVariable::getExitStatus();
345     }
346
347     return -1;
348 }
349
350 void StopScilabEngine(ScilabEngineInfo* _pSEI)
351 {
352     ConfigVariable::setEndProcessing(true);
353 #ifdef _MSC_VER
354     /* bug 3672 */
355     /* Create a Mutex (closing scilab)
356      * used by files association
357      */
358     createMutexClosingScilab();
359 #endif
360
361     clearScilabPreferences();
362
363     //close console scope
364     symbol::Context::getInstance()->scope_end();
365
366     //execute scilab.quit
367     if (_pSEI->pstFile)
368     {
369         //-f option execute exec('%s',-1)
370         char *pstCommand = (char *)MALLOC(sizeof(char) * (strlen("exec(\"\",-1)") + strlen(_pSEI->pstFile) + 1));
371         sprintf(pstCommand, "exec(\"%s\",-1)", _pSEI->pstFile);
372
373         _pSEI->pstExec = pstCommand;
374         processCommand(_pSEI);
375         FREE(pstCommand);
376     }
377     else if (_pSEI->iNoStart == 0)
378     {
379         execScilabQuitTask(_pSEI->iSerialize != 0);
380         //call all modules.quit
381         EndModules();
382     }
383
384     //close macros scope
385     symbol::Context::getInstance()->scope_end();
386
387     //close gateways scope
388     symbol::Context::getInstance()->scope_end();
389
390     //clean context
391     symbol::Context::getInstance()->clearAll();
392     //destroy context
393     symbol::Context::destroyInstance();
394 #ifndef NDEBUG
395     //uncomment to print mem leak log
396     //types::Inspector::displayMemleak();
397 #endif
398
399     // cleanup Java dependent features
400     saveCWDInPreferences();
401     clearScilabPreferences();
402     TerminateHistoryManager();
403
404     // stop the JVM
405     if (_pSEI->iNoJvm == 0)
406     {
407         //dynamic_TerminateTclTk();
408         TerminateGraphics();
409         TerminateJVM();
410     }
411
412     // reset struct to prevent the use of deleted objects
413     // when we start scilab again without kill process (ie: call_scilab)
414     resetVariableValueDefinedInScilab();
415
416     /* TerminateCorePart2 */
417
418     //clear opened files
419     FileManager::destroy();
420
421     /* Remove TMPDIR before exit */
422     clearTMPDIR();
423
424     //Unload dynamic modules
425     UnloadModules();
426
427     //destroy function manager
428     destroyfunctionManagerInstance();
429     /* TerminateCorePart2 end */
430
431     /*
432     * Cleanup function for the XML library.
433     */
434     xmlCleanupParser();
435
436     /* Cleanup the parser state */
437     Parser::cleanup();
438
439 #ifdef _MSC_VER
440     TerminateWindows_tools();
441 #endif
442
443     /* Reset terminal configuration */
444     if (_pSEI->iConsoleMode)
445     {
446 #ifndef _MSC_VER
447         initConsoleMode(ATTR_RESET);
448 #endif
449     }
450
451 #ifdef _MSC_VER
452     /* close mutex (closing scilab)
453      * used by files association
454      */
455     terminateMutexClosingScilab();
456 #endif
457
458     ConfigVariable::clearLastError();
459     ConfigVariable::setEndProcessing(false);
460 }
461
462 static void processCommand(ScilabEngineInfo* _pSEI)
463 {
464     /*
465      ** -*- DUMPING TREE -*-
466      */
467     if (_pSEI->iDumpAst)
468     {
469         dumpAstTask((ast::Exp*)_pSEI->pExpTree, _pSEI->iTimed != 0);
470     }
471
472     /*
473      ** -*- PRETTY PRINT TREE -*-
474      */
475     if (_pSEI->iPrintAst)
476     {
477         printAstTask((ast::Exp*)_pSEI->pExpTree, _pSEI->iTimed != 0);
478     }
479
480     /*
481      ** -*- EXECUTING TREE -*-
482      */
483     if (_pSEI->iExecAst)
484     {
485         execAstTask((ast::Exp*)_pSEI->pExpTree, _pSEI->iSerialize != 0,
486                     _pSEI->iTimed != 0, _pSEI->iAstTimed != 0,
487                     _pSEI->iExecVerbose != 0, _pSEI->isInterruptible != 0,
488                     _pSEI->isPrioritary != 0, _pSEI->isConsoleCommand != 0);
489     }
490
491     /*
492      ** -*- DUMPING STACK AFTER EXECUTION -*-
493      */
494     if (_pSEI->iDumpStack)
495     {
496         dumpStackTask(_pSEI->iTimed != 0);
497     }
498 }
499
500 // Thread used to parse and execute Scilab command setted in storeCommand
501 void* scilabReadAndExecCommand(void* param)
502 {
503     int iInterruptibleCmd   = 0;
504     int iPrioritaryCmd      = 0;
505     int iConsoleCmd         = 0;
506     char* command           = NULL;
507
508     ScilabEngineInfo* _pSEI = (ScilabEngineInfo*)param;
509
510     while (ConfigVariable::getForceQuit() == false)
511     {
512         if (GetCommand(&command, &iInterruptibleCmd, &iPrioritaryCmd, &iConsoleCmd) == 0)
513         {
514             // command queue is empty
515             ThreadManagement::WaitForCommandStoredSignal();
516             continue;
517         }
518
519         // empty command
520         if (command == NULL || strlen(command) == 0)
521         {
522             continue;
523         }
524
525         _pSEI->isInterruptible = iInterruptibleCmd;
526         _pSEI->isPrioritary = iPrioritaryCmd;
527         _pSEI->isConsoleCommand = iConsoleCmd;
528
529         ThreadManagement::LockParser();
530         Parser parser;
531         parser.setParseTrace(_pSEI->iParseTrace != 0);
532         parseCommandTask(&parser, _pSEI->iTimed != 0, command);
533
534         if (parser.getExitStatus() == Parser::Failed)
535         {
536             scilabWriteW(parser.getErrorMessage());
537             ThreadManagement::UnlockParser();
538             continue;
539         }
540
541         _pSEI->pExpTree = parser.getTree();
542         ThreadManagement::UnlockParser();
543
544         processCommand(_pSEI);
545         FREE(command);
546     }
547
548     return NULL;
549 }
550
551 //Thread used to parse and set console commands in storeCommand
552 void* scilabReadAndStore(void* param)
553 {
554     ThreadManagement::LockStart();
555     ThreadManagement::UnlockStart();
556
557     Parser::ControlStatus controlStatus = Parser::AllControlClosed;
558
559     char *command = NULL;
560     wchar_t* parserErrorMsg = NULL;
561
562     ScilabEngineInfo* _pSEI = (ScilabEngineInfo*)param;
563
564     if (_pSEI->iMultiLine)
565     {
566         command = _pSEI->pstExec;
567     }
568
569     if (isEmptyCommandQueue() == false)
570     {
571         // unlock main thread
572         ThreadManagement::SendStartPendingSignal();
573
574         // Command stored as console command by -f
575         // We have to wait this execution before
576         // callOnPrompt (ie: onPrompt perform a quit in test_run)
577         ThreadManagement::WaitForConsoleExecDoneSignal();
578     }
579
580     // unlock main thread
581     ThreadManagement::SendStartPendingSignal();
582
583     while (ConfigVariable::getForceQuit() == false)
584     {
585         callOnPrompt();
586
587         Parser parser;
588         parser.setParseTrace(_pSEI->iParseTrace != 0);
589
590         Parser::ParserStatus exitStatus = Parser::Failed;
591
592         if (ConfigVariable::isEmptyLineShow())
593         {
594             scilabWriteW(L"\n");
595         }
596
597         do
598         {
599             // Show Parser Sate before prompt
600             stateShow(controlStatus);
601
602             int pause = ConfigVariable::getPauseLevel();
603
604             //set prompt value
605             C2F(setprlev) (&pause);
606
607             char *pstRead = scilabRead();
608
609             if (command == NULL)
610             {
611                 command = pstRead;
612                 if (strcmp(command, "") == 0)
613                 {
614                     FREE(command);
615                     command = NULL;
616                     break;
617                 }
618             }
619             else
620             {
621                 //+1 for null termination and +1 for '\n'
622                 size_t iLen = strlen(command) + strlen(pstRead) + 2;
623                 char *pstNewCommand = (char *)MALLOC(iLen * sizeof(char));
624
625 #ifdef _MSC_VER
626                 sprintf_s(pstNewCommand, iLen, "%s\n%s", command, pstRead);
627 #else
628                 sprintf(pstNewCommand, "%s\n%s", command, pstRead);
629 #endif
630                 FREE(pstRead);
631                 FREE(command);
632                 command = pstNewCommand;
633             }
634
635             ThreadManagement::LockParser();
636             parseCommandTask(&parser, _pSEI->iTimed != 0, command);
637             controlStatus = parser.getControlStatus();
638             exitStatus = parser.getExitStatus();
639             parserErrorMsg = parser.getErrorMessage();
640             if (parser.getTree())
641             {
642                 delete parser.getTree();
643                 parser.setTree(NULL);
644             }
645             ThreadManagement::UnlockParser();
646         }
647         while (controlStatus != Parser::AllControlClosed);
648
649         if (command == NULL)
650         {
651             continue;
652         }
653
654         if (exitStatus == Parser::Failed)
655         {
656             FREE(command);
657             command = NULL;
658             scilabForcedWriteW(parserErrorMsg);
659             continue;
660         }
661
662         StoreConsoleCommand(command);
663
664         FREE(command);
665         command = NULL;
666
667         ThreadManagement::WaitForConsoleExecDoneSignal();
668     }
669
670     // Awake scilabReadAndExecCommand thread in case of scilab exit
671     ThreadManagement::SendCommandStoredSignal();
672     return NULL;
673 }
674
675 /*
676 ** -*- Interactive Main -*-
677 */
678 static int interactiveMain(ScilabEngineInfo* _pSEI)
679 {
680 #ifndef WITH_GUI
681 #ifndef _MSC_VER
682     if (getScilabMode() != SCILAB_NWNI)
683     {
684         fprintf(stderr, "Scilab was compiled without its GUI and advanced features. Run scilab-cli or use the -nwni option.\n");
685         initConsoleMode(ATTR_RESET);
686         exit(1);
687     }
688 #endif
689 #endif
690
691     InitializeHistoryManager();
692
693     if (getScilabMode() != SCILAB_NWNI && getScilabMode() != SCILAB_API)
694     {
695
696         char *cwd = NULL;
697
698         int err = 0;
699
700         UpdateBrowseVar();
701         cwd = scigetcwd(&err);
702         if (cwd)
703         {
704             FileBrowserChDir(cwd);
705             FREE(cwd);
706         }
707     }
708
709     __threadId threadIdConsole;
710     __threadKey threadKeyConsole;
711     __threadId threadIdCommand;
712     __threadKey threadKeyCommand;
713
714     if (_pSEI->iStartConsoleThread)
715     {
716         ThreadManagement::LockStart();
717         // thread to manage console command
718         __CreateThreadWithParams(&threadIdConsole, &threadKeyConsole, &scilabReadAndStore, _pSEI);
719
720         // scilabReadAndStore thread must be execute before scilabReadAndExecCommand
721         // to be such that the -f command stored is not removed
722         // from queue before scilabReadAndStore is waiting for.
723         ThreadManagement::WaitForStartPendingSignal();
724     }
725
726     // thread to manage command stored
727     __CreateThreadWithParams(&threadIdCommand, &threadKeyCommand, &scilabReadAndExecCommand, _pSEI);
728
729     __WaitThreadDie(threadIdCommand);
730
731 #ifdef DEBUG
732     std::cerr << "To end program press [ENTER]" << std::endl;
733 #endif
734
735     return ConfigVariable::getExitStatus();
736 }
737
738 /*
739 ** -*- Batch Main -*-
740 */
741 static int batchMain(ScilabEngineInfo* _pSEI)
742 {
743     /*
744      ** -*- PARSING -*-
745      */
746     Parser *parser = new Parser();
747
748     parser->setParseTrace(_pSEI->iParseTrace != 0);
749
750     wchar_t *pwstFileName = to_wide_string(_pSEI->pstParseFile);
751
752     /*
753      ** -*- PARSING -*-
754      */
755     parseFileTask(parser, _pSEI->iTimed != 0, pwstFileName, L"YaSp");
756
757     /*
758      ** -*- DUMPING TREE -*-
759      */
760     if (_pSEI->iDumpAst)
761     {
762         dumpAstTask(parser->getTree(), _pSEI->iTimed != 0);
763     }
764
765     if (parser->getExitStatus() == Parser::Succeded)
766     {
767         /*
768          ** -*- PRETTY PRINT TREE -*-
769          */
770         if (_pSEI->iPrintAst)
771         {
772             printAstTask(parser->getTree(), _pSEI->iTimed != 0);
773         }
774
775     }
776     else
777     {
778         scilabWriteW(parser->getErrorMessage());
779     }
780
781 #ifdef DEBUG
782     std::cerr << "To end program press [ENTER]" << std::endl;
783 #endif
784     return parser->getExitStatus();
785 }
786
787 /*
788 ** -*- stateView
789 ** Used to show parser state.
790 ** Find if we are stuck within some control structure.
791 */
792 static void stateShow(Parser::ControlStatus status)
793 {
794     switch (status)
795     {
796         //case Parser::WithinFor:
797         //    SetTemporaryPrompt("-for       ->");
798         //    break;
799         //case Parser::WithinWhile:
800         //    SetTemporaryPrompt("-while     ->");
801         //    break;
802         //case Parser::WithinIf:
803         //    SetTemporaryPrompt("-if        ->");
804         //    break;
805         //case Parser::WithinElse:
806         //    SetTemporaryPrompt("-else      ->");
807         //    break;
808         //case Parser::WithinElseIf:
809         //    SetTemporaryPrompt("-elseif    ->");
810         //    break;
811         //case Parser::WithinTry:
812         //    SetTemporaryPrompt("-try       ->");
813         //    break;
814         //case Parser::WithinCatch:
815         //    SetTemporaryPrompt("-catch     ->");
816         //    break;
817         //case Parser::WithinFunction:
818         //    SetTemporaryPrompt("-function  ->");
819         //    break;
820         //case Parser::WithinSelect:
821         //    SetTemporaryPrompt("-select    ->");
822         //    break;
823         //case Parser::WithinCase:
824         //    SetTemporaryPrompt("-case      ->");
825         //    break;
826         //case Parser::WithinSwitch:
827         //    SetTemporaryPrompt("-switch    ->");
828         //    break;
829         //case Parser::WithinOtherwise:
830         //    SetTemporaryPrompt("-otherwise ->");
831         //    break;
832         //case Parser::WithinMatrix:
833         //    SetTemporaryPrompt("- [        ->");
834         //    break;
835         //case Parser::WithinCell:
836         //    SetTemporaryPrompt("- {        ->");
837         //    break;
838         //case Parser::WithinBlockComment:
839         //    SetTemporaryPrompt("- /*       ->");
840         //    break;
841         //case Parser::WithinDots:
842         //    SetTemporaryPrompt("- ...      ->");
843         //    break;
844         default :
845             SetTemporaryPrompt("  > ");
846             break;
847         case Parser::AllControlClosed:
848             //ClearTemporaryPrompt();
849             break;
850     }
851 }
852
853 static int InitializeEnvironnement(void)
854 {
855     SetScilabEnvironment();
856     InitializeLocalization();
857
858     ConfigVariable::setConsoleWidth(75);
859     ConfigVariable::setFormatSize(10);
860     ConfigVariable::setFormatMode(1);
861     Add_All_Variables();
862     FileManager::initialize();
863     initOperationArray();
864     return 0;
865 }
866
867 /*
868  * Private function to check any linker errors
869  */
870
871 static void checkForLinkerErrors(void)
872 {
873 #ifndef _MSC_VER
874     /*
875        Depending on the linking order, sometime, libs are not loaded the right way.
876        This can cause painful debugging tasks for packager or developer, we are
877        doing the check to help them.
878     */
879 #define LINKER_ERROR_1 "Scilab startup function detected that the function proposed to the engine is the wrong one. Usually, it comes from a linker problem in your distribution/OS.\n"
880 #define LINKER_ERROR_2 "If you do not know what it means, please report a bug on http://bugzilla.scilab.org/. If you do, you probably know that you should change the link order in SCI/modules/Makefile.am\n"
881
882     if (getScilabMode() != SCILAB_NWNI && getScilabMode() != SCILAB_API)
883     {
884         if (isItTheDisabledLib())
885         {
886             fprintf(stderr, LINKER_ERROR_1);
887             fprintf(stderr, "Here, Scilab should have 'libscijvm' defined but gets 'libscijvm-disable' instead.\n");
888             fprintf(stderr, LINKER_ERROR_2);
889             exit(1);
890         }
891     }
892     else
893     {
894         /* NWNI mode */
895         if (!isItTheDisabledLib())
896         {
897             fprintf(stderr, LINKER_ERROR_1);
898             fprintf(stderr, "Here, Scilab should have 'libscijvm-disable' defined but gets 'libscijvm' instead.\n");
899             fprintf(stderr, LINKER_ERROR_2);
900             exit(1);
901         }
902     }
903 #undef LINKER_ERROR_1
904 #undef LINKER_ERROR_2
905 #endif
906 }
907
908 static void Add_All_Variables(void)
909 {
910     Add_pi();
911     Add_eps();
912     Add_e();
913     Add_i();
914     Add_s();
915     Add_z();
916     Add_gui();
917     Add_fftw();
918     Add_Nan();
919     Add_Inf();
920     Add_io();
921 }
922
923 static void Add_Nan(void)
924 {
925     double dbl1 = -1.0;
926     double dbl0 = fabs(dbl1 - dbl1);
927
928     Add_Double_Constant(L"%nan", dbl0 / dbl0, 0, false);
929 }
930
931 static void Add_Inf(void)
932 {
933     double dbl1 = 1.0;
934     double dbl0 = dbl1 - dbl1;
935
936     Add_Double_Constant(L"%inf", dbl1 / dbl0, 0, false);
937 }
938
939 static void Add_gui(void)
940 {
941     Add_Boolean_Constant(L"%gui", false);
942 }
943
944 static void Add_fftw(void)
945 {
946     Add_Boolean_Constant(L"%fftw", withfftw() == 1);
947 }
948
949 static void Add_pi(void)
950 {
951     Add_Double_Constant(L"%pi", M_PI, 0, false);
952 }
953
954 static void Add_eps(void)
955 {
956     Add_Double_Constant(L"%eps", C2F(dlamch) ("p", 1L), 0, false);
957 }
958
959 static void Add_e(void)
960 {
961     Add_Double_Constant(L"%e", 2.71828182845904530, 0, false);
962 }
963
964 static void Add_i(void)
965 {
966     Add_Double_Constant(L"%i", 0, 1, true);
967 }
968
969 static void Add_s(void)
970 {
971     Double dblCoef(1, 2);
972
973     dblCoef.set(0, 0, 0);
974     dblCoef.set(0, 1, 1);
975
976     Add_Poly_Constant(L"%s", L"s", 1, &dblCoef);
977 }
978
979 static void Add_z(void)
980 {
981     Double dblCoef(1, 2);
982
983     dblCoef.set(0, 0, 0);
984     dblCoef.set(0, 1, 1);
985
986     Add_Poly_Constant(L"%z", L"z", 1, &dblCoef);
987 }
988
989 static void Add_io(void)
990 {
991     types::Double * pVal = new types::Double(1, 2);
992     pVal->set(0, 5);
993     pVal->set(1, 6);
994     symbol::Context::getInstance()->put(symbol::Symbol(L"%io"), pVal);
995 }
996
997 static void Add_Poly_Constant(wstring _szName, wstring _szPolyVar, int _iRank, Double * _pdbl)
998 {
999     types::Polynom * pVar = new types::Polynom(_szPolyVar, 1, 1, &_iRank);
1000     SinglePoly *poPoly = pVar->get(0);
1001
1002     poPoly->setCoef(_pdbl);
1003     symbol::Context::getInstance()->put(symbol::Symbol(_szName), pVar);
1004 }
1005
1006 static void Add_Double_Constant(wstring _szName, double _dblReal, double _dblImg, bool _bComplex)
1007 {
1008     types::Double * pVal = new types::Double(1, 1, _bComplex);
1009     pVal->set(0, 0, _dblReal);
1010     pVal->setImg(0, 0, _dblImg);
1011     symbol::Context::getInstance()->put(symbol::Symbol(_szName), pVal);
1012 }
1013
1014 static void Add_Boolean_Constant(wstring _szName, bool _bBool)
1015 {
1016     types::Bool * pVal = new types::Bool(_bBool);
1017     symbol::Context::getInstance()->put(symbol::Symbol(_szName), pVal);
1018 }
1019
1020 static void Add_String_Constant(wstring _szName, const char *_pstString)
1021 {
1022     types::String * ps = new types::String(_pstString);
1023     symbol::Context::getInstance()->put(symbol::Symbol(_szName), ps);
1024 }