Merge remote-tracking branch 'origin/master' into windows
[scilab.git] / scilab / modules / api_scilab / src / cpp / returnProperty.cpp
1 /*
2  * Scilab (http://www.scilab.org/) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Jean-Baptiste SILVY
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 /*------------------------------------------------------------------------*/
16 /* file: returnProperty.c                                                 */
17 /* desc : a set of functions used to return values in Scilab              */
18 /*------------------------------------------------------------------------*/
19
20 #include "returnProperty.h"
21 #include <string.h>
22 #include "sci_malloc.h"
23 #include "double.hxx"
24 #include "int.hxx"
25 #include "string.hxx"
26 #include "graphichandle.hxx"
27
28 /*--------------------------------------------------------------------------*/
29 void* sciReturnEmptyMatrix()
30 {
31     return types::Double::Empty();
32 }
33 /*--------------------------------------------------------------------------*/
34 void* sciReturnString(const char * value)
35 {
36     return new types::String(value);
37 }
38 /*--------------------------------------------------------------------------*/
39 void* sciReturnChar(char value)
40 {
41     char pstValue[2] = {value, 0};//createSingleString needs null terminated characters string
42     return new types::String(pstValue);
43 }
44 /*--------------------------------------------------------------------------*/
45 void* sciReturnDouble(double value)
46 {
47     return new types::Double(value);
48 }
49 /*--------------------------------------------------------------------------*/
50 void* sciReturnInt(int value)
51 {
52     return sciReturnDouble((double)value);
53 }
54 /*--------------------------------------------------------------------------*/
55 void* sciReturnRowVector(const double values[], int nbValues)
56 {
57     double* pdbl = NULL;
58     types::Double* pD = new types::Double(1, nbValues, &pdbl);
59     for (int i = 0 ; i < nbValues ; i++)
60     {
61         pdbl[i] = values[i];
62     }
63     return pD;
64 }
65 /*--------------------------------------------------------------------------*/
66 void* sciReturnRowVectorFromInt(const int values[], int nbValues)
67 {
68     double* pdbl = NULL;
69     types::Double* pD = new types::Double(1, nbValues, &pdbl);
70     for (int i = 0 ; i < nbValues ; i++)
71     {
72         pdbl[i] = (double)values[i];
73     }
74     return pD;
75 }
76 /*--------------------------------------------------------------------------*/
77 void* sciReturnRowIntVector(const int values[], int nbValues)
78 {
79     return sciReturnRowVectorFromInt(values, nbValues);
80 }
81 /*--------------------------------------------------------------------------*/
82 void* sciReturnRowStringVector(char * values[], int nbValues)
83 {
84     return sciReturnStringMatrix(values, 1, nbValues);
85 }
86 /*--------------------------------------------------------------------------*/
87 void* sciReturnHandle(long handle)
88 {
89     return new types::GraphicHandle(handle);
90 }
91 /*--------------------------------------------------------------------------*/
92 void* sciReturnRowHandleVector(const long handles[], int nbValues)
93 {
94     types::GraphicHandle* pH = new types::GraphicHandle(1, nbValues);
95     long long* pHandle = pH->get();
96     for (int i = 0 ; i < nbValues ; i++)
97     {
98         pHandle[i] = (long long)handles[i];
99     }
100     return pH;
101 }
102 /*--------------------------------------------------------------------------*/
103 void* sciReturnColHandleVector(const long handles[], int nbValues)
104 {
105     types::GraphicHandle* pH = new types::GraphicHandle(nbValues, 1);
106     long long* pHandle = pH->get();
107     for (int i = 0 ; i < nbValues ; i++)
108     {
109         pHandle[i] = (long long)handles[i];
110     }
111     return pH;
112 }
113 /*--------------------------------------------------------------------------*/
114 void* sciReturnMatrix(double values[], int nbRow, int nbCol)
115 {
116     double* pdbl = NULL;
117     types::Double* pD = new types::Double(nbRow, nbCol, &pdbl);
118     for (int i = 0 ; i < nbRow * nbCol ; i++)
119     {
120         pdbl[i] = values[i];
121     }
122     return pD;
123 }
124 /*--------------------------------------------------------------------------*/
125 void* sciReturnStringMatrix(char * values[], int nbRow, int nbCol)
126 {
127     types::String* pS = new types::String(nbRow, nbCol);
128     for (int i = 0 ; i < nbRow * nbCol ; i++)
129     {
130         pS->set(i, values[i]);
131     }
132     return pS;
133 }
134 /*--------------------------------------------------------------------------*/
135 void* sciReturnUserData(const int * userData, int userDataSize)
136 {
137     //take care of 32 and 64 bits arch.
138     if (userDataSize == 1)
139     {
140         //32 bits
141         int* p = (int*)userData;
142         return ((types::InternalType*) * p);
143     }
144     else
145     {
146         //64 bits
147         long long* p = (long long*)userData;
148         return ((types::InternalType*) * p);
149     }
150 }
151 /*--------------------------------------------------------------------------*/
152 void* sciReturnHypermatOfDouble(int dims[], int ndims, double values[])
153 {
154     types::Double* pOut = new types::Double(ndims, dims);
155     double* pValues = pOut->get();
156     memcpy(pValues, values, pOut->getSize() * sizeof(double));
157     return pOut;
158 }
159 /*--------------------------------------------------------------------------*/
160 void* sciReturnHypermatOfInteger8(int dims[], int ndims, char values[])
161 {
162     types::Int8* pOut = new types::Int8(ndims, dims);
163     char* pValues = pOut->get();
164     memcpy(pValues, values, pOut->getSize() * sizeof(char));
165     return pOut;
166 }
167 /*--------------------------------------------------------------------------*/
168 void* sciReturnHypermatOfUnsignedInteger8(int dims[], int ndims, unsigned char values[])
169 {
170     types::UInt8* pOut = new types::UInt8(ndims, dims);
171     unsigned char* pValues = pOut->get();
172     memcpy(pValues, values, pOut->getSize() * sizeof(unsigned char));
173     return pOut;
174 }
175 /*--------------------------------------------------------------------------*/
176 void* sciReturnMatrixOfInteger8(char values[], int nbRow, int nbCol)
177 {
178     types::Int8* pOut = new types::Int8(nbRow, nbCol);
179     char* pValues = pOut->get();
180     memcpy(pValues, values, pOut->getSize() * sizeof(char));
181     return pOut;
182 }
183 /*--------------------------------------------------------------------------*/
184 void* sciReturnMatrixOfUnsignedInteger8(unsigned char values[], int nbRow, int nbCol)
185 {
186     types::UInt8* pOut = new types::UInt8(nbRow, nbCol);
187     unsigned char* pValues = pOut->get();
188     memcpy(pValues, values, pOut->getSize() * sizeof(unsigned char));
189     return pOut;
190 }
191 /*--------------------------------------------------------------------------*/
192 void* sciReturnMatrixOfInteger16(short values[], int nbRow, int nbCol)
193 {
194     types::Int16* pOut = new types::Int16(nbRow, nbCol);
195     short* pValues = pOut->get();
196     memcpy(pValues, values, pOut->getSize() * sizeof(short));
197     return pOut;
198 }
199 /*--------------------------------------------------------------------------*/
200 void* sciReturnMatrixOfUnsignedInteger16(unsigned short values[], int nbRow, int nbCol)
201 {
202     types::UInt16* pOut = new types::UInt16(nbRow, nbCol);
203     unsigned short* pValues = pOut->get();
204     memcpy(pValues, values, pOut->getSize() * sizeof(unsigned short));
205     return pOut;
206 }
207 /*--------------------------------------------------------------------------*/
208 void* sciReturnMatrixOfInteger32(int values[], int nbRow, int nbCol)
209 {
210     types::Int32* pOut = new types::Int32(nbRow, nbCol);
211     int* pValues = pOut->get();
212     memcpy(pValues, values, pOut->getSize() * sizeof(int));
213     return pOut;
214 }
215 /*--------------------------------------------------------------------------*/
216 void* sciReturnMatrixOfUnsignedInteger32(unsigned int values[], int nbRow, int nbCol)
217 {
218     types::UInt32* pOut = new types::UInt32(nbRow, nbCol);
219     unsigned int* pValues = pOut->get();
220     memcpy(pValues, values, pOut->getSize() * sizeof(unsigned int));
221     return pOut;
222 }
223 /*--------------------------------------------------------------------------*/