Fix Coverity issues introduced by https://codereview.scilab.org/#/c/13430/ ...
[scilab.git] / scilab / modules / xml / src / c / XMLMlistsManagement.c
1 /*
2  * Scilab ( http://www.scilab.org/ ) - This file is part of Scilab
3  * Copyright (C) 2012-2014 - 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.1-en.txt
10  *
11  */
12
13 #include "xml_mlist.h"
14 #include "api_scilab.h"
15 #include "Scierror.h"
16 #include "MALLOC.h"
17
18 static const char *_XMLDoc[] = { "XMLDoc", "_id" };
19 static const char *_XMLElem[] = { "XMLElem", "_id" };
20 static const char *_XMLAttr[] = { "XMLAttr", "_id" };
21 static const char *_XMLNs[] = { "XMLNs", "_id" };
22 static const char *_XMLList[] = { "XMLList", "_id" };
23 static const char *_XMLNotHandled[] = { "XMLNH", "_id" };
24 static const char *_XMLSet[] = { "XMLSet", "_id" };
25 static const char *_XMLValid[] = { "XMLValid", "_id" };
26
27 static int getMListType(int * mlist, void * pvApiCtx);
28
29 /*--------------------------------------------------------------------------*/
30 int createXMLObjectAtPos(int type, int pos, int id, void *pvApiCtx)
31 {
32     const char **fields = NULL;
33     int *mlistaddr = NULL;
34     SciErr err;
35
36     switch (type)
37     {
38         case XMLDOCUMENT:
39             ;
40             fields = _XMLDoc;
41             break;
42         case XMLELEMENT:
43             ;
44             fields = _XMLElem;
45             break;
46         case XMLATTRIBUTE:
47             ;
48             fields = _XMLAttr;
49             break;
50         case XMLNAMESPACE:
51             ;
52             fields = _XMLNs;
53             break;
54         case XMLLIST:
55             ;
56             fields = _XMLList;
57             break;
58         case XMLNOTHANDLED:
59             ;
60             fields = _XMLNotHandled;
61             break;
62         case XMLSET:
63             ;
64             fields = _XMLSet;
65             break;
66         case XMLVALID:
67             ;
68             fields = _XMLValid;
69             break;
70     }
71
72     err = createMList(pvApiCtx, pos, 2, &mlistaddr);
73     if (err.iErr)
74     {
75         printError(&err, 0);
76         return 0;
77     }
78
79     err = createMatrixOfStringInList(pvApiCtx, pos, mlistaddr, 1, 1, 2, fields);
80     if (err.iErr)
81     {
82         printError(&err, 0);
83         return 0;
84     }
85
86     err = createMatrixOfInteger32InList(pvApiCtx, pos, mlistaddr, 2, 1, 1, &id);
87     if (err.iErr)
88     {
89         printError(&err, 0);
90         return 0;
91     }
92     return 1;
93 }
94
95 /*--------------------------------------------------------------------------*/
96 int createXMLObjectAtPosInList(int *list, int stackPos, int type, int pos, int id, void *pvApiCtx)
97 {
98     const char **fields = NULL;
99     int *mlistaddr = NULL;
100     SciErr err;
101
102     err = createMListInList(pvApiCtx, stackPos, list, pos, 2, &mlistaddr);
103     if (err.iErr)
104     {
105         printError(&err, 0);
106         return 0;
107     }
108
109     switch (type)
110     {
111         case XMLDOCUMENT:
112             ;
113             fields = _XMLDoc;
114             break;
115         case XMLELEMENT:
116             ;
117             fields = _XMLElem;
118             break;
119         case XMLATTRIBUTE:
120             ;
121             fields = _XMLAttr;
122             break;
123         case XMLNAMESPACE:
124             ;
125             fields = _XMLNs;
126             break;
127         case XMLLIST:
128             ;
129             fields = _XMLList;
130             break;
131         case XMLNOTHANDLED:
132             ;
133             fields = _XMLNotHandled;
134             break;
135         case XMLSET:
136             ;
137             fields = _XMLSet;
138             break;
139         case XMLVALID:
140             ;
141             fields = _XMLValid;
142             break;
143     }
144
145     err = createMatrixOfStringInList(pvApiCtx, stackPos, mlistaddr, 1, 1, 2, fields);
146     if (err.iErr)
147     {
148         printError(&err, 0);
149         return 0;
150     }
151
152     err = createMatrixOfInteger32InList(pvApiCtx, stackPos, mlistaddr, 2, 1, 1, &id);
153     if (err.iErr)
154     {
155         printError(&err, 0);
156         return 0;
157     }
158
159     return 1;
160 }
161
162 /*--------------------------------------------------------------------------*/
163 int isXMLDoc(int *mlist, void *pvApiCtx)
164 {
165     return getMListType(mlist, pvApiCtx) == XMLDOCUMENT;
166 }
167
168 /*--------------------------------------------------------------------------*/
169 int isXMLElem(int *mlist, void *pvApiCtx)
170 {
171     return getMListType(mlist, pvApiCtx) == XMLELEMENT;
172 }
173
174 /*--------------------------------------------------------------------------*/
175 int isXMLAttr(int *mlist, void *pvApiCtx)
176 {
177     return getMListType(mlist, pvApiCtx) == XMLATTRIBUTE;
178 }
179
180 /*--------------------------------------------------------------------------*/
181 int isXMLNs(int *mlist, void *pvApiCtx)
182 {
183     return getMListType(mlist, pvApiCtx) == XMLNAMESPACE;
184 }
185
186 /*--------------------------------------------------------------------------*/
187 int isXMLList(int *mlist, void *pvApiCtx)
188 {
189     return getMListType(mlist, pvApiCtx) == XMLLIST;
190 }
191
192 /*--------------------------------------------------------------------------*/
193 int isXMLNotHandled(int *mlist, void *pvApiCtx)
194 {
195     return getMListType(mlist, pvApiCtx) == XMLNOTHANDLED;
196 }
197
198 /*--------------------------------------------------------------------------*/
199 int isXMLSet(int *mlist, void *pvApiCtx)
200 {
201     return getMListType(mlist, pvApiCtx) == XMLSET;
202 }
203
204 /*--------------------------------------------------------------------------*/
205 int isXMLValid(int *mlist, void *pvApiCtx)
206 {
207     return getMListType(mlist, pvApiCtx) == XMLVALID;
208 }
209
210 /*--------------------------------------------------------------------------*/
211 int isXMLObject(int *mlist, void *pvApiCtx)
212 {
213     const int type = getMListType(mlist, pvApiCtx);
214     return type == XMLDOCUMENT || type == XMLELEMENT || type == XMLATTRIBUTE || type == XMLNAMESPACE || type == XMLLIST || type == XMLNOTHANDLED || type == XMLSET || type == XMLVALID;
215 }
216
217 /*--------------------------------------------------------------------------*/
218 int isXMLObjects(const int * types, int nb, int *mlist, void *pvApiCtx)
219 {
220     const int type = getMListType(mlist, pvApiCtx);
221     int i = 0;
222     for (; i < nb; i++)
223     {
224         if (type == types[i])
225         {
226             return i;
227         }
228     }
229
230     return -1;
231 }
232 /*--------------------------------------------------------------------------*/
233 int getXMLObjectId(int *mlist, void *pvApiCtx)
234 {
235     int *id = NULL;
236     int row, col;
237
238     SciErr err = getMatrixOfInteger32InList(pvApiCtx, mlist, 2, &row, &col, &id);
239
240     if (err.iErr)
241     {
242         printError(&err, 0);
243         return -1;
244     }
245
246     return *id;
247 }
248
249 /*--------------------------------------------------------------------------*/
250 int getMListType(int * mlist, void * pvApiCtx)
251 {
252     if (mlist[0] != sci_mlist || mlist[1] != 2)
253     {
254         return -1;
255     }
256
257     if (mlist[6] != sci_strings || mlist[7] != 1 || mlist[8] != 2)
258     {
259         // first field is not a matrix 1x2 of strings
260         return -1;
261     }
262
263     if (mlist[13] == -33 && mlist[14] == -22 && mlist[15] == -21)
264     {
265         if (mlist[11] - 1 == strlen("XMLDoc") && mlist[16] == -13 && mlist[17] == 24  && mlist[18] == 12)
266         {
267             return XMLDOCUMENT;
268         }
269         if (mlist[11] - 1 == strlen("XMLElem") && mlist[16] == -14 && mlist[17] == 21 && mlist[18] == 14 && mlist[19] == 22)
270         {
271             return XMLELEMENT;
272         }
273         if (mlist[11] - 1 == strlen("XMLAttr") && mlist[16] == -10 && mlist[17] == 29 && mlist[18] == 29 && mlist[19] == 27)
274         {
275             return XMLATTRIBUTE;
276         }
277         if (mlist[11] - 1 == strlen("XMLNs") && mlist[16] == -23 && mlist[17] == 28)
278         {
279             return XMLNAMESPACE;
280         }
281         if (mlist[11] - 1 == strlen("XMLList") && mlist[16] == -21 && mlist[17] == 18 && mlist[18] == 28 && mlist[19] == 29)
282         {
283             return XMLLIST;
284         }
285         if (mlist[11] - 1 == strlen("XMLNH") && mlist[16] == -23 && mlist[17] == 17)
286         {
287             return XMLNOTHANDLED;
288         }
289         if (mlist[11] - 1 == strlen("XMLSet") && mlist[16] == -28 && mlist[17] == 14 && mlist[18] == 29)
290         {
291             return XMLSET;
292         }
293         if (mlist[11] - 1 == strlen("XMLValid") && mlist[16] == -31 && mlist[17] == 10 && mlist[18] == 21 && mlist[19] == 18 && mlist[20] == 13)
294         {
295             return XMLVALID;
296         }
297     }
298
299     return -1;
300 }