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