scilab/modules/core/sci_gateway/c/sci_clear.c

   1 /*
   2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
   3  * Copyright (C) 2006 - INRIA - Allan CORNET
   4  * Copyright (C) 2011 - DIGITEO - Allan CORNET
   5  *
   6  * This file must be used under the terms of the CeCILL.
   7  * This source file is licensed as described in the file COPYING, which
   8  * you should have received as part of this distribution.  The terms
   9  * are also available at
  10  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
  11  *
  12  */
  13 #include <ctype.h>
  14 #include <string.h>
  15 #include <stdlib.h>
  16 #include "gw_core.h"
  17 #include "machine.h"
  18 #include "stack-c.h"
  19 #include "BOOL.h"
  20 #include "localization.h"
  21 #include "Scierror.h"
  22 #include "MALLOC.h"
  23 #include "call_scilab.h"
  24 #include "isScilabFunction.h"
  25 #include "api_scilab.h"
  26
  27 /*--------------------------------------------------------------------------*/
  28 static int clearAllVariablesOnStack(void);
  29 /*--------------------------------------------------------------------------*/
  30 static int sci_clear_no_rhs(const char *fname);
  31 static int sci_clear_n_rhs(const char *fname);
  32 /*--------------------------------------------------------------------------*/
  33 extern int C2F(stackp)(int *, int *); /* fortran subroutine */
  34 /*--------------------------------------------------------------------------*/
  35 int C2F(sci_clear)(char *fname,unsigned long fname_len)
  36 {
  37     if (Rhs == 0)
  38     {
  39         sci_clear_no_rhs(fname);
  40     }
  41     else
  42     {
  43         sci_clear_n_rhs(fname);
  44     }
  45     return 0;
  46 }
  47 /*--------------------------------------------------------------------------*/
  48 static int sci_clear_no_rhs(const char *fname)
  49 {
  50     if (C2F(recu).macr != 0 || C2F(recu).paus != 0)
  51     {
  52         int k = 0;
  53         if (C2F(recu).rstk[C2F(recu).pt - 3] == 909)
  54         {
  55             /* clear within an exec'd macro */
  56             return clearAllVariablesOnStack();
  57         }
  58         /* clear within a macro, an execstr, an exec or a pause */
  59         k = C2F(iop).lpt[0] - 19;
  60         if (C2F(iop).lin[k + 6] != 0 && ((int *)&C2F(stack))[C2F(iop).lin[k + 5] - 1] == 10)
  61         {
  62             PutLhsVar();
  63             return 0;
  64         }
  65         /* clear within a macro, an exec or a pause */
  66         /* Computing MIN */
  67         Bot = Min(C2F(vstk).bbot, C2F(iop).lin[k + 4]);
  68         PutLhsVar();
  69         return 0;
  70     }
  71     return clearAllVariablesOnStack();
  72 }
  73 /*--------------------------------------------------------------------------*/
  74 static int sci_clear_n_rhs(const char *fname)
  75 {
  76     int k = 0;
  77     int i = 0;
  78     int nbVariables = Rhs;
  79     char **VariableNameToClear = (char **)MALLOC(sizeof(char*) * nbVariables);
  80
  81     if (!VariableNameToClear)
  82     {
  83         Scierror(999,_("%s: No more memory.\n"), fname);
  84         return 0;
  85     }
  86
  87     for (k = 0; k < nbVariables; k++)
  88     {
  89         int *piAddressVar = NULL;
  90         SciErr sciErr = getVarAddressFromPosition(pvApiCtx, k + 1, &piAddressVar);
  91         if (!sciErr.iErr)
  92         {
  93             if (isScalar(pvApiCtx, piAddressVar) && isStringType(pvApiCtx, piAddressVar))
  94             {
  95                 char *variablename = NULL;
  96                 if (getAllocatedSingleString(pvApiCtx, piAddressVar, &variablename) == 0)
  97                 {
  98                     VariableNameToClear[i] =  variablename;
  99                     i++;
 100                  }
 101                 else
 102                 {
 103                     freeAllocatedMatrixOfString(i, 1, VariableNameToClear);
 104                     VariableNameToClear = NULL;
 105                     Scierror(999,_("%s: No more memory.\n"), fname);
 106                     return 0;
 107                 }
 108             }
 109             else
 110             {
 111                 freeAllocatedMatrixOfString(i, 1, VariableNameToClear);
 112                 VariableNameToClear = NULL;
 113
 114                 if (isScalar(pvApiCtx, piAddressVar))
 115                 {
 116                     Scierror(201, _("%s: Wrong type for argument %d: Valid variable name expected.\n"), fname, k + 1);
 117                     return 0;
 118                 }
 119                 else
 120                 {
 121                     Scierror(999, _("%s: Wrong size for argument %d: Valid variable name expected.\n"), fname, k + 1);
 122                     return 0;
 123                 }
 124             }
 125         }
 126     }
 127
 128     for (k = 0; k < nbVariables; k++)
 129     {
 130         deleteNamedVariable(NULL, VariableNameToClear[k]);
 131     }
 132
 133     if (VariableNameToClear)
 134     {
 135         freeAllocatedMatrixOfString(nbVariables, 1, VariableNameToClear);
 136         VariableNameToClear = NULL;
 137     }
 138     PutLhsVar();
 139     return 0;
 140 }
 141 /*--------------------------------------------------------------------------*/
 142 int clearAllVariablesOnStack(void)
 143 {
 144     /* clear all variables */
 145     int il = 0;
 146     Fin = 0;
 147     C2F(adre).is = Fin;
 148     Bot = C2F(vstk).bbot;
 149
 150     //create a null matrix a the Top of the stack
 151     Top = Top + 1;
 152     il = iadr(*Lstk(Top));
 153     *istk(il) = 0;
 154     *Lstk(Top + 1) = *Lstk(Top) + 1;
 155     return 0;
 156 }