graphics module ported to api_scilab. test_run("graphics") 15/9115/11
Cedric Delamarre [Mon, 24 Sep 2012 08:49:14 +0000 (10:49 +0200)]
Change-Id: Ibb35d371fc058fe40b605e8694541b501f0dc5c4

62 files changed:
scilab/modules/graphics/includes/gw_graphics.h
scilab/modules/graphics/sci_gateway/c/gw_graphics.c
scilab/modules/graphics/sci_gateway/c/sci_Legend.c
scilab/modules/graphics/sci_gateway/c/sci_StringBox.c
scilab/modules/graphics/sci_gateway/c/sci_champ.c
scilab/modules/graphics/sci_gateway/c/sci_contour2di.c
scilab/modules/graphics/sci_gateway/c/sci_copy.c
scilab/modules/graphics/sci_gateway/c/sci_delete.c
scilab/modules/graphics/sci_gateway/c/sci_demo.c
scilab/modules/graphics/sci_gateway/c/sci_drawaxis.c
scilab/modules/graphics/sci_gateway/c/sci_drawlater.c
scilab/modules/graphics/sci_gateway/c/sci_drawnow.c
scilab/modules/graphics/sci_gateway/c/sci_fec.c
scilab/modules/graphics/sci_gateway/c/sci_geom3d.c
scilab/modules/graphics/sci_gateway/c/sci_get.c
scilab/modules/graphics/sci_gateway/c/sci_glue.c
scilab/modules/graphics/sci_gateway/c/sci_grayplot.c
scilab/modules/graphics/sci_gateway/c/sci_is_handle_valid.c
scilab/modules/graphics/sci_gateway/c/sci_matplot.c
scilab/modules/graphics/sci_gateway/c/sci_matplot1.c
scilab/modules/graphics/sci_gateway/c/sci_move.c
scilab/modules/graphics/sci_gateway/c/sci_newaxes.c
scilab/modules/graphics/sci_gateway/c/sci_param3d.c
scilab/modules/graphics/sci_gateway/c/sci_param3d1.c
scilab/modules/graphics/sci_gateway/c/sci_plot2d.c
scilab/modules/graphics/sci_gateway/c/sci_plot2d1.c
scilab/modules/graphics/sci_gateway/c/sci_plot3d.c
scilab/modules/graphics/sci_gateway/c/sci_relocate_handle.c
scilab/modules/graphics/sci_gateway/c/sci_rotate_axes.c
scilab/modules/graphics/sci_gateway/c/sci_rubberbox.c
scilab/modules/graphics/sci_gateway/c/sci_set.c
scilab/modules/graphics/sci_gateway/c/sci_show_window.c
scilab/modules/graphics/sci_gateway/c/sci_swap_handles.c
scilab/modules/graphics/sci_gateway/c/sci_unglue.c
scilab/modules/graphics/sci_gateway/c/sci_unzoom.c
scilab/modules/graphics/sci_gateway/c/sci_winsid.c
scilab/modules/graphics/sci_gateway/c/sci_xarc.c
scilab/modules/graphics/sci_gateway/c/sci_xarcs.c
scilab/modules/graphics/sci_gateway/c/sci_xarrows.c
scilab/modules/graphics/sci_gateway/c/sci_xchange.c
scilab/modules/graphics/sci_gateway/c/sci_xclick.c
scilab/modules/graphics/sci_gateway/c/sci_xdel.c
scilab/modules/graphics/sci_gateway/c/sci_xfarcs.c
scilab/modules/graphics/sci_gateway/c/sci_xfpoly.c
scilab/modules/graphics/sci_gateway/c/sci_xfpolys.c
scilab/modules/graphics/sci_gateway/c/sci_xget.c
scilab/modules/graphics/sci_gateway/c/sci_xgetmouse.c
scilab/modules/graphics/sci_gateway/c/sci_xgraduate.c
scilab/modules/graphics/sci_gateway/c/sci_xgrid.c
scilab/modules/graphics/sci_gateway/c/sci_xlfont.c
scilab/modules/graphics/sci_gateway/c/sci_xname.c
scilab/modules/graphics/sci_gateway/c/sci_xpoly.c
scilab/modules/graphics/sci_gateway/c/sci_xpolys.c
scilab/modules/graphics/sci_gateway/c/sci_xrect.c
scilab/modules/graphics/sci_gateway/c/sci_xrects.c
scilab/modules/graphics/sci_gateway/c/sci_xsegs.c
scilab/modules/graphics/sci_gateway/c/sci_xset.c
scilab/modules/graphics/sci_gateway/c/sci_xstring.c
scilab/modules/graphics/sci_gateway/c/sci_xstringb.c
scilab/modules/graphics/sci_gateway/c/sci_xtitle.c
scilab/modules/graphics/sci_gateway/c/sci_zoom_rect.c
scilab/modules/graphics/sci_gateway/graphics_gateway.xml

index 4bce68b..a562e45 100644 (file)
@@ -2,11 +2,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2005 - INRIA - Allan Cornet
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
- * 
+ *
  * 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
  *
  */
@@ -58,7 +58,6 @@ GRAPHICS_IMPEXP int sci_unglue(char *fname, unsigned long fname_len);
 GRAPHICS_IMPEXP int sci_swap_handles(char *fname, unsigned long fname_len);
 GRAPHICS_IMPEXP int sci_stringbox(char *fname, unsigned long fname_len);
 GRAPHICS_IMPEXP int sci_show_window(char *fname, unsigned long fname_len);
-GRAPHICS_IMPEXP int sci_show_pixmap(char *fname, unsigned long fname_len);
 GRAPHICS_IMPEXP int sci_set(char *fname, unsigned long fname_len);
 GRAPHICS_IMPEXP int sci_rubberbox(char *fname, unsigned long fname_len);
 GRAPHICS_IMPEXP int sci_rotate_axes(char *fname, unsigned long fname_len);
@@ -92,12 +91,10 @@ GRAPHICS_IMPEXP int sci_fec(char *fname, unsigned long fname_len);
 GRAPHICS_IMPEXP int sci_drawnow(char *fname, unsigned long fname_len);
 GRAPHICS_IMPEXP int sci_drawlater(char *fname, unsigned long fname_len);
 GRAPHICS_IMPEXP int sci_drawaxis(char *fname, unsigned long fname_len);
-GRAPHICS_IMPEXP int sci_draw(char *fname, unsigned long fname_len);
 GRAPHICS_IMPEXP int sci_demo(char *fname, int fname_len);
 GRAPHICS_IMPEXP int sci_delete(char *fname, unsigned long fname_len);
 GRAPHICS_IMPEXP int sci_copy(char *fname, unsigned long fname_len);
 GRAPHICS_IMPEXP int sci_contour2di(char *fname, unsigned long fname_len);
-GRAPHICS_IMPEXP int sci_clear_pixmap(char *fname, unsigned long fname_len);
 
 /*--------------------------------------------------------------------------*/
 #endif /* __INTGRAPHICS__ */
index 06e41ca..5aca499 100644 (file)
@@ -25,7 +25,8 @@
 static BOOL loadedDep = FALSE;
 
 /*--------------------------------------------------------------------------*/
-static gw_generic_table Tab[] = {
+static gw_generic_table Tab[] =
+{
     {sci_champ, "champ"},
     {sci_champ1, "champ1"},
     {sci_fec, "fec"},
@@ -50,7 +51,7 @@ static gw_generic_table Tab[] = {
     {sci_xarrows, "xarrows"},
     {sci_drawaxis, "drawaxis"},
     {sci_xchange, "xchange"},
-    {sci_show_pixmap, "show_pixmap"},
+    {NULL, ""},//show_pixmap
     {sci_xclick, "xclick"},
     {sci_xdel, "xdel"},
     {sci_xarc, "xfarc"},
@@ -75,7 +76,7 @@ static gw_generic_table Tab[] = {
     {sci_xtitle, "xtitle"},
     {sci_xgraduate, "xgraduate"},
     {sci_xname, "xname"},
-    {sci_clear_pixmap, "clear_pixmap"},
+    {NULL, ""}, //clear_pixmap
     {sci_zoom_rect, "zoom_rect"},
     {sci_unzoom, "unzoom"},
     {sci_stringbox, "stringbox"},
@@ -84,7 +85,7 @@ static gw_generic_table Tab[] = {
     {sci_unglue, "unglue"},
     {sci_drawnow, "drawnow"},
     {sci_drawlater, "drawlater"},
-    {sci_draw, "draw"},
+    {NULL, ""}, // draw
     {NULL, ""}, // was addcb, unusable.
     {sci_copy, "copy"},
     {sci_delete, "delete"},
@@ -103,14 +104,14 @@ static gw_generic_table Tab[] = {
 /* interface for the previous function Table */
 int gw_graphics(void)
 {
-    Rhs = Max(0, Rhs);
+    nbInputArgument(pvApiCtx) = Max(0, nbInputArgument(pvApiCtx));
 
-    if(pvApiCtx == NULL)
+    if (pvApiCtx == NULL)
     {
         pvApiCtx = (StrCtx*)MALLOC(sizeof(StrCtx));
     }
 
-    pvApiCtx->pstName = (char*)Tab[Fin-1].name;
+    pvApiCtx->pstName = (char*)Tab[Fin - 1].name;
     if ( getScilabMode() != SCILAB_NWNI )
     {
         if (!loadedDep)
@@ -122,17 +123,17 @@ int gw_graphics(void)
     }
     else
     {
-        if ( (strcmp(Tab[Fin-1].name, "set")==0 ||
-              strcmp(Tab[Fin-1].name, "delete")==0 ||
-              strcmp(Tab[Fin-1].name, "get")==0) &&
-             (VarType(1)==sci_tlist || VarType(1)==sci_mlist))
+        if ( (strcmp(Tab[Fin - 1].name, "set") == 0 ||
+                strcmp(Tab[Fin - 1].name, "delete") == 0 ||
+                strcmp(Tab[Fin - 1].name, "get") == 0) &&
+                (getInputArgumentType(pvApiCtx, 1) == sci_tlist || getInputArgumentType(pvApiCtx, 1) == sci_mlist))
         {
             callFunctionFromGateway(Tab, SIZE_CURRENT_GENERIC_TABLE(Tab));
             return 0;
         }
         else
         {
-            Scierror(999,_("Scilab graphic module disabled -nogui or -nwni mode.\n"));
+            Scierror(999, _("Scilab graphic module disabled -nogui or -nwni mode.\n"));
         }
     }
 
index f68ebc3..cdc43ed 100644 (file)
@@ -21,7 +21,7 @@
 #include <string.h>
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "BuildObjects.h"
 #include "MALLOC.h"
 #include "localization.h"
 /*--------------------------------------------------------------------------*/
 int sci_Legend( char * fname, unsigned long fname_len )
 {
-    int numrow = 0, numcol = 0, l1 = 0, l2 = 0, n = 0, m2 = 0, n2 = 0;
+    SciErr sciErr;
+
+    double* Empty = NULL;
+    int* piAddrl1 = NULL;
+    long long* l1 = NULL;
+    int* piAddrStr = NULL;
+    int* piAddrl2 = NULL;
+    char* l2 = NULL;
+    long long* outindex = NULL;
+
+    int numrow = 0, numcol = 0, n = 0, m2 = 0, n2 = 0;
     long handlesvalue = 0;
-    int outindex = 0, i = 0;
+    int i = 0;
     char *pobjUID = NULL;
     long long *tabofhandles = NULL;
     char * psubwinUID = NULL;
@@ -54,38 +64,92 @@ int sci_Legend( char * fname, unsigned long fname_len )
     char **Str = NULL;
     char * legendUID = NULL;
 
-    CheckRhs(2, 3);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 2, 3);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
 
     GetMatrixdims(1, &numrow, &numcol);
     n = numrow * numcol;
     if (numrow == 0 || numcol == 0)
     {
-        CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &numrow, &numcol, &l1);
-        LhsVar(1) = Rhs + 1;
-        PutLhsVar();
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, numrow, numcol, &Empty);
+        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 0;
     }
+
     GetMatrixdims(2, &m2, &n2);
     if (m2*n2 != n)
     {
         Scierror(999, _("%s: Wrong size for input arguments #%d and #%d: Incompatible length.\n"), fname, 1, 2);
-        return 0;
+        return 1;
+    }
+
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of handle at position 1.
+    sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &numrow, &numcol, &l1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+        return 1;
+    }
+
+    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))
+    {
+        freeAllocatedMatrixOfString(m2, n2, Str);
+        Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+        return 1;
+    }
 
-    GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &numrow, &numcol, &l1);
-    GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &m2, &n2, &Str);
-    if (Rhs == 3)
+    if (nbInputArgument(pvApiCtx) == 3)
     {
-        GetRhsVar(3, STRING_DATATYPE, &m2, &n2, &l2);
-        location = propertyNameToLegendPlace(cstk(l2));
+        sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 3.
+        if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2))
+        {
+            freeAllocatedMatrixOfString(m2, n2, Str);
+            freeAllocatedSingleString(l2);
+            Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 3);
+            return 1;
+        }
+
+        location = propertyNameToLegendPlace((l2));
 
         if (location == SCI_LEGEND_POSITION_UNSPECIFIED)
         {
+            freeAllocatedMatrixOfString(m2, n2, Str);
+            freeAllocatedSingleString(l2);
             Scierror(999, _("%s: Wrong value for input argument #%d: Incorrect value.\n"), fname, 3);
-            return 0;
+            return 1;
         }
     }
     else
@@ -96,29 +160,29 @@ int sci_Legend( char * fname, unsigned long fname_len )
     tabofhandles = (long long *)MALLOC(n * sizeof(long long));
     if (tabofhandles == NULL)
     {
-        freeArrayOfString(Str, n);
+        freeAllocatedMatrixOfString(m2, n2, Str);
         Scierror(999, _("%s: No more memory.\n"), fname);
-        return 0;
+        return 1;
     }
 
     for (i = 0; i < n; i++)
     {
         char* subwinUID;
 
-        handlesvalue = (unsigned long) (hstk(l1))[n - 1 - i];
+        handlesvalue = (unsigned long) ((long long*)(l1))[n - 1 - i];
         pobjUID = (char*)getObjectFromHandle(handlesvalue);
 
         if (pobjUID == NULL)
         {
-            freeArrayOfString(Str, n);
+            freeAllocatedMatrixOfString(m2, n2, Str);
             FREE(tabofhandles);
             Scierror(999, _("%s: The handle is no more valid.\n"), fname);
-            return 0;
+            return 1;
         }
 
-       /**
-         * We get the current pSubwin & pFigure from the first handle's parents.
-         */
+        /**
+          * We get the current pSubwin & pFigure from the first handle's parents.
+          */
         if (i == 0)
         {
             getGraphicObjectProperty(pobjUID, __GO_PARENT_FIGURE__, jni_string, (void **)&pFigureUID);
@@ -132,19 +196,20 @@ int sci_Legend( char * fname, unsigned long fname_len )
 
         if (strcmp(psubwinUID, subwinUID) != 0)
         {
+            freeAllocatedMatrixOfString(m2, n2, Str);
             Scierror(999, _("%s: Objects must have the same axes.\n"), fname);
             FREE(tabofhandles);
-            return 0;
+            return 1;
         }
 
         getGraphicObjectProperty(pobjUID, __GO_TYPE__, jni_int, (void **)&piType);
 
         if (type != __GO_POLYLINE__)
         {
-            freeArrayOfString(Str, n);
+            freeAllocatedMatrixOfString(m2, n2, Str);
             FREE(tabofhandles);
             Scierror(999, _("%s: The %d th handle is not a polyline handle.\n"), fname, i + 1);
-            return 0;
+            return 1;
         }
 
         tabofhandles[i] = handlesvalue;
@@ -155,16 +220,24 @@ int sci_Legend( char * fname, unsigned long fname_len )
 
     setGraphicObjectProperty(legendUID, __GO_LEGEND_LOCATION__, &location, jni_int, 1);
 
-    freeArrayOfString(Str, n);
+    freeAllocatedMatrixOfString(m2, n2, Str);
     FREE(tabofhandles);
 
     /* Return the handle of the newly created legend */
     numrow = 1;
     numcol = 1;
-    CreateVar(Rhs + 1, GRAPHICAL_HANDLE_DATATYPE, &numrow, &numcol, &outindex);
-    hstk(outindex)[0] = getHandle((char *) getCurrentObject());
-    LhsVar(1) = Rhs + 1;
-    PutLhsVar();
+
+    sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, numrow, numcol, &outindex);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
+
+    outindex[0] = getHandle((char *) getCurrentObject());
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 /*--------------------------------------------------------------------------*/
index e2a36c5..917a632 100644 (file)
@@ -20,7 +20,7 @@
 
 #include "gw_graphics.h"
 #include "Scierror.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "GetProperty.h"
 #include "StringBox.h"
 #include "localization.h"
@@ -40,17 +40,34 @@ static int getScalarFromStack(int paramIndex, char * funcName, double * res);
 /*--------------------------------------------------------------------------*/
 static int getScalarFromStack(int paramIndex, char * funcName, double * res)
 {
+    SciErr sciErr;
     int m = 0;
     int n = 0;
-    size_t stackPointer = 0;
-    if ( VarType(paramIndex) != sci_matrix )
+    int* piAddrstackPointer = NULL;
+    double* stackPointer = NULL;
+    if ((!checkInputArgumentType(pvApiCtx, paramIndex, sci_matrix)) )
     {
         Scierror(999, _("%s: Wrong type for input argument #%d: Real scalar expected.\n"), funcName, paramIndex);
         return -1 ;
     }
 
     /* get the handle */
-    GetRhsVar( paramIndex, MATRIX_OF_DOUBLE_DATATYPE, &m, &n, &stackPointer );
+    sciErr = getVarAddressFromPosition(pvApiCtx,  paramIndex, &piAddrstackPointer);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return -1;
+    }
+
+    // Retrieve a matrix of double at position  paramIndex.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrstackPointer, &m, &n, &stackPointer);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), funcName,  paramIndex);
+        return -1;
+    }
+
 
     if ( m * n != 1 )
     {
@@ -58,40 +75,63 @@ static int getScalarFromStack(int paramIndex, char * funcName, double * res)
         return -1 ;
     }
 
-    *res = *(stk(stackPointer));
+    *res = *stackPointer;
     return 0;
 }
 /*--------------------------------------------------------------------------*/
 int sci_stringbox( char * fname, unsigned long fname_len )
 {
+
+    SciErr sciErr;
+
+    int* piAddrstackPointer = NULL;
+    long long* stackPointer = NULL;
+    char** strStackPointer   = NULL;
+    double* pdblStackPointer = NULL;
+
     int type = -1;
     int *piType = &type;
+
     char* parentAxes = NULL;
     double* textCorners = NULL;
     int two   = 2;
     int four  = 4;
-    size_t stackPointer = 0;
     double corners[4][2]; /* the four edges of the boundingRect */
 
     /* The function should be called with stringbox( handle ) */
-    CheckRhs( 1, 6 );
-    CheckLhs( 0, 1 );
+    CheckInputArgument(pvApiCtx,  1, 6 );
+    CheckOutputArgument(pvApiCtx,  0, 1 );
 
-    if (Rhs == 1)
+    if (nbInputArgument(pvApiCtx) == 1)
     {
         int m;
         int n;
         /* A text handle should be specified */
 
         char * pTextUID = NULL;
-        if ( VarType(1) != sci_handles )
+        if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles)) )
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: A 'Text' handle expected.\n"), fname, 1);
             return 0 ;
         }
 
         /* get the handle */
-        GetRhsVar( 1, GRAPHICAL_HANDLE_DATATYPE, &m, &n, &stackPointer );
+        sciErr = getVarAddressFromPosition(pvApiCtx,  1, &piAddrstackPointer);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of handle at position  1.
+        sciErr = getMatrixOfHandle(pvApiCtx, piAddrstackPointer, &m, &n, &stackPointer);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname,  1);
+            return 1;
+        }
+
         if ( m * n != 1 )
         {
             Scierror(999, _("%s: Wrong size for input argument #%d: A 'Text' handle expected.\n"), fname, 1);
@@ -99,7 +139,7 @@ int sci_stringbox( char * fname, unsigned long fname_len )
         }
 
         /* Get the handle and check that this is a text handle */
-        pTextUID = (char*)getObjectFromHandle(getHandleFromStack(stackPointer));
+        pTextUID = (char*)getObjectFromHandle((long int) * stackPointer);
 
         if ( pTextUID == NULL )
         {
@@ -138,7 +178,7 @@ int sci_stringbox( char * fname, unsigned long fname_len )
         corners[2][0] = textCorners[9];
         corners[2][1] = textCorners[10];
     }
-    else if (Rhs == 2)
+    else if (nbInputArgument(pvApiCtx) == 2)
     {
         Scierror(999, _("%s: Wrong number of input arguments: %d or %d to %d expected.\n"), fname, 1, 3, 6);
         return 0 ;
@@ -161,79 +201,99 @@ int sci_stringbox( char * fname, unsigned long fname_len )
         getGraphicObjectProperty(parentSubwinUID, __GO_FONT_SIZE__, jni_double, (void **)&pfontSize);
 
         /* Check that first argument is a string */
-        if ( VarType(1) != sci_strings )
+        if ((!checkInputArgumentType(pvApiCtx, 1, sci_strings)) )
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: 2D array of strings expected.\n"), fname, 1);
             return 0 ;
         }
-        GetRhsVar( 1, MATRIX_OF_STRING_DATATYPE, &textNbRow, &textNbCol, &stackPointer );
+        sciErr = getVarAddressFromPosition(pvApiCtx,  1, &piAddrstackPointer);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of string at position  1.
+        if (getAllocatedMatrixOfString(pvApiCtx, piAddrstackPointer, &textNbRow, &textNbCol, &strStackPointer))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname,  1);
+            return 1;
+        }
+
         /* retrieve it */
-        text = getStringMatrixFromStack(stackPointer);
+        text = strStackPointer;
 
         /* Second and third arguments should be scalars */
         if (getScalarFromStack(2, fname, &xPos) < 0)
         {
-            freeArrayOfString(text, textNbRow * textNbCol);
+            freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer);
             return 0;
         }
+
         if (getScalarFromStack(3, fname, &yPos) < 0)
         {
-            freeArrayOfString(text, textNbRow * textNbCol);
+            freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer);
             return 0;
         }
 
-        if (Rhs >= 4)
+        if (nbInputArgument(pvApiCtx) >= 4)
         {
             /* angle is defined */
             if (getScalarFromStack(4, fname, &angle) < 0)
             {
-                freeArrayOfString(text, textNbRow * textNbCol);
+                freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer);
                 return 0;
             }
         }
 
-        if (Rhs >= 5)
+        if (nbInputArgument(pvApiCtx) >= 5)
         {
             double fontIdD;
             /* font style is defined */
             if (getScalarFromStack(5, fname, &fontIdD) < 0)
             {
-                freeArrayOfString(text, textNbRow * textNbCol);
+                freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer);
                 return 0;
             }
             fontId = (int) fontIdD;
         }
 
-        if (Rhs >= 6)
+        if (nbInputArgument(pvApiCtx) >= 6)
         {
             /* font size is defined */
             if (getScalarFromStack(6, fname, &fontSize) < 0)
             {
-                freeArrayOfString(text, textNbRow * textNbCol);
+                freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer);
                 return 0;
             }
         }
 
         /* compute the box */
         getTextBoundingBox(text, textNbRow, textNbCol, xPos, yPos, angle, fontId, fontSize, corners);
-        freeArrayOfString(text, textNbRow * textNbCol);
+        freeAllocatedMatrixOfString(textNbRow, textNbCol, strStackPointer);
     }
 
 
     /* copy everything into the lhs */
-    stackPointer = 0; /* Fix for 64 bits: MSB of stackPointer has been set by GetRhsVar but are not reset by CreateVar */
-    CreateVar( Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &two, &four, &stackPointer );
-    *stk( stackPointer     )  = corners[1][0] ;
-    *stk( stackPointer + 1 )  = corners[1][1] ;
-    *stk( stackPointer + 2 )  = corners[0][0] ;
-    *stk( stackPointer + 3 )  = corners[0][1] ;
-    *stk( stackPointer + 4 )  = corners[3][0] ;
-    *stk( stackPointer + 5 )  = corners[3][1] ;
-    *stk( stackPointer + 6 )  = corners[2][0] ;
-    *stk( stackPointer + 7 )  = corners[2][1] ;
-
-    LhsVar( 1 ) = Rhs + 1 ;
-    PutLhsVar();
+    sciErr = allocMatrixOfDouble(pvApiCtx,  nbInputArgument(pvApiCtx) + 1, two, four, &pdblStackPointer);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
+
+    pdblStackPointer[0] = corners[1][0];
+    pdblStackPointer[1] = corners[1][1];
+    pdblStackPointer[2] = corners[0][0];
+    pdblStackPointer[3] = corners[0][1];
+    pdblStackPointer[4] = corners[3][0];
+    pdblStackPointer[5] = corners[3][1];
+    pdblStackPointer[6] = corners[2][0];
+    pdblStackPointer[7] = corners[2][1];
+
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1 ;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 
index 67a39c2..848b328 100644 (file)
@@ -18,7 +18,7 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "GetCommandArg.h"
 #include "BuildObjects.h"
 #include "DefaultCommandArg.h"
 #include "localization.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
-int sci_champ (char *fname,unsigned long fname_len)
+int sci_champ (char *fname, unsigned long fname_len)
 {
-    return sci_champ_G(fname,C2F(champ),fname_len);
+    return sci_champ_G(fname, C2F(champ), fname_len);
 }
 /*--------------------------------------------------------------------------*/
-int sci_champ1 (char *fname,unsigned long fname_len)
+int sci_champ1 (char *fname, unsigned long fname_len)
 {
-    return sci_champ_G(fname,C2F(champ1),fname_len);
+    return sci_champ_G(fname, C2F(champ1), fname_len);
 }
 /*--------------------------------------------------------------------------*/
 int sci_champ_G(char *fname,
                 int (*func) (double *, double *, double *, double *, int *, int *, char *, double *, double *, int),
                 unsigned long fname_len)
 {
+    SciErr sciErr;
     double arfact_def = 1.0;
     double * arfact = &arfact_def;
-    int m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0, m3 = 0, n3 = 0, l3 = 0, m4 = 0, n4 = 0, l4 = 0;
-    static rhs_opts opts[]= { {-1,"arfact","?",0,0,0},
-                              {-1,"rect","?",0,0,0},
-                              {-1,"strf","?",0,0,0},
-                              {-1,NULL,NULL,0,0}};
+    int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0;
+    static rhs_opts opts[] =
+    {
+        { -1, "arfact", "?", 0, 0, 0},
+        { -1, "rect", "?", 0, 0, 0},
+        { -1, "strf", "?", 0, 0, 0},
+        { -1, NULL, NULL, 0, 0}
+    };
 
     char   * strf = NULL ;
     double * rect = NULL ;
 
-    CheckRhs(-1,7) ;
-    CheckLhs(0,1) ;
+    int* piAddr1 = NULL;
+    int* piAddr2 = NULL;
+    int* piAddr3 = NULL;
+    int* piAddr4 = NULL;
+
+    double* l1 = NULL;
+    double* l2 = NULL;
+    double* l3 = NULL;
+    double* l4 = NULL;
+
+    CheckInputArgument(pvApiCtx, -1, 7) ;
+    CheckOutputArgument(pvApiCtx, 0, 1) ;
 
-    if (Rhs <= 0)
+    if (nbInputArgument(pvApiCtx) <= 0)
     {
         sci_demo(fname, fname_len);
         return 0;
     }
-    else if ( Rhs < 4 )
+    else if (nbInputArgument(pvApiCtx) < 4)
     {
-        Scierror(999,_("%s: Wrong number of input arguments: At least %d expected.\n"),fname,4);
+        Scierror(999, _("%s: Wrong number of input arguments: At least %d expected.\n"), fname, 4);
         return 0;
     }
 
-    if ( get_optionals(fname,opts) == 0)
+    if (get_optionals(fname, opts) == 0)
     {
         return 0;
     }
 
     if ( FirstOpt() < 5 )
     {
-        Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname,1, 5);
+        Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 5);
         return -1;
     }
 
-    GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-    GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
-    GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE, &m3, &n3, &l3);
-    GetRhsVar(4,MATRIX_OF_DOUBLE_DATATYPE, &m4, &n4, &l4);
-    CheckSameDims(3,4,m3,n3,m4,n4);
-    CheckDimProp(2,3,m2 * n2 != n3);
-    CheckDimProp(1,3,m1 * n1 != m3);
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 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;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 3.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 4.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &l4);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    //CheckSameDims
+    if (m3 != m4 || n3 != n4)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 3, m3, n3);
+        return 1;
+    }
+
+    //CheckDimProp
+    if (m2 * n2 != n3)
+    {
+        Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
+        return 1;
+    }
+
+    //CheckDimProp
+    if (m1 * n1 != m3)
+    {
+        Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
+        return 1;
+    }
+
     if (m3 * n3 == 0)
     {
-        LhsVar(1) = 0;
-        PutLhsVar();
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
         return 0;
     }
 
-    GetOptionalDoubleArg(fname,5,"arfact",&arfact,1,opts);
-    GetRect(fname,6,opts,&rect);
-    GetStrf(fname,7,opts,&strf);
+    GetOptionalDoubleArg(fname, 5, "arfact", &arfact, 1, opts);
+    GetRect(fname, 6, opts, &rect);
+    GetStrf(fname, 7, opts, &strf);
 
     getOrCreateDefaultSubwin();
 
     if ( isDefStrf( strf ) )
     {
         char strfl[4];
-        strcpy(strfl,DEFSTRFN);
+        strcpy(strfl, DEFSTRFN);
         strf = strfl;
         if ( !isDefRect( rect ) )
         {
-            strf[1]='5';
+            strf[1] = '5';
         }
     }
 
-    (*func)(stk(l1 ),stk(l2 ),stk(l3 ),stk(l4 ),&m3,&n3,strf,rect, arfact, 4L);
-    LhsVar(1) = 0;
-    PutLhsVar();
+    (*func)((l1 ), (l2 ), (l3 ), (l4 ), &m3, &n3, strf, rect, arfact, 4L);
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 /*--------------------------------------------------------------------------*/
index c198e30..3ba0355 100644 (file)
@@ -2,11 +2,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Fabrice Leray
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
- * 
+ *
  * 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
  *
  */
@@ -17,6 +17,7 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
+#include "api_scilab.h"
 #include "GetCommandArg.h"
 #include "Scierror.h"
 #include "Contour.h"
 /*--------------------------------------------------------------------------*/
 int sci_contour2di( char * fname, unsigned long fname_len )
 {
-  int flagx = 0, nz = 10; /* default number of level curves : 10 */
-  int m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0, m3 = 0, n3 = 0, l3 = 0, m4 = 0, n4 = 0, l4 = 0, l5 = 0;
-  double  *hl1 = NULL, *hl2 = NULL;
-  double *znz= NULL;
-  int ix4, i = 0, un = 1;
-
-  CheckRhs(3,4);
-  CheckLhs(2,2);
-
-  GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-  CheckVector(1,m1,n1);
-  GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
-  CheckVector(2,m2,n2);
-  GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE, &m3, &n3, &l3);
-  if (m3 * n3 == 0) {
-               LhsVar(1) = 0;
-               PutLhsVar();
-               return 0;
-       }
-  if (m3 == 1 || n3 == 1) {
-    Scierror(999,_("%s: Wrong type for input argument #%d: Matrix expected.\n"),fname,3);
+    SciErr sciErr;
+    int flagx = 0, nz = 10; /* default number of level curves : 10 */
+    int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0;
+    double* hl1 = NULL;
+    double* hl2 = NULL;
+    double* znz = NULL;
+    int ix4, i = 0, un = 1;
+
+    int* piAddr1 = NULL;
+    int* piAddr2 = NULL;
+    int* piAddr3 = NULL;
+    int* piAddr4 = NULL;
+
+    double* l1 = NULL;
+    double* l2 = NULL;
+    double* l3 = NULL;
+    double* l4 = NULL;
+    int* l5    = NULL;
+
+    CheckInputArgument(pvApiCtx, 4, 4);
+    CheckOutputArgument(pvApiCtx, 2, 2);
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 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;
+    }
+
+    //CheckVector
+    if (m1 != 1 && n1 != 1)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 1);
+        return 1;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    //CheckVector
+    if (m2 != 1 && n2 != 1)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 2);
+        return 1;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 3.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    if (m3 * n3 == 0)
+    {
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+    if (m3 == 1 || n3 == 1)
+    {
+        Scierror(999, _("%s: Wrong type for input argument #%d: Matrix expected.\n"), fname, 3);
+        return 1;
+    }
+
+    //CheckDimProp
+    if (m1 * n1 != m3)
+    {
+        Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
+        return 1;
+    }
+
+    //CheckDimProp
+    if (m2 * n2 != n3)
+    {
+        Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
+        return 1;
+    }
+
+    /*     number of level curves */
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 4.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &l4);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    if (m4 * n4 == 1)
+    {
+        flagx = 0;
+        nz = Max(1, (int)  * (l4));
+        znz = (l4);
+    }
+    else
+    {
+        flagx = 1;
+        nz = m4 * n4;
+        znz = (l4);
+    }
+
+    ix4 = Max(nz, 2);
+
+    sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, 5, un, ix4, &l5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
+
+    for (i = 0 ; i < ix4 ; ++i)
+    {
+        l5[i] = i + 1;
+    }
+
+    if (nz == 1)
+    {
+        l5[1] = 1;
+    }
+
+    if (C2F(contourif)(l1, l2, l3, &m3, &n3, &flagx, &nz, znz, l5) != 0)
+    {
+        /* Something wrong happened */
+        return -1;
+    }
+
+    C2F(getconts)(&hl1, &hl2, &m1, &n1);
+    if (n1 == 0)
+    {
+        sciErr = allocMatrixOfDouble(pvApiCtx, 6, n1, n1, &hl1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        sciErr = allocMatrixOfDouble(pvApiCtx, 7, n1, n1, &hl2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+    }
+    else
+    {
+        sciErr = createMatrixOfDouble(pvApiCtx, 6, m1, n1, hl1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        sciErr = createMatrixOfDouble(pvApiCtx, 7, m1, n1, hl2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+    }
+    AssignOutputVariable(pvApiCtx, 1) = 6;
+    AssignOutputVariable(pvApiCtx, 2) = 7;
+    ReturnArguments(pvApiCtx);
     return 0;
-  }
-
-  CheckDimProp(1,3, m1 * n1 != m3); 
-  CheckDimProp(2,3, m2 * n2 != n3); 
-
-  /*     number of level curves */
-  if ( Rhs == 4 ) 
-  {
-    GetRhsVar(4,MATRIX_OF_DOUBLE_DATATYPE, &m4, &n4, &l4);
-    if (m4 * n4 == 1) {
-      flagx = 0;  nz = Max(1,(int)  *stk(l4)),znz= stk(l4);
-    } else {
-      flagx = 1;  nz = m4 * n4; znz=stk(l4);
-    }
-  }
-
-  ix4 = Max(nz,2);
-  CreateVar(Rhs+1,MATRIX_OF_INTEGER_DATATYPE,&un,&ix4,&l5);
-  for (i =0 ; i < ix4 ; ++i) *istk(l5 + i ) = i+1;
-  if (nz == 1) *istk(l5 +1) = 1;
-
-  if (C2F(contourif)(stk(l1),stk(l2),stk(l3),&m3,&n3,&flagx,&nz,znz,istk(l5)) != 0)
-       {
-               /* Something wrong happened */
-               return -1;      
-       }
-  C2F(getconts)(&hl1, &hl2, &m1, &n1);
-  if (n1 == 0)
-  {
-    CreateVar(6,MATRIX_OF_DOUBLE_DATATYPE, &n1, &n1, &l1);
-    CreateVar(7,MATRIX_OF_DOUBLE_DATATYPE, &n1, &n1, &l2);
-  }
-  else 
-  {
-    CreateVarFromPtr(6,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &hl1);
-    CreateVarFromPtr(7,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &hl2);
-  }
-  LhsVar(1)=Rhs+2;
-  LhsVar(2)=Rhs+3;
-  PutLhsVar();
-  return 0;
 }
 /*--------------------------------------------------------------------------*/
index 4270240..8721309 100644 (file)
@@ -21,7 +21,7 @@
 #include <stdlib.h>
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "GetProperty.h"
 #include "CloneObjects.h"
 #include "localization.h"
 /*--------------------------------------------------------------------------*/
 int sci_copy(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    long long* l1 = NULL;
+    int* piAddrl2 = NULL;
+    long long* l2 = NULL;
+    long long* outindex = NULL;
+
     unsigned long hdl = 0, hdlparent = 0;
     char *pobjUID = NULL, *psubwinparenttargetUID = NULL, *pcopyobjUID = NULL;
-    int m1 = 0, n1 = 0, l1 = 0, l2 = 0;
-    int numrow = 0, numcol = 0, outindex = 0, lw = 0;
     int iType = -1;
     int *piType = &iType;
+    int m1 = 0, n1 = 0;
+    int numrow = 0, numcol = 0, lw = 0;
     int isPolyline = 0;
 
-    CheckRhs(1, 2);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 1, 2);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     /*  set or create a graphic window*/
-    lw = 1 + Top - Rhs;
-    GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &m1, &n1, &l1); /* Gets the Handle passed as argument*/
+    lw = 1 + nbArgumentOnStack(pvApiCtx) - nbInputArgument(pvApiCtx);
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of handle at position 1.
+    sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &m1, &n1, &l1); /* Gets the Handle passed as argument*/
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+        return 1;
+    }
+
     if (m1 != 1 || n1 != 1)
     {
         C2F(overload)(&lw, "copy", 4);
         return 0;
     }
 
-    hdl = (unsigned long) * hstk(l1); /* on recupere le pointeur d'objet par le handle*/
+    hdl = (unsigned long) * l1; /* on recupere le pointeur d'objet par le handle*/
     pobjUID = (char*)getObjectFromHandle(hdl);
     if (pobjUID == NULL)
     {
@@ -64,16 +87,16 @@ int sci_copy(char *fname, unsigned long fname_len)
 
     getGraphicObjectProperty(pobjUID, __GO_TYPE__, jni_int, (void **)&piType);
 
-    if (piType != __GO_TEXT__ &&
-        piType != __GO_ARC__ &&
-        piType != __GO_POLYLINE__ &&
-        piType != __GO_RECTANGLE__)
+    if (iType != __GO_TEXT__ &&
+            iType != __GO_ARC__ &&
+            iType != __GO_POLYLINE__ &&
+            iType != __GO_RECTANGLE__)
     {
         C2F(overload)(&lw, "copy", 4);
         return 0;
     }
 
-    if (piType == __GO_POLYLINE__)
+    if (iType == __GO_POLYLINE__)
     {
         isPolyline = 1;
     }
@@ -82,10 +105,25 @@ int sci_copy(char *fname, unsigned long fname_len)
         isPolyline = 0;
     }
 
-    if (Rhs > 1)
+    if (nbInputArgument(pvApiCtx) > 1)
     {
-        GetRhsVar(2, GRAPHICAL_HANDLE_DATATYPE, &m1, &n1, &l2); /* Gets the command name */
-        hdlparent = (unsigned long) * hstk(l2); /* on recupere le pointeur d'objet par le handle*/
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of handle at position 2.
+        sciErr = getMatrixOfHandle(pvApiCtx, piAddrl2, &m1, &n1, &l2); /* Gets the command name */
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 2);
+            return 1;
+        }
+
+        hdlparent = (unsigned long) * l2; /* on recupere le pointeur d'objet par le handle*/
         psubwinparenttargetUID = (char*)getObjectFromHandle(hdlparent);
         if ( psubwinparenttargetUID == NULL)
         {
@@ -110,7 +148,14 @@ int sci_copy(char *fname, unsigned long fname_len)
 
     numrow   = 1;
     numcol   = 1;
-    CreateVar(Rhs + 1, GRAPHICAL_HANDLE_DATATYPE, &numrow, &numcol, &outindex);
+    sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, numrow, numcol, &outindex);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
+
 
     if (isPolyline)
     {
@@ -121,13 +166,13 @@ int sci_copy(char *fname, unsigned long fname_len)
         pcopyobjUID = cloneGraphicObject(pobjUID);
     }
 
-    *hstk(outindex) = getHandle(pcopyobjUID);
+    *(outindex) = getHandle(pcopyobjUID);
 
     setGraphicObjectRelationship(psubwinparenttargetUID, pcopyobjUID);
     releaseGraphicObjectProperty(__GO_PARENT__, pcopyobjUID, jni_string, 1);
 
-    LhsVar(1) = Rhs + 1;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
 
     return 0;
 }
index 3f44cac..596bbf3 100644 (file)
@@ -20,7 +20,7 @@
 
 #include "MALLOC.h"
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "DestroyObjects.h"
 #include "SetProperty.h"
 #include "GetProperty.h"
 /*--------------------------------------------------------------------------*/
 int sci_delete(char *fname, unsigned long fname_len)
 {
-    int m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0, lw = 0;
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    long long* l1 = NULL;
+    int* piAddrl2 = NULL;
+    char* l2 = NULL;
+
+    int m1 = 0, n1 = 0, lw = 0;
     unsigned long hdl = 0;
     int nb_handles = 0, i = 0, dont_overload = 0;
     char *pobjUID = NULL;
@@ -67,17 +74,17 @@ int sci_delete(char *fname, unsigned long fname_len)
     int iObjType = -1;
     int *piObjType = &iObjType;
 
-    CheckRhs(0, 1);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 0, 1);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
-    if (Rhs == 0)               /* Delete current object */
+    if (nbInputArgument(pvApiCtx) == 0)               /* Delete current object */
     {
         pobjUID = (char*)getCurrentObject();
         if (pobjUID == NULL)
         {
             //No current object, we can leave
-            LhsVar(1) = 0;
-            PutLhsVar();
+            AssignOutputVariable(pvApiCtx, 1) = 0;
+            ReturnArguments(pvApiCtx);
             return 0;
         }
 
@@ -87,22 +94,63 @@ int sci_delete(char *fname, unsigned long fname_len)
     }
     else
     {
-        switch (VarType(1))
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        switch (getInputArgumentType(pvApiCtx, 1))
         {
             case sci_handles:      /* delete Entity given by a handle */
-                GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &m1, &n1, &l1); /* Gets the Handle passed as argument */
+
+                // Retrieve a matrix of handle at position 1.
+                sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &m1, &n1, &l1); /* Gets the Handle passed as argument */
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+                    return 1;
+                }
+
                 nb_handles = m1 * n1;
 
-                if (Rhs == 2)
+                if (nbInputArgument(pvApiCtx) == 2)
                 {
-                    GetRhsVar(2, STRING_DATATYPE, &m2, &n2, &l2);   /* Gets the command name */
+                    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 1;
+                    }
+
+                    // Retrieve a matrix of double at position 2.
+                    if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2))   /* Gets the command name */
+                    {
+                        Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
+                        return 1;
+                    }
                 }
-                hdl = (unsigned long) * hstk(l1); /* Puts the value of the Handle to hdl */
+                hdl = (unsigned long) * (l1); /* Puts the value of the Handle to hdl */
                 break;
             case sci_strings:      /* delete("all") */
-                CheckRhs(1, 1);
-                GetRhsVar(1, STRING_DATATYPE, &m2, &n2, &l2);
-                if (strcmp(cstk(l2), "all") == 0)
+                CheckInputArgument(pvApiCtx, 1, 1);
+                sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl2);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 1;
+                }
+
+                // Retrieve a matrix of double at position 1.
+                if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2))
+                {
+                    Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+                    return 1;
+                }
+
+                if (strcmp((l2), "all") == 0)
                 {
                     int i = 0;
                     int iFigureNumber = sciGetNbFigure();
@@ -110,8 +158,8 @@ int sci_delete(char *fname, unsigned long fname_len)
                     if (iFigureNumber == 0)
                     {
                         //no graphic windows, we can leave
-                        LhsVar(1) = 0;
-                        PutLhsVar();
+                        AssignOutputVariable(pvApiCtx, 1) = 0;
+                        ReturnArguments(pvApiCtx);
                         return 0;
                     }
 
@@ -130,8 +178,8 @@ int sci_delete(char *fname, unsigned long fname_len)
                         }
                     }
 
-                    LhsVar(1) = 0;
-                    PutLhsVar();
+                    AssignOutputVariable(pvApiCtx, 1) = 0;
+                    ReturnArguments(pvApiCtx);
 
                     return 0;
                 }
@@ -143,17 +191,18 @@ int sci_delete(char *fname, unsigned long fname_len)
                 break;
             default:
                 // Overload
-                lw = 1 + Top - Rhs;
+                lw = 1 + nbArgumentOnStack(pvApiCtx) - nbInputArgument(pvApiCtx);
                 C2F(overload) (&lw, "delete", 6);
                 return 0;
         }
     }
+
     for (i = 0; i < nb_handles; i++)
     {
         char* pstTemp = NULL;
-        if (Rhs != 0)
+        if (nbInputArgument(pvApiCtx) != 0)
         {
-            hdl = (unsigned long) * hstk(l1 + i); /* Puts the value of the Handle to hdl */
+            hdl = (unsigned long) * (l1 + i); /* Puts the value of the Handle to hdl */
         }
 
         pobjUID = (char*)getObjectFromHandle(hdl);
@@ -235,13 +284,18 @@ int sci_delete(char *fname, unsigned long fname_len)
     if (!dont_overload)
     {
         // Overload
-        lw = 1 + Top - Rhs;
+        lw = 1 + nbArgumentOnStack(pvApiCtx) - nbInputArgument(pvApiCtx);
         C2F(overload) (&lw, "delete", 6);
     }
     else
     {
-        LhsVar(1) = 0;
-        PutLhsVar();
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
+    }
+
+    if (l2)
+    {
+        freeAllocatedSingleString(l2);
     }
 
     return 0;
index 5ba7bde..22ed64a 100644 (file)
 /* desc : function used to launch a demo of a command                     */
 /*------------------------------------------------------------------------*/
 
-#include "stack2.h"
+#include "api_scilab.h"
 
 int sci_demo( char * fname, int fname_len)
 {
-  int lw = 0;
-  C2F(overload)(&lw, fname, fname_len);
-  return 0;
+    int lw = 0;
+    C2F(overload)(&lw, fname, fname_len);
+    return 0;
 }
index edf114b..977a4ab 100644 (file)
@@ -19,7 +19,7 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "GetProperty.h"
 #include "sciCall.h"
 #include "Scierror.h"
@@ -31,6 +31,8 @@
 #include "CurrentSubwin.h"
 
 /*--------------------------------------------------------------------------*/
+// get_optionals not yet managed
+/*--------------------------------------------------------------------------*/
 static int check_xy(char *fname, char dir, int mn, int xpos, int xm, int xn,
                     long unsigned int xl, int ypos, int yRow, int yCol, long unsigned int yl, int *ntics);
 
@@ -40,19 +42,20 @@ int sci_drawaxis(char *fname, unsigned long fname_len)
     /** XXXXX : un point en suspens c'est le "S" ou une adresse est
      *  stockees ds un unsigned long : est ce sufisant ?
      */
-    static rhs_opts opts[] = {
-        {-1, "dir", "c", 0, 0, 0},
-        {-1, "fontsize", "i", 0, 0, 0},
-        {-1, "format_n", "c", 0, 0, 0},
-        {-1, "seg", "i", 0, 0, 0},
-        {-1, "sub_int", "i", 0, 0, 0},
-        {-1, "textcolor", "i", 0, 0, 0},
-        {-1, "tics", "c", 0, 0, 0},
-        {-1, "ticscolor", "i", 0, 0, 0},
-        {-1, "val", "S", 0, 0, 0},
-        {-1, "x", "d", 0, 0, 0},
-        {-1, "y", "d", 0, 0, 0},
-        {-1, NULL, NULL, 0, 0}
+    static rhs_opts opts[] =
+    {
+        { -1, "dir", "c", 0, 0, 0},
+        { -1, "fontsize", "i", 0, 0, 0},
+        { -1, "format_n", "c", 0, 0, 0},
+        { -1, "seg", "i", 0, 0, 0},
+        { -1, "sub_int", "i", 0, 0, 0},
+        { -1, "textcolor", "i", 0, 0, 0},
+        { -1, "tics", "c", 0, 0, 0},
+        { -1, "ticscolor", "i", 0, 0, 0},
+        { -1, "val", "S", 0, 0, 0},
+        { -1, "x", "d", 0, 0, 0},
+        { -1, "y", "d", 0, 0, 0},
+        { -1, NULL, NULL, 0, 0}
     };
 
     char *psubwinUID = NULL;
@@ -65,8 +68,8 @@ int sci_drawaxis(char *fname, unsigned long fname_len)
 
     nopt = NumOpt();
 
-    CheckRhs(minrhs, maxrhs + nopt);
-    CheckLhs(minlhs, maxlhs);
+    CheckInputArgument(pvApiCtx, minrhs, maxrhs + nopt);
+    CheckOutputArgument(pvApiCtx, minlhs, maxlhs);
 
     if (get_optionals(fname, opts) == 0)
     {
@@ -78,12 +81,24 @@ int sci_drawaxis(char *fname, unsigned long fname_len)
 
     if (opts[0].position != -1)
     {
-        CheckLength(opts[0].position, opts[0].m, 1);
+        //CheckLength
+        if (opts[0].m != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, opts[0].position, opts[0].m);
+            return 1;
+        }
+
         dir = *cstk(opts[0].l);
     }
     if (opts[1].position != -1)
     {
-        CheckScalar(opts[1].position, opts[1].m, opts[1].n);
+        //CheckScalar
+        if (opts[1].m != 1 || opts[1].n != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, opts[1].position);
+            return 1;
+        }
+
         fontsize = *istk(opts[1].l);
     }
     if (opts[2].position != -1)
@@ -94,31 +109,61 @@ int sci_drawaxis(char *fname, unsigned long fname_len)
 
     if (opts[3].position != -1)
     {
-        CheckScalar(opts[3].position, opts[3].m, opts[3].n);
+        //CheckScalar
+        if (opts[3].m != 1 || opts[3].n != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, opts[3].position);
+            return 1;
+        }
+
         seg_flag = *istk(opts[3].l);
     }
 
     if (opts[4].position != -1)
     {
-        CheckScalar(opts[4].position, opts[4].m, opts[4].n);
+        //CheckScalar
+        if (opts[4].m != 1 || opts[4].n != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, opts[4].position);
+            return 1;
+        }
+
         sub_int = *istk(opts[4].l);
     }
 
     if (opts[5].position != -1)
     {
-        CheckScalar(opts[5].position, opts[5].m, opts[5].n);
+        //CheckScalar
+        if (opts[5].m != 1 || opts[5].n != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, opts[5].position);
+            return 1;
+        }
+
         textcolor = *istk(opts[5].l);
     }
 
     if (opts[6].position != -1)
     {
-        CheckLength(opts[6].position, opts[6].m, 1);
+        //CheckLength
+        if (opts[6].m != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, opts[6].position, opts[6].m);
+            return 1;
+        }
+
         tics = *cstk(opts[6].l);
     }
 
     if (opts[7].position != -1)
     {
-        CheckScalar(opts[7].position, opts[7].m, opts[7].n);
+        //CheckScalar
+        if (opts[7].m != 1 || opts[7].n != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, opts[7].position);
+            return 1;
+        }
+
         ticscolor = *istk(opts[7].l);
     }
 
@@ -170,45 +215,51 @@ int sci_drawaxis(char *fname, unsigned long fname_len)
     /* compatibility test */
     switch (tics)
     {
-    case 'r':
-        if (check_xy(fname, dir, 3, opts[9].position, opts[9].m, opts[9].n, opts[9].l,
-                     opts[10].position, opts[10].m, opts[10].n, opts[10].l, &ntics) == 0)
-        {
-            PutLhsVar();
-            return 0;
-        }
-        break;
-    case 'i':
-        if (check_xy(fname, dir, 4, opts[9].position, opts[9].m, opts[9].n, opts[9].l,
-                     opts[10].position, opts[10].m, opts[10].n, opts[10].l, &ntics) == 0)
-        {
-            PutLhsVar();
-            return 0;
-        }
-        break;
-    case 'v':
-        if (check_xy(fname, dir, -1, opts[9].position, opts[9].m, opts[9].n, opts[9].l,
-                     opts[10].position, opts[10].m, opts[10].n, opts[10].l, &ntics) == 0)
-        {
-            PutLhsVar();
+        case 'r':
+            if (check_xy(fname, dir, 3, opts[9].position, opts[9].m, opts[9].n, opts[9].l,
+                         opts[10].position, opts[10].m, opts[10].n, opts[10].l, &ntics) == 0)
+            {
+                ReturnArguments(pvApiCtx);
+                return 0;
+            }
+            break;
+        case 'i':
+            if (check_xy(fname, dir, 4, opts[9].position, opts[9].m, opts[9].n, opts[9].l,
+                         opts[10].position, opts[10].m, opts[10].n, opts[10].l, &ntics) == 0)
+            {
+                ReturnArguments(pvApiCtx);
+                return 0;
+            }
+            break;
+        case 'v':
+            if (check_xy(fname, dir, -1, opts[9].position, opts[9].m, opts[9].n, opts[9].l,
+                         opts[10].position, opts[10].m, opts[10].n, opts[10].l, &ntics) == 0)
+            {
+                ReturnArguments(pvApiCtx);
+                return 0;
+            }
+            break;
+        default:
+            Scierror(999, _("%: Wrong value for %s '%c': '%s', '%s' and '%s' expected.\n"), fname, "tics", dir, "r", "v", "i");
             return 0;
-        }
-        break;
-    default:
-        Scierror(999, _("%: Wrong value for %s '%c': '%s', '%s' and '%s' expected.\n"), fname, "tics", dir, "r", "v", "i");
-        return 0;
     }
 
     if (val != NULL)
     {
-        CheckLength(opts[8].position, opts[8].m * opts[8].n, ntics);
+        //CheckLength
+        if (opts[8].m * opts[8].n != ntics)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, opts[8].position, opts[8].m * opts[8].n);
+            return 1;
+        }
+
         nb_tics_labels = opts[8].m * opts[8].n;
     }
 
     Objdrawaxis(dir, tics, x, &nx, y, &ny, val, sub_int, format, fontsize, textcolor, ticscolor, 'n', seg_flag, nb_tics_labels);
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 
@@ -218,51 +269,75 @@ static int check_xy(char *fname, char dir, int mn, int xpos, int xm, int xn,
 {
     switch (dir)
     {
-    case 'l':
-    case 'r':
-        /* x must be scalar */
-        if (xpos != -1)
-            CheckScalar(xpos, xm, xn);
-        /* y must be of size mn */
-        if (mn != -1)
-            CheckDims(ypos, yRow, yCol, 1, mn);
-        switch (mn)
-        {
-        case 3:
-            *ntics = (int)*stk(yl + 2) + 1;
-            break;
-        case 4:
-            *ntics = (int)*stk(yl + 3) + 1;
-            break;
-        case -1:
-            *ntics = yRow * yCol;
-            break;
-        }
-        break;
-    case 'u':
-    case 'd':
-        /* y must be scalar */
-        if (ypos != -1)
-            CheckScalar(ypos, yRow, yCol);
-        /* x must be of size mn */
-        if (mn != -1)
-            CheckDims(xpos, xm, xn, 1, mn);
-        switch (mn)
-        {
-        case 3:
-            *ntics = (int)*stk(xl + 2) + 1;
-            break;
-        case 4:
-            *ntics = (int)*stk(xl + 3) + 1;
+        case 'l':
+        case 'r':
+            /* x must be scalar */
+            if (xpos != -1)
+                //CheckScalar
+                if (xm != 1 || xn != 1)
+                {
+                    Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, xpos);
+                    return 1;
+                }
+
+            /* y must be of size mn */
+            if (mn != -1)
+                //CheckDims
+                if (yRow != 1 || yCol != mn)
+                {
+                    Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, ypos, 1, mn);
+                    return 1;
+                }
+
+            switch (mn)
+            {
+                case 3:
+                    *ntics = (int) * stk(yl + 2) + 1;
+                    break;
+                case 4:
+                    *ntics = (int) * stk(yl + 3) + 1;
+                    break;
+                case -1:
+                    *ntics = yRow * yCol;
+                    break;
+            }
             break;
-        case -1:
-            *ntics = xm * xn;
+        case 'u':
+        case 'd':
+            /* y must be scalar */
+            if (ypos != -1)
+                //CheckScalar
+                if (yRow != 1 || yCol != 1)
+                {
+                    Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, ypos);
+                    return 1;
+                }
+
+            /* x must be of size mn */
+            if (mn != -1)
+                //CheckDims
+                if (xm != 1 || xn != mn)
+                {
+                    Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, xpos, 1, mn);
+                    return 1;
+                }
+
+            switch (mn)
+            {
+                case 3:
+                    *ntics = (int) * stk(xl + 2) + 1;
+                    break;
+                case 4:
+                    *ntics = (int) * stk(xl + 3) + 1;
+                    break;
+                case -1:
+                    *ntics = xm * xn;
+                    break;
+            }
             break;
-        }
-        break;
-    default:
-        Scierror(999, "%s: Wrong value for %s '%c': '%s','%s','%s' and '%s' expected.\n", fname, "dir", dir, "u", "d", "r", "l");
-        return 0;
+        default:
+            Scierror(999, "%s: Wrong value for %s '%c': '%s','%s','%s' and '%s' expected.\n", fname, "dir", dir, "u", "d", "r", "l");
+            return 0;
     }
     return 1;
 }
index 922a0f4..c9cfad2 100644 (file)
@@ -18,7 +18,9 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
+#include "Scierror.h"
+#include "localization.h"
 #include "BuildObjects.h"
 #include "getGraphicObjectProperty.h"
 #include "setGraphicObjectProperty.h"
@@ -30,10 +32,10 @@ int sci_drawlater( char * fname, unsigned long fname_len )
     char* pFigureUID = NULL;
     char* pSubwinUID = NULL;
 
-    CheckRhs(0, 0);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 0, 0);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
-    if (Rhs <= 0)
+    if (nbInputArgument(pvApiCtx) <= 0)
     {
         pSubwinUID = (char*)getOrCreateDefaultSubwin();
         if (pSubwinUID != NULL)
@@ -46,8 +48,8 @@ int sci_drawlater( char * fname, unsigned long fname_len )
         }
     }
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 /*--------------------------------------------------------------------------*/
index dc59620..57b903d 100644 (file)
@@ -17,7 +17,9 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
+#include "Scierror.h"
+#include "localization.h"
 #include "BuildObjects.h"
 #include "getGraphicObjectProperty.h"
 #include "setGraphicObjectProperty.h"
 /*--------------------------------------------------------------------------*/
 int sci_drawnow(char *fname, unsigned long fname_len)
 {
-    int iTrue =  (int)TRUE;
+    int iTrue = (int)TRUE;
     char* pFigureUID = NULL;
     char* pSubwinUID = NULL;
 
-    CheckRhs(0, 0);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 0, 0);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
-    if (Rhs <= 0)
+    if (nbInputArgument(pvApiCtx) <= 0)
     {
         pSubwinUID = (char*)getOrCreateDefaultSubwin();
         if (pSubwinUID != NULL)
@@ -45,8 +47,8 @@ int sci_drawnow(char *fname, unsigned long fname_len)
         }
     }
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 /*--------------------------------------------------------------------------*/
index 3db45a6..8907768 100644 (file)
@@ -18,7 +18,7 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "GetCommandArg.h"
 #include "BuildObjects.h"
 #include "sciCall.h"
 #include "Scierror.h"
 
 /*--------------------------------------------------------------------------*/
-int sci_fec(char *fname,unsigned long fname_len)
+int sci_fec(char *fname, unsigned long fname_len)
 {
-    int m1 = 0,n1 = 0,l1 = 0,m2 = 0,n2 = 0,l2 = 0,m3 = 0,n3 = 0,l3 = 0,m4 = 0,n4 = 0,l4 = 0, mn1 = 0;
-
-    static rhs_opts opts[]= { {-1,"colminmax","?",0,0,0},
-                              {-1,"colout","?",0,0,0},
-                              {-1,"leg","?",0,0,0},
-                              {-1,"mesh","?",0,0,0},
-                              {-1,"nax","?",0,0,0},
-                              {-1,"rect","?",0,0,0},
-                              {-1,"strf","?",0,0,0},
-                              {-1,"zminmax","?",0,0,0},
-                              {-1,NULL,NULL,0,0}        } ;
-
-    char * strf = NULL ;
-    char * legend = NULL ;
-    double * rect = NULL ;
-    double * zminmax = NULL ;
-    int * colminmax = NULL ;
-    int * nax = NULL ;
-    int * colOut = NULL ;
-    BOOL flagNax = FALSE ;
-    BOOL withMesh = FALSE ;
-
-
-    if (Rhs <= 0)
+    SciErr sciErr;
+    int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0, m4 = 0, n4 = 0, mn1 = 0;
+
+    static rhs_opts opts[] = { { -1, "colminmax", "?", 0, 0, 0},
+        { -1, "colout", "?", 0, 0, 0},
+        { -1, "leg", "?", 0, 0, 0},
+        { -1, "mesh", "?", 0, 0, 0},
+        { -1, "nax", "?", 0, 0, 0},
+        { -1, "rect", "?", 0, 0, 0},
+        { -1, "strf", "?", 0, 0, 0},
+        { -1, "zminmax", "?", 0, 0, 0},
+        { -1, NULL, NULL, 0, 0}
+    } ;
+
+    char* strf      = NULL ;
+    char* legend    = NULL ;
+    double* rect    = NULL ;
+    double* zminmax = NULL ;
+    int* colminmax  = NULL ;
+    int* nax        = NULL ;
+    int* colOut     = NULL ;
+    BOOL flagNax    = FALSE ;
+    BOOL withMesh   = FALSE ;
+
+    int* piAddr1 = NULL;
+    int* piAddr2 = NULL;
+    int* piAddr3 = NULL;
+    int* piAddr4 = NULL;
+
+    double* l1 = NULL;
+    double* l2 = NULL;
+    double* l3 = NULL;
+    double* l4 = NULL;
+
+    if (nbInputArgument(pvApiCtx) <= 0)
     {
-               sci_demo(fname, fname_len);
-               return 0;
+        sci_demo(fname, fname_len);
+        return 0;
     }
 
-    CheckRhs(4,12);
+    CheckInputArgument(pvApiCtx, 4, 12);
 
-    if ( get_optionals(fname,opts) == 0)
+    if ( get_optionals(fname, opts) == 0)
     {
-        PutLhsVar();
+        ReturnArguments(pvApiCtx);
         return 0;
     }
 
     if ( FirstOpt() < 5)
     {
-        Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"),fname,1, 5);
+        Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 5);
         return -1;
     }
 
-    GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
-    GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m2,&n2,&l2);
-    CheckSameDims(1,2,m1,n1,m2,n2);
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 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;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    //CheckSameDims
+    if (m1 != m2 || n1 != n2)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
+        return 1;
+    }
+
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 3.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+        printError(&sciErr, 0);
+        return 1;
+    }
 
-    GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&m3,&n3,&l3);
     if (n3 != 5)
     {
-        Scierror(999,_("%s: Wrong number of columns for input argument #%d: %d expected.\n"),fname,3,5);
+        Scierror(999, _("%s: Wrong number of columns for input argument #%d: %d expected.\n"), fname, 3, 5);
         return 0;
     }
 
-    GetRhsVar(4,MATRIX_OF_DOUBLE_DATATYPE,&m4,&n4,&l4);
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 4.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr4, &m4, &n4, &l4);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
 
     if (m1 * n1 == 0 || m3 == 0)
     {
-        LhsVar(1) = 0;
-        PutLhsVar();
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
         return 0;
     }
 
-    GetStrf(fname,5,opts,&strf);
-    GetLegend(fname,6,opts,&legend);
-    GetRect(fname,7,opts,&rect);
-    GetNax(8,opts,&nax,&flagNax);
-    GetZminmax(fname,9,opts,&zminmax);
-    GetColminmax(fname,10,opts,&colminmax);
-    GetColOut(fname,11,opts,&colOut);
-    GetWithMesh(fname,12,opts,&withMesh);
+    GetStrf(fname, 5, opts, &strf);
+    GetLegend(fname, 6, opts, &legend);
+    GetRect(fname, 7, opts, &rect);
+    GetNax(8, opts, &nax, &flagNax);
+    GetZminmax(fname, 9, opts, &zminmax);
+    GetColminmax(fname, 10, opts, &colminmax);
+    GetColOut(fname, 11, opts, &colOut);
+    GetWithMesh(fname, 12, opts, &withMesh);
 
     getOrCreateDefaultSubwin();
 
-    if ( isDefStrf ( strf ) ) {
+    if ( isDefStrf ( strf ) )
+    {
         char strfl[4];
 
-        strcpy(strfl,DEFSTRFN);
+        strcpy(strfl, DEFSTRFN);
 
         strf = strfl;
         if ( !isDefRect( rect ))
         {
-            strfl[1]='7';
+            strfl[1] = '7';
         }
         if ( !isDefLegend( legend ) )
         {
-            strfl[0]='1';
+            strfl[0] = '1';
         }
     }
     mn1 = m1 * n1;
 
-    Objfec (stk(l1),stk(l2),stk(l3),stk(l4),&mn1,&m3,strf,legend,rect,nax,zminmax,colminmax,colOut,withMesh,flagNax);
+    Objfec ((l1), (l2), (l3), (l4), &mn1, &m3, strf, legend, rect, nax, zminmax, colminmax, colOut, withMesh, flagNax);
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
 
     return 0;
 }
index f44c69a..2a1dc24 100644 (file)
@@ -16,7 +16,9 @@
 /* file: sci_geom3d.c                                                     */
 /* desc : interface for geom3d routine                                    */
 /*------------------------------------------------------------------------*/
-#include "stack-c.h"
+#include "api_scilab.h"
+#include "Scierror.h"
+#include "localization.h"
 #include "gw_graphics.h"
 #include "GetProperty.h"
 #include "HandleManagement.h"
@@ -47,29 +49,98 @@ int geom3d(double *x, double *y, double *z, int n)
 /*--------------------------------------------------------------------------*/
 int sci_geom3d(char * fname, unsigned long fname_len)
 {
-    int ix1 = 0, m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0, m3 = 0, n3 = 0, l3 = 0;
+    SciErr sciErr;
+    int ix1 = 0, m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0;
 
-    CheckRhs(3,3);
-    CheckLhs(2,3);
+    int* piAddr1 = NULL;
+    int* piAddr2 = NULL;
+    int* piAddr3 = NULL;
+
+    double* l1 = NULL;
+    double* l2 = NULL;
+    double* l3 = NULL;
+
+    CheckInputArgument(pvApiCtx, 3, 3);
+    CheckOutputArgument(pvApiCtx, 2, 3);
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 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;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 3.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    //CheckSameDims
+    if (m1 != m2 || n1 != n2)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
+        return 1;
+    }
+
+    //CheckSameDims
+    if (m2 != m3 || n2 != n3)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 2, m2, n2);
+        return 1;
+    }
 
-    GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-    GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
-    GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE, &m3, &n3, &l3);
-    CheckSameDims(1,2,m1,n1,m2,n2);
-    CheckSameDims(2,3,m2,n2,m3,n3);
     if (m1 * n1 == 0)
     {
-        LhsVar(1) = 0;
-        PutLhsVar();
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
         return 0;
     }
 
     ix1 = m1 * n1;
-    geom3d(stk(l1), stk(l2), stk(l3), ix1);
+    geom3d((l1), (l2), (l3), ix1);
 
-    LhsVar(1) = 1;
-    LhsVar(2) = 2;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 1;
+    AssignOutputVariable(pvApiCtx, 2) = 2;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 /*--------------------------------------------------------------------------*/
index ca874b4..dbcb1c4 100644 (file)
@@ -21,7 +21,6 @@
 #include "gw_graphics.h"
 /*--------------------------------------------------------------------------*/
 
-#include "stack-c.h"
 #include "HandleManagement.h"
 
 #include "GetHashTable.h"
@@ -53,8 +52,16 @@ int sciGet(void* _pvCtx, char *pobjUID, char *marker)
 /*--------------------------------------------------------------------------*/
 int sci_get(char *fname, unsigned long fname_len)
 {
-    int m1 = 0, n1 = 0, numrow2 = 0, numcol2 = 0, l2 = 0;
-    int l1 = 0;
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    double* pdbll1 = NULL;
+    int* piAddrstkAdr = NULL;
+    long long* l1 = NULL;
+    int* piAddrl2 = NULL;
+    char* l2 = NULL;
+
+    int m1 = 0, n1 = 0;
     long hdl = 0;
 
     int lw = 0;
@@ -64,46 +71,74 @@ int sci_get(char *fname, unsigned long fname_len)
     char **stkAdr = NULL;
     int status = SET_PROPERTY_ERROR;
 
-    if ((VarType(1) == sci_mlist) || (VarType(1) == sci_tlist))
+    if (((checkInputArgumentType(pvApiCtx, 1, sci_mlist))) || ((checkInputArgumentType(pvApiCtx, 1, sci_tlist))))
     {
-        lw = 1 + Top - Rhs;
+        lw = 1 + nbArgumentOnStack(pvApiCtx) - nbInputArgument(pvApiCtx);
         C2F(overload) (&lw, "get", 3);
         return 0;
     }
 
-    CheckRhs(1, 2);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 1, 2);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     /*  set or create a graphic window */
 
     /*
      * The first input argument can be an ID or a marker (in this case, get returns the value of the current object */
-    switch (VarType(1))
+    switch (getInputArgumentType(pvApiCtx, 1))
     {
         case 1:                    /* tclsci handle */
-            GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-            if ((int)*stk(l1) == 0) /* Root property */
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &pdbll1);
+            if (sciErr.iErr)
             {
-                if (Rhs == 1)
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+                return 1;
+            }
+
+            if ((int)pdbll1[0] == 0) /* Root property */
+            {
+                if (nbInputArgument(pvApiCtx) == 1)
                 {
                     if (sciReturnHandle(pvApiCtx, getHandle(getConsoleIdentifier())) != 0)    /* Get Console handle */
                     {
                         /* An error has occurred */
-                        PutLhsVar();
+                        ReturnArguments(pvApiCtx);
                         return 0;
                     }
-                    LhsVar(1) = Rhs + 1;
-                    PutLhsVar();
+                    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+                    ReturnArguments(pvApiCtx);
                     return 0;
                 }
-                CheckRhs(2, 2);
-                if (VarType(2) == sci_strings)
+                CheckInputArgument(pvApiCtx, 2, 2);
+                if ((checkInputArgumentType(pvApiCtx, 2, sci_strings)))
                 {
-                    GetRhsVar(2, MATRIX_OF_STRING_DATATYPE, &m1, &n1, &stkAdr);
+                    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrstkAdr);
+                    if (sciErr.iErr)
+                    {
+                        printError(&sciErr, 0);
+                        return 1;
+                    }
+
+                    // Retrieve a matrix of string at position 2.
+                    if (getAllocatedMatrixOfString(pvApiCtx, piAddrstkAdr, &m1, &n1, &stkAdr))
+                    {
+                        Scierror(202, _("%s: Wrong type for argument #%d: String matrix expected.\n"), fname, 2);
+                        return 1;
+                    }
+
 
                     if (m1 * n1 != 1)
                     {
-                        freeArrayOfString(stkAdr, m1 * n1);
+                        freeAllocatedMatrixOfString(m1, n1, stkAdr);
                         Scierror(999, _("%s: Wrong type for input argument #%d: Single string expected.\n"), "get", 2);
                         return SET_PROPERTY_ERROR;
                     }
@@ -113,53 +148,94 @@ int sci_get(char *fname, unsigned long fname_len)
                     if (status != SET_PROPERTY_SUCCEED) /* Return property */
                     {
                         Scierror(999, _("%s: Could not read property '%s' for root object.\n"), "get", stkAdr[0]);
-                        freeArrayOfString(stkAdr, m1 * n1);
+                        freeAllocatedMatrixOfString(m1, n1, stkAdr);
                         return FALSE;
                     }
-                    freeArrayOfString(stkAdr, m1 * n1);
+                    freeAllocatedMatrixOfString(m1, n1, stkAdr);
                 }
                 else
                 {
                     Scierror(999, _("%s: Wrong type for input argument #%d: Single string expected.\n"), "get", 2);
                     return FALSE;
                 }
-                LhsVar(1) = Rhs + 1;
-                PutLhsVar();
+                AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+                ReturnArguments(pvApiCtx);
             }
             else                    /* tclsci handle: should no more happen */
             {
-                lw = 1 + Top - Rhs;
+                lw = 1 + nbArgumentOnStack(pvApiCtx) - nbInputArgument(pvApiCtx);
                 C2F(overload) (&lw, "get", 3);
             }
             return 0;
             break;
         case sci_handles:          /* scalar argument (hdl + string) */
-            CheckRhs(2, 2);
-            GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &m1, &n1, &l1);
+            CheckInputArgument(pvApiCtx, 2, 2);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of handle at position 1.
+            sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &m1, &n1, &l1);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+                return 1;
+            }
+
             if (m1 != 1 || n1 != 1)
             {
-                lw = 1 + Top - Rhs;
+                lw = 1 + nbArgumentOnStack(pvApiCtx) - nbInputArgument(pvApiCtx);
                 C2F(overload) (&lw, "get", 3);
                 return 0;
             }
-            GetRhsVar(2, STRING_DATATYPE, &numrow2, &numcol2, &l2);
-            hdl = (long) * hstk(l1); /* on recupere le pointeur d'objet par le handle */
+            sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 2.
+            if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2))
+            {
+                Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 2);
+                return 1;
+            }
+
+            hdl = (long) * l1; /* on recupere le pointeur d'objet par le handle */
             break;
         case sci_strings:          /* string argument (string) */
-            CheckRhs(1, 1);
-            GetRhsVar(1, STRING_DATATYPE, &numrow2, &numcol2, &l2);
-            if (strcmp(cstk(l2), "default_figure") != 0 && strcmp(cstk(l2), "default_axes") != 0)
+            CheckInputArgument(pvApiCtx, 1, 1);
+            sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl2);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            // Retrieve a matrix of double at position 1.
+            if (getAllocatedSingleString(pvApiCtx, piAddrl2, &l2))
             {
-                if (strcmp(cstk(l2), "current_figure") == 0 || strcmp(cstk(l2), "current_axes") == 0 || strcmp(cstk(l2), "current_entity") == 0
-                        || strcmp(cstk(l2), "hdl") == 0 || strcmp(cstk(l2), "figures_id") == 0)
+                Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+                return 1;
+            }
+
+            if (strcmp((l2), "default_figure") != 0 && strcmp((l2), "default_axes") != 0)
+            {
+                if (strcmp((l2), "current_figure") == 0 || strcmp((l2), "current_axes") == 0 || strcmp((l2), "current_entity") == 0
+                        || strcmp((l2), "hdl") == 0 || strcmp((l2), "figures_id") == 0)
                 {
                     hdl = 0;
                 }
                 else
                 {
                     /* Test debug F.Leray 13.04.04 */
-                    if ((strcmp(cstk(l2), "children") != 0) && (strcmp(cstk(l2), "zoom_") != 0) && (strcmp(cstk(l2), "clip_box") != 0)
-                            && (strcmp(cstk(l2), "auto_") != 0))
+                    if ((strcmp((l2), "children") != 0) && (strcmp((l2), "zoom_") != 0) && (strcmp((l2), "clip_box") != 0)
+                            && (strcmp((l2), "auto_") != 0))
                     {
                         getOrCreateDefaultSubwin();
                         hdl = getHandle(getCurrentObject());
@@ -176,21 +252,22 @@ int sci_get(char *fname, unsigned long fname_len)
             }
             break;
         default:
-            lw = 1 + Top - Rhs;
+            lw = 1 + nbArgumentOnStack(pvApiCtx) - nbInputArgument(pvApiCtx);
             C2F(overload) (&lw, "get", 3);
             return 0;
             break;
     }
-    /* cstk(l2) est la commande, l3 l'indice sur les parametres de la commande */
-    CheckLhs(0, 1);
+    /* (l2) est la commande, l3 l'indice sur les parametres de la commande */
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     if (hdl == 0)
     {
         /* No handle specified */
-        if (sciGet(pvApiCtx, NULL, cstk(l2)) != 0)
+        if (sciGet(pvApiCtx, NULL, (l2)) != 0)
         {
             /* An error has occurred */
-            PutLhsVar();
+            freeAllocatedSingleString(l2);
+            ReturnArguments(pvApiCtx);
             return 0;
         }
     }
@@ -200,23 +277,25 @@ int sci_get(char *fname, unsigned long fname_len)
         if (pobjUID != NULL)
         {
 
-            if (sciGet(pvApiCtx, pobjUID, cstk(l2)) != 0)
+            if (sciGet(pvApiCtx, pobjUID, (l2)) != 0)
             {
                 /* An error has occurred */
-                PutLhsVar();
+                freeAllocatedSingleString(l2);
+                ReturnArguments(pvApiCtx);
                 return 0;
             }
         }
         else
         {
             Scierror(999, _("%s: The handle is not or no more valid.\n"), fname);
+            freeAllocatedSingleString(l2);
             return 0;
         }
     }
 
-    LhsVar(1) = Rhs + 1;
-    PutLhsVar();
-
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
+    freeAllocatedSingleString(l2);
     return 0;
 }
 
index d85bb80..b47cc45 100644 (file)
@@ -21,7 +21,7 @@
 #include <stdlib.h>
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "BuildObjects.h"
 #include "MALLOC.h"
 #include "GetProperty.h"
 /*--------------------------------------------------------------------------*/
 int sci_glue( char * fname, unsigned long fname_len )
 {
-    int numrow = 0, numcol = 0, l1 = 0, l2 = 0, lind = 0, n = 0, cx1 = 1;
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    long long* l1 = NULL;
+    double* l2 = NULL;
+    int* lind = NULL;
+    long long* outindex = NULL;
+
+    int numrow = 0, numcol = 0, n = 0, cx1 = 1;
     long *handelsvalue = NULL ;
-    int outindex = 0, i = 0;
+    int i = 0;
 
     char *pstCompoundUID = NULL;
     char *pstParentUID = NULL;
     char *pstCurrentParentUID = NULL;
     char *pobjUID = NULL;
 
-    CheckRhs(1, 1);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     /*  set or create a graphic window */
-    GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &numrow, &numcol, &l1); /* We get the scalar value if it is ones */
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of handle at position 1.
+    sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &numrow, &numcol, &l1); /* We get the scalar value if it is ones */
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+        return 1;
+    }
+
     n = numrow * numcol;
-    CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &numrow, &numcol, &l2);
-    CreateVar(Rhs + 2, MATRIX_OF_INTEGER_DATATYPE, &numrow, &numcol, &lind);
+    sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, numrow, numcol, &l2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
+
+    sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 2, numrow, numcol, &lind);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
 
     if (n > 1)
     {
-        C2F(dcopy)(&n, stk(l1), &cx1, stk(l2), &cx1);
-        C2F(dsort)(stk(l2), &n, istk(lind));
+        C2F(dcopy)(&n, (double*)l1, &cx1, l2, &cx1);
+        C2F(dsort)(l2, &n, (int*)(lind));
         for (i = 1; i < n; i++)
         {
-            long long i1 = (long long) * hstk(l2 + i);
-            long long i2 = (long long) * hstk(l2 + i - 1);
+            long long i1 = ((long long*)l2)[i];
+            long long i2 = ((long long*)l2)[i - 1];
 
             if (i1 == i2)
             {
@@ -75,7 +111,7 @@ int sci_glue( char * fname, unsigned long fname_len )
     handelsvalue = MALLOC(n * sizeof(long));
     for (i = 0 ; i < n ; i++)
     {
-        handelsvalue[i] = (unsigned long) (hstk(l1))[i];
+        handelsvalue[i] = (unsigned long) l1[i];
         pobjUID = (char*)getObjectFromHandle(handelsvalue[i]);
         if (pobjUID == NULL)
         {
@@ -119,11 +155,19 @@ int sci_glue( char * fname, unsigned long fname_len )
 
     numrow = 1;
     numcol = 1;
-    CreateVar(Rhs + 3, GRAPHICAL_HANDLE_DATATYPE, &numrow, &numcol, &outindex);
-    hstk(outindex)[0] = getHandle(pstCompoundUID);
+
+    sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 3, numrow, numcol, &outindex);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
+
+    outindex[0] = getHandle(pstCompoundUID);
     releaseGraphicObjectProperty(__GO_PARENT__, pstCompoundUID, jni_string, 1);
-    LhsVar(1) = Rhs + 3;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 3;
+    ReturnArguments(pvApiCtx);
     FREE(handelsvalue);
 
     return 0;
index e60494b..bbe8d9b 100644 (file)
@@ -18,6 +18,7 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
+#include "api_scilab.h"
 #include "GetCommandArg.h"
 #include "BuildObjects.h"
 #include "DefaultCommandArg.h"
 /*--------------------------------------------------------------------------*/
 int sci_grayplot( char *fname, unsigned long fname_len )
 {
-    int frame_def=8;
-    int *frame=&frame_def;
-    int axes_def=1;
-    int *axes=&axes_def;
-    int m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0, m3 = 0, n3 = 0, l3 = 0;
-    static rhs_opts opts[]= { {-1,"axesflag","?",0,0,0},
-                              {-1,"frameflag","?",0,0,0},
-                              {-1,"nax","?",0,0,0},
-                              {-1,"rect","?",0,0,0},
-                              {-1,"strf","?",0,0,0},
-                              {-1,NULL,NULL,0,0}};
+    SciErr sciErr;
+    int frame_def = 8;
+    int *frame = &frame_def;
+    int axes_def = 1;
+    int *axes = &axes_def;
+    int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0;
+    static rhs_opts opts[] = { { -1, "axesflag", "?", 0, 0, 0},
+        { -1, "frameflag", "?", 0, 0, 0},
+        { -1, "nax", "?", 0, 0, 0},
+        { -1, "rect", "?", 0, 0, 0},
+        { -1, "strf", "?", 0, 0, 0},
+        { -1, NULL, NULL, 0, 0}
+    };
 
     char   * strf    = NULL  ;
     double * rect    = NULL  ;
     int    * nax     = NULL  ;
     BOOL     flagNax = FALSE ;
 
-    if (Rhs <= 0)
+    int* piAddr1 = NULL;
+    int* piAddr2 = NULL;
+    int* piAddr3 = NULL;
+
+    double* l1 = NULL;
+    double* l2 = NULL;
+    double* l3 = NULL;
+
+    if (nbInputArgument(pvApiCtx) <= 0)
     {
         sci_demo(fname, fname_len);
         return 0;
     }
-    CheckRhs(3,7);
+    CheckInputArgument(pvApiCtx, 3, 7);
 
-    if ( get_optionals(fname,opts) == 0)
+    if ( get_optionals(fname, opts) == 0)
     {
-        PutLhsVar();
+        ReturnArguments(pvApiCtx);
         return 0 ;
     }
 
     if ( FirstOpt() < 4)
     {
         Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"),
-                 fname,1, 4);
+                 fname, 1, 4);
         return -1;
     }
-    GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-    CheckVector(1,m1,n1);
-    GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
-    CheckVector(2,m2,n2);
-    GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE, &m3, &n3, &l3);
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 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;
+    }
+
+    //CheckVector
+    if (m1 != 1 && n1 != 1)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 1);
+        return 1;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    //CheckVector
+    if (m2 != 1 && n2 != 1)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 2);
+        return 1;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 3.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
     if (m3 * n3 == 0)
     {
-        LhsVar(1)=0;
-        PutLhsVar();
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
         return 0;
     }
 
-    CheckDimProp(2,3,m2 * n2 != n3);
-    CheckDimProp(1,3,m1 * n1 != m3);
+    //CheckDimProp
+    if (m2 * n2 != n3)
+    {
+        Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
+        return 1;
+    }
+
+    //CheckDimProp
+    if (m1 * n1 != m3)
+    {
+        Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
+        return 1;
+    }
+
 
-    GetStrf(fname,4,opts,&strf);
-    GetRect(fname,5,opts,&rect);
-    GetNax(6,opts,&nax,&flagNax);
+    GetStrf(fname, 4, opts, &strf);
+    GetRect(fname, 5, opts, &rect);
+    GetNax(6, opts, &nax, &flagNax);
 
     getOrCreateDefaultSubwin();
 
@@ -89,30 +172,30 @@ int sci_grayplot( char *fname, unsigned long fname_len )
     {
         char strfl[4];
 
-        strcpy(strfl,DEFSTRFN);
+        strcpy(strfl, DEFSTRFN);
 
         strf = strfl;
         if ( !isDefRect( rect ) )
         {
-            strfl[1]='7';
+            strfl[1] = '7';
         }
 
-        GetOptionalIntArg(fname,7,"frameflag",&frame,1,opts);
-        if(frame != &frame_def)
+        GetOptionalIntArg(fname, 7, "frameflag", &frame, 1, opts);
+        if (frame != &frame_def)
         {
-            strfl[1] = (char)(*frame+48);
+            strfl[1] = (char)(*frame + 48);
         }
-        GetOptionalIntArg(fname,7,"axesflag",&axes,1,opts);
-        if(axes != &axes_def)
+        GetOptionalIntArg(fname, 7, "axesflag", &axes, 1, opts);
+        if (axes != &axes_def)
         {
-            strfl[2] = (char)(*axes+48);
+            strfl[2] = (char)(*axes + 48);
         }
     }
 
-    Objgrayplot (stk(l1), stk(l2), stk(l3), &m3, &n3, strf, rect, nax, flagNax);
+    Objgrayplot ((l1), (l2), (l3), &m3, &n3, strf, rect, nax, flagNax);
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 /*--------------------------------------------------------------------------*/
index d81c2c1..a2d4a50 100644 (file)
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "HandleManagement.h"
 #include "Scierror.h"
 #include "localization.h"
 #include "getPropertyAssignedValue.h"
 
 /*--------------------------------------------------------------------------*/
-int sci_is_handle_valid(char *fname,unsigned long fname_len)
+int sci_is_handle_valid(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
 
-  /* Call isValid = is_handle_valid(h) with h a matrix of handle */
-  /* and isValid a matrix of boolean */
+    int* piAddrhandleStackPointer = NULL;
+    long long* handleStackPointer = NULL;
+    int* resultStackPointer       = NULL;
 
-  int nbCol = 0;
-  int nbRow = 0;
-  int nbHandle = 0;
-  int handleStackPointer = 0;
-  int resultStackPointer = 0;
-  int i = 0;
+    /* Call isValid = is_handle_valid(h) with h a matrix of handle */
+    /* and isValid a matrix of boolean */
 
-  CheckRhs(1,1);
-  CheckLhs(0,1);
+    int nbCol = 0;
+    int nbRow = 0;
+    int nbHandle = 0;
+    int i = 0;
 
-  /* Get handles matrix */
-  if (VarType(1) != sci_handles)
-  {
-    Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of handle expected.\n"), fname,1);
-    return  -1;
-  }
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
-  GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &handleStackPointer);
-  nbHandle = nbRow * nbCol;
+    /* Get handles matrix */
+    if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles)))
+    {
+        Scierror(999, _("%s: Wrong type for input argument #%d: Matrix of handle expected.\n"), fname, 1);
+        return  -1;
+    }
 
-  /* create output matrix */
-  CreateVar(Rhs + 1, MATRIX_OF_BOOLEAN_DATATYPE, &nbRow, &nbCol, &resultStackPointer)
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrhandleStackPointer);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
 
-  /* Check each handle */
-  for (i = 0; i < nbHandle; i++)
-  {
-      *istk(resultStackPointer + i) =  (getObjectFromHandle(getHandleFromStack(handleStackPointer + i)) != NULL ? TRUE : FALSE);
-  }
+    // Retrieve a matrix of handle at position 1.
+    sciErr = getMatrixOfHandle(pvApiCtx, piAddrhandleStackPointer, &nbRow, &nbCol, &handleStackPointer);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+        return 1;
+    }
 
-  LhsVar(1) = Rhs + 1;
-  PutLhsVar();
+    nbHandle = nbRow * nbCol;
 
-  return 0;
+    /* create output matrix */
+    allocMatrixOfBoolean(pvApiCtx, nbInputArgument(pvApiCtx) + 1, nbRow, nbCol, &resultStackPointer);
+
+    /* Check each handle */
+    for (i = 0; i < nbHandle; i++)
+    {
+        resultStackPointer[i] =  (getObjectFromHandle((long int)handleStackPointer[i]) != NULL ? TRUE : FALSE);
+    }
+
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
+
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index dc90c70..1b9ac4c 100644 (file)
@@ -2,11 +2,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Fabrice Leray
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
- * 
+ *
  * 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
  *
  */
 #include "DefaultCommandArg.h"
 #include "BuildObjects.h"
 #include "sciCall.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
-int sci_matplot(char *fname,unsigned long fname_len)
+int sci_matplot(char *fname, unsigned long fname_len)
 {
-  int m1 = 0, n1 = 0, l1 = 0;
-  int frame_def=8;
-  int *frame=&frame_def;
-  int axes_def=1;
-  int *axes=&axes_def;
-  static rhs_opts opts[]= { {-1,"axesflag","?",0,0,0},
-  {-1,"frameflag","?",0,0,0},
-  {-1,"nax","?",0,0,0},
-  {-1,"rect","?",0,0,0},
-  {-1,"strf","?",0,0,0},
-  {-1,NULL,NULL,0,0}};
-
-  char   * strf    = NULL  ;
-  double * rect    = NULL  ;
-  int    * nax     = NULL  ;
-  BOOL     flagNax = FALSE ;
-
-  if ( Rhs <= 0 )
-  {
-    sci_demo(fname, fname_len);
-    return 0;
-  }
-  CheckRhs(1,5);
-
-  if ( get_optionals(fname,opts) == 0 ) 
-  {
-         PutLhsVar();
-         return 0 ; 
-  }
-  if ( FirstOpt() < 2)
-  {
-    Scierror(999,_("%s: Misplaced optional argument: #%d must be at position %d.\n"),
-      fname,1,2);
-    return(0);
-  }
-  GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-  if (m1 * n1 == 0) 
-  {  
-         LhsVar(1) = 0;
-         PutLhsVar();
-         return 0;
-  }
-
-  GetStrf(fname,2,opts,&strf);
-  GetRect(fname,3,opts,&rect);
-  GetNax(4,opts,&nax,&flagNax);
-
-  getOrCreateDefaultSubwin();
-
-  if ( isDefStrf( strf ) ) {
-    char strfl[4];
-   
-    strcpy(strfl,DEFSTRFN) ;
-   
-    strf = strfl;
-    if ( !isDefRect( rect ) )
+    SciErr sciErr;
+    int m1 = 0, n1 = 0;
+    int frame_def = 8;
+    int *frame = &frame_def;
+    int axes_def = 1;
+    int *axes = &axes_def;
+    static rhs_opts opts[] = { { -1, "axesflag", "?", 0, 0, 0},
+        { -1, "frameflag", "?", 0, 0, 0},
+        { -1, "nax", "?", 0, 0, 0},
+        { -1, "rect", "?", 0, 0, 0},
+        { -1, "strf", "?", 0, 0, 0},
+        { -1, NULL, NULL, 0, 0}
+    };
+
+    char   * strf    = NULL  ;
+    double * rect    = NULL  ;
+    int    * nax     = NULL  ;
+    BOOL     flagNax = FALSE ;
+
+    int* piAddr1 = NULL;
+    double* l1 = NULL;
+
+    if ( nbInputArgument(pvApiCtx) <= 0 )
+    {
+        sci_demo(fname, fname_len);
+        return 0;
+    }
+    CheckInputArgument(pvApiCtx, 1, 5);
+
+    if ( get_optionals(fname, opts) == 0 )
+    {
+        ReturnArguments(pvApiCtx);
+        return 0 ;
+    }
+    if ( FirstOpt() < 2)
+    {
+        Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"),
+                 fname, 1, 2);
+        return(0);
+    }
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
     {
-      strfl[1]='7';
+        printError(&sciErr, 0);
+        return 1;
     }
 
-    GetOptionalIntArg(fname,5,"frameflag",&frame,1,opts);
-    if(frame != &frame_def)
+    // Retrieve a matrix of double at position 1.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1);
+    if (sciErr.iErr)
     {
-      strfl[1] = (char)(*frame+48);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+        printError(&sciErr, 0);
+        return 1;
     }
-    GetOptionalIntArg(fname,5,"axesflag",&axes,1,opts);
-    if(axes != &axes_def)
+
+    if (m1 * n1 == 0)
     {
-      strfl[2] = (char)(*axes+48);
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
+        return 0;
     }
-  }
 
-  Objmatplot( stk(l1), &m1, &n1, strf, rect, nax, flagNax ) ;
+    GetStrf(fname, 2, opts, &strf);
+    GetRect(fname, 3, opts, &rect);
+    GetNax(4, opts, &nax, &flagNax);
+
+    getOrCreateDefaultSubwin();
+
+    if ( isDefStrf( strf ) )
+    {
+        char strfl[4];
+
+        strcpy(strfl, DEFSTRFN) ;
 
-  /* NG end */
-  LhsVar(1) = 0;
-  PutLhsVar();
-  return 0;
+        strf = strfl;
+        if ( !isDefRect( rect ) )
+        {
+            strfl[1] = '7';
+        }
+
+        GetOptionalIntArg(fname, 5, "frameflag", &frame, 1, opts);
+        if (frame != &frame_def)
+        {
+            strfl[1] = (char)(*frame + 48);
+        }
+        GetOptionalIntArg(fname, 5, "axesflag", &axes, 1, opts);
+        if (axes != &axes_def)
+        {
+            strfl[2] = (char)(*axes + 48);
+        }
+    }
+
+    Objmatplot((l1), &m1, &n1, strf, rect, nax, flagNax ) ;
+
+    /* NG end */
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 937d37f..353b4ae 100644 (file)
@@ -3,11 +3,11 @@
  * Copyright (C) 2006 - INRIA - Fabrice Leray
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
  * Copyright (C) 2012 - DIGITEO - Manuel Juliachs
- * 
+ *
  * 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,9 @@
 /* file: sci_matplot1.c                                                   */
 /* desc : interface for matplot1 routine                                  */
 /*------------------------------------------------------------------------*/
-#include "stack-c.h"
+#include "api_scilab.h"
+#include "Scierror.h"
+#include "localization.h"
 #include "gw_graphics.h"
 #include "BuildObjects.h"
 #include "sciCall.h"
 /*--------------------------------------------------------------------------*/
 int sci_matplot1( char * fname, unsigned long fname_len )
 {
-    int m1 = 0, n1 = 0, l1 = 0,m2 = 0,n2 = 0,l2 = 0;
-    if ( Rhs <= 0 )
+    SciErr sciErr;
+    int m1 = 0, n1 = 0, m2 = 0, n2 = 0;
+    if ( nbInputArgument(pvApiCtx) <= 0 )
     {
         sci_demo(fname, fname_len);
         return 0;
     }
 
-    CheckRhs(2,2);
-    GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-    GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
-    CheckLength(2,m2*n2,4);
+    int* piAddr1 = NULL;
+    int* piAddr2 = NULL;
+
+    double* l1 = NULL;
+    double* l2 = NULL;
+
+    CheckInputArgument(pvApiCtx, 2, 2);
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 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;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    //CheckLength
+    if (m2 * n2 != 4)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 2, m2 * n2);
+        return 1;
+    }
+
     if ( m1 * n1 == 0 )
     {
-        LhsVar(1) = 0;
-        PutLhsVar();
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
         return 0;
     }
 
     getOrCreateDefaultSubwin();
 
     /* NG beg */
-    Objmatplot1 (stk(l1), &m1, &n1,stk(l2));
+    Objmatplot1 ((l1), &m1, &n1, (l2));
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
-} 
+}
 /*--------------------------------------------------------------------------*/
index 10c7a9a..0450c9f 100644 (file)
@@ -19,7 +19,7 @@
 
 #include <stdio.h>
 
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "gw_graphics.h"
 #include "Interaction.h"
 #include "localization.h"
 /*--------------------------------------------------------------------------*/
 int sci_move( char * fname, unsigned long fname_len )
 {
-    int m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0, m3 = 0, n3 = 0, l3 = 0;
+    SciErr sciErr;
+
+    int* piAddrl3 = NULL;
+    char* l3 = NULL;
+    int* piAddrl1 = NULL;
+    long long* l1 = NULL;
+    int* piAddrl2 = NULL;
+    double* l2 = NULL;
+
+    int m1 = 0, n1 = 0, m2 = 0, n2 = 0;
     int nbDim = 2;
     BOOL alone = FALSE;
     char* pobjUID = NULL;
     double * moveVector = NULL;
 
-    CheckRhs(2, 3);
+    CheckInputArgument(pvApiCtx, 2, 3);
     /*  set or create a graphic window */
-    if (Rhs == 3)
+    if (nbInputArgument(pvApiCtx) == 3)
     {
         char * option = NULL;
-        GetRhsVar(3, STRING_DATATYPE, &m3, &n3, &l3);
-        option = getStringFromStack(l3);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl3);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 3.
+        if (getAllocatedSingleString(pvApiCtx, piAddrl3, &l3))
+        {
+            Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 3);
+            return 1;
+        }
+
+        option = l3;
         if (strcmp(option, "alone") == 0)
         {
             alone = TRUE;
@@ -50,35 +72,67 @@ int sci_move( char * fname, unsigned long fname_len )
         else
         {
             Scierror(999, _("%s: Wrong value for input argument #%d: '%s' expected.\n"), fname, 3, "alone");
-            return 0;
+            return 1;
         }
+
+        freeAllocatedSingleString(l3);
     }
 
-    GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &m1, &n1, &l1); /* Gets the Handle passed as argument */
-    pobjUID = (char*)getObjectFromHandle(getHandleFromStack(l1));
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of handle at position 1.
+    sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &m1, &n1, &l1); /* Gets the Handle passed as argument */
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+        return 1;
+    }
+
+    pobjUID = (char*)getObjectFromHandle((long int) * l1);
 
     if (pobjUID == NULL)
     {
         Scierror(999, _("%s: The handle is not or no more valid.\n"), fname);
-        return 0;
+        return 1;
     }
 
     /* Get [x,y] or [x,y,z] vector */
-    GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        return 1;
+    }
+
     /* size of the vector, shoul dbe 2 or 3 */
     nbDim = m2 * n2;
     if (nbDim != 2 && nbDim != 3)
     {
         Scierror(999, _("%s: Wrong type for input argument #%d: Vector %s or %s expected.\n"), fname, 3, "[x y]", "[x,y,z]");
-        return 0;
+        return 1;
     }
-    moveVector = stk(l2);
+    moveVector = (l2);
 
     Objmove(pobjUID, moveVector, nbDim, alone);
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
 
-    return 1;
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 4afdb20..1f193fe 100644 (file)
@@ -20,7 +20,7 @@
 #include <stdlib.h>
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "BuildObjects.h"
 #include "Scierror.h"
 #include "SetProperty.h"
 /*--------------------------------------------------------------------------*/
 int sci_newaxes( char * fname, unsigned long fname_len )
 {
+    SciErr sciErr;
+
+    long long* outindex = NULL;
+
     char *psubwinUID = NULL;
-    int outindex = 0, numrow   = 1, numcol   = 1;
-    CheckRhs(0, 0);
-    CheckLhs(0, 1);
+    int numrow   = 1, numcol   = 1;
+    CheckInputArgument(pvApiCtx, 0, 0);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
     getOrCreateDefaultSubwin();
 
     if ((psubwinUID = (char*)ConstructSubWin (getCurrentFigure())) != NULL)
     {
-        CreateVar(Rhs + 1, GRAPHICAL_HANDLE_DATATYPE, &numrow, &numcol, &outindex);
+        sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, numrow, numcol, &outindex);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
 
-        *hstk(outindex) = getHandle(psubwinUID);
+        *(outindex) = getHandle(psubwinUID);
 
-        LhsVar(1) = 1;
-        PutLhsVar();
+        AssignOutputVariable(pvApiCtx, 1) = 1;
+        ReturnArguments(pvApiCtx);
     }
     else
     {
index 4987a70..b1fcb6f 100644 (file)
@@ -2,11 +2,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Fabrice Leray
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
- * 
+ *
  * 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
  *
  */
 #include "GetCommandArg.h"
 #include "BuildObjects.h"
 #include "sciCall.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "Scierror.h"
 /*------------------------------------------------------------------------*/
 int sci_param3d( char * fname, unsigned long fname_len )
 {
-  int izcol = 0, isfac = 0;
-  static double  ebox_def[6]= { 0,1,0,1,0,1};
-  double *ebox = ebox_def ;
-  static int iflag_def[3]= {1,2,4};
-  int iflag[3], *ifl = NULL, ix1 = 0, one = 1;
-  double  alpha_def=35.0 , theta_def=45.0 ;
-  double *alpha=&alpha_def, *theta=&theta_def;
-  int m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0, m3 = 0, n3 = 0, l3 = 0;
-  int m3n = 0, n3n = 0; /* F.Leray 19.03.04*/
-
-  static rhs_opts opts[]= { {-1,"alpha","?",0,0,0},
-                            {-1,"ebox","?",0,0,0},
-                            {-1,"flag","?",0,0,0},
-                            {-1,"leg","?",0,0,0},
-                            {-1,"theta","?",0,0,0},
-                            {-1,NULL,NULL,0,0}     };
-
-  char * labels = NULL ;
-
-  if (Rhs <= 0)
-  {
-    sci_demo(fname, fname_len);
+    SciErr sciErr;
+    int izcol = 0, isfac = 0;
+    static double  ebox_def[6] = { 0, 1, 0, 1, 0, 1};
+    double *ebox = ebox_def ;
+    static int iflag_def[3] = {1, 2, 4};
+    int iflag[3], *ifl = NULL, ix1 = 0, one = 1;
+    double  alpha_def = 35.0 , theta_def = 45.0 ;
+    double *alpha = &alpha_def, *theta = &theta_def;
+    int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0;
+    int m3n = 0, n3n = 0; /* F.Leray 19.03.04*/
+
+    static rhs_opts opts[] = { { -1, "alpha", "?", 0, 0, 0},
+        { -1, "ebox", "?", 0, 0, 0},
+        { -1, "flag", "?", 0, 0, 0},
+        { -1, "leg", "?", 0, 0, 0},
+        { -1, "theta", "?", 0, 0, 0},
+        { -1, NULL, NULL, 0, 0}
+    };
+
+    char * labels = NULL ;
+
+    int* piAddr1 = NULL;
+    int* piAddr2 = NULL;
+    int* piAddr3 = NULL;
+
+    double* l1 = NULL;
+    double* l2 = NULL;
+    double* l3 = NULL;
+
+    if (nbInputArgument(pvApiCtx) <= 0)
+    {
+        sci_demo(fname, fname_len);
+        return 0;
+    }
+
+    CheckInputArgument(pvApiCtx, 3, 8);
+
+    if ( get_optionals(fname, opts) == 0)
+    {
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+    if ( FirstOpt() < 4)
+    {
+        Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 4);
+        return(0);
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 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 (m1 * n1 == 0)
+    {
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 3.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    //CheckSameDims
+    if (m1 != m2 || n1 != n2)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
+        return 1;
+    }
+
+    //CheckSameDims
+    if (m2 != m3 || n2 != n3)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 2, m2, n2);
+        return 1;
+    }
+
+
+    GetOptionalDoubleArg(fname, 4, "theta", &theta, 1, opts);
+    GetOptionalDoubleArg(fname, 5, "alpha", &alpha, 1, opts);
+    GetLabels(fname, 6, opts, &labels);
+
+    iflag_def[1] = 8;
+    ifl = &(iflag_def[1]);
+    GetOptionalIntArg(fname, 7, "flag", &ifl, 2, opts);
+    iflag[0] = iflag_def[0];
+    iflag[1] = ifl[0];
+    iflag[2] = ifl[1];
+    GetOptionalDoubleArg(fname, 8, "ebox", &ebox, 6, opts);
+
+    getOrCreateDefaultSubwin();
+
+    ix1 = m1 * n1;
+
+    /* NG beg */
+    isfac = -1;
+    izcol = 0;
+
+    Objplot3d (fname, &isfac, &izcol, (l1), (l2), (l3), (double *) NULL, &ix1, &one, theta, alpha, labels, iflag, ebox, &m1, &n1, &m2, &n2, &m3, &n3, &m3n, &n3n); /*Adding F.Leray 12.03.04 */
+
+
+    /* NG end */
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
-  }
-
-  CheckRhs(3,8);
-
-  if ( get_optionals(fname,opts) == 0) 
-  {
-         PutLhsVar();
-         return 0;
-  }
-  if ( FirstOpt() < 4) 
-  {
-    Scierror(999,_("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname,1, 4);
-    return(0);
-  }
-
-  GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-  if (m1 * n1 == 0) 
-  { 
-         LhsVar(1) = 0; 
-         PutLhsVar();
-         return 0;
-  } 
-  GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
-  GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE, &m3, &n3, &l3);
-  CheckSameDims(1,2,m1,n1,m2,n2);
-  CheckSameDims(2,3,m2,n2,m3,n3);
-
-  GetOptionalDoubleArg(fname,4,"theta",&theta,1,opts);
-  GetOptionalDoubleArg(fname,5,"alpha",&alpha,1,opts);
-  GetLabels(fname,6,opts,&labels);
-
-  iflag_def[1]=8;
-  ifl=&(iflag_def[1]);
-  GetOptionalIntArg(fname,7,"flag",&ifl,2,opts);
-  iflag[0]=iflag_def[0];iflag[1]=ifl[0];iflag[2]=ifl[1];
-  GetOptionalDoubleArg(fname,8,"ebox",&ebox,6,opts);
-
-  getOrCreateDefaultSubwin();
-
-  ix1 = m1 * n1;
-
-  /* NG beg */
-  isfac=-1;
-  izcol=0;
-  
-  Objplot3d (fname,&isfac,&izcol,stk(l1),stk(l2),stk(l3),(double *) NULL,&ix1,&one,theta,alpha,labels,iflag,ebox,&m1,&n1,&m2,&n2,&m3,&n3,&m3n,&n3n);/*Adding F.Leray 12.03.04 */
-  
-
-  /* NG end */
-  LhsVar(1) = 0;
-  PutLhsVar();
-  return 0;
 }
 /*------------------------------------------------------------------------*/
index b0a51ea..01b625c 100644 (file)
@@ -2,11 +2,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Fabrice Leray
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
- * 
+ *
  * 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
  *
  */
 #include "BuildObjects.h"
 #include "sciCall.h"
 #include "MALLOC.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
 int sci_param3d1( char *fname, unsigned long fname_len )
 {
-  int izcol = 0, isfac = 0;
-  double *zcol = NULL;
-  static double  ebox_def [6]= { 0,1,0,1,0,1};
-  double *ebox = ebox_def ;
-  static int iflag_def[3]={1,2,4};
-  int iflag[3] , *ifl = NULL;
-  double  alpha_def=35.0 , theta_def=45.0 ;
-  double *alpha=&alpha_def, *theta=&theta_def;
-  int m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0, m3 = 0, n3 = 0, l3 = 0;
-  int m3n = 0, n3n = 0, l3n = 0, m3l = 0, n3l = 0, l3l = 0;
-  static rhs_opts opts[]= { {-1,"alpha","?",0,0,0},
-                            {-1,"ebox","?",0,0,0},
-                            {-1,"flag","?",0,0,0},
-                            {-1,"leg","?",0,0,0},
-                            {-1,"theta","?",0,0,0},
-                            {-1,NULL,NULL,0,0}     };
-
-  char * labels = NULL ;
-
-  if (Rhs <= 0)
-  {
-    sci_demo(fname, fname_len);
-    return 0;
-  }
-
-  CheckRhs(3,8);
-
-  if ( get_optionals(fname,opts) == 0) 
-  {
-         PutLhsVar();
-         return 0;
-  }
-
-  if ( FirstOpt() < 4) 
-  {
-    Scierror(999,_("%s: Misplaced optional argument: #%d must be at position %d.\n"),fname,1,4);
-    return(0);
-  }
-
-  GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);/* x */
-  if (m1 == 1 && n1 > 1) {m1 = n1;n1 = 1;}
-
-  GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);/* y */
-  if (m2 == 1 && n2 > 1) {m2 = n2;n2 = 1;}
-
-  if (m1 * n1 == 0) 
-  { 
-         LhsVar(1) = 0;
-         PutLhsVar();
-         return 0;
-  }
-  CheckSameDims(1,2,m1,n1,m2,n2); 
-
-  switch ( VarType(3) ) 
-  {
-  case 1 : 
-    izcol = 0;
-    GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE, &m3, &n3, &l3); /* z */
-    break;
-  case 15 : 
-    izcol = 1;
-    /* z = list(z,colors) */
-    GetRhsVar(3,LIST_DATATYPE,&m3l,&n3l,&l3l);
-    if ( m3l != 2 ) 
-    {
-      Scierror(999,_("%s: Wrong size for input argument #%d: List of size %d expected.\n"),
-        fname,2,m3l,2);
-      return 0;
-    }
-    GetListRhsVar(3,1,MATRIX_OF_DOUBLE_DATATYPE,&m3,&n3,&l3); /* z*/ 
-    GetListRhsVar(3,2,MATRIX_OF_DOUBLE_DATATYPE,&m3n,&n3n,&l3n); /* colors */
-    zcol  = stk(l3n);
-    if (m3n * n3n != n3) 
-    {
-      Scierror(999,_("%s: Wrong size for input argument #%d: %d expected.\n"),fname,3,n3);
-      return 0;
-    }
-    break ;
-  default : 
-    OverLoad(3);
-    return 0;
-  }
-  if (m3 == 1 && n3 > 1) {m3 = n3;n3 = 1;}
-  CheckSameDims(1,3,m1,n1,m3,n3); 
+    SciErr sciErr;
+    int izcol = 0, isfac = 0;
+    double *zcol = NULL;
+    static double  ebox_def [6] = { 0, 1, 0, 1, 0, 1};
+    double *ebox = ebox_def ;
+    static int iflag_def[3] = {1, 2, 4};
+    int iflag[3] , *ifl = NULL;
+    double  alpha_def = 35.0 , theta_def = 45.0 ;
+    double *alpha = &alpha_def, *theta = &theta_def;
+    int m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 0, n3 = 0;
+    int m3n = 0, n3n = 0, m3l = 0;
+    static rhs_opts opts[] = { { -1, "alpha", "?", 0, 0, 0},
+        { -1, "ebox", "?", 0, 0, 0},
+        { -1, "flag", "?", 0, 0, 0},
+        { -1, "leg", "?", 0, 0, 0},
+        { -1, "theta", "?", 0, 0, 0},
+        { -1, NULL, NULL, 0, 0}
+    };
+
+    char * labels = NULL ;
+
+    int* piAddr1  = NULL;
+    int* piAddr2  = NULL;
+    int* piAddr3  = NULL;
+    int* piAddr31 = NULL;
+    int* piAddr32 = NULL;
+
+    double* l1  = NULL;
+    double* l2  = NULL;
+    double* l3  = NULL;
+    double* l3n = NULL;
+
+    if (nbInputArgument(pvApiCtx) <= 0)
+    {
+        sci_demo(fname, fname_len);
+        return 0;
+    }
+
+    CheckInputArgument(pvApiCtx, 3, 8);
+
+    if ( get_optionals(fname, opts) == 0)
+    {
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+
+    if ( FirstOpt() < 4)
+    {
+        Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 4);
+        return(0);
+    }
 
-  GetOptionalDoubleArg(fname,4,"theta",&theta,1,opts);
-  GetOptionalDoubleArg(fname,5,"alpha",&alpha,1,opts);
-  GetLabels(fname,6,opts,&labels);
-  iflag_def[1]=8;
-  ifl=&(iflag_def[1]);
-  GetOptionalIntArg(fname,7,"flag",&ifl,2,opts);
-  iflag[0]=iflag_def[0];iflag[1]=ifl[0];iflag[2]=ifl[1];
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 1.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &m1, &n1, &l1); /* x */
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+        printError(&sciErr, 0);
+        return 1;
+    }
 
-  GetOptionalDoubleArg(fname,8,"ebox",&ebox,6,opts);
+    if (m1 == 1 && n1 > 1)
+    {
+        m1 = n1;
+        n1 = 1;
+    }
 
-  if (m1 == 1 && n1 > 1) { m1 = n1;    n1 = 1; }
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
 
-  getOrCreateDefaultSubwin();
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2); /* y */
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        printError(&sciErr, 0);
+        return 1;
+    }
 
-  /* NG beg */
-  isfac=-1;
+    if (m2 == 1 && n2 > 1)
+    {
+        m2 = n2;
+        n2 = 1;
+    }
 
-  Objplot3d (fname,&isfac,&izcol,stk(l1),stk(l2),stk(l3),zcol,&m1,&n1,theta,alpha,labels,iflag,ebox,&m1,&n1,&m2,&n2,&m3,&n3,&m3n,&n3n); /*Adding F.Leray 12.03.04*/
-  
-  LhsVar(1) = 0;
-  PutLhsVar();
-  return 0;
+    if (m1 * n1 == 0)
+    {
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
+    //CheckSameDims
+    if (m1 != m2 || n1 != n2)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
+        return 1;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    switch (getInputArgumentType(pvApiCtx, 3))
+    {
+        case 1 :
+            izcol = 0;
+
+            // Retrieve a matrix of double at position 3.
+            // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int l3".
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3); /* z */
+            if (sciErr.iErr)
+            {
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            break;
+        case 15 :
+            izcol = 1;
+            /* z = list(z,colors) */
+            sciErr = getListItemNumber(pvApiCtx, piAddr3, &m3l);
+            if (sciErr.iErr)
+            {
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            if ( m3l != 2 )
+            {
+                Scierror(999, _("%s: Wrong size for input argument #%d: List of size %d expected.\n"),
+                         fname, 2, m3l, 2);
+                return 0;
+            }
+
+            sciErr = getListItemAddress(pvApiCtx, piAddr3, 1, &piAddr31);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddr31, &m3, &n3, &l3); /* z */
+            if (sciErr.iErr)
+            {
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            sciErr = getListItemAddress(pvApiCtx, piAddr3, 2, &piAddr32);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddr32, &m3n, &n3n, &l3n); /* z */
+            if (sciErr.iErr)
+            {
+                Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+                printError(&sciErr, 0);
+                return 1;
+            }
+
+            zcol  = (l3n);
+            if (m3n * n3n != n3)
+            {
+                Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 3, n3);
+                return 0;
+            }
+            break ;
+        default :
+            OverLoad(3);
+            return 0;
+    }
+
+    if (m3 == 1 && n3 > 1)
+    {
+        m3 = n3;
+        n3 = 1;
+    }
+    //CheckSameDims
+    if (m1 != m3 || n1 != n3)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
+        return 1;
+    }
+
+
+    GetOptionalDoubleArg(fname, 4, "theta", &theta, 1, opts);
+    GetOptionalDoubleArg(fname, 5, "alpha", &alpha, 1, opts);
+    GetLabels(fname, 6, opts, &labels);
+    iflag_def[1] = 8;
+    ifl = &(iflag_def[1]);
+    GetOptionalIntArg(fname, 7, "flag", &ifl, 2, opts);
+    iflag[0] = iflag_def[0];
+    iflag[1] = ifl[0];
+    iflag[2] = ifl[1];
+
+    GetOptionalDoubleArg(fname, 8, "ebox", &ebox, 6, opts);
+
+    if (m1 == 1 && n1 > 1)
+    {
+        m1 = n1;
+        n1 = 1;
+    }
+
+    getOrCreateDefaultSubwin();
+
+    /* NG beg */
+    isfac = -1;
+
+    Objplot3d (fname, &isfac, &izcol, (l1), (l2), (l3), zcol, &m1, &n1, theta, alpha, labels, iflag, ebox, &m1, &n1, &m2, &n2, &m3, &n3, &m3n, &n3n); /*Adding F.Leray 12.03.04*/
+
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index aacab57..7d28198 100644 (file)
@@ -18,7 +18,7 @@
 
 #include "gw_graphics.h"
 #include "GetCommandArg.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "BasicAlgos.h"
 #include "sciCall.h"
 #include "DefaultCommandArg.h"
 /*------------------------------------------------------------------------*/
 int sci_plot2d( char * fname, unsigned long fname_len )
 {
+    SciErr sciErr;
 
-    int m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0, lt = 0;
+    int* piAddrl1 = NULL;
+    double* l1 = NULL;
+    int* piAddrl2 = NULL;
+    double* l2 = NULL;
+    double* lt = NULL;
+
+    int m1 = 0, n1 = 0, m2 = 0, n2 = 0;
     int test = 0, i = 0, j = 0, iskip = 0;
     int frame_def = 8;
     int *frame = &frame_def;
@@ -41,7 +48,6 @@ int sci_plot2d( char * fname, unsigned long fname_len )
 
     /* F.Leray 18.05.04 : log. case test*/
     int size_x = 0, size_y = 0;
-    double xd[2];
     char dataflag = 0;
 
     char   * logFlags = NULL  ;
@@ -64,22 +70,28 @@ int sci_plot2d( char * fname, unsigned long fname_len )
         { -1, NULL, NULL, 0, 0}
     };
 
-    if (Rhs == 0)
+    if (nbInputArgument(pvApiCtx) == 0)
     {
         sci_demo(fname, fname_len);
         return 0;
     }
 
-    CheckRhs(1, 9);
+    if ( get_optionals(fname, opts) == 0)
+    {
+        PutLhsVar();
+        return 0 ;
+    }
+
+    CheckInputArgument(pvApiCtx, 1, 9);
 
     iskip = 0;
     if ( get_optionals(fname, opts) == 0)
     {
-        PutLhsVar();
+        ReturnArguments(pvApiCtx);
         return 0 ;
     }
 
-    if (GetType(1) == sci_strings)
+    if (checkInputArgumentType(pvApiCtx, 1, sci_strings))
     {
         /* logflags */
         GetLogflags( fname, 1, opts, &logFlags ) ;
@@ -88,44 +100,105 @@ int sci_plot2d( char * fname, unsigned long fname_len )
 
     if (FirstOpt() == 2 + iskip)                                       /** plot2d([loglags,] y, <opt_args>); **/
     {
-        GetRhsVar(1 + iskip, MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1 + iskip, &piAddrl2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 1 + iskip.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1 + iskip);
+            return 1;
+        }
 
         if (m2 == 1 && n2 > 1)
         {
             m2 = n2;
             n2 = 1;
         }
+
         m1 = m2;
         n1 = n2;
-        CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE,  &m1, &n1, &l1);
+
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
 
         for (i = 0; i < m2 ; ++i)
         {
             for (j = 0 ; j < n2 ;  ++j)
             {
-                *stk( l1 + i + m2 * j) = (double) i + 1;
+                *(l1 + i + m2 * j) = (double) i + 1;
             }
         }
     }
     else if (FirstOpt() >= 3 + iskip)     /** plot2d([loglags,] x, y[, style [,...]]); **/
     {
-
         /* x */
-        GetRhsVar(1 + iskip, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1 + iskip, &piAddrl1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 1 + iskip.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1 + iskip);
+            return 1;
+        }
 
         /* y */
-        GetRhsVar(2 + iskip, MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2 + iskip, &piAddrl2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 2 + iskip.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2 + iskip);
+            return 1;
+        }
 
         test = (m1*n1 == 0) ||
                ((m1 == 1 || n1 == 1) && (m2 == 1 || n2 == 1) && (m1*n1 == m2 * n2))  ||
                ((m1 == m2) && (n1 == n2)) ||
                ((m1 == 1 && n1 == m2) || (n1 == 1 && m1 == m2));
-        CheckDimProp(1 + iskip, 2 + iskip, !test);
+        //CheckDimProp
+        if (!test)
+        {
+            Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
+            return 1;
+        }
 
         if (m1*n1 == 0)
         {
             /* default x=1:n */
-            CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE,  &m2, &n2, &lt);
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m2, n2, &lt);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
             if (m2 == 1 && n2 > 1)
             {
                 m2 = n2;
@@ -135,7 +208,7 @@ int sci_plot2d( char * fname, unsigned long fname_len )
             {
                 for (j = 0 ; j < n2 ;  ++j)
                 {
-                    *stk( lt + i + m2 * j) = (double) i + 1;
+                    *(lt + i + m2 * j) = (double) i + 1;
                 }
             }
             m1 = m2;
@@ -145,12 +218,19 @@ int sci_plot2d( char * fname, unsigned long fname_len )
         else if ((m1 == 1 || n1 == 1) && (m2 != 1 && n2 != 1) )
         {
             /* a single x vector for mutiple columns for y */
-            CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE,  &m2, &n2, &lt);
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m2, n2, &lt);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
             for (i = 0; i < m2 ; ++i)
             {
                 for (j = 0 ; j < n2 ;  ++j)
                 {
-                    *stk( lt + i + m2 * j) = *stk(l1 + i);
+                    *(lt + i + m2 * j) = *(l1 + i);
                 }
             }
             m1 = m2;
@@ -160,10 +240,17 @@ int sci_plot2d( char * fname, unsigned long fname_len )
         else if ((m1 == 1 && n1 == 1) && (n2 != 1) )
         {
             /* a single y row vector  for a single x */
-            CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE,  &m1, &n2, &lt);
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n2, &lt);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
             for (j = 0 ; j < n2 ;  ++j)
             {
-                *stk( lt + j ) = *stk(l1);
+                lt[j] = *l1;
             }
             n1 = n2;
             l1 = lt;
@@ -195,13 +282,9 @@ int sci_plot2d( char * fname, unsigned long fname_len )
     }
 
     sciGetStyle( fname, 3 + iskip, n1, opts, &style ) ;
-
     GetStrf( fname, 4 + iskip, opts, &strf ) ;
-
     GetLegend( fname, 5 + iskip, opts, &legend );
-
     GetRect( fname, 6 + iskip, opts, &rect );
-
     GetNax( 7 + iskip, opts, &nax, &flagNax ) ;
 
     if (iskip == 0)
@@ -291,8 +374,6 @@ int sci_plot2d( char * fname, unsigned long fname_len )
             switch ( dataflag )
             {
                 case 'e' :
-                    xd[0] = 1.0;
-                    xd[1] = (double)m1;
                     size_x = (m1 != 0) ? 2 : 0 ;
                     break;
                 case 'o' :
@@ -306,7 +387,7 @@ int sci_plot2d( char * fname, unsigned long fname_len )
 
             if (size_x != 0)
             {
-                if (logFlags[1] == 'l' && sciFindStPosMin(stk(l1), size_x) <= 0.0 )
+                if (logFlags[1] == 'l' && sciFindStPosMin((l1), size_x) <= 0.0 )
                 {
                     Scierror(999, _("%s: At least one x data must be strictly positive to compute the bounds and use logarithmic mode.\n"), fname);
                     return -1 ;
@@ -317,7 +398,7 @@ int sci_plot2d( char * fname, unsigned long fname_len )
 
             if (size_y != 0)
             {
-                if ( logFlags[2] == 'l' && sciFindStPosMin(stk(l2), size_y) <= 0.0 )
+                if ( logFlags[2] == 'l' && sciFindStPosMin((l2), size_y) <= 0.0 )
                 {
                     Scierror(999, _("%s: At least one y data must be strictly positive to compute the bounds and use logarithmic mode\n"), fname);
                     return -1 ;
@@ -329,10 +410,11 @@ int sci_plot2d( char * fname, unsigned long fname_len )
 
     // open a figure if none already exists
     getOrCreateDefaultSubwin();
-    Objplot2d (1, logFlags, stk(l1), stk(l2), &n1, &m1, style, strf, legend, rect, nax, flagNax);
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    Objplot2d (1, logFlags, (l1), (l2), &n1, &m1, style, strf, legend, rect, nax, flagNax);
+
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 /*------------------------------------------------------------------------*/
index 7a205be..93edaa3 100644 (file)
@@ -2,11 +2,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Fabrice Leray
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
- * 
+ *
  * 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
  *
  */
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "GetCommandArg.h"
 #include "DefaultCommandArg.h"
 #include "sciCall.h"
 #include "localization.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
-int sci_plot2d1_1 (char *fname,unsigned long fname_len)
+int sci_plot2d1_1 (char *fname, unsigned long fname_len)
 {
-  return sci_plot2d1_G("plot2d1",1,fname_len);/* NG */
+    return sci_plot2d1_G("plot2d1", 1, fname_len); /* NG */
 }
 /*--------------------------------------------------------------------------*/
-int sci_plot2d1_2 (char *fname,unsigned long fname_len)
+int sci_plot2d1_2 (char *fname, unsigned long fname_len)
 {
-  return sci_plot2d1_G("plot2d2",2,fname_len); /* NG */
+    return sci_plot2d1_G("plot2d2", 2, fname_len); /* NG */
 }
 /*--------------------------------------------------------------------------*/
-int sci_plot2d1_3 (char *fname,unsigned long fname_len)
+int sci_plot2d1_3 (char *fname, unsigned long fname_len)
 {
-  return sci_plot2d1_G("plot2d3",3,fname_len);/* NG */
+    return sci_plot2d1_G("plot2d3", 3, fname_len); /* NG */
 }
 /*--------------------------------------------------------------------------*/
-int sci_plot2d1_4 (char *fname,unsigned long fname_len)
+int sci_plot2d1_4 (char *fname, unsigned long fname_len)
 {
-  return sci_plot2d1_G("plot2d4",4,fname_len);/* NG */
+    return sci_plot2d1_G("plot2d4", 4, fname_len); /* NG */
 }
 /*--------------------------------------------------------------------------*/
 int sci_plot2d1_G( char * fname, int ptype, unsigned long fname_len )
 {
-  int frame_def=8;
-  int *frame=&frame_def;
-  int axes_def=1;
-  int *axes=&axes_def;
-  int iskip = 0, test  = 0;
-  int m1 = 0,n1 = 0,l1 = 0, m2 = 0, n2 = 0, l2 = 0, lt = 0, i = 0, j = 0;
-
-  static rhs_opts opts[]= { {-1,"axesflag","?",0,0,0},
-                            {-1,"frameflag","?",0,0,0},
-                            {-1,"leg","?",0,0,0},
-                            {-1,"logflag","?",0,0,0},
-                            {-1,"nax","?",0,0,0},
-                            {-1,"rect","?",0,0,0},
-                            {-1,"strf","?",0,0,0},
-                            {-1,"style","?",0,0,0},
-                            {-1,NULL,NULL,0,0}       };
-
-  int    * style    = NULL  ;
-  double * rect     = NULL  ;
-  int    * nax      = NULL  ;
-  BOOL     flagNax  = FALSE ;
-  char   * strf     = NULL  ;
-  char   * legend   = NULL  ;
-  char   * logFlags = NULL  ;
-
-  if (Rhs <= 0) {
-    /* lauch the default routines depending on the name of the calling funtion */
-    sci_demo(fname, fname_len);
-    return 0;
-  }
-  CheckRhs(1,9); /* to allow plot2dxx(y) */
-
-
-  iskip=0;
-  if ( get_optionals(fname,opts) == 0) 
-  {
-         PutLhsVar();
-         return 0;
-  }
-
-  if (GetType(1)==sci_strings) {
-    /* logflags */
-    GetLogflags(fname,1,opts,&logFlags);
-    iskip=1;
-  }
-
-  /* added to support plot2dxx([logflags],y) */
-  if ( Rhs == 1 + iskip )
-  {
-    if ( FirstOpt() <= Rhs)
-    {
-      Scierror(999,_("%s: Misplaced optional argument: #%d must be at position %d.\n"),fname,1, 3+iskip);
-      return(0);
-    }
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    double* l1 = NULL;
+    int* piAddrl2 = NULL;
+    double* l2 = NULL;
+    double* lt = NULL;
 
-    GetRhsVar(1+iskip,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
-    CreateVar(2+iskip,MATRIX_OF_DOUBLE_DATATYPE,  &m2, &n2, &l1);
-    if (m2 == 1 && n2 > 1) { m2 = n2; n2 = 1;}
-    m1 = m2;  n1 = n2;
-    for (i = 0; i < m2 ; ++i) 
-      for (j = 0 ; j < n2 ;  ++j)
-        *stk( l1 + i + m2*j) = (double) i+1;
-  }
+    int frame_def = 8;
+    int *frame = &frame_def;
+    int axes_def = 1;
+    int *axes = &axes_def;
+    int iskip = 0, test  = 0;
+    int m1 = 0, n1 = 0, m2 = 0, n2 = 0, i = 0, j = 0;
 
+    static rhs_opts opts[] = { { -1, "axesflag", "?", 0, 0, 0},
+        { -1, "frameflag", "?", 0, 0, 0},
+        { -1, "leg", "?", 0, 0, 0},
+        { -1, "logflag", "?", 0, 0, 0},
+        { -1, "nax", "?", 0, 0, 0},
+        { -1, "rect", "?", 0, 0, 0},
+        { -1, "strf", "?", 0, 0, 0},
+        { -1, "style", "?", 0, 0, 0},
+        { -1, NULL, NULL, 0, 0}
+    };
 
-  if (Rhs >= 2+iskip)
-  {
-    if ( FirstOpt() < 3+iskip) 
+    int    * style    = NULL  ;
+    double * rect     = NULL  ;
+    int    * nax      = NULL  ;
+    BOOL     flagNax  = FALSE ;
+    char   * strf     = NULL  ;
+    char   * legend   = NULL  ;
+    char   * logFlags = NULL  ;
+
+    if (nbInputArgument(pvApiCtx) <= 0)
     {
-      Scierror(999,_("%s: Misplaced optional argument: #%d must be at position %d.\n"),
-        fname,1, 3+iskip);
-      return(0);
+        /* lauch the default routines depending on the name of the calling funtion */
+        sci_demo(fname, fname_len);
+        return 0;
     }
+    CheckInputArgument(pvApiCtx, 1, 9); /* to allow plot2dxx(y) */
 
 
-    /* x */
-    GetRhsVar(1+iskip,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-    if (iskip==1) 
+    iskip = 0;
+    if ( get_optionals(fname, opts) == 0)
     {
-      if (logFlags[0]=='e')
-      {
-        m1 = 0 ;
-        n1 = 0 ;
-      }
+        ReturnArguments(pvApiCtx);
+        return 0;
     }
 
-    /* y */
-    GetRhsVar(2+iskip,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
-    /* if (m2 * n2 == 0) { m1 = 0; n1 = 0;}  */
-
-    test = (m1*n1 == 0) /* x = [] */
-      /* x,y vectors of same length */  
-      || ((m1 == 1 || n1 == 1) && (m2 == 1 || n2 ==1) && (m1*n1 == m2*n2))
-      || ((m1 == m2) && (n1 == n2)) /* size(x) == size(y) */
-      /* x vector size(y)==[size(x),.] */
-      || ((m1 == 1 && n1 == m2) || (n1 == 1 && m1 == m2)); 
-
-    CheckDimProp(1+iskip,2+iskip,!test);
-
-    if (m1*n1 == 0) 
-    { /* default x=1:n */
-      CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,  &m2, &n2, &lt);
-      if (m2 == 1 && n2 > 1) { m2 = n2; n2 = 1;}
-      for (i = 0; i < m2 ; ++i)
-      {
-        for (j = 0 ; j < n2 ;  ++j)
-        {
-          *stk( lt + i + m2*j) = (double) i+1;
-        }
-      }
-      m1 = m2;
-      n1 = n2;
-      l1 = lt;
-    }
-    else if ((m1 == 1 || n1 == 1) && (m2 != 1 && n2 != 1) ) {
-      /* a single x vector for mutiple columns for y */
-      CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,  &m2, &n2, &lt);
-      for (i = 0; i < m2 ; ++i)
-      {
-        for (j = 0 ; j < n2 ;  ++j)
-        {
-          *stk( lt + i + m2*j) = *stk(l1 +i);
-        }
-      }
-      m1 = m2;
-      n1 = n2;
-      l1 = lt;
-    }
-    else if ((m1 == 1 && n1 == 1) && (n2 != 1) ) {
-      /* a single y row vector  for a single x */
-      CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,  &m1, &n2, &lt);
-      for (j = 0 ; j < n2 ;  ++j)
-      {
-        *stk( lt + j ) = *stk(l1);
-      }
-      n1 = n2;
-      l1 = lt;
-    }
-    else {
-      if (m2 == 1 && n2 > 1) { m2 = n2; n2 = 1;}
-      if (m1 == 1 && n1 > 1) { m1 = n1; n1 = 1;}
+    if (checkInputArgumentType(pvApiCtx, 1, sci_strings))
+    {
+        /* logflags */
+        GetLogflags(fname, 1, opts, &logFlags);
+        iskip = 1;
     }
-  }
 
-  sciGetStyle(fname,3+iskip,n1,opts,&style);
-  GetStrf(fname,4+iskip,opts,&strf);
-  GetLegend(fname,5+iskip,opts,&legend);
-  GetRect(fname,6+iskip,opts,&rect);
-  GetNax(7+iskip,opts,&nax,&flagNax);
-  if (iskip==0) GetLogflags(fname,8,opts,&logFlags);
+    /* added to support plot2dxx([logflags],y) */
+    if ( nbInputArgument(pvApiCtx) == 1 + iskip )
+    {
+        if ( FirstOpt() <= nbInputArgument(pvApiCtx))
+        {
+            Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 3 + iskip);
+            return(0);
+        }
+
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1 + iskip, &piAddrl2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
 
-  if ( isDefStrf( strf ) ) {
-    char strfl[4];
-    strcpy(strfl,DEFSTRFN);
+        // Retrieve a matrix of double at position 1 + iskip.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1 + iskip);
+            return 1;
+        }
 
-    strf = strfl;
-    if ( !isDefRect( rect ) )
-    {
-      strfl[1]='7';
+        sciErr = allocMatrixOfDouble(pvApiCtx, 2 + iskip, m2, n2, &l1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        if (m2 == 1 && n2 > 1)
+        {
+            m2 = n2;
+            n2 = 1;
+        }
+
+        m1 = m2;
+        n1 = n2;
+
+        for (i = 0; i < m2 ; ++i)
+        {
+            for (j = 0 ; j < n2 ;  ++j)
+            {
+                *(l1 + i + m2 * j) = (double) i + 1;
+            }
+        }
     }
-    if ( !isDefLegend( legend ) )
+
+
+    if (nbInputArgument(pvApiCtx) >= 2 + iskip)
     {
-      strfl[0]='1';
+        if ( FirstOpt() < 3 + iskip)
+        {
+            Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"),
+                     fname, 1, 3 + iskip);
+            return(0);
+        }
+
+
+        /* x */
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1 + iskip, &piAddrl1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 1 + iskip.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1 + iskip);
+            return 1;
+        }
+
+        if (iskip == 1)
+        {
+            if (logFlags[0] == 'e')
+            {
+                m1 = 0 ;
+                n1 = 0 ;
+            }
+        }
+
+        /* y */
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2 + iskip, &piAddrl2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 2 + iskip.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2 + iskip);
+            return 1;
+        }
+
+        /* if (m2 * n2 == 0) { m1 = 0; n1 = 0;}  */
+
+        test = (m1*n1 == 0) /* x = [] */
+               /* x,y vectors of same length */
+               || ((m1 == 1 || n1 == 1) && (m2 == 1 || n2 == 1) && (m1*n1 == m2 * n2))
+               || ((m1 == m2) && (n1 == n2)) /* size(x) == size(y) */
+               /* x vector size(y)==[size(x),.] */
+               || ((m1 == 1 && n1 == m2) || (n1 == 1 && m1 == m2));
+
+        //CheckDimProp
+        if (!test)
+        {
+            Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
+            return 1;
+        }
+
+
+        if (m1*n1 == 0)
+        {
+            /* default x=1:n */
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m2, n2, &lt);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
+            if (m2 == 1 && n2 > 1)
+            {
+                m2 = n2;
+                n2 = 1;
+            }
+            for (i = 0; i < m2 ; ++i)
+            {
+                for (j = 0 ; j < n2 ;  ++j)
+                {
+                    *(lt + i + m2 * j) = (double) i + 1;
+                }
+            }
+            m1 = m2;
+            n1 = n2;
+            l1 = lt;
+        }
+        else if ((m1 == 1 || n1 == 1) && (m2 != 1 && n2 != 1) )
+        {
+            /* a single x vector for mutiple columns for y */
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m2, n2, &lt);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
+            for (i = 0; i < m2 ; ++i)
+            {
+                for (j = 0 ; j < n2 ;  ++j)
+                {
+                    *(lt + i + m2 * j) = l1[i];
+                }
+            }
+            m1 = m2;
+            n1 = n2;
+            l1 = lt;
+        }
+        else if ((m1 == 1 && n1 == 1) && (n2 != 1) )
+        {
+            /* a single y row vector  for a single x */
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n2, &lt);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), fname);
+                return 1;
+            }
+
+            for (j = 0 ; j < n2 ;  ++j)
+            {
+                lt[j] = *l1;
+            }
+            n1 = n2;
+            l1 = lt;
+        }
+        else
+        {
+            if (m2 == 1 && n2 > 1)
+            {
+                m2 = n2;
+                n2 = 1;
+            }
+            if (m1 == 1 && n1 > 1)
+            {
+                m1 = n1;
+                n1 = 1;
+            }
+        }
     }
-    GetOptionalIntArg(fname,9,"frameflag",&frame,1,opts);
-    if(frame != &frame_def)
+
+    sciGetStyle(fname, 3 + iskip, n1, opts, &style);
+    GetStrf(fname, 4 + iskip, opts, &strf);
+    GetLegend(fname, 5 + iskip, opts, &legend);
+    GetRect(fname, 6 + iskip, opts, &rect);
+    GetNax(7 + iskip, opts, &nax, &flagNax);
+    if (iskip == 0)
     {
-      strfl[1] = (char)(*frame+48);
+        GetLogflags(fname, 8, opts, &logFlags);
     }
-    GetOptionalIntArg(fname,9,"axesflag",&axes,1,opts);
-    if(axes != &axes_def)
+
+    if ( isDefStrf( strf ) )
     {
-      strfl[2] = (char)(*axes+48);
+        char strfl[4];
+        strcpy(strfl, DEFSTRFN);
+
+        strf = strfl;
+        if ( !isDefRect( rect ) )
+        {
+            strfl[1] = '7';
+        }
+        if ( !isDefLegend( legend ) )
+        {
+            strfl[0] = '1';
+        }
+        GetOptionalIntArg(fname, 9, "frameflag", &frame, 1, opts);
+        if (frame != &frame_def)
+        {
+            strfl[1] = (char)(*frame + 48);
+        }
+        GetOptionalIntArg(fname, 9, "axesflag", &axes, 1, opts);
+        if (axes != &axes_def)
+        {
+            strfl[2] = (char)(*axes + 48);
+        }
     }
-  }
 
-  if(ptype == 0) { ptype = 1 ; }
+    if (ptype == 0)
+    {
+        ptype = 1 ;
+    }
 
-  Objplot2d (ptype,logFlags,stk(l1), stk(l2), &n1, &m1, style, strf,legend,rect, nax, flagNax);
+    Objplot2d (ptype, logFlags, (l1), (l2), &n1, &m1, style, strf, legend, rect, nax, flagNax);
 
 
-  LhsVar(1) = 0;
-  PutLhsVar();
-  return 0;
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 1859f84..a1cc0da 100644 (file)
@@ -20,7 +20,7 @@
 #include <stdio.h>
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "BuildObjects.h"
 #include "GetCommandArg.h"
 #include "MALLOC.h"
 /*--------------------------------------------------------------------------*/
 int sci_plot3d( char * fname, unsigned long fname_len )
 {
-  static double  ebox_def [6]= { 0,1,0,1,0,1};
-  double *ebox = ebox_def ;
-  static int iflag_def[3]={2,2,4};
-  int *iflag = iflag_def;
-  double  alpha_def=35.0 , theta_def=45.0 ;
-  double *alpha=&alpha_def, *theta=&theta_def;
-  int m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0, m3 = 0, n3 = 0, l3 = 0;
-  int m3n = 0, n3n = 0, l3n = 0, m3l = 0, n3l = 0, l3l = 0;
-
-  int izcol = 0,  isfac = 0;
-  double *zcol = NULL;
-
-  static rhs_opts opts[]= { {-1,"alpha","?",0,0,0},
-  {-1,"ebox","?",0,0,0},
-  {-1,"flag","?",0,0,0},
-  {-1,"leg","?",0,0,0},
-  {-1,"theta","?",0,0,0},
-  {-1,NULL,NULL,0,0}};
-
-  char * legend = NULL ;
-
-  /*
-  ** This overload the function to call demo script
-  ** the demo script is called %_<fname>
-  */
-  if (Rhs <= 0)
-  {
-   sci_demo(fname, fname_len);
-   return 0;
-  }
-
-  CheckRhs(3,8);
-
-  if ( get_optionals(fname,opts) == 0)
-  {
-         PutLhsVar();
-         return 0;
-  }
-
-  if ( FirstOpt() < 4)
-  {
-    Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname,1, 4);
-    return -1;
-  }
-
-  GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-  GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
-  if (m1 * n1 == 0)
-  {
-         LhsVar(1) = 0;
-         PutLhsVar();
-         return 0;
-  }
-
-  if (Rhs >= 3) {
-    /*     third argument can be a matrix z or a list list(z,zcol) */
-    switch ( VarType(3) )
+    SciErr sciErr;
+    static double  ebox_def [6] = { 0, 1, 0, 1, 0, 1};
+    double *ebox = ebox_def ;
+    static int iflag_def[3] = {2, 2, 4};
+    int *iflag = iflag_def;
+    double  alpha_def = 35.0 , theta_def = 45.0 ;
+    double *alpha = &alpha_def, *theta = &theta_def;
+    int m1 = 0, n1 = 0,  m2 = 0, n2 = 0, m3 = 0, n3 = 0;
+    int m3n = 0, n3n = 0, m3l = 0;
+
+    int izcol = 0,  isfac = 0;
+    double *zcol = NULL;
+
+    static rhs_opts opts[] =
+    {
+        { -1, "alpha", "?", 0, 0, 0},
+        { -1, "ebox", "?", 0, 0, 0},
+        { -1, "flag", "?", 0, 0, 0},
+        { -1, "leg", "?", 0, 0, 0},
+        { -1, "theta", "?", 0, 0, 0},
+        { -1, NULL, NULL, 0, 0}
+    };
+
+    char * legend = NULL ;
+
+    int* piAddr1  = NULL;
+    int* piAddr2  = NULL;
+    int* piAddr3  = NULL;
+    int* piAddr31 = NULL;
+    int* piAddr32 = NULL;
+
+    double* l1  = NULL;
+    double* l2  = NULL;
+    double* l3  = NULL;
+    double* l3n = NULL;
+
+    /*
+    ** This overload the function to call demo script
+    ** the demo script is called %_<fname>
+    */
+    if (nbInputArgument(pvApiCtx) <= 0)
     {
-    case sci_matrix :
-      GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE, &m3, &n3, &l3);
-      izcol = 0;
-      break;
-    case sci_list :
-      izcol = 1;
-      /* z = list(z,colors) */
-      GetRhsVar(3,LIST_DATATYPE,&m3l,&n3l,&l3l);
-      if ( m3l != 2 )
-      {
-        Scierror(999,_("%s: Wrong size for input argument #%d: List of size %d expected.\n"),
-          fname, 3, 2);
+        sci_demo(fname, fname_len);
         return 0;
-      }
-      GetListRhsVar(3,1,MATRIX_OF_DOUBLE_DATATYPE,&m3,&n3,&l3);
-      GetListRhsVar(3,2,MATRIX_OF_DOUBLE_DATATYPE,&m3n,&n3n,&l3n);
-      zcol  = stk(l3n);
-      if (m3n * n3n != n3 &&  m3n*n3n != m3*n3)
-      {
-        Scierror(999,_("%s: Wrong size for input argument #%d: %d or %d expected.\n"),fname,3, n3,m3*n3);
+    }
+
+    CheckInputArgument(pvApiCtx, 3, 8);
+
+    if ( get_optionals(fname, opts) == 0)
+    {
+        ReturnArguments(pvApiCtx);
         return 0;
-      }
-      /*
-      *   Added by E Segre 4/5/4000. In the case where zcol is a
-      *   matrix of the same size as z, we set izcol to 2. This
-      *   value is later transmitted to the C2F(fac3dg) routine,
-      *   which has been modified to do the interpolated shading
-      *    (see the file SCI/modules/graphics/src/c/Plo3d.c
-      */
-      if (   m3n*n3n == m3*n3 ) { izcol=2  ; }
-      break ;
-    default :
-      OverLoad(3);
-      return 0;
     }
-  }
-  iflag_def[1]=8;
-
-  GetOptionalDoubleArg(fname,4,"theta",&theta,1,opts);
-  GetOptionalDoubleArg(fname,5,"alpha",&alpha,1,opts);
-  GetLabels(fname,6,opts,&legend);
-  GetOptionalIntArg(fname,7,"flag",&iflag,3,opts);
-  GetOptionalDoubleArg(fname,8,"ebox",&ebox,6,opts);
-
-  if (m1 * n1 == m3 * n3 && m1 * n1 == m2 * n2 && m1 * n1 != 1) {
-    if (! (m1 == m2 && m2 == m3 && n1 == n2 && n2 == n3)) {
-      Scierror(999,_("%s: Wrong value for input arguments #%d, #%d and #%d: Incompatible length.\n"),fname, 1, 2, 3);
-      return 0;
+
+    if ( FirstOpt() < 4)
+    {
+        Scierror(999, _("%s: Misplaced optional argument: #%d must be at position %d.\n"), fname, 1, 4);
+        return -1;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 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;
+    }
+
+    //get variable address
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr2, &m2, &n2, &l2);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    if (m1 * n1 == 0)
+    {
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
+        return 0;
     }
-  } else {
-    if (m2 * n2 != n3) {
-      Scierror(999,_("%s: Wrong value for input arguments #%d and #%d: Incompatible length.\n"),fname, 2, 3);
-      return 0;
+
+    if (nbInputArgument(pvApiCtx) >= 3)
+    {
+        /*     third argument can be a matrix z or a list list(z,zcol) */
+        sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        switch (getInputArgumentType(pvApiCtx, 3))
+        {
+            case sci_matrix :
+                //get variable address
+                sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 1;
+                }
+
+                // Retrieve a matrix of double at position 3.
+                sciErr = getMatrixOfDouble(pvApiCtx, piAddr3, &m3, &n3, &l3);
+                if (sciErr.iErr)
+                {
+                    Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+                    printError(&sciErr, 0);
+                    return 1;
+                }
+
+                izcol = 0;
+                break;
+            case sci_list :
+                izcol = 1;
+                /* z = list(z,colors) */
+                sciErr = getListItemNumber(pvApiCtx, piAddr3, &m3l);
+                if (sciErr.iErr)
+                {
+                    Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+                    printError(&sciErr, 0);
+                    return 1;
+                }
+
+                if ( m3l != 2 )
+                {
+                    Scierror(999, _("%s: Wrong size for input argument #%d: List of size %d expected.\n"),
+                             fname, 2, m3l, 2);
+                    return 1;
+                }
+
+                sciErr = getListItemAddress(pvApiCtx, piAddr3, 1, &piAddr31);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 1;
+                }
+
+                sciErr = getMatrixOfDouble(pvApiCtx, piAddr31, &m3, &n3, &l3); /* z */
+                if (sciErr.iErr)
+                {
+                    Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+                    printError(&sciErr, 0);
+                    return 1;
+                }
+
+                sciErr = getListItemAddress(pvApiCtx, piAddr3, 2, &piAddr32);
+                if (sciErr.iErr)
+                {
+                    printError(&sciErr, 0);
+                    return 1;
+                }
+
+                sciErr = getMatrixOfDouble(pvApiCtx, piAddr32, &m3n, &n3n, &l3n); /* z */
+                if (sciErr.iErr)
+                {
+                    Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+                    printError(&sciErr, 0);
+                    return 1;
+                }
+
+                zcol  = (l3n);
+                if (m3n * n3n != n3 &&  m3n*n3n != m3 * n3)
+                {
+                    Scierror(999, _("%s: Wrong size for input argument #%d: %d or %d expected.\n"), fname, 3, n3, m3 * n3);
+                    return 1;
+                }
+                /*
+                *   Added by E Segre 4/5/2000. In the case where zcol is a
+                *   matrix of the same size as z, we set izcol to 2. This
+                *   value is later transmitted to the C2F(fac3dg) routine,
+                *   which has been modified to do the interpolated shading
+                *    (see the file SCI/modules/graphics/src/c/Plo3d.c
+                */
+                if (m3n*n3n == m3 * n3)
+                {
+                    izcol = 2  ;
+                }
+                break ;
+            default :
+                OverLoad(3);
+                return 0;
+        }
     }
-    if (m1 * n1 != m3) {
-      Scierror(999,_("%s: Wrong value for input arguments #%d and #%d: Incompatible length.\n"),fname, 1, 3);
-      return 0;
+    iflag_def[1] = 8;
+
+    GetOptionalDoubleArg(fname, 4, "theta", &theta, 1, opts);
+    GetOptionalDoubleArg(fname, 5, "alpha", &alpha, 1, opts);
+    GetLabels(fname, 6, opts, &legend);
+    GetOptionalIntArg(fname, 7, "flag", &iflag, 3, opts);
+    GetOptionalDoubleArg(fname, 8, "ebox", &ebox, 6, opts);
+
+    if (m1 * n1 == m3 * n3 && m1 * n1 == m2 * n2 && m1 * n1 != 1)
+    {
+        if (! (m1 == m2 && m2 == m3 && n1 == n2 && n2 == n3))
+        {
+            Scierror(999, _("%s: Wrong value for input arguments #%d, #%d and #%d: Incompatible length.\n"), fname, 1, 2, 3);
+            return 1;
+        }
     }
-    if ( m1*n1 <= 1 || m2*n2 <= 1 )
+    else
     {
-               Scierror(999,_("%s: Wrong size for input arguments #%d and #%d: %s expected.\n"),fname, 2, 3, ">= 2");
-      return 0;
+        if (m2 * n2 != n3)
+        {
+            Scierror(999, _("%s: Wrong value for input arguments #%d and #%d: Incompatible length.\n"), fname, 2, 3);
+            return 1;
+        }
+
+        if (m1 * n1 != m3)
+        {
+            Scierror(999, _("%s: Wrong value for input arguments #%d and #%d: Incompatible length.\n"), fname, 1, 3);
+            return 1;
+        }
+
+        if ( m1*n1 <= 1 || m2*n2 <= 1 )
+        {
+            Scierror(999, _("%s: Wrong size for input arguments #%d and #%d: %s expected.\n"), fname, 2, 3, ">= 2");
+            return 1;
+        }
     }
-  }
 
-  if (m1 * n1 == 0 || m2 * n2 == 0 || m3 * n3 == 0) {
-               LhsVar(1)=0;
-               PutLhsVar();
-               return 0;
-       }
+    if (m1 * n1 == 0 || m2 * n2 == 0 || m3 * n3 == 0)
+    {
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
+        return 0;
+    }
 
-  getOrCreateDefaultSubwin();
+    getOrCreateDefaultSubwin();
 
-  /******************** 24/015/2002 ********************/
-  if (m1 * n1 == m3 * n3 && m1 * n1 == m2 * n2 && m1 * n1 != 1) /* NG beg */
-  {
-    isfac=1;
-  }
-  else
-  {
-    isfac=0;
-  }
+    /******************** 24/05/2002 ********************/
+    if (m1 * n1 == m3 * n3 && m1 * n1 == m2 * n2 && m1 * n1 != 1) /* NG beg */
+    {
+        isfac = 1;
+    }
+    else
+    {
+        isfac = 0;
+    }
 
 
-  Objplot3d (fname,&isfac,&izcol,stk(l1),stk(l2),stk(l3),zcol,&m3,&n3,theta,alpha,legend,iflag,ebox,&m1,&n1,&m2,&n2,&m3,&n3,&m3n,&n3n);/*Adding F.Leray 12.03.04 and 19.03.04*/
+    Objplot3d (fname, &isfac, &izcol, (l1), (l2), (l3), zcol, &m3, &n3, theta, alpha, legend, iflag, ebox, &m1, &n1, &m2, &n2, &m3, &n3, &m3n, &n3n); /*Adding F.Leray 12.03.04 and 19.03.04*/
 
-  LhsVar(1) = 0;
-  PutLhsVar();
-  return 0;
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
+    return 0;
 
 }
 /*--------------------------------------------------------------------------*/
index 30b3ca8..cdd00cd 100644 (file)
@@ -18,7 +18,7 @@
 
 #include "gw_graphics.h"
 #include "setGraphicObjectProperty.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "MALLOC.h"
 #include "HandleManagement.h"
 #include "localization.h"
 
 int sci_relocate_handle( char * fname, unsigned long fname_len )
 {
-  int handleCol  = 0;
-  int handleRow = 0 ;
-  int nbHandle = 0 ;
-  int handleStkIndex = 0 ;
-  int parentCol = 0 ;
-  int parentRow = 0 ;
-  int parentStkIndex = 0 ;
-  int outIndex = 0 ;
-  int i = 0 ;
-
-  long children = 0 ;
-  char* childrenID = NULL;
-  long parent = 0 ;
-  char* parentID = NULL;
-
-  /* the function should be called with relocate_handle( handle, parent_handle ) */
-  CheckRhs(2,2) ;
-  CheckLhs(0,1) ;
-
-
-  GetRhsVar( 1,GRAPHICAL_HANDLE_DATATYPE, &handleRow, &handleCol, &handleStkIndex );
-  nbHandle = handleRow * handleCol ;
-  GetRhsVar( 2,GRAPHICAL_HANDLE_DATATYPE, &parentRow, &parentCol, &parentStkIndex );
-
-  if(parentCol * parentRow != 1)
-  {
-    Scierror(999,_("%s: Handles must be relocated under a single parent.\n"),fname);
+    SciErr sciErr;
+
+    int* piAddrhandleStkIndex = NULL;
+    long long* handleStkIndex = NULL;
+    int* piAddrparentStkIndex = NULL;
+    long long* parentStkIndex = NULL;
+    long long* outIndex = NULL;
+
+    int handleCol  = 0;
+    int handleRow = 0;
+    int nbHandle = 0;
+    int parentCol = 0;
+    int parentRow = 0;
+    int i = 0;
+
+    long children = 0 ;
+    char* childrenID = NULL;
+    long parent = 0 ;
+    char* parentID = NULL;
+
+    /* the function should be called with relocate_handle( handle, parent_handle ) */
+    CheckInputArgument(pvApiCtx, 2, 2) ;
+    CheckOutputArgument(pvApiCtx, 0, 1) ;
+
+
+    sciErr = getVarAddressFromPosition(pvApiCtx,  1, &piAddrhandleStkIndex);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of handle at position  1.
+    sciErr = getMatrixOfHandle(pvApiCtx, piAddrhandleStkIndex, &handleRow, &handleCol, &handleStkIndex);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname,  1);
+        return 1;
+    }
+
+    nbHandle = handleRow * handleCol ;
+    sciErr = getVarAddressFromPosition(pvApiCtx,  2, &piAddrparentStkIndex);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of handle at position  2.
+    sciErr = getMatrixOfHandle(pvApiCtx, piAddrparentStkIndex, &parentRow, &parentCol, &parentStkIndex);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname,  2);
+        return 1;
+    }
+
+
+    if (parentCol * parentRow != 1)
+    {
+        Scierror(999, _("%s: Handles must be relocated under a single parent.\n"), fname);
+        return 0 ;
+    }
+
+    parent = (long) * (parentStkIndex);
+    parentID = (char*)getObjectFromHandle(parent);
+
+    for (i = 0; i < nbHandle; i++)
+    {
+        children = (long)handleStkIndex[i];
+        childrenID = (char*)getObjectFromHandle(children);
+        setGraphicObjectRelationship(parentID, childrenID);
+    }
+
+    sciErr = allocMatrixOfHandle(pvApiCtx,  nbInputArgument(pvApiCtx) + 1, handleCol, handleRow, &outIndex);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), fname);
+        return 1;
+    }
+
+    *(outIndex) = *(handleStkIndex) ;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1 ;
+    ReturnArguments(pvApiCtx);
     return 0 ;
-  }
-
-  parent = (long) *hstk(parentStkIndex);
-  parentID = (char*)getObjectFromHandle(parent);
-
-  for(i = 0; i < nbHandle; i++)
-  {
-    children = (long) *hstk( handleStkIndex + i );
-    childrenID = (char*)getObjectFromHandle(children);
-    setGraphicObjectRelationship(parentID, childrenID);
-  }
-
-  CreateVar( Rhs + 1,GRAPHICAL_HANDLE_DATATYPE, &handleCol, &handleRow, &outIndex );
-  *hstk(outIndex) = *hstk(handleStkIndex) ;
-  LhsVar(1) = Rhs + 1 ;
-  PutLhsVar();
-  return 0 ;
 
 }
 /*--------------------------------------------------------------------------*/
index 2da5c22..3f1ed8b 100644 (file)
@@ -1,3 +1,4 @@
+
 /*
 * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
 * Copyright (C) 2006 - INRIA - Fabrice Leray
 #include "getPropertyAssignedValue.h"
 #include "getGraphicObjectProperty.h"
 /*--------------------------------------------------------------------------*/
-int sci_rotate_axes(char *fname,unsigned long fname_len)
+int sci_rotate_axes(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddrstackPointer = NULL;
+    long long* stackPointer = NULL;
+
     int nbRow = 0;
     int nbCol = 0;
-    size_t stackPointer = 0;
 
     char* pstrUID = NULL;
     int iType = -1;
     int *piType = &iType;
 
     /* check size of input and output */
-    CheckRhs(0,1);
-    CheckLhs(0,1);
+    CheckInputArgument(pvApiCtx, 0, 1);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
-    if(Rhs == 0)
+    if (nbInputArgument(pvApiCtx) == 0)
     {
         pstrUID = (char*)getCurrentFigure();
     }
     else
     {
         /* Get figure or subwin handle */
-        if (GetType(1) != sci_handles)
+        if ((!checkInputArgumentType(pvApiCtx, 1, sci_handles)))
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: Single Figure or Axes handle expected.\n"), fname, 1);
             return -1;
         }
 
-        GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stackPointer);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstackPointer);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of handle at position 1.
+        sciErr = getMatrixOfHandle(pvApiCtx, piAddrstackPointer, &nbRow, &nbCol, &stackPointer);
+        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)
         {
@@ -64,7 +84,7 @@ int sci_rotate_axes(char *fname,unsigned long fname_len)
             return -1;
         }
 
-        pstrUID = (char*)getObjectFromHandle(getHandleFromStack(stackPointer));
+        pstrUID = (char*)getObjectFromHandle((long int) * stackPointer);
 
         getGraphicObjectProperty(pstrUID, __GO_TYPE__, jni_int, (void **)&piType);
         if (iType == __GO_AXES__)
@@ -75,14 +95,14 @@ int sci_rotate_axes(char *fname,unsigned long fname_len)
 
     if (pstrUID == NULL)
     {
-        Scierror(999,_("%s: The handle is not or no more valid.\n"),fname);
+        Scierror(999, _("%s: The handle is not or no more valid.\n"), fname);
         return -1;
     }
 
     setGraphicObjectProperty(pstrUID, __GO_INFO_MESSAGE__, "Right click and drag to rotate.", jni_string, 1);
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
 
     return 0;
 }
index 1ff3d47..2b4b034 100644 (file)
@@ -17,7 +17,7 @@
 /* desc : interface for rubberbox routine                                 */
 /*------------------------------------------------------------------------*/
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "getPropertyAssignedValue.h"
 #include "Scierror.h"
@@ -35,15 +35,33 @@ static int returnRectAndButton(const double *_piJavaValues, int _iSelectedRectSi
 /*--------------------------------------------------------------------------*/
 static int getInitialRectangle(double initRect[4])
 {
+    SciErr sciErr;
     int rectNbRow = 0;
     int rectNbCol = 0;
-    int rectStackPointer = 0;
     int i = 0;
     int nbDims = 0;
     double * rect = NULL;
 
     /* Initial rect is always in first position */
-    GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &rectNbRow, &rectNbCol, &rectStackPointer);
+    //get variable address
+    int* piAddr1 = NULL;
+    double* rectStackPointer = NULL;
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddr1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 1.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddr1, &rectNbRow, &rectNbCol, &rectStackPointer);
+    if (sciErr.iErr)
+    {
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), "rubberbox", 1);
+        printError(&sciErr, 0);
+        return 1;
+    }
+
 
     /* We have found a matrix of double within the parameters check its dims */
     nbDims = rectNbCol * rectNbRow;
@@ -55,7 +73,7 @@ static int getInitialRectangle(double initRect[4])
 
 
     /* pointer on the stack */
-    rect = stk(rectStackPointer);
+    rect = (rectStackPointer);
 
     /* intialize to 0 */
     for (i = 0; i < 4; i++)
@@ -73,18 +91,36 @@ static int getInitialRectangle(double initRect[4])
 /*--------------------------------------------------------------------------*/
 static int getEditionMode(int rhsPos)
 {
-    int stackPointer = 0;
+    SciErr sciErr;
     int nbRow = 0;
     int nbCol = 0;
     BOOL isEditionModeOn = FALSE;
-    GetRhsVar(rhsPos, MATRIX_OF_BOOLEAN_DATATYPE, &nbRow, &nbCol, &stackPointer);
+    //get variable address
+    int* piAddrrhsPos = NULL;
+    int* stackPointer = NULL;
+    sciErr = getVarAddressFromPosition(pvApiCtx, rhsPos, &piAddrrhsPos);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of boolean at position rhsPos.
+    sciErr = getMatrixOfBoolean(pvApiCtx, piAddrrhsPos, &nbRow, &nbCol, &stackPointer);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: Boolean matrix expected.\n"), "rubberbox", rhsPos);
+        return 1;
+    }
+
 
     if (nbRow * nbCol != 1)
     {
         return -1;
     }
 
-    isEditionModeOn = *istk(stackPointer);
+    isEditionModeOn = *(stackPointer);
     if (isEditionModeOn)
     {
         return 1;
@@ -98,55 +134,82 @@ static int getEditionMode(int rhsPos)
 /*--------------------------------------------------------------------------*/
 static int returnRectAndButton(const double *_piJavaValues, int _iSelectedRectSize)
 {
+    SciErr sciErr;
     int zero = 0;
     int one = 1;
-    int rectStackPointer = 0;
     int i = 0;
     int j = 0;
+    double* rectStackPointer = NULL;
 
     // button < 0 means user cancelled selection so return [] or [], []
     if (_piJavaValues[0] < 0)
     {
-        CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &zero, &zero, &rectStackPointer);
-        LhsVar(1) = Rhs + 1;
-        if (Lhs >= 2)
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, zero, zero, &rectStackPointer);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), "rubberbox");
+            return 1;
+        }
+
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+        if (nbOutputArgument(pvApiCtx) >= 2)
         {
-            CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &zero, &zero, &rectStackPointer);
-            LhsVar(2) = Rhs + 2;
+            sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, zero, zero, &rectStackPointer);
+            if (sciErr.iErr)
+            {
+                printError(&sciErr, 0);
+                Scierror(999, _("%s: Memory allocation error.\n"), "rubberbox");
+                return 1;
+            }
+
+            AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
         }
-        PutLhsVar();
+        ReturnArguments(pvApiCtx);
         return 0;
     }
 
     /* return rectangle */
-    CreateVar(Rhs + 1, MATRIX_OF_DOUBLE_DATATYPE, &one, &_iSelectedRectSize, &rectStackPointer);
+    sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, one, _iSelectedRectSize, &rectStackPointer);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(999, _("%s: Memory allocation error.\n"), "rubberbox");
+        return 1;
+    }
+
     for ( i = 0; i < _iSelectedRectSize / 2; i++)
     {
         j = i + _iSelectedRectSize / 2;
-        stk(rectStackPointer)[i] = _piJavaValues[i + 1];
-        stk(rectStackPointer)[j] = _piJavaValues[i + 4];
+        (rectStackPointer)[i] = _piJavaValues[i + 1];
+        (rectStackPointer)[j] = _piJavaValues[i + 4];
     }
-    LhsVar(1) = Rhs + 1;
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
 
     /* return button */
-    if (Lhs >= 2)
+    if (nbOutputArgument(pvApiCtx) >= 2)
     {
-        int buttonStackPointer = 0;
-        CreateVar(Rhs + 2, MATRIX_OF_DOUBLE_DATATYPE, &one, &one, &buttonStackPointer);
-        *stk(buttonStackPointer) = _piJavaValues[0];
-        LhsVar(2) = Rhs + 2;
+        double* buttonStackPointer = NULL;
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, one, one, &buttonStackPointer);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), "rubberbox");
+            return 1;
+        }
+
+        *(buttonStackPointer) = _piJavaValues[0];
+        AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
     }
 
-    PutLhsVar();
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 /*--------------------------------------------------------------------------*/
 int sci_rubberbox(char * fname, unsigned long fname_len)
 {
-
     /* [final_rect, btn] = rubberbox([initial_rect],[edition_mode]) */
 
-    int button = 0;
     double initialRect[4] = {0.0, 0.0, 0.0, 0.0};
     int initialRectSize = 0;
 
@@ -158,20 +221,20 @@ int sci_rubberbox(char * fname, unsigned long fname_len)
 
     BOOL bClickMode = TRUE;
 
-    CheckRhs(0, 2);
-    CheckLhs(1, 2);
+    CheckInputArgument(pvApiCtx, 0, 2);
+    CheckOutputArgument(pvApiCtx, 1, 2);
     // iView == 1 => 2D
     // else 3D
     getGraphicObjectProperty(pSubwinUID, __GO_VIEW__, jni_int, (void**)&piView);
     getGraphicObjectProperty(pSubwinUID, __GO_PARENT__, jni_string, (void **)&pFigureUID);
 
-    if (Rhs == 0)
+    if (nbInputArgument(pvApiCtx) == 0)
     {
         /* rubberbox() */
         bClickMode = TRUE;
         initialRectSize = 0;
     }
-    else if (Rhs == 1)
+    else if (nbInputArgument(pvApiCtx) == 1)
     {
         // Check we are running 2D view rubberbox,
         // Otherwise initial_rect and edition_mode are not usable.
@@ -181,7 +244,7 @@ int sci_rubberbox(char * fname, unsigned long fname_len)
             return -1;
         }
         /* rubberbox(initial_rect) or rubberbox(edition_mode) */
-        if (GetType(1) == sci_matrix)
+        if (checkInputArgumentType(pvApiCtx, 1, sci_matrix))
         {
             /* rubberbox(initial_rect) */
             if (getInitialRectangle(initialRect) == 1)
@@ -195,7 +258,7 @@ int sci_rubberbox(char * fname, unsigned long fname_len)
                 return -1;
             }
         }
-        else if (GetType(1) == sci_boolean)
+        else if (checkInputArgumentType(pvApiCtx, 1, sci_boolean))
         {
             /* rubberbox(editionMode) */
             int editionModeStatus = getEditionMode(1);
@@ -223,7 +286,7 @@ int sci_rubberbox(char * fname, unsigned long fname_len)
             return -1;
         }
     }
-    else if (Rhs == 2)
+    else if (nbInputArgument(pvApiCtx) == 2)
     {
         /* rubberbox(initial_rect, edition_mode) */
 
@@ -239,13 +302,13 @@ int sci_rubberbox(char * fname, unsigned long fname_len)
             return -1;
         }
 
-        if (GetType(1) != sci_matrix)
+        if ((!checkInputArgumentType(pvApiCtx, 1, sci_matrix)))
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: Real row vector expected.\n"), fname, 1);
             return -1;
         }
 
-        if (GetType(2) != sci_boolean)
+        if ((!checkInputArgumentType(pvApiCtx, 2, sci_boolean)))
         {
             Scierror(999, _("%s: Wrong type for input argument #%d: A boolean expected.\n"), fname, 2);
             return -1;
index 59c0929..0f8bf54 100644 (file)
@@ -48,7 +48,7 @@ static int sciSet(void* _pvCtx, char *pobjUID, char *marker, size_t * value, int
 }
 
 /*--------------------------------------------------------------------------*/
-
+//for YaSp => modify all "set properties" function (use stack pointer : value)
 /*-----------------------------------------------------------
  * sciset(choice-name,x1,x2,x3,x4,x5)
  * or   xset()
index 5bb8403..8ff3d0c 100644 (file)
@@ -21,7 +21,7 @@
 #include "gw_graphics.h"
 #include "getPropertyAssignedValue.h"
 #include "HandleManagement.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "Scierror.h"
 #include "SetProperty.h"
 #include "GetProperty.h"
 /*--------------------------------------------------------------------------*/
 int sci_show_window( char *fname, unsigned long fname_len )
 {
+    SciErr sciErr;
+
+    int* piAddrstackPointer = NULL;
+    long long* llstackPointer = NULL;
+    double* pdblstackPointer = NULL;
+
     char* pFigureUID = NULL;
     char* pstrAxesUID = NULL;
 
-    CheckRhs(0, 1);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 0, 1);
+    CheckOutputArgument(pvApiCtx, 0, 1);
 
-    if ( Rhs == 1 )
+    if ( nbInputArgument(pvApiCtx) == 1 )
     {
         /* the window to show is specified */
-        int paramType    = VarType(1);
+        int paramType    = getInputArgumentType(pvApiCtx, 1);
         int nbRow        = 0 ;
         int nbCol        = 0 ;
-        size_t stackPointer = 0 ;
+
         int type = -1;
         int *piType = &type;
 
+        sciErr = getVarAddressFromPosition(pvApiCtx,  1, &piAddrstackPointer);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
         if ( ( paramType == sci_handles ) )
         {
             /* by tis handle */
-            GetRhsVar( 1, GRAPHICAL_HANDLE_DATATYPE, &nbRow, &nbCol, &stackPointer );
+            // Retrieve a matrix of handle at position  1.
+            sciErr = getMatrixOfHandle(pvApiCtx, piAddrstackPointer, &nbRow, &nbCol, &llstackPointer);
+            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 )
             {
@@ -65,7 +86,7 @@ int sci_show_window( char *fname, unsigned long fname_len )
                 return -1 ;
             }
 
-            pFigureUID = (char*)getObjectFromHandle( getHandleFromStack(stackPointer) );
+            pFigureUID = (char*)getObjectFromHandle((long int)(*llstackPointer));
 
             if (pFigureUID == NULL)
             {
@@ -85,13 +106,21 @@ int sci_show_window( char *fname, unsigned long fname_len )
         {
             /* by its number */
             int winNum = 0;
-            GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &nbRow, &nbCol, &stackPointer );
+            // Retrieve a matrix of double at position 1.
+            sciErr = getMatrixOfDouble(pvApiCtx, piAddrstackPointer, &nbRow, &nbCol, &pdblstackPointer);
+            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 '%s' handle or a real scalar expected.\n"), fname, 1, "Figure");
                 return -1 ;
             }
-            winNum = (int) * (stk(stackPointer));
+            winNum = (int) * pdblstackPointer;
             pFigureUID = (char*)getFigureFromIndex(winNum);
 
             if (pFigureUID == NULL)
@@ -100,7 +129,7 @@ int sci_show_window( char *fname, unsigned long fname_len )
                 setGraphicObjectProperty(pFigureUID, __GO_ID__, &winNum, jni_int, 1);
                 setCurrentFigure(pFigureUID);
 
-                getGraphicObjectProperty(pFigureUID, __GO_SELECTED_CHILD__, jni_string,  &pstrAxesUID);
+                getGraphicObjectProperty(pFigureUID, __GO_SELECTED_CHILD__, jni_string,  (void**)&pstrAxesUID);
                 setCurrentSubWin(pstrAxesUID);
             }
         }
@@ -112,7 +141,7 @@ int sci_show_window( char *fname, unsigned long fname_len )
     }
     else
     {
-        /* Rhs == 0 */
+        /* nbInputArgument(pvApiCtx) == 0 */
         /* raise current figure */
         getOrCreateDefaultSubwin();
         pFigureUID = (char*)getCurrentFigure();
@@ -128,8 +157,8 @@ int sci_show_window( char *fname, unsigned long fname_len )
     /* Actually show the window */
     showWindow(pFigureUID);
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
 
     return 0;
 }
index f79537e..07c651e 100644 (file)
@@ -16,7 +16,7 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "HandleManagement.h"
 #include "localization.h"
 #include "Scierror.h"
 /*--------------------------------------------------------------------------*/
 int sci_swap_handles( char * fname, unsigned long fname_len )
 {
-  int firstHdlCol = 0;
-  int firstHdlRow = 0;
-  int secondHdlCol = 0;
-  int secondHdlRow = 0;
-  int firstHdlStkIndex = 0;
-  int secondHdlStkIndex = 0;
-  char *pstHandle_1 = NULL;
-  char *pstHandle_2 = NULL;
-  char *pstParent_1 = NULL;
-  char *pstParent_2 = NULL;
-  int iChildrenCount = 0;
-  int *piChildrenCount = &iChildrenCount;
-  char **pstChildrenUID = NULL;
-  int i = 0;
-  long h = 0;
-
-  CheckRhs( 2, 2 ) ;
-  CheckLhs( 0, 1 ) ;
-
-  GetRhsVar( 1,GRAPHICAL_HANDLE_DATATYPE, &firstHdlRow, &firstHdlCol, &firstHdlStkIndex );
-  GetRhsVar( 2,GRAPHICAL_HANDLE_DATATYPE, &secondHdlRow, &secondHdlCol, &secondHdlStkIndex );
-
-  if ( firstHdlRow * firstHdlCol != 1 || secondHdlRow * secondHdlCol != 1 )
-  {
-    Scierror(999,_("%s: Routine can only swap two single handles.\n"),fname);
+    SciErr sciErr;
+
+    int* piAddrfirstHdlStkIndex = NULL;
+    long long* firstHdlStkIndex = NULL;
+    int* piAddrsecondHdlStkIndex = NULL;
+    long long* secondHdlStkIndex = NULL;
+
+    int firstHdlCol = 0;
+    int firstHdlRow = 0;
+    int secondHdlCol = 0;
+    int secondHdlRow = 0;
+    char *pstHandle_1 = NULL;
+    char *pstHandle_2 = NULL;
+    char *pstParent_1 = NULL;
+    char *pstParent_2 = NULL;
+    int iChildrenCount = 0;
+    int *piChildrenCount = &iChildrenCount;
+    char **pstChildrenUID = NULL;
+    int i = 0;
+    long h = 0;
+
+    CheckInputArgument(pvApiCtx,  2, 2 ) ;
+    CheckOutputArgument(pvApiCtx,  0, 1 ) ;
+
+    sciErr = getVarAddressFromPosition(pvApiCtx,  1, &piAddrfirstHdlStkIndex);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of handle at position  1.
+    sciErr = getMatrixOfHandle(pvApiCtx, piAddrfirstHdlStkIndex, &firstHdlRow, &firstHdlCol, &firstHdlStkIndex);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname,  1);
+        return 1;
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx,  2, &piAddrsecondHdlStkIndex);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of handle at position  2.
+    sciErr = getMatrixOfHandle(pvApiCtx, piAddrsecondHdlStkIndex, &secondHdlRow, &secondHdlCol, &secondHdlStkIndex);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname,  2);
+        return 1;
+    }
+
+
+    if ( firstHdlRow * firstHdlCol != 1 || secondHdlRow * secondHdlCol != 1 )
+    {
+        Scierror(999, _("%s: Routine can only swap two single handles.\n"), fname);
+        return 0 ;
+    }
+
+    /* get the two handles and swap them */
+    h = (long) * (firstHdlStkIndex);
+    pstHandle_1 = (char*)getObjectFromHandle(h);
+
+    h = (long) * (secondHdlStkIndex);
+    pstHandle_2 = (char*)getObjectFromHandle(h);
+
+    getGraphicObjectProperty(pstHandle_1, __GO_PARENT__, jni_string, (void **)&pstParent_1);
+    getGraphicObjectProperty(pstHandle_2, __GO_PARENT__, jni_string, (void **)&pstParent_2);
+
+    // Check if objects do not have the same parent
+    if (strcmp(pstParent_1, pstParent_2) == 0)
+    {
+        getGraphicObjectProperty(pstParent_1, __GO_CHILDREN_COUNT__, jni_int, (void **)&piChildrenCount);
+        getGraphicObjectProperty(pstParent_1, __GO_CHILDREN__, jni_string_vector, (void **)&pstChildrenUID);
+
+        for (i = 0 ; i < iChildrenCount ; ++i)
+        {
+            if (strcmp(pstChildrenUID[i], pstHandle_1) == 0)
+            {
+                pstChildrenUID[i] = pstHandle_2;
+            }
+            else if (strcmp(pstChildrenUID[i], pstHandle_2) == 0)
+            {
+                pstChildrenUID[i] = pstHandle_1;
+            }
+        }
+
+        setGraphicObjectProperty(pstParent_1, __GO_CHILDREN__, pstChildrenUID, jni_string_vector, iChildrenCount);
+
+    }
+    else
+    {
+        setGraphicObjectRelationship(pstParent_1, pstHandle_2);
+        setGraphicObjectRelationship(pstParent_2, pstHandle_1);
+    }
+    AssignOutputVariable(pvApiCtx, 1) = 0 ;
+    ReturnArguments(pvApiCtx);
     return 0 ;
-  }
-
-  /* get the two handles and swap them */
-  h = (long)*hstk(firstHdlStkIndex);
-  pstHandle_1 = (char*)getObjectFromHandle(h);
-
-  h = (long)*hstk(secondHdlStkIndex);
-  pstHandle_2 = (char*)getObjectFromHandle(h);
-
-  getGraphicObjectProperty(pstHandle_1, __GO_PARENT__, jni_string, (void **)&pstParent_1);
-  getGraphicObjectProperty(pstHandle_2, __GO_PARENT__, jni_string, (void **)&pstParent_2);
-
-  // Check if objects do not have the same parent
-  if (strcmp(pstParent_1, pstParent_2) == 0)
-  {
-      getGraphicObjectProperty(pstParent_1, __GO_CHILDREN_COUNT__, jni_int, (void **)&piChildrenCount);
-      getGraphicObjectProperty(pstParent_1, __GO_CHILDREN__, jni_string_vector, (void **)&pstChildrenUID);
-
-      for (i = 0 ; i < iChildrenCount ; ++i)
-      {
-          if (strcmp(pstChildrenUID[i], pstHandle_1) == 0)
-          {
-              pstChildrenUID[i] = pstHandle_2;
-          }
-          else if (strcmp(pstChildrenUID[i], pstHandle_2) == 0)
-          {
-              pstChildrenUID[i] = pstHandle_1;
-          }
-      }
-
-      setGraphicObjectProperty(pstParent_1, __GO_CHILDREN__, pstChildrenUID, jni_string_vector, iChildrenCount);
-
-  }
-  else
-  {
-      setGraphicObjectRelationship(pstParent_1, pstHandle_2);
-      setGraphicObjectRelationship(pstParent_2, pstHandle_1);
-  }
-  LhsVar(1) = 0 ;
-  PutLhsVar();
-  return 0 ;
 }
 /*--------------------------------------------------------------------------*/
index 45430e2..43584a2 100644 (file)
@@ -20,7 +20,7 @@
 #include <stdlib.h>
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "GetProperty.h"
 #include "DestroyObjects.h"
 #include "localization.h"
 #include "graphicObjectProperties.h"
 #include "deleteGraphicObject.h"
 /*--------------------------------------------------------------------------*/
-int sci_unglue(char *fname,unsigned long fname_len)
+int sci_unglue(char *fname, unsigned long fname_len)
 {
-    int m1 = 0,n1 = 0,l1 = 0;
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    long long* l1 = NULL;
+
+    int m1 = 0, n1 = 0;
     unsigned long hdl = 0;
-    int outindex = 0, i = 0;
+    int i = 0;
+    long long* outindex = NULL;
 
-    int iOne = 1;
     char *pobjUID = NULL;
     int iObjectType = -1;
     int *piObjectType = &iObjectType;
@@ -47,23 +52,38 @@ int sci_unglue(char *fname,unsigned long fname_len)
     int iChildrenCount = 0;
     int *piChildrenCount = &iChildrenCount;
 
-    CheckRhs(1, 1);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 1, 1);
+    CheckOutputArgument(pvApiCtx, 0, 1);
     /*  set or create a graphic window */
-    GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &m1, &n1, &l1);
-    hdl = (unsigned long)*hstk(l1);
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of handle at position 1.
+    sciErr = getMatrixOfHandle(pvApiCtx, piAddrl1, &m1, &n1, &l1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+        return 1;
+    }
+
+    hdl = (unsigned long) * (l1);
 
     pobjUID = (char*)getObjectFromHandle(hdl);
 
     if (pobjUID == NULL)
     {
-        Scierror(999,_("%s: The handle is not or no more valid.\n"),fname);
+        Scierror(999, _("%s: The handle is not or no more valid.\n"), fname);
         return 0;
     }
 
     getGraphicObjectProperty(pobjUID, __GO_TYPE__, jni_int, (void **)&piObjectType);
 
-    if (piObjectType != -1 && iObjectType == __GO_COMPOUND__)
+    if (iObjectType != -1 && iObjectType == __GO_COMPOUND__)
     {
         // Retrieve number of children.
         getGraphicObjectProperty(pobjUID, __GO_CHILDREN_COUNT__, jni_int, (void **) &piChildrenCount);
@@ -74,26 +94,32 @@ int sci_unglue(char *fname,unsigned long fname_len)
         // Retrieve Compound Parent.
         getGraphicObjectProperty(pobjUID, __GO_PARENT__, jni_string, (void **)&pstParentUID);
 
-        CreateVar(Rhs+1, GRAPHICAL_HANDLE_DATATYPE, piChildrenCount, &iOne, &outindex);
+        sciErr = allocMatrixOfHandle(pvApiCtx, nbInputArgument(pvApiCtx) + 1, *piChildrenCount, 1, &outindex); /* We get the scalar value if it is ones */
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+            return 1;
+        }
 
         for (i = 0 ; i < iChildrenCount ; ++i)
         {
-            hstk(outindex)[i] = getHandle(pstChildrenUID[i]);
+            outindex[i] = getHandle(pstChildrenUID[i]);
             /*
              * Register Child to its new parent.
              * Children are added from the last to the first to obtain the same ordering
              * as the previous one (insertion is done at the head of the list).
              */
-            setGraphicObjectRelationship(pstParentUID, pstChildrenUID[iChildrenCount-i-1]);
+            setGraphicObjectRelationship(pstParentUID, pstChildrenUID[iChildrenCount - i - 1]);
         }
 
         deleteGraphicObject(pobjUID);
-        LhsVar(1) = Rhs + 1;
-        PutLhsVar();
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+        ReturnArguments(pvApiCtx);
     }
     else
     {
-        Scierror(999,_("%s: Object must be a Compound.\n"),fname);
+        Scierror(999, _("%s: Object must be a Compound.\n"), fname);
     }
     return 0;
 }
index d767d30..5aa3b49 100644 (file)
@@ -18,7 +18,7 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "GetProperty.h"
 #include "MALLOC.h"
 #include "axesScale.h"
 #include "getGraphicObjectProperty.h"
 
 /*--------------------------------------------------------------------------*/
-int sci_unzoom(char *fname,unsigned long fname_len)
+int sci_unzoom(char *fname, unsigned long fname_len)
 {
-  /* number of object to unzoom */
-  int nbObjects = 0;
+    SciErr sciErr;
 
-  /* ids of object to unzoom */
-  char** objectsId = NULL;
+    int* piAddrstackPointer = NULL;
+    long long* stackPointer = NULL;
 
-  char* objectUID = NULL;
+    /* number of object to unzoom */
+    int nbObjects = 0;
 
-  /* object type */
-  int iType = -1;
-  int *piType = &iType;
+    /* object type */
+    int iType = -1;
+    int *piType = &iType;
 
-  CheckRhs(0,1) ;
-  CheckLhs(0,1) ;
-  if ( Rhs == 0 )
-  {
-    objectUID = (char*)getCurrentFigure();
-    if (objectUID != NULL)
-    {
-      sciUnzoomFigure(objectUID);
-    }
-  }
-  else
-  {
-    int m = 0,n = 0,i = 0;
-    size_t stackPointer = 0;
-    GetRhsVar(1, GRAPHICAL_HANDLE_DATATYPE, &m, &n, &stackPointer);
+    /* ids of object to unzoom */
+    char** objectsId = NULL;
+    char* objectUID = NULL;
 
-    nbObjects = m * n;
-    objectsId = MALLOC(nbObjects * sizeof(char*));
-    if (objectsId == NULL)
+    CheckInputArgument(pvApiCtx, 0, 1) ;
+    CheckOutputArgument(pvApiCtx, 0, 1) ;
+    if ( nbInputArgument(pvApiCtx) == 0 )
     {
-      Scierror(999, _("%s: No more memory.\n"),fname);
-      return -1;
+        objectUID = (char*)getCurrentFigure();
+        if (objectUID != NULL)
+        {
+            sciUnzoomFigure(objectUID);
+        }
     }
-
-    /* first pass, check that all the handles are subwindows or figures */
-    /* and copy them into an array of objects */
-    for (i = 0; i < nbObjects; i++ )
+    else
     {
-      objectUID = (char*)getObjectFromHandle(getHandleFromStack(stackPointer + i));
-      getGraphicObjectProperty(objectUID, __GO_TYPE__, jni_int, (void **) &piType);
-      if (iType != __GO_FIGURE__ && iType != __GO_AXES__)
-      {
-        FREE(objectsId);
-        Scierror(999, _("%s: Wrong type for input argument: Vector of Axes and Figure handles expected.\n"),fname);
-        return -1;
-      }
-      objectsId[i] = objectUID;
-    }
+        int m = 0, n = 0, i = 0;
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrstackPointer);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
 
-    /* second pass un zoom the objects */
-    sciUnzoomArray(objectsId, nbObjects);
+        // Retrieve a matrix of handle at position 1.
+        sciErr = getMatrixOfHandle(pvApiCtx, piAddrstackPointer, &m, &n, &stackPointer);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: Handle matrix expected.\n"), fname, 1);
+            return 1;
+        }
 
-    FREE(objectsId);
-  }
+        nbObjects = m * n;
+        objectsId = MALLOC(nbObjects * sizeof(char*));
+        if (objectsId == NULL)
+        {
+            Scierror(999, _("%s: No more memory.\n"), fname);
+            return -1;
+        }
+
+        /* first pass, check that all the handles are subwindows or figures */
+        /* and copy them into an array of objects */
+        for (i = 0; i < nbObjects; i++ )
+        {
+            objectUID = (char*)getObjectFromHandle((long int)stackPointer[i]);
+            getGraphicObjectProperty(objectUID, __GO_TYPE__, jni_string, (void **) &piType);
+            if (iType != __GO_FIGURE__ && iType != __GO_AXES__)
+            {
+                FREE(objectsId);
+                Scierror(999, _("%s: Wrong type for input argument: Vector of Axes and Figure handles expected.\n"), fname);
+                return -1;
+            }
+            objectsId[i] = objectUID;
+        }
+
+        /* second pass un zoom the objects */
+        sciUnzoomArray(objectsId, nbObjects);
+        FREE(objectsId);
+    }
 
 
-  LhsVar(1)=0;
-  PutLhsVar();
-  return 0;
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 09d4b16..4219ae7 100644 (file)
 /* file: sci_winsid.c                                                     */
 /* desc : interface for winsid routine                                    */
 /*------------------------------------------------------------------------*/
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "gw_graphics.h"
 #include "MALLOC.h"
 #include "FigureList.h"
 #include "Scierror.h"
 #include "returnProperty.h"
 #include "localization.h"
-#include "api_scilab.h"
+
 /*--------------------------------------------------------------------------*/
-int sci_winsid(char *fname,unsigned long fname_len)
+int sci_winsid(char *fname, unsigned long fname_len)
 {
-  int status = 0;
-  int nbFigure = sciGetNbFigure();
-  CheckRhs(-1,0);
+    int status = 0;
+    int nbFigure = sciGetNbFigure();
+    CheckInputArgument(pvApiCtx, -1, 0);
 
-  if (nbFigure <= 0)
-  {
-    /* There is no figure */
-    status = sciReturnEmptyMatrix(pvApiCtx);
-  }
-  else
-  {
-    int * ids = (int*)MALLOC(nbFigure * sizeof(int));
-    if (ids == NULL)
+    if (nbFigure <= 0)
     {
-      Scierror(999, _("%s: No more memory.\n"),fname);
-      return 0;
+        /* There is no figure */
+        status = sciReturnEmptyMatrix(pvApiCtx);
     }
-    sciGetFiguresId(ids);
+    else
+    {
+        int * ids = (int*)MALLOC(nbFigure * sizeof(int));
+        if (ids == NULL)
+        {
+            Scierror(999, _("%s: No more memory.\n"), fname);
+            return 0;
+        }
+        sciGetFiguresId(ids);
 
-    status = sciReturnRowIntVector(pvApiCtx, ids, nbFigure);
-    FREE(ids);
-  }
-  LhsVar(1) = Rhs+1;
-  PutLhsVar();
-  return status;
+        status = sciReturnRowIntVector(pvApiCtx, ids, nbFigure);
+        FREE(ids);
+    }
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    ReturnArguments(pvApiCtx);
+    return status;
 }
 /*--------------------------------------------------------------------------*/
index 797848a..e2e201f 100644 (file)
@@ -20,7 +20,9 @@
 #include "gw_graphics.h"
 #include "sciCall.h"
 #include "GetProperty.h"
-#include "stack-c.h"
+#include "api_scilab.h"
+#include "Scierror.h"
+#include "localization.h"
 
 #include "graphicObjectProperties.h"
 #include "getGraphicObjectProperty.h"
 #include "BuildObjects.h"
 
 /*--------------------------------------------------------------------------*/
-int sci_xarc(char *fname,unsigned long fname_len)
+int sci_xarc(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    double* l1 = NULL;
+    int* piAddrl2 = NULL;
+    double* l2 = NULL;
+    int* piAddrl3 = NULL;
+    double* l3 = NULL;
+    int* piAddrl4 = NULL;
+    double* l4 = NULL;
+    int* piAddr5 = NULL;
+    int* l5 = NULL;
+    int* piAddr6 = NULL;
+    int* l6 = NULL;
+
     char* psubwinUID = NULL;
-    int m1 = 0,n1 = 0,l1 = 0,l2 = 0,l3 = 0,l4 = 0,l5 = 0,l6 = 0;
+    int m1 = 0, n1 = 0;
     long hdl = 0;
     int curcolor = 0;
     int *piCurColor = &curcolor;
@@ -39,32 +56,164 @@ int sci_xarc(char *fname,unsigned long fname_len)
     double angle2 = 0.0;
 
 
-    CheckRhs(6,6);
-    GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);CheckScalar(1,m1,n1);
-    GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l2);CheckScalar(2,m1,n1);
-    GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l3);CheckScalar(3,m1,n1);
-    GetRhsVar(4,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l4);CheckScalar(4,m1,n1);
-    GetRhsVar(5,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l5);CheckScalar(5,m1,n1);
-    GetRhsVar(6,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l6);CheckScalar(6,m1,n1);
+    CheckInputArgument(pvApiCtx, 6, 6);
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 1.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+        return 1;
+    }
+
+    //CheckScalar
+    if (m1 != 1 || n1 != 1)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 1);
+        return 1;
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m1, &n1, &l2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        return 1;
+    }
+
+    //CheckScalar
+    if (m1 != 1 || n1 != 1)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 2);
+        return 1;
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 3.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl3, &m1, &n1, &l3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+        return 1;
+    }
+
+    //CheckScalar
+    if (m1 != 1 || n1 != 1)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 3);
+        return 1;
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddrl4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 4.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl4, &m1, &n1, &l4);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
+        return 1;
+    }
+
+    //CheckScalar
+    if (m1 != 1 || n1 != 1)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 4);
+        return 1;
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 5, &piAddr5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 5.
+    sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr5, &m1, &n1, &l5);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 5);
+        return 1;
+    }
+
+    //CheckScalar
+    if (m1 != 1 || n1 != 1)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 5);
+        return 1;
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 6, &piAddr6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 6.
+    sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr6, &m1, &n1, &l6);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 6);
+        return 1;
+    }
+
+    //CheckScalar
+    if (m1 != 1 || n1 != 1)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 6);
+        return 1;
+    }
+
 
-    angle1 = DEG2RAD(*istk(l5) / 64.0); /* convert to radian */
-    angle2 = DEG2RAD(*istk(l6) / 64.0);
+    angle1 = DEG2RAD(*(int*)(l5) / 64.0); /* convert to radian */
+    angle2 = DEG2RAD(*(int*)(l6) / 64.0);
 
     psubwinUID = (char*)getOrCreateDefaultSubwin();
 
     getGraphicObjectProperty(psubwinUID, __GO_LINE_COLOR__, jni_int, (void**)&piCurColor);
 
-    if ( strcmp(fname,"xarc") == 0 )
+    if ( strcmp(fname, "xarc") == 0 )
     {
-        Objarc (&angle1,&angle2,stk(l1),stk(l2),stk(l3),stk(l4),&curcolor,NULL,FALSE,TRUE,&hdl);
+        Objarc (&angle1, &angle2, (l1), (l2), (l3), (l4), &curcolor, NULL, FALSE, TRUE, &hdl);
     }
     else /* xfarc case */
     {
-        Objarc (&angle1,&angle2,stk(l1),stk(l2),stk(l3),stk(l4),NULL,&curcolor,TRUE,FALSE,&hdl);
+        Objarc (&angle1, &angle2, (l1), (l2), (l3), (l4), NULL, &curcolor, TRUE, FALSE, &hdl);
     }
 
-    LhsVar(1)=0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 /*--------------------------------------------------------------------------*/
index ef754af..67b3aff 100644 (file)
@@ -16,7 +16,7 @@
 /* file: sci_xarcs.h                                                       */
 /* desc : interface for xarcs routine                                      */
 /*------------------------------------------------------------------------*/
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "gw_graphics.h"
 #include "BuildObjects.h"
 #include "sciCall.h"
 /*--------------------------------------------------------------------------*/
 int sci_xarcs(char *fname, unsigned long fname_len)
 {
-    int m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0;
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    double* l1 = NULL;
+    int* piAddr2 = NULL;
+    int* l2 = NULL;
+
+    int m1 = 0, n1 = 0, m2 = 0, n2 = 0;
 
     long hdl = 0;
     int i = 0, i2 = 0;
@@ -42,9 +49,24 @@ int sci_xarcs(char *fname, unsigned long fname_len)
     int iCurrentSubWinForeground = 0;
     int *piCurrentSubWinForeground = &iCurrentSubWinForeground;
 
-    CheckRhs(1, 2);
+    CheckInputArgument(pvApiCtx, 1, 2);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 1.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
+    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_DOUBLE_DATATYPE, &m1, &n1, &l1);
     if (strcmp(fname, "xarcs") == 0)
     {
         if (m1 != 6)
@@ -64,10 +86,31 @@ int sci_xarcs(char *fname, unsigned long fname_len)
 
     pstCurrentSubWinUID = (char*)getOrCreateDefaultSubwin();
 
-    if (Rhs == 2)
+    if (nbInputArgument(pvApiCtx) == 2)
     {
-        GetRhsVar(2, MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);
-        CheckVector(2, m2, n2);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 2.
+        sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr2, &m2, &n2, &l2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+            return 1;
+        }
+
+        //CheckVector
+        if (m2 != 1 && n2 != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 2);
+            return 1;
+        }
+
         if (m2 * n2 != n1)
         {
             Scierror(999, _("%s: Wrong size for arguments #%d and #%d.\n"), fname, 1, 2);
@@ -78,20 +121,28 @@ int sci_xarcs(char *fname, unsigned long fname_len)
     {
         m2 = 1;
         n2 = n1;
-        CreateVar(2, MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);
+
+        sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, 2, m2, n2, &l2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
         getGraphicObjectProperty(pstCurrentSubWinUID, __GO_LINE_COLOR__, jni_int, (void **)&piCurrentSubWinForeground);
         for (i2 = 0; i2 < n2; ++i2)
         {
-            *istk(l2 + i2) = iCurrentSubWinForeground;
+            *(int*)(l2 + i2) = iCurrentSubWinForeground;
         }
     }
 
     for (i = 0; i < n1; ++i)
     {
-        angle1 = DEG2RAD(*stk(l1 + (6 * i) + 4) / 64.0);
-        angle2 = DEG2RAD(*stk(l1 + (6 * i) + 5) / 64.0);
-        Objarc(&angle1, &angle2, stk(l1 + (6 * i)), stk(l1 + (6 * i) + 1),
-               stk(l1 + (6 * i) + 2), stk(l1 + (6 * i) + 3), istk(l2 + i), NULL, FALSE, TRUE, &hdl);
+        angle1 = DEG2RAD(*(l1 + (6 * i) + 4) / 64.0);
+        angle2 = DEG2RAD(*(l1 + (6 * i) + 5) / 64.0);
+        Objarc(&angle1, &angle2, (l1 + (6 * i)), (l1 + (6 * i) + 1),
+               (l1 + (6 * i) + 2), (l1 + (6 * i) + 3), (int*)(l2 + i), NULL, FALSE, TRUE, &hdl);
     }
 
     /* construct Compound and make it current object */
@@ -101,8 +152,8 @@ int sci_xarcs(char *fname, unsigned long fname_len)
         releaseGraphicObjectProperty(__GO_PARENT__, o, jni_string, 1);
     }
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
 
     return 0;
 }
index f45f304..5514a8b 100644 (file)
 
 #include "gw_graphics.h"
 #include "sciCall.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "Scierror.h"
 #include "HandleManagement.h"
 #include "BuildObjects.h"
 /*--------------------------------------------------------------------------*/
-int sci_xarrows(char *fname,unsigned long fname_len)
+int sci_xarrows(char *fname, unsigned long fname_len)
 {
-    int dstyle = -1,m1 = 0,n1 = 0,l1 = 0,m2 = 0,n2 = 0,l2 = 0, m3 = 1, n3 = 1, l3 = 0;
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    double* l1 = NULL;
+    int* piAddrl2 = NULL;
+    double* l2 = NULL;
+    int* piAddrl3 = NULL;
+    double* l3 = NULL;
+    int* piAddr4 = NULL;
+    int* l4 = NULL;
+
+    int dstyle = -1, m1 = 0, n1 = 0, m2 = 0, n2 = 0, m3 = 1, n3 = 1;
     int *style = NULL, flag = 0;
-    int m4 = 0, n4 = 0, l4 = 0, mn2 = 0;
+    int m4 = 0, n4 = 0, mn2 = 0;
     double arsize = -1.0;
 
-    CheckRhs(2,4);
+    CheckInputArgument(pvApiCtx, 2, 4);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 1.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+        return 1;
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        return 1;
+    }
 
-    GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
-    GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m2,&n2,&l2);
     mn2 = m2 * n2;
-    CheckSameDims(1,2,m1,n1,m2,n2);
+    //CheckSameDims
+    if (m1 != m2 || n1 != n2)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
+        return 1;
+    }
+
     if (mn2 == 0)
     {
-        LhsVar(1)=0;
-        PutLhsVar();
-       return 0;
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
+        return 0;
     }
 
-    if (Rhs >= 3)
+    if (nbInputArgument(pvApiCtx) >= 3)
     {
-        GetRhsVar(3,MATRIX_OF_DOUBLE_DATATYPE,&m3,&n3,&l3);
-        CheckScalar(3,m3,n3);
-        arsize = *stk(l3);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl3);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 3.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrl3, &m3, &n3, &l3);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+            return 1;
+        }
+
+        //CheckScalar
+        if (m3 != 1 || n3 != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 3);
+            return 1;
+        }
+
+        arsize = *l3;
     }
 
-    if (Rhs >= 4)
+    if (nbInputArgument(pvApiCtx) >= 4)
     {
-        GetRhsVar(4,MATRIX_OF_INTEGER_DATATYPE,&m4,&n4,&l4); CheckVector(4,m4,n4);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 4, &piAddr4);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 4.
+        sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr4, &m4, &n4, &l4);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 4);
+            return 1;
+        }
+
+        //CheckVector
+        if (m4 != 1 && n4 != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 4);
+            return 1;
+        }
+
         if (m4 * n4 == 1)
         {
-            dstyle = *istk(l4);
+            dstyle = *(int*)(l4);
         }
         if (m4 * n4 != 1 && m2 * n2 / 2 != m4 * n4)
         {
-            Scierror(999,_("%s: Wrong size for input argument #%d: %d expected.\n"),fname, 4, m2 * n2 / 2 );
+            Scierror(999, _("%s: Wrong size for input argument #%d: %d expected.\n"), fname, 4, m2 * n2 / 2 );
             return 0;
         }
     }
     /* NG beg */
-    if (Rhs == 4 && m4 * n4 != 1)
+    if (nbInputArgument(pvApiCtx) == 4 && m4 * n4 != 1)
     {
-        style=istk(l4) ;
+        style = (int*)(l4) ;
         flag = 1 ;
     }
     else
@@ -78,10 +168,10 @@ int sci_xarrows(char *fname,unsigned long fname_len)
 
     getOrCreateDefaultSubwin();
 
-    Objsegs(style,flag,mn2,stk(l1),stk(l2),NULL,arsize);
+    Objsegs(style, flag, mn2, (l1), (l2), NULL, arsize);
 
-    LhsVar(1)=0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 /*--------------------------------------------------------------------------*/
index ab160d6..20cfaaf 100644 (file)
@@ -2,11 +2,11 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Fabrice Leray
  * Copyright (C) 2006 - INRIA - Jean-Baptiste Silvy
- * 
+ *
  * 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
  *
  */
@@ -17,7 +17,9 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
+#include "Scierror.h"
+#include "localization.h"
 #include "PloEch.h"
 
 #define VIEWING_RECT_SIZE 4
 /*--------------------------------------------------------------------------*/
 int sci_xchange( char * fname, unsigned long fname_len )
 {
-  int m1 = 0,n1 = 0,l1 = 0,m2 = 0,n2 = 0,l2 = 0,m3 = 0,n3 = 0,l3 = 0,l4 = 0,l5 = 0;
-  int four = VIEWING_RECT_SIZE ;
-  int one  = 1 ;
-  int * xPixCoords = NULL;
-  int * yPixCoords = NULL;
-  double * xCoords = NULL;
-  double * yCoords = NULL;
-  int viewingRect[VIEWING_RECT_SIZE];
-
-  CheckRhs(3,3);
-  CheckLhs(1,3);
-
-  GetRhsVar(3,STRING_DATATYPE,&m3,&n3,&l3);
-  
-
-  /* Convert coordinates */
-  if ( strcmp(cstk(l3),"i2f") == 0) 
-  {
-    GetRhsVar(1,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l1);
-    GetRhsVar(2,MATRIX_OF_INTEGER_DATATYPE,&m2,&n2,&l2);
-               CheckSameDims(1,2,m1,n1,m2,n2);
-
-    CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l3);
-    CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l4);
-    /* Get rectangle */
-    CreateVar(Rhs+3,MATRIX_OF_DOUBLE_DATATYPE,&one,&four,&l5);
-
-    xPixCoords = istk(l1);
-    yPixCoords = istk(l2);
-    xCoords = stk(l3);
-    yCoords = stk(l4);
-
-    convertPixelCoordsToUserCoords(xPixCoords, yPixCoords,
-                                   xCoords, yCoords,
-                                   m1 * n1, viewingRect );
-
-  }
-  else 
-  {
-               GetRhsVar(1,MATRIX_OF_DOUBLE_DATATYPE,&m1,&n1,&l1);
-               GetRhsVar(2,MATRIX_OF_DOUBLE_DATATYPE,&m2,&n2,&l2);
-               CheckSameDims(1,2,m1,n1,m2,n2);
-
-    CreateVar(Rhs+1,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l3);
-    CreateVar(Rhs+2,MATRIX_OF_INTEGER_DATATYPE,&m1,&n1,&l4);
-    /* Get rectangle */
-    CreateVar(Rhs+3,MATRIX_OF_DOUBLE_DATATYPE,&one,&four,&l5);
-    xCoords = stk(l1);
-    yCoords = stk(l2);
-    xPixCoords = istk(l3);
-    yPixCoords = istk(l4);
-
-    convertUserCoordToPixelCoords(xCoords, yCoords,
-                                  xPixCoords, yPixCoords,
-                                  m1 * n1, viewingRect);
-  }
-
-  *stk(l5) = viewingRect[0];
-  *stk(l5 + 1) = viewingRect[1];
-  *stk(l5 + 2) = viewingRect[2];
-  *stk(l5 + 3) = viewingRect[3];
-
-  LhsVar(1)=Rhs+1;
-  LhsVar(2)=Rhs+2;
-  LhsVar(3)=Rhs+3;
-  PutLhsVar();
-  return 0;
+    SciErr sciErr;
+
+    int* piAddrl3 = NULL;
+    int* piAddr1  = NULL;
+    int* piAddr2  = NULL;
+    int* piAddrl1 = NULL;
+    int* piAddrl2 = NULL;
+
+    char* l3Input = NULL;
+    double* l5 = NULL;
+
+    int m1 = 0, n1 = 0, m2 = 0, n2 = 0;
+    int four = VIEWING_RECT_SIZE;
+    int one  = 1;
+    int * xPixCoords = NULL;
+    int * yPixCoords = NULL;
+    double * xCoords = NULL;
+    double * yCoords = NULL;
+    int viewingRect[VIEWING_RECT_SIZE];
+
+    CheckInputArgument(pvApiCtx, 3, 3);
+    CheckOutputArgument(pvApiCtx, 1, 3);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl3);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 3.
+    if (getAllocatedSingleString(pvApiCtx, piAddrl3, &l3Input))
+    {
+        Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 3);
+        return 1;
+    }
+
+    /* Convert coordinates */
+    if ( strcmp(l3Input, "i2f") == 0)
+    {
+        int* l1 = NULL;
+        int* l2 = NULL;
+        double* l3 = NULL;
+        double* l4 = NULL;
+
+        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, &l1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+            return 1;
+        }
+
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 2.
+        sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr2, &m2, &n2, &l2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+            return 1;
+        }
+
+        //CheckSameDims
+        if (m1 != m2 || n1 != n2)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
+            return 1;
+        }
+
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l3);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, m1, n1, &l4);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        /* Get rectangle */
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, one, four, &l5);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+
+        xPixCoords = (int*)(l1);
+        yPixCoords = (int*)(l2);
+        xCoords = (l3);
+        yCoords = (l4);
+
+        convertPixelCoordsToUserCoords(xPixCoords, yPixCoords, xCoords, yCoords, m1 * n1, viewingRect );
+    }
+    else
+    {
+        double* l1 = NULL;
+        double* l2 = NULL;
+        int* l3 = NULL;
+        int* l4 = NULL;
+
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 1.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+            return 1;
+        }
+
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 2.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+            return 1;
+        }
+
+        //CheckSameDims
+        if (m1 != m2 || n1 != n2)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
+            return 1;
+        }
+
+
+        sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 1, m1, n1, &l3);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, nbInputArgument(pvApiCtx) + 2, m1, n1, &l4);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        /* Get rectangle */
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, one, four, &l5);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+
+        xCoords = (l1);
+        yCoords = (l2);
+        xPixCoords = (int*)(l3);
+        yPixCoords = (int*)(l4);
+
+        convertUserCoordToPixelCoords(xCoords, yCoords, xPixCoords, yPixCoords, m1 * n1, viewingRect);
+    }
+
+    l5[0] = viewingRect[0];
+    l5[1] = viewingRect[1];
+    l5[2] = viewingRect[2];
+    l5[3] = viewingRect[3];
+
+    freeAllocatedSingleString(l3Input);
+
+    AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+    AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+    AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
+    ReturnArguments(pvApiCtx);
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
 
index 674463a..5b5f6ca 100644 (file)
@@ -18,7 +18,9 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
+#include "Scierror.h"
+#include "localization.h"
 #include "CallJxclick.h"
 #include "GetProperty.h"
 #include "FigureList.h"
 #include "getGraphicObjectProperty.h"
 
 /*--------------------------------------------------------------------------*/
-int sci_xclick(char *fname,unsigned long fname_len)
+int sci_xclick(char *fname, unsigned long fname_len)
 {
-  int one = 1, three = 3, rep = 0;
-  int istr = 0;
-  //int iflag = 0;
-
-  int mouseButtonNumber = 0;
-  char * menuCallback = NULL;
-  char *pstWindowUID = NULL;
-  int pixelCoords[2];
-  double userCoords2D[2];
-
-  int iFigureId = 0;
-  int *piFigureId = &iFigureId;
-
-  CheckRhs(-1, 1) ;
-  CheckLhs(1, 5) ;
-
-  //iflag = ( Rhs >= 1) ? 1 :0;
-
-  // Select current figure or create it
-  getOrCreateDefaultSubwin();
-
-  // Call Java xclick
-  CallJxclick();
-
-  // Get return values
-  mouseButtonNumber = getJxclickMouseButtonNumber();
-  pixelCoords[0] = (int) getJxclickXCoordinate();
-  pixelCoords[1] = (int) getJxclickYCoordinate();
-  pstWindowUID = getJxclickWindowID();
-  menuCallback = getJxclickMenuCallback();
-
-  // Convert pixel coordinates to user coordinates
-  // Conversion is not done if the user clicked on a menu (pixelCoords[*] == -1)
-  if (pixelCoords[0] != -1 && pixelCoords[1] != -1)
-  {
-    char* clickedSubwinUID = (char*)getCurrentSubWin();
-    sciGet2dViewCoordFromPixel(clickedSubwinUID, pixelCoords, userCoords2D);
-  }
-  else
-  {
-    userCoords2D[0] = pixelCoords[0];
-    userCoords2D[1] = pixelCoords[1];
-  }
-
-  if (Lhs == 1)
-  {
-    LhsVar(1) = Rhs+1;
-    CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,&one,&three,&rep);
-    *stk(rep) = (double) mouseButtonNumber;
-    *stk(rep + 1) = userCoords2D[0];
-    *stk(rep + 2) = userCoords2D[1];
-  }
-  else
-  {
-    LhsVar(1) = Rhs+1;
-    CreateVar(Rhs+1,MATRIX_OF_DOUBLE_DATATYPE,&one,&one,&rep);
-    *stk(rep) = (double) mouseButtonNumber;
-  }
-
-  if (Lhs >= 2)
-  {
-    LhsVar(2) = Rhs+2;
-    CreateVar(Rhs+2,MATRIX_OF_DOUBLE_DATATYPE,&one,&one,&rep);
-    *stk(rep) = userCoords2D[0];
-  }
-
-  if (Lhs >= 3)
-  {
-    LhsVar(3) = Rhs+3;
-    CreateVar(Rhs+3,MATRIX_OF_DOUBLE_DATATYPE,&one,&one,&rep);
-    *stk(rep) = userCoords2D[1];
-  }
-
-  if (Lhs >=4)
-  {
-    LhsVar(4) = Rhs+4;
-    CreateVar(Rhs+4,MATRIX_OF_DOUBLE_DATATYPE,&one,&one,&rep);
-    getGraphicObjectProperty(pstWindowUID, __GO_ID__, jni_int, (void**)&piFigureId);
-    *stk(rep) = (double) iFigureId;
-  }
-
-  if (Lhs >= 5)
-  {
-    LhsVar(5) = Rhs+5;
-    istr = (int)strlen(menuCallback);
-    CreateVar(Rhs+5,STRING_DATATYPE,&istr,&one,&rep);
-    strncpy(cstk(rep),menuCallback,istr);
-  }
-
-  deleteJxclickString(menuCallback);
-  deleteJxclickString(pstWindowUID);
-
-  PutLhsVar();
-
-  return 0;
+    SciErr sciErr;
+
+    double* rep = NULL;
+    int one = 1, three = 3;
+    int istr = 0;
+    //int iflag = 0;
+
+    int mouseButtonNumber = 0;
+    char * menuCallback = NULL;
+    char *pstWindowUID = NULL;
+    int pixelCoords[2];
+    double userCoords2D[2];
+
+    int iFigureId = 0;
+    int *piFigureId = &iFigureId;
+
+    CheckInputArgument(pvApiCtx, -1, 1) ;
+    CheckOutputArgument(pvApiCtx, 1, 5) ;
+
+    //iflag = ( nbInputArgument(pvApiCtx) >= 1) ? 1 :0;
+
+    // Select current figure or create it
+    getOrCreateDefaultSubwin();
+
+    // Call Java xclick
+    CallJxclick();
+
+    // Get return values
+    mouseButtonNumber = getJxclickMouseButtonNumber();
+    pixelCoords[0] = (int) getJxclickXCoordinate();
+    pixelCoords[1] = (int) getJxclickYCoordinate();
+    pstWindowUID = getJxclickWindowID();
+    menuCallback = getJxclickMenuCallback();
+
+    // Convert pixel coordinates to user coordinates
+    // Conversion is not done if the user clicked on a menu (pixelCoords[*] == -1)
+    if (pixelCoords[0] != -1 && pixelCoords[1] != -1)
+    {
+        char* clickedSubwinUID = (char*)getCurrentSubWin();
+        sciGet2dViewCoordFromPixel(clickedSubwinUID, pixelCoords, userCoords2D);
+    }
+    else
+    {
+        userCoords2D[0] = pixelCoords[0];
+        userCoords2D[1] = pixelCoords[1];
+    }
+
+    if (nbOutputArgument(pvApiCtx) == 1)
+    {
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, one, three, &rep);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        rep[0] = (double) mouseButtonNumber;
+        rep[1] = userCoords2D[0];
+        rep[2] = userCoords2D[1];
+    }
+    else
+    {
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, one, one, &rep);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        rep[0] = (double) mouseButtonNumber;
+    }
+
+    if (nbOutputArgument(pvApiCtx) >= 2)
+    {
+        AssignOutputVariable(pvApiCtx, 2) = nbInputArgument(pvApiCtx) + 2;
+
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 2, one, one, &rep);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        rep[0] = userCoords2D[0];
+    }
+
+    if (nbOutputArgument(pvApiCtx) >= 3)
+    {
+        AssignOutputVariable(pvApiCtx, 3) = nbInputArgument(pvApiCtx) + 3;
+        // YOU MUST REMOVE YOUR VARIABLE DECLARATION "int rep".
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 3, one, one, &rep);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        rep[0] = userCoords2D[1];
+    }
+
+    if (nbOutputArgument(pvApiCtx) >= 4)
+    {
+        AssignOutputVariable(pvApiCtx, 4) = nbInputArgument(pvApiCtx) + 4;
+
+        sciErr = allocMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 4, one, one, &rep);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        getGraphicObjectProperty(pstWindowUID, __GO_ID__, jni_int, (void**)&piFigureId);
+        rep[0] = (double) iFigureId;
+    }
+
+    if (nbOutputArgument(pvApiCtx) >= 5)
+    {
+        char* strRep = NULL;
+        AssignOutputVariable(pvApiCtx, 5) = nbInputArgument(pvApiCtx) + 5;
+        istr = (int)strlen(menuCallback);
+
+        if (allocSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 5, istr * one, (const char**)&strRep))
+        {
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        strncpy(strRep, menuCallback, istr);
+    }
+
+    deleteJxclickString(menuCallback);
+    deleteJxclickString(pstWindowUID);
+
+    ReturnArguments(pvApiCtx);
+
+    return 0;
 }
 /*--------------------------------------------------------------------------*/
index 8a92e55..c2158a6 100644 (file)
@@ -17,7 +17,8 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
+#include "localization.h"
 #include "DestroyObjects.h"
 #include "GetProperty.h"
 #include "getPropertyAssignedValue.h"
 /*--------------------------------------------------------------------------*/
 int sci_xdel(char *fname, unsigned long fname_len)
 {
-    int m1 = 0, n1 = 0, l1 = 0;
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    double* l1 = NULL;
+
+    int m1 = 0, n1 = 0;
     char *pstCurrentFigure = NULL;
-    CheckRhs(-1, 1);
-    if (Rhs >= 1)
+    CheckInputArgument(pvApiCtx, -1, 1);
+    if (nbInputArgument(pvApiCtx) >= 1)
     {
         int i = 0;
         double * windowNumbers = NULL;
-        GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 1.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+            return 1;
+        }
+
 
         /* First check that all the window numbers are valid */
-        windowNumbers = stk(l1);
+        windowNumbers = l1;
         for (i = 0; i < m1 * n1; i++)
         {
             if (!sciIsExistingFigure((int) windowNumbers[i]))
@@ -64,8 +85,8 @@ int sci_xdel(char *fname, unsigned long fname_len)
             deleteGraphicObject(pstCurrentFigure);
         }
     }
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 
index 58f6b13..f1f091c 100644 (file)
@@ -18,7 +18,7 @@
 
 #include "gw_graphics.h"
 #include "sciCall.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "localization.h"
 #include "Scierror.h"
 #include "BuildObjects.h"
 /*--------------------------------------------------------------------------*/
 int sci_xfarcs(char *fname, unsigned long fname_len)
 {
-    int m1 = 0, n1 = 0, l1 = 0;
-    int m2 = 0, n2 = 0, l2 = 0;
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    double* l1 = NULL;
+    int* piAddr2 = NULL;
+    int* l2 = NULL;
+
+    int m1 = 0, n1 = 0;
+    int m2 = 0, n2 = 0;
 
     long hdl = 0;
 
@@ -41,19 +48,55 @@ int sci_xfarcs(char *fname, unsigned long fname_len)
     double angle1 = 0.0;
     double angle2 = 0.0;
 
-    CheckRhs(1, 2);
+    CheckInputArgument(pvApiCtx, 1, 2);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 1.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
+    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_DOUBLE_DATATYPE, &m1, &n1, &l1);
     if (m1 != 6)
     {
         Scierror(999, _("%s: Wrong size for input argument #%d: %s expected.\n"), fname, 1, "(6,n)");
         return 0;
     }
 
-    if (Rhs == 2)
+    if (nbInputArgument(pvApiCtx) == 2)
     {
-        GetRhsVar(2, MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);
-        CheckVector(2, m2, n2);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddr2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 2.
+        sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr2, &m2, &n2, &l2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+            return 1;
+        }
+
+        //CheckVector
+        if (m2 != 1 && n2 != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 2);
+            return 1;
+        }
+
         if (n1 != m2 * n2)
         {
             Scierror(999, _("%s: Wrong size for input arguments #%d and #%d.\n"), fname, 1, 2);
@@ -64,10 +107,17 @@ int sci_xfarcs(char *fname, unsigned long fname_len)
     {
         m2 = 1;
         n2 = n1;
-        CreateVar(2, MATRIX_OF_INTEGER_DATATYPE, &m2, &n2, &l2);
+        sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, 2, m2, n2, &l2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
         for (i = 0; i < n2; ++i)
         {
-            *istk(l2 + i) = i + 1;
+            *((int*)(l2 + i)) = i + 1;
         }
     }
 
@@ -75,10 +125,10 @@ int sci_xfarcs(char *fname, unsigned long fname_len)
 
     for (i = 0; i < n1; ++i)
     {
-        angle1 = DEG2RAD(*stk(l1 + (6 * i) + 4) / 64.0);
-        angle2 = DEG2RAD(*stk(l1 + (6 * i) + 5) / 64.0);
-        Objarc(&angle1, &angle2, stk(l1 + (6 * i)), stk(l1 + (6 * i) + 1),
-               stk(l1 + (6 * i) + 2), stk(l1 + (6 * i) + 3), istk(l2 + i), istk(l2 + i), TRUE, FALSE, &hdl);
+        angle1 = DEG2RAD(*(l1 + (6 * i) + 4) / 64.0);
+        angle2 = DEG2RAD(*(l1 + (6 * i) + 5) / 64.0);
+        Objarc(&angle1, &angle2, (l1 + (6 * i)), (l1 + (6 * i) + 1),
+               (l1 + (6 * i) + 2), (l1 + (6 * i) + 3), (int*)(l2 + i), (int*)(l2 + i), TRUE, FALSE, &hdl);
     }
 
     /** Construct Compound and make it current object **/
@@ -88,8 +138,8 @@ int sci_xfarcs(char *fname, unsigned long fname_len)
         releaseGraphicObjectProperty(__GO_PARENT__, o, jni_string, 1);
     }
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
 
     return 0;
 }
index 1158e84..6091b56 100644 (file)
@@ -18,7 +18,9 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
+#include "Scierror.h"
+#include "localization.h"
 #include "sciCall.h"
 #include "BuildObjects.h"
 
 #include "setGraphicObjectProperty.h"
 
 /*--------------------------------------------------------------------------*/
-int sci_xfpoly(char *fname,unsigned long fname_len)
+int sci_xfpoly(char *fname, unsigned long fname_len)
 {
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    double* l1 = NULL;
+    int* piAddrl2 = NULL;
+    double* l2 = NULL;
+    int* piAddrl3 = NULL;
+    double* l3 = NULL;
+
     char* psubwinUID = (char*)getOrCreateDefaultSubwin();
     int iStyle = 0;
-    int m1 = 0, n1 = 0, l1 = 0;
-    int m2 = 0, n2 = 0, l2 = 0;
-    int m3 = 0, n3 = 0, l3 = 0;
-    int mn1 = 0;
+    int m1 = 0, n1 = 0;
+    int m2 = 0, n2 = 0;
+    int m3 = 0, n3 = 0;
 
     long hdl = 0; /* NG */
 
-    CheckRhs(2, 3);
+    CheckInputArgument(pvApiCtx, 2, 3);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 1.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+        return 1;
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        return 1;
+    }
+
+    //CheckSameDims
+    if (m1 != m2 || n1 != n2)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
+        return 1;
+    }
 
-    GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-    GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
-    CheckSameDims(1, 2, m1, n1, m2, n2);
 
-    if (Rhs == 3)
+    if (nbInputArgument(pvApiCtx) == 3)
     {
-        GetRhsVar(3, MATRIX_OF_DOUBLE_DATATYPE, &m3, &n3, &l3);
-        CheckScalar(3, m3, n3);
-        iStyle = (int) *stk(l3);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddrl3);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 3.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrl3, &m3, &n3, &l3);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+            return 1;
+        }
+
+        //CheckScalar
+        if (m3 != 1 || n3 != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 3);
+            return 1;
+        }
+
+        iStyle = (int) * (l3);
     }
 
-    if(iStyle == 0)
+    if (iStyle == 0)
     {
         int iColorMapSize = 0;
         int* piColorMapSize = &iColorMapSize;
@@ -67,11 +134,11 @@ int sci_xfpoly(char *fname,unsigned long fname_len)
         //get current foreground color
         getGraphicObjectProperty(psubwinUID, __GO_LINE_COLOR__, jni_int, (void**)&piForeGround);
 
-        if(iForeGround == -1)
+        if (iForeGround == -1)
         {
             iStyle = iColorMapSize + 1;
         }
-        else if(iForeGround == -2)
+        else if (iForeGround == -2)
         {
             iStyle = iColorMapSize + 2;
         }
@@ -81,12 +148,12 @@ int sci_xfpoly(char *fname,unsigned long fname_len)
         }
     }
 
-    Objfpoly(stk(l1), stk(l2), m1 * n1, &iStyle, &hdl, 0);
+    Objfpoly((l1), (l2), m1 * n1, &iStyle, &hdl, 0);
 
     setGraphicObjectRelationship(psubwinUID, getObjectFromHandle(hdl));
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 
index 031ce56..23e23cb 100644 (file)
@@ -18,7 +18,7 @@
 /*------------------------------------------------------------------------*/
 
 #include "gw_graphics.h"
-#include "stack-c.h"
+#include "api_scilab.h"
 #include "BuildObjects.h"
 #include "Scierror.h"
 #include "sciCall.h"
 /*--------------------------------------------------------------------------*/
 int sci_xfpolys(char *fname, unsigned long fname_len)
 {
-    int m1 = 0, n1 = 0, l1 = 0;
-    int m2 = 0, n2 = 0, l2 = 0;
-    int m3 = 0, n3 = 0, l3 = 0;
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    double* l1 = NULL;
+    int* piAddrl2 = NULL;
+    double* l2 = NULL;
+    int* piAddr3 = NULL;
+    int* l3 = NULL;
+
+    int m1 = 0, n1 = 0;
+    int m2 = 0, n2 = 0;
+    int m3 = 0, n3 = 0;
     int mn2 = 0;
 
     int v1 = 0;                 /* v1 is the flag used for flat (v1==1) or interpolated (v1==2) shading */
@@ -48,7 +57,6 @@ int sci_xfpolys(char *fname, unsigned long fname_len)
     char *pstFigureUID = NULL;
     char *pstCompoundUID = NULL;
     int iSubWinForeground = 0;
-    int *piSubWinForeground = &iSubWinForeground;
 
     int iImmediateDrawing = 0;
     int *piImmediateDrawing = &iImmediateDrawing;
@@ -62,26 +70,83 @@ int sci_xfpolys(char *fname, unsigned long fname_len)
     int iVisible = 0;
     int *piVisible = &iVisible;
 
-    CheckRhs(2, 3);
+    CheckInputArgument(pvApiCtx, 2, 3);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 1.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl1, &m1, &n1, &l1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 1);
+        return 1;
+    }
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
+
+    // Retrieve a matrix of double at position 2.
+    sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+        return 1;
+    }
+
+    //CheckSameDims
+    if (m1 != m2 || n1 != n2)
+    {
+        Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
+        return 1;
+    }
 
-    GetRhsVar(1, MATRIX_OF_DOUBLE_DATATYPE, &m1, &n1, &l1);
-    GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
-    CheckSameDims(1, 2, m1, n1, m2, n2);
     mn2 = m2 * n2;
     if (mn2 == 0)
     {
-        LhsVar(1) = 0;
-        PutLhsVar();
+        AssignOutputVariable(pvApiCtx, 1) = 0;
+        ReturnArguments(pvApiCtx);
         return 0;
     }
 
-    if (Rhs == 3)
+    if (nbInputArgument(pvApiCtx) == 3)
     {
-        GetRhsVar(3, MATRIX_OF_INTEGER_DATATYPE, &m3, &n3, &l3);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 3, &piAddr3);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 3.
+        sciErr = getMatrixOfDoubleAsInteger(pvApiCtx, piAddr3, &m3, &n3, &l3);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 3);
+            return 1;
+        }
+
 
         if (m3 * n3 == m1 * n1)
         {
-            CheckSameDims(1, 3, m1, n1, m3, n3);
+            //CheckSameDims
+            if (m1 != m3 || n1 != n3)
+            {
+                Scierror(999, _("%s: Wrong size for input argument #%d: %d-by-%d matrix expected.\n"), fname, 1, m1, n1);
+                return 1;
+            }
+
             v1 = 2;             /* interpolated shading */
 
             if (m3 != 3 && m3 != 4)
@@ -92,8 +157,20 @@ int sci_xfpolys(char *fname, unsigned long fname_len)
         }
         else
         {
-            CheckVector(3, m3, n3);
-            CheckDimProp(2, 3, m3 * n3 != n2);
+            //CheckVector
+            if (m3 != 1 && n3 != 1)
+            {
+                Scierror(999, _("%s: Wrong size for input argument #%d: Vector expected.\n"), fname, 3);
+                return 1;
+            }
+
+            //CheckDimProp
+            if (m3 * n3 != n2)
+            {
+                Scierror(999, _("%s: Wrong size for input arguments: Incompatible sizes.\n"), fname);
+                return 1;
+            }
+
             v1 = 1;             /* flat shading */
         }
     }
@@ -101,10 +178,17 @@ int sci_xfpolys(char *fname, unsigned long fname_len)
     {
         int un = 1, ix = 0;
 
-        CreateVar(3, MATRIX_OF_INTEGER_DATATYPE, &un, &n2, &l3);
+        sciErr = allocMatrixOfDoubleAsInteger(pvApiCtx, 3, un, n2, &l3);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
         for (ix = 0; ix < n2; ++ix)
         {
-            *istk(l3 + ix) = 0;
+            *(int*)(l3 + ix) = 0;
         }
         m3 = n3 = 1;
     }
@@ -130,7 +214,7 @@ int sci_xfpolys(char *fname, unsigned long fname_len)
     {
         if (m3 == 1 || n3 == 1) /* color vector specified */
         {
-            if (*istk(l3 + i) == 0)
+            if (*(int*)(l3 + i) == 0)
             {
                 if (iForeGround == -1)
                 {
@@ -145,16 +229,16 @@ int sci_xfpolys(char *fname, unsigned long fname_len)
                     iSubWinForeground = iForeGround;
                 }
 
-                Objpoly(stk(l1 + (i * m1)), stk(l2 + (i * m1)), m1, 1, iSubWinForeground, &hdl);
+                Objpoly((l1 + (i * m1)), (l2 + (i * m1)), m1, 1, iSubWinForeground, &hdl);
             }
             else
             {
-                Objfpoly(stk(l1 + (i * m1)), stk(l2 + (i * m1)), m1, istk(l3 + i), &hdl, v1);
+                Objfpoly((l1 + (i * m1)), (l2 + (i * m1)), m1, (int*)(l3 + i), &hdl, v1);
             }
         }
         else                    /* we have a color matrix used for interpolated shading : one color per vertex */
         {
-            Objfpoly(stk(l1 + (i * m1)), stk(l2 + (i * m1)), m1, istk(l3 + i * m3), &hdl, v1);
+            Objfpoly((l1 + (i * m1)), (l2 + (i * m1)), m1, (int*)(l3 + i * m3), &hdl, v1);
         }
 
         // Add newly created object to Compound
@@ -170,8 +254,8 @@ int sci_xfpolys(char *fname, unsigned long fname_len)
     setGraphicObjectProperty(pstCompoundUID, __GO_VISIBLE__, &iVisible, jni_bool, 1);
 
 
-    LhsVar(1) = 0;
-    PutLhsVar();
+    AssignOutputVariable(pvApiCtx, 1) = 0;
+    ReturnArguments(pvApiCtx);
     return 0;
 }
 
index c509960..0aea208 100644 (file)
@@ -22,7 +22,6 @@
 #include "api_scilab.h"
 
 #include "gw_graphics.h"
-#include "stack-c.h"
 #include "XsetXgetParameters.h"
 #include "GetProperty.h"
 #include "Format.h"
@@ -42,26 +41,46 @@ int xgetg( char * str, char * str1, int * len, int  lx0, int lx1);
 /*--------------------------------------------------------------------------*/
 int sci_xget(char *fname, unsigned long fname_len)
 {
-    int x2 = 0, m1 = 0, n1 = 0, l1 = 0, m2 = 0, n2 = 0, l2 = 0, l3 = 0, i = 0;
+    SciErr sciErr;
+
+    int* piAddrl1 = NULL;
+    char* l1 = NULL;
+    int* piAddrl2 = NULL;
+    double* l2 = NULL;
+    char* l3 = NULL;
+
+    int flagx = 0, m1 = 0, m2 = 0, n2 = 0, i = 0;
     int one = 1;
 
     BOOL keyFound = FALSE;
 
-    if ( Rhs <= 0 )
+    if ( nbInputArgument(pvApiCtx) <= 0 )
     {
         sci_demo(fname, fname_len);
         return 0;
     }
 
-    CheckRhs(1, 2);
-    CheckLhs(0, 1);
+    CheckInputArgument(pvApiCtx, 1, 2);
+    CheckOutputArgument(pvApiCtx, 0, 1);
+
+    sciErr = getVarAddressFromPosition(pvApiCtx, 1, &piAddrl1);
+    if (sciErr.iErr)
+    {
+        printError(&sciErr, 0);
+        return 1;
+    }
 
-    GetRhsVar(1, STRING_DATATYPE, &m1, &n1, &l1);
+    // Retrieve a matrix of double at position 1.
+    if (getAllocatedSingleString(pvApiCtx, piAddrl1, &l1))
+    {
+        Scierror(202, _("%s: Wrong type for argument #%d: A string expected.\n"), fname, 1);
+        return 1;
+    }
 
     /* check if key is valid */
     for (i = 0; i < NUMSETFONC ; i++)
     {
-        if ( strcmp(cstk(l1), KeyTab_[i]) == 0 )
+        if ( strcmp((l1), KeyTab_[i]) == 0 )
         {
             keyFound = TRUE ;
             break ;
@@ -70,28 +89,59 @@ int sci_xget(char *fname, unsigned long fname_len)
 
     if ( !keyFound )
     {
-        Scierror(999, _("%s: Unrecognized input argument: '%s'.\n"), fname, cstk(l1));
+        Scierror(999, _("%s: Unrecognized input argument: '%s'.\n"), fname, (l1));
         return -1;
     }
 
-    if (Rhs == 2)
+    if (nbInputArgument(pvApiCtx) == 2)
     {
-        GetRhsVar(2, MATRIX_OF_DOUBLE_DATATYPE, &m2, &n2, &l2);
-        CheckScalar(2, m2, n2);
+        sciErr = getVarAddressFromPosition(pvApiCtx, 2, &piAddrl2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            return 1;
+        }
+
+        // Retrieve a matrix of double at position 2.
+        sciErr = getMatrixOfDouble(pvApiCtx, piAddrl2, &m2, &n2, &l2);
+        if (sciErr.iErr)
+        {
+            printError(&sciErr, 0);
+            Scierror(202, _("%s: Wrong type for argument %d: A real expected.\n"), fname, 2);
+            return 1;
+        }
+
+        //CheckScalar
+        if (m2 != 1 || n2 != 1)
+        {
+            Scierror(999, _("%s: Wrong size for input argument #%d: A real scalar expected.\n"), fname, 2);
+            return 1;
+        }
+
+        flagx = (int)  * (l2);
+    }
+    else
+    {
+        flagx = 0;
     }
 
-    if ( strcmp(cstk(l1), "fpf") == 0 || strcmp(cstk(l1), "auto clear") == 0)
+    if ( strcmp(l1, "fpf") == 0 || strcmp(l1, "auto clear") == 0)
     {
         int bufl;
         /*     special case for global variables set */
-        xgetg( cstk(l1), C2F(cha1).buf, &bufl, m1, bsiz);
-        CreateVar(Rhs + 1, STRING_DATATYPE, &bufl, &one, &l3);
-        strncpy(cstk(l3), C2F(cha1).buf, bufl);
-        LhsVar(1) = Rhs + 1;
-        PutLhsVar();
+        xgetg( (l1), C2F(cha1).buf, &bufl, m1, bsiz);
+        if (allocSingleString(pvApiCtx, nbInputArgument(pvApiCtx) + 1, bufl * one, (const char **)&l3))
+        {
+            Scierror(999, _("%s: Memory allocation error.\n"), fname);
+            return 1;
+        }
+
+        strncpy((l3), C2F(cha1).buf, bufl);
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+        ReturnArguments(pvApiCtx);
         return 0;
     }
-    else if ( strcmp(cstk(l1), "colormap") == 0)
+    else if ( strcmp(l1, "colormap") == 0)
     {
         char *pobjUID = NULL;
         // Force figure creation if none exists.
@@ -100,12 +150,12 @@ int sci_xget(char *fname, unsigned long fname_len)
 
         get_color_map_property(pvApiCtx, pobjUID);
 
-        LhsVar(1) = Rhs + 1;
-        PutLhsVar();
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+        ReturnArguments(pvApiCtx);
 
         return 0;
     }
-    else if ( strcmp(cstk(l1), "mark") == 0)
+    else if ( strcmp(l1, "mark") == 0)
     {
         char *pobjUID = (char*)getOrCreateDefaultSubwin();
         int iMarkStyle = 0;
@@ -119,43 +169,43 @@ int sci_xget(char *fname, unsigned long fname_len)
         pdblResult[0] = iMarkStyle;
         pdblResult[1] = iMarkSize;
 
-        createMatrixOfDouble(pvApiCtx, Rhs + 1, 1, 2, pdblResult);
-        LhsVar(1) = Rhs + 1;
-        PutLhsVar();
+        createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 2, pdblResult);
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+        ReturnArguments(pvApiCtx);
 
         return 0;
     }
-    else if ( strcmp(cstk(l1), "mark size") == 0)
+    else if ( strcmp(l1, "mark size") == 0)
     {
         char *pobjUID = (char*)getOrCreateDefaultSubwin();
         get_mark_size_property(pvApiCtx, pobjUID);
 
-        LhsVar(1) = Rhs + 1;
-        PutLhsVar();
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+        ReturnArguments(pvApiCtx);
 
         return 0;
     }
-    else if ( strcmp(cstk(l1), "line style") == 0)
+    else if ( strcmp(l1, "line style") == 0)
     {
         get_line_style_property(pvApiCtx, (char*)getOrCreateDefaultSubwin());
 
-        LhsVar(1) = Rhs + 1;
-        PutLhsVar();
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+        ReturnArguments(pvApiCtx);
         return 0;
     }
-    else if (strcmp(cstk(l1), "clipping") == 0)
+    else if (strcmp(l1, "clipping") == 0)
     {
         double *clipBox = NULL;
         char* pobjUID = (char*)getOrCreateDefaultSubwin();
 
         getGraphicObjectProperty(pobjUID, __GO_CLIP_BOX__, jni_double_vector, (void **)&clipBox);
 
-        createMatrixOfDouble(pvApiCtx, Rhs + 1, 1, 4, clipBox);
-        LhsVar(1) = Rhs + 1;
-        PutLhsVar();
+        createMatrixOfDouble(pvApiCtx, nbInputArgument(pvApiCtx) + 1, 1, 4, clipBox);
+        AssignOutputVariable(pvApiCtx, 1) = nbInputArgument(pvApiCtx) + 1;
+        ReturnArguments(pvApiCtx);</