module preferences plugged
[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 #include "InitializePreferences.h"
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     int iScript = 0;
275     try
276     {
277         if (_pSEI->pstExec)
278         {
279             //-e option
280             Parser parser;
281             parseCommandTask(&parser, _pSEI->iTimed != 0, _pSEI->pstExec);
282
283             if (parser.getExitStatus() == Parser::Failed)
284             {
285                 scilabWriteW(parser.getErrorMessage());
286             }
287             else if (parser.getControlStatus() !=  Parser::AllControlClosed)
288             {
289                 _pSEI->iMultiLine = 1;
290             }
291             else
292             {
293                 StoreConsoleCommand(_pSEI->pstExec);
294             }
295
296             if (parser.getTree())
297             {
298                 delete parser.getTree();
299                 parser.setTree(NULL);
300             }
301             iMainRet = ConfigVariable::getExitStatus();
302             iScript = 1;
303         }
304         else if (_pSEI->pstFile)
305         {
306             //-f option execute exec('%s',-1)
307             char *pstCommand = (char *)MALLOC(sizeof(char) * (strlen("exec(\"\",-1)") + strlen(_pSEI->pstFile) + 1));
308             sprintf(pstCommand, "exec(\"%s\",-1)", _pSEI->pstFile);
309
310             StoreConsoleCommand(pstCommand);
311             FREE(pstCommand);
312             iMainRet = ConfigVariable::getExitStatus();
313             _pSEI->pstExec = NULL;
314             _pSEI->pstFile = NULL;
315             iScript = 1;
316         }
317     }
318     catch (const ast::ScilabException& se)
319     {
320         scilabErrorW(se.GetErrorMessage().c_str());
321     }
322
323     ConfigVariable::setPromptMode(2);
324
325     InitializePreferences(iScript);
326
327     return iMainRet;
328 }
329
330 int RunScilabEngine(ScilabEngineInfo* _pSEI)
331 {
332     if (_pSEI->pstParseFile)
333     {
334         // Only for parsing test, won't execute anything.
335         return batchMain(_pSEI);
336     }
337     else
338     {
339         //always run as interactiveMain even after -e or -f option
340         return interactiveMain(_pSEI);
341     }
342 }
343
344 int ExecExternalCommand(ScilabEngineInfo* _pSEI)
345 {
346     if (_pSEI->pstExec)
347     {
348         StoreConsoleCommand(_pSEI->pstExec);
349         ThreadManagement::WaitForConsoleExecDoneSignal();
350         return ConfigVariable::getExitStatus();
351     }
352
353     return -1;
354 }
355
356 void StopScilabEngine(ScilabEngineInfo* _pSEI)
357 {
358     ConfigVariable::setEndProcessing(true);
359 #ifdef _MSC_VER
360     /* bug 3672 */
361     /* Create a Mutex (closing scilab)
362      * used by files association
363      */
364     createMutexClosingScilab();
365 #endif
366
367     clearScilabPreferences();
368
369     //close console scope
370     symbol::Context::getInstance()->scope_end();
371
372     //execute scilab.quit
373     if (_pSEI->pstFile)
374     {
375         //-f option execute exec('%s',-1)
376         char *pstCommand = (char *)MALLOC(sizeof(char) * (strlen("exec(\"\",-1)") + strlen(_pSEI->pstFile) + 1));
377         sprintf(pstCommand, "exec(\"%s\",-1)", _pSEI->pstFile);
378
379         _pSEI->pstExec = pstCommand;
380         processCommand(_pSEI);
381         FREE(pstCommand);
382     }
383     else if (_pSEI->iNoStart == 0)
384     {
385         execScilabQuitTask(_pSEI->iSerialize != 0);
386         //call all modules.quit
387         EndModules();
388     }
389
390     //close macros scope
391     symbol::Context::getInstance()->scope_end();
392
393     //close gateways scope
394     symbol::Context::getInstance()->scope_end();
395
396     //clean context
397     symbol::Context::getInstance()->clearAll();
398     //destroy context
399     symbol::Context::destroyInstance();
400 #ifndef NDEBUG
401     //uncomment to print mem leak log
402     //types::Inspector::displayMemleak();
403 #endif
404
405     // cleanup Java dependent features
406     saveCWDInPreferences();
407     clearScilabPreferences();
408     TerminateHistoryManager();
409
410     // stop the JVM
411     if (_pSEI->iNoJvm == 0)
412     {
413         //dynamic_TerminateTclTk();
414         TerminateGraphics();
415         TerminateJVM();
416     }
417
418     // reset struct to prevent the use of deleted objects
419     // when we start scilab again without kill process (ie: call_scilab)
420     resetVariableValueDefinedInScilab();
421
422     /* TerminateCorePart2 */
423
424     //clear opened files
425     FileManager::destroy();
426
427     /* Remove TMPDIR before exit */
428     clearTMPDIR();
429
430     //Unload dynamic modules
431     UnloadModules();
432
433     //destroy function manager
434     destroyfunctionManagerInstance();
435     /* TerminateCorePart2 end */
436
437     /*
438     * Cleanup function for the XML library.
439     */
440     xmlCleanupParser();
441
442     /* Cleanup the parser state */
443     Parser::cleanup();
444
445 #ifdef _MSC_VER
446     TerminateWindows_tools();
447 #endif
448
449     /* Reset terminal configuration */
450     if (_pSEI->iConsoleMode)
451     {
452 #ifndef _MSC_VER
453         initConsoleMode(ATTR_RESET);
454 #endif
455     }
456
457 #ifdef _MSC_VER
458     /* close mutex (closing scilab)
459      * used by files association
460      */
461     terminateMutexClosingScilab();
462 #endif
463
464     ConfigVariable::clearLastError();
465     ConfigVariable::setEndProcessing(false);
466 }
467
468 static void processCommand(ScilabEngineInfo* _pSEI)
469 {
470     /*
471      ** -*- DUMPING TREE -*-
472      */
473     if (_pSEI->iDumpAst)
474     {
475         dumpAstTask((ast::Exp*)_pSEI->pExpTree, _pSEI->iTimed != 0);
476     }
477
478     /*
479      ** -*- PRETTY PRINT TREE -*-
480      */
481     if (_pSEI->iPrintAst)
482     {
483         printAstTask((ast::Exp*)_pSEI->pExpTree, _pSEI->iTimed != 0);
484     }
485
486     /*
487      ** -*- EXECUTING TREE -*-
488      */
489     if (_pSEI->iExecAst)
490     {
491         execAstTask((ast::Exp*)_pSEI->pExpTree, _pSEI->iSerialize != 0,
492                     _pSEI->iTimed != 0, _pSEI->iAstTimed != 0,
493                     _pSEI->iExecVerbose != 0, _pSEI->isInterruptible != 0,
494                     _pSEI->isPrioritary != 0, _pSEI->isConsoleCommand != 0);
495     }
496
497     /*
498      ** -*- DUMPING STACK AFTER EXECUTION -*-
499      */
500     if (_pSEI->iDumpStack)
501     {
502         dumpStackTask(_pSEI->iTimed != 0);
503     }
504 }
505
506 // Thread used to parse and execute Scilab command setted in storeCommand
507 void* scilabReadAndExecCommand(void* param)
508 {
509     int iInterruptibleCmd   = 0;
510     int iPrioritaryCmd      = 0;
511     int iConsoleCmd         = 0;
512     char* command           = NULL;
513
514     ScilabEngineInfo* _pSEI = (ScilabEngineInfo*)param;
515
516     while (ConfigVariable::getForceQuit() == false)
517     {
518         if (GetCommand(&command, &iInterruptibleCmd, &iPrioritaryCmd, &iConsoleCmd) == 0)
519         {
520             // command queue is empty
521             ThreadManagement::WaitForCommandStoredSignal();
522             continue;
523         }
524
525         // empty command
526         if (command == NULL || strlen(command) == 0)
527         {
528             continue;
529         }
530
531         _pSEI->isInterruptible = iInterruptibleCmd;
532         _pSEI->isPrioritary = iPrioritaryCmd;
533         _pSEI->isConsoleCommand = iConsoleCmd;
534
535         ThreadManagement::LockParser();
536         Parser parser;
537         parser.setParseTrace(_pSEI->iParseTrace != 0);
538         parseCommandTask(&parser, _pSEI->iTimed != 0, command);
539
540         if (parser.getExitStatus() == Parser::Failed)
541         {
542             scilabWriteW(parser.getErrorMessage());
543             ThreadManagement::UnlockParser();
544             continue;
545         }
546
547         _pSEI->pExpTree = parser.getTree();
548         ThreadManagement::UnlockParser();
549
550         processCommand(_pSEI);
551         FREE(command);
552     }
553
554     return NULL;
555 }
556
557 //Thread used to parse and set console commands in storeCommand
558 void* scilabReadAndStore(void* param)
559 {
560     ThreadManagement::LockStart();
561     ThreadManagement::UnlockStart();
562
563     Parser::ControlStatus controlStatus = Parser::AllControlClosed;
564
565     char *command = NULL;
566     wchar_t* parserErrorMsg = NULL;
567
568     ScilabEngineInfo* _pSEI = (ScilabEngineInfo*)param;
569
570     if (_pSEI->iMultiLine)
571     {
572         command = _pSEI->pstExec;
573     }
574
575     if (isEmptyCommandQueue() == false)
576     {
577         // unlock main thread
578         ThreadManagement::SendStartPendingSignal();
579
580         // Command stored as console command by -f
581         // We have to wait this execution before
582         // callOnPrompt (ie: onPrompt perform a quit in test_run)
583         ThreadManagement::WaitForConsoleExecDoneSignal();
584     }
585
586     // unlock main thread
587     ThreadManagement::SendStartPendingSignal();
588
589     while (ConfigVariable::getForceQuit() == false)
590     {
591         callOnPrompt();
592
593         Parser parser;
594         parser.setParseTrace(_pSEI->iParseTrace != 0);
595
596         Parser::ParserStatus exitStatus = Parser::Failed;
597
598         if (ConfigVariable::isEmptyLineShow())
599         {
600             scilabWriteW(L"\n");
601         }
602
603         do
604         {
605             // Show Parser Sate before prompt
606             stateShow(controlStatus);
607
608             int pause = ConfigVariable::getPauseLevel();
609
610             //set prompt value
611             C2F(setprlev) (&pause);
612
613             char *pstRead = scilabRead();
614
615             if (command == NULL)
616             {
617                 command = pstRead;
618                 if (strcmp(command, "") == 0)
619                 {
620                     FREE(command);
621                     command = NULL;
622                     break;
623                 }
624             }
625             else
626             {
627                 //+1 for null termination and +1 for '\n'
628                 size_t iLen = strlen(command) + strlen(pstRead) + 2;
629                 char *pstNewCommand = (char *)MALLOC(iLen * sizeof(char));
630
631 #ifdef _MSC_VER
632                 sprintf_s(pstNewCommand, iLen, "%s\n%s", command, pstRead);
633 #else
634                 sprintf(pstNewCommand, "%s\n%s", command, pstRead);
635 #endif
636                 FREE(pstRead);
637                 FREE(command);
638                 command = pstNewCommand;
639             }
640
641             ThreadManagement::LockParser();
642             parseCommandTask(&parser, _pSEI->iTimed != 0, command);
643             controlStatus = parser.getControlStatus();
644             exitStatus = parser.getExitStatus();
645             parserErrorMsg = parser.getErrorMessage();
646             if (parser.getTree())
647             {
648                 delete parser.getTree();
649                 parser.setTree(NULL);
650             }
651             ThreadManagement::UnlockParser();
652         }
653         while (controlStatus != Parser::AllControlClosed);
654
655         if (command == NULL)
656         {
657             continue;
658         }
659
660         if (exitStatus == Parser::Failed)
661         {
662             FREE(command);
663             command = NULL;
664             scilabForcedWriteW(parserErrorMsg);
665             continue;
666         }
667
668         StoreConsoleCommand(command);
669
670         FREE(command);
671         command = NULL;
672
673         ThreadManagement::WaitForConsoleExecDoneSignal();
674     }
675
676     // Awake scilabReadAndExecCommand thread in case of scilab exit
677     ThreadManagement::SendCommandStoredSignal();
678     return NULL;
679 }
680
681 /*
682 ** -*- Interactive Main -*-
683 */
684 static int interactiveMain(ScilabEngineInfo* _pSEI)
685 {
686 #ifndef WITH_GUI
687 #ifndef _MSC_VER
688     if (getScilabMode() != SCILAB_NWNI)
689     {
690         fprintf(stderr, "Scilab was compiled without its GUI and advanced features. Run scilab-cli or use the -nwni option.\n");
691         initConsoleMode(ATTR_RESET);
692         exit(1);
693     }
694 #endif
695 #endif
696
697     InitializeHistoryManager();
698
699     if (getScilabMode() != SCILAB_NWNI && getScilabMode() != SCILAB_API)
700     {
701
702         char *cwd = NULL;
703
704         int err = 0;
705
706         UpdateBrowseVar();
707         cwd = scigetcwd(&err);
708         if (cwd)
709         {
710             FileBrowserChDir(cwd);
711             FREE(cwd);
712         }
713     }
714
715     __threadId threadIdConsole;
716     __threadKey threadKeyConsole;
717     __threadId threadIdCommand;
718     __threadKey threadKeyCommand;
719
720     if (_pSEI->iStartConsoleThread)
721     {
722         ThreadManagement::LockStart();
723         // thread to manage console command
724         __CreateThreadWithParams(&threadIdConsole, &threadKeyConsole, &scilabReadAndStore, _pSEI);
725
726         // scilabReadAndStore thread must be execute before scilabReadAndExecCommand
727         // to be such that the -f command stored is not removed
728         // from queue before scilabReadAndStore is waiting for.
729         ThreadManagement::WaitForStartPendingSignal();
730     }
731
732     // thread to manage command stored
733     __CreateThreadWithParams(&threadIdCommand, &threadKeyCommand, &scilabReadAndExecCommand, _pSEI);
734
735     __WaitThreadDie(threadIdCommand);
736
737 #ifdef DEBUG
738     std::cerr << "To end program press [ENTER]" << std::endl;
739 #endif
740
741     return ConfigVariable::getExitStatus();
742 }
743
744 /*
745 ** -*- Batch Main -*-
746 */
747 static int batchMain(ScilabEngineInfo* _pSEI)
748 {
749     /*
750      ** -*- PARSING -*-
751      */
752     Parser *parser = new Parser();
753
754     parser->setParseTrace(_pSEI->iParseTrace != 0);
755
756     wchar_t *pwstFileName = to_wide_string(_pSEI->pstParseFile);
757
758     /*
759      ** -*- PARSING -*-
760      */
761     parseFileTask(parser, _pSEI->iTimed != 0, pwstFileName, L"YaSp");
762
763     /*
764      ** -*- DUMPING TREE -*-
765      */
766     if (_pSEI->iDumpAst)
767     {
768         dumpAstTask(parser->getTree(), _pSEI->iTimed != 0);
769     }
770
771     if (parser->getExitStatus() == Parser::Succeded)
772     {
773         /*
774          ** -*- PRETTY PRINT TREE -*-
775          */
776         if (_pSEI->iPrintAst)
777         {
778             printAstTask(parser->getTree(), _pSEI->iTimed != 0);
779         }
780
781     }
782     else
783     {
784         scilabWriteW(parser->getErrorMessage());
785     }
786
787 #ifdef DEBUG
788     std::cerr << "To end program press [ENTER]" << std::endl;
789 #endif
790     return parser->getExitStatus();
791 }
792
793 /*
794 ** -*- stateView
795 ** Used to show parser state.
796 ** Find if we are stuck within some control structure.
797 */
798 static void stateShow(Parser::ControlStatus status)
799 {
800     switch (status)
801     {
802             //case Parser::WithinFor:
803             //    SetTemporaryPrompt("-for       ->");
804             //    break;
805             //case Parser::WithinWhile:
806             //    SetTemporaryPrompt("-while     ->");
807             //    break;
808             //case Parser::WithinIf:
809             //    SetTemporaryPrompt("-if        ->");
810             //    break;
811             //case Parser::WithinElse:
812             //    SetTemporaryPrompt("-else      ->");
813             //    break;
814             //case Parser::WithinElseIf:
815             //    SetTemporaryPrompt("-elseif    ->");
816             //    break;
817             //case Parser::WithinTry:
818             //    SetTemporaryPrompt("-try       ->");
819             //    break;
820             //case Parser::WithinCatch:
821             //    SetTemporaryPrompt("-catch     ->");
822             //    break;
823             //case Parser::WithinFunction:
824             //    SetTemporaryPrompt("-function  ->");
825             //    break;
826             //case Parser::WithinSelect:
827             //    SetTemporaryPrompt("-select    ->");
828             //    break;
829             //case Parser::WithinCase:
830             //    SetTemporaryPrompt("-case      ->");
831             //    break;
832             //case Parser::WithinSwitch:
833             //    SetTemporaryPrompt("-switch    ->");
834             //    break;
835             //case Parser::WithinOtherwise:
836             //    SetTemporaryPrompt("-otherwise ->");
837             //    break;
838             //case Parser::WithinMatrix:
839             //    SetTemporaryPrompt("- [        ->");
840             //    break;
841             //case Parser::WithinCell:
842             //    SetTemporaryPrompt("- {        ->");
843             //    break;
844             //case Parser::WithinBlockComment:
845             //    SetTemporaryPrompt("- /*       ->");
846             //    break;
847             //case Parser::WithinDots:
848             //    SetTemporaryPrompt("- ...      ->");
849             //    break;
850         default :
851             SetTemporaryPrompt("  > ");
852             break;
853         case Parser::AllControlClosed:
854             //ClearTemporaryPrompt();
855             break;
856     }
857 }
858
859 static int InitializeEnvironnement(void)
860 {
861     SetScilabEnvironment();
862     InitializeLocalization();
863
864     ConfigVariable::setConsoleWidth(75);
865     ConfigVariable::setFormatSize(10);
866     ConfigVariable::setFormatMode(1);
867     Add_All_Variables();
868     FileManager::initialize();
869     initOperationArray();
870     return 0;
871 }
872
873 /*
874  * Private function to check any linker errors
875  */
876
877 static void checkForLinkerErrors(void)
878 {
879 #ifndef _MSC_VER
880     /*
881        Depending on the linking order, sometime, libs are not loaded the right way.
882        This can cause painful debugging tasks for packager or developer, we are
883        doing the check to help them.
884     */
885 #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"
886 #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"
887
888     if (getScilabMode() != SCILAB_NWNI && getScilabMode() != SCILAB_API)
889     {
890         if (isItTheDisabledLib())
891         {
892             fprintf(stderr, LINKER_ERROR_1);
893             fprintf(stderr, "Here, Scilab should have 'libscijvm' defined but gets 'libscijvm-disable' instead.\n");
894             fprintf(stderr, LINKER_ERROR_2);
895             exit(1);
896         }
897     }
898     else
899     {
900         /* NWNI mode */
901         if (!isItTheDisabledLib())
902         {
903             fprintf(stderr, LINKER_ERROR_1);
904             fprintf(stderr, "Here, Scilab should have 'libscijvm-disable' defined but gets 'libscijvm' instead.\n");
905             fprintf(stderr, LINKER_ERROR_2);
906             exit(1);
907         }
908     }
909 #undef LINKER_ERROR_1
910 #undef LINKER_ERROR_2
911 #endif
912 }
913
914 static void Add_All_Variables(void)
915 {
916     Add_pi();
917     Add_eps();
918     Add_e();
919     Add_i();
920     Add_s();
921     Add_z();
922     Add_gui();
923     Add_fftw();
924     Add_Nan();
925     Add_Inf();
926     Add_io();
927 }
928
929 static void Add_Nan(void)
930 {
931     double dbl1 = -1.0;
932     double dbl0 = fabs(dbl1 - dbl1);
933
934     Add_Double_Constant(L"%nan", dbl0 / dbl0, 0, false);
935 }
936
937 static void Add_Inf(void)
938 {
939     double dbl1 = 1.0;
940     double dbl0 = dbl1 - dbl1;
941
942     Add_Double_Constant(L"%inf", dbl1 / dbl0, 0, false);
943 }
944
945 static void Add_gui(void)
946 {
947     Add_Boolean_Constant(L"%gui", false);
948 }
949
950 static void Add_fftw(void)
951 {
952     Add_Boolean_Constant(L"%fftw", withfftw() == 1);
953 }
954
955 static void Add_pi(void)
956 {
957     Add_Double_Constant(L"%pi", M_PI, 0, false);
958 }
959
960 static void Add_eps(void)
961 {
962     Add_Double_Constant(L"%eps", C2F(dlamch) ("p", 1L), 0, false);
963 }
964
965 static void Add_e(void)
966 {
967     Add_Double_Constant(L"%e", 2.71828182845904530, 0, false);
968 }
969
970 static void Add_i(void)
971 {
972     Add_Double_Constant(L"%i", 0, 1, true);
973 }
974
975 static void Add_s(void)
976 {
977     Double dblCoef(1, 2);
978
979     dblCoef.set(0, 0, 0);
980     dblCoef.set(0, 1, 1);
981
982     Add_Poly_Constant(L"%s", L"s", 1, &dblCoef);
983 }
984
985 static void Add_z(void)
986 {
987     Double dblCoef(1, 2);
988
989     dblCoef.set(0, 0, 0);
990     dblCoef.set(0, 1, 1);
991
992     Add_Poly_Constant(L"%z", L"z", 1, &dblCoef);
993 }
994
995 static void Add_io(void)
996 {
997     types::Double * pVal = new types::Double(1, 2);
998     pVal->set(0, 5);
999     pVal->set(1, 6);
1000     symbol::Context::getInstance()->put(symbol::Symbol(L"%io"), pVal);
1001 }
1002
1003 static void Add_Poly_Constant(wstring _szName, wstring _szPolyVar, int _iRank, Double * _pdbl)
1004 {
1005     types::Polynom * pVar = new types::Polynom(_szPolyVar, 1, 1, &_iRank);
1006     SinglePoly *poPoly = pVar->get(0);
1007
1008     poPoly->setCoef(_pdbl);
1009     symbol::Context::getInstance()->put(symbol::Symbol(_szName), pVar);
1010 }
1011
1012 static void Add_Double_Constant(wstring _szName, double _dblReal, double _dblImg, bool _bComplex)
1013 {
1014     types::Double * pVal = new types::Double(1, 1, _bComplex);
1015     pVal->set(0, 0, _dblReal);
1016     pVal->setImg(0, 0, _dblImg);
1017     symbol::Context::getInstance()->put(symbol::Symbol(_szName), pVal);
1018 }
1019
1020 static void Add_Boolean_Constant(wstring _szName, bool _bBool)
1021 {
1022     types::Bool * pVal = new types::Bool(_bBool);
1023     symbol::Context::getInstance()->put(symbol::Symbol(_szName), pVal);
1024 }
1025
1026 static void Add_String_Constant(wstring _szName, const char *_pstString)
1027 {
1028     types::String * ps = new types::String(_pstString);
1029     symbol::Context::getInstance()->put(symbol::Symbol(_szName), ps);
1030 }