b58f057c664798bcf33c2020b41819cbdce40dcf
[scilab.git] / 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 }