Use hxx extensions instead of hpp
[scilab.git] / scilab / modules / xml / sci_gateway / cpp / sci_xmlValidate.cpp
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2011 - Scilab Enterprises - Calixte DENIZET
4  *
5  * This file must be used under the terms of the CeCILL.
6  * This source file is licensed as described in the file COPYING, which
7  * you should have received as part of this distribution.  The terms
8  * are also available at
9  * http://www.cecill.info/licences/Licence_CeCILL_V2-en.txt
10  *
11  */
12
13 #include "xml.h"
14
15 extern "C"
16 {
17 #include "gw_xml.h"
18 #include "Scierror.h"
19 #include "api_scilab.h"
20 #include "xml_mlist.h"
21 #include "localization.h"
22 }
23
24 #include "XMLObject.hxx"
25 #include "XMLDocument.hxx"
26 #include "XMLValidation.hxx"
27 #include "XMLValidationDTD.hxx"
28 #include "SplitString.hxx"
29
30 using namespace org_modules_xml;
31
32 /*--------------------------------------------------------------------------*/
33 int sci_xmlValidate(char *fname, unsigned long fname_len)
34 {
35     XMLValidation *validation = 0;
36
37     org_modules_xml::XMLDocument * doc = 0;
38     SciErr err;
39     int *addr = 0;
40
41     std::string error;
42     std::string msg;
43     int id;
44     bool isValid;
45     char **path = 0;
46     int row = 0;
47     int col = 0;
48
49     CheckLhs(1, 1);
50     CheckRhs(1, 2);
51
52     err = getVarAddressFromPosition(pvApiCtx, 1, &addr);
53     if (err.iErr)
54     {
55         printError(&err, 0);
56         Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 1);
57         return 0;
58     }
59
60     if (isStringType(pvApiCtx, addr))
61     {
62         if (getAllocatedMatrixOfString(pvApiCtx, addr, &row, &col, &path) != 0)
63         {
64             Scierror(999, _("%s: No more memory.\n"), fname);
65             return 0;
66         }
67     }
68     else if (isXMLDoc(addr, pvApiCtx))
69     {
70         id = getXMLObjectId(addr, pvApiCtx);
71         doc = XMLObject::getFromId < org_modules_xml::XMLDocument > (id);
72         if (!doc)
73         {
74             Scierror(999, gettext("%s: XML document does not exist\n"), fname);
75             return 0;
76         }
77     }
78     else
79     {
80         Scierror(999, gettext("%s: Wrong type for input argument #%d: A matrix of strings or a XMLDoc expected.\n"), fname, 1);
81         return 0;
82     }
83
84     if (Rhs == 2)
85     {
86         err = getVarAddressFromPosition(pvApiCtx, 2, &addr);
87         if (err.iErr)
88         {
89             printError(&err, 0);
90             Scierror(999, _("%s: Can not read input argument #%d.\n"), fname, 2);
91             return 0;
92         }
93
94         if (!isXMLValid(addr, pvApiCtx))
95         {
96             Scierror(999, gettext("%s: Wrong type for input argument #%d: A %s expected.\n"), fname, 1, "XMLValid");
97             return 0;
98         }
99
100         id = getXMLObjectId(addr, pvApiCtx);
101         validation = XMLObject::getFromId < XMLValidation > (id);
102         if (!validation)
103         {
104             Scierror(999, gettext("%s: XML validation file does not exist.\n"), fname);
105             return 0;
106         }
107     }
108     else
109     {
110         validation = new XMLValidationDTD();
111     }
112
113     if (path)
114     {
115         msg = std::string("");
116         for (int i = 0; i < row * col; i++)
117         {
118             isValid = validation->validate(path[i], &error);
119             if (!isValid)
120             {
121                 char *s = new char[strlen(gettext("The file %s is not valid:\n%s\n")) + strlen(path[i]) + error.size() + 1];
122
123                 sprintf(s, gettext("The file %s is not valid:\n%s\n"), path[i], error.c_str());
124                 msg.append(s);
125                 delete[]s;
126             }
127         }
128     }
129     else
130     {
131         isValid = validation->validate(*doc, &error);
132         if (!isValid)
133         {
134             msg = error;
135         }
136     }
137
138     if (!msg.empty())
139     {
140         std::vector < std::string > lines = std::vector < std::string > ();
141         SplitString::split(msg, lines);
142         std::vector < const char *>clines = std::vector < const char *>(lines.size());
143
144         for (unsigned int i = 0; i < lines.size(); i++)
145         {
146             clines[i] = lines[i].c_str();
147         }
148
149         if (clines.size())
150         {
151             err = createMatrixOfString(pvApiCtx, Rhs + 1, (int)lines.size(), 1, const_cast < const char *const *>(&(clines[0])));
152         }
153         else
154         {
155             err = createMatrixOfDouble(pvApiCtx, Rhs + 1, 0, 0, 0);
156         }
157     }
158     else
159     {
160         err = createMatrixOfDouble(pvApiCtx, Rhs + 1, 0, 0, 0);
161     }
162
163     if (err.iErr)
164     {
165         printError(&err, 0);
166         Scierror(999, _("%s: Memory allocation error.\n"), fname);
167         return 0;
168     }
169
170     LhsVar(1) = Rhs + 1;
171     PutLhsVar();
172
173     return 0;
174 }
175
176 /*--------------------------------------------------------------------------*/