Fix plot2d3('enn', 1, 1:10) and plot2d3('enn', 1, abs(1:10))
[scilab.git] / scilab / modules / graphics / src / c / GetCommandArg.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2006 - INRIA - Fabrice Leray
4  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
5  * Copyright (C) 2009 - INRIA - Pierre Lando
6  * Copyright (C) 2011 - DIGITEO - Manuel Juliachs
7  *
8  * Copyright (C) 2012 - 2016 - Scilab Enterprises
9  *
10  * This file is hereby licensed under the terms of the GNU GPL v2.0,
11  * pursuant to article 5.3.4 of the CeCILL v.2.1.
12  * This file was originally licensed under the terms of the CeCILL v2.1,
13  * and continues to be available under such terms.
14  * For more information, see the COPYING file which you should have received
15  * along with this program.
16  *
17  */
18
19 /*------------------------------------------------------------------------*/
20 /* file: GetCommandArg.h                                                  */
21 /* desc : tools to retrieve parameters within the command line for        */
22 /*        graphic routines.                                               */
23 /*------------------------------------------------------------------------*/
24
25 #include <string.h>
26 #include "GetCommandArg.h"
27 #include "GetProperty.h"
28 #include "DefaultCommandArg.h"
29 #include "CurrentSubwin.h"
30 #include "localization.h"
31 #include "Scierror.h"
32 #include "BuildObjects.h"
33 #include "api_scilab.h"
34 #include "sci_malloc.h"
35
36 static char logFlagsCpy[3] ; /* real logflags may use either this or the stack */
37
38 /*--------------------------------------------------------------------------*/
39 /* get_style */
40 /*--------------------------------------------------------------------------*/
41 int get_style_arg(void* _pvCtx, char *fname, int pos, int n1, rhs_opts opts[], int ** style)
42 {
43     int m = 0, n = 0, first_opt = FirstOpt(_pvCtx), kopt = 0, un = 1, ix = 0, i = 0, l1 = 0;
44
45     if ( pos < first_opt ) /* regular argument  */
46     {
47         int* piAddr = 0;
48         int iType = 0;
49         int* piData = NULL;
50         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
51         getVarType(_pvCtx, piAddr, &iType);
52
53         if (iType)
54         {
55             getMatrixOfDoubleAsInteger(_pvCtx, piAddr, &m, &n, &piData);
56             if (m * n < n1)
57             {
58                 Scierror(999, _("%s: Wrong size for input argument #%d: %d < %d expected.\n"), fname, pos, m * n, n1);
59                 return 0;
60             }
61
62             if ( n1 == 1 && m * n == 1 )
63             {
64                 *style = (int*)MALLOC(2 * sizeof(int));
65                 (*style)[0] = piData[0];
66                 (*style)[1] = 1;
67             }
68             else
69             {
70                 *style = (int*)MALLOC(m * n * sizeof(int));
71                 for (i = 0; i < m * n; i++)
72                 {
73                     (*style)[i] = piData[i];
74                 }
75             }
76         }
77         else /* zero type argument --> default value */
78         {
79             ix = Max(n1, 2);
80             *style = (int*)MALLOC(ix * sizeof(int));
81             (*style)[1] = 1;
82
83             for ( i = 0 ; i < n1 ; ++i )
84             {
85                 (*style)[i] = i + 1;
86             }
87         }
88     }
89     else if ((kopt = FindOpt(_pvCtx, "style", opts)) >= 0)
90     {
91         /* optinal argument: style=value */
92         int* piData = NULL;
93
94         getMatrixOfDoubleAsInteger(_pvCtx, opts[kopt].piAddr, &m, &n, &piData);
95         if (m * n < n1)
96         {
97             Scierror(999, _("%s: Wrong size for input argument #%d: %d < %d expected.\n"), fname, kopt, m * n, n1);
98             return 0;
99         }
100
101         if (n1 == 1 && m * n == 1)
102         {
103             *style = (int*)MALLOC(2 * sizeof(int));
104             (*style)[0] = piData[0];
105             (*style)[1] = 1;
106         }
107         else
108         {
109             *style = (int*)MALLOC(m * n * sizeof(int));
110             for (i = 0; i < m * n; i++)
111             {
112                 (*style)[i] = piData[i];
113             }
114         }
115     }
116     else /* unspecified argument --> default value */
117     {
118         ix = Max(n1, 2);
119         *style = (int*)MALLOC(ix * sizeof(int));
120         (*style)[1] = 1;
121
122         for (i = 0 ; i < n1 ; ++i)
123         {
124             (*style)[i] = i + 1;
125         }
126     }
127
128     return 1;
129 }
130 /*--------------------------------------------------------------------------*/
131 /* get_rect */
132 /*--------------------------------------------------------------------------*/
133 int get_rect_arg(void* _pvCtx, char *fname, int pos, rhs_opts opts[], double ** rect)
134 {
135     int m, n, first_opt = FirstOpt(_pvCtx), kopt, i;
136
137     if (pos < first_opt)
138     {
139         int* piAddr = 0;
140         int iType = 0;
141         double* pdblData = NULL;
142         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
143         getVarType(_pvCtx, piAddr, &iType);
144
145         if (iType)
146         {
147             getMatrixOfDouble(_pvCtx, piAddr, &m, &n, &pdblData);
148             if (m * n != 4)
149             {
150                 Scierror(999, "%s: Wrong size for input argument #%d: %d expected\n", fname, pos, 4);
151                 return 0;
152             }
153
154             *rect = pdblData;
155
156             for (i = 0; i < 4; i++)
157             {
158                 if (finite((*rect)[i]) == 0)
159                 {
160                     Scierror(999, "%s: Wrong values (Nan or Inf) for input argument: %d finite values expected\n", fname, 4);
161                     return 0;
162                 }
163             }
164         }
165         else
166         {
167             /** global value can be modified  **/
168             double zeros[4] = { 0.0, 0.0, 0.0, 0.0 };
169             setDefRect(zeros);
170             *rect = getDefRect();
171         }
172     }
173     else if ((kopt = FindOpt(_pvCtx, "rect", opts)) >= 0) /* named argument: rect=value */
174     {
175         double* pdblData = NULL;
176         getMatrixOfDouble(_pvCtx, opts[kopt].piAddr, &m, &n, &pdblData);
177         if (m * n != 4)
178         {
179             Scierror(999, "%s: Wrong size for input argument #%d: %d expected\n", fname, kopt, 4);
180             return 0;
181         }
182
183         *rect = pdblData;
184
185         for (i = 0; i < 4; i++)
186         {
187             if (finite((*rect)[i]) == 0)
188             {
189                 Scierror(999, "%s: Wrong values (Nan or Inf) for input argument: %d finite values expected\n", fname, 4);
190                 return 0;
191             }
192         }
193     }
194     else
195     {
196         /** global value can be modified  **/
197         double zeros[4] = { 0.0, 0.0, 0.0, 0.0 };
198         setDefRect(zeros);
199         *rect = getDefRect();
200     }
201
202     return 1;
203 }
204 /*--------------------------------------------------------------------------*/
205 int get_strf_arg(void* _pvCtx, char *fname, int pos, rhs_opts opts[], char ** strf)
206 {
207     int first_opt = FirstOpt(_pvCtx), kopt;
208
209     if (pos < first_opt)
210     {
211         int* piAddr = 0;
212         int iType = 0;
213         char* pstData = NULL;
214         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
215         getVarType(_pvCtx, piAddr, &iType);
216         if (iType == 0)
217         {
218             // For example: grayplot(x,y,m,);
219             reinitDefStrfN();
220             *strf = getDefStrf();
221             return 1;
222         }
223         else if (iType != 10)
224         {
225             Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, pos);
226             return 0;
227         }
228
229         if (getAllocatedSingleString(_pvCtx, piAddr, &pstData))
230         {
231             return 0;
232         }
233
234         if ((int)strlen(pstData) != 3)
235         {
236             Scierror(999, _("%s: Wrong size for input argument #%d: String of %d characters expected.\n"), fname, pos, 3);
237             freeAllocatedSingleString(pstData);
238             return 0;
239         }
240         *strf = pstData;
241     }
242     else if ((kopt = FindOpt(_pvCtx, "strf", opts)) >= 0)
243     {
244         char* pstData = NULL;
245         int iType = 0;
246         getVarType(_pvCtx, opts[kopt].piAddr, &iType);
247         if (iType != 10)
248         {
249             Scierror(999, _("%s: Wrong type for input argument #%d: String expected.\n"), fname, pos);
250             return 0;
251         }
252
253         if (getAllocatedSingleString(_pvCtx, opts[kopt].piAddr, &pstData))
254         {
255             return 0;
256         }
257
258         if ((int)strlen(pstData) != 3)
259         {
260             Scierror(999, _("%s: Wrong size for input argument #%d: String of %d characters expected.\n"), fname, kopt, 3);
261             freeAllocatedSingleString(pstData);
262             return 0;
263         }
264         *strf = pstData;
265     }
266     else
267     {
268         /* def value can be changed */
269         reinitDefStrfN();
270         *strf = getDefStrf();
271     }
272     return 1;
273 }
274
275 /*--------------------------------------------------------------------------*/
276 int get_legend_arg(void* _pvCtx, char *fname, int pos, rhs_opts opts[], char ** legend)
277 {
278     int first_opt = FirstOpt(_pvCtx), kopt;
279
280     if (pos < first_opt)
281     {
282         int* piAddr = 0;
283         int iType = 0;
284         char* pstData = NULL;
285         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
286         getVarType(_pvCtx, piAddr, &iType);
287
288         if (iType)
289         {
290             if (getAllocatedSingleString(_pvCtx, piAddr, &pstData))
291             {
292                 return 0;
293             }
294             *legend = pstData;
295         }
296         else
297         {
298             *legend = getDefLegend();
299         }
300     }
301     else if ((kopt = FindOpt(_pvCtx, "leg", opts)) >= 0)
302     {
303         char* pstData = NULL;
304         if (getAllocatedSingleString(_pvCtx, opts[kopt].piAddr, &pstData))
305         {
306             return 0;
307         }
308         *legend = pstData;
309     }
310     else
311     {
312         *legend = getDefLegend();
313     }
314     return 1;
315 }
316 /*--------------------------------------------------------------------------*/
317 /**
318  * retrieve the labels from the command line and store them into labels
319  */
320 int get_labels_arg(void* _pvCtx, char *fname, int pos, rhs_opts opts[], char ** labels)
321 {
322     int first_opt = FirstOpt(_pvCtx), kopt;
323
324     if (pos < first_opt)
325     {
326         int* piAddr = 0;
327         int iType = 0;
328         char* pstData = NULL;
329         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
330         getVarType(_pvCtx, piAddr, &iType);
331
332         if (iType)
333         {
334             if (getAllocatedSingleString(_pvCtx, piAddr, &pstData))
335             {
336                 return 0;
337             }
338             *labels = pstData;
339         }
340         else
341         {
342             /* jb silvy 03/2006 */
343             /* do not change the legend if one already exists */
344             if (sciGetLegendDefined(getOrCreateDefaultSubwin()))
345             {
346                 *labels = NULL;
347             }
348             else
349             {
350                 *labels = getDefLegend();
351             }
352         }
353     }
354     else if ((kopt = FindOpt(_pvCtx, "leg", opts)) >= 0)
355     {
356         char* pstData = NULL;
357         if (getAllocatedSingleString(_pvCtx, opts[kopt].piAddr, &pstData))
358         {
359             return 0;
360         }
361         *labels = pstData;
362     }
363     else
364     {
365         /* jb silvy 03/2006 */
366         /* do not change the legend if one already exists */
367         if (sciGetLegendDefined(getOrCreateDefaultSubwin()))
368         {
369             *labels = NULL;
370         }
371         else
372         {
373             *labels = getDefLegend();
374         }
375     }
376     return 1;
377 }
378
379 /*--------------------------------------------------------------------------*/
380 int get_nax_arg(void* _pvCtx, int pos, rhs_opts opts[], int ** nax, BOOL * flagNax)
381 {
382     int i, m, n, first_opt = FirstOpt(_pvCtx), kopt;
383
384     if (pos < first_opt)
385     {
386         int* piAddr = 0;
387         int iType = 0;
388         int* piData = NULL;
389         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
390         getVarType(_pvCtx, piAddr, &iType);
391
392         if (iType)
393         {
394             getMatrixOfDoubleAsInteger(_pvCtx, piAddr, &m, &n, &piData);
395             if (n * m != 4)
396             {
397                 return 1;
398             }
399
400             for (i = 0 ; i < 4; ++i)
401             {
402                 // When i = 1 or 3 we talk about the number of ticks, this value can be -1 to say 'AutoTicks'
403                 piData[i] = Max(piData[i], -(i % 2));
404             }
405             *nax = piData;
406             *flagNax = TRUE;
407         }
408         else
409         {
410             *nax = getDefNax();
411             *flagNax = FALSE;
412         }
413     }
414     else if ((kopt = FindOpt(_pvCtx, "nax", opts)) >= 0)
415     {
416         int* piData = NULL;
417
418         getMatrixOfDoubleAsInteger(_pvCtx, opts[kopt].piAddr, &m, &n, &piData);
419         if (m * n != 4)
420         {
421             return 1;
422         }
423
424         for (i = 0 ; i < 4; ++i)
425         {
426             // When i = 1 or 3 we talk about the number of ticks, this value can be -1 to say 'AutoTicks'
427             piData[i] = Max(piData[i], -(i % 2));
428         }
429         *nax = piData;
430         *flagNax = TRUE;
431     }
432     else
433     {
434         *nax = getDefNax();
435         *flagNax = FALSE;
436     }
437     return 1;
438 }
439
440
441 /*--------------------------------------------------------------------------*/
442 int get_zminmax_arg(void* _pvCtx, char *fname, int pos, rhs_opts opts[], double ** zminmax)
443 {
444     int m, n, first_opt = FirstOpt(_pvCtx), kopt;
445
446     if (pos < first_opt)
447     {
448         int* piAddr = 0;
449         int iType = 0;
450         double* pdblData = NULL;
451         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
452         getVarType(_pvCtx, piAddr, &iType);
453
454         if (iType)
455         {
456             getMatrixOfDouble(_pvCtx, piAddr, &m, &n, &pdblData);
457             if (m * n != 2)
458             {
459                 Scierror(999, "%s: Wrong size for input argument #%d: %d expected\n", fname, pos, 2);
460                 return 0;
461             }
462             *zminmax = pdblData;
463         }
464         else
465         {
466             /** global value can be modified  **/
467             double zeros[2] = { 0.0, 0.0 };
468             setDefZminMax(zeros);
469             *zminmax = getDefZminMax();
470         }
471     }
472     else if ((kopt = FindOpt(_pvCtx, "zminmax", opts)) >= 0) /* named argument: rect=value */
473     {
474         double* pdblData = NULL;
475         getMatrixOfDouble(_pvCtx, opts[kopt].piAddr, &m, &n, &pdblData);
476         if (m * n != 2)
477         {
478             Scierror(999, "%s: Wrong size for input argument #%d: %d expected\n", fname, kopt, 2);
479             return 0;
480         }
481         *zminmax = pdblData;
482     }
483     else
484     {
485         /** global value can be modified  **/
486         double zeros[2] = { 0.0, 0.0 };
487         setDefZminMax(zeros);
488         *zminmax = getDefZminMax();
489     }
490
491     return 1;
492 }
493
494 /*--------------------------------------------------------------------------*/
495 int get_colminmax_arg(void* _pvCtx, char *fname, int pos, rhs_opts opts[], int ** colminmax)
496 {
497     int m, n, first_opt = FirstOpt(_pvCtx), kopt;
498
499     if (pos < first_opt)
500     {
501         int* piAddr = 0;
502         int iType = 0;
503         int* piData = NULL;
504         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
505         getVarType(_pvCtx, piAddr, &iType);
506
507         if (iType)
508         {
509             getMatrixOfDoubleAsInteger(_pvCtx, piAddr, &m, &n, &piData);
510             if (m * n != 2)
511             {
512                 return 1;
513             }
514             *colminmax = piData;
515         }
516         else
517         {
518             /** global value can be modified  **/
519             int zeros[2] = { 0, 0 };
520             setDefColMinMax(zeros);
521             *colminmax = getDefColMinMax();
522         }
523     }
524     else if ((kopt = FindOpt(_pvCtx, "colminmax", opts)) >= 0)
525     {
526         int* piData = NULL;
527
528         getMatrixOfDoubleAsInteger(_pvCtx, opts[kopt].piAddr, &m, &n, &piData);
529         if (m * n != 2)
530         {
531             return 1;
532         }
533         *colminmax = piData;
534     }
535     else
536     {
537         /** global value can be modified  **/
538         int zeros[2] = { 0, 0 };
539         setDefColMinMax(zeros);
540         *colminmax = getDefColMinMax();
541     }
542     return 1;
543 }
544
545 /*--------------------------------------------------------------------------*/
546 int get_colout_arg(void* _pvCtx, char *fname, int pos, rhs_opts opts[], int ** colout)
547 {
548     int m, n, first_opt = FirstOpt(_pvCtx), kopt;
549
550     if (pos < first_opt)
551     {
552         int* piAddr = 0;
553         int iType = 0;
554         int* piData = NULL;
555         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
556         getVarType(_pvCtx, piAddr, &iType);
557
558         if (iType)
559         {
560             getMatrixOfDoubleAsInteger(_pvCtx, piAddr, &m, &n, &piData);
561             if (m * n != 2)
562             {
563                 return 1;
564             }
565             *colout = piData;
566         }
567         else
568         {
569             /** global value can be modified  **/
570             int newDefCO[2] = { -1, -1 };
571             setDefColOut(newDefCO);
572             *colout = getDefColOut();
573         }
574     }
575     else if ((kopt = FindOpt(_pvCtx, "colout", opts)) >= 0)
576     {
577         int* piData = NULL;
578
579         getMatrixOfDoubleAsInteger(_pvCtx, opts[kopt].piAddr, &m, &n, &piData);
580         if (m * n != 2)
581         {
582             return 1;
583         }
584         *colout = piData;
585     }
586     else
587     {
588         /** global value can be modified  **/
589         int newDefCO[2] = { -1, -1 };
590         setDefColOut(newDefCO);
591         *colout = getDefColOut();
592     }
593     return 1;
594 }
595 /*--------------------------------------------------------------------------*/
596 int get_with_mesh_arg(void* _pvCtx, char *fname, int pos, rhs_opts opts[], BOOL * withMesh)
597 {
598     int first_opt = FirstOpt(_pvCtx), kopt;
599
600     if (pos < first_opt)
601     {
602         int* piAddr = 0;
603         int iType = 0;
604         int iData = 0;
605         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
606         getVarType(_pvCtx, piAddr, &iType);
607
608         if (iType)
609         {
610             getScalarBoolean(_pvCtx, piAddr, &iData);
611             *withMesh = iData;
612         }
613         else
614         {
615             /** global value can be modified  **/
616             setDefWithMesh(FALSE);
617             *withMesh = getDefWithMesh();
618         }
619     }
620     else if ((kopt = FindOpt(_pvCtx, "mesh", opts)) >= 0)
621     {
622         int iData = 0;
623
624         getScalarBoolean(_pvCtx, opts[kopt].piAddr, &iData);
625         *withMesh = iData;
626     }
627     else
628     {
629         /** global value can be modified  **/
630         setDefWithMesh(FALSE);
631         *withMesh = getDefWithMesh();
632     }
633     return 1;
634 }
635
636 /*--------------------------------------------------------------------------*/
637 int get_logflags_arg(void* _pvCtx, char *fname, int pos, rhs_opts opts[], char ** logFlags)
638 {
639     int kopt = 0;
640     int* piAddr = NULL;
641
642     int iLog = 0;
643     char* pstLog = NULL;
644     if (pos < FirstOpt(_pvCtx)) //input argument  */
645     {
646         //no idea of the real goal of this, how input var can have type == 0 Oo
647         if (getInputArgumentType(_pvCtx, pos) == 0)
648         {
649             *logFlags = getDefLogFlags();
650             return 1;
651         }
652
653         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
654     }
655     else if ((kopt = FindOpt(_pvCtx, "logflag", opts)) >= 0)//optional argument
656     {
657         piAddr = opts[kopt].piAddr;
658     }
659     else
660     {
661         //take default value
662         *logFlags = getDefLogFlags();
663         return 1;
664     }
665
666     if (getAllocatedSingleString(_pvCtx, piAddr, &pstLog))
667     {
668         return 0;
669     }
670
671     iLog = (int)strlen(pstLog);
672     if (iLog != 2 && iLog != 3)
673     {
674         Scierror(999, "%s: Wrong size for input argument #%d: %d or %d expected\n", fname, pos, 2, 3);
675         freeAllocatedSingleString(pstLog);
676         return 0;
677     }
678
679     if (iLog == 2)
680     {
681         if ((pstLog[0] != 'l' && pstLog[0] != 'n') || (pstLog[1] != 'l' && pstLog[1] != 'n'))
682         {
683             //Err = pos;
684             SciError(116);
685             freeAllocatedSingleString(pstLog);
686             return 0;
687         }
688
689         logFlagsCpy[0] = 'g';
690         logFlagsCpy[1] = pstLog[0];
691         logFlagsCpy[2] = pstLog[1];
692         *logFlags = logFlagsCpy;
693     }
694     else //iLog == 3
695     {
696         if (((pstLog[0] != 'g') && (pstLog[0] != 'e') && (pstLog[0] != 'o')) ||
697                 (pstLog[1] != 'l' && pstLog[1] != 'n') ||
698                 (pstLog[2] != 'l' && pstLog[2] != 'n'))
699         {
700             //Err = pos;
701             SciError(116);
702             freeAllocatedSingleString(pstLog);
703             return 0;
704         }
705
706         logFlagsCpy[0] = pstLog[0];
707         logFlagsCpy[1] = pstLog[1];
708         logFlagsCpy[2] = pstLog[2];
709         *logFlags = logFlagsCpy;
710     }
711
712     freeAllocatedSingleString(pstLog);
713     return 1;
714 }
715 /*--------------------------------------------------------------------------*/
716 int get_optional_double_arg(void* _pvCtx, char* fname, int pos, char* name, double** value, int sz, rhs_opts opts[])
717 {
718     int m, n, first_opt = FirstOpt(_pvCtx), kopt;
719
720     if (pos < first_opt)
721     {
722         int* piAddr = 0;
723         int iType = 0;
724         double* pdblData = NULL;
725         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
726         getVarType(_pvCtx, piAddr, &iType);
727
728         if (iType)
729         {
730             getMatrixOfDouble(_pvCtx, piAddr, &m, &n, &pdblData);
731             if (m * n != sz)
732             {
733                 return 1;
734             }
735             *value = pdblData;
736         }
737     }
738     else if ((kopt = FindOpt(_pvCtx, name, opts)) >= 0)
739     {
740         double* pdblData = NULL;
741         getMatrixOfDouble(_pvCtx, opts[kopt].piAddr, &m, &n, &pdblData);
742         if (m * n != sz)
743         {
744             Scierror(999, "%s: Wrong size for input argument #%d: %d expected\n", fname, kopt, 4);
745             return 0;
746         }
747
748         *value = pdblData;
749     }
750     return 1;
751 }
752 /*--------------------------------------------------------------------------*/
753 int get_optional_int_arg(void* _pvCtx, char* fname, int pos, char* name, int** value, int sz, rhs_opts opts[])
754 {
755     int m, n, first_opt = FirstOpt(_pvCtx), kopt;
756
757     if (pos < first_opt)
758     {
759         int* piAddr = 0;
760         int iType = 0;
761         int* piData = NULL;
762         getVarAddressFromPosition(_pvCtx, pos, &piAddr);
763         getVarType(_pvCtx, piAddr, &iType);
764
765         if (iType)
766         {
767             getMatrixOfDoubleAsInteger(_pvCtx, piAddr, &m, &n, &piData);
768             if (m * n != sz)
769             {
770                 return 1;
771             }
772             *value = piData;
773         }
774     }
775     else if ((kopt = FindOpt(_pvCtx, name, opts)) >= 0)
776     {
777         int* piData = NULL;
778
779         getMatrixOfDoubleAsInteger(_pvCtx, opts[kopt].piAddr, &m, &n, &piData);
780         if (m * n < 1)
781         {
782             return 1;
783         }
784         *value = piData;
785     }
786     return 1;
787 }
788 /*--------------------------------------------------------------------------*/