Javasci: fix java build, javadoc warnings
[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  * 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 }