* Bug #8373 fixed - Core: clear can take matrix of strings 34/11734/5
Paul BIGNIER [Tue, 18 Jun 2013 11:56:10 +0000 (13:56 +0200)]
Change-Id: I6114fc860920674bd329c1570bff5258c6e4f521

SEP/INDEX
SEP/SEP_099_clear.odt [new file with mode: 0644]
scilab/CHANGES_5.5.X
scilab/modules/core/help/en_US/variables/clear.xml
scilab/modules/core/help/fr_FR/variables/clear.xml
scilab/modules/core/sci_gateway/c/sci_clear.c
scilab/modules/core/tests/unit_tests/clear.dia.ref
scilab/modules/core/tests/unit_tests/clear.tst

index 6818f3c..1aa22d2 100644 (file)
--- a/SEP/INDEX
+++ b/SEP/INDEX
@@ -94,3 +94,4 @@ SEP #095: New functions: ismatrix, isrow,iscolumn and issquare.
 SEP #096: cross function.
 SEP #097: New argument added at strtod function (decimalseparator)
 SEP #098: New output argument for qp_solve function
+SEP #099: Matrices of strings as input argument for clear
\ No newline at end of file
diff --git a/SEP/SEP_099_clear.odt b/SEP/SEP_099_clear.odt
new file mode 100644 (file)
index 0000000..6b14ac8
Binary files /dev/null and b/SEP/SEP_099_clear.odt differ
index 43382dd..82f2fc1 100644 (file)
@@ -227,6 +227,8 @@ Bug fixes
 
 * Bug #8319 fixed - dbphi(hypermat) and phasemag(hypermat) returned a matrix instead of a hypermatrix.
 
+* Bug #8373 fixed - clear() can now take a matrix of strings argument.
+
 * Bug #8511 fixed - sprand used rand and grand functions, and internal state of the random
                     generator was changed.
 
index 2d01795..851779b 100644 (file)
@@ -8,7 +8,8 @@
         <title>Calling Sequence</title>
         <synopsis>
             clear a b c
-            clear('a','b','c')
+            clear('a', 'b', 'c')
+            clear(['a' 'b' 'c'])
         </synopsis>
     </refsynopsisdiv>
     <refsection>
     <refsection>
         <title>Examples</title>
         <programlisting role="example"><![CDATA[
-a=2;
-b=3;
-c=4;
+a = 2;
+b = 3;
+c = 4;
 clear a
 isdef("a") // F
 isdef("b") // T
 clear("b");
 isdef("b") // F
+
+a = 2;
+b = 3;
+c = 4;
+clear(['a' 'b' 'c'])
+isdef("a") | isdef("b") | isdef("c") // F
         ]]></programlisting>
     </refsection>
     <refsection role="see also">
@@ -71,4 +78,13 @@ isdef("b") // F
             </member>
         </simplelist>
     </refsection>
+    <refsection>
+        <title>History</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revdescription>Argument can now be a matrix of strings</revdescription>
+            </revision>
+        </revhistory>
+    </refsection>
 </refentry>
index 6de862a..acdb6f4 100644 (file)
@@ -2,17 +2,32 @@
 <refentry xmlns="http://docbook.org/ns/docbook" xmlns:xlink="http://www.w3.org/1999/xlink" xmlns:svg="http://www.w3.org/2000/svg" xmlns:mml="http://www.w3.org/1998/Math/MathML" xmlns:db="http://docbook.org/ns/docbook" xmlns:scilab="http://www.scilab.org" xml:lang="fr" xml:id="clear">
     <refnamediv>
         <refname>clear</refname>
-        <refpurpose>suppression de variables  </refpurpose>
+        <refpurpose>Suppression de variables</refpurpose>
     </refnamediv>
     <refsynopsisdiv>
         <title>Séquence d'appel</title>
-        <synopsis>clear a</synopsis>
+        <synopsis>
+            clear a b c
+            clear('a', 'b', 'c')
+            clear(['a' 'b' 'c'])
+        </synopsis>
     </refsynopsisdiv>
     <refsection>
+        <title>Paramètres</title>
+        <variablelist>
+            <varlistentry>
+                <term>a, b, c...</term>
+                <listitem>
+                    <para>variables de n'importe quel type et taille, non protégées</para>
+                </listitem>
+            </varlistentry>
+        </variablelist>
+    </refsection>
+    <refsection>
         <title>Description</title>
         <para>
             Cette commande supprime des variables non-protégées. Elle supprime de l'environnement les variables dont les noms sont spécifiés.
-            Sans argument <literal>clear</literal> supprime toutes les variables sauf celles qui ont été protégées par <literal>predef</literal>. La succession des commandes <literal>predef(0)</literal> et <literal>clear</literal> supprime toutes les variables. 
+            Sans argument, <literal>clear</literal> supprime toutes les variables sauf celles qui ont été protégées par <literal>predef</literal>. La succession des commandes <literal>predef(0)</literal> et <literal>clear</literal> supprime toutes les variables. 
         </para>
         <para>
             Habituellement, les variables protégées sont les bibliothèques standard et les variables dont le nom commence par le caractère "%".
             Notez la syntaxe particulière :  <literal>clear a</literal> et non <literal>clear(a)</literal>. Notez aussi que <literal>a=[]</literal> ne supprime pas <literal>a</literal> mais affecte à <literal>a</literal> une matrice vide.
         </para>
     </refsection>
+    <refsection>
+        <title>Exemples</title>
+        <programlisting role="example"><![CDATA[
+a = 2;
+b = 3;
+c = 4;
+clear a
+isdef("a") // F
+isdef("b") // T
+clear("b");
+isdef("b") // F
+
+a = 2;
+b = 3;
+c = 4;
+clear(['a' 'b' 'c'])
+isdef("a") | isdef("b") | isdef("c") // F
+        ]]></programlisting>
+    </refsection>
     <refsection role="see also">
         <title>Voir aussi</title>
         <simplelist type="inline">
             </member>
         </simplelist>
     </refsection>
+    <refsection>
+        <title>Historique</title>
+        <revhistory>
+            <revision>
+                <revnumber>5.5.0</revnumber>
+                <revdescription>Peut prendre une matrice de chaînes de caractères en argument</revdescription>
+            </revision>
+        </revhistory>
+    </refsection>
 </refentry>
index 7a7f5bf..349f9f4 100644 (file)
@@ -2,6 +2,7 @@
  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
  * Copyright (C) 2006 - INRIA - Allan CORNET
  * Copyright (C) 2011 - DIGITEO - Allan CORNET
+ * Copyright (C) 2013 - Scilab Enterprises - Paul Bignier
  *
  * This file must be used under the terms of the CeCILL.
  * This source file is licensed as described in the file COPYING, which
@@ -28,7 +29,7 @@
 static int clearAllVariablesOnStack(void);
 /*--------------------------------------------------------------------------*/
 static int sci_clear_no_rhs(const char *fname);
-static int sci_clear_n_rhs(const char *fname);
+static int sci_clear_n_rhs(const char *fname, void* _pvCtx);
 /*--------------------------------------------------------------------------*/
 extern int C2F(stackp)(int *, int *); /* fortran subroutine */
 /*--------------------------------------------------------------------------*/
@@ -40,7 +41,7 @@ int C2F(sci_clear)(char *fname, unsigned long fname_len)
     }
     else
     {
-        sci_clear_n_rhs(fname);
+        sci_clear_n_rhs(fname, pvApiCtx);
     }
     return 0;
 }
@@ -71,71 +72,43 @@ static int sci_clear_no_rhs(const char *fname)
     return clearAllVariablesOnStack();
 }
 /*--------------------------------------------------------------------------*/
-static int sci_clear_n_rhs(const char *fname)
+static int sci_clear_n_rhs(const char *fname, void* _pvCtx)
 {
     int k = 0;
     int i = 0;
-    int nbVariables = Rhs;
-    char **VariableNameToClear = (char **)MALLOC(sizeof(char*) * nbVariables);
+    int nbVariables = nbInputArgument(_pvCtx);
+    int nRows = 0;
+    int nCols = 0;
+    char** variablename = NULL;
+    int* piAddressVar = NULL;
 
-    if (!VariableNameToClear)
+    for (k = 0 ; k < nbVariables ; ++k)
     {
-        Scierror(999, _("%s: No more memory.\n"), fname);
-        return 0;
-    }
-
-    for (k = 0; k < nbVariables; k++)
-    {
-        int *piAddressVar = NULL;
-        SciErr sciErr = getVarAddressFromPosition(pvApiCtx, k + 1, &piAddressVar);
+        SciErr sciErr = getVarAddressFromPosition(_pvCtx, k + 1, &piAddressVar);
         if (!sciErr.iErr)
         {
-            if (isScalar(pvApiCtx, piAddressVar) && isStringType(pvApiCtx, piAddressVar))
+            if (isStringType(_pvCtx, piAddressVar) == 0)
             {
-                char *variablename = NULL;
-                if (getAllocatedSingleString(pvApiCtx, piAddressVar, &variablename) == 0)
-                {
-                    VariableNameToClear[i] =  variablename;
-                    i++;
-                }
-                else
-                {
-                    freeAllocatedMatrixOfString(i, 1, VariableNameToClear);
-                    VariableNameToClear = NULL;
-                    Scierror(999, _("%s: No more memory.\n"), fname);
-                    return 0;
-                }
+                Scierror(207, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, k + 1);
+                return 0;
             }
-            else
+
+            if (getAllocatedMatrixOfString(_pvCtx, piAddressVar, &nRows, &nCols, &variablename))
             {
-                freeAllocatedMatrixOfString(i, 1, VariableNameToClear);
-                VariableNameToClear = NULL;
+                Scierror(207, _("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), fname, k + 1);
+                return 0;
+            }
 
-                if (isScalar(pvApiCtx, piAddressVar))
-                {
-                    Scierror(201, _("%s: Wrong type for input argument #%d: A single string expected.\n"), fname, k + 1);
-                    return 0;
-                }
-                else
-                {
-                    Scierror(999, _("%s: Wrong size for input argument #%d: A single string expected.\n"), fname, k + 1);
-                    return 0;
-                }
+            for (i = 0 ; i < nCols * nRows ; ++i)
+            {
+                deleteNamedVariable(_pvCtx, variablename[i]);
             }
-        }
-    }
 
-    for (k = 0; k < nbVariables; k++)
-    {
-        deleteNamedVariable(NULL, VariableNameToClear[k]);
+            freeAllocatedMatrixOfString(nRows, nCols, variablename);
+        }
     }
 
-    if (VariableNameToClear)
-    {
-        freeAllocatedMatrixOfString(nbVariables, 1, VariableNameToClear);
-        VariableNameToClear = NULL;
-    }
-    PutLhsVar();
+    ReturnArguments(_pvCtx);
     return 0;
 }
 /*--------------------------------------------------------------------------*/
index 5dc3365..c1efb59 100644 (file)
@@ -5,8 +5,8 @@
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- CLI SHELL MODE -->
-//
 // <-- JVM NOT MANDATORY -->
+// Run with test_run('core, 'clear')
 A = 2;
 B = 4;
 C = 6;
@@ -17,6 +17,42 @@ assert_checkequal(isdef("C"), %t);
 clear();
 assert_checkequal(isdef("A"), %f);
 assert_checkequal(isdef("C"), %f);
+A = 2;
+B = 4;
+C = 6;
+D = 8;
+clear( ["A" "B" "C" "D"] );
+assert_checkequal(isdef("A"), %f);
+assert_checkequal(isdef("B"), %f);
+assert_checkequal(isdef("C"), %f);
+assert_checkequal(isdef("D"), %f);
+A = 2;
+B = 4;
+C = 6;
+D = 8;
+clear( ["A" ; "B" ; "C" ; "D"] );
+assert_checkequal(isdef("A"), %f);
+assert_checkequal(isdef("B"), %f);
+assert_checkequal(isdef("C"), %f);
+assert_checkequal(isdef("D"), %f);
+A = 2;
+B = 4;
+C = 6;
+D = 8;
+clear( ["A" "B" ; "C" "D"] );
+assert_checkequal(isdef("A"), %f);
+assert_checkequal(isdef("B"), %f);
+assert_checkequal(isdef("C"), %f);
+assert_checkequal(isdef("D"), %f);
+A = 2;
+B = 4;
+C = 6;
+D = 8;
+clear( ["A" "B"], ["C";"D"] );
+assert_checkequal(isdef("A"), %f);
+assert_checkequal(isdef("B"), %f);
+assert_checkequal(isdef("C"), %f);
+assert_checkequal(isdef("D"), %f);
 function test_clear()
   A = 6;
   clear("A")
@@ -32,12 +68,8 @@ assert_checkequal(ierr, 13);
 msg_ref = msprintf(gettext("Redefining permanent variable.\n"));
 assert_checkequal (msg_err, msg_ref);
 ierr = execstr("clear(1)", "errcatch");
-assert_checkequal(ierr, 201);
-msg_ref = msprintf(gettext("%s: Wrong type for input argument #%d: A single string expected.\n"), "clear", 1);
+assert_checkequal(ierr, 207);
+msg_ref = msprintf(gettext("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), "clear", 1);
 assert_checkerror ("clear(1)", msg_ref);
-ierr = execstr("clear([""A"",""B""])", "errcatch");
-assert_checkequal(ierr, 999);
-msg_ref = msprintf(gettext("%s: Wrong size for input argument #%d: A single string expected.\n"), "clear", 1);
-assert_checkerror ("clear([""A"",""B""])", msg_ref);
 ierr = execstr("clear toto", "errcatch");
 assert_checkequal(ierr, 0);
index aea8855..02bb13f 100644 (file)
@@ -5,10 +5,11 @@
 //  This file is distributed under the same license as the Scilab package.
 // =============================================================================
 // <-- CLI SHELL MODE -->
-//
 
 // <-- JVM NOT MANDATORY -->
 
+// Run with test_run('core, 'clear')
+
 A = 2;
 B = 4;
 C = 6;
@@ -21,6 +22,47 @@ clear();
 assert_checkequal(isdef("A"), %f);
 assert_checkequal(isdef("C"), %f);
 
+A = 2;
+B = 4;
+C = 6;
+D = 8;
+clear( ["A" "B" "C" "D"] );
+assert_checkequal(isdef("A"), %f);
+assert_checkequal(isdef("B"), %f);
+assert_checkequal(isdef("C"), %f);
+assert_checkequal(isdef("D"), %f);
+
+A = 2;
+B = 4;
+C = 6;
+D = 8;
+clear( ["A" ; "B" ; "C" ; "D"] );
+assert_checkequal(isdef("A"), %f);
+assert_checkequal(isdef("B"), %f);
+assert_checkequal(isdef("C"), %f);
+assert_checkequal(isdef("D"), %f);
+
+A = 2;
+B = 4;
+C = 6;
+D = 8;
+clear( ["A" "B" ; "C" "D"] );
+assert_checkequal(isdef("A"), %f);
+assert_checkequal(isdef("B"), %f);
+assert_checkequal(isdef("C"), %f);
+assert_checkequal(isdef("D"), %f);
+
+A = 2;
+B = 4;
+C = 6;
+D = 8;
+clear( ["A" "B"], ["C";"D"] );
+assert_checkequal(isdef("A"), %f);
+assert_checkequal(isdef("B"), %f);
+assert_checkequal(isdef("C"), %f);
+assert_checkequal(isdef("D"), %f);
+
+
 function test_clear()
   A = 6;
   clear("A")
@@ -38,14 +80,9 @@ msg_ref = msprintf(gettext("Redefining permanent variable.\n"));
 assert_checkequal (msg_err, msg_ref);
 
 ierr = execstr("clear(1)", "errcatch");
-assert_checkequal(ierr, 201);
-msg_ref = msprintf(gettext("%s: Wrong type for input argument #%d: A single string expected.\n"), "clear", 1);
+assert_checkequal(ierr, 207);
+msg_ref = msprintf(gettext("%s: Wrong type for input argument #%d: Matrix of strings expected.\n"), "clear", 1);
 assert_checkerror ("clear(1)", msg_ref);
 
-ierr = execstr("clear([""A"",""B""])", "errcatch");
-assert_checkequal(ierr, 999);
-msg_ref = msprintf(gettext("%s: Wrong size for input argument #%d: A single string expected.\n"), "clear", 1);
-assert_checkerror ("clear([""A"",""B""])", msg_ref);
-
 ierr = execstr("clear toto", "errcatch");
 assert_checkequal(ierr, 0);