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
  33 extern "C"
  34 {
  35 #include "machine.h"
  36 #include "InitializeLocalization.h"
  37 #include "elem_common.h"
  38 #include "LaunchScilabSignal.h"
  39 #include "InitializeJVM.h"
  40 #include "TerminateJVM.h"
  41 #include "InitializeGUI.h"
  42 #include "graphicModuleLoad.h"
  43 #include "TerminateGraphics.h"
  44 #include "loadBackGroundClassPath.h"
  45 #include "sci_tmpdir.h"
  46 #include "configvariable_interface.h"
  47 #include "setgetlanguage.h"
  48 #include "InitializeConsole.h"
  49 #include "InitializeHistoryManager.h"
  50 #include "TerminateHistoryManager.h"
  51 #include "prompt.h"
  52 #include "scilabRead.h"
  53 #include "functions_manager.h"
  54 #include "InitScilab.h"
  55 #include "setenvvar.h"
  56 #include "getScilabPreference.h"
  57 #include "saveCWDInPreferences.h"
  58 #include "h5_fileManagement.h"
  59 #include "with_fftw.h"
  60
  61
  62 #ifdef _MSC_VER
  63 #include "InitializeWindows_tools.h"
  64 #include "TerminateWindows_tools.h"
  65 #include "WndThread.h"
  66 #include "console.h"
  67 #include "InnosetupMutex.h"
  68 #include "MutexClosingScilab.h"
  69 #include "WinConsole.h"
  70 #else
  71 #include "signal_mgmt.h"
  72 #include "initConsoleMode.h"
  73 #endif
  74
  75 #if defined(linux) && defined(__i386__)
  76 #include "setPrecisionFPU.h"
  77 #endif
  78
  79     /* Defined without include to avoid useless header dependency */
  80     extern BOOL isItTheDisabledLib(void);
  81 }
  82
  83 static void Add_i(void);
  84 static void Add_pi(void);
  85 static void Add_eps(void);
  86 static void Add_e(void);
  87 static void Add_s(void);
  88 static void Add_z(void);
  89 static void Add_gui(void);
  90 static void Add_fftw(void);
  91 static void Add_Nan(void);
  92 static void Add_Inf(void);
  93 static void Add_io(void);
  94 static void Add_All_Variables(void);
  95 static void Add_Double_Constant(std::wstring _szName, double _dblReal, double _dblImg, bool _bComplex);
  96 static void Add_Poly_Constant(std::wstring _szName, std::wstring _szPolyVar, int _iRank, types::Double * _pdblReal);
  97 static void Add_Boolean_Constant(std::wstring _szName, bool _bBool);
  98 static void Add_String_Constant(std::wstring _szName, const char *_pstString);
  99 static void checkForLinkerErrors(void);
 100
 101 static int batchMain(ScilabEngineInfo* _pSEI);
 102 static int InitializeEnvironnement(void);
 103 static int interactiveMain(ScilabEngineInfo* _pSEI);
 104 static Parser::ControlStatus processCommand(ScilabEngineInfo* _pSEI);
 105 static void stateShow(Parser::ControlStatus status);
 106
 107 using namespace ast;
 108
 109 ScilabEngineInfo* InitScilabEngineInfo()
 110 {
 111     // Disable all startup flags.
 112     ScilabEngineInfo* pSEI = (ScilabEngineInfo*)CALLOC(1, sizeof(ScilabEngineInfo));
 113
 114     //Active default flags
 115     pSEI->iExecAst = 1;
 116     pSEI->iNoBanner = 1;
 117
 118     return pSEI;
 119 }
 120
 121 int StartScilabEngine(ScilabEngineInfo* _pSEI)
 122 {
 123     int iMainRet = 0;
 124     ConfigVariable::setStartProcessing(true);
 125
 126     /* This bug only occurs under Linux 32 bits
 127      * See: http://wiki.scilab.org/Scilab_precision
 128      */
 129 #if defined(linux) && defined(__i386__)
 130     setFPUToDouble();
 131 #endif
 132
 133 #ifndef _MSC_VER
 134     /* Management of the signals (seg fault, floating point exception, etc) */
 135     if (getenv("SCI_DISABLE_EXCEPTION_CATCHING") == NULL)
 136     {
 137         base_error_init();
 138     }
 139 #endif
 140
 141 #if defined(netbsd) || defined(freebsd)
 142     /* floating point exceptions */
 143     fpsetmask(0);
 144 #endif
 145
 146     Runner::init();
 147
 148     checkForLinkerErrors();
 149
 150 #ifdef _MSC_VER
 151     //get current console window and hide it
 152     int scilabMode = getScilabMode();
 153     if (scilabMode == SCILAB_STD || scilabMode == SCILAB_NW)
 154     {
 155         CreateScilabHiddenWndThread();
 156     }
 157
 158     if (scilabMode == SCILAB_STD)
 159     {
 160         //show banner in console window
 161         CreateScilabConsole(_pSEI->iNoBanner);
 162
 163         if (_pSEI->iKeepConsole == 0)
 164         {
 165             HideScilex(); /* hide console window */
 166         }
 167         else
 168         {
 169             ShowScilex();
 170         }
 171     }
 172     else
 173     {
 174         if (scilabMode == SCILAB_NW || scilabMode == SCILAB_NWNI)
 175         {
 176             SaveConsoleColors();
 177             if (scilabMode == SCILAB_NW)
 178             {
 179                 RenameConsole();
 180                 UpdateConsoleColors();
 181             }
 182         }
 183     }
 184
 185     //create a thread for innosetup to allow reinstall during scilab running
 186     createInnosetupMutex();
 187 #endif
 188
 189     InitializeLaunchScilabSignal();
 190
 191     /* Scilab Startup */
 192     xmlInitParser();
 193     InitializeEnvironnement();
 194
 195     if (_pSEI->pstLang)
 196     {
 197         wchar_t *pwstLang = to_wide_string(_pSEI->pstLang);
 198         setlanguage(pwstLang);
 199         FREE(pwstLang);
 200     }
 201
 202 #ifdef _MSC_VER
 203     InitializeWindows_tools();
 204 #endif
 205
 206     if (_pSEI->iNoJvm == 0) // With JVM
 207     {
 208         /* bug 3702 */
 209         /* tclsci creates a TK window on Windows */
 210         /* it changes focus on previous windows */
 211         /* we put InitializeTclTk before InitializeGUI */
 212
 213         //InitializeTclTk();
 214         InitializeJVM();
 215         InitializeGUI();
 216
 217         /* create needed data structure if not already created */
 218         loadGraphicModule();
 219
 220         loadBackGroundClassPath();
 221
 222         //update %gui to true
 223         Add_Boolean_Constant(L"%gui", true);
 224     }
 225
 226     /* Standard mode -> init Java Console */
 227     if (_pSEI->iConsoleMode == 0)
 228     {
 229         /* Initialize console: lines... */
 230         InitializeConsole();
 231     }
 232     else
 233     {
 234 #ifndef _MSC_VER
 235         initConsoleMode(RAW);
 236 #endif
 237     }
 238
 239     //open "protection" scope to protect all variables after scilab start
 240     symbol::Context::getInstance()->scope_begin();
 241
 242     LoadModules();
 243
 244     //execute scilab.start
 245     if (_pSEI->iNoStart == 0)
 246     {
 247         StartModules();
 248         execScilabStartTask(_pSEI->iSerialize != 0);
 249     }
 250
 251     ConfigVariable::setStartProcessing(false);
 252     int pause = 0;
 253
 254     //set prompt value
 255     C2F(setprlev) (&pause);
 256
 257     ConfigVariable::setPromptMode(0);
 258     try
 259     {
 260         if (_pSEI->pstExec)
 261         {
 262             //-e option
 263
 264             processCommand(_pSEI);
 265             iMainRet = ConfigVariable::getExitStatus();
 266         }
 267         else if (_pSEI->pstFile)
 268         {
 269             //-f option execute exec('%s',-1)
 270             char *pstCommand = (char *)MALLOC(sizeof(char) * (strlen("exec(\"\",-1)") + strlen(_pSEI->pstFile) + 1));
 271             sprintf(pstCommand, "exec(\"%s\",-1)", _pSEI->pstFile);
 272
 273             _pSEI->pstExec = pstCommand;
 274             processCommand(_pSEI);
 275             FREE(pstCommand);
 276             iMainRet = ConfigVariable::getExitStatus();
 277             _pSEI->pstExec = NULL;
 278             _pSEI->pstFile = NULL;
 279         }
 280     }
 281     catch (const ast::ScilabException& se)
 282     {
 283         scilabErrorW(se.GetErrorMessage().c_str());
 284     }
 285
 286     ConfigVariable::setPromptMode(2);
 287     return iMainRet;
 288 }
 289
 290 int RunScilabEngine(ScilabEngineInfo* _pSEI)
 291 {
 292     if (_pSEI->pstParseFile)
 293     {
 294         // Only for parsing test, won't execute anything.
 295         return batchMain(_pSEI);
 296     }
 297     else
 298     {
 299         //always run as interactiveMain even after -e or -f option
 300         return interactiveMain(_pSEI);
 301     }
 302 }
 303
 304 int ExecExternalCommand(ScilabEngineInfo* _pSEI)
 305 {
 306     if (_pSEI->pstExec)
 307     {
 308         processCommand(_pSEI);
 309         return ConfigVariable::getExitStatus();
 310     }
 311
 312     return -1;
 313 }
 314
 315 void StopScilabEngine(ScilabEngineInfo* _pSEI)
 316 {
 317     ConfigVariable::setEndProcessing(true);
 318 #ifdef _MSC_VER
 319     /* bug 3672 */
 320     /* Create a Mutex (closing scilab)
 321      * used by files association
 322      */
 323     createMutexClosingScilab();
 324 #endif
 325
 326     clearScilabPreferences();
 327
 328     //close "protection" scope
 329     symbol::Context::getInstance()->scope_end();
 330
 331     //execute scilab.quit
 332     if (_pSEI->pstFile)
 333     {
 334         //-f option execute exec('%s',-1)
 335         char *pstCommand = (char *)MALLOC(sizeof(char) * (strlen("exec(\"\",-1)") + strlen(_pSEI->pstFile) + 1));
 336         sprintf(pstCommand, "exec(\"%s\",-1)", _pSEI->pstFile);
 337
 338         _pSEI->pstExec = pstCommand;
 339         processCommand(_pSEI);
 340         FREE(pstCommand);
 341     }
 342     else if (_pSEI->iNoStart == 0)
 343     {
 344         execScilabQuitTask(_pSEI->iSerialize != 0);
 345         //call all modules.quit
 346         EndModules();
 347     }
 348
 349     //clean context
 350     symbol::Context::getInstance()->clearAll();
 351     //destroy context
 352     symbol::Context::destroyInstance();
 353
 354 #ifndef NDEBUG
 355     //uncomment to print mem leak log
 356     //types::Inspector::displayMemleak();
 357 #endif
 358
 359     // cleanup Java dependent features
 360     saveCWDInPreferences();
 361     clearScilabPreferences();
 362     TerminateHistoryManager();
 363
 364     // stop the JVM
 365     if (_pSEI->iNoJvm == 0)
 366     {
 367         //dynamic_TerminateTclTk();
 368         TerminateGraphics();
 369         TerminateJVM();
 370     }
 371     /* TerminateCorePart2 */
 372
 373     //clear opened files
 374     FileManager::destroy();
 375
 376     /* Remove TMPDIR before exit */
 377     clearTMPDIR();
 378
 379     //Unload dynamic modules
 380     UnloadModules();
 381
 382     //destroy function manager
 383     destroyfunctionManagerInstance();
 384     /* TerminateCorePart2 end */
 385
 386     /*
 387     * Cleanup function for the XML library.
 388     */
 389     xmlCleanupParser();
 390
 391     /* Cleanup the parser state */
 392     Parser::cleanup();
 393
 394 #ifdef _MSC_VER
 395     TerminateWindows_tools();
 396 #endif
 397
 398     /* Reset terminal configuration */
 399     if (_pSEI->iConsoleMode)
 400     {
 401 #ifndef _MSC_VER
 402         initConsoleMode(ATTR_RESET);
 403 #endif
 404     }
 405
 406 #ifdef _MSC_VER
 407     /* close mutex (closing scilab)
 408      * used by files association
 409      */
 410     terminateMutexClosingScilab();
 411 #endif
 412     ConfigVariable::setEndProcessing(false);
 413 }
 414
 415 static Parser::ControlStatus processCommand(ScilabEngineInfo* _pSEI)
 416 {
 417     Parser *parser = new Parser();
 418
 419     parser->setParseTrace(_pSEI->iParseTrace != 0);
 420     if (strcmp(_pSEI->pstExec, "") != 0)
 421     {
 422         wchar_t *pwstCommand = to_wide_string(_pSEI->pstExec);
 423
 424         /*
 425          ** -*- PARSING -*-
 426          */
 427         parseCommandTask(parser, _pSEI->iTimed != 0, pwstCommand);
 428
 429         /*
 430          ** -*- DUMPING TREE -*-
 431          */
 432         if (_pSEI->iDumpAst)
 433         {
 434             dumpAstTask(parser->getTree(), _pSEI->iTimed != 0);
 435         }
 436
 437         if (parser->getExitStatus() == Parser::Succeded)
 438         {
 439             /*
 440              ** -*- PRETTY PRINT TREE -*-
 441              */
 442             if (_pSEI->iPrintAst)
 443             {
 444                 printAstTask(parser->getTree(), _pSEI->iTimed != 0);
 445             }
 446
 447             /*
 448              ** -*- EXECUTING TREE -*-
 449              */
 450             if (_pSEI->iExecAst)
 451             {
 452                 //before calling YaspReader, try to call %onprompt function
 453                 callOnPrompt();
 454                 execAstTask(parser->getTree(), _pSEI->iSerialize != 0, _pSEI->iTimed != 0, _pSEI->iAstTimed != 0, _pSEI->iExecVerbose != 0);
 455             }
 456
 457             /*
 458              ** -*- DUMPING STACK AFTER EXECUTION -*-
 459              */
 460             if (_pSEI->iDumpStack)
 461             {
 462                 dumpStackTask(_pSEI->iTimed != 0);
 463             }
 464         }
 465         else if (parser->getExitStatus() == Parser::Failed && parser->getControlStatus() == Parser::AllControlClosed)
 466         {
 467             if (_pSEI->iExecAst)
 468             {
 469                 //before calling YaspReader, try to call %onprompt function
 470                 callOnPrompt();
 471             }
 472
 473             scilabWriteW(parser->getErrorMessage());
 474         }
 475
 476         FREE(pwstCommand);
 477     }
 478     else
 479     {
 480         if (_pSEI->iExecAst)
 481         {
 482             //before calling YaspReader, try to call %onprompt function
 483             callOnPrompt();
 484         }
 485     }
 486
 487     Parser::ControlStatus ret = parser->getControlStatus();
 488     delete parser;
 489     return ret;
 490 }
 491
 492 /*
 493 ** -*- Interactive Main -*-
 494 */
 495 static int interactiveMain(ScilabEngineInfo* _pSEI)
 496 {
 497     int pause = 0;
 498     char *command = NULL;
 499
 500     Parser::ControlStatus controlStatus = Parser::AllControlClosed;
 501
 502 #ifndef WITH_GUI
 503 #ifndef _MSC_VER
 504     if (getScilabMode() != SCILAB_NWNI)
 505     {
 506         fprintf(stderr, "Scilab was compiled without its GUI and advanced features. Run scilab-cli or us the -nwni option.\n");
 507         initConsoleMode(ATTR_RESET);
 508         exit(1);
 509     }
 510 #endif
 511 #endif
 512
 513     InitializeHistoryManager();
 514
 515     //before calling reader, try to call %onprompt function
 516     callOnPrompt();
 517
 518     while (!ConfigVariable::getForceQuit())
 519     {
 520         // Show Parser Sate before prompt
 521         stateShow(controlStatus);
 522
 523         pause = ConfigVariable::getPauseLevel();
 524
 525         //set prompt value
 526         C2F(setprlev) (&pause);
 527
 528         if (controlStatus == Parser::AllControlClosed)
 529         {
 530             if (command)
 531             {
 532                 FREE(command);
 533                 command = NULL;
 534             }
 535
 536             if (ConfigVariable::isEmptyLineShow())
 537             {
 538                 scilabWriteW(L"\n");
 539             }
 540
 541             command = scilabRead();
 542         }
 543         else
 544         {
 545             char *pstRead = scilabRead();
 546
 547             //+1 for null termination and +1 for '\n'
 548             size_t iLen = strlen(command) + strlen(pstRead) + 2;
 549             char *pstNewCommand = (char *)MALLOC(iLen * sizeof(char));
 550
 551 #ifdef _MSC_VER
 552             sprintf_s(pstNewCommand, iLen, "%s\n%s", command, pstRead);
 553 #else
 554             sprintf(pstNewCommand, "%s\n%s", command, pstRead);
 555 #endif
 556             FREE(pstRead);
 557             FREE(command);
 558             command = pstNewCommand;
 559         }
 560
 561         _pSEI->pstExec = command;
 562         controlStatus = processCommand(_pSEI);
 563         _pSEI->pstExec = NULL;
 564     }
 565 #ifdef DEBUG
 566     std::cerr << "To end program press [ENTER]" << std::endl;
 567 #endif
 568
 569     FREE(command);
 570     return ConfigVariable::getExitStatus();
 571 }
 572
 573 /*
 574 ** -*- Batch Main -*-
 575 */
 576 static int batchMain(ScilabEngineInfo* _pSEI)
 577 {
 578     /*
 579      ** -*- PARSING -*-
 580      */
 581     Parser *parser = new Parser();
 582
 583     parser->setParseTrace(_pSEI->iParseTrace != 0);
 584
 585     wchar_t *pwstFileName = to_wide_string(_pSEI->pstParseFile);
 586
 587     /*
 588      ** -*- PARSING -*-
 589      */
 590     parseFileTask(parser, _pSEI->iTimed != 0, pwstFileName, L"YaSp");
 591
 592     /*
 593      ** -*- DUMPING TREE -*-
 594      */
 595     if (_pSEI->iDumpAst)
 596     {
 597         dumpAstTask(parser->getTree(), _pSEI->iTimed != 0);
 598     }
 599
 600     if (parser->getExitStatus() == Parser::Succeded)
 601     {
 602         /*
 603          ** -*- PRETTY PRINT TREE -*-
 604          */
 605         if (_pSEI->iPrintAst)
 606         {
 607             printAstTask(parser->getTree(), _pSEI->iTimed != 0);
 608         }
 609
 610     }
 611     else
 612     {
 613         scilabWriteW(parser->getErrorMessage());
 614     }
 615
 616 #ifdef DEBUG
 617     std::cerr << "To end program press [ENTER]" << std::endl;
 618 #endif
 619     return parser->getExitStatus();
 620 }
 621
 622 /*
 623 ** -*- stateView
 624 ** Used to show parser state.
 625 ** Find if we are stuck within some control structure.
 626 */
 627 static void stateShow(Parser::ControlStatus status)
 628 {
 629     switch (status)
 630     {
 631         case Parser::WithinFor:
 632             SetTemporaryPrompt("-for       ->");
 633             break;
 634         case Parser::WithinWhile:
 635             SetTemporaryPrompt("-while     ->");
 636             break;
 637         case Parser::WithinIf:
 638             SetTemporaryPrompt("-if        ->");
 639             break;
 640         case Parser::WithinElse:
 641             SetTemporaryPrompt("-else      ->");
 642             break;
 643         case Parser::WithinElseIf:
 644             SetTemporaryPrompt("-elseif    ->");
 645             break;
 646         case Parser::WithinTry:
 647             SetTemporaryPrompt("-try       ->");
 648             break;
 649         case Parser::WithinCatch:
 650             SetTemporaryPrompt("-catch     ->");
 651             break;
 652         case Parser::WithinFunction:
 653             SetTemporaryPrompt("-function  ->");
 654             break;
 655         case Parser::WithinSelect:
 656             SetTemporaryPrompt("-select    ->");
 657             break;
 658         case Parser::WithinCase:
 659             SetTemporaryPrompt("-case      ->");
 660             break;
 661         case Parser::WithinSwitch:
 662             SetTemporaryPrompt("-switch    ->");
 663             break;
 664         case Parser::WithinOtherwise:
 665             SetTemporaryPrompt("-otherwise ->");
 666             break;
 667         case Parser::WithinMatrix:
 668             SetTemporaryPrompt("- [        ->");
 669             break;
 670         case Parser::WithinCell:
 671             SetTemporaryPrompt("- {        ->");
 672             break;
 673         case Parser::WithinBlockComment:
 674             SetTemporaryPrompt("- /*       ->");
 675             break;
 676         case Parser::WithinDots:
 677             SetTemporaryPrompt("- ...      ->");
 678             break;
 679         case Parser::AllControlClosed:
 680             //ClearTemporaryPrompt();
 681             break;
 682     }
 683 }
 684
 685 static int InitializeEnvironnement(void)
 686 {
 687     SetScilabEnvironment();
 688     InitializeLocalization();
 689
 690     ConfigVariable::setConsoleWidth(75);
 691     ConfigVariable::setFormatSize(10);
 692     ConfigVariable::setFormatMode(1);
 693     Add_All_Variables();
 694     FileManager::initialize();
 695     initOperationArray();
 696     return 0;
 697 }
 698
 699 /*
 700  * Private function to check any linker errors
 701  */
 702
 703 static void checkForLinkerErrors(void)
 704 {
 705 #ifndef _MSC_VER
 706     /*
 707        Depending on the linking order, sometime, libs are not loaded the right way.
 708        This can cause painful debugging tasks for packager or developer, we are
 709        doing the check to help them.
 710     */
 711 #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"
 712 #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"
 713
 714     if (getScilabMode() != SCILAB_NWNI)
 715     {
 716         if (isItTheDisabledLib())
 717         {
 718             fprintf(stderr, LINKER_ERROR_1);
 719             fprintf(stderr, "Here, Scilab should have 'libscijvm' defined but gets 'libscijvm-disable' instead.\n");
 720             fprintf(stderr, LINKER_ERROR_2);
 721             exit(1);
 722
 723         }
 724     }
 725     else
 726     {
 727         /* NWNI mode */
 728         if (!isItTheDisabledLib())
 729         {
 730             fprintf(stderr, LINKER_ERROR_1);
 731             fprintf(stderr, "Here, Scilab should have 'libscijvm-disable' defined but gets 'libscijvm' instead.\n");
 732             fprintf(stderr, LINKER_ERROR_2);
 733             exit(1);
 734         }
 735     }
 736 #undef LINKER_ERROR_1
 737 #undef LINKER_ERROR_2
 738 #endif
 739 }
 740
 741 static void Add_All_Variables(void)
 742 {
 743     Add_pi();
 744     Add_eps();
 745     Add_e();
 746     Add_i();
 747     Add_s();
 748     Add_z();
 749     Add_gui();
 750     Add_fftw();
 751     Add_Nan();
 752     Add_Inf();
 753     Add_io();
 754 }
 755
 756 static void Add_Nan(void)
 757 {
 758     double dbl1 = -1.0;
 759     double dbl0 = fabs(dbl1 - dbl1);
 760
 761     Add_Double_Constant(L"%nan", dbl0 / dbl0, 0, false);
 762 }
 763
 764 static void Add_Inf(void)
 765 {
 766     double dbl1 = 1.0;
 767     double dbl0 = dbl1 - dbl1;
 768
 769     Add_Double_Constant(L"%inf", dbl1 / dbl0, 0, false);
 770 }
 771
 772 static void Add_gui(void)
 773 {
 774     Add_Boolean_Constant(L"%gui", false);
 775 }
 776
 777 static void Add_fftw(void)
 778 {
 779     Add_Boolean_Constant(L"%fftw", withfftw() == 1);
 780 }
 781
 782 static void Add_pi(void)
 783 {
 784     Add_Double_Constant(L"%pi", 3.1415926535897931159980, 0, false);
 785 }
 786
 787 static void Add_eps(void)
 788 {
 789     Add_Double_Constant(L"%eps", C2F(dlamch) ("p", 1L), 0, false);
 790 }
 791
 792 static void Add_e(void)
 793 {
 794     Add_Double_Constant(L"%e", 2.71828182845904530, 0, false);
 795 }
 796
 797 static void Add_i(void)
 798 {
 799     Add_Double_Constant(L"%i", 0, 1, true);
 800 }
 801
 802 static void Add_s(void)
 803 {
 804     Double dblCoef(1, 2);
 805
 806     dblCoef.set(0, 0, 0);
 807     dblCoef.set(0, 1, 1);
 808
 809     Add_Poly_Constant(L"%s", L"s", 1, &dblCoef);
 810 }
 811
 812 static void Add_z(void)
 813 {
 814     Double dblCoef(1, 2);
 815
 816     dblCoef.set(0, 0, 0);
 817     dblCoef.set(0, 1, 1);
 818
 819     Add_Poly_Constant(L"%z", L"z", 1, &dblCoef);
 820 }
 821
 822 static void Add_io(void)
 823 {
 824     types::Double * pVal = new types::Double(1, 2);
 825     pVal->set(0, 5);
 826     pVal->set(1, 6);
 827     symbol::Context::getInstance()->put(symbol::Symbol(L"%io"), pVal);
 828 }
 829
 830 static void Add_Poly_Constant(wstring _szName, wstring _szPolyVar, int _iRank, Double * _pdbl)
 831 {
 832     types::Polynom * pVar = new types::Polynom(_szPolyVar, 1, 1, &_iRank);
 833     SinglePoly *poPoly = pVar->get(0);
 834
 835     poPoly->setCoef(_pdbl);
 836     symbol::Context::getInstance()->put(symbol::Symbol(_szName), pVar);
 837 }
 838
 839 static void Add_Double_Constant(wstring _szName, double _dblReal, double _dblImg, bool _bComplex)
 840 {
 841     types::Double * pVal = new types::Double(1, 1, _bComplex);
 842     pVal->set(0, 0, _dblReal);
 843     pVal->setImg(0, 0, _dblImg);
 844     symbol::Context::getInstance()->put(symbol::Symbol(_szName), pVal);
 845 }
 846
 847 static void Add_Boolean_Constant(wstring _szName, bool _bBool)
 848 {
 849     types::Bool * pVal = new types::Bool(_bBool);
 850     symbol::Context::getInstance()->put(symbol::Symbol(_szName), pVal);
 851 }
 852
 853 static void Add_String_Constant(wstring _szName, const char *_pstString)
 854 {
 855     types::String * ps = new types::String(_pstString);
 856     symbol::Context::getInstance()->put(symbol::Symbol(_szName), ps);
 857 }