scilab/modules/javasci/src/java/org/scilab/modules/javasci/Scilab.java

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2010 - INRIA - Sylvestre LEDRU
   4  *
   5  * Copyright (C) 2012 - 2016 - Scilab Enterprises
   6  *
   7  * This file is hereby licensed under the terms of the GNU GPL v2.0,
   8  * pursuant to article 5.3.4 of the CeCILL v.2.1.
   9  * This file was originally licensed under the terms of the CeCILL v2.1,
  10  * and continues to be available under such terms.
  11  * For more information, see the COPYING file which you should have received
  12  * along with this program.
  13  *
  14  */
  15 package org.scilab.modules.javasci;
  16
  17 import java.io.File;
  18 import java.io.FileNotFoundException;
  19
  20 import org.scilab.modules.types.ScilabType;
  21 import org.scilab.modules.types.ScilabTypeEnum;
  22 import org.scilab.modules.types.ScilabIntegerTypeEnum;
  23 import org.scilab.modules.types.ScilabDouble;
  24 import org.scilab.modules.types.ScilabList;
  25 import org.scilab.modules.types.ScilabMList;
  26 import org.scilab.modules.types.ScilabTList;
  27 import org.scilab.modules.types.ScilabString;
  28 import org.scilab.modules.types.ScilabBoolean;
  29 import org.scilab.modules.types.ScilabBooleanSparse;
  30 import org.scilab.modules.types.ScilabInteger;
  31 import org.scilab.modules.types.ScilabPolynomial;
  32 import org.scilab.modules.types.ScilabSparse;
  33 import org.scilab.modules.javasci.Call_Scilab;
  34 import org.scilab.modules.javasci.JavasciException.AlreadyRunningException;
  35 import org.scilab.modules.javasci.JavasciException.InitializationException;
  36 import org.scilab.modules.javasci.JavasciException.UnsupportedTypeException;
  37 import org.scilab.modules.javasci.JavasciException.UndefinedVariableException;
  38 import org.scilab.modules.javasci.JavasciException.UnknownTypeException;
  39 import org.scilab.modules.javasci.JavasciException.ScilabInternalException;
  40 import org.scilab.modules.javasci.JavasciException.ScilabErrorException;
  41
  42 /**
  43  * This class provides the capability to access to the Scilab engine from
  44  * a Java application.<BR>
  45  * <BR>
  46  * Example:<BR>
  47  * <code>
  48  * Scilab sci = new Scilab();<BR>
  49  * if (sci.open()) {<BR>
  50  * double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};<BR>
  51  * ScilabDouble aOriginal = new ScilabDouble(a);<BR>
  52  * sci.put("a",aOriginal);<BR>
  53  * ScilabDouble aFromScilab = (ScilabDouble)sci.get("a");<BR>
  54  * }<BR>
  55  * </code>
  56  * @see org.scilab.modules.types
  57  */
  58 public class Scilab {
  59
  60     private static int notHandledError = -999;
  61
  62     private String SCI = null;
  63     private boolean advancedMode = false;
  64
  65     /**
  66      * Creator of the Scilab Javasci object. <BR>
  67      * <UL>
  68      * <LI>Scilab data path is autodetected (SCI) </LI>
  69      * <LI>advanced features are disabled (no Java nor TCL/TK features) </LI>
  70      * </UL>
  71      */
  72     public Scilab() throws InitializationException {
  73         this(null, false);
  74     }
  75
  76     /**
  77      * Creator of the Scilab Javasci object with a specific Scilab path.<BR>
  78      * Advanced features are disabled (no Java nor TCL/TK features)
  79      * <BR>
  80      * Example:<BR>
  81      * <code>
  82      * Scilab sci = new Scilab("/path/to/Scilab/data/dir/");<BR>
  83      * <BR>
  84      * </code>
  85      * @param SCI provide the path to Scilab data
  86      */
  87     public Scilab(String SCI) throws InitializationException {
  88         this(SCI, false);
  89     }
  90
  91     /**
  92      * Creator of the Scilab Javasci object in advanced mode<BR>
  93      * Scilab data path is autodetected
  94      * <BR>
  95      * Example:<BR>
  96      * <code>
  97      * Scilab sci = new Scilab(true); // Starts in advanced mode<BR>
  98      * <BR>
  99      * </code>
 100      * @param advancedMode true enables the advanced mode (GUI, graphics, Tcl/Tk, sciNotes...). Smaller.
 101      */
 102     public Scilab(boolean advancedMode) throws InitializationException {
 103         this(null, advancedMode);
 104     }
 105
 106     /**
 107      * Creator of the Scilab Javasci object. <BR>
 108      * Under GNU/Linux / Mac OS X, try to detect Scilab base path<BR>
 109      * if the property SCI is set, use it<BR>
 110      * if not, try with the global variable SCI<BR>
 111      * if not, throws a new exception<BR>
 112      * Under Windows, use also the registery<BR>
 113      * <BR>
 114      * Example:<BR>
 115      * <code>
 116      * Scilab sci = new Scilab("/path/to/Scilab/data/dir/",true); // Starts in advanced mode<BR>
 117      * <BR>
 118      * </code>
 119      * @param SCIPath the path to Scilab data
 120      * @param advancedMode true enables the advanced mode (GUI, graphics, Tcl/Tk, sciNotes...). Smaller.
 121      */
 122     public Scilab(String SCIPath, boolean advancedMode) throws InitializationException {
 123         String SCI = SCIPath;
 124         if (!System.getProperty("os.name").toLowerCase().contains("windows")) {
 125             if (SCI == null) {
 126                 // Auto detect
 127                 try {
 128                     SCI = System.getProperty("SCI");
 129                     if (SCI == null || SCI.length() == 0) {
 130                         SCI = System.getenv("SCI");
 131                         if (SCI == null || SCI.length() == 0) {
 132                             throw new InitializationException("Auto detection of SCI failed.\nSCI empty.");
 133                         }
 134                     }
 135                 } catch (Exception e) {
 136                     throw new InitializationException("Auto detection of SCI failed.\nCould not retrieve the variable SCI.", e);
 137                 }
 138             }
 139         }
 140         this.advancedMode = advancedMode;
 141         this.initScilab(SCI);
 142
 143     }
 144
 145
 146     private void initScilab(String SCI) throws InitializationException {
 147         /* Let Scilab engine knows that he is run through the Javasci API */
 148         Call_Scilab.SetFromJavaToON();
 149         if (!System.getProperty("os.name").toLowerCase().contains("windows")) {
 150             File f = new File(SCI);
 151             if (!f.isDirectory()) {
 152                 throw new InitializationException("Could not find directory " + f.getAbsolutePath());
 153             }
 154             this.SCI = SCI;
 155         }
 156     }
 157
 158     /**
 159      * Open a connection to the Scilab engine<BR>
 160      * This function is based on Call_ScilabOpen from call_scilab<BR>
 161      * Note: For now, only one instance of Scilab can be launched<BR>
 162      * A second launch will return FALSE<BR>
 163      * <BR>
 164      * Example:<BR>
 165      * <code>
 166      * Scilab sci = new Scilab();<BR>
 167      * sci.open();<BR>
 168      * <BR>
 169      * </code>
 170      * @return if the operation is successful
 171      * @throws AlreadyRunningException Scilab is already running
 172      * @throws InitializationException Cannot start Scilab
 173      */
 174     public boolean open() throws JavasciException {
 175         int res = Call_Scilab.Call_ScilabOpen(this.SCI, this.advancedMode, null, -1);
 176         switch (res) {
 177             case 0: /* Success */
 178                 return true;
 179             case -1:
 180                 throw new AlreadyRunningException("Javasci already running.");
 181             case -2:
 182                 /* Should not occurd (processed before) */
 183                 throw new InitializationException("Could not find SCI.");
 184             case -3:
 185                 throw new InitializationException("No existing directory.");
 186             case 10001:
 187                 throw new InitializationException("Stacksize failed (not enought memory ?).");
 188             default:
 189                 throw new InitializationException("Unknown startup error: " + res);
 190         }
 191     }
 192
 193     /**
 194      * Open a connection to the Scilab engine and run the command job<BR>
 195      * This function is based on Call_ScilabOpen from call_scilab<BR>
 196      * Note: For now, only one instance of Scilab can be launched<BR>
 197      * A second launch will return FALSE<BR>
 198      * <BR>
 199      * Example:<BR>
 200      * <code>
 201      * Scilab sci = new Scilab();<BR>
 202      * sci.open("a=%pi;");<BR>
 203      * <BR>
 204      * </code>
 205      * @param job The job to run on startup
 206      * @return if the operation is successful
 207      */
 208     public boolean open(String job) throws JavasciException {
 209         if (!this.open()) {
 210             return false;
 211         }
 212
 213         return this.exec(job);
 214     }
 215
 216     /**
 217      * Open a connection to the Scilab engine and run commands job<BR>
 218      * This function is based on Call_ScilabOpen from call_scilab<BR>
 219      * Note: For now, only one instance of Scilab can be launched<BR>
 220      * A second launch will return FALSE<BR>
 221      * <BR>
 222      * Example:<BR>
 223      * <code>
 224      * Scilab sci = new Scilab();<BR>
 225      * sci.open(new String[]{"a=42*2;","b=44*2", "c=(a==b)"});<BR>
 226      * <BR>
 227      * </code>
 228      * @param jobs The serie of jobs to run on startup
 229      * @return if the operation is successful
 230      */
 231     public boolean open(String jobs[]) throws JavasciException {
 232         if (!this.open()) {
 233             return false;
 234         }
 235         return this.exec(jobs);
 236     }
 237
 238
 239     /**
 240      * Open a connection to the Scilab engine and run thefile scriptFilename<BR>
 241      * This function is based on Call_ScilabOpen from call_scilab<BR>
 242      * Note: For now, only one instance of Scilab can be launched<BR>
 243      * A second launch will return FALSE<BR>
 244      * <BR>
 245      * Example:<BR>
 246      * <code>
 247      * Scilab sci = new Scilab();<BR>
 248      * sci.open(new File("/tmp/myscript.sce"));<BR>
 249      * <BR>
 250      * </code>
 251      * @param scriptFilename The script to execute on startup
 252      * @return if the operation is successful
 253      */
 254     public boolean open(File scriptFilename) throws JavasciException, FileNotFoundException {
 255         if (!this.open()) {
 256             return false;
 257         }
 258
 259         return this.exec(scriptFilename);
 260     }
 261
 262
 263     /**
 264      * Execute a single command in Scilab<BR>
 265      * This function is based on SendScilabJob from call_scilab
 266      * <BR>
 267      * Example:<BR>
 268      * <code>
 269      * sci.exec("a=2*%pi");<BR>
 270      * <BR>
 271      * </code>
 272      * @param job the job to execute
 273      * @return if the operation is successful
 274      */
 275     public boolean exec(String job) {
 276         try {
 277             this.execException(job);
 278             return true;
 279         } catch (Exception e) {
 280             return false;
 281         }
 282     }
 283
 284
 285     /**
 286      * Execute a single command in Scilab<BR>
 287      * Returns a ScilabErrorException in case of Scilab problem<BR>
 288      * This function is based on SendScilabJob from call_scilab
 289      * <BR>
 290      * Example:<BR>
 291      * <code>
 292      * sci.exec("a=2*%pi");<BR>
 293      * <BR>
 294      * </code>
 295      * @param job the job to execute
 296      * @since 5.4.0
 297      */
 298     public void execException(String job) throws ScilabErrorException {
 299         int result = Call_Scilab.SendScilabJob(job);
 300         if (result != 0) {
 301             throw new ScilabErrorException("A Scilab error occurred: " + this.getLastErrorMessage(), this.getLastErrorCode());
 302         }
 303     }
 304
 305
 306     /**
 307      * Execute several commands in Scilab<BR>
 308      * This function is based on SendScilabJob from call_scilab
 309      * <BR>
 310      * Example:<BR>
 311      * <code>
 312      * sci.exec(new String[]{"a=42*2;","b=44*2", "c=(a==b)"});<BR>
 313      * <BR>
 314      * </code>
 315      * @param jobs the serie of job to execute
 316      * @return if the operation is successful
 317      */
 318     public boolean exec(String jobs[]) {
 319         try {
 320             this.execException(jobs);
 321             return true;
 322         } catch (Exception e) {
 323             return false;
 324         }
 325     }
 326
 327     /**
 328      * Execute several commands in Scilab<BR>
 329      * Returns a ScilabErrorException in case of Scilab problem<BR>
 330      * This function is based on SendScilabJob from call_scilab
 331      * <BR>
 332      * Example:<BR>
 333      * <code>
 334      * sci.exec(new String[]{"a=42*2;","b=44*2", "c=(a==b)"});<BR>
 335      * <BR>
 336      * </code>
 337      * @param jobs the serie of job to execute
 338      * @since 5.4.0
 339      */
 340     public void execException(String jobs[]) throws ScilabErrorException {
 341         int result = Call_Scilab.SendScilabJobs(jobs, jobs.length);
 342         if (result != 0) {
 343             throw new ScilabErrorException("A Scilab error occurred: " + this.getLastErrorMessage(), this.getLastErrorCode());
 344         }
 345     }
 346
 347     /**
 348      * Execute a Scilab script .sce/.sci and throws an exception in case<BR>
 349      * of a Scilab error<BR>
 350      * Returns a ScilabErrorException in case of Scilab problem<BR>
 351      * This function is based on SendScilabJob from call_scilab<BR>
 352      * Note that this function is a direct call on the Scilab function exec:
 353      * <code> this.exec("exec('" + scriptFilename + "');");</code>
 354      * <BR>
 355      * Example:<BR>
 356      * <code>
 357      * sci.exec(new File("/tmp/myscript.sci"));<BR>
 358      * <BR>
 359      * </code>
 360      * @param scriptFilename the script to execute
 361      * @since 5.4.0
 362      */
 363     public void execException(File scriptFilename) throws FileNotFoundException, ScilabErrorException {
 364         if (!scriptFilename.exists()) {
 365             throw new FileNotFoundException("Could not find " + scriptFilename);
 366         }
 367         this.execException("exec('" + scriptFilename + "');");
 368     }
 369
 370     /**
 371      * Execute a Scilab script .sce/.sci and throws an exception in case<BR>
 372      * the file is not found<BR>
 373      * This function is based on SendScilabJob from call_scilab<BR>
 374      * Note that this function is a direct call on the Scilab function exec:
 375      * <code> this.exec("exec('" + scriptFilename + "');");</code>
 376      * <BR>
 377      * Example:<BR>
 378      * <code>
 379      * sci.exec(new File("/tmp/myscript.sci"));<BR>
 380      * <BR>
 381      * </code>
 382      * @param scriptFilename the script to execute
 383      * @return if the operation is successful
 384      */
 385     public boolean exec(File scriptFilename) throws FileNotFoundException {
 386         if (!scriptFilename.exists()) {
 387             throw new FileNotFoundException("Could not find " + scriptFilename);
 388         }
 389         return this.exec("exec('" + scriptFilename + "');");
 390     }
 391
 392
 393     /**
 394      * Detect if a variable (varname) exists in Scilab
 395      * <BR>
 396      * Example:<BR>
 397      * <code>
 398      * double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};<BR>
 399      * ScilabDouble aOriginal = new ScilabDouble(a);<BR>
 400      * sci.put("a",aOriginal);<BR>
 401      * assert sci.isExistingVariable("a") == true;<BR>
 402      * <BR>
 403      * </code>
 404      * @param varname the variable to check
 405      * @return if the variable exists or not
 406      */
 407     public boolean isExistingVariable(String varname) {
 408         return Call_Scilab.isExistingVariable(varname);
 409     }
 410
 411
 412     /**
 413      * Shutdown Scilab<BR>
 414      * This function is based on TerminateScilab from call_scilab
 415      * <BR>
 416      * Example:<BR>
 417      * <code>
 418      * sci.close();<BR>
 419      * <BR>
 420      * </code>
 421      * @return if the operation is successful
 422      */
 423     public boolean close() {
 424         return Call_Scilab.TerminateScilab(null);
 425     }
 426
 427
 428     /**
 429      * Return the last error code
 430      * <BR>
 431      * Example:<BR>
 432      * <code>
 433      * sci.open("a=1+"); // Wrong operation<BR>
 434      * sci.getLastErrorCode() // Returns 2<BR>
 435      * <BR>
 436      * </code>
 437      * @return the error code
 438      */
 439     public int getLastErrorCode() {
 440         return Call_Scilab.GetLastErrorCode();
 441     }
 442
 443
 444     /**
 445      * Return the last error message
 446      * <BR>
 447      * Example:<BR>
 448      * <code>
 449      * sci.open("a=1+");<BR>
 450      * System.err.println(sci.getLastErrorMessage());<BR>
 451      * <BR>
 452      * </code>
 453      * @return the error message itself
 454      */
 455     public String getLastErrorMessage() {
 456         return Call_Scilab.getLastErrorMessage();
 457     }
 458
 459
 460     /**
 461      * Detect if a Scilab graphic window is still opened<BR>
 462      * This function is based on ScilabHaveAGraph from call_scilab
 463      * <BR>
 464      * Example:<BR>
 465      * <code>
 466      * sci.exec("plot3d();");<BR>
 467      * sci.isGraphicOpened();<BR>
 468      * <BR>
 469      * </code>
 470      * @return if the graphic is open or not
 471      */
 472     public boolean isGraphicOpened() {
 473         return Call_Scilab.isGraphicOpened();
 474     }
 475
 476     /**
 477      * Return the code type of a variable varname
 478      * <BR>
 479      * Example:<BR>
 480      * <code>
 481      * sci.exec("a = 2*%pi");<BR>
 482      * if (sci.getVariableType("a") == ScilabTypeEnum.sci_matrix) {<BR>
 483      *      System.out.println("a is a double matrix");<BR>
 484      * }<BR>
 485      * <BR>
 486      * </code>
 487      * @param varName the name of the variable
 488      * @return the type of the variable
 489      * @throws UndefinedVariableException The variable does not exist
 490      * @throws UnknownTypeException Cannot find the type
 491      */
 492     public ScilabTypeEnum getVariableType(String varName) throws JavasciException {
 493         return getVariableTypeInCurrentScilabSession(varName);
 494     }
 495
 496     /**
 497      * Return the code type of a variable varname in the current Scilab session
 498      * <BR>
 499      * Example:<BR>
 500      * <code>
 501      * sci.exec("a = 2*%pi");<BR>
 502      * if (sci.getVariableType("a") == ScilabTypeEnum.sci_matrix) {<BR>
 503      *      System.out.println("a is a double matrix");<BR>
 504      * }<BR>
 505      * <BR>
 506      * </code>
 507      * @param varName the name of the variable
 508      * @return the type of the variable
 509      * @throws UndefinedVariableException The variable does not exist
 510      * @throws UnknownTypeException Cannot find the type
 511      */
 512     public static ScilabTypeEnum getVariableTypeInCurrentScilabSession(String varName) throws JavasciException {
 513         ScilabTypeEnum variableType = null;
 514         try {
 515             variableType = Call_Scilab.getVariableType(varName);
 516             if (variableType == null ) {
 517                 throw new UndefinedVariableException("Could not find the type of the variable '" + varName + "'");
 518             }
 519         } catch (IllegalArgumentException e) {
 520             String lastWord = e.getMessage().substring(e.getMessage().lastIndexOf(' ') + 1);
 521             if (lastWord.equals("-2")) { /* Crappy workaround. Parse the exception */
 522                 throw new UndefinedVariableException("Could not find variable '" + varName + "'");
 523             }
 524             throw new UnknownTypeException("Type of " + varName + " unknown");
 525
 526         }
 527         return variableType;
 528     }
 529
 530     /**
 531      * Returns a variable named varname<BR>
 532      * Throws an exception if the datatype is not managed or if the variable is not available
 533      * <BR>
 534      * Example:<BR>
 535      * <code>
 536      * double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};<BR>
 537      * double [][]aImg={{212.2, 221.0, 423.0, 393.0},{234.2, 244.0, 441.0, 407.0}};<BR>
 538      * ScilabDouble aOriginal = new ScilabDouble(a, aImg);<BR>
 539      * sci.put("a",aOriginal);<BR>
 540      * ScilabDouble aFromScilab = (ScilabDouble)sci.get("a");<BR>
 541      * <BR>
 542      * </code>
 543      * @param varname the name of the variable
 544      * @return return the variable
 545      * @throws UnsupportedTypeException Type not managed yet.
 546      */
 547     public ScilabType get(String varname) throws JavasciException {
 548         return getInCurrentScilabSession(varname);
 549     }
 550
 551     /**
 552      * Returns a reference variable named varname<BR>
 553      * Throws an exception if the datatype is not managed or if the variable is not available
 554      * <BR>
 555      * Example:<BR>
 556      * <code>
 557      * double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};<BR>
 558      * double [][]aImg={{212.2, 221.0, 423.0, 393.0},{234.2, 244.0, 441.0, 407.0}};<BR>
 559      * ScilabDouble aOriginal = new ScilabDouble(a, aImg);<BR>
 560      * sci.put("a",aOriginal);<BR>
 561      * ScilabDouble aFromScilab = (ScilabDouble)sci.get("a");<BR>
 562      * <BR>
 563      * </code>
 564      * @param varname the name of the variable
 565      * @return return the variable
 566      * @throws UnsupportedTypeException Type not managed yet.
 567      */
 568     public ScilabType getByReference(String varname) throws JavasciException {
 569         return getInCurrentScilabSession(varname, true);
 570     }
 571
 572     /**
 573      * Returns a variable named varname in the current Scilab session<BR>
 574      * Throws an exception if the datatype is not managed or if the variable is not available
 575      * <BR>
 576      * Example:<BR>
 577      * <code>
 578      * double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};<BR>
 579      * double [][]aImg={{212.2, 221.0, 423.0, 393.0},{234.2, 244.0, 441.0, 407.0}};<BR>
 580      * ScilabDouble aOriginal = new ScilabDouble(a, aImg);<BR>
 581      * sci.put("a",aOriginal);<BR>
 582      * ScilabDouble aFromScilab = (ScilabDouble)sci.get("a");<BR>
 583      * <BR>
 584      * </code>
 585      * @param varname the name of the variable
 586      * @return return the variable
 587      * @throws UnsupportedTypeException Type not managed yet.
 588      */
 589     public static ScilabType getInCurrentScilabSession(String varname) throws JavasciException {
 590         return getInCurrentScilabSession(varname, false);
 591     }
 592
 593     /**
 594      * Returns a variable named varname in the current Scilab session<BR>
 595      * Throws an exception if the datatype is not managed or if the variable is not available
 596      * <BR>
 597      * Example:<BR>
 598      * <code>
 599      * double [][]a={{21.2, 22.0, 42.0, 39.0},{23.2, 24.0, 44.0, 40.0}};<BR>
 600      * double [][]aImg={{212.2, 221.0, 423.0, 393.0},{234.2, 244.0, 441.0, 407.0}};<BR>
 601      * ScilabDouble aOriginal = new ScilabDouble(a, aImg);<BR>
 602      * sci.put("a",aOriginal);<BR>
 603      * ScilabDouble aFromScilab = (ScilabDouble)sci.get("a");<BR>
 604      * <BR>
 605      * </code>
 606      * @param varname the name of the variable
 607      * @return return the variable
 608      * @throws UnsupportedTypeException Type not managed yet.
 609      */
 610     public static ScilabType getInCurrentScilabSession(String varname, boolean byref) throws JavasciException {
 611         ScilabTypeEnum sciType = getVariableTypeInCurrentScilabSession(varname);
 612         switch (sciType) {
 613             case sci_matrix:
 614             case sci_boolean:
 615             case sci_strings:
 616
 617             case sci_poly:
 618             case sci_sparse:
 619             case sci_boolean_sparse:
 620             case sci_list:
 621             case sci_tlist:
 622             case sci_mlist:
 623                 return ScilabVariablesJavasci.getScilabVariable(varname, true, byref);
 624             case sci_ints:
 625                 ScilabIntegerTypeEnum typeInt = Call_Scilab.getIntegerPrecision(varname);
 626
 627                 switch (typeInt) {
 628                     case sci_int8:
 629                     case sci_uint8:
 630                     case sci_int16:
 631                     case sci_uint16:
 632                     case sci_int32:
 633                     case sci_uint32:
 634                         return ScilabVariablesJavasci.getScilabVariable(varname, true, byref);
 635                     case sci_int64:
 636                     case sci_uint64:
 637                         // will be available in Scilab 6
 638                         throw new UnsupportedTypeException("64 bit (signed and unsigned) integer types not managed in Scilab 5.X");
 639
 640                 }
 641
 642             default:
 643                 throw new UnsupportedTypeException("Type not managed: " + sciType);
 644         }
 645     }
 646
 647     /**
 648      * Send to Scilab a variable theVariable named varname<BR>
 649      * Throws an exception if the datatype is not managed or if the variable is not available
 650      * <BR>
 651      * Example:<BR>
 652      * <code>
 653      * boolean [][]a={{true, true, false, false},{true, false, true, false}};<BR>
 654      * ScilabBoolean aOriginal = new ScilabBoolean(a);<BR>
 655      * sci.put("a",aOriginal);<BR>
 656      * ScilabBoolean aFromScilab = (ScilabBoolean)sci.get("a");<BR>
 657      * <BR>
 658      * </code>
 659      * @param varname the name of the variable
 660      * @param theVariable the variable itself
 661      * @return true if the operation is successful
 662      * @throws UnsupportedTypeException Type not managed yet.
 663      */
 664     public boolean put(String varname, ScilabType theVariable) throws JavasciException {
 665         return putInCurrentScilabSession(varname, theVariable);
 666     }
 667
 668     /**
 669      * Send to the current Scilab session a variable theVariable named varname<BR>
 670      * Throws an exception if the datatype is not managed or if the variable is not available
 671      * <BR>
 672      * Example:<BR>
 673      * <code>
 674      * boolean [][]a={{true, true, false, false},{true, false, true, false}};<BR>
 675      * ScilabBoolean aOriginal = new ScilabBoolean(a);<BR>
 676      * sci.put("a",aOriginal);<BR>
 677      * ScilabBoolean aFromScilab = (ScilabBoolean)sci.get("a");<BR>
 678      * <BR>
 679      * </code>
 680      * @param varname the name of the variable
 681      * @param theVariable the variable itself
 682      * @return true if the operation is successful
 683      * @throws UnsupportedTypeException Type not managed yet.
 684      */
 685     public static boolean putInCurrentScilabSession(String varname, ScilabType theVariable) throws JavasciException {
 686         int err = notHandledError; /* -999: if the type is not handled */
 687
 688         switch (theVariable.getType()) {
 689             case sci_matrix :
 690                 ScilabDouble sciDouble = (ScilabDouble) theVariable;
 691                 if (sciDouble.isReal()) {
 692                     err = Call_Scilab.putDouble(varname, sciDouble.getRealPart());
 693                 } else {
 694                     err = Call_Scilab.putDoubleComplex(varname, sciDouble.getRealPart(), sciDouble.getImaginaryPart());
 695                 }
 696                 break;
 697             case sci_poly :
 698                 ScilabPolynomial sciPoly = (ScilabPolynomial) theVariable;
 699                 if (sciPoly.isReal()) {
 700                     err = Call_Scilab.putPolynomial(varname, sciPoly.getPolyVarName(), sciPoly.getRealPart());
 701                 } else {
 702                     err = Call_Scilab.putComplexPolynomial(varname, sciPoly.getPolyVarName(), sciPoly.getRealPart(), sciPoly.getImaginaryPart());
 703                 }
 704                 break;
 705             case sci_boolean :
 706                 ScilabBoolean sciBoolean = (ScilabBoolean) theVariable;
 707                 err = Call_Scilab.putBoolean(varname, sciBoolean.getData());
 708                 break;
 709             case sci_sparse :
 710                 ScilabSparse sciSparse = (ScilabSparse) theVariable;
 711                 if (sciSparse.isReal()) {
 712                     err = Call_Scilab.putSparse(varname, sciSparse.getHeight(), sciSparse.getWidth(), sciSparse.getNbItemRow(), sciSparse.getScilabColPos(), sciSparse.getRealPart());
 713                 } else {
 714                     err = Call_Scilab.putComplexSparse(varname, sciSparse.getHeight(), sciSparse.getWidth(), sciSparse.getNbItemRow(), sciSparse.getScilabColPos(), sciSparse.getRealPart(), sciSparse.getImaginaryPart());
 715                 }
 716                 break;
 717             case sci_boolean_sparse :
 718                 ScilabBooleanSparse sciBooleanSparse = (ScilabBooleanSparse) theVariable;
 719                 err = Call_Scilab.putBooleanSparse(varname, sciBooleanSparse.getHeight(), sciBooleanSparse.getWidth(), sciBooleanSparse.getNbItemRow(), sciBooleanSparse.getScilabColPos());
 720                 break;
 721             case sci_ints :
 722                 ScilabInteger sciInteger = (ScilabInteger) theVariable;
 723                 switch (sciInteger.getPrec()) {
 724                     case sci_uint8:
 725                         err = Call_Scilab.putUnsignedByte(varname, sciInteger.getDataAsByte());
 726                         break;
 727                     case sci_int8:
 728                         err = Call_Scilab.putByte(varname, sciInteger.getDataAsByte());
 729                         break;
 730                     case sci_uint16:
 731                         err = Call_Scilab.putUnsignedShort(varname, sciInteger.getDataAsShort());
 732                         break;
 733                     case sci_int16:
 734                         err = Call_Scilab.putShort(varname, sciInteger.getDataAsShort());
 735                         break;
 736                     case sci_uint32:
 737                         err = Call_Scilab.putUnsignedInt(varname, sciInteger.getDataAsInt());
 738                         break;
 739                     case sci_int32:
 740                         err = Call_Scilab.putInt(varname, sciInteger.getDataAsInt());
 741                         break;
 742                     case sci_uint64:
 743                         //                    err = Call_Scilab.putUnsignedLong(varname, sciInteger.getData_());
 744                     case sci_int64:
 745                         //                    err = Call_Scilab.putLong(varname, sciInteger.getData_());
 746                         break;
 747                 }
 748                 break;
 749             case sci_strings :
 750                 ScilabString sciString = (ScilabString) theVariable;
 751                 err = Call_Scilab.putString(varname, sciString.getData());
 752                 break;
 753             case sci_list :
 754                 ScilabList sciList = (ScilabList) theVariable;
 755                 err = Call_ScilabJNI.putList(varname, sciList.getSerializedObject(), 'l');
 756                 break;
 757             case sci_tlist :
 758                 ScilabTList sciTList = (ScilabTList) theVariable;
 759                 err = Call_ScilabJNI.putList(varname, sciTList.getSerializedObject(), 't');
 760                 break;
 761             case sci_mlist :
 762                 ScilabMList sciMList = (ScilabMList) theVariable;
 763                 err = Call_ScilabJNI.putList(varname, sciMList.getSerializedObject(), 'm');
 764                 break;
 765         }
 766
 767         if (err == notHandledError) {
 768             throw new UnsupportedTypeException("Type not managed: " + theVariable.getClass());
 769         } else {
 770             if (err != 0) {
 771                 throw new ScilabInternalException("Storage of the variable '" + varname + "' (" + theVariable.getClass() + ") failed.");
 772             }
 773         }
 774         return true;
 775     }
 776 }