GUI module ported to api_scilab. test_run("gui") 68/9368/7
Cedric Delamarre [Tue, 2 Oct 2012 16:13:26 +0000 (18:13 +0200)]
Change-Id: I838e9635fec591aa9cd25af3f7eb79d78bf04032

51 files changed:
scilab/modules/graphics/sci_gateway/c/sci_set.c
scilab/modules/graphics/src/c/getHandleProperty/set_anti_aliasing_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_arc_drawing_method_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_callback_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_clip_state_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_data_mapping_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_figure_style_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_format_n_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_grid_position_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_mark_size_unit_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_rotation_style_property.c
scilab/modules/graphics/src/c/getHandleProperty/set_text_box_mode_property.c
scilab/modules/gui/sci_gateway/c/sci_ClipBoard.c
scilab/modules/gui/sci_gateway/c/sci_delmenu.c
scilab/modules/gui/sci_gateway/c/sci_exportUI.c
scilab/modules/gui/sci_gateway/c/sci_getcallbackobject.c
scilab/modules/gui/sci_gateway/c/sci_helpbrowser.c
scilab/modules/gui/sci_gateway/c/sci_messagebox.c
scilab/modules/gui/sci_gateway/c/sci_progressionbar.c
scilab/modules/gui/sci_gateway/c/sci_setmenu.c
scilab/modules/gui/sci_gateway/c/sci_toolbar.c
scilab/modules/gui/sci_gateway/c/sci_uicontextmenu.c
scilab/modules/gui/sci_gateway/c/sci_uicontrol.c
scilab/modules/gui/sci_gateway/c/sci_uigetcolor.c
scilab/modules/gui/sci_gateway/c/sci_uigetdir.c [deleted file]
scilab/modules/gui/sci_gateway/c/sci_uigetfont.c
scilab/modules/gui/sci_gateway/c/sci_uimenu.c
scilab/modules/gui/sci_gateway/c/sci_uiwait.c
scilab/modules/gui/sci_gateway/c/sci_unsetmenu.c
scilab/modules/gui/sci_gateway/c/sci_waitbar.c
scilab/modules/gui/sci_gateway/c/sci_x_choice.c
scilab/modules/gui/sci_gateway/c/sci_x_choose.c
scilab/modules/gui/sci_gateway/c/sci_x_choose_modeless.c
scilab/modules/gui/sci_gateway/c/sci_x_dialog.c
scilab/modules/gui/sci_gateway/c/sci_x_mdialog.c
scilab/modules/gui/sci_gateway/cpp/sci_about.cpp
scilab/modules/gui/sci_gateway/cpp/sci_displaytree.cpp
scilab/modules/gui/sci_gateway/cpp/sci_fire_closing_finished.cpp
scilab/modules/gui/sci_gateway/cpp/sci_getinstalledlookandfeels.cpp
scilab/modules/gui/sci_gateway/cpp/sci_getlookandfeel.cpp
scilab/modules/gui/sci_gateway/cpp/sci_printfigure.cpp
scilab/modules/gui/sci_gateway/cpp/sci_printsetupbox.cpp
scilab/modules/gui/sci_gateway/cpp/sci_raise_window.cpp
scilab/modules/gui/sci_gateway/cpp/sci_setlookandfeel.cpp
scilab/modules/gui/sci_gateway/cpp/sci_toprint.cpp
scilab/modules/gui/sci_gateway/cpp/sci_uigetdir.cpp
scilab/modules/gui/sci_gateway/cpp/sci_uigetfile.cpp
scilab/modules/gui/sci_gateway/cpp/sci_uiputfile.cpp
scilab/modules/gui/sci_gateway/cpp/sci_usecanvas.cpp
scilab/modules/gui/src/cpp/displaytree.cpp
scilab/modules/gui/src/cpp/displaytree.hxx

index 42b0e37..3ba7b1c 100644 (file)
 #include "localization.h"
 #include "stricmp.h"
 #include "api_scilab.h"
-/*--------------------------------------------------------------------------*/
-static int sciSet(void* _pvCtx, char *pobjUID, char *marker, void* value, int valueType, int *numrow, int *numcol);
-
-/*--------------------------------------------------------------------------*/
-/**
- * Sets the value to the object
- */
-static int sciSet(void* _pvCtx, char *pobjUID, char *marker, void* value, int valueType, int *numrow, int *numcol)
-{
-    return callSetProperty(_pvCtx, pobjUID, value, valueType, *numrow, *numcol, marker);
-}
-
-/*--------------------------------------------------------------------------*/
-//for YaSp => modify all "set properties" function (use stack pointer : value)
-/*-----------------------------------------------------------
+/*--------------------------------------------------------------------------
  * sciset(choice-name,x1,x2,x3,x4,x5)
  * or   xset()
  *-----------------------------------------------------------*/
@@ -73,8 +59,7 @@ int sci_set(char *fname, unsigned long fname_len)
 
     if (isMListType(pvApiCtx, piAddr1) || isTListType(pvApiCtx, piAddr1))
     {
-        lw = 1 + Top - Rhs;
-        OverLoad(lw);
+        OverLoad(1);
         return 0;
     }
 
@@ -83,9 +68,8 @@ int sci_set(char *fname, unsigned long fname_len)
 
     if (isDoubleType(pvApiCtx, piAddr1))   /* tclsci handle */
     {
-        lw = 1 + Top - Rhs;
         /* call "set" for tcl/tk see tclsci/sci_gateway/c/sci_set.c */
-        OverLoad(lw);
+        OverLoad(1);
         return 0;
     }
     else                        /* others types */
@@ -123,8 +107,7 @@ int sci_set(char *fname, unsigned long fname_len)
 
                 if (isScalar(pvApiCtx, piAddr1) == FALSE)
                 {
-                    lw = 1 + Top - Rhs;
-                    OverLoad(lw);
+                    OverLoad(1);
                     return 0;
                 }
 
@@ -165,22 +148,20 @@ int sci_set(char *fname, unsigned long fname_len)
                             strcmp(pstProperty, "text") != 0 && stricmp(pstProperty, "string") != 0 &&
                             stricmp(pstProperty, "tooltipstring") != 0) /* Added for uicontrols */
                     {
-                        iRows3 = 1;
-                        iCols3 = 1;
                         getAllocatedSingleString(pvApiCtx, piAddr3, (char**)&_pvData);
-                        iCols3 = (int)strlen((char*)_pvData);
+                        iRows3 = (int)strlen((char*)_pvData);
+                        iCols3 = 1;
                     }
                     else
                     {
                         isMatrixOfString = 1;
                         getAllocatedMatrixOfString(pvApiCtx, piAddr3, &iRows3, &iCols3, (char***)&_pvData);
-                        //WARNING possible troubles !
                     }
                 }
                 else if (valueType == sci_list) /* Added for callbacks */
                 {
+                    iCols3 = 1;
                     getListItemNumber(pvApiCtx, piAddr3, &iRows3);
-                    //GetRhsVar(3, LIST_DATATYPE, &numrow3, &numcol3, &l3);
                     _pvData = (void*)piAddr3;         /* In this case l3 is the list position in stack */
                 }
                 break;
@@ -212,10 +193,9 @@ int sci_set(char *fname, unsigned long fname_len)
                     }
                     else
                     {
-                        iRows3 = 1;
-                        iCols3 = 1;
                         getAllocatedSingleString(pvApiCtx, piAddr2, (char**)&_pvData);
-                        iCols3 = (int)strlen((char*)_pvData);
+                        iRows3 = (int)strlen((char*)_pvData);
+                        iCols3 = 1;
                     }
                 }
                 break;
@@ -237,7 +217,20 @@ int sci_set(char *fname, unsigned long fname_len)
             }
 
             // Only set the property whitout doing anythig else.
-            setStatus = sciSet(pvApiCtx, pobjUID, pstProperty, _pvData, valueType, &iRows3, &iCols3);
+            //static int sciSet(void* _pvCtx, char *pobjUID, char *marker, void* value, int valueType, int *numrow, int *numcol)
+            setStatus = callSetProperty(pvApiCtx, pobjUID, _pvData, valueType, iRows3, iCols3, pstProperty);
+            if (valueType == sci_strings)
+            {
+                //free allacted data
+                if (isMatrixOfString == 1)
+                {
+                    freeAllocatedMatrixOfString(iRows3, iCols3, (char**)_pvData);
+                }
+                else
+                {
+                    freeAllocatedSingleString((char*)_pvData);
+                }
+            }
         }
         else
         {
@@ -279,7 +272,19 @@ int sci_set(char *fname, unsigned long fname_len)
 
                 if (bDoSet)
                 {
-                    sciSet(pvApiCtx, NULL, pstProperty, _pvData, valueType, &iRows3, &iCols3);
+                    setStatus = callSetProperty(pvApiCtx, NULL, _pvData, valueType, iRows3, iCols3, pstProperty);
+                    if (valueType == sci_strings)
+                    {
+                        //free allacted data
+                        if (isMatrixOfString == 1)
+                        {
+                            freeAllocatedMatrixOfString(iRows3, iCols3, (char**)_pvData);
+                        }
+                        else
+                        {
+                            freeAllocatedSingleString((char*)_pvData);
+                        }
+                    }
                 }
             }
             else
index aea6b25..3f3702a 100644 (file)
@@ -71,7 +71,6 @@ int set_anti_aliasing_property(void* _pvCtx, char* pobjUID, void* _pvData, int v
     }
 
     status = setGraphicObjectProperty(pobjUID, __GO_ANTIALIASING__, &quality, jni_int, 1);
-
     if (status == TRUE)
     {
         return SET_PROPERTY_SUCCEED;
index 07d00ff..49adbca 100644 (file)
@@ -57,7 +57,6 @@ int set_arc_drawing_method_property(void* _pvCtx, char* pobjUID, void* _pvData,
     }
 
     status = setGraphicObjectProperty(pobjUID, __GO_ARC_DRAWING_METHOD__, &arcDrawingMethod, jni_int, 1);
-
     if (status == TRUE)
     {
         return SET_PROPERTY_SUCCEED;
index 4d4331a..29d1799 100644 (file)
@@ -72,16 +72,16 @@ int set_callback_property(void* _pvCtx, char* pobjUID, void* _pvData, int valueT
         }
 
 
-        getMatrixOfStringInList(pvApiCtx, (int*)_pvData, 1, &iRows, &iCols, NULL, NULL);
+        getMatrixOfStringInList(pvApiCtx, (int*)_pvData, 2, &iRows, &iCols, NULL, NULL);
         if (iRows * iCols != 1)
         {
             Scierror(999, _("Wrong size for '%s' property: A string expected.\n"), "Callback");
             return SET_PROPERTY_ERROR;
         }
 
-        getMatrixOfStringInList(pvApiCtx, (int*)_pvData, 1, &iRows, &iCols, &iLen, NULL);
-        cbString = (char*)MALLOC(sizeof(char) * iLen);
-        getMatrixOfStringInList(pvApiCtx, (int*)_pvData, 1, &iRows, &iCols, &iLen, &cbString);
+        getMatrixOfStringInList(pvApiCtx, (int*)_pvData, 2, &iRows, &iCols, &iLen, NULL);
+        cbString = (char*)MALLOC(sizeof(char) * (iLen + 1));
+        getMatrixOfStringInList(pvApiCtx, (int*)_pvData, 2, &iRows, &iCols, &iLen, &cbString);
     }
     else
     {
@@ -97,11 +97,6 @@ int set_callback_property(void* _pvCtx, char* pobjUID, void* _pvData, int valueT
 
     status = setGraphicObjectProperty(pobjUID, __GO_CALLBACK__, cbString, jni_string, 1);
 
-    if (cbString)
-    {
-        FREE(cbString);
-    }
-
     if (status != TRUE)
     {
         Scierror(999, _("'%s' property does not exist for this handle.\n"), "Callback");
index c87fcb1..7e289cb 100644 (file)
@@ -62,7 +62,6 @@ int set_clip_state_property(void* _pvCtx, char* pobjUID, void* _pvData, int valu
         return SET_PROPERTY_ERROR;
     }
 
-    FREE(_pvData);
     status = setGraphicObjectProperty(pobjUID, __GO_CLIP_STATE__, &clipState, jni_int, 1);
 
     if (status == TRUE)
index 912a406..464c8db 100644 (file)
@@ -61,7 +61,6 @@ int set_data_mapping_property(void* _pvCtx, char* pobjUID, void* _pvData, int va
         return SET_PROPERTY_ERROR;
     }
 
-    FREE(_pvData);
     status = setGraphicObjectProperty(pobjUID, __GO_DATA_MAPPING__, &dataMapping, jni_int, 1);
 
     if (status == TRUE)
index a6e0b63..74c5c68 100644 (file)
@@ -56,7 +56,6 @@ int set_figure_style_property(void* _pvCtx, char* pobjUID, void* _pvData, int va
 
     }
 
-    FREE(_pvData);
     return SET_PROPERTY_ERROR;
 }
 /*------------------------------------------------------------------------*/
index d48be0d..29ba8c3 100644 (file)
@@ -47,7 +47,6 @@ int set_format_n_property(void* _pvCtx, char* pobjUID, void* _pvData, int valueT
     format = (char*)_pvData;
 
     status = setGraphicObjectProperty(pobjUID, __GO_FORMATN__, format, jni_string, 1);
-    FREE(_pvData);
     if (status == TRUE)
     {
         return SET_PROPERTY_SUCCEED;
index e5f0358..8db1c59 100644 (file)
@@ -55,7 +55,6 @@ int set_grid_position_property(void* _pvCtx, char* pobjUID, void* _pvData, int v
         return SET_PROPERTY_ERROR;
     }
 
-    FREE(_pvData);
     status = setGraphicObjectProperty(pobjUID, __GO_GRID_POSITION__, &position, jni_int, 1);
 
     if (status == TRUE)
index 89f7ffa..171f60f 100644 (file)
@@ -58,7 +58,6 @@ int set_mark_size_unit_property(void* _pvCtx, char* pobjUID, void* _pvData, int
 
     }
 
-    FREE(_pvData);
     status = setGraphicObjectProperty(pobjUID, __GO_MARK_SIZE_UNIT__, &markSizeUnit, jni_int, 1);
 
     if (status == TRUE)
index 9421ebc..7aa6582 100644 (file)
@@ -56,7 +56,6 @@ int set_rotation_style_property(void* _pvCtx, char* pobjUID, void* _pvData, int
         return SET_PROPERTY_ERROR;
     }
 
-    FREE(_pvData);
     status = setGraphicObjectProperty(pobjUID, __GO_ROTATION_TYPE__, &rotationStyle, jni_int, 1);
 
     if (status == TRUE)
index 31348ee..797a110 100644 (file)
@@ -68,7 +68,6 @@ int set_text_box_mode_property(void* _pvCtx, char* pobjUID, void* _pvData, int v
         return SET_PROPERTY_ERROR;
     }
 
-    FREE(_pvData);
     status[0] = setGraphicObjectProperty(pobjUID, __GO_TEXT_BOX_MODE__, &textBoxMode, jni_int, 1);
     status[1] = setGraphicObjectProperty(pobjUID, __GO_AUTO_DIMENSIONING__, &autoSize, jni_bool, 1);
 
index 1a5af2e..6c48698 100644 (file)
@@ -3,11 +3,11 @@
 * Copyright (C) 2005 - INRIA - Allan CORNET
 * Copyright (C) 2008 - INRIA - Vincent COUVERT
 * Copyright (C) 2010 - DIGITEO - Vincent COUVERT
-* 
+*
 * This file must be used under the terms of the CeCILL.
 * This source file is licensed as described in the file COPYING, which
 * you should have received as part of this distribution.  The terms
-* are also available at    
+* are also available at
 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 *
 */
@@ -16,7 +16,7 @@
 #include <stdlib.h>
 #include <stdio.h>
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "Scierror.h"
 #include "MALLOC.h"
 #include "sciprint.h"
 #include "strdup_windows.h"
 #endif
 /*--------------------------------------------------------------------------*/
-int sci_ClipBoard(char *fname,unsigned long l)
+int sci_ClipBoard(char *fname, unsigned long l)
 {
-    static int l1 = 0,n1 = 0,m1 = 0;
-    char *param1 = NULL, *param2 = NULL;
+    SciErr sciErr;
+
+    int* piAddr1   = NULL;
+    int* piAddrl1   = NULL;
+    int* piAddrStr  = NULL;
+    double* pdbll1  = NULL;
+    int* pil1       = NULL;
+
+    static int n1 = 0, m1 = 0;
+    char* param1 = NULL;
+    char* param2 = NULL;
 
-    Rhs=Max(0,Rhs);
-    CheckRhs(0,2);
-    CheckLhs(0,1);
+    nbInputArgument(pvApiCtx) = Max(0, nbInputArgument(pvApiCtx));
+    CheckInputArgument(pvApiCtx, 0, 2);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     if ( getScilabMode() != SCILAB_NWNI )
     {
         /*--------------------*/
         /* clipboard("paste") */
         /*--------------------*/
-        if (Rhs == 1)
+        if (nbInputArgument(pvApiCtx) == 1)
         {
-            if (GetType(1)==sci_strings)
+            if (checkInputArgumentType(pvApiCtx, 1, sci_strings))
             {
-                GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
-                param1=cstk(l1);
+                sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 1;
+                }
 
-                if ( ( strcmp(param1,"paste") == 0 ) || ( strcmp(param1,"pastespecial") == 0 ) )
+                // Retrieve a matrix of double at position 1.
+                if (getAllocatedSingleString(pvApiCtx, piAddrl1, &param1))
+                {
+                    Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+                    return 1;
+                }
+
+                if ( ( strcmp(param1, "paste") == 0 ) || ( strcmp(param1, "pastespecial") == 0 ) )
                 {
                     /* Use the Java clipboard (CallScilabBridge.java returns "" if clipbaord could not be read) */
                     char *output = getClipboardContents();
@@ -59,42 +79,61 @@ int sci_ClipBoard(char *fname,unsigned long l)
                     m1 = (int)strlen(output);
                     n1 = 1;
 
-                    CreateVarFromPtr(Rhs+ 1,STRING_DATATYPE, &m1, &n1, &output);
+                    if (createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, output))
+                    {
+                        freeAllocatedSingleString(param1);
+                        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                        return 1;
+                    }
+
                     /* TO DO a delete [] and not a FREE */
                     FREE(output);
-                    LhsVar(1)=Rhs+1;
+                    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
 
-                    PutLhsVar();       
+                    freeAllocatedSingleString(param1);
+                    ReturnArguments(pvApiCtx);
                     return TRUE;
                 }
                 else
                 {
-                    Scierror(999,_("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 1, "paste", "pastespecial");
+                    freeAllocatedSingleString(param1);
+                    Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 1, "paste", "pastespecial");
                     return FALSE;
                 }
             }
             else
             {
-                Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
                 return FALSE;
             }
-        } 
-
-        else if (Rhs == 2)
+        }
+        else if (nbInputArgument(pvApiCtx) == 2)
         {
-            if (GetType(1)==sci_strings)
+            if (checkInputArgumentType(pvApiCtx, 1, sci_strings))
             {
                 /* Get the first argument: should be "copy" or "do" */
-                GetRhsVar(1,STRING_DATATYPE,&m1,&n1,&l1);
-                param1=cstk(l1);
+                sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 1;
+                }
 
-                if (n1!=1)
+                // Retrieve a matrix of double at position 1.
+                if (getAllocatedSingleString(pvApiCtx, piAddrl1, &param1))
                 {
-                    Scierror(999,_("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 1, "do","copy");
+                    Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+                    return 1;
+                }
+
+                if (( strcmp(param1, "do") != 0 ) && ( strcmp(param1, "copy") != 0 ))
+                {
+                    freeAllocatedSingleString(param1);
+                    Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 1, "do", "copy");
                     return FALSE;
                 }
 
-                if (GetType(2)==sci_strings)
+                if (checkInputArgumentType(pvApiCtx, 2, sci_strings))
                 {
 
                     /*-------------------------------------------*/
@@ -102,37 +141,61 @@ int sci_ClipBoard(char *fname,unsigned long l)
                     /*-------------------------------------------*/
 
                     /* @TODO : should be remplaced by an enum */
-                    if ( strcmp(param1,"do") == 0 )
+                    if ( strcmp(param1, "do") == 0 )
                     {
-                        GetRhsVar(2,STRING_DATATYPE,&m1,&n1,&l1);
-                        param2=cstk(l1);
+                        freeAllocatedSingleString(param1);
+
+                        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl1);
+                        if (sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 1;
+                        }
 
-                        if ( strcmp(param2,"paste") == 0 )
+                        // Retrieve a matrix of double at position 2.
+                        if (getAllocatedSingleString(pvApiCtx, piAddrl1, &param2))
+                        {
+                            Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
+                            return 1;
+                        }
+
+                        if ( strcmp(param2, "paste") == 0 )
                         {
                             /* Call Java to do the job */
                             pasteClipboardIntoConsole();
                         }
-                        else if ( strcmp(param2,"copy") == 0 )
+                        else if ( strcmp(param2, "copy") == 0 )
                         {
                             /* Call Java to do the job */
                             copyConsoleSelection();
                         }
-                        else if ( strcmp(param2,"empty") == 0 )
+                        else if ( strcmp(param2, "empty") == 0 )
                         {
                             /* Call Java to do the job */
                             emptyClipboard();
                         }
                         else
                         {
-                            Scierror(999,_("%s: Wrong value for input argument #%d: '%s', '%s' or '%s' expected.\n"), fname, 2, "copy","paste","empty");
+                            freeAllocatedSingleString(param2);
+                            Scierror(999, _("%s: Wrong value for input argument #%d: '%s', '%s' or '%s' expected.\n"), fname, 2, "copy", "paste", "empty");
                             return FALSE;
                         }
 
-                        m1=0;
-                        n1=0;
-                        CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,  &m1, &n1, &l1);
-                        LhsVar(1)=Rhs+1;
-                        PutLhsVar();   
+                        m1 = 0;
+                        n1 = 0;
+
+                        freeAllocatedSingleString(param2);
+
+                        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &pdbll1);
+                        if (sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                            return 1;
+                        }
+
+                        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+                        ReturnArguments(pvApiCtx);
                         return TRUE;
                     }
 
@@ -140,17 +203,31 @@ int sci_ClipBoard(char *fname,unsigned long l)
                     /* clipboard("copy", data) */
                     /*-------------------------*/
 
-                    else if ( strcmp(param1,"copy") == 0 )
+                    else if ( strcmp(param1, "copy") == 0 )
                     {
                         char *TextToPutInClipboard = NULL;
                         char **Str = NULL;
                         int m2 = 0, n2 = 0;
 
-                        GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &m2, &n2, &Str);
+                        freeAllocatedSingleString(param1);
+
+                        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrStr);
+                        if (sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            return 1;
+                        }
+
+                        // Retrieve a matrix of string at position 2.
+                        if (getAllocatedMatrixOfString(pvApiCtx, piAddrStr, &m2, &n2, &Str))
+                        {
+                            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                            return 1;
+                        }
 
                         if (m2 * n2 == 1) /* Single line copy */
                         {
-                            TextToPutInClipboard=Str[0];
+                            TextToPutInClipboard = Str[0];
                             /* Call Java to do the job */
                             setClipboardContents(TextToPutInClipboard);
                         }
@@ -159,67 +236,78 @@ int sci_ClipBoard(char *fname,unsigned long l)
                             int i = 0, j = 0, l2 = 0;
                             char *TextToSendInClipboard = NULL;
                             int SizeofTextToSendInClipboard = 0;
-                            char **buffer = (char**)MALLOC( (m2 * n2)*sizeof(char *) );
+                            char **buffer = (char**)MALLOC( (m2 * n2) * sizeof(char *) );
                             if (buffer == NULL)
                             {
+
+                                freeAllocatedMatrixOfString(m2, n2, Str);
                                 Scierror(999, _("%s: No more memory.\n"), fname);
                                 return FALSE;
                             }
 
-                            for (i=0; i<m2; i++) 
+                            for (i = 0; i < m2; i++)
                             {
-                                for (j=0; j<n2; j++) 
+                                for (j = 0; j < n2; j++)
                                 {
-                                    SizeofTextToSendInClipboard = SizeofTextToSendInClipboard + (int)strlen(Str[j*m2+i]) + (int)strlen("\n") + (int)strlen(" ");
-                                    buffer[i*n2+j] = strdup(Str[j*m2+i]);
+                                    SizeofTextToSendInClipboard = SizeofTextToSendInClipboard + (int)strlen(Str[j * m2 + i]) + (int)strlen("\n") + (int)strlen(" ");
+                                    buffer[i * n2 + j] = strdup(Str[j * m2 + i]);
                                 }
                             }
 
-                            TextToSendInClipboard = (char*)MALLOC( (SizeofTextToSendInClipboard)*sizeof(char) );
+                            TextToSendInClipboard = (char*)MALLOC( (SizeofTextToSendInClipboard) * sizeof(char) );
                             if (TextToSendInClipboard == NULL)
                             {
+                                freeAllocatedMatrixOfString(m2, n2, Str);
                                 Scierror(999, _("%s: No more memory.\n"), fname);
                                 return FALSE;
                             }
+
                             strcpy(TextToSendInClipboard, "");
 
                             for (i = 0; i < m2; i++)
                             {
-                                for (j = 0; j < n2; j++) 
+                                for (j = 0; j < n2; j++)
                                 {
                                     strcat(TextToSendInClipboard, buffer[l2++]);
-                                    strcat(TextToSendInClipboard," ");
+                                    strcat(TextToSendInClipboard, " ");
+                                }
+                                if ( i != (m2 - 1) )
+                                {
+                                    strcat(TextToSendInClipboard, "\n");
                                 }
-                                if ( i != (m2 - 1) ) strcat(TextToSendInClipboard, "\n");
                             }
 
                             /* Call Java to do the job */
                             setClipboardContents(TextToSendInClipboard);
 
                             FREE(buffer);
-                            buffer=NULL;
+                            buffer = NULL;
 
                             FREE(TextToSendInClipboard);
-                            TextToSendInClipboard=NULL;
+                            TextToSendInClipboard = NULL;
                         }
 
-                        freeArrayOfString(Str,m2*n2);
+                        freeAllocatedMatrixOfString(m2, n2, Str);
                         m1 = 0;
                         n1 = 0;
-                        CreateVar(Rhs+1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-                        LhsVar(1) = Rhs+1;
-                        PutLhsVar();           
+
+                        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &pdbll1);
+                        if (sciErr.iErr)
+                        {
+                            printError(&sciErr, 0);
+                            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                            return 1;
+                        }
+
+                        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+                        ReturnArguments(pvApiCtx);
                         return TRUE;
                     }
-                    else
-                    {
-                        Scierror(999,_("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 1, "do","copy");
-                        return FALSE;
-                    }
                 }
                 else
                 {
-                    Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
+                    freeAllocatedSingleString(param1);
+                    Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
                     return FALSE;
                 }
             }
@@ -228,31 +316,57 @@ int sci_ClipBoard(char *fname,unsigned long l)
             /* clipboard(fignum, {"EMF","DIB"}) */
             /*----------------------------------*/
 
-            else if (GetType(1)==sci_matrix)
+            else if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))
             {
 
-                int num_win=-2;
+                int num_win = -2;
+
+                sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 1;
+                }
+
+                // Retrieve a matrix of double at position 1.
+                sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr1, &m1, &n1, &pil1);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                    return 1;
+                }
 
-                GetRhsVar(1,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l1);
-                num_win=*istk(l1);
+                num_win = pil1[0];
 
-                if (m1*n1!=1)
+                if (m1*n1 != 1)
                 {
-                    Scierror(999,_("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1);
+                    Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1);
                     return FALSE;
                 }
 
-                if (GetType(2)==sci_strings)
+                if (checkInputArgumentType(pvApiCtx, 2, sci_strings))
                 {
-                    GetRhsVar(2,STRING_DATATYPE,&m1,&n1,&l1);
-                    param2=cstk(l1);
+                    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl1);
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 1;
+                    }
+
+                    // Retrieve a matrix of double at position 2.
+                    if (getAllocatedSingleString(pvApiCtx, piAddrl1, &param2))
+                    {
+                        Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
+                        return 1;
+                    }
 
-                    if ( ( strcmp(param2,"EMF") == 0 ) || ( strcmp(param2,"DIB") == 0 ) )
+                    if ( ( strcmp(param2, "EMF") == 0 ) || ( strcmp(param2, "DIB") == 0 ) )
                     {
-                        if (num_win>=0)
+                        if (num_win >= 0)
                         {
                             /* Call Java */
-                            if ( strcmp(param2,"EMF") == 0)
+                            if ( strcmp(param2, "EMF") == 0)
                             {
                                 /* @TODO create EMF */
                                 copyFigureToClipBoard(num_win);
@@ -263,43 +377,54 @@ int sci_ClipBoard(char *fname,unsigned long l)
                                 copyFigureToClipBoard(num_win);
                             }
 
-                            m1=0;
-                            n1=0;
-                            CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,  &m1, &n1, &l1);
-                            LhsVar(1)=Rhs+1;
-                            PutLhsVar();               
+                            m1 = 0;
+                            n1 = 0;
+
+                            freeAllocatedSingleString(param2);
+
+                            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &pdbll1);
+                            if (sciErr.iErr)
+                            {
+                                printError(&sciErr, 0);
+                                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                                return 1;
+                            }
+                            AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+                            ReturnArguments(pvApiCtx);
                             return TRUE;
                         }
                         else
                         {
-                            Scierror(999,_("%s: Wrong value for input argument #%d: Must be >= %d expected.\n"), fname, 1, 0);
+                            freeAllocatedSingleString(param2);
+                            Scierror(999, _("%s: Wrong value for input argument #%d: Must be >= %d expected.\n"), fname, 1, 0);
                             return FALSE;
                         }
 
                     }
                     else
                     {
-                        Scierror(999,_("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 2, "EMF","DIB");
+                        freeAllocatedSingleString(param2);
+                        Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 2, "EMF", "DIB");
                         return FALSE;
                     }
 
                 }
                 else
                 {
-                    Scierror(999,_("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
+                    Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
                     return FALSE;
                 }
             }
             else
             {
-                Scierror(999,_("%s: Wrong type for input argument #%d: A string or a real expected.\n"), fname, 1);
+                Scierror(999, _("%s: Wrong type for input argument #%d: A string or a real expected.\n"), fname, 1);
                 return FALSE;
             }
         }
     }
     else
     {
-        Scierror(999,_("%s: Function not available in NWNI mode.\n"), fname);
+        Scierror(999, _("%s: Function not available in NWNI mode.\n"), fname);
         return FALSE;
     }
 
index 2faa976..51501bc 100644 (file)
@@ -13,7 +13,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "Scierror.h"
 #include "InitUIMenu.h"
 /*--------------------------------------------------------------------------*/
 int sci_delmenu(char *fname, unsigned long fname_len)
 {
-    int nbRow = 0, nbCol = 0, stkAdr = 0;
-    int nbRow1 = 0, nbCol1 = 0, stkAdr1 = 0;
+    SciErr sciErr;
+
+    int* piAddr1    = NULL;
+    int* piAddr2    = NULL;
+    char* strAdr    = NULL;
+    double* pdblAdr = NULL;
+
+    int nbRow = 0;
+    int nbCol = 0;
 
     // Check parameter number
-    CheckRhs(1, 2);
-    CheckLhs(1, 1);
+    CheckInputArgument(pvApiCtx, 1, 2);
+    CheckOutputArgument(pvApiCtx, 1, 1);
 
-    if (Rhs == 1)
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
     {
+        printError(&sciErr, 0);
+        return 1;
+    }
 
+    if (nbInputArgument(pvApiCtx) == 1)
+    {
         // Error message in not in standard mode (we need figure index)
         if (getScilabMode() != SCILAB_STD)
         {
@@ -41,31 +54,40 @@ int sci_delmenu(char *fname, unsigned long fname_len)
         }
 
         // Unset a Menu of Scilab Main Window
-        if (VarType(1) != sci_strings)
+        if ((!checkInputArgumentType(pvApiCtx, 1, sci_strings)))
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
             return FALSE;
         }
 
-        GetRhsVar(1, STRING_DATATYPE, &nbRow, &nbCol, &stkAdr);
-
-        if (nbCol != 1)
+        // Retrieve a matrix of double at position 1.
+        if (getAllocatedSingleString(pvApiCtx, piAddr1, &strAdr))
         {
-            Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
-            return FALSE;
+            Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+            return 1;
         }
 
-        DeleteMenuWithName(getConsoleIdentifier(), cstk(stkAdr));
+        DeleteMenuWithName(getConsoleIdentifier(), strAdr);
+        freeAllocatedSingleString(strAdr);
     }
     else
     {
         // Unset a Menu a Scilab Graphic Window
-        if (VarType(1) != sci_matrix)
+        if ((!checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 1);
             return FALSE;
         }
-        GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
+
+        // Retrieve a matrix of double at position 1.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &nbRow, &nbCol, &pdblAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+            return 1;
+        }
+
 
         if (nbRow * nbCol != 1)
         {
@@ -73,18 +95,31 @@ int sci_delmenu(char *fname, unsigned long fname_len)
             return FALSE;
         }
 
-        if (VarType(2) != sci_strings)
+        if ((!checkInputArgumentType(pvApiCtx, 2, sci_strings)))
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
             return FALSE;
         }
-        GetRhsVar(2, STRING_DATATYPE, &nbRow1, &nbCol1, &stkAdr1);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 2.
+        if (getAllocatedSingleString(pvApiCtx, piAddr2, &strAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
+            return 1;
+        }
 
-        DeleteMenuWithName((char*)getFigureFromIndex((int)*stk(stkAdr)), cstk(stkAdr1));
+        DeleteMenuWithName((char*)getFigureFromIndex((int)(*pdblAdr)), strAdr);
+        freeAllocatedSingleString(strAdr);
     }
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 
index b7e215f..357e53c 100644 (file)
@@ -13,7 +13,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "HandleManagement.h"
 #include "localization.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
 int sci_exportUI(char * fname, unsigned long fname_len)
 {
-    int iFigureId = 0; // id of the figure to export
-    int iRows = 0;
-    int iCols = 0;
-    size_t stackPointer = 0;
+    SciErr sciErr;
 
-    CheckLhs(0, 1);
-    CheckRhs(1, 1);
+    int* piAddrstackPointer = NULL;
 
-    if (GetType(1) == sci_handles) // exportUI(figHandle)
+    int iFigureId   = 0; // id of the figure to export
+    int *piFigureId = &iFigureId;
+    int iRows       = 0;
+    int iCols       = 0;
+    int iHandleType = -1;
+    int *piHandleType = &iHandleType;
+
+    CheckOutputArgument(pvApiCtx, 0, 1);
+    CheckInputArgument(pvApiCtx, 1, 1);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstackPointer);
+    if (sciErr.iErr)
     {
-        char *pstFigureUID = NULL;
-        int iHandleType = -1;
-        int *piHandleType = &iHandleType;
-        int *piFigureId = &iFigureId;
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    if (checkInputArgumentType(pvApiCtx, 1, sci_handles)) // exportUI(figHandle)
+    {
+        char *pstFigureUID      = NULL;
+        char *pstHandleType     = NULL;
+        long long* stackPointer = NULL;
+        // Retrieve a matrix of handle at position 1.
+        sciErr = getMatrixOfHandle(pvApiCtx, piAddrstackPointer, &iRows, &iCols, &stackPointer);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+            return 1;
+        }
 
-        GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &iRows, &iCols, &stackPointer);
         if (iRows * iCols != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument #%d: A Real Scalar or a 'Figure' handle expected.\n"), fname, 1);
         }
 
-        pstFigureUID = (char*)getObjectFromHandle((unsigned long) * (hstk(stackPointer)));
+        pstFigureUID = getObjectFromHandle((unsigned long) * stackPointer);
 
         getGraphicObjectProperty(pstFigureUID, __GO_TYPE__, jni_int, (void **)&piHandleType);
         if (iHandleType == __GO_FIGURE__)
@@ -56,16 +75,26 @@ int sci_exportUI(char * fname, unsigned long fname_len)
 
         getGraphicObjectProperty(pstFigureUID, __GO_ID__, jni_int, (void **)&piFigureId);
     }
-    else if (GetType(1) == sci_matrix) // exportUI(figId)
+    else if (checkInputArgumentType(pvApiCtx, 1, sci_matrix)) // exportUI(figId)
     {
-        GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &iRows, &iCols, &stackPointer);
+        double* stackPointer = NULL;
+
+        // Retrieve a matrix of double at position 1.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrstackPointer, &iRows, &iCols, &stackPointer);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+            return 1;
+        }
+
         if (iRows * iCols != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument #%d: A Real Scalar or a 'Figure' handle expected.\n"), fname, 1);
             return FALSE;
         }
 
-        iFigureId = (int) * (stk(stackPointer));
+        iFigureId = (int) * stackPointer;
     }
     else
     {
@@ -76,10 +105,8 @@ int sci_exportUI(char * fname, unsigned long fname_len)
     // call the export function
     exportUserInterface(iFigureId);
 
-    LhsVar(1) = 0;
-
-    PutLhsVar();
-
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 /*--------------------------------------------------------------------------*/
index 624153e..c6af06c 100644 (file)
 #include "localization.h"
 #include "Scierror.h"
 #include "HandleManagement.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "gw_gui.h"
 /*--------------------------------------------------------------------------*/
 int sci_getcallbackobject(char *fname, unsigned long fname_len)
 {
-    int nbRow = 0, nbCol = 0, stkAdr = 0;
-
-    char **pObjUID = NULL;
+    SciErr sciErr;
 
+    int* piAddrpObjUID = NULL;
+    int nbRow = 0;
+    int nbCol = 0;
+    char** pObjUID = NULL;
     unsigned long graphicHandle = 0;
 
-    CheckRhs(1, 1);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
-    if (VarType(1) == sci_strings)
+    if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
     {
-        GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &pObjUID);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrpObjUID);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 1.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrpObjUID, &nbRow, &nbCol, &pObjUID))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+            return 1;
+        }
+
         if (nbCol != 1 || nbRow == 0)
         {
             Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
@@ -47,25 +62,42 @@ int sci_getcallbackobject(char *fname, unsigned long fname_len)
     }
 
     graphicHandle = getHandle(pObjUID[0]);
+    freeAllocatedMatrixOfString(nbRow, nbCol, pObjUID);
 
     /* Create return variable */
     if (graphicHandle == 0)     /* Non-existing object --> return [] */
     {
+        double* stkAdr = NULL;
         nbRow = 0;
         nbCol = 0;
-        CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
+
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &stkAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
     }
     else                        /* Return the handle */
     {
+        long long* stkAdr = NULL;
         nbRow = 1;
         nbCol = 1;
-        CreateVar(Rhs + 1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
-        *hstk(stkAdr) = graphicHandle;
-    }
 
-    LhsVar(1) = Rhs + 1;
+        sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &stkAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        *stkAdr = (long long)graphicHandle;
+    }
 
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 
index 56c2a51..c1dc76e 100644 (file)
@@ -1,17 +1,17 @@
 /*
-* Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
-* Copyright (C) 2008 - INRIA - Vincent COUVERT
-*
-* This file must be used under the terms of the CeCILL.
-* This source file is licensed as described in the file COPYING, which
-* you should have received as part of this distribution.  The terms
-* are also available at
-* http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
-*
-*/
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2008 - INRIA - Vincent COUVERT
+ *
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "CallHelpBrowser.h"
 #include "Scierror.h"
@@ -24,62 +24,93 @@ static BOOL loadedDep = FALSE;
 /*--------------------------------------------------------------------------*/
 int sci_helpbrowser(char *fname, unsigned long fname_len)
 {
-    int nbRow = 0, nbCol = 0;
-    char **keywordAdr = NULL;
+    SciErr sciErr;
 
-    int nbRowHelp = 0, nbColHelp = 0;
-    char **helpAdr = NULL;
-    char **languageAdr = NULL;
-    int fullTextAdr = 0;
+    int* piAddrhelpAdr      = NULL;
+    int* piAddrkeywordAdr   = NULL;
+    int* piAddrfullTextAdr  = NULL;
+    int* fullTextAdr        = NULL;
 
-    CheckRhs(2, 4);
-    CheckLhs(0, 1);
+    int nbRow = 0;
+    int nbCol = 0;
+    char** keywordAdr = NULL;
+
+    int nbRowHelp       = 0;
+    int nbColHelp       = 0;
+    char** helpAdr      = NULL;
+    char** languageAdr  = NULL;
+
+    CheckInputArgument(pvApiCtx, 2, 4);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     /* We load SciNotes when calling javahelp because we have no way to know
-    * to load it when using Javahelp because it can call SciNotes directly */
+     * to load it when using Javahelp because it can call SciNotes directly */
     if (!loadedDep)
     {
         loadOnUseClassPath("SciNotes");
         loadedDep = TRUE;
     }
 
-    if (VarType(1) == sci_strings)
+    if (checkInputArgumentType(pvApiCtx, 1, sci_strings))
     {
-        GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRowHelp, &nbColHelp, &helpAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrhelpAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 1.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrhelpAdr, &nbRowHelp, &nbColHelp, &helpAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+            return 1;
+        }
+    }
+    else if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))
+    {
+        helpAdr = NULL; /* No toolboxes installed */
     }
     else
     {
-        if (VarType(1) == sci_matrix)
+        Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 1);
+        return FALSE;
+    }
+
+    if (nbInputArgument(pvApiCtx) == 2)
+    {
+        if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
         {
-            if (nbRow * nbCol == 0)
+            int* piAddrlanguageAdr = NULL;
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlanguageAdr);
+            if (sciErr.iErr)
             {
-                helpAdr = NULL; /* No toolboxes installed */
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+                printError(&sciErr, 0);
+                return 1;
             }
-            else
+
+            // Retrieve a matrix of string at position 2.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrlanguageAdr, &nbRow, &nbCol, &languageAdr))
             {
-                Scierror(999, _("%s: Wrong size for input argument #%d: Matrix of strings expected.\n"), fname, 1);
-                return FALSE;
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                return 1;
             }
-        }
-        else
-        {
-            Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, 1);
-            return FALSE;
-        }
-    }
 
-    if (Rhs == 2)
-    {
-        if (VarType(2) == sci_strings)
-        {
-            GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &languageAdr);
-            if (nbRow * nbCol != 1)
+            if (nbRow*nbCol != 1)
             {
                 if (helpAdr)
                 {
-                    freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
                 }
-                freeArrayOfString(languageAdr, nbRow * nbCol);
+                freeAllocatedMatrixOfString(nbRow, nbCol, languageAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
                 return FALSE;
             }
@@ -88,35 +119,55 @@ int sci_helpbrowser(char *fname, unsigned long fname_len)
         {
             if (helpAdr)
             {
-                freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
             }
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
             return FALSE;
         }
 
-        if (helpAdr == NULL) /* No toolboxes loaded */
-        {
-            launchHelpBrowser(NULL, nbRowHelp * nbColHelp, languageAdr[0]);
-        }
-        else
+        launchHelpBrowser(helpAdr, nbRowHelp * nbColHelp, languageAdr[0]);
+
+        if (helpAdr)
         {
-            launchHelpBrowser(helpAdr, nbRowHelp * nbColHelp, languageAdr[0]);
-            freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+            freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
         }
-        freeArrayOfString(languageAdr, nbRow * nbCol);
+        freeAllocatedMatrixOfString(nbRow, nbCol, languageAdr);
     }
-    else if (Rhs == 4)
+    else if (nbInputArgument(pvApiCtx) == 4)
     {
-        if (VarType(2) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
         {
-            GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &keywordAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrkeywordAdr);
+            if (sciErr.iErr)
+            {
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 2.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrkeywordAdr, &nbRow, &nbCol, &keywordAdr))
+            {
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
             {
                 if (helpAdr)
                 {
-                    freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
                 }
-                freeArrayOfString(keywordAdr, nbRow * nbCol);
+                freeAllocatedMatrixOfString(nbRow, nbCol, keywordAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
                 return FALSE;
             }
@@ -125,23 +176,47 @@ int sci_helpbrowser(char *fname, unsigned long fname_len)
         {
             if (helpAdr)
             {
-                freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
             }
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
             return FALSE;
         }
 
-        if (VarType(3) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 3, sci_strings)))
         {
-            GetRhsVar(3, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &languageAdr);
-            if (nbRow * nbCol != 1)
+            int* piAddrlanguageAdr = NULL;
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrlanguageAdr);
+            if (sciErr.iErr)
             {
                 if (helpAdr)
                 {
-                    freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
                 }
-                freeArrayOfString(keywordAdr, 1);
-                freeArrayOfString(languageAdr, nbRow * nbCol);
+                freeAllocatedSingleString(*keywordAdr);
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 3.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrlanguageAdr, &nbRow, &nbCol, &languageAdr))
+            {
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+                freeAllocatedSingleString(*keywordAdr);
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
+            {
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+                freeAllocatedSingleString(*keywordAdr);
+                freeAllocatedMatrixOfString(nbRow, nbCol, languageAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 3);
                 return FALSE;
             }
@@ -150,24 +225,51 @@ int sci_helpbrowser(char *fname, unsigned long fname_len)
         {
             if (helpAdr)
             {
-                freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
             }
-            freeArrayOfString(keywordAdr, 1);
+            freeAllocatedSingleString(*keywordAdr);
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 3);
             return FALSE;
         }
 
-        if (VarType(4) == sci_boolean)
+        if ((checkInputArgumentType(pvApiCtx, 4, sci_boolean)))
         {
-            GetRhsVar(4, MATRIX_OF_BOOLEAN_DATATYPE, &nbRow, &nbCol, &fullTextAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrfullTextAdr);
+            if (sciErr.iErr)
             {
                 if (helpAdr)
                 {
-                    freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
                 }
-                freeArrayOfString(keywordAdr, 1);
-                freeArrayOfString(languageAdr, 1);
+                freeAllocatedSingleString(*keywordAdr);
+                freeAllocatedSingleString(*languageAdr);
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of boolean at position 4.
+            sciErr = getMatrixOfBoolean(pvApiCtx, piAddrfullTextAdr, &nbRow, &nbCol, &fullTextAdr);
+            if (sciErr.iErr)
+            {
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+                freeAllocatedSingleString(*keywordAdr);
+                freeAllocatedSingleString(*languageAdr);
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: Boolean matrix expected.\n"), fname, 4);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
+            {
+                if (helpAdr)
+                {
+                    freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
+                }
+                freeAllocatedSingleString(*keywordAdr);
+                freeAllocatedSingleString(*languageAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 4);
                 return FALSE;
             }
@@ -176,28 +278,23 @@ int sci_helpbrowser(char *fname, unsigned long fname_len)
         {
             if (helpAdr)
             {
-                freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
+                freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
             }
-            freeArrayOfString(keywordAdr, 1);
-            freeArrayOfString(languageAdr, 1);
+            freeAllocatedSingleString(*keywordAdr);
+            freeAllocatedSingleString(*languageAdr);
             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 4);
             return FALSE;
         }
 
-        if (helpAdr == NULL) /* No toolboxes loaded */
-        {
-            searchKeyword(NULL, nbRowHelp * nbColHelp, keywordAdr[0], languageAdr[0], *istk(fullTextAdr) == 1);
-        }
-        else
+        searchKeyword(helpAdr, nbRowHelp * nbColHelp, keywordAdr[0], languageAdr[0], *fullTextAdr == 1);
+
+        if (helpAdr)
         {
-            searchKeyword(helpAdr, nbRowHelp * nbColHelp, keywordAdr[0], languageAdr[0], *istk(fullTextAdr) == 1);
-            if (helpAdr)
-            {
-                freeArrayOfString(helpAdr, nbRowHelp * nbColHelp);
-            }
+            freeAllocatedMatrixOfString(nbRowHelp, nbColHelp, helpAdr);
         }
-        freeArrayOfString(keywordAdr, 1);
-        freeArrayOfString(languageAdr, 1);
+
+        freeAllocatedSingleString(*keywordAdr);
+        freeAllocatedSingleString(*languageAdr);
     }
     else
     {
@@ -205,11 +302,8 @@ int sci_helpbrowser(char *fname, unsigned long fname_len)
         return FALSE;
     }
 
-    LhsVar(1) = 0;
-
-    PutLhsVar();
-
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return TRUE;
-
 }
 /*--------------------------------------------------------------------------*/
index 5c902b6..94d8d48 100644 (file)
@@ -11,7 +11,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "CallMessageBox.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
 int sci_messagebox(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddrmessageAdr       = NULL;
+    int* piAddrtitleAdr         = NULL;
+    int* piAddriconAdr          = NULL;
+    int* piAddrbuttonsTextAdr   = NULL;
+    int* piAddrmodalOptionAdr   = NULL;
+    double* buttonNumberAdr     = NULL;
+
     int messageBoxID = 0;
 
     /* Used to read input arguments */
@@ -29,23 +38,34 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     int nbRowButtons = 0, nbColButtons = 0;
     int nbRowMessage = 0, nbColMessage = 0;
 
-    char **buttonsTextAdr = 0;
-    char **messageAdr = 0;
-    char **titleAdr = 0;
-    char **modalOptionAdr = 0;
-    char **iconAdr = 0;
+    char **buttonsTextAdr   = 0;
+    char **messageAdr       = 0;
+    char **titleAdr         = 0;
+    char **modalOptionAdr   = 0;
+    char **iconAdr          = 0;
 
     /* Used to write output argument */
-    int buttonNumberAdr = 0;
     int buttonNumber = 0;
 
-    CheckRhs(1, 5);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 1, 5);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     /* Message to be displayed */
-    if (VarType(1) == sci_strings)
+    if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
     {
-        GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRowMessage, &nbColMessage, &messageAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmessageAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 1.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+            return 1;
+        }
     }
     else
     {
@@ -54,12 +74,25 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     }
 
     /* Title to be displayed */
-    if (Rhs >= 2)
+    if (nbInputArgument(pvApiCtx) >= 2)
     {
-        if (VarType(2) == sci_strings)
+        if (checkInputArgumentType(pvApiCtx, 2, sci_strings))
         {
-            GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &titleAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrtitleAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 2.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrtitleAdr, &nbRow, &nbCol, &titleAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
                 return FALSE;
@@ -79,12 +112,25 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     }
 
     /* Icon to be displayed */
-    if (Rhs >= 3)
+    if (nbInputArgument(pvApiCtx) >= 3)
     {
-        if (VarType(3) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 3, sci_strings)))
         {
-            GetRhsVar(3, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &iconAdr);
-            if (nbRow * nbCol == 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddriconAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 3.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddriconAdr, &nbRow, &nbCol, &iconAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
+                return 1;
+            }
+
+            if (nbRow*nbCol == 1)
             {
                 /* The icon argument can be used to give the modal option or the buttons names */
                 if (isModalOption(iconAdr[0]))
@@ -107,7 +153,6 @@ int sci_messagebox(char *fname, unsigned long fname_len)
                 nbColButtons = nbCol;
                 iconAdr = NULL;
             }
-
         }
         else
         {
@@ -117,12 +162,25 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     }
 
     /* Buttons names */
-    if (Rhs >= 4)
+    if (nbInputArgument(pvApiCtx) >= 4)
     {
-        if (VarType(4) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 4, sci_strings)))
         {
-            GetRhsVar(4, MATRIX_OF_STRING_DATATYPE, &nbRowButtons, &nbColButtons, &buttonsTextAdr);
-            if (nbRow * nbCol == 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrbuttonsTextAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 4.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrbuttonsTextAdr, &nbRowButtons, &nbColButtons, &buttonsTextAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 4);
+                return 1;
+            }
+
+            if (nbRow*nbCol == 1)
             {
                 /* The buttons names argument can be used to give the modal option */
                 if (isModalOption(buttonsTextAdr[0]))
@@ -140,12 +198,25 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     }
 
     /* Modal option */
-    if (Rhs == 5)
+    if (nbInputArgument(pvApiCtx) == 5)
     {
-        if (VarType(5) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 5, sci_strings)))
         {
-            GetRhsVar(5, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &modalOptionAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddrmodalOptionAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 5.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrmodalOptionAdr, &nbRow, &nbCol, &modalOptionAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 5);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 5);
                 return FALSE;
@@ -162,11 +233,13 @@ int sci_messagebox(char *fname, unsigned long fname_len)
 
     /* Message */
     setMessageBoxMultiLineMessage(messageBoxID, messageAdr, nbColMessage * nbRowMessage);
+    freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
 
     /* Title */
     if (titleAdr != NULL)
     {
         setMessageBoxTitle(messageBoxID, titleAdr[0]);
+        freeAllocatedMatrixOfString(nbRow, nbCol, titleAdr);
     }
     else
     {
@@ -177,18 +250,21 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     if (iconAdr != NULL)
     {
         setMessageBoxIcon(messageBoxID, iconAdr[0]);
+        freeAllocatedMatrixOfString(nbRow, nbCol, iconAdr);
     }
 
     /* Buttons */
     if (buttonsTextAdr != NULL)
     {
         setMessageBoxButtonsLabels(messageBoxID, buttonsTextAdr, nbColButtons * nbRowButtons);
+        freeAllocatedMatrixOfString(nbRowButtons, nbColButtons, buttonsTextAdr);
     }
 
     /* Modal ? */
     if (modalOptionAdr != NULL)
     {
         setMessageBoxModal(messageBoxID, !stricmp(modalOptionAdr[0], "modal"));
+        freeAllocatedMatrixOfString(nbRow, nbCol, modalOptionAdr);
     }
     else
     {
@@ -199,25 +275,32 @@ int sci_messagebox(char *fname, unsigned long fname_len)
     messageBoxDisplayAndWait(messageBoxID);
 
     /* Return the index of the button selected */
-
-    if (Lhs == 1)
+    if (nbOutputArgument(pvApiCtx) == 1)
     {
         /* Read the user answer */
         buttonNumber = getMessageBoxSelectedButton(messageBoxID);
 
         nbRow = 1;
         nbCol = 1;
-        CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &buttonNumberAdr);
-        *stk(buttonNumberAdr) = buttonNumber;
 
-        LhsVar(1) = Rhs + 1;
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &buttonNumberAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        buttonNumberAdr[0] = buttonNumber;
+
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     }
     else
     {
-        LhsVar(1) = 0;
+        AssignOutputVariable(pvApiCtx, 1) = 0;
     }
 
-    PutLhsVar();
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 /*--------------------------------------------------------------------------*/
index ff3d662..5b5cb3d 100644 (file)
@@ -12,7 +12,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "Scierror.h"
 #include "getPropertyAssignedValue.h"
 /*--------------------------------------------------------------------------*/
 int sci_progressionbar(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddrhandleAdr = NULL;
+    long long* handleAdr = NULL;
+    int* piAddrmessageAdr = NULL;
+    long long* stkAdr = NULL;
+
     char *pProgressionbarUID = NULL;
 
     int nbRow = 0, nbCol = 0;
     int nbRowMessage = 0, nbColMessage = 0;
 
     char **messageAdr = NULL;
-    int handleAdr = 0;
-    int stkAdr = 0;
-
     int iValue = 0;
-
     unsigned long GraphicHandle = 0;
 
-    CheckRhs(1, 2);
-    CheckLhs(1, 1);
+    CheckInputArgument(pvApiCtx, 1, 2);
+    CheckOutputArgument(pvApiCtx, 1, 1);
 
-    if (Rhs == 1)
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrhandleAdr);
+    if (sciErr.iErr)
     {
-        if (VarType(1) == sci_handles)  /* ProgressionBar to update */
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    if (nbInputArgument(pvApiCtx) == 1)
+    {
+        if ((checkInputArgumentType(pvApiCtx, 1, sci_handles)))  /* ProgressionBar to update */
         {
-            GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &handleAdr);
+            // Retrieve a matrix of handle at position 1.
+            sciErr = getMatrixOfHandle(pvApiCtx, piAddrhandleAdr, &nbRow, &nbCol, &handleAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+                return 1;
+            }
+
             if (nbRow * nbCol != 1)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
                 return FALSE;
             }
         }
-        else if (VarType(1) == sci_strings) /* Message to display */
+        else if ((checkInputArgumentType(pvApiCtx, 1, sci_strings))) /* Message to display */
         {
-            GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRowMessage, &nbColMessage, &messageAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmessageAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 1.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+                return 1;
+            }
         }
         else
         {
@@ -66,40 +96,55 @@ int sci_progressionbar(char *fname, unsigned long fname_len)
         {
             /* Create a new ProgressionBar */
             pProgressionbarUID = createGraphicObject(__GO_PROGRESSIONBAR__);
-
             GraphicHandle = getHandle(pProgressionbarUID);
-
-            setGraphicObjectProperty(pProgressionbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector,
-                                     nbColMessage * nbRowMessage);
-            freeArrayOfString(messageAdr, nbColMessage * nbRowMessage);
+            setGraphicObjectProperty(pProgressionbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector, nbColMessage * nbRowMessage);
+            freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
         }
         else
         {
-            GraphicHandle = (unsigned long) * hstk(handleAdr);
+            GraphicHandle = (unsigned long) * (handleAdr);
             pProgressionbarUID = (char*)getObjectFromHandle(GraphicHandle);
-
             setGraphicObjectProperty(pProgressionbarUID, __GO_UI_VALUE__, &iValue, jni_int, 1);
         }
     }
-    else if (Rhs == 2)
+    else if (nbInputArgument(pvApiCtx) == 2)
     {
-        if (VarType(1) == sci_handles && VarType(2) == sci_strings) /* progressionbar(id,mes) */
+        if ((checkInputArgumentType(pvApiCtx, 1, sci_handles)) && (checkInputArgumentType(pvApiCtx, 2, sci_strings))) /* progressionbar(id,mes) */
         {
-            GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &handleAdr);
+            // Retrieve a matrix of handle at position 1.
+            sciErr = getMatrixOfHandle(pvApiCtx, piAddrhandleAdr, &nbRow, &nbCol, &handleAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+                return 1;
+            }
+
             if (nbRow * nbCol != 1)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
                 return FALSE;
             }
-            GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRowMessage, &nbColMessage, &messageAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmessageAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 2.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                return 1;
+            }
 
-            GraphicHandle = (unsigned long) * hstk(handleAdr);
+            GraphicHandle = (unsigned long) * handleAdr;
             pProgressionbarUID = (char*)getObjectFromHandle(GraphicHandle);
 
             setGraphicObjectProperty(pProgressionbarUID, __GO_UI_VALUE__, &iValue, jni_int, 1);
-            setGraphicObjectProperty(pProgressionbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector,
-                                     nbColMessage * nbRowMessage);
-            freeArrayOfString(messageAdr, nbColMessage * nbRowMessage);
+            setGraphicObjectProperty(pProgressionbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector, nbColMessage * nbRowMessage);
+            freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
         }
         else
         {
@@ -108,23 +153,28 @@ int sci_progressionbar(char *fname, unsigned long fname_len)
         }
     }
 
-    if (Lhs == 1)
+    if (nbOutputArgument(pvApiCtx) == 1)
     {
         nbRow = 1;
         nbCol = 1;
-        CreateVar(Rhs + 1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
-        *hstk(stkAdr) = GraphicHandle;
-        LhsVar(1) = Rhs + 1;
+
+        sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &stkAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        *stkAdr = (long long)GraphicHandle;
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     }
     else
     {
-        LhsVar(1) = 0;
+        AssignOutputVariable(pvApiCtx, 1) = 0;
     }
 
-    PutLhsVar();
-
+    ReturnArguments(pvApiCtx);
     return TRUE;
-
 }
-
 /*--------------------------------------------------------------------------*/
index 25fde61..32a0b2d 100644 (file)
@@ -12,7 +12,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "Scierror.h"
 #include "InitUIMenu.h"
 /*--------------------------------------------------------------------------*/
 int sci_setmenu(char *fname, unsigned long fname_len)
 {
-    int nbRow = 0, nbCol = 0;
-    int menuNameAdr = 0;
-    int figureNumberAdr = 0;
-    int subMenuIndexAdr = 0;
+    SciErr sciErr;
+
+    int* piAddrmenuNameAdr = NULL;
+    char* menuNameAdr = NULL;
+    int* piAddrfigureNumberAdr = NULL;
+    double* figureNumberAdr = NULL;
+    int* piAddrsubMenuIndexAdr = NULL;
+    double* subMenuIndexAdr = NULL;
+
+    int nbRow = 0;
+    int nbCol = 0;
 
     // Check parameter number
-    CheckRhs(1, 3);
-    CheckLhs(1, 1);
+    CheckInputArgument(pvApiCtx, 1, 3);
+    CheckOutputArgument(pvApiCtx, 1, 1);
 
-    if (Rhs == 1)
+    if (nbInputArgument(pvApiCtx) == 1)
     {
         // Error message in not in standard mode (we need figure index)
         if (getScilabMode() != SCILAB_STD)
@@ -41,28 +48,57 @@ int sci_setmenu(char *fname, unsigned long fname_len)
         }
 
         // Unset a Menu of Scilab Main Window
-        if (VarType(1) != sci_strings)
+        if ((!checkInputArgumentType(pvApiCtx, 1, sci_strings)))
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
             return FALSE;
         }
 
-        GetRhsVar(1, STRING_DATATYPE, &nbRow, &nbCol, &menuNameAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmenuNameAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
 
-        if (nbCol != 1)
+        if (isScalar(pvApiCtx, piAddrmenuNameAdr) == FALSE)
         {
             Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
             return FALSE;
         }
 
-        EnableMenu(getConsoleIdentifier(), cstk(menuNameAdr), TRUE);
+        // Retrieve a matrix of double at position 1.
+        if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+            return 1;
+        }
+
+
+        EnableMenu(getConsoleIdentifier(), menuNameAdr, TRUE);
+        freeAllocatedSingleString(menuNameAdr);
     }
-    else if (Rhs == 2)
+    else if (nbInputArgument(pvApiCtx) == 2)
     {
         // Unset a Menu a Scilab Graphic Window
-        if (VarType(1) == sci_matrix && VarType(2) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)) && (checkInputArgumentType(pvApiCtx, 2, sci_strings)))
         {
-            GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &figureNumberAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfigureNumberAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrfigureNumberAdr, &nbRow, &nbCol, &figureNumberAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                return 1;
+            }
+
 
             if (nbRow * nbCol != 1)
             {
@@ -70,15 +106,57 @@ int sci_setmenu(char *fname, unsigned long fname_len)
                 return FALSE;
             }
 
-            GetRhsVar(2, STRING_DATATYPE, &nbRow, &nbCol, &menuNameAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmenuNameAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 2.
+            if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
+                return 1;
+            }
+
 
-            EnableMenu((char*)getFigureFromIndex((int)*stk(figureNumberAdr)), cstk(menuNameAdr), TRUE);
+            EnableMenu((char*)getFigureFromIndex((int)(*figureNumberAdr)), (menuNameAdr), TRUE);
+            freeAllocatedSingleString(menuNameAdr);
         }
-        else if (VarType(1) == sci_strings && VarType(2) == sci_matrix) // Unset a submenu in main window
+        else if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)) && (checkInputArgumentType(pvApiCtx, 2, sci_matrix))) // Unset a submenu in main window
         {
-            GetRhsVar(1, STRING_DATATYPE, &nbRow, &nbCol, &menuNameAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmenuNameAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+                return 1;
+            }
+
+
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrsubMenuIndexAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 2.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrsubMenuIndexAdr, &nbRow, &nbCol, &subMenuIndexAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+                return 1;
+            }
 
-            GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &subMenuIndexAdr);
 
             if (nbRow * nbCol != 1)
             {
@@ -86,7 +164,8 @@ int sci_setmenu(char *fname, unsigned long fname_len)
                 return FALSE;
             }
 
-            EnableSubMenu(getConsoleIdentifier(), cstk(menuNameAdr), (int)*stk(subMenuIndexAdr), TRUE);
+            EnableSubMenu(getConsoleIdentifier(), (menuNameAdr), (int)(*subMenuIndexAdr), TRUE);
+            freeAllocatedSingleString(menuNameAdr);
         }
         else
         {
@@ -96,9 +175,24 @@ int sci_setmenu(char *fname, unsigned long fname_len)
     }
     else                        // Unset a submenu in graphics window
     {
-        if (VarType(1) == sci_matrix)
+        if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
         {
-            GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &figureNumberAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfigureNumberAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrfigureNumberAdr, &nbRow, &nbCol, &figureNumberAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                return 1;
+            }
+
 
             if (nbRow * nbCol != 1)
             {
@@ -112,9 +206,22 @@ int sci_setmenu(char *fname, unsigned long fname_len)
             return FALSE;
         }
 
-        if (VarType(2) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
         {
-            GetRhsVar(2, STRING_DATATYPE, &nbRow, &nbCol, &menuNameAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmenuNameAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 2.
+            if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
+                return 1;
+            }
+
         }
         else
         {
@@ -122,9 +229,24 @@ int sci_setmenu(char *fname, unsigned long fname_len)
             return FALSE;
         }
 
-        if (VarType(3) == sci_matrix)
+        if ((checkInputArgumentType(pvApiCtx, 3, sci_matrix)))
         {
-            GetRhsVar(3, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &subMenuIndexAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrsubMenuIndexAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 3.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrsubMenuIndexAdr, &nbRow, &nbCol, &subMenuIndexAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+                return 1;
+            }
+
 
             if (nbRow * nbCol != 1)
             {
@@ -138,11 +260,12 @@ int sci_setmenu(char *fname, unsigned long fname_len)
             return FALSE;
         }
 
-        EnableSubMenu((char*)getFigureFromIndex((int)*stk(figureNumberAdr)), cstk(menuNameAdr), (int)*stk(subMenuIndexAdr), TRUE);
+        EnableSubMenu((char*)getFigureFromIndex((int)(*figureNumberAdr)), (menuNameAdr), (int)(*subMenuIndexAdr), TRUE);
+        freeAllocatedSingleString(menuNameAdr);
     }
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 
index 7685a19..d834ec5 100644 (file)
@@ -13,7 +13,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "Scierror.h"
 #include "MALLOC.h"
 #include "localization.h"
 /*--------------------------------------------------------------------------*/
 int sci_toolbar(char *fname, unsigned long l)
 {
-    static int stkAdr = 0, nbCol = 0, nbRow = 0;
+    SciErr sciErr;
 
-    char *Output = NULL;
+    int* piAddr1 = NULL;
+    int* piStkAdr = NULL;
+    int* piAddrstkAdr = NULL;
+    long long* stkAdr = NULL;
+    int* piAddrparam = NULL;
 
-    char **param = NULL;
+    int nbCol = 0;
+    int nbRow = 0;
 
+    char *Output = NULL;
+    char **param = NULL;
     int figNum = -2;
 
     char *pParentUID = NULL;
     int iParentType = -1;
     int *piParentType = &iParentType;
 
-    CheckRhs(1, 2);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 1, 2);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     /* Figure number */
-    if (GetType(1) == sci_matrix)
+    if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))
     {
-        GetRhsVar(1, MATRIX_OF_INTEGER_DATATYPE, &nbRow, &nbCol, &stkAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 1.
+        sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr1, &nbRow, &nbCol, &piStkAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+            return 1;
+        }
+
         if (nbRow * nbCol != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1);
             return FALSE;
         }
-        figNum = *istk(stkAdr);
+        figNum = *piStkAdr;
 
         if (figNum < -1)
         {
@@ -81,16 +103,30 @@ int sci_toolbar(char *fname, unsigned long l)
             pParentUID = (char*)getFigureFromIndex(figNum);
         }
     }
-    else if (GetType(1) == sci_handles)
+    else if (checkInputArgumentType(pvApiCtx, 1, sci_handles))
     {
-        GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstkAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of handle at position 1.
+        sciErr = getMatrixOfHandle(pvApiCtx, piAddrstkAdr, &nbRow, &nbCol, &stkAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+            return 1;
+        }
 
         if (nbRow * nbCol != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
             return FALSE;
         }
-        pParentUID = (char*)getObjectFromHandle((long) * hstk(stkAdr));
+        pParentUID = (char*)getObjectFromHandle((long) * stkAdr);
 
         if (pParentUID == NULL)
         {
@@ -111,14 +147,27 @@ int sci_toolbar(char *fname, unsigned long l)
         return FALSE;
     }
 
-    if (Rhs == 2)               /* New status */
+    if (nbInputArgument(pvApiCtx) == 2)               /* New status */
     {
-        if ((GetType(2) == sci_strings))
+        if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
         {
-            GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &param);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrparam);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 2.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrparam, &nbRow, &nbCol, &param))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                return 1;
+            }
+
             if (nbRow * nbCol != 1)
             {
-                freeArrayOfString(param, nbRow * nbCol);
+                freeAllocatedMatrixOfString(nbRow, nbCol, param);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
                 return FALSE;
             }
@@ -126,11 +175,11 @@ int sci_toolbar(char *fname, unsigned long l)
             if ((strcmp(param[0], "off") == 0) || (strcmp(param[0], "on") == 0))
             {
                 setToolbarVisible(pParentUID, strcmp(param[0], "on") == 0);
-                freeArrayOfString(param, nbRow * nbCol);
+                freeAllocatedMatrixOfString(nbRow, nbCol, param);
             }
             else
             {
-                freeArrayOfString(param, nbRow * nbCol);
+                freeAllocatedMatrixOfString(nbRow, nbCol, param);
                 Scierror(999, _("%s: Wrong value for input argument #%d: '%s' or '%s' expected.\n"), fname, 2, "on", "off");
                 return FALSE;
             }
@@ -154,8 +203,13 @@ int sci_toolbar(char *fname, unsigned long l)
 
     nbCol = 1;
     nbRow = (int)strlen(Output);
-    CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &nbRow, &nbCol, &Output);
-    LhsVar(1) = Rhs + 1;
+    if (createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, Output))
+    {
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
+
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
 
     if (Output)
     {
@@ -163,7 +217,7 @@ int sci_toolbar(char *fname, unsigned long l)
         Output = NULL;
     }
 
-    PutLhsVar();
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 
index 945ed9a..a28c28a 100644 (file)
@@ -17,7 +17,7 @@
 #include "gw_gui.h"
 #include "gw_gui.h"
 #include "localization.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "GetProperty.h"
 #include "sciprint.h"
 #include "localization.h"
 /*--------------------------------------------------------------------------*/
 int sci_uicontextmenu(char *fname, unsigned long fname_len)
 {
-    int nbRow = 0, nbCol = 0, stkAdr = 0;
+    SciErr sciErr;
 
+    long long* stkAdr = NULL;
+    int nbRow = 0, nbCol = 0;
     unsigned long GraphicHandle = 0;
 
-    CheckRhs(0, 0);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 0, 0);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     /* Create a new context menu */
     GraphicHandle = getHandle(createGraphicObject(__GO_UICONTEXTMENU__));
@@ -41,13 +43,19 @@ int sci_uicontextmenu(char *fname, unsigned long fname_len)
     /* Create return variable */
     nbRow = 1;
     nbCol = 1;
-    CreateVar(Rhs + 1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
-    *hstk(stkAdr) = GraphicHandle;
 
-    LhsVar(1) = Rhs + 1;
+    sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &stkAdr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
 
-    PutLhsVar();
+    *stkAdr = GraphicHandle;
 
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 
index f0176d2..00f664c 100644 (file)
 #include "CurrentFigure.h"
 #include "BuildObjects.h"
 #include "api_scilab.h"
+
+/* DO NOT CHANGE ORDER !! */
+static const char* propertiesNames[] =
+{
+    "style",
+    "parent",
+    "backgroundcolor",
+    "foregroundcolor",
+    "string",
+    "units",
+    "fontweight",
+    "min",
+    "max",
+    "tag",
+    "position",
+    "relief",
+    "horizontalalignment",
+    "verticalalignment",
+    "sliderstep",
+    "fontname",
+    "callback",
+    "fontangle",
+    "fontunits",
+    "fontsize",
+    "listboxtop",
+    "user_data",
+    "value",
+    "userdata",
+    "visible",
+    "enable",
+    "callback_type",
+    "tooltipstring"
+};
+
 /*--------------------------------------------------------------------------*/
-#define NBPROPERTIES 28
-#define MAXPROPERTYNAMELENGTH 20
+//#define NBPROPERTIES 28
+//#define MAXPROPERTYNAMELENGTH 20
+/*--------------------------------------------------------------------------*/
+// callSetProperty get a stack pointer in input argument.
 /*--------------------------------------------------------------------------*/
 int sci_uicontrol(char *fname, unsigned long fname_len)
 {
-    int nbRow = 0, nbCol = 0, stkAdr = 0, k = 0;
-    char **stkAdrForStrings = NULL;
+    SciErr sciErr;
 
+    int nbRow = 0, nbCol = 0, k = 0;
     int setStatus = SET_PROPERTY_SUCCEED;
-
     int NOT_FOUND = -1;
-
     int inputIndex = 0, beginIndex = 0;
-
     char *propertyName = NULL;
     char *styleProperty = NULL;
-
     char *pParentUID = NULL;
     char *pUicontrol = NULL;
 
+    int iPropertiesCount = sizeof(propertiesNames) / sizeof(char**);
     unsigned long GraphicHandle = 0;
 
     int found = 0;              /* Does the property exists ? */
 
-    /* @TODO remove this crappy initialization */
-    /* DO NOT CHANGE ORDER !! */
-    char propertiesNames[NBPROPERTIES][MAXPROPERTYNAMELENGTH] =
-    {
-        "style", "parent", "backgroundcolor", "foregroundcolor", "string", "units", "fontweight", "min", "max", "tag", "position", "relief",
-        "horizontalalignment", "verticalalignment", "sliderstep", "fontname", "callback", "fontangle", "fontunits", "fontsize", "listboxtop", "user_data", "value", "userdata", "visible", "enable",
-        "callback_type", "tooltipstring"
-    };
     int *propertiesValuesIndices = NULL;
-    int lw = 0;
-    char *propertyPart = NULL;
 
     int iParentType = -1;
     int *piParentType = &iParentType;
@@ -76,9 +99,9 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
     int *piParentStyle = &iParentStyle;
     char const* pstCurrentFigure = NULL;
 
-    CheckLhs(0, 1);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
-    if (Rhs == 0)
+    if (nbInputArgument(pvApiCtx) == 0)
     {
         /* Create a pushbutton in current figure */
 
@@ -94,33 +117,46 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
         setGraphicObjectRelationship(pstCurrentFigure, (char*)getObjectFromHandle(GraphicHandle));
         pUicontrol = (char*)getObjectFromHandle(GraphicHandle);
     }
-    else if (Rhs == 1)
+    else if (nbInputArgument(pvApiCtx) == 1)
     {
         /* Create a pushbutton in figure given as parameter */
         /* Or give focus to the uicontrol given as parameter */
 
-        if (VarType(1) != sci_handles)
+        if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles)))
         {
-            lw = 1 + Top - Rhs;
-            C2F(overload) (&lw, "uicontrol", 9);
+            OverLoad(1);
             return FALSE;
         }
-        else                    /* Get parent ID */
+        else /* Get parent ID */
         {
-            GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
+            int* piAddr = NULL;
+            long long hParent = 0;
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
 
-            if (nbRow * nbCol != 1)
+            if (isScalar(pvApiCtx, piAddr) == 0)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
                 return FALSE;
             }
-            pParentUID = (char*)getObjectFromHandle((long) * hstk(stkAdr));
+
+            if (getScalarHandle(pvApiCtx, piAddr, &hParent))
+            {
+                Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+                return 1;
+            }
+
+            pParentUID = (char*)getObjectFromHandle((long)hParent);
             if (pParentUID != NULL)
             {
                 getGraphicObjectProperty(pParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
                 if (iParentType == __GO_UICONTROL__)  /* Focus management */
                 {
-                    GraphicHandle = (long) * hstk(stkAdr);
+                    GraphicHandle = (unsigned long)hParent;
                     requestFocus(pParentUID);
                 }
                 else if (iParentType == __GO_FIGURE__ || iParentType == __GO_UIMENU__)  /* PushButton creation */
@@ -130,7 +166,7 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
 
                     /* First parameter is the parent */
                     setGraphicObjectRelationship(pParentUID, getObjectFromHandle(GraphicHandle));
-                    setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), stkAdr, sci_handles, nbRow, nbCol, (char *)propertiesNames[1]);
+                    setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), &hParent, sci_handles, 1, 1, (char*)propertiesNames[1]);
                     if (setStatus == SET_PROPERTY_ERROR)
                     {
                         Scierror(999, _("%s: Could not set property '%s'.\n"), fname, propertyName);
@@ -155,22 +191,21 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
     }
     else
     {
-        if ((VarType(1) != sci_handles) && (VarType(1) != sci_strings))
+        if (!checkInputArgumentType(pvApiCtx, 1, sci_handles) && !checkInputArgumentType(pvApiCtx, 1, sci_strings))
         {
-            lw = 1 + Top - Rhs;
-            C2F(overload) (&lw, "uicontrol", 9);
+            OverLoad(1);
             return FALSE;
         }
 
         /* Allocate memory to store the position of properties in uicontrol call */
-        if ((propertiesValuesIndices = (int *)MALLOC(sizeof(int) * NBPROPERTIES)) == NULL)
+        if ((propertiesValuesIndices = (int*)MALLOC(sizeof(int) * iPropertiesCount)) == NULL)
         {
             Scierror(999, _("%s: No more memory.\n"), fname);
             return FALSE;
         }
 
         /* Init all positions to NOT_FOUND */
-        for (inputIndex = 0; inputIndex < NBPROPERTIES; inputIndex++)
+        for (inputIndex = 0; inputIndex < iPropertiesCount; inputIndex++)
         {
             propertiesValuesIndices[inputIndex] = NOT_FOUND;    /* Property initialized as not found */
         }
@@ -181,42 +216,56 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
          * All event inputs are property names
          * All odd (except first) inputs are property values
          */
-        if (Rhs % 2 == 1)
+        if (nbInputArgument(pvApiCtx) % 2 == 1)
         {
-            if (VarType(1) != sci_handles)
+            if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles)))
             {
-                if (VarType(1) == sci_matrix)
+                if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
                 {
-                    GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
-                    if (nbRow * nbCol == 1)
+                    int* piAddr = NULL;
+                    double dblValue = 0;
+
+                    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+                    if (sciErr.iErr)
                     {
-                        pParentUID = (char*)getFigureFromIndex((int)(*stk(stkAdr)));
+                        printError(&sciErr, 0);
+                        return 1;
+                    }
 
-                        if (pParentUID == NULL)
+                    if (isScalar(pvApiCtx, piAddr) == 0)
+                    {
+                        Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
+                        return FALSE;
+                    }
+
+                    if (getScalarDouble(pvApiCtx, piAddr, &dblValue))
+                    {
+                        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                        return 1;
+                    }
+
+                    pParentUID = (char*)getFigureFromIndex((int)dblValue);
+
+                    if (pParentUID == NULL)
+                    {
+                        Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
+                                 "Frame uicontrol");
+                        return FALSE;
+                    }
+
+                    getGraphicObjectProperty(pParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
+                    if (iParentType != __GO_FIGURE__)
+                    {
+                        getGraphicObjectProperty(pParentUID, __GO_STYLE__, jni_int, (void **)&piParentStyle);
+                        if (iParentType != __GO_UICONTROL__ || iParentStyle != __GO_UI_FRAME__)
                         {
                             Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
                                      "Frame uicontrol");
                             return FALSE;
                         }
-                        getGraphicObjectProperty(pParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
-                        if (iParentType != __GO_FIGURE__)
-                        {
-                            getGraphicObjectProperty(pParentUID, __GO_STYLE__, jni_int, (void **)&piParentStyle);
-                            if (iParentType != __GO_UICONTROL__ || iParentStyle != __GO_UI_FRAME__)
-                            {
-                                Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
-                                         "Frame uicontrol");
-                                return FALSE;
-                            }
-                        }
-                        /* First parameter is the parent */
-                        propertiesValuesIndices[1] = 1;
-                    }
-                    else
-                    {
-                        Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
-                        return FALSE;
                     }
+                    /* First parameter is the parent */
+                    propertiesValuesIndices[1] = 1;
                 }
                 else
                 {
@@ -225,17 +274,31 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
                     return FALSE;
                 }
             }
-            else                /* Get parent ID */
+            else /* Get parent ID */
             {
-                GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
+                int* piAddr = NULL;
+                long long hParent = 0;
+                sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 1;
+                }
 
-                if (nbRow * nbCol != 1)
+                if (isScalar(pvApiCtx, piAddr) == 0)
                 {
                     Scierror(999, _("%s: Wrong size for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
                              "Frame uicontrol");
                     return FALSE;
                 }
-                pParentUID = (char*)getObjectFromHandle((long) * hstk(stkAdr));
+
+                if (getScalarHandle(pvApiCtx, piAddr, &hParent))
+                {
+                    Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+                    return 1;
+                }
+
+                pParentUID = (char*)getObjectFromHandle((long)hParent);
                 if (pParentUID == NULL)
                 {
                     Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' or a '%s' handle expected.\n"), fname, 1, "Figure",
@@ -275,35 +338,37 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
         for (inputIndex = beginIndex; inputIndex < Rhs; inputIndex = inputIndex + 2)
         {
             /* Read property name */
-            if (VarType(inputIndex) != sci_strings)
+            if ((!checkInputArgumentType(pvApiCtx, inputIndex, sci_strings)))
             {
                 Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, inputIndex);
                 return FALSE;
             }
             else
             {
-                GetRhsVar(inputIndex, STRING_DATATYPE, &nbRow, &nbCol, &stkAdr);
-                propertyName = cstk(stkAdr);
+                int* piAddr = NULL;
+                sciErr = getVarAddressFromPosition(pvApiCtx, inputIndex, &piAddr);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 1;
+                }
 
-                /* Bug 3031 */
-                /* We only want to compare propertyName along its length */
-                /* 'posi' must be matched to 'position' */
-                propertyPart = (char *)MALLOC(sizeof(char) * (MAXPROPERTYNAMELENGTH + 1));
-                if (propertyPart == NULL)
+                if (getAllocatedSingleString(pvApiCtx, piAddr, &propertyName))
                 {
-                    Scierror(999, _("%s: No more memory.\n"), fname);
-                    return FALSE;
+                    Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, inputIndex);
+                    return 1;
                 }
 
+
+                /* Bug 3031 */
+                /* We only want to compare propertyName along its length */
+                /* 'posi' must be matched to 'position' */
                 found = 0;
-                for (k = 0; k < NBPROPERTIES; k++)
+                for (k = 0; k < iPropertiesCount ; k++)
                 {
-                    if (strlen(propertyName) <= MAXPROPERTYNAMELENGTH)
+                    if (strlen(propertyName) <= strlen(propertiesNames[k]))
                     {
-                        strncpy(propertyPart, propertiesNames[k], strlen(propertyName));
-                        propertyPart[strlen(propertyName)] = '\0';
-
-                        if (stricmp(propertyName, propertyPart) == 0)
+                        if (strnicmp(propertyName, propertiesNames[k], strlen(propertyName)) == 0)
                         {
                             propertiesValuesIndices[k] = inputIndex + 1;    /* Position of value for property */
                             found = 1;
@@ -312,8 +377,6 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
                     }
                 }
 
-                FREE(propertyPart);
-
                 if (found == 0)
                 {
                     Scierror(999, _("%s: Unknown property: %s for '%s' handles.\n"), fname, propertyName, "Uicontrol");
@@ -324,10 +387,21 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
 
         if (propertiesValuesIndices[0] != NOT_FOUND)    /* Style found */
         {
-            if (VarType(propertiesValuesIndices[0]) == sci_strings)
+            if ((checkInputArgumentType(pvApiCtx, propertiesValuesIndices[0], sci_strings)))
             {
-                GetRhsVar(propertiesValuesIndices[0], STRING_DATATYPE, &nbRow, &nbCol, &stkAdr);
-                styleProperty = cstk(stkAdr);
+                int* piAddr = NULL;
+                sciErr = getVarAddressFromPosition(pvApiCtx, propertiesValuesIndices[0], &piAddr);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 1;
+                }
+
+                if (getAllocatedSingleString(pvApiCtx, piAddr, &styleProperty))
+                {
+                    Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, propertiesValuesIndices[0]);
+                    return 1;
+                }
             }
             else
             {
@@ -338,6 +412,7 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
 
         /* Create a new uicontrol */
         pUicontrol = CreateUIControl(styleProperty);
+        freeAllocatedSingleString(styleProperty);
         if (pUicontrol == NULL) /* Error in creation */
         {
             Scierror(999, _("%s: Could not create 'Uicontrol' handle.\n"), fname);
@@ -361,54 +436,86 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
         }
 
         /* Read and set all properties */
-        for (inputIndex = 1; inputIndex < NBPROPERTIES; inputIndex++)   /* Style has already been set */
+        for (inputIndex = 1; inputIndex < iPropertiesCount; inputIndex++)   /* Style has already been set */
         {
             if (propertiesValuesIndices[inputIndex] != NOT_FOUND)
             {
+                int* piAddr = NULL;
+                sciErr = getVarAddressFromPosition(pvApiCtx, propertiesValuesIndices[inputIndex], &piAddr);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 1;
+                }
+
                 if (inputIndex == 21 || inputIndex == 23)   /* User data settings */
                 {
-                    stkAdr = propertiesValuesIndices[inputIndex];   /* Special management */
                     nbRow = -1;
                     nbCol = -1;
-                    setStatus =
-                        callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), stkAdr, VarType(propertiesValuesIndices[inputIndex]), nbRow, nbCol,
-                                        (char *)propertiesNames[inputIndex]);
+                    setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), piAddr, 0, 0, 0, (char*)propertiesNames[inputIndex]);
                 }
                 else            /* All other properties */
                 {
                     /* Read property value */
-                    switch (VarType(propertiesValuesIndices[inputIndex]))
+                    switch (getInputArgumentType(pvApiCtx, propertiesValuesIndices[inputIndex]))
                     {
                         case sci_matrix:
-                            GetRhsVar(propertiesValuesIndices[inputIndex], MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
-                            setStatus =
-                                callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), stkAdr, sci_matrix, nbRow, nbCol,
-                                                (char *)propertiesNames[inputIndex]);
+                        {
+                            double* pdblValue = NULL;
+                            sciErr = getMatrixOfDouble(pvApiCtx, piAddr, &nbRow, &nbCol, &pdblValue);
+                            if (sciErr.iErr)
+                            {
+                                printError(&sciErr, 0);
+                                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, propertiesValuesIndices[inputIndex]);
+                                return 1;
+                            }
+
+                            setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), pdblValue, sci_matrix, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
                             break;
+                        }
                         case sci_strings:
                             /* Index for String & TooltipString properties: Can be more than one character string */
                             if ((inputIndex == 4) || (inputIndex == 27))
                             {
-                                GetRhsVar(propertiesValuesIndices[inputIndex], MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &stkAdrForStrings);
-                                setStatus =
-                                    callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), (size_t) stkAdrForStrings, sci_strings, nbRow, nbCol,
-                                                    (char *)propertiesNames[inputIndex]);
-                                freeArrayOfString(stkAdrForStrings, nbRow * nbCol);
+                                char** pstValue = NULL;
+                                if (getAllocatedMatrixOfString(pvApiCtx, piAddr, &nbRow, &nbCol, &pstValue))
+                                {
+                                    Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, propertiesValuesIndices[inputIndex]);
+                                    return 1;
+                                }
+
+                                setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), pstValue, sci_strings, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
+                                freeAllocatedMatrixOfString(nbRow, nbCol, pstValue);
                             }
                             else
                             {
-                                GetRhsVar(propertiesValuesIndices[inputIndex], STRING_DATATYPE, &nbRow, &nbCol, &stkAdr);
-                                setStatus =
-                                    callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), stkAdr, sci_strings, nbRow, nbCol,
-                                                    (char *)propertiesNames[inputIndex]);
+                                char* pstValue = NULL;
+                                if (getAllocatedSingleString(pvApiCtx, piAddr, &pstValue))
+                                {
+                                    Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, propertiesValuesIndices[inputIndex]);
+                                    return 1;
+                                }
+
+                                nbRow = (int)strlen(pstValue);
+                                nbCol = 1;
+                                setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), pstValue, sci_strings, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
+                                freeAllocatedSingleString(pstValue);
                             }
                             break;
                         case sci_handles:
-                            GetRhsVar(propertiesValuesIndices[inputIndex], GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
-                            setStatus =
-                                callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), stkAdr, sci_handles, nbRow, nbCol,
-                                                (char *)propertiesNames[inputIndex]);
+                        {
+                            long long* pHandles = NULL;
+                            sciErr = getMatrixOfHandle(pvApiCtx, piAddr, &nbRow, &nbCol, &pHandles);
+                            if (sciErr.iErr)
+                            {
+                                printError(&sciErr, 0);
+                                Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, propertiesValuesIndices[inputIndex]);
+                                return 1;
+                            }
+
+                            setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), pHandles, sci_handles, nbRow, nbCol, (char*)propertiesNames[inputIndex]);
                             break;
+                        }
                         default:
                             setStatus = SET_PROPERTY_ERROR;
                             break;
@@ -416,21 +523,21 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
                 }
                 if (setStatus == SET_PROPERTY_ERROR)
                 {
-                    Scierror(999, _("%s: Could not set property '%s'.\n"), fname, (char *)propertiesNames[inputIndex]);
+                    Scierror(999, _("%s: Could not set property '%s'.\n"), fname, (char*)propertiesNames[inputIndex]);
                     return FALSE;
                 }
             }
         }
     }
 
-    if ((Rhs < 2) || (propertiesValuesIndices[24] == NOT_FOUND))    /* Visible property not set */
+    if ((nbInputArgument(pvApiCtx) < 2) || (propertiesValuesIndices[24] == NOT_FOUND))    /* Visible property not set */
     {
         /* Force the uicontrol to be visible because is invisible by default in the model (See bug #10346) */
         int b = (int)TRUE;
         setGraphicObjectProperty(pUicontrol, __GO_VISIBLE__, &b, jni_bool, 1);
     }
 
-    if ((Rhs < 2) || (propertiesValuesIndices[14] == NOT_FOUND))    /* SliderStep property not set */
+    if ((nbInputArgument(pvApiCtx) < 2) || (propertiesValuesIndices[14] == NOT_FOUND))    /* SliderStep property not set */
     {
         /* Set SliderStep property to [1/100*(Max-Min) 1/10*(Max-Min)] */
         double maxValue = 0;
@@ -451,15 +558,14 @@ int sci_uicontrol(char *fname, unsigned long fname_len)
     FREE(propertiesValuesIndices);
 
     /* Create return variable */
-    nbRow = 1;
-    nbCol = 1;
-    CreateVar(Rhs + 1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
-    *hstk(stkAdr) = GraphicHandle;
-
-    LhsVar(1) = Rhs + 1;
-
-    PutLhsVar();
+    if (createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, GraphicHandle))
+    {
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
 
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 
index 09fce18..c9c577a 100644 (file)
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "Scierror.h"
 #include "CallColorChooser.h"
 
 /*--------------------------------------------------------------------------*/
-int sci_uigetcolor(char *fname,unsigned long fname_len)
+int sci_uigetcolor(char *fname, unsigned long fname_len)
 {
-  int colorChooserID = 0;
-  int firstColorIndex = 0;
+    SciErr sciErr;
 
-  int nbRow = 0, nbCol = 0;
+    //WARNING ALL NEW DECALRATIONS ARE HERE IF YOUR HAVE MANY FUNCTIONS
+    //IN THE FILE YOU HAVE PROBABLY TO MOVE DECLARATIONS IN GOOD FUNCTIONS
+    int* piAddrredAdr = NULL;
+    double* redAdr = NULL;
+    int* piAddrtitleAdr = NULL;
+    char* titleAdr = NULL;
+    int* piAddrgreenAdr = NULL;
+    double* greenAdr = NULL;
+    int* piAddrblueAdr = NULL;
+    double* blueAdr = NULL;
 
-  int redAdr = 0;
-  int greenAdr = 0;
-  int blueAdr = 0;
-  int titleAdr = 0;
+    int colorChooserID = 0;
+    int firstColorIndex = 0;
 
-  double *selectedRGB = NULL;
+    int nbRow = 0, nbCol = 0;
 
-  CheckRhs(0, 4);
+    double *selectedRGB = NULL;
 
-  if ((Lhs!=1) && (Lhs!=3)) /* Bad use */
+    CheckInputArgument(pvApiCtx, 0, 4);
+
+    if ((nbOutputArgument(pvApiCtx) != 1) && (nbOutputArgument(pvApiCtx) != 3)) /* Bad use */
     {
-      Scierror(999, _("%s: Wrong number of output arguments: %d or %d expected.\n"), fname, 1, 3);
-      return FALSE;
+        Scierror(999, _("%s: Wrong number of output arguments: %d or %d expected.\n"), fname, 1, 3);
+        return FALSE;
     }
-  
-  /* Rhs==1: title or [R, G, B] given */
-  if (Rhs==1)
+
+    /* Rhs==1: title or [R, G, B] given */
+    if (nbInputArgument(pvApiCtx) == 1)
     {
-      if (VarType(1) == sci_matrix)
+        if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
         {
-          GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &redAdr);
-          if ((nbRow != 1) || (nbCol != 3))
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrredAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrredAdr, &nbRow, &nbCol, &redAdr);
+            if (sciErr.iErr)
             {
-              Scierror(999, _("%s: Wrong size for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 1, 3);
-              return FALSE;
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                return 1;
+            }
+
+            if ((nbRow != 1) || (nbCol != 3))
+            {
+                Scierror(999, _("%s: Wrong size for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 1, 3);
+                return FALSE;
             }
         }
-      else if (VarType(1) == sci_strings)
+        else if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
         {
-          GetRhsVar(1, STRING_DATATYPE, &nbRow, &nbCol, &titleAdr);
-          if (nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrtitleAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            if (getAllocatedSingleString(pvApiCtx, piAddrtitleAdr, &titleAdr))
             {
-              Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
-              return FALSE;
+                Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+                return 1;
+            }
+
+            if (nbCol != 1)
+            {
+                Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
+                return FALSE;
             }
         }
-      else
+        else
         {
-          Scierror(999, _("%s: Wrong type for input argument #%d: A real or a string expected.\n"), fname, 1);
-          return FALSE;
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real or a string expected.\n"), fname, 1);
+            return FALSE;
         }
     }
 
-  /* Title and [R, G, B] given */
-  if (Rhs==2)
+    /* Title and [R, G, B] given */
+    if (nbInputArgument(pvApiCtx) == 2)
     {
-      /* Title */
-      if (VarType(1) == sci_strings)
+        /* Title */
+        if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
         {
-          GetRhsVar(1, STRING_DATATYPE, &nbRow, &nbCol, &titleAdr);
-          if (nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrtitleAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            if (getAllocatedSingleString(pvApiCtx, piAddrtitleAdr, &titleAdr))
             {
-              Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
-              return FALSE;
+                Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+                return 1;
+            }
+
+            if (nbCol != 1)
+            {
+                Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
+                return FALSE;
             }
         }
-      else
+        else
         {
-          Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
-          return FALSE;
+            Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
+            return FALSE;
         }
 
-      /* [R, G, B] */
-      if (VarType(2) == sci_matrix)
+        /* [R, G, B] */
+        if ((checkInputArgumentType(pvApiCtx, 2, sci_matrix)))
         {
-          GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &redAdr);
-          if (nbRow*nbCol != 3)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrredAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 2.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrredAdr, &nbRow, &nbCol, &redAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 3)
             {
-              Scierror(999, _("%s: Wrong size for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 2, 3);
-              return FALSE;
+                Scierror(999, _("%s: Wrong size for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 2, 3);
+                return FALSE;
             }
         }
-      else
+        else
         {
-          Scierror(999, _("%s: Wrong type for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 2, 3);
-          return FALSE;
+            Scierror(999, _("%s: Wrong type for input argument #%d: A 1 x %d real row vector expected.\n"), fname, 2, 3);
+            return FALSE;
         }
     }
 
-  /* No title given but colors given with separate values */
-  if (Rhs==3)
+    /* No title given but colors given with separate values */
+    if (nbInputArgument(pvApiCtx) == 3)
     {
-      firstColorIndex = 1;
+        firstColorIndex = 1;
     }
 
-  /* Title and colors given with separate values */
-  if (Rhs==4)
+    /* Title and colors given with separate values */
+    if (nbInputArgument(pvApiCtx) == 4)
     {
-      firstColorIndex = 2;
-      
-      /* Title */
-      if (VarType(1) == sci_strings)
+        firstColorIndex = 2;
+
+        /* Title */
+        if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
         {
-          GetRhsVar(1, STRING_DATATYPE, &nbRow, &nbCol, &titleAdr);
-          if (nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrtitleAdr);
+            if (sciErr.iErr)
             {
-              Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
-              return FALSE;
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            if (getAllocatedSingleString(pvApiCtx, piAddrtitleAdr, &titleAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+                return 1;
+            }
+
+            if (nbCol != 1)
+            {
+                Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
+                return FALSE;
             }
         }
-      else
+        else
         {
-          Scierror(999, _("%s: Wrong type for input argument #%d: A real or a string expected.\n"), fname, 1);
-          return FALSE;
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real or a string expected.\n"), fname, 1);
+            return FALSE;
         }
     }
 
-  /* R, G, B given */
-  if (Rhs>=3)
+    /* R, G, B given */
+    if (nbInputArgument(pvApiCtx) >= 3)
     {
-      /* Default red value */
-      if (VarType(firstColorIndex) == sci_matrix)
+        /* Default red value */
+        if ((checkInputArgumentType(pvApiCtx, firstColorIndex, sci_matrix)))
         {
-          GetRhsVar(firstColorIndex, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &redAdr);
-          if (nbRow*nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, firstColorIndex, &piAddrredAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position firstColorIndex.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrredAdr, &nbRow, &nbCol, &redAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, firstColorIndex);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
             {
-              Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex);
-              return FALSE;
+                Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex);
+                return FALSE;
             }
         }
-      else
+        else
         {
-          Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex);
-          return FALSE;
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex);
+            return FALSE;
         }
-      
-      /* Default green value */
-      if (VarType(firstColorIndex + 1) == sci_matrix)
+
+        /* Default green value */
+        if (VarType(firstColorIndex + 1) == sci_matrix)
         {
-          GetRhsVar(firstColorIndex + 1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &greenAdr);
-          if (nbRow*nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, firstColorIndex + 1, &piAddrgreenAdr);
+            if (sciErr.iErr)
             {
-              Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex + 1);
-              return FALSE;
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position firstColorIndex + 1.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrgreenAdr, &nbRow, &nbCol, &greenAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, firstColorIndex + 1);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
+            {
+                Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex + 1);
+                return FALSE;
             }
         }
-      else
+        else
         {
-          Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex + 1);
-          return FALSE;
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex + 1);
+            return FALSE;
         }
-      
-      /* Default blue value */
-      if (VarType(firstColorIndex + 2) == sci_matrix)
+
+        /* Default blue value */
+        if (VarType(firstColorIndex + 2) == sci_matrix)
         {
-          GetRhsVar(firstColorIndex + 2, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &blueAdr);
-          if (nbRow*nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, firstColorIndex + 2, &piAddrblueAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position firstColorIndex + 2.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrblueAdr, &nbRow, &nbCol, &blueAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, firstColorIndex + 2);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
             {
-              Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex + 2);
-              return FALSE;
+                Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, firstColorIndex + 2);
+                return FALSE;
             }
         }
-      else
+        else
         {
-          Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex + 2);
-          return FALSE;
+            Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, firstColorIndex + 2);
+            return FALSE;
         }
     }
-  
-  /* Create the Java Object */
-  colorChooserID = createColorChooser();
 
-  /* Title */
-  if (titleAdr != 0)
+    /* Create the Java Object */
+    colorChooserID = createColorChooser();
+
+    /* Title */
+    if (titleAdr != 0)
     {
-      setColorChooserTitle(colorChooserID, cstk(titleAdr));
+        setColorChooserTitle(colorChooserID, titleAdr);
+        freeAllocatedSingleString(titleAdr);
     }
 
-  /* Default red value */
-  if (redAdr != 0)
+    /* Default red value */
+    if (redAdr != 0)
     {
-      if (greenAdr !=0 ) /* All values given in first input argument */
+        if (greenAdr != 0 ) /* All values given in first input argument */
         {
-          setColorChooserDefaultRGBSeparateValues(colorChooserID, (int)stk(redAdr)[0], (int)stk(greenAdr)[0], (int)stk(blueAdr)[0]);
+            setColorChooserDefaultRGBSeparateValues(colorChooserID, (int)redAdr[0], (int)greenAdr[0], (int)blueAdr[0]);
         }
-      else
+        else
         {
-          setColorChooserDefaultRGB(colorChooserID, stk(redAdr));
+            setColorChooserDefaultRGB(colorChooserID, redAdr);
         }
     }
 
-  /* Display it and wait for a user input */
-  colorChooserDisplayAndWait(colorChooserID);
-
-  /* Return the selected color */
+    /* Display it and wait for a user input */
+    colorChooserDisplayAndWait(colorChooserID);
 
-  /* Read the user answer */
-  selectedRGB = getColorChooserSelectedRGB(colorChooserID);
+    /* Return the selected color */
+    /* Read the user answer */
+    selectedRGB = getColorChooserSelectedRGB(colorChooserID);
 
-  if (selectedRGB[0] >= 0) /* The user selected a color */
+    if (selectedRGB[0] >= 0) /* The user selected a color */
     {
 
-      nbRow = 1;
-      if (Lhs==1)
+        nbRow = 1;
+        if (nbOutputArgument(pvApiCtx) == 1)
         {
-          nbCol = 3;
-          CreateVarFromPtr(Rhs+1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &selectedRGB);
-          LhsVar(1) = Rhs+1;
+            nbCol = 3;
+            sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, selectedRGB);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
+            AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
         }
 
-      if (Lhs>=2)
+        if (nbOutputArgument(pvApiCtx) >= 2)
         {
-          nbCol = 1;
-          CreateVar(Rhs+1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &redAdr);
-          *stk(redAdr) = selectedRGB[0];
-          CreateVar(Rhs+2, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &greenAdr);
-          *stk(greenAdr) = selectedRGB[1];
-          CreateVar(Rhs+3, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &blueAdr);
-          *stk(blueAdr) = selectedRGB[2];
-
-          LhsVar(1) = Rhs+1;
-          LhsVar(2) = Rhs+2;
-          LhsVar(3) = Rhs+3;
+            nbCol = 1;
+
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &redAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
+            redAdr[0] = selectedRGB[0];
+
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &greenAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
+            greenAdr[0] = selectedRGB[1];
+
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &blueAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
+            blueAdr[0] = selectedRGB[2];
+
+            AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+            AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+            AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
         }
     }
-  else /* The user canceled */
+    else /* The user canceled */
     {
-      nbRow = 0; nbCol = 0;
-      if (Lhs==1)
+        nbRow = 0;
+        nbCol = 0;
+        if (nbOutputArgument(pvApiCtx) == 1)
         {
-          /* Return [] */
-          CreateVar(Rhs+1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &redAdr);
+            /* Return [] */
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &redAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
 
-          LhsVar(1) = Rhs+1;
+
+            AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
         }
 
-      if (Lhs>=2)
+        if (nbOutputArgument(pvApiCtx) >= 2)
         {
-          CreateVar(Rhs+1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &redAdr);
-          CreateVar(Rhs+2, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &greenAdr);
-          CreateVar(Rhs+3, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &blueAdr);
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &redAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &greenAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &blueAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
 
-          LhsVar(1) = Rhs+1;
-          LhsVar(2) = Rhs+2;
-          LhsVar(3) = Rhs+3;
+            AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+            AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+            AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
         }
     }
 
-  PutLhsVar();
-  return TRUE;
+    ReturnArguments(pvApiCtx);
+    return TRUE;
 }
 /*--------------------------------------------------------------------------*/
diff --git a/scilab/modules/gui/sci_gateway/c/sci_uigetdir.c b/scilab/modules/gui/sci_gateway/c/sci_uigetdir.c
deleted file mode 100644 (file)
index 4a47490..0000000
+++ /dev/null
@@ -1,144 +0,0 @@
-/*
- * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
- * Copyright (C) 2007 - INRIA - Vincent COUVERT
- *
- * This file must be used under the terms of the CeCILL.
- * This source file is licensed as described in the file COPYING, which
- * you should have received as part of this distribution.  The terms
- * are also available at
- * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
- *
- */
-
-#include "gw_gui.h"
-#include "PATH_MAX.h"
-#include "stack-c.h"
-#include "CallFileChooser.h"
-#include "MALLOC.h"
-#include "localization.h"
-#include "Scierror.h"
-#include "cluni0.h"
-/*--------------------------------------------------------------------------*/
-int sci_uigetdir(char *fname,unsigned long l)
-{
-  int fileChooserID = 0;
-
-  int nbRow = 0, nbCol = 0;
-
-
-  int voidSelectionAdr = 0;
-
-  int titleAdr = 0;
-  int initialDirectoryAdr = 0;
-
-  char *title = NULL, *initialDirectory = NULL;
-
-  CheckRhs(0,2);
-  CheckLhs(1,1);
-
-  if (Rhs==1)
-    {
-      if (VarType(1) == sci_strings)
-        {
-          GetRhsVar(1, STRING_DATATYPE, &nbRow, &nbCol, &initialDirectoryAdr);
-          if (nbCol !=1)
-            {
-              Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname,1);
-              return FALSE;
-            }
-          initialDirectory = cstk(initialDirectoryAdr);
-        }
-      else
-        {
-          Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
-          return FALSE;
-        }
-    }
-  else if (Rhs==2)
-    {
-      /* First argument is initial directory */
-      if (VarType(1) == sci_strings)
-        {
-          GetRhsVar(1, STRING_DATATYPE, &nbRow, &nbCol, &initialDirectoryAdr);
-          if (nbCol !=1)
-            {
-              Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
-              return FALSE;
-            }
-          initialDirectory = cstk(initialDirectoryAdr);
-        }
-      else
-        {
-          Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
-          return FALSE;
-        }
-
-      /* Second argument is title */
-      if (VarType(2) == sci_strings)
-        {
-          GetRhsVar(2, STRING_DATATYPE, &nbRow, &nbCol, &titleAdr);
-          if (nbCol !=1)
-            {
-              Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 2);
-              return FALSE;
-            }
-          title = cstk(titleAdr);
-        }
-      else
-        {
-          Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 2);
-          return FALSE;
-        }
-    }
-
-  /* Create the Java Object */
-  fileChooserID = createFileChooser();
-
-  /* Set options */
-  if (title != NULL)
-    {
-      setFileChooserTitle(fileChooserID, title);
-    }
-
-  if (initialDirectory != NULL)
-    {
-               char expandedpath[PATH_MAX+1];
-               int out_n = 0;
-               C2F(cluni0)(initialDirectory ,expandedpath, &out_n,(int)strlen(initialDirectory),PATH_MAX);
-               setFileChooserInitialDirectory(fileChooserID, expandedpath);
-    }
-
-  setFileChooserDirectorySelectionOnly(fileChooserID);
-
-  /* Display it and wait for a user input */
-  fileChooserDisplayAndWait(fileChooserID);
-
-  /* Read the size of the selection, if 0 then no file selected */
-  nbRow = getFileChooserSelectionSize(fileChooserID);
-
-  if (nbRow !=0 )
-    {
-         char **userSelection = NULL;
-      /* The user selected a file --> returns the files names */
-      nbCol = 1;
-
-      userSelection = getFileChooserSelection(fileChooserID);
-      CreateVarFromPtr(Rhs+1, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, userSelection);
-      /* TO DO a delete [] userSelection */
-
-    }
-  else
-    {
-      /* The user canceled the selection --> returns an empty matrix */
-      nbRow = 0;
-      nbCol = 0;
-
-      CreateVar(Rhs+1, STRING_DATATYPE, &nbRow, &nbCol, &voidSelectionAdr);
-    }
-
-  LhsVar(1)=Rhs+1;
-  PutLhsVar();;
-
-  return TRUE;
-}
-/*--------------------------------------------------------------------------*/
index d92e5f2..1ed3fa0 100644 (file)
@@ -11,7 +11,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "Scierror.h"
 #include "CallFontChooser.h"
 /*--------------------------------------------------------------------------*/
 int sci_uigetfont(char *fname, unsigned long fname_len)
 {
-    int fontChooserID = 0;
+    SciErr sciErr;
 
-    int nbRow = 0, nbCol = 0;
+    int* piAddrfontNameAdr  = NULL;
+    int* piAddrfontSizeAdr  = NULL;
+    int* piAddrboldAdr      = NULL;
+    int* boldAdr            = NULL;
+    int* piAddritalicAdr    = NULL;
+    int* italicAdr          = NULL;
+    double* fontSizeAdr     = NULL;
 
-    char **fontNameAdr = NULL;
-    int fontNameSize = 0;
-    int fontSizeAdr = 0;
-    int boldAdr = 0;
-    int italicAdr = 0;
+    int fontChooserID = 0;
+    int nbRow = 0;
+    int nbCol = 0;
 
-    char *selectedFontName = NULL;
-    int selectedFontSize = 0;
-    BOOL selectedBold = FALSE;
-    BOOL selectedItalic = FALSE;
+    char **fontNameAdr = NULL;
+    int fontNameSize   = 0;
 
+    char *selectedFontName  = NULL;
+    int selectedFontSize    = 0;
+    BOOL selectedBold       = FALSE;
+    BOOL selectedItalic     = FALSE;
 
-    CheckRhs(0, 4);
-    CheckLhs(1, 4);
+    CheckInputArgument(pvApiCtx, 0, 4);
+    CheckOutputArgument(pvApiCtx, 1, 4);
 
     /* Default font name */
-    if (Rhs >= 1)
+    if (nbInputArgument(pvApiCtx) >= 1)
     {
-        if (VarType(1) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
         {
-            GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &fontNameAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfontNameAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 1.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrfontNameAdr, &nbRow, &nbCol, &fontNameAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+                return 1;
+            }
+
             fontNameSize = nbRow * nbCol;
             if (fontNameSize != 1)
             {
-                freeArrayOfString(fontNameAdr, fontNameSize);
+                freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 1);
                 return FALSE;
             }
@@ -62,35 +81,65 @@ int sci_uigetfont(char *fname, unsigned long fname_len)
     }
 
     /* Default font size */
-    if (Rhs >= 2)
+    if (nbInputArgument(pvApiCtx) >= 2)
     {
-        if (VarType(2) == sci_matrix)
+        if ((checkInputArgumentType(pvApiCtx, 2, sci_matrix)))
         {
-            GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &fontSizeAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrfontSizeAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 2.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrfontSizeAdr, &nbRow, &nbCol, &fontSizeAdr);
+            if (sciErr.iErr)
             {
-                freeArrayOfString(fontNameAdr, fontNameSize);
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
+            {
+                freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 2);
                 return FALSE;
             }
         }
         else
         {
-            freeArrayOfString(fontNameAdr, fontNameSize);
+            freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
             Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 2);
             return FALSE;
         }
     }
 
     /* Is the default font bold ? */
-    if (Rhs >= 3)
+    if (nbInputArgument(pvApiCtx) >= 3)
     {
-        if (VarType(3) == sci_boolean)
+        if ((checkInputArgumentType(pvApiCtx, 3, sci_boolean)))
         {
-            GetRhsVar(3, MATRIX_OF_BOOLEAN_DATATYPE, &nbRow, &nbCol, &boldAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrboldAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of boolean at position 3.
+            sciErr = getMatrixOfBoolean(pvApiCtx, piAddrboldAdr, &nbRow, &nbCol, &boldAdr);
+            if (sciErr.iErr)
             {
-                freeArrayOfString(fontNameAdr, fontNameSize);
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: Boolean matrix expected.\n"), fname, 3);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
+            {
+                freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 3);
                 return FALSE;
             }
@@ -98,21 +147,36 @@ int sci_uigetfont(char *fname, unsigned long fname_len)
         }
         else
         {
-            freeArrayOfString(fontNameAdr, fontNameSize);
+            freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 3);
             return FALSE;
         }
     }
 
     /* Is the default font italic ? */
-    if (Rhs >= 4)
+    if (nbInputArgument(pvApiCtx) >= 4)
     {
-        if (VarType(4) == sci_boolean)
+        if ((checkInputArgumentType(pvApiCtx, 4, sci_boolean)))
         {
-            GetRhsVar(4, MATRIX_OF_BOOLEAN_DATATYPE, &nbRow, &nbCol, &italicAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddritalicAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of boolean at position 4.
+            sciErr = getMatrixOfBoolean(pvApiCtx, piAddritalicAdr, &nbRow, &nbCol, &italicAdr);
+            if (sciErr.iErr)
             {
-                freeArrayOfString(fontNameAdr, fontNameSize);
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: Boolean matrix expected.\n"), fname, 4);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
+            {
+                freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A boolean expected.\n"), fname, 4);
                 return FALSE;
             }
@@ -120,7 +184,7 @@ int sci_uigetfont(char *fname, unsigned long fname_len)
         }
         else
         {
-            freeArrayOfString(fontNameAdr, fontNameSize);
+            freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 4);
             return FALSE;
         }
@@ -138,19 +202,19 @@ int sci_uigetfont(char *fname, unsigned long fname_len)
     /* Default size */
     if (fontSizeAdr != 0)
     {
-        setFontChooserFontSize(fontChooserID, (int)stk(fontSizeAdr)[0]);
+        setFontChooserFontSize(fontChooserID, (int)fontSizeAdr[0]);
     }
 
     /* Default bold */
     if (boldAdr != 0)
     {
-        setFontChooserBold(fontChooserID, istk(boldAdr)[0]);
+        setFontChooserBold(fontChooserID, boldAdr[0]);
     }
 
     /* Default italic */
     if (italicAdr != 0)
     {
-        setFontChooserItalic(fontChooserID, istk(italicAdr)[0]);
+        setFontChooserItalic(fontChooserID, italicAdr[0]);
     }
 
     /* Display it and wait for a user input */
@@ -170,70 +234,124 @@ int sci_uigetfont(char *fname, unsigned long fname_len)
 
         nbRow = 1;
         nbCol = 1;
-        if (Lhs >= 1)
+        if (nbOutputArgument(pvApiCtx) >= 1)
         {
-            CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &selectedFontName);
+            sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, (const char * const*) &selectedFontName);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
         }
 
-        if (Lhs >= 2)
+        if (nbOutputArgument(pvApiCtx) >= 2)
         {
-            CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &fontSizeAdr);
-            *stk(fontSizeAdr) = selectedFontSize;
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &fontSizeAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
+            *fontSizeAdr = selectedFontSize;
         }
 
-        if (Lhs >= 3)
+        if (nbOutputArgument(pvApiCtx) >= 3)
         {
-            CreateVar(Rhs + 3, MATRIX_OF_BOOLEAN_DATATYPE, &nbRow, &nbCol, &boldAdr);
-            *istk(boldAdr) = selectedBold;
+            sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &boldAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
+            *boldAdr = selectedBold;
         }
 
-        if (Lhs >= 4)
+        if (nbOutputArgument(pvApiCtx) >= 4)
         {
-            CreateVar(Rhs + 4, MATRIX_OF_BOOLEAN_DATATYPE, &nbRow, &nbCol, &italicAdr);
-            *istk(italicAdr) = selectedItalic;
+            sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 4, nbRow, nbCol, &italicAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
+            *italicAdr = selectedItalic;
         }
     }
     else /* The user canceled */
     {
         nbRow = 0;
         nbCol = 0;
-        if (Lhs >= 1)
+        if (nbOutputArgument(pvApiCtx) >= 1)
         {
             /* Return "" as font name */
-            CreateVar(Rhs + 1, STRING_DATATYPE, &nbRow, &nbCol, &fontNameAdr);
+            char* fontNameEmpty = NULL;
+            if (allocSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow * nbCol, (const char**) &fontNameEmpty))
+            {
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
         }
 
-        if (Lhs >= 2)
+        if (nbOutputArgument(pvApiCtx) >= 2)
         {
             /* Return [] as font size */
-            CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &fontSizeAdr);
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, nbRow, nbCol, &fontSizeAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
         }
 
-        if (Lhs >= 3)
+        if (nbOutputArgument(pvApiCtx) >= 3)
         {
             /* Return [] as bold value */
-            CreateVar(Rhs + 3, MATRIX_OF_BOOLEAN_DATATYPE, &nbRow, &nbCol, &boldAdr);
+            sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 3, nbRow, nbCol, &boldAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
         }
 
-        if (Lhs >= 4)
+        if (nbOutputArgument(pvApiCtx) >= 4)
         {
             /* Return [] as italic value */
-            CreateVar(Rhs + 4, MATRIX_OF_BOOLEAN_DATATYPE, &nbRow, &nbCol, &italicAdr);
+            sciErr = allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 4, nbRow, nbCol, &italicAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
         }
     }
 
-    /* TO DO delete [] selectedFontName */
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+    AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
+    AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
 
-    LhsVar(1) = Rhs + 1;
-    LhsVar(2) = Rhs + 2;
-    LhsVar(3) = Rhs + 3;
-    LhsVar(4) = Rhs + 4;
+    if (selectedFontName)
+    {
+        freeAllocatedSingleString(selectedFontName);
+    }
 
     if (fontNameSize)
     {
-        freeArrayOfString(fontNameAdr, fontNameSize);
+        freeAllocatedMatrixOfString(nbRow, nbCol, fontNameAdr);
     }
-    PutLhsVar();
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 /*--------------------------------------------------------------------------*/
index c8d069c..2ac3ae6 100644 (file)
 #include "api_scilab.h"
 #include "HandleManagement.h"
 /*--------------------------------------------------------------------------*/
+// callSetProperty get a stack pointer in input argument.
+/*--------------------------------------------------------------------------*/
 int sci_uimenu(char *fname, unsigned long fname_len)
 {
-    int nbRow = 0, nbCol = 0, stkAdr = 0;
-
+    SciErr sciErr;
+    int nbRow = 0, nbCol = 0;
     int setStatus = SET_PROPERTY_SUCCEED;
-
     int inputIndex = 0, beginIndex = 0;
-
     char *propertyName = NULL;
-
     char *pParentUID = NULL;
-
     unsigned long GraphicHandle = 0;
-
     int parentDefined = FALSE;
-
     char *pstCurrentFigure = NULL;
-
     int iParentType = -1;
     int *piParentType = &iParentType;
 
     /* Create a new menu */
     GraphicHandle = getHandle(CreateUimenu());
 
-    /* If no Rhs -> current figure is the parent (Ascendant compatibility) */
-    if (Rhs == 0)
+    /* If no nbInputArgument(pvApiCtx) -> current figure is the parent (Ascendant compatibility) */
+    if (nbInputArgument(pvApiCtx) == 0)
     {
         // Set the parent property
         pstCurrentFigure = (char*)getCurrentFigure();
@@ -76,23 +71,33 @@ int sci_uimenu(char *fname, unsigned long fname_len)
      * All event inputs are property names
      * All odd (except first) inputs are property values
      */
-    if (Rhs % 2 == 1)
+    if (nbInputArgument(pvApiCtx) % 2 == 1)
     {
-        if (VarType(1) != sci_handles)
+        if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles)))
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: A graphic handle expected.\n"), fname, 1);
             return FALSE;
         }
         else                    /* Get parent ID */
         {
-            GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
+            int *piAddr = NULL;
+            long long hParent = 0;
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
 
-            if (nbRow * nbCol != 1)
+            // Retrieve a matrix of handle at position 1.
+            // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int stkAdr".
+            if (getScalarHandle(pvApiCtx, piAddr, &hParent))
             {
-                Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
-                return FALSE;
+                Scierror(202, _("%s: Wrong type for argument %d: Handle expected.\n"), fname, 1);
+                return 1;
             }
-            pParentUID = (char*)getObjectFromHandle((long) * hstk(stkAdr));
+
+            pParentUID = (char*)getObjectFromHandle((long)hParent);
             if (pParentUID != NULL)
             {
                 getGraphicObjectProperty(pParentUID, __GO_TYPE__, jni_int, (void **)&piParentType);
@@ -103,7 +108,7 @@ int sci_uimenu(char *fname, unsigned long fname_len)
                 }
 
                 // Set the parent property
-                callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), stkAdr, sci_handles, nbRow, nbCol, "parent");
+                callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), &hParent, sci_handles, 1, 1, "parent");
 
                 // Set the flag to avoid setting the parent two times
                 parentDefined = TRUE;
@@ -130,22 +135,35 @@ int sci_uimenu(char *fname, unsigned long fname_len)
     }
 
     /* Read and set all properties */
-    for (inputIndex = beginIndex; inputIndex < Rhs; inputIndex = inputIndex + 2)
+    for (inputIndex = beginIndex; inputIndex < nbInputArgument(pvApiCtx); inputIndex = inputIndex + 2)
     {
+        int* piAddrValue = NULL;
+        int* piAddrProperty = NULL;
+
         int isUserDataProperty = 0;
         int iPropertyValuePositionIndex = inputIndex + 1;
         size_t posStackOrAdr = 0;
 
         /* Read property name */
-        if (VarType(inputIndex) != sci_strings)
+        if ((!checkInputArgumentType(pvApiCtx, inputIndex, sci_strings)))
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, inputIndex);
             return FALSE;
         }
         else
         {
-            GetRhsVar(inputIndex, STRING_DATATYPE, &nbRow, &nbCol, &stkAdr);
-            propertyName = cstk(stkAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, inputIndex, &piAddrProperty);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            if (getAllocatedSingleString(pvApiCtx, piAddrProperty, &propertyName))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, inputIndex);
+                return 1;
+            }
 
             if (stricmp(propertyName, "parent") == 0)
             {
@@ -155,78 +173,90 @@ int sci_uimenu(char *fname, unsigned long fname_len)
             isUserDataProperty = (stricmp(propertyName, "user_data") == 0) || (stricmp(propertyName, "userdata") == 0);
         }
 
+        sciErr = getVarAddressFromPosition(pvApiCtx, iPropertyValuePositionIndex, &piAddrValue);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        if (isUserDataProperty)
+        {
+            nbRow = -1;
+            nbCol = -1;
+            setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), piAddrValue, 0, 0, 0, propertyName);
+        }
+
         /* Read property value */
-        switch (VarType(iPropertyValuePositionIndex))
+        switch (getInputArgumentType(pvApiCtx, iPropertyValuePositionIndex))
         {
             case sci_matrix:
-                if (isUserDataProperty)
-                {
-                    nbRow = -1;
-                    nbCol = -1;
-                    posStackOrAdr = iPropertyValuePositionIndex;
-                }
-                else
+            {
+                double* pdblValue = NULL;
+                sciErr = getMatrixOfDouble(pvApiCtx, piAddrValue, &nbRow, &nbCol, &pdblValue);
+                if (sciErr.iErr)
                 {
-                    GetRhsVar(iPropertyValuePositionIndex, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
-                    posStackOrAdr = stkAdr;
+                    printError(&sciErr, 0);
+                    Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, iPropertyValuePositionIndex);
+                    return 1;
                 }
-                setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), posStackOrAdr, sci_matrix, nbRow, nbCol, propertyName);
+
+                setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), pdblValue, sci_matrix, nbRow, nbCol, propertyName);
                 break;
+            }
             case sci_strings:
-                if (isUserDataProperty)
-                {
-                    nbRow = -1;
-                    nbCol = -1;
-                    posStackOrAdr = iPropertyValuePositionIndex;
-                }
-                else
+            {
+                char* pstValue = NULL;
+                if (getAllocatedSingleString(pvApiCtx, piAddrValue, &pstValue))
                 {
-                    GetRhsVar(iPropertyValuePositionIndex, STRING_DATATYPE, &nbRow, &nbCol, &stkAdr);
-                    posStackOrAdr = stkAdr;
+                    Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, iPropertyValuePositionIndex);
+                    return 1;
                 }
-                setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), posStackOrAdr, sci_strings, nbRow, nbCol, propertyName);
+
+                nbRow = (int)strlen(pstValue);
+                nbCol = 1;
+                setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), pstValue, sci_strings, nbRow, nbCol, propertyName);
+                freeAllocatedSingleString(pstValue);
                 break;
+            }
             case sci_handles:
-                if (isUserDataProperty)
-                {
-                    nbRow = -1;
-                    nbCol = -1;
-                    posStackOrAdr = iPropertyValuePositionIndex;
-                }
-                else
+            {
+                long long* phValues = NULL;
+                sciErr = getMatrixOfHandle(pvApiCtx, piAddrValue, &nbRow, &nbCol, &phValues);
+                if (sciErr.iErr)
                 {
-                    GetRhsVar(iPropertyValuePositionIndex, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
-                    posStackOrAdr = stkAdr;
+                    printError(&sciErr, 0);
+                    Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, iPropertyValuePositionIndex);
+                    return 1;
                 }
-                setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), posStackOrAdr, sci_handles, nbRow, nbCol, propertyName);
+                setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), phValues, sci_handles, nbRow, nbCol, propertyName);
                 break;
+            }
             case sci_list:
-                if (isUserDataProperty)
-                {
-                    nbRow = -1;
-                    nbCol = -1;
-                    posStackOrAdr = iPropertyValuePositionIndex;
-                }
-                else
-                {
-                    GetRhsVar(iPropertyValuePositionIndex, LIST_DATATYPE, &nbRow, &nbCol, &stkAdr);
-                    posStackOrAdr = iPropertyValuePositionIndex;
-                }
-                setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), posStackOrAdr, sci_list, nbRow, nbCol, propertyName);
+            {
+                getListItemNumber(pvApiCtx, piAddrValue, &nbRow);
+                nbCol = 1;
+                setStatus = callSetProperty(pvApiCtx, (char*)getObjectFromHandle(GraphicHandle), piAddrValue, sci_list, nbRow, nbCol, propertyName);
                 break;
+            }
             default:
+            {
                 setStatus = SET_PROPERTY_ERROR;
                 break;
+            }
         }
+
         if (setStatus == SET_PROPERTY_ERROR)
         {
             Scierror(999, _("%s: Could not set property '%s'.\n"), fname, propertyName);
             return FALSE;
         }
+
+        freeAllocatedSingleString(propertyName);
     }
 
     /* If the parent is not given, the current figure is set as parent */
-    if (!parentDefined && (Rhs != 0))
+    if (!parentDefined && (nbInputArgument(pvApiCtx) != 0))
     {
         // Set the parent property
         pstCurrentFigure = (char*)getCurrentFigure();
@@ -240,13 +270,15 @@ int sci_uimenu(char *fname, unsigned long fname_len)
     /* Create return variable */
     nbRow = 1;
     nbCol = 1;
-    CreateVar(Rhs + 1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
-    *hstk(stkAdr) = GraphicHandle;
-
-    LhsVar(1) = Rhs + 1;
-
-    PutLhsVar();
+    // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int stkAdr".
+    if (createScalarHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, GraphicHandle))
+    {
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
 
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 
index b941d5c..0b0fe56 100644 (file)
@@ -13,7 +13,7 @@
 
 #include "gw_gui.h"
 #include "localization.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "Scierror.h"
 #include "ContextMenu.h"
 #include "graphicObjectProperties.h"
 /*--------------------------------------------------------------------------*/
 int sci_uiwait(char *fname, unsigned long fname_len)
 {
-    int nbRow = 0, nbCol = 0, stkAdr = 0;
+    SciErr sciErr;
 
-    char *result = NULL;
+    int* piAddrstkAdr = NULL;
+    long long* stkAdr = NULL;
+    char* strAdr = NULL;
 
-    long hdl = 0;
+    int nbRow = 0, nbCol = 0;
+    char *result = NULL;
 
     char *pObjUID = NULL;
     int iObjType = -1;
     int *piObjType = &iObjType;
 
-    CheckRhs(1, 1);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
-    if (VarType(1) == sci_handles)
+    if ((checkInputArgumentType(pvApiCtx, 1, sci_handles)))
     {
-        GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstkAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of handle at position 1.
+        sciErr = getMatrixOfHandle(pvApiCtx, piAddrstkAdr, &nbRow, &nbCol, &stkAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+            return 1;
+        }
+
         if (nbRow * nbCol != 1)
         {
             Scierror(999, _("%s: Wrong size for input argument #%d: A graphic handle expected.\n"), fname, 1);
             return FALSE;
         }
-        hdl = (unsigned long)*hstk(stkAdr);
-        pObjUID = (char*)getObjectFromHandle(hdl);
+
+        pObjUID = (char*)getObjectFromHandle((unsigned long) * stkAdr);
 
         getGraphicObjectProperty(pObjUID, __GO_TYPE__, jni_int, (void **)&piObjType);
         if (iObjType == __GO_UICONTEXTMENU__)
@@ -66,13 +84,20 @@ int sci_uiwait(char *fname, unsigned long fname_len)
     /* Create return variable */
     nbRow = (int)strlen(result);
     nbCol = 1;
-    CreateVar(Rhs + 1, STRING_DATATYPE, &nbRow, &nbCol, &stkAdr);
-    strcpy(cstk(stkAdr), result);
 
-    LhsVar(1) = Rhs + 1;
+    if (allocSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow * nbCol, (const char**) &strAdr))
+    {
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
+
+    strcpy(strAdr, result);
 
-    PutLhsVar();
+    // TO DO : delete of "result"
+    // uiWaitContextMenu(pObjUID) can return NULL.
 
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 
index 949ac04..593ba7b 100644 (file)
@@ -13,7 +13,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "Scierror.h"
 #include "InitUIMenu.h"
 /*--------------------------------------------------------------------------*/
 int sci_unsetmenu(char *fname, unsigned long fname_len)
 {
-    int nbRow = 0, nbCol = 0;
-    int menuNameAdr = 0;
-    int figureNumberAdr = 0;
-    int subMenuIndexAdr = 0;
+    SciErr sciErr;
+
+    int* piAddrmenuNameAdr      = NULL;
+    char* menuNameAdr           = NULL;
+    int* piAddrfigureNumberAdr  = NULL;
+    double* figureNumberAdr     = NULL;
+    int* piAddrsubMenuIndexAdr  = NULL;
+    double* subMenuIndexAdr     = NULL;
+
+    int nbRow = 0;
+    int nbCol = 0;
 
     // Check parameter number
-    CheckRhs(1, 3);
-    CheckLhs(1, 1);
+    CheckInputArgument(pvApiCtx, 1, 3);
+    CheckOutputArgument(pvApiCtx, 1, 1);
 
-    if (Rhs == 1)
+    if (nbInputArgument(pvApiCtx) == 1)
     {
         // Error message in not in standard mode (we need figure number)
         if (getScilabMode() != SCILAB_STD)
@@ -42,13 +49,25 @@ int sci_unsetmenu(char *fname, unsigned long fname_len)
         }
 
         // Unset a Menu of Scilab Main Window
-        if (VarType(1) != sci_strings)
+        if ((!checkInputArgumentType(pvApiCtx, 1, sci_strings)))
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);
             return FALSE;
         }
 
-        GetRhsVar(1, STRING_DATATYPE, &nbRow, &nbCol, &menuNameAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmenuNameAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 1.
+        if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+            return 1;
+        }
 
         if (nbCol != 1)
         {
@@ -56,14 +75,30 @@ int sci_unsetmenu(char *fname, unsigned long fname_len)
             return FALSE;
         }
 
-        EnableMenu(getConsoleIdentifier(), cstk(menuNameAdr), FALSE);
+        EnableMenu(getConsoleIdentifier(), menuNameAdr, FALSE);
+        freeAllocatedSingleString(menuNameAdr);
     }
-    else if (Rhs == 2)
+    else if (nbInputArgument(pvApiCtx) == 2)
     {
         // Unset a Menu a Scilab Graphic Window
-        if (VarType(1) == sci_matrix && VarType(2) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)) && (checkInputArgumentType(pvApiCtx, 2, sci_strings)))
         {
-            GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &figureNumberAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfigureNumberAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrfigureNumberAdr, &nbRow, &nbCol, &figureNumberAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                return 1;
+            }
+
 
             if (nbRow * nbCol != 1)
             {
@@ -71,11 +106,24 @@ int sci_unsetmenu(char *fname, unsigned long fname_len)
                 return FALSE;
             }
 
-            GetRhsVar(2, STRING_DATATYPE, &nbRow, &nbCol, &menuNameAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmenuNameAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 2.
+            if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
+                return 1;
+            }
 
-            EnableMenu((char*)getFigureFromIndex((int)*stk(figureNumberAdr)), cstk(menuNameAdr), FALSE);
+            EnableMenu((char*)getFigureFromIndex((int)*figureNumberAdr), menuNameAdr, FALSE);
+            freeAllocatedSingleString(menuNameAdr);
         }
-        else if (VarType(1) == sci_strings && VarType(2) == sci_matrix) // Unset a submenu in main window
+        else if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)) && (checkInputArgumentType(pvApiCtx, 2, sci_matrix))) // Unset a submenu in main window
         {
             // Error message in not in standard mode (we need figure number)
             if (getScilabMode() != SCILAB_STD)
@@ -84,9 +132,36 @@ int sci_unsetmenu(char *fname, unsigned long fname_len)
                 return FALSE;
             }
 
-            GetRhsVar(1, STRING_DATATYPE, &nbRow, &nbCol, &menuNameAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmenuNameAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+                return 1;
+            }
+
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrsubMenuIndexAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 2.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrsubMenuIndexAdr, &nbRow, &nbCol, &subMenuIndexAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+                return 1;
+            }
 
-            GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &subMenuIndexAdr);
 
             if (nbRow * nbCol != 1)
             {
@@ -94,7 +169,8 @@ int sci_unsetmenu(char *fname, unsigned long fname_len)
                 return FALSE;
             }
 
-            EnableSubMenu(getConsoleIdentifier(), cstk(menuNameAdr), (int)*stk(subMenuIndexAdr), FALSE);
+            EnableSubMenu(getConsoleIdentifier(), menuNameAdr, (int)*subMenuIndexAdr, FALSE);
+            freeAllocatedSingleString(menuNameAdr);
         }
         else
         {
@@ -104,9 +180,24 @@ int sci_unsetmenu(char *fname, unsigned long fname_len)
     }
     else                        // Unset a submenu in graphics window
     {
-        if (VarType(1) == sci_matrix)
+        if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
         {
-            GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &figureNumberAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfigureNumberAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrfigureNumberAdr, &nbRow, &nbCol, &figureNumberAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                return 1;
+            }
+
 
             if (nbRow * nbCol != 1)
             {
@@ -120,9 +211,21 @@ int sci_unsetmenu(char *fname, unsigned long fname_len)
             return FALSE;
         }
 
-        if (VarType(2) == sci_strings)
+        if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
         {
-            GetRhsVar(2, STRING_DATATYPE, &nbRow, &nbCol, &menuNameAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmenuNameAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 2.
+            if (getAllocatedSingleString(pvApiCtx, piAddrmenuNameAdr, &menuNameAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
+                return 1;
+            }
         }
         else
         {
@@ -130,9 +233,23 @@ int sci_unsetmenu(char *fname, unsigned long fname_len)
             return FALSE;
         }
 
-        if (VarType(3) == sci_matrix)
+        if ((checkInputArgumentType(pvApiCtx, 3, sci_matrix)))
         {
-            GetRhsVar(3, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &subMenuIndexAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrsubMenuIndexAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 3.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrsubMenuIndexAdr, &nbRow, &nbCol, &subMenuIndexAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+                return 1;
+            }
 
             if (nbRow * nbCol != 1)
             {
@@ -146,12 +263,12 @@ int sci_unsetmenu(char *fname, unsigned long fname_len)
             return FALSE;
         }
 
-        EnableSubMenu((char*)getFigureFromIndex((int)*stk(figureNumberAdr)), cstk(menuNameAdr), (int)*stk(subMenuIndexAdr), FALSE);
+        EnableSubMenu((char*)getFigureFromIndex((int)*figureNumberAdr), menuNameAdr, (int)*subMenuIndexAdr, FALSE);
+        freeAllocatedSingleString(menuNameAdr);
     }
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
-
 /*--------------------------------------------------------------------------*/
index 5a3549b..8d6459f 100644 (file)
@@ -12,7 +12,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "Scierror.h"
 #include "getPropertyAssignedValue.h"
 /*--------------------------------------------------------------------------*/
 int sci_waitbar(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddrfractionAdr = NULL;
+    double* fractionAdr = NULL;
+    int* piAddrmessageAdr = NULL;
+    int* piAddrhandleAdr = NULL;
+    long long* handleAdr = NULL;
+    long long* stkAdr = NULL;
+
     char *pWaitbarUID = NULL;
 
-    int nbRow = 0, nbCol = 0;
-    int nbRowMessage = 0, nbColMessage = 0;
+    int nbRow = 0;
+    int nbCol = 0;
+    int nbRowMessage = 0;
+    int nbColMessage = 0;
 
-    int fractionAdr = 0;
     char **messageAdr = NULL;
-    int handleAdr = 0;
-    int stkAdr = 0;
-
     int iValue = 0;
 
     unsigned long GraphicHandle = 0;
 
-    CheckRhs(1, 3);
-    CheckLhs(1, 1);
+    CheckInputArgument(pvApiCtx, 1, 3);
+    CheckOutputArgument(pvApiCtx, 1, 1);
 
-    if (Rhs == 1)
+    if (nbInputArgument(pvApiCtx) == 1)
     {
-        if (VarType(1) == sci_matrix)   /* Fraction to display */
+        if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))   /* Fraction to display */
         {
-            GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &fractionAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfractionAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrfractionAdr, &nbRow, &nbCol, &fractionAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                return 1;
+            }
+
             if (nbRow * nbCol != 1)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1);
                 return FALSE;
             }
         }
-        else if (VarType(1) == sci_strings) /* Message to display */
+        else if (checkInputArgumentType(pvApiCtx, 1, sci_strings)) /* Message to display */
         {
-            GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRowMessage, &nbColMessage, &messageAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmessageAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 1.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+                return 1;
+            }
+
         }
         else
         {
@@ -65,60 +100,115 @@ int sci_waitbar(char *fname, unsigned long fname_len)
 
         /* Create a new waitbar */
         pWaitbarUID = createGraphicObject(__GO_WAITBAR__);
-
         GraphicHandle = getHandle(pWaitbarUID);
 
-        if (fractionAdr != 0)
+        if (fractionAdr != NULL)
         {
-            iValue = (int)(*(stk(fractionAdr)) * 100);
+            iValue = (int)(fractionAdr[0] * 100);
             setGraphicObjectProperty(pWaitbarUID, __GO_UI_VALUE__, &iValue, jni_int, 1);
         }
         else if (messageAdr != NULL)
         {
-            setGraphicObjectProperty(pWaitbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector,
-                                     nbColMessage * nbRowMessage);
-            freeArrayOfString(messageAdr, nbColMessage * nbRowMessage);
+            setGraphicObjectProperty(pWaitbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector, nbColMessage * nbRowMessage);
+            freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
         }
     }
-    else if (Rhs == 2)
+    else if (nbInputArgument(pvApiCtx) == 2)
     {
-        if (VarType(1) == sci_matrix && VarType(2) == sci_strings)  /* waitbar(x,mes) */
+        if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)) && (checkInputArgumentType(pvApiCtx, 2, sci_strings))) /* waitbar(x,mes) */
         {
-            GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &fractionAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfractionAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrfractionAdr, &nbRow, &nbCol, &fractionAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                return 1;
+            }
+
             if (nbRow * nbCol != 1)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1);
                 return FALSE;
             }
-            GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRowMessage, &nbColMessage, &messageAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmessageAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 2.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                return 1;
+            }
+
 
             pWaitbarUID = createGraphicObject(__GO_WAITBAR__);
 
             GraphicHandle = getHandle(pWaitbarUID);
 
-            iValue = (int)(*(stk(fractionAdr)) * 100);
+            iValue = (int)(fractionAdr[0] * 100);
             setGraphicObjectProperty(pWaitbarUID, __GO_UI_VALUE__, &iValue, jni_int, 1);
-            setGraphicObjectProperty(pWaitbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector,
-                                     nbColMessage * nbRowMessage);
-            freeArrayOfString(messageAdr, nbColMessage * nbRowMessage);
+            setGraphicObjectProperty(pWaitbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector, nbColMessage * nbRowMessage);
+            freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
         }
-        else if (VarType(1) == sci_matrix && VarType(2) == sci_handles) /* waitbar(x,winId) */
+        else if ((checkInputArgumentType(pvApiCtx, 1, sci_matrix)) && (checkInputArgumentType(pvApiCtx, 2, sci_handles))) /* waitbar(x,winId) */
         {
-            GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &fractionAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfractionAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrfractionAdr, &nbRow, &nbCol, &fractionAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                return 1;
+            }
+
             if (nbRow * nbCol != 1)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1);
                 return FALSE;
             }
 
-            GetRhsVar(2, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &handleAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrhandleAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of handle at position 2.
+            sciErr = getMatrixOfHandle(pvApiCtx, piAddrhandleAdr, &nbRow, &nbCol, &handleAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 2);
+                return 1;
+            }
+
             if (nbRow * nbCol != 1)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A '%s' handle expected.\n"), fname, 2, "Waitbar");
                 return FALSE;
             }
 
-            GraphicHandle = (unsigned long) * hstk(handleAdr);
+            GraphicHandle = (unsigned long) * handleAdr;
             pWaitbarUID = (char*)getObjectFromHandle(GraphicHandle);
             if (pWaitbarUID == NULL)
             {
@@ -126,21 +216,48 @@ int sci_waitbar(char *fname, unsigned long fname_len)
                 return FALSE;
             }
 
-            iValue = (int)(*(stk(fractionAdr)) * 100);
+            iValue = (int)(fractionAdr[0] * 100);
             setGraphicObjectProperty(pWaitbarUID, __GO_UI_VALUE__, &iValue, jni_int, 1);
         }
-        else if (VarType(1) == sci_strings && VarType(2) == sci_handles)    /* waitbar(mes,winId) */
+        else if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)) && (checkInputArgumentType(pvApiCtx, 2, sci_handles)))   /* waitbar(mes,winId) */
         {
-            GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRowMessage, &nbColMessage, &messageAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrmessageAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 1.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+                return 1;
+            }
+
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrhandleAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of handle at position 2.
+            sciErr = getMatrixOfHandle(pvApiCtx, piAddrhandleAdr, &nbRow, &nbCol, &handleAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 2);
+                return 1;
+            }
 
-            GetRhsVar(2, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &handleAdr);
             if (nbRow * nbCol != 1)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A '%s' handle expected.\n"), fname, 2, "Waitbar");
                 return FALSE;
             }
 
-            GraphicHandle = (unsigned long) * hstk(handleAdr);
+            GraphicHandle = (unsigned long) * handleAdr;
             pWaitbarUID = (char*)getObjectFromHandle(GraphicHandle);
             if (pWaitbarUID == NULL)
             {
@@ -148,9 +265,8 @@ int sci_waitbar(char *fname, unsigned long fname_len)
                 return FALSE;
             }
 
-            setGraphicObjectProperty(pWaitbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector,
-                                     nbColMessage * nbRowMessage);
-            freeArrayOfString(messageAdr, nbColMessage * nbRowMessage);
+            setGraphicObjectProperty(pWaitbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector, nbColMessage * nbRowMessage);
+            freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
         }
         else
         {
@@ -160,9 +276,24 @@ int sci_waitbar(char *fname, unsigned long fname_len)
     }
     else
     {
-        if (VarType(1) == sci_matrix)   /* Fraction */
+        if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))  /* Fraction */
         {
-            GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &fractionAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrfractionAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrfractionAdr, &nbRow, &nbCol, &fractionAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                return 1;
+            }
+
             if (nbRow * nbCol != 1)
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1);
@@ -175,9 +306,21 @@ int sci_waitbar(char *fname, unsigned long fname_len)
             return FALSE;
         }
 
-        if (VarType(2) == sci_strings)  /* Message */
+        if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))  /* Message */
         {
-            GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRowMessage, &nbColMessage, &messageAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmessageAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 2.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRowMessage, &nbColMessage, &messageAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                return 1;
+            }
         }
         else
         {
@@ -185,58 +328,78 @@ int sci_waitbar(char *fname, unsigned long fname_len)
             return FALSE;
         }
 
-        if (VarType(3) == sci_handles)  /* Handle */
+        if ((checkInputArgumentType(pvApiCtx, 3, sci_handles)))  /* Handle */
         {
-            GetRhsVar(3, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &handleAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrhandleAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of handle at position 3.
+            sciErr = getMatrixOfHandle(pvApiCtx, piAddrhandleAdr, &nbRow, &nbCol, &handleAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 3);
+                return 1;
+            }
+
             if (nbRow * nbCol != 1)
             {
-                freeArrayOfString(messageAdr, nbColMessage * nbRowMessage);
+                freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A '%s' handle expected.\n"), fname, 3, "Waitbar");
                 return FALSE;
             }
         }
         else
         {
-            freeArrayOfString(messageAdr, nbColMessage * nbRowMessage);
+            freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
             Scierror(999, _("%s: Wrong type for input argument #%d: A '%s' handle expected.\n"), fname, 3, "Waitbar");
             return FALSE;
         }
 
-        GraphicHandle = (unsigned long) * hstk(handleAdr);
+        GraphicHandle = (unsigned long) * handleAdr;
         pWaitbarUID = (char*)getObjectFromHandle(GraphicHandle);
         if (pWaitbarUID != NULL)
         {
-            iValue = (int)(*(stk(fractionAdr)) * 100);
+            iValue = (int)(fractionAdr[0] * 100);
             setGraphicObjectProperty(pWaitbarUID, __GO_UI_VALUE__, &iValue, jni_int, 1);
-            setGraphicObjectProperty(pWaitbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector,
-                                     nbColMessage * nbRowMessage);
-            freeArrayOfString(messageAdr, nbColMessage * nbRowMessage);
+            setGraphicObjectProperty(pWaitbarUID, __GO_UI_MESSAGE__, messageAdr, jni_string_vector, nbColMessage * nbRowMessage);
+            freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
         }
         else
         {
-            freeArrayOfString(messageAdr, nbColMessage * nbRowMessage);
+            freeAllocatedMatrixOfString(nbRowMessage, nbColMessage, messageAdr);
             Scierror(999, _("%s: Wrong value for input argument #%d: A valid '%s' handle expected.\n"), fname, 3, "Waitbar");
             return 0;
         }
     }
 
-    if (Lhs == 1)
+    if (nbOutputArgument(pvApiCtx) == 1)
     {
         nbRow = 1;
         nbCol = 1;
-        CreateVar(Rhs + 1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stkAdr);
-        *hstk(stkAdr) = GraphicHandle;
-        LhsVar(1) = Rhs + 1;
+
+        sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &stkAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        *stkAdr = GraphicHandle;
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
     }
     else
     {
-        LhsVar(1) = 0;
+        AssignOutputVariable(pvApiCtx, 1) = 0;
     }
 
-    PutLhsVar();
-
+    ReturnArguments(pvApiCtx);
     return TRUE;
-
 }
 
 /*--------------------------------------------------------------------------*/
index 5644e11..7aaa594 100644 (file)
@@ -13,7 +13,7 @@
 
 #include "gw_gui.h"
 #include "MALLOC.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "CallMessageBox.h"
 #include "getPropertyAssignedValue.h"
 /*--------------------------------------------------------------------------*/
 int sci_x_choice(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddrdefaultValuesAdr = NULL;
+    int* piAddrlabelsAdr = NULL;
+    int* piAddrlineLabelsAdr = NULL;
+    double* emptyMatrixAdr = NULL;
+
     int nbRow = 0, nbCol = 0;
     int nbRowDefaultValues = 0, nbColDefaultValues = 0;
     int nbRowLineLabels = 0, nbColLineLabels = 0;
@@ -31,7 +38,6 @@ int sci_x_choice(char *fname, unsigned long fname_len)
 
     char **labelsAdr = NULL;
     char **lineLabelsAdr = NULL;
-    int defaultValuesAdr = 0;
     double *defaultValues = NULL;
     int *defaultValuesInt = NULL;
 
@@ -39,18 +45,29 @@ int sci_x_choice(char *fname, unsigned long fname_len)
     int *userValue = NULL;
     double *userValueDouble = NULL;
 
-    int emptyMatrixAdr = 0;
-
     int K = 0;
 
-    CheckRhs(3, 3);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 3, 3);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     /* READ THE DEFAULT VALUES */
     if (VarType(1) ==  sci_matrix)
     {
-        GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr);
-        defaultValues = stk(defaultValuesAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrdefaultValuesAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 1.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValues);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+            return 1;
+        }
 
         defaultValuesInt = (int *)MALLOC(nbRowDefaultValues * nbColDefaultValues * sizeof(int));
         for (K = 0; K < nbRowDefaultValues * nbColDefaultValues; K++)
@@ -65,9 +82,22 @@ int sci_x_choice(char *fname, unsigned long fname_len)
     }
 
     /* READ THE MESSAGE */
-    if (VarType(2) == sci_strings)
+    if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
     {
-        GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &labelsAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlabelsAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 2.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+            return 1;
+        }
+
     }
     else
     {
@@ -84,20 +114,33 @@ int sci_x_choice(char *fname, unsigned long fname_len)
 
     /* Message */
     setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow);
-    freeArrayOfString(labelsAdr, nbRow * nbCol);
+    freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr);
 
     /* READ THE LABELS */
     if (VarType(3) ==  sci_strings)
     {
-        GetRhsVar(3, MATRIX_OF_STRING_DATATYPE, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrlineLabelsAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 3.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrlineLabelsAdr, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
+            return 1;
+        }
+
         if (nbRow != 1 && nbCol != 1)
         {
-            freeArrayOfString(lineLabelsAdr, nbRowLineLabels * nbColLineLabels);
+            freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr);
             Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 3);
             return FALSE;
         }
         setMessageBoxLineLabels(messageBoxID, lineLabelsAdr, nbColLineLabels * nbRowLineLabels);
-        freeArrayOfString(lineLabelsAdr, nbRowLineLabels * nbColLineLabels);
+        freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr);
     }
     else
     {
@@ -117,11 +160,17 @@ int sci_x_choice(char *fname, unsigned long fname_len)
     {
         nbRow = 0;
         nbCol = 0;
-        CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &emptyMatrixAdr);
+
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
     }
     else
     {
-
         userValue = (int*)getMessageBoxUserSelectedButtons(messageBoxID);
 
         userValueDouble = (double *)MALLOC(nbRowDefaultValues * nbColDefaultValues * sizeof(double));
@@ -130,14 +179,21 @@ int sci_x_choice(char *fname, unsigned long fname_len)
             userValueDouble[K] = userValue[K];
         }
 
-        CreateVarFromPtr(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &nbRowDefaultValues, &nbColDefaultValues, &userValueDouble);
-        /* TO DO : do a delete []  getMessageBoxUserSelectedButton */
+        sciErr = createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRowDefaultValues, nbColDefaultValues, userValueDouble);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        /* TO DO : do a delete []  getMessageBoxUserSelectedButtons */
     }
 
     FREE(defaultValuesInt);
 
-    LhsVar(1) = Rhs + 1;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 /*--------------------------------------------------------------------------*/
index efc3be8..3548d7d 100644 (file)
@@ -12,7 +12,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "CallMessageBox.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
 int sci_x_choose(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddritemsAdr = NULL;
+    int* piAddrmessageAdr = NULL;
+    int* piAddrbuttonLabelAdr = NULL;
+    double* userValueAdr = NULL;
+
     int nbRow = 0, nbCol = 0;
     int nbRowItems = 0, nbColItems = 0;
 
@@ -30,15 +37,26 @@ int sci_x_choose(char *fname, unsigned long fname_len)
 
     char **messageAdr = NULL;
 
-    int userValueAdr = 0;
     int userValue = 0;
 
-    CheckRhs(2, 3);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 2, 3);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
-    if (VarType(1) == sci_strings)
+    if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
     {
-        GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRowItems, &nbColItems, &itemsAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddritemsAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 1.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddritemsAdr, &nbRowItems, &nbColItems, &itemsAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+            return 1;
+        }
     }
     else
     {
@@ -46,9 +64,22 @@ int sci_x_choose(char *fname, unsigned long fname_len)
         return FALSE;
     }
 
-    if (VarType(2) == sci_strings)
+    if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
     {
-        GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &messageAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmessageAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 2.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRow, &nbCol, &messageAdr))
+        {
+            freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr);
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+            return 1;
+        }
     }
     else
     {
@@ -63,18 +94,34 @@ int sci_x_choose(char *fname, unsigned long fname_len)
     setMessageBoxTitle(messageBoxID, _("Scilab Choose Message"));
     /* Message */
     setMessageBoxMultiLineMessage(messageBoxID, messageAdr, nbCol * nbRow);
+    freeAllocatedMatrixOfString(nbRow, nbCol, messageAdr);
     /* ListBox Items */
     setMessageBoxListBoxItems(messageBoxID, itemsAdr, nbColItems * nbRowItems);
+    freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr);
     /* Modality */
     setMessageBoxModal(messageBoxID, TRUE);
 
-    if (Rhs == 3)
+    if (nbInputArgument(pvApiCtx) == 3)
     {
         if (VarType(3) ==  sci_strings)
         {
-            GetRhsVar(3, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &buttonLabelAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrbuttonLabelAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 3.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrbuttonLabelAdr, &nbRow, &nbCol, &buttonLabelAdr))
             {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
+            {
+                freeAllocatedMatrixOfString(nbRow, nbCol, buttonLabelAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 3);
                 return FALSE;
             }
@@ -86,6 +133,7 @@ int sci_x_choose(char *fname, unsigned long fname_len)
         }
 
         setMessageBoxButtonsLabels(messageBoxID, buttonLabelAdr, nbCol * nbRow);
+        freeAllocatedMatrixOfString(nbRow, nbCol, buttonLabelAdr);
     }
 
     /* Display it and wait for a user input */
@@ -96,11 +144,19 @@ int sci_x_choose(char *fname, unsigned long fname_len)
 
     nbRow = 1;
     nbCol = 1;
-    CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &userValueAdr);
-    *stk(userValueAdr) = userValue;
 
-    LhsVar(1) = Rhs + 1;
-    PutLhsVar();
+    sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &userValueAdr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
+
+    *userValueAdr = userValue;
+
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 /*--------------------------------------------------------------------------*/
index d63bd34..ca4e261 100644 (file)
@@ -11,7 +11,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "CallMessageBox.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
 int sci_x_choose_modeless(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddritemsAdr = NULL;
+    int* piAddrmessageAdr = NULL;
+    int* piAddrbuttonLabelAdr = NULL;
+    double* userValueAdr = NULL;
+
     int nbRow = 0, nbCol = 0;
     int nbRowItems = 0, nbColItems = 0;
 
@@ -30,15 +37,26 @@ int sci_x_choose_modeless(char *fname, unsigned long fname_len)
 
     char **messageAdr = NULL;
 
-    int userValueAdr = 0;
     int userValue = 0;
 
-    CheckRhs(2, 3);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 2, 3);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
-    if (VarType(1) == sci_strings)
+    if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
     {
-        GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRowItems, &nbColItems, &itemsAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddritemsAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 1.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddritemsAdr, &nbRowItems, &nbColItems, &itemsAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+            return 1;
+        }
     }
     else
     {
@@ -46,13 +64,27 @@ int sci_x_choose_modeless(char *fname, unsigned long fname_len)
         return FALSE;
     }
 
-    if (VarType(2) == sci_strings)
+    if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
     {
-        GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &messageAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrmessageAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 2.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrmessageAdr, &nbRow, &nbCol, &messageAdr))
+        {
+            freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr);
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+            return 1;
+        }
+
     }
     else
     {
-        freeArrayOfString(itemsAdr, nbColItems * nbRowItems);
+        freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr);
         Scierror(999, _("%s: Wrong type for input argument #%d: Vector of strings expected.\n"), fname, 2);
         return FALSE;
     }
@@ -69,17 +101,30 @@ int sci_x_choose_modeless(char *fname, unsigned long fname_len)
     /* Modality */
     setMessageBoxModal(messageBoxID, FALSE);
 
-    freeArrayOfString(itemsAdr, nbColItems * nbRowItems);
-    freeArrayOfString(messageAdr, nbCol * nbRow);
+    freeAllocatedMatrixOfString(nbRowItems, nbColItems, itemsAdr);
+    freeAllocatedMatrixOfString(nbRow, nbCol, messageAdr);
 
-    if (Rhs == 3)
+    if (nbInputArgument(pvApiCtx) == 3)
     {
         if (VarType(3) ==  sci_strings)
         {
-            GetRhsVar(3, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &buttonLabelAdr);
-            if (nbRow * nbCol != 1)
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrbuttonLabelAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 3.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrbuttonLabelAdr, &nbRow, &nbCol, &buttonLabelAdr))
             {
-                freeArrayOfString(buttonLabelAdr, nbRow * nbCol);
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
+                return 1;
+            }
+
+            if (nbRow*nbCol != 1)
+            {
+                freeAllocatedMatrixOfString(nbRow, nbCol, buttonLabelAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: A string expected.\n"), fname, 3);
                 return FALSE;
             }
@@ -91,7 +136,7 @@ int sci_x_choose_modeless(char *fname, unsigned long fname_len)
         }
 
         setMessageBoxButtonsLabels(messageBoxID, buttonLabelAdr, nbCol * nbRow);
-        freeArrayOfString(buttonLabelAdr, nbRow * nbCol);
+        freeAllocatedMatrixOfString(nbRow, nbCol, buttonLabelAdr);
     }
 
     /* Display it and wait for a user input */
@@ -102,11 +147,19 @@ int sci_x_choose_modeless(char *fname, unsigned long fname_len)
 
     nbRow = 1;
     nbCol = 1;
-    CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &userValueAdr);
-    *stk(userValueAdr) = userValue;
 
-    LhsVar(1) = Rhs + 1;
-    PutLhsVar();
+    sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &userValueAdr);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
+
+    *userValueAdr = userValue;
+
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 /*--------------------------------------------------------------------------*/
index d9b67fe..44b53f3 100644 (file)
@@ -12,7 +12,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "CallMessageBox.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
 int sci_x_dialog(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddrlabelsAdr = NULL;
+    int* piAddrinitialValueAdr = NULL;
+    double* emptyMatrixAdr = NULL;
+
     int nbRow = 0, nbCol = 0;
 
     int messageBoxID = 0;
@@ -32,14 +38,24 @@ int sci_x_dialog(char *fname, unsigned long fname_len)
     int userValueSize = 0;
     char **userValue = NULL;
 
-    int emptyMatrixAdr = 0;
+    CheckInputArgument(pvApiCtx, 1, 2);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
-    CheckRhs(1, 2);
-    CheckLhs(0, 1);
-
-    if (VarType(1) == sci_strings)
+    if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
     {
-        GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &labelsAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrlabelsAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 1.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+            return 1;
+        }
     }
     else
     {
@@ -54,13 +70,25 @@ int sci_x_dialog(char *fname, unsigned long fname_len)
     setMessageBoxTitle(messageBoxID, _("Scilab Input Value Request"));
     /* Message */
     setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow);
-    freeArrayOfString(labelsAdr, nbCol * nbRow);
+    freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr);
 
-    if (Rhs == 2)
+    if (nbInputArgument(pvApiCtx) == 2)
     {
         if (VarType(2) ==  sci_strings)
         {
-            GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &initialValueAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrinitialValueAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 2.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrinitialValueAdr, &nbRow, &nbCol, &initialValueAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                return 1;
+            }
         }
         else
         {
@@ -69,7 +97,7 @@ int sci_x_dialog(char *fname, unsigned long fname_len)
         }
 
         setMessageBoxInitialValue(messageBoxID, initialValueAdr, nbCol * nbRow);
-        freeArrayOfString(initialValueAdr, nbCol * nbRow);
+        freeAllocatedMatrixOfString(nbRow, nbCol, initialValueAdr);
     }
 
     /* Display it and wait for a user input */
@@ -81,21 +109,26 @@ int sci_x_dialog(char *fname, unsigned long fname_len)
     {
         nbRow = 0;
         nbCol = 0;
-        CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &emptyMatrixAdr);
+
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
     }
     else
     {
         userValue = getMessageBoxValue(messageBoxID);
 
-
         nbCol = 1;
-        CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &userValueSize, &nbCol, userValue);
+        CreateVarFromPtr(nbInputArgument(pvApiCtx) + 1, MATRIX_OF_STRING_DATATYPE, &userValueSize, &nbCol, userValue);
         /* TO DO : delete of userValue */
-
     }
 
-    LhsVar(1) = Rhs + 1;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 /*--------------------------------------------------------------------------*/
index 7f6cc4a..9980aab 100644 (file)
@@ -12,7 +12,7 @@
  */
 
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "CallMessageBox.h"
 #include "getPropertyAssignedValue.h"
 /*--------------------------------------------------------------------------*/
 int sci_x_mdialog(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddrlabelsAdr = NULL;
+    int* piAddrlineLabelsAdr = NULL;
+    int* piAddrdefaultValuesAdr = NULL;
+    int* piAddrcolumnLabelsAdr = NULL;
+    double* emptyMatrixAdr = NULL;
+
     int nbRow = 0, nbCol = 0;
     int nbRowDefaultValues = 0, nbColDefaultValues = 0;
     int nbRowLineLabels = 0, nbColLineLabels = 0;
@@ -36,15 +44,25 @@ int sci_x_mdialog(char *fname, unsigned long fname_len)
     int userValueSize = 0;
     char **userValue = NULL;
 
-    int emptyMatrixAdr = 0;
-
-    CheckRhs(3, 4);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 3, 4);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     /* READ THE LABELS */
-    if (VarType(1) == sci_strings)
+    if ((checkInputArgumentType(pvApiCtx, 1, sci_strings)))
     {
-        GetRhsVar(1, MATRIX_OF_STRING_DATATYPE, &nbRow, &nbCol, &labelsAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrlabelsAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 1.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrlabelsAdr, &nbRow, &nbCol, &labelsAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 1);
+            return 1;
+        }
     }
     else
     {
@@ -59,19 +77,33 @@ int sci_x_mdialog(char *fname, unsigned long fname_len)
     setMessageBoxTitle(messageBoxID, _("Scilab Multiple Values Request"));
     /* Message */
     setMessageBoxMultiLineMessage(messageBoxID, labelsAdr, nbCol * nbRow);
-    freeArrayOfString(labelsAdr, nbCol * nbRow);
+    freeAllocatedMatrixOfString(nbRow, nbCol, labelsAdr);
 
     /* READ THE LINE LABELS */
     if (VarType(2) ==  sci_strings)
     {
-        GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrlineLabelsAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position 2.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrlineLabelsAdr, &nbRowLineLabels, &nbColLineLabels, &lineLabelsAdr))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+            return 1;
+        }
+
         if (nbRow != 1 && nbCol != 1)
         {
+            freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr);
             Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 2);
             return FALSE;
         }
         setMessageBoxLineLabels(messageBoxID, lineLabelsAdr, nbColLineLabels * nbRowLineLabels);
-        freeArrayOfString(lineLabelsAdr, nbColLineLabels * nbRowLineLabels);
+        freeAllocatedMatrixOfString(nbRowLineLabels, nbColLineLabels, lineLabelsAdr);
     }
     else
     {
@@ -82,33 +114,62 @@ int sci_x_mdialog(char *fname, unsigned long fname_len)
     /* READ THE COLUMN LABELS or DEFAULT VALUES */
     if (VarType(3) ==  sci_strings)
     {
-        if (Rhs == 3)
+        if (nbInputArgument(pvApiCtx) == 3)
         {
-            GetRhsVar(3, MATRIX_OF_STRING_DATATYPE, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrdefaultValuesAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 3.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
+                return 1;
+            }
+
             if ((nbRowDefaultValues != nbRowLineLabels) || (nbColDefaultValues != nbColLineLabels))
             {
+                freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: It must have same dimensions that argument #%d.\n"), fname, 3, 2);
                 return FALSE;
             }
 
             if (nbRowDefaultValues != 1 && nbColDefaultValues != 1)
             {
+                freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 3);
                 return FALSE;
             }
             setMessageBoxDefaultInput(messageBoxID, defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues);
-            freeArrayOfString(defaultValuesAdr, nbColDefaultValues * nbRowDefaultValues);
+            freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr);
         }
         else
         {
-            GetRhsVar(3, MATRIX_OF_STRING_DATATYPE, &nbRowColumnLabels, &nbColColumnLabels, &columnLabelsAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrcolumnLabelsAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 3.
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrcolumnLabelsAdr, &nbRowColumnLabels, &nbColColumnLabels, &columnLabelsAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 3);
+                return 1;
+            }
+
             if (nbRow != 1 && nbCol != 1)
             {
+                freeAllocatedMatrixOfString(nbRowColumnLabels, nbColColumnLabels, columnLabelsAdr);
                 Scierror(999, _("%s: Wrong size for input argument #%d: Vector of strings expected.\n"), fname, 3);
                 return FALSE;
             }
             setMessageBoxColumnLabels(messageBoxID, columnLabelsAdr, nbColColumnLabels * nbRowColumnLabels);
-            freeArrayOfString(columnLabelsAdr, nbColColumnLabels * nbRowColumnLabels);
+            freeAllocatedMatrixOfString(nbRowColumnLabels, nbColColumnLabels, columnLabelsAdr);
         }
     }
     else
@@ -117,12 +178,26 @@ int sci_x_mdialog(char *fname, unsigned long fname_len)
         return FALSE;
     }
 
-    if (Rhs == 4)
+    if (nbInputArgument(pvApiCtx) == 4)
     {
         /* READ  DEFAULT VALUES */
         if (VarType(4) ==  sci_strings)
         {
-            GetRhsVar(4, MATRIX_OF_STRING_DATATYPE, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrdefaultValuesAdr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of string at position 4.
+            // DO NOT FORGET TO RELEASE MEMORY via freeAllocatedMatrixOfString(nbRowDefaultValues, nbColDefaultValues, defaultValuesAdr).
+            if (getAllocatedMatrixOfString(pvApiCtx, piAddrdefaultValuesAdr, &nbRowDefaultValues, &nbColDefaultValues, &defaultValuesAdr))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 4);
+                return 1;
+            }
+
             if ((nbRowDefaultValues != nbRowLineLabels * nbColLineLabels) || (nbColDefaultValues != nbRowColumnLabels * nbColColumnLabels))
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: %d x %d matrix of strings expected.\n"), fname, 4, nbRowLineLabels * nbColLineLabels, nbRowColumnLabels * nbColColumnLabels);
@@ -147,7 +222,15 @@ int sci_x_mdialog(char *fname, unsigned long fname_len)
     {
         nbRow = 0;
         nbCol = 0;
-        CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &emptyMatrixAdr);
+        // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int emptyMatrixAdr".
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &emptyMatrixAdr);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
     }
     else
     {
@@ -155,16 +238,16 @@ int sci_x_mdialog(char *fname, unsigned long fname_len)
         nbCol = 1;
         nbRowDefaultValues = nbColLineLabels * nbRowLineLabels;
         nbColDefaultValues = 1;
-        if (Rhs == 4)
+        if (nbInputArgument(pvApiCtx) == 4)
         {
             nbColDefaultValues = nbColColumnLabels * nbRowColumnLabels;
         }
-        CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &nbRowDefaultValues, &nbColDefaultValues, userValue);
+        CreateVarFromPtr(nbInputArgument(pvApiCtx) + 1, MATRIX_OF_STRING_DATATYPE, &nbRowDefaultValues, &nbColDefaultValues, userValue);
         /* TO DO : delete of userValue */
     }
 
-    LhsVar(1) = Rhs + 1;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
     return TRUE;
 }
 /*--------------------------------------------------------------------------*/
index fb172ba..524cb85 100644 (file)
@@ -34,14 +34,14 @@ int sci_about(char *fname, unsigned long fname_len)
     {
         CallScilabBridge::scilabAboutBox(getScilabJavaVM());
     }
-    catch(const GiwsException::JniException & e)
+    catch (const GiwsException::JniException & e)
     {
         Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
         return FALSE;
     }
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    returnArguments(pvApiCtx);
 
     return TRUE;
 
index 67378d8..d887a44 100644 (file)
 #include <iostream>
 #include <string>
 
-#ifdef _MSC_VER
-#include "strdup_windows.h"
-#endif
 #include "displaytree.hxx"
 #include "ScilabDisplayTree.hxx"
 #include "GiwsException.hxx"
 
 extern "C"
 {
-#include "stack-c.h"
+#ifdef _MSC_VER
+#include "strdup_windows.h"
+#endif
+
+#include "api_scilab.h"
 #include "gw_gui.h"
 #include "stdlib.h"
 #include "sciprint.h"
@@ -35,102 +36,150 @@ extern "C"
 #include "getScilabJavaVM.h"
 }
 
-using namespace std;
-
 /*--------------------------------------------------------------------------*/
 int sci_displaytree(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddrTree         = NULL;
+    int* piAddrTreeStr      = NULL;
+    int* piAddrTreeMList    = NULL;
+    int* piAddrLabel        = NULL;
+    int* piAddrIcon         = NULL;
+    int* piAddrCallback     = NULL;
+
     int iItemCount = 0;
 
-    CheckRhs(1, 1);
-    CheckLhs(1, 1);
+    char* strItem1      = NULL;
+    char* strLabel      = NULL;
+    char* strIcon       = NULL;
+    char* strCallback   = NULL;
 
-    vector < string > StructList;
-    int *piCurrentItem = NULL;
-    string szCurLevel = "";
+    vector<std::string> StructList;
+    std::string szCurLevel = "";
 
-    iGetListItemType(1, piCurrentItem, &iItemCount, NULL);
-    int *piItemType = (int *)MALLOC(iItemCount * sizeof(int));
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 1, 1);
 
-    iGetListItemType(1, piCurrentItem, &iItemCount, piItemType);
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrTree);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    sciErr = getListItemNumber(pvApiCtx, piAddrTree, &iItemCount);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
 
     if (iItemCount < 2)
     {
-        sciprint("Invalid size");
+        Scierror(999, _("%s: Wrong size for input argument #%d: At least 2 elements expected.\n"), fname, 1);
         return 1;
     }
 
-    if (piItemType[0] != sci_strings && piItemType[1] != sci_mlist) //type
+    // get first element as a string
+    sciErr = getListItemAddress(pvApiCtx, piAddrTree, 1, &piAddrTreeStr);
+    if (sciErr.iErr)
     {
-        sciprint("Invalid tree");
-        FREE(piItemType);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    if (getAllocatedSingleString(pvApiCtx, piAddrTreeStr, &strItem1))
+    {
+        Scierror(999, _("%s: Wrong type for input argument #%d: First element must be a string.\n"), fname, 1);
         return 1;
     }
 
-    FREE(piItemType);
     /*check tree structure */
-    if (bIsTreeStructure(1, piCurrentItem, 1) == false)
+    if (strcmp(strItem1, TREE_REF_NAME))
     {
-        sciprint("Invalid structure");
+        freeAllocatedSingleString(strItem1);
+        Scierror(999, _("%s: Wrong type for input argument #%d: A Tree expected.\n"), fname, 1);
         return 1;
     }
-    //Add node level
-    if (szCurLevel != "")
+
+    freeAllocatedSingleString(strItem1);
+
+    // get the second element as a mlist
+    sciErr = getListItemAddress(pvApiCtx, piAddrTree, 2, &piAddrTreeMList);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    if (isMListType(pvApiCtx, piAddrTreeMList) == false)
     {
-        szCurLevel + ".";
+        Scierror(999, _("%s: Wrong type for input argument #%d: Second element must be a mlist.\n"), fname, 1);
+        printError(&sciErr, 0);
+        return 1;
     }
+
+    //Add node level
     szCurLevel += "1";
     StructList.push_back(szCurLevel);
 
     //get label name
-    char *szLabel = NULL;
-    int iRet = iGetNodeLabel(1, piCurrentItem, szLabel);
+    sciErr = getListItemAddress(pvApiCtx, piAddrTreeMList, 3, &piAddrLabel);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
 
-    if (iRet == -1)
+    if (getAllocatedSingleString(pvApiCtx, piAddrLabel, &strLabel))
     {
-        return false;
+        Scierror(999, _("%s: Wrong type for input argument #%d: Label: A string expected.\n"), fname, 1);
+        return 1;
     }
 
-    szLabel = (char *)MALLOC((iRet + 1) * sizeof(char));
-    iRet = iGetNodeLabel(1, piCurrentItem, szLabel);
-    StructList.push_back(szLabel);
-    FREE(szLabel);
+    StructList.push_back(strLabel);
+    freeAllocatedSingleString(strLabel);
 
     //get Icon name
-    char *szIcon = NULL;
+    sciErr = getListItemAddress(pvApiCtx, piAddrTreeMList, 4, &piAddrIcon);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
 
-    iRet = iGetNodeIcon(1, piCurrentItem, szIcon);
-    if (iRet == -1)
+    if (getAllocatedSingleString(pvApiCtx, piAddrIcon, &strIcon))
     {
-        return false;
+        Scierror(999, _("%s: Wrong type for input argument #%d: Icon: A string expected.\n"), fname, 1);
+        return 1;
     }
 
-    szIcon = (char *)MALLOC((iRet + 1) * sizeof(char));
-    iRet = iGetNodeIcon(1, piCurrentItem, szIcon);
-    StructList.push_back(szIcon);
-    FREE(szIcon);
+    StructList.push_back(strIcon);
+    freeAllocatedSingleString(strIcon);
 
     //get callback name
-    char *szCallBack = NULL;
-
-    iRet = iGetNodeCallBack(1, piCurrentItem, szCallBack);
-    if (iRet == -1)
+    sciErr = getListItemAddress(pvApiCtx, piAddrTreeMList, 5, &piAddrCallback);
+    if (sciErr.iErr)
     {
-        return false;
+        printError(&sciErr, 0);
+        return 1;
     }
 
-    szCallBack = (char *)MALLOC((iRet + 1) * sizeof(char)); //new char[iRet + 1]; replace later
-    iRet = iGetNodeCallBack(1, piCurrentItem, szCallBack);
-    StructList.push_back(szCallBack);
-    FREE(szCallBack);           //delete[] szCallBack; replace later
-
-    if (iRet == -1)
+    if (getAllocatedSingleString(pvApiCtx, piAddrCallback, &strCallback))
     {
-        return false;
+        Scierror(999, _("%s: Wrong type for input argument #%d: callback: A string expected.\n"), fname, 1);
+        return 1;
     }
 
-    bParseListItem(1, piCurrentItem, &StructList, szCurLevel);
+    StructList.push_back(strCallback);
+    freeAllocatedSingleString(strCallback);
 
+    if (bParseListItem(pvApiCtx, piAddrTree, iItemCount, &StructList, szCurLevel))
+    {
+        Scierror(999, _("%s: Error in the tree parsing.\n"), fname, 1);
+        return 1;
+    }
     // Conversion Vector<string> to char **
     char **tab = NULL;
     size_t i = 0;
@@ -148,7 +197,7 @@ int sci_displaytree(char *fname, unsigned long fname_len)
         //Java
         org_scilab_modules_gui_tree::ScilabDisplayTree::scilabDisplayTree(getScilabJavaVM(), tab, (int)struct_size);
     }
-    catch(const GiwsException::JniException & e)
+    catch (const GiwsException::JniException & e)
     {
         Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
         return FALSE;
index 5ef94ac..301dd50 100644 (file)
@@ -27,22 +27,20 @@ using namespace org_scilab_modules_gui_bridge;
 /*--------------------------------------------------------------------------*/
 int sci_fire_closing_finished(char *fname, unsigned long fname_len)
 {
-    CheckRhs(0, 0);
-       
+    CheckInputArgument(pvApiCtx, 0, 0);
+
     char const* pstCurrentFigure = NULL;
 
     /* Set current figure as parent */
     pstCurrentFigure = getCurrentFigure();
     if (pstCurrentFigure != NULL)
     {
-       CallScilabBridge::fireClosingFinished(getScilabJavaVM(), pstCurrentFigure);
+        CallScilabBridge::fireClosingFinished(getScilabJavaVM(), pstCurrentFigure);
     }
 
-    LhsVar(1) = 0;
-
-    PutLhsVar();
-
-    return 1;
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    returnArguments(pvApiCtx);
+    return 0;
 }
 
 /*--------------------------------------------------------------------------*/
index 7119694..b7e6d9d 100644 (file)
@@ -1,11 +1,11 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA - Allan CORNET
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
@@ -16,26 +16,27 @@ extern "C"
 {
 #include <stdlib.h>
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "getScilabJavaVM.h"
 #include "Scierror.h"
 #include "localization.h"
 #include "GiwsException.hxx"
-/*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
     int sci_getinstalledlookandfeels(char *fname, unsigned long fname_len)
     {
-        CheckRhs(0, 0);
-        CheckLhs(1, 1);
+        SciErr sciErr;
+        CheckInputArgument(pvApiCtx, 0, 0);
+        CheckOutputArgument(pvApiCtx, 1, 1);
 
         org_scilab_modules_gui_utils::LookAndFeelManager * lnf = 0;
         try
         {
             lnf = new org_scilab_modules_gui_utils::LookAndFeelManager(getScilabJavaVM());
         }
-        catch(const GiwsException::JniException & e)
+        catch (const GiwsException::JniException & e)
         {
             Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
-            return 0;
+            return 1;
         }
 
         if (lnf)
@@ -48,7 +49,14 @@ extern "C"
             nbElems = lnf->numbersOfInstalledLookAndFeels();
 
             nbCol = 1;
-            CreateVarFromPtr(Rhs + 1, MATRIX_OF_STRING_DATATYPE, &nbElems, &nbCol, lookandfeels);
+
+            sciErr = createMatrixOfString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbElems, nbCol, lookandfeels);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
 
             if (lookandfeels)
             {
@@ -66,8 +74,8 @@ extern "C"
             }
             delete lnf;
 
-            LhsVar(1) = Rhs + 1;
-            PutLhsVar();
+            AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+            returnArguments(pvApiCtx);
         }
         else
         {
@@ -75,7 +83,7 @@ extern "C"
         }
         return 0;
     }
-/*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
 }
 
 /* END OF extern "C" */
index 39440bd..0c685d9 100644 (file)
@@ -1,11 +1,11 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA - Allan CORNET
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
@@ -16,39 +16,44 @@ extern "C"
 {
 #include <stdlib.h>
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "getScilabJavaVM.h"
 #include "Scierror.h"
 #include "localization.h"
 #include "GiwsException.hxx"
-/*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
     int sci_getlookandfeel(char *fname, unsigned long fname_len)
     {
-        CheckRhs(0, 0);
-        CheckLhs(1, 1);
+        CheckInputArgument(pvApiCtx, 0, 0);
+        CheckOutputArgument(pvApiCtx, 1, 1);
 
         org_scilab_modules_gui_utils::LookAndFeelManager * lnf = 0;
         try
         {
             lnf = new org_scilab_modules_gui_utils::LookAndFeelManager(getScilabJavaVM());
         }
-        catch(const GiwsException::JniException & e)
+        catch (const GiwsException::JniException & e)
         {
             Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
-            return 0;
+            return 1;
         }
 
         if (lnf)
         {
             static int n1 = 0, m1 = 0;
-
             char *look = lnf->getCurrentLookAndFeel();
 
             if (look)
             {
                 m1 = (int)strlen(look);
                 n1 = 1;
-                CreateVarFromPtr(Rhs + 1, STRING_DATATYPE, &m1, &n1, &look);
+
+                if (createSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, look))
+                {
+                    Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                    return 1;
+                }
+
                 if (look)
                 {
                     delete[]look;
@@ -56,24 +61,25 @@ extern "C"
                 }
                 delete lnf;
 
-                LhsVar(1) = Rhs + 1;
-                PutLhsVar();
+                AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+                returnArguments(pvApiCtx);
             }
             else
             {
                 delete lnf;
-
                 Scierror(999, _("%s: An error occurred: %s.\n"), fname, _("Impossible to get current look and feel"));
+                return 1;
             }
         }
         else
         {
             Scierror(999, _("%s: No more memory.\n"), fname);
+            return 1;
         }
 
         return 0;
     }
-/*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
 
 }                               /* END OF extern "C" */
 
index 148b069..4801cd7 100644 (file)
@@ -15,7 +15,7 @@
 
 extern "C"
 {
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "Scierror.h"
 #include "scilabmode.h"
 #include "localization.h"
@@ -30,68 +30,85 @@ using namespace org_scilab_modules_gui_bridge;
 /*--------------------------------------------------------------------------*/
 int sci_printfigure(char *fname, unsigned long l)
 {
-    static int l1 = 0, n1 = 0, m1 = 0;
+    SciErr sciErr;
+
+    int n1 = 0, m1 = 0;
     int num_win = -2;
-    int *status = NULL;
+    int status  = 0;
+
+    int * piAddr1   = NULL;
+    double* l1      = NULL;
 
-    Rhs = Max(0, Rhs);
-    CheckRhs(1, 1);
-    CheckLhs(0, 1);
+    nbInputArgument(pvApiCtx) = Max(0, nbInputArgument(pvApiCtx));
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     if (getScilabMode() != SCILAB_NWNI)
     {
-        if (Rhs == 1)
+        if (nbInputArgument(pvApiCtx) == 1)
         {
-            GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
+            if (sciErr.iErr)
+            {
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                printError(&sciErr, 0);
+                return 1;
+            }
 
             if (!IsAScalar(1))
             {
                 Scierror(999, _("%s: Wrong size for input argument #%d: A real expected.\n"), fname, 1);
-                return FALSE;
+                return 1;
             }
-            num_win = (int)(*stk(l1));
+            num_win = (int) * l1;
 
             if (num_win >= 0)
             {
                 /* Call Java */
-                status = new int[1];
-
                 try
                 {
-                    status[0] = (int)CallScilabBridge::printFigure(getScilabJavaVM(), getFigureFromIndex(num_win), true, true); /* postscript mode and display dialog */
+                    status = (int)CallScilabBridge::printFigure(getScilabJavaVM(), getFigureFromIndex(num_win), true, true); /* postscript mode and display dialog */
                 }
-                catch(const GiwsException::JniException & e)
+                catch (const GiwsException::JniException & e)
                 {
                     Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
-                    return FALSE;
+                    return 1;
+                }
+
+                if (createScalarBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, status))
+                {
+                    Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                    return 1;
                 }
 
-                m1 = 1;
-                n1 = 1;
-                CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &m1, &n1, &status);
-                LhsVar(1) = Rhs + 1;
-                delete[]status;
-                PutLhsVar();
-                return TRUE;
+                AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+                returnArguments(pvApiCtx);
+                return 0;
             }
             else
             {
                 Scierror(999, _("%s: Wrong value for input argument #%d: Must be >= %d expected.\n"), fname, 1, 0);
-                return FALSE;
+                return 1;
             }
         }
         else
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: A real expected.\n"), fname, 2);
-            return FALSE;
+            return 1;
         }
     }
     else
     {
         Scierror(999, _("%s: Function not available in NWNI mode.\n"), fname);
-        return FALSE;
+        return 1;
     }
-    return TRUE;
+    return 0;
 }
 
 /*--------------------------------------------------------------------------*/
index 0d5ffef..8543693 100644 (file)
@@ -2,11 +2,11 @@
 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) INRIA - Allan CORNET
 * Copyright (C) 2008 - INRIA - Vincent COUVERT (Java version)
-* 
+*
 * This file must be used under the terms of the CeCILL.
 * This source file is licensed as described in the file COPYING, which
 * you should have received as part of this distribution.  The terms
-* are also available at    
+* are also available at
 * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
 *
 */
@@ -18,7 +18,7 @@
 extern "C"
 {
 #include "MALLOC.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "getScilabJavaVM.h"
 #include "Scierror.h"
@@ -30,29 +30,31 @@ using namespace org_scilab_modules_gui_bridge;
 /*--------------------------------------------------------------------------*/
 int sci_printsetupbox(char *fname, unsigned long l)
 {
-    static int n1 = 0;
-    int *paramoutINT = new int[1];
+    int paramoutINT = 0;
 
-    CheckRhs(0, 0);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 0, 0);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     try
     {
-        paramoutINT[0] = (int)CallScilabBridge::pageSetup(getScilabJavaVM());
+        paramoutINT = (int)CallScilabBridge::pageSetup(getScilabJavaVM());
     }
-    catch(const GiwsException::JniException & e)
+    catch (const GiwsException::JniException & e)
     {
         Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
-        return FALSE;
+        return 1;
+    }
+
+    if (createScalarBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, paramoutINT))
+    {
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
     }
 
-    n1 = 1;
-    CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &paramoutINT);
-    LhsVar(1) = Rhs + 1;
-    delete[]paramoutINT;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    returnArguments(pvApiCtx);
 
-    return TRUE;
+    return 0;
 }
 
 /*--------------------------------------------------------------------------*/
index aab2cee..64cd32b 100644 (file)
@@ -17,7 +17,7 @@
 
 extern "C"
 {
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "getScilabJavaVM.h"
 #include "gw_gui.h"
 #include "localization.h"
@@ -29,26 +29,41 @@ using namespace org_scilab_modules_gui_bridge;
 /*--------------------------------------------------------------------------*/
 int sci_raise_window(char *fname, unsigned long fname_len)
 {
-    int m1 = 0, n1 = 0, l1 = 0;
+    SciErr sciErr;
+    int m1 = 0, n1 = 0;
 
-    CheckLhs(1, 1);
+    int * piAddr1   = NULL;
+    double* l1      = NULL;
 
-    GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
+    CheckInputArgument(pvApiCtx, 1, 1);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+        printError(&sciErr, 0);
+        return 1;
+    }
 
     try
     {
-        CallScilabBridge::raiseWindow(getScilabJavaVM(), (int)(*stk(l1)));
+        CallScilabBridge::raiseWindow(getScilabJavaVM(), (int)*l1);
     }
-    catch(const GiwsException::JniException & e)
+    catch (const GiwsException::JniException & e)
     {
         Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
-        return FALSE;
+        return 1;
     }
 
-    LhsVar(1) = 0;
-    PutLhsVar();
-
-    return TRUE;
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    returnArguments(pvApiCtx);
+    return 0;
 }
 
 /*--------------------------------------------------------------------------*/
index c650c8c..5f04e51 100644 (file)
@@ -1,11 +1,11 @@
 /*
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2008 - INRIA - Allan CORNET
- * 
+ *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
  * you should have received as part of this distribution.  The terms
- * are also available at    
+ * are also available at
  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  *
  */
 extern "C"
 {
 #include "gw_gui.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "getScilabJavaVM.h"
 #include "Scierror.h"
 #include "localization.h"
 #include "BOOL.h"
 #include "MALLOC.h"
-/*--------------------------------------------------------------------------*/
+    /*--------------------------------------------------------------------------*/
     int sci_setlookandfeel(char *fname, unsigned long fname_len)
     {
-        CheckRhs(0, 1);
-        CheckLhs(0, 1);
+        SciErr sciErr;
+        CheckInputArgument(pvApiCtx, 0, 1);
+        CheckOutputArgument(pvApiCtx, 0, 1);
 
         org_scilab_modules_gui_utils::LookAndFeelManager * lnf = 0;
 
-        if (Rhs == 0)
+        if (nbInputArgument(pvApiCtx) == 0)
         {
             try
             {
                 lnf = new org_scilab_modules_gui_utils::LookAndFeelManager(getScilabJavaVM());
             }
-            catch(const GiwsException::JniException & e)
+            catch (const GiwsException::JniException & e)
             {
                 Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
-                return FALSE;
+                return 1;
             }
 
             if (lnf)
             {
-                int n1 = 1;
-                int *paramoutINT = (int *)MALLOC(sizeof(int));
+                int paramoutINT = 0;
 
-                *paramoutINT = (int)booltoBOOL(lnf->setSystemLookAndFeel());
+                paramoutINT = (int)booltoBOOL(lnf->setSystemLookAndFeel());
                 delete lnf;
 
-                n1 = 1;
-                CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &paramoutINT);
-                LhsVar(1) = Rhs + 1;
-
-                if (paramoutINT)
+                if (createScalarBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, paramoutINT))
                 {
-                    FREE(paramoutINT);
-                    paramoutINT = NULL;
+                    Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                    return 1;
                 }
-                PutLhsVar();
+
+                AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+                returnArguments(pvApiCtx);
+                return 0;
             }
             else
             {
                 Scierror(999, _("%s: No more memory.\n"), fname);
+                return 1;
             }
         }
-        else if (GetType(1) == sci_strings)
+        else if (checkInputArgumentType(pvApiCtx, 1, sci_strings))
         {
-            int m1, n1 = 0, l1 = 0;
-
             char *looknfeel = NULL;
+            int* piAddrStr = NULL;
+
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrStr);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
 
-            GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
-            looknfeel = cstk(l1);
+            if (getAllocatedSingleString(pvApiCtx, piAddrStr, &looknfeel))
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
 
             try
             {
                 lnf = new org_scilab_modules_gui_utils::LookAndFeelManager(getScilabJavaVM());
             }
-            catch(const GiwsException::JniException & e)
+            catch (const GiwsException::JniException & e)
             {
+                freeAllocatedSingleString(looknfeel);
                 Scierror(999, _("%s: A Java exception arisen:\n%s"), fname, e.whatStr().c_str());
-                return FALSE;
+                return 1;
             }
 
             if (lnf)
             {
-                int *paramoutINT = (int *)MALLOC(sizeof(int));
+                int paramoutINT = 0;
 
-                *paramoutINT = (int)booltoBOOL(lnf->setLookAndFeel(looknfeel));
+                paramoutINT = (int)booltoBOOL(lnf->setLookAndFeel(looknfeel));
+                freeAllocatedSingleString(looknfeel);
                 delete lnf;
 
-                n1 = 1;
-                CreateVarFromPtr(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &n1, &n1, &paramoutINT);
-                LhsVar(1) = Rhs + 1;
-
-                if (paramoutINT)
+                if (createScalarBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, paramoutINT))
                 {
-                    FREE(paramoutINT);
-                    paramoutINT = NULL;
+                    Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                    return 1;
                 }
-                PutLhsVar();
+
+                AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+                returnArguments(pvApiCtx);
+                return 0;
             }
             else
             {
                 Scierror(999, _("%s: No more memory.\n"), fname);
+                return 1;
             }
         }
         else
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: A string expected.\n"), fname, 1);