43701ca9fbc839225cee43d62d4553b9186ecdd7
[scilab.git] / scilab / modules / graphics / src / c / getHandleProperty / getPropertyAssignedValue.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
4  * 
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at    
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12
13 /*------------------------------------------------------------------------*/
14 /* file: getPropertyAssignedValue.c                                       */
15 /* desc : a set of functions used to get the values which will be         */
16 /*        assigned to handles properties from the stack                   */
17 /*------------------------------------------------------------------------*/
18
19
20 #include "getPropertyAssignedValue.h"
21 #include "stack-c.h"
22 #include "sciprint.h"
23 #include "localization.h"
24 #include "MALLOC.h"
25 #include "BasicAlgos.h"
26
27 /*--------------------------------------------------------------------------*/
28 BOOL isParameterHandle( int type )
29 {
30   return ( type == sci_handles ) ;
31 }
32 /*--------------------------------------------------------------------------*/
33 BOOL isParameterDoubleMatrix( int type )
34 {
35   return ( type == sci_matrix ) ;
36 }
37 /*--------------------------------------------------------------------------*/
38 BOOL isParameterTlist( int type )
39 {
40   return ( type == sci_tlist ) ;
41 }
42 /*--------------------------------------------------------------------------*/
43 BOOL isParameterStringMatrix( int type )
44 {
45   return ( type == sci_strings ) ;
46 }
47 /*--------------------------------------------------------------------------*/
48 double getDoubleFromStack( int stackPointer )
49 {
50   return *(stk( stackPointer ));
51 }
52 /*--------------------------------------------------------------------------*/
53 double * getDoubleMatrixFromStack( int stackPointer )
54 {
55   return stk( stackPointer ) ;
56 }
57 /*--------------------------------------------------------------------------*/
58 void copyDoubleVectorFromStack( int stackPointer, double dest[], int nbElement )
59
60   doubleArrayCopy( dest, getDoubleMatrixFromStack( stackPointer ), nbElement ) ;
61 }
62 /*--------------------------------------------------------------------------*/
63 void copyDoubleVectorToIntFromStack( int stackPointer, int dest[], int nbElement )
64
65   int i ;
66   double * values = getDoubleMatrixFromStack( stackPointer ) ;
67   for ( i = 0 ; i < nbElement ; i++ )
68   {
69     dest[i] = (int) values[i] ;
70   }
71 }
72 /*--------------------------------------------------------------------------*/
73 double * createCopyDoubleVectorFromStack( int stackPointer, int nbElement )
74 {
75   double * res = MALLOC( nbElement * sizeof(double) ) ;
76   if ( res == NULL )
77   {
78     return NULL ;
79   }
80   copyDoubleVectorFromStack( stackPointer, res, nbElement ) ;
81   return res ;
82 }
83 /*--------------------------------------------------------------------------*/
84 char * getStringFromStack( int stackPointer )
85 {
86   return cstk( stackPointer ) ;
87 }
88 /*--------------------------------------------------------------------------*/
89 char ** getStringMatrixFromStack( int stackPointer )
90 {
91   /* strange but it was taken from sci_set */
92   return (char **) stackPointer ;
93 }
94 /*--------------------------------------------------------------------------*/
95 char ** createCopyStringMatrixFromStack( int stackPointer, int nbElement )
96 {
97   int i ;
98   char ** res    = MALLOC( nbElement * sizeof(char *) ) ;
99   char ** values = getStringMatrixFromStack( stackPointer ) ;
100   
101   if ( res == NULL )
102   {
103     return NULL ;
104   }
105
106   for ( i = 0 ; i < nbElement ; i++ )
107   {
108     int size =  (int)strlen( values[i] ) + 1 ;
109     res[i] = MALLOC( size * sizeof(char) ) ;
110
111     if ( res[i] == NULL )
112     {
113       /* deallocate what have been allocated */
114       int j ;
115       for ( j = 0 ; j < i ; j++ )
116       {
117         FREE( res[j] ) ;
118       }
119       FREE( res ) ;
120       return NULL ;
121     }
122
123     strcpy( res[i], values[i] ) ;
124   }
125
126   return res ;
127
128 }
129 /*--------------------------------------------------------------------------*/
130 unsigned long getHandleFromStack( int stackPointer )
131 {
132   return (unsigned long) *(hstk( stackPointer )) ;
133 }
134 /*--------------------------------------------------------------------------*/
135 BOOL isStringParamEqual( int stackPointer, const char * str )
136 {
137   if ( strcmp( getStringFromStack( stackPointer ), str ) == 0 )
138   {
139     return TRUE ;
140   }
141   else
142   {
143     return FALSE ;
144   }
145 }
146 /*--------------------------------------------------------------------------*/
147 /*--------------------------------------------------------------------------*/
148 int getStackListNbElement( int paramNum )
149 {
150   int nbRow        = 0 ;
151   int nbCol        = 0 ;
152   int stackPointer = 0 ;
153
154   GetRhsVar( paramNum,TYPED_LIST_DATATYPE, &nbRow, &nbCol, &stackPointer );
155
156   return nbRow - 1 ;
157
158  }
159 /*--------------------------------------------------------------------------*/
160 AssignedList * createAssignedList( int paramNum, int nbElement )
161 {
162   AssignedList * newList = NULL ;
163   int nbRow = 0 ;
164   int nbCol = 0 ;
165
166   newList = MALLOC( sizeof(AssignedList) ) ;
167
168   if ( newList == NULL )
169   {
170     return NULL ;
171   }
172
173   newList->nbElement   = nbElement + 1 ;
174   newList->curElement  = 2 ; /* begin with 1 and 1 are the names */
175   newList->paramNumber = paramNum ;
176
177   /* get the stack pointer */
178   GetRhsVar( paramNum,TYPED_LIST_DATATYPE, &nbRow, &nbCol, &(newList->stackPointer) );
179
180   /* check the size */
181   if ( nbRow != newList->nbElement || nbCol != 1 )
182   {
183     sciprint("Wrong size for tlist.\n") ;
184     return NULL ;
185   }
186   return newList ;
187 }
188 /*--------------------------------------------------------------------------*/
189 void destroyAssignedList( AssignedList * list )
190 {
191   FREE( list ) ;
192 }
193 /*--------------------------------------------------------------------------*/
194 int getAssignedListNbElement( AssignedList * list )
195 {
196   return list->nbElement - 1 ;
197 }
198 /*--------------------------------------------------------------------------*/
199 void rewindAssignedList( AssignedList * list )
200 {
201   list->curElement = 2 ;
202 }
203 /*--------------------------------------------------------------------------*/
204 BOOL isListCurrentElementDoubleMatrix( AssignedList * list )
205 {
206   return ( ElementType( list->paramNumber, list->curElement ) == 1 ) ;
207 }
208 /*--------------------------------------------------------------------------*/
209 BOOL isListCurrentElementStringMatrix( AssignedList * list )
210 {
211   return ( ElementType( list->paramNumber, list->curElement ) == 10 ) ;
212 }
213 /*--------------------------------------------------------------------------*/
214 BOOL isListCurrentElementEmptyMatrix( AssignedList * list )
215 {
216   int nbRow = 0 ;
217   int nbCol = 0 ;
218
219   if ( !isListCurrentElementDoubleMatrix( list ) )
220   {
221     /* empty matrix is a double matrix */
222     return FALSE ;
223   }
224
225   getDoubleMatrixFromList( list, list->curElement, &nbRow, &nbCol ) ;
226
227   if ( nbRow * nbCol == 0 )
228   {
229     return TRUE ;
230   }
231
232   return FALSE ;
233
234 }
235 /*--------------------------------------------------------------------------*/
236 double * getDoubleMatrixFromList( AssignedList * list, int rank, int * nbRow, int * nbCol )
237 {
238   int valueStackPointer = 0 ;
239   GetListRhsVar( list->paramNumber, rank,MATRIX_OF_DOUBLE_DATATYPE, nbRow, nbCol, &valueStackPointer );
240   
241   return getDoubleMatrixFromStack( valueStackPointer ) ;
242 }
243 /*--------------------------------------------------------------------------*/
244 char ** getStringMatrixFromList( AssignedList * list, int rank, int * nbRow, int * nbCol )
245 {
246   int valueStackPointer = 0 ;
247   GetListRhsVar( list->paramNumber, rank,MATRIX_OF_STRING_DATATYPE, nbRow, nbCol, &valueStackPointer );
248
249   return getStringMatrixFromStack( valueStackPointer ) ;
250 }
251 /*--------------------------------------------------------------------------*/
252 double * getCurrentDoubleMatrixFromList( AssignedList * list, int * nbRow, int * nbCol )
253 {
254   double * res = NULL ;
255   if ( list->curElement > list->nbElement )
256   {
257     *nbRow = 0 ;
258     *nbCol = 0 ;
259     return NULL ;
260   }
261
262   res = getDoubleMatrixFromList( list, list->curElement, nbRow, nbCol ) ;
263   list->curElement++ ;
264   return res ;
265 }
266 /*--------------------------------------------------------------------------*/
267 char ** getCurrentStringMatrixFromList( AssignedList * list, int * nbRow, int * nbCol )
268 {
269   char ** res = NULL ;
270   if ( list->curElement > list->nbElement )
271   {
272     *nbRow = 0 ;
273     *nbCol = 0 ;
274     return NULL ;
275   }
276
277   res = getStringMatrixFromList( list, list->curElement, nbRow, nbCol ) ;
278   list->curElement++ ;
279   return res ;
280
281 }
282 /*--------------------------------------------------------------------------*/
283 double * createCopyDoubleMatrixFromList( AssignedList * list, int * nbRow, int * nbCol )
284 {
285   /* get the matrix */
286   double * stackValues = getCurrentDoubleMatrixFromList( list, nbRow, nbCol ) ;
287   int nbElement = (*nbRow) * (*nbCol) ;
288
289   double * copyMatrix = NULL ;
290
291   if ( nbElement == 0 )
292   {
293     return NULL ;
294   }
295
296   /* copy */
297
298   copyMatrix = MALLOC( (*nbRow) * (*nbCol) * sizeof( double ) ) ;
299
300   if ( copyMatrix == NULL )
301   { 
302     *nbRow = -1 ;
303     *nbCol = -1 ;
304     return NULL ;
305   }
306
307   doubleArrayCopy( copyMatrix, stackValues, nbElement ) ;
308
309   return copyMatrix ;
310
311 }
312 /*--------------------------------------------------------------------------*/
313 char ** createCopyStringMatrixFromList( AssignedList * list, int * nbRow, int * nbCol )
314 {
315   char ** stackValues = NULL; 
316   int nbElement = (*nbRow) * (*nbCol) ;
317
318   if ( nbElement == 0 )
319   {
320     return NULL ;
321   }
322
323   /* get the matrix */
324   stackValues = getCurrentStringMatrixFromList( list, nbRow, nbCol ) ;
325
326   return createStringArrayCopy( stackValues, nbElement ) ;
327 }
328 /*--------------------------------------------------------------------------*/