XML: xmlValidate now returns the error msg or [] 40/4840/2
Calixte DENIZET [Sun, 4 Sep 2011 11:13:38 +0000 (13:13 +0200)]
Change-Id: Ieb89aef7ecfffba0c0da6e92d62bed0bceb7dce8

15 files changed:
scilab/modules/xml/help/en_US/xmlValidate.xml
scilab/modules/xml/sci_gateway/cpp/sci_xmlDump.cpp
scilab/modules/xml/sci_gateway/cpp/sci_xmlValidate.cpp
scilab/modules/xml/src/cpp/SplitString.hxx [new file with mode: 0644]
scilab/modules/xml/src/cpp/XMLAttr.cpp
scilab/modules/xml/src/cpp/XMLDocument.cpp
scilab/modules/xml/src/cpp/XMLElement.cpp
scilab/modules/xml/src/cpp/XMLList.cpp
scilab/modules/xml/src/cpp/XMLNotHandledElement.cpp
scilab/modules/xml/src/cpp/XMLNs.cpp
scilab/modules/xml/src/cpp/XMLObject.hxx
scilab/modules/xml/src/cpp/XMLValidationDTD.cpp
scilab/modules/xml/src/cpp/XMLValidationDTD.hxx
scilab/modules/xml/src/cpp/XMLValidationRelaxNG.cpp
scilab/modules/xml/src/cpp/XMLValidationSchema.cpp

index f70002e..1502167 100644 (file)
@@ -30,7 +30,7 @@
     <title>Calling Sequence</title>
 
     <synopsis>
-      xmlValidate(docs [, valid])
+      error = xmlValidate(docs [, valid])
     </synopsis>
   </refsynopsisdiv>
 
           <para>a mlist typed XMLValid.</para>
         </listitem>
       </varlistentry>
+
+      <varlistentry>
+        <term>error</term>
+        <listitem>
+          <para>a matrix of string if an error occured or []</para>
+        </listitem>
+      </varlistentry>
     </variablelist>
   </refsection>
 
   <refsection>
     <title>Description</title>
 
-    <para>Validate a already parsed document or a set of documents with given paths with a DTD, a Relax NG or a Schema. To know if a document is valid or not, you just have to put the xmlValidate in a try...catch statement.</para>
+    <para>Validate a already parsed document or a set of documents with given paths with a DTD, a Relax NG or a Schema. If the document is valid, then the returned error is an empty matrix, else a matrix of strings is returned with the error message.</para>
     <para>Validate a document with its path can improve performance and reduce the memory consumption.</para>
     <para>It is not possible for the moment to validate a document against an external DTD. The only way to do this is to include in your XML file someting like <![CDATA[<!DOCTYPE foo SYSTEM "foo.dtd">]]> and to use xmlValidate without second argument.</para>
   </refsection>
index 0996063..d93c67d 100644 (file)
@@ -10,6 +10,7 @@
  *
  */
 
+#include <string>
 #include <vector>
 
 #include "XMLObject.hxx"
@@ -17,6 +18,7 @@
 #include "XMLElement.hxx"
 #include "XMLNs.hxx"
 #include "XMLAttr.hxx"
+#include "SplitString.hxx"
 
 extern "C"
 {
@@ -38,9 +40,8 @@ int sci_xmlDump(char *fname, unsigned long fname_len)
     int type;
     SciErr err;
     int * addr = 0;
-    char * dump;
-    std::string str;
-    std::vector<char *> vector;
+    std::vector<std::string> lines;
+    std::vector<const char *> clines;
 
     CheckLhs(1, 1);
     CheckRhs(1, 1);
@@ -67,20 +68,18 @@ int sci_xmlDump(char *fname, unsigned long fname_len)
         return 0;
     }
 
-    str = obj->dump();
-    dump = const_cast<char *>(str.c_str());
-    vector = std::vector<char *>();
+    lines = std::vector<std::string>();
+    SplitString::split(obj->dump(), lines);
+    clines = std::vector<const char *>(lines.size());
 
-    dump = strtok(dump, "\n\r");
-    while (dump)
+    for (unsigned int i = 0; i < lines.size(); i++)
     {
-        vector.push_back(dump);
-        dump = strtok(0, "\n\r");
+        clines[i] = lines[i].c_str();
     }
 
-    if (vector.size())
+    if (clines.size())
     {
-        err = createMatrixOfString(pvApiCtx, Rhs + 1, vector.size(), 1, const_cast<const char * const *>(&(vector[0])));
+        err = createMatrixOfString(pvApiCtx, Rhs + 1, lines.size(), 1, const_cast<const char * const *>(&(clines[0])));
     }
     else
     {
index e1e79c5..77d152c 100644 (file)
@@ -10,9 +10,6 @@
  *
  */
 
-#include "XMLObject.hxx"
-#include "XMLDocument.hxx"
-
 extern "C"
 {
 #include "xml.h"
@@ -28,6 +25,7 @@ extern "C"
 #include "XMLDocument.hxx"
 #include "XMLValidation.hxx"
 #include "XMLValidationDTD.hxx"
+#include "SplitString.hxx"
 
 using namespace org_modules_xml;
 
@@ -39,6 +37,7 @@ int sci_xmlValidate(char * fname, unsigned long fname_len)
     SciErr err;
     int * addr = 0;
     std::string error;
+    std::string msg;
     int id;
     bool isValid;
     char ** path = 0;
@@ -100,12 +99,12 @@ int sci_xmlValidate(char * fname, unsigned long fname_len)
     }
     else
     {
-       validation = new XMLValidationDTD(&error);
+        validation = new XMLValidationDTD();
     }
 
     if (path)
     {
-        std::string msg = std::string("");
+        msg = std::string("");
         for (int i = 0; i < row * col; i++)
         {
             isValid = validation->validate(path[i], &error);
@@ -117,23 +116,48 @@ int sci_xmlValidate(char * fname, unsigned long fname_len)
                 delete [] s;
             }
         }
-        if (!msg.empty())
-        {
-            Scierror(999, "%s: %s", fname, msg.c_str());
-            return 0;
-        }
     }
     else
     {
         isValid = validation->validate(*doc, &error);
         if (!isValid)
         {
-            Scierror(999, gettext("%s: The file is not valid:\n%s"), fname, error.c_str());
-            return 0;
+            msg = error;
         }
     }
 
-    LhsVar(1) = 0;
+    if (!msg.empty())
+    {
+        std::vector<std::string> lines = std::vector<std::string>();
+        SplitString::split(msg, lines);
+        std::vector<const char *> clines = std::vector<const char *>(lines.size());
+
+        for (unsigned int i = 0; i < lines.size(); i++)
+        {
+            clines[i] = lines[i].c_str();
+        }
+
+        if (clines.size())
+        {
+            err = createMatrixOfString(pvApiCtx, Rhs + 1, lines.size(), 1, const_cast<const char * const *>(&(clines[0])));
+        }
+        else
+        {
+            err = createMatrixOfDouble(pvApiCtx, Rhs + 1, 0, 0, 0);
+        }
+    }
+    else
+    {
+        err = createMatrixOfDouble(pvApiCtx, Rhs + 1, 0, 0, 0);
+    }
+
+    if (err.iErr)
+    {
+        printError(&err, 0);
+        return 0;
+    }
+
+    LhsVar(1) = Rhs + 1;
     PutLhsVar();
 
     return 0;
diff --git a/scilab/modules/xml/src/cpp/SplitString.hxx b/scilab/modules/xml/src/cpp/SplitString.hxx
new file mode 100644 (file)
index 0000000..9e01d97
--- /dev/null
@@ -0,0 +1,52 @@
+/*
+ * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
+ * Copyright (C) 2011 - DIGITEO - Calixte DENIZET
+ *
+ * This file must be used under the terms of the CeCILL.
+ * This source file is licensed as described in the file COPYING, which
+ * you should have received as part of this distribution.  The terms
+ * are also available at
+ * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
+ *
+ */
+
+#ifndef __SPLITSTRING_HXX__
+#define __SPLITSTRING_HXX__
+
+#include <string>
+#include <vector>
+
+namespace org_modules_xml
+{
+    /**
+     * @file
+     * @author Calixte DENIZET <calixte.denizet@scilab.org>
+     *
+     * Split a string into lines
+     */
+    class SplitString
+    {
+
+    public :
+
+        /**
+         * Split string into lines
+         * @param str the string to split
+         * @param lines a vector which will contain lines
+         */
+        static void split(const std::string & str, std::vector<std::string> & lines)
+            {
+                std::string::size_type lastPos = str.find_first_not_of("\n", 0);
+                std::string::size_type pos = str.find_first_of("\n", lastPos);
+
+                while (std::string::npos != pos || std::string::npos != lastPos)
+                {
+                    lines.push_back(str.substr(lastPos, pos - lastPos));
+                    lastPos = str.find_first_not_of("\n", pos);
+                    pos = str.find_first_of("\n", lastPos);
+                }
+            }
+    };
+}
+
+#endif
index 309737f..f9bf687 100644 (file)
@@ -153,21 +153,22 @@ namespace org_modules_xml
 
     const std::string XMLAttr::toString() const
     {
-        std::string str = "XML Attributes\n";
+        std::ostringstream oss;
         xmlNode * node = elem.getRealNode();
 
+        oss << "XML Attributes" << std::endl;
         for (xmlAttr * cur = node->properties; cur; cur = cur->next)
         {
             if (cur->ns)
             {
-                str += " " + std::string((const char *)cur->ns->prefix) + ":" + std::string((const char *)cur->name) + " --> " + std::string((const char *)cur->children->content) + "\n";
+                oss << cur->ns->prefix << ":" << cur->name << " --> " << cur->children->content << std::endl;
             }
             else
             {
-                str += " " + std::string((const char *)cur->name) + " --> " + std::string((const char *)cur->children->content) + "\n";
+                oss << cur->name << " --> " << cur->children->content << std::endl;
             }
         }
 
-        return str;
+        return oss.str();
     }
 }
index 1841e88..e7a82e8 100644 (file)
@@ -159,10 +159,12 @@ namespace org_modules_xml
 
     const std::string XMLDocument::toString() const
     {
-        std::string str = "XML Document\n";
-        str += "URL: " + std::string(getDocumentURL());
+        std::ostringstream oss;
 
-        return str;
+        oss << "XML Document" << std::endl;
+        oss << "URL: " << getDocumentURL();
+
+        return oss.str();
     }
 
     const std::string XMLDocument::dump() const
@@ -286,12 +288,6 @@ namespace org_modules_xml
         return doc;
     }
 
-    /**
-     * Read and parse a document
-     * @param filename the file name
-     * @param error a string where to write the parsing errors
-     * @return a pointer on a xmlDoc
-     */
     xmlDoc * XMLDocument::readDocument(const std::string & xmlCode, bool validate, std::string * error)
     {
         xmlParserCtxt * ctxt = initContext(error, validate);
index ffcda42..d260bf7 100644 (file)
@@ -120,7 +120,7 @@ namespace org_modules_xml
 
     void XMLElement::setChildren(const std::string & xmlCode) const
     {
-       std::string error;
+        std::string error;
         XMLDocument document = XMLDocument(xmlCode, false, &error);
 
         if (error.empty())
@@ -175,6 +175,7 @@ namespace org_modules_xml
 
     const std::string XMLElement::toString() const
     {
+        std::ostringstream oss;
         std::string ns = "";
         std::string prefix = "";
 
@@ -191,14 +192,14 @@ namespace org_modules_xml
             }
         }
 
-        std::string str = "XML Element\n";
-        str += "name: " + std::string(getNodeName()) + "\n";
-        str += "namespace href: " + ns + "\n";
-        str += "namespace prefix: " + prefix + "\n";
-        str += "type: " + std::string(nodes_type[getNodeType() - 1]) + "\n";
-        str += "definition line: " + intToStr(node->line);
+        oss << "XML Element" << std::endl;
+        oss << "name: " << getNodeName() << std::endl;
+        oss << "namespace href: " << ns << std::endl;
+        oss << "namespace prefix: " << prefix << std::endl;
+        oss << "type: " << nodes_type[getNodeType() - 1] << std::endl;
+        oss << "definition line: " << node->line;
 
-        return str;
+        return oss.str();
     }
 
     const XMLNs * XMLElement::getNodeNameSpace() const
index 29a5406..0701f15 100644 (file)
@@ -22,9 +22,11 @@ namespace org_modules_xml
 
     const std::string XMLList::toString() const
     {
-        std::string str = "XML List\n";
-        str += "size: " + intToStr(getSize());
+        std::ostringstream oss;
 
-        return str;
+        oss << "XML List" << std::endl;
+        oss << "size: " << getSize();
+
+        return oss.str();
     }
 }
index 22a1260..dfa4ae1 100644 (file)
@@ -25,12 +25,12 @@ namespace org_modules_xml
         node = _node;
         scilabType = XMLNOTHANDLED;
         id = scope->getVariableId(*this);
-       scope->registerPointers(node, this);
+        scope->registerPointers(node, this);
     }
 
     XMLNotHandledElement::~XMLNotHandledElement()
     {
-       scope->unregisterPointer(node);
+        scope->unregisterPointer(node);
         scope->removeId(id);
     }
 
@@ -41,6 +41,11 @@ namespace org_modules_xml
 
     const std::string XMLNotHandledElement::toString() const
     {
-        return std::string("Not handled XML Element\ntype") + std::string(nodes_type[node->type - 1]);
+        std::ostringstream oss;
+
+        oss << "Not handled XML Element" << std::endl;
+        oss << "type: " << nodes_type[node->type - 1];
+
+        return oss.str();
     }
 }
index 48c983f..2a05604 100644 (file)
@@ -47,10 +47,12 @@ namespace org_modules_xml
 
     const std::string XMLNs::toString() const
     {
-        std::string str = "XML Namespace\n";
-        str += "href: " + std::string(getHref()) + "\n";
-        str += "prefix: " + std::string(getPrefix());
+        std::ostringstream oss;
 
-        return str;
+        oss << "XML Namespace" << std::endl;
+        oss << "href: " << getHref() << std::endl;
+        oss << "prefix: " << getPrefix();
+
+        return oss.str();
     }
 }
index e5c726a..c583074 100644 (file)
@@ -17,7 +17,8 @@
 #include <sstream>
 #include <typeinfo>
 
-extern "C" {
+extern "C"
+{
 #include "xml_mlist.h"
 }
 
@@ -82,16 +83,6 @@ namespace org_modules_xml
         template <class T>
         static T * getFromId(int id) { return static_cast<T *>(getVariableFromId(id)); }
 
-        /**
-         * Convert a number into a string
-         */
-        static const std::string intToStr(int n)
-            {
-                std::stringstream oss;
-                oss << n;
-                return oss.str();
-            }
-
     protected :
         int id;
         int scilabType;
index 811c529..6ffe2a6 100644 (file)
@@ -48,7 +48,7 @@ namespace org_modules_xml
         id = scope->getVariableId(*this);
     }
 
-    XMLValidationDTD::XMLValidationDTD(std::string * error) : XMLValidation()
+    XMLValidationDTD::XMLValidationDTD() : XMLValidation()
     {
         validationFile = 0;
         internalValidate = true;
@@ -152,13 +152,14 @@ namespace org_modules_xml
 
     const std::string XMLValidationDTD::toString() const
     {
+        std::ostringstream oss;
         xmlDtd * dtd = getValidationFile<xmlDtd>();
 
-        std::string str = "XML DTD\n";
-        str += "name: " + std::string(dtd->name ? (const char *)dtd->name : "") + "\n";
-        str += "external ID: " + std::string(dtd->ExternalID ? (const char *)dtd->ExternalID : "") + "\n";
-        str += "system ID: " + std::string(dtd->SystemID ? (const char *)dtd->SystemID : "");
+        oss << "XML DTD" << std::endl;
+        oss << "name: " << (dtd->name ? (const char * )dtd->name : "") << std::endl;
+        oss << "external ID: " << (dtd->ExternalID ? (const char * )dtd->ExternalID : "") << std::endl;
+        oss << "system ID: " << (dtd->SystemID ? (const char * )dtd->SystemID : "");
 
-        return str;
+        return oss.str();
     }
 }
index 36f5e92..8b016fc 100644 (file)
@@ -41,9 +41,9 @@ namespace org_modules_xml
         XMLValidationDTD(const char * path, std::string * error);
 
         /**
-         * @param error a string which will contain error messages
+         * Use internal validation
          */
-        XMLValidationDTD(std::string * error);
+        XMLValidationDTD();
 
         ~XMLValidationDTD();
 
index 980d3ed..f933b36 100644 (file)
@@ -146,9 +146,6 @@ namespace org_modules_xml
 
     const std::string XMLValidationRelaxNG::toString() const
     {
-        std::string str = "XML Relax NG\n";
-        str += "No public informations";
-
-        return str;
+        return std::string("XML Relax NG\nNo public informations");
     }
 }
index 27d484d..64a3410 100644 (file)
@@ -165,14 +165,15 @@ namespace org_modules_xml
 
     const std::string XMLValidationSchema::toString() const
     {
+        std::ostringstream oss;
         xmlSchema * schema = getValidationFile<xmlSchema>();
 
-        std::string str = "XML Schema\n";
-        str += "name: " + std::string(schema->name ? (const char *)schema->name : "") + "\n";
-        str += "target namespace: " + std::string(schema->targetNamespace ? (const char *)schema->targetNamespace : "") + "\n";
-        str += "version: " + std::string(schema->version ? (const char *)schema->version : "");
+        oss << "XML Schema" << std::endl;
+        oss << "name: " << (schema->name ? (const char * )schema->name : "") << std::endl;
+        oss << "target namespace: " << (schema->targetNamespace ? (const char * )schema->targetNamespace : "") << std::endl;
+        oss << "version: " << (schema->version ? (const char * )schema->version : "");
 
-        return str;
+        return oss.str();
     }
 
 }