a0697dcad294a8c27c4f2aad52cc4e0dfdbf0c2a
[scilab.git] / 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 && *istk(C2F(iop).lin[k + 5]) == 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: A single string expected.\n"), fname, k + 1);
117                     return 0;
118                 }
119                 else
120                 {
121                     Scierror(999, _("%s: Wrong size for argument %d: A single string 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 }