1 /*-------------------------------------------------------------------------
2 * drawElements Quality Program Helper Library
3 * -------------------------------------------
4 *
5 * Copyright 2014 The Android Open Source Project
6 *
7 * Licensed under the Apache License, Version 2.0 (the "License");
8 * you may not use this file except in compliance with the License.
9 * You may obtain a copy of the License at
10 *
11 * http://www.apache.org/licenses/LICENSE-2.0
12 *
13 * Unless required by applicable law or agreed to in writing, software
14 * distributed under the License is distributed on an "AS IS" BASIS,
15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16 * See the License for the specific language governing permissions and
17 * limitations under the License.
18 *
19 *//*!
20 * \file
21 * \brief XML Writer.
22 *//*--------------------------------------------------------------------*/
23
24 #include "qpXmlWriter.h"
25
26 #include "deMemory.h"
27 #include "deInt32.h"
28
29 /*------------------------------------------------------------------------
30 * qpXmlWriter stand-alone implementation.
31 *----------------------------------------------------------------------*/
32
33 #include "deMemPool.h"
34 #include "dePoolArray.h"
35
36 struct qpXmlWriter_s
37 {
38 FILE* outputFile;
39 deBool flushAfterWrite;
40
41 deBool xmlPrevIsStartElement;
42 deBool xmlIsWriting;
43 int xmlElementDepth;
44 };
45
writeEscaped(qpXmlWriter * writer,const char * str)46 static deBool writeEscaped (qpXmlWriter* writer, const char* str)
47 {
48 char buf[256 + 10];
49 char* d = &buf[0];
50 const char* s = str;
51 deBool isEOS = DE_FALSE;
52
53 do
54 {
55 /* Check for characters that need to be escaped. */
56 const char* repl = DE_NULL;
57 switch (*s)
58 {
59 case 0: isEOS = DE_TRUE; break;
60 case '<': repl = "<"; break;
61 case '>': repl = ">"; break;
62 case '&': repl = "&"; break;
63 case '\'': repl = "'"; break;
64 case '"': repl = """; break;
65
66 /* Non-printable characters. */
67 case 1: repl = "<SOH>"; break;
68 case 2: repl = "<STX>"; break;
69 case 3: repl = "<ETX>"; break;
70 case 4: repl = "<EOT>"; break;
71 case 5: repl = "<ENQ>"; break;
72 case 6: repl = "<ACK>"; break;
73 case 7: repl = "<BEL>"; break;
74 case 8: repl = "<BS>"; break;
75 case 11: repl = "<VT>"; break;
76 case 12: repl = "<FF>"; break;
77 case 14: repl = "<SO>"; break;
78 case 15: repl = "<SI>"; break;
79 case 16: repl = "<DLE>"; break;
80 case 17: repl = "<DC1>"; break;
81 case 18: repl = "<DC2>"; break;
82 case 19: repl = "<DC3>"; break;
83 case 20: repl = "<DC4>"; break;
84 case 21: repl = "<NAK>"; break;
85 case 22: repl = "<SYN>"; break;
86 case 23: repl = "<ETB>"; break;
87 case 24: repl = "<CAN>"; break;
88 case 25: repl = "<EM>"; break;
89 case 26: repl = "<SUB>"; break;
90 case 27: repl = "<ESC>"; break;
91 case 28: repl = "<FS>"; break;
92 case 29: repl = "<GS>"; break;
93 case 30: repl = "<RS>"; break;
94 case 31: repl = "<US>"; break;
95
96 default: /* nada */ break;
97 }
98
99 /* Write out char or escape sequence. */
100 if (repl)
101 {
102 s++;
103 strcpy(d, repl);
104 d += strlen(repl);
105 }
106 else
107 *d++ = *s++;
108
109 /* Write buffer if EOS or buffer full. */
110 if (isEOS || ((d - &buf[0]) >= 4))
111 {
112 *d = 0;
113 fputs(buf, writer->outputFile);
114 d = &buf[0];
115 }
116 } while (!isEOS);
117
118 if (writer->flushAfterWrite)
119 fflush(writer->outputFile);
120 DE_ASSERT(d == &buf[0]); /* buffer must be empty */
121 return DE_TRUE;
122 }
123
qpXmlWriter_createFileWriter(FILE * outputFile,deBool useCompression,deBool flushAfterWrite)124 qpXmlWriter* qpXmlWriter_createFileWriter (FILE* outputFile, deBool useCompression, deBool flushAfterWrite)
125 {
126 qpXmlWriter* writer = (qpXmlWriter*)deCalloc(sizeof(qpXmlWriter));
127 if (!writer)
128 return DE_NULL;
129
130 DE_UNREF(useCompression); /* no compression supported. */
131
132 writer->outputFile = outputFile;
133 writer->flushAfterWrite = flushAfterWrite;
134
135 return writer;
136 }
137
qpXmlWriter_destroy(qpXmlWriter * writer)138 void qpXmlWriter_destroy (qpXmlWriter* writer)
139 {
140 DE_ASSERT(writer);
141
142 deFree(writer);
143 }
144
closePending(qpXmlWriter * writer)145 static deBool closePending (qpXmlWriter* writer)
146 {
147 if (writer->xmlPrevIsStartElement)
148 {
149 fprintf(writer->outputFile, ">\n");
150 writer->xmlPrevIsStartElement = DE_FALSE;
151 }
152
153 return DE_TRUE;
154 }
155
qpXmlWriter_flush(qpXmlWriter * writer)156 void qpXmlWriter_flush (qpXmlWriter* writer)
157 {
158 closePending(writer);
159 }
160
qpXmlWriter_startDocument(qpXmlWriter * writer,deBool writeXmlHeader)161 deBool qpXmlWriter_startDocument (qpXmlWriter* writer, deBool writeXmlHeader)
162 {
163 DE_ASSERT(writer && !writer->xmlIsWriting);
164 writer->xmlIsWriting = DE_TRUE;
165 writer->xmlElementDepth = 0;
166 writer->xmlPrevIsStartElement = DE_FALSE;
167 if(writeXmlHeader)
168 {
169 fprintf(writer->outputFile, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
170 }
171 return DE_TRUE;
172 }
173
getIndentStr(int indentLevel)174 static const char* getIndentStr (int indentLevel)
175 {
176 static const char s_indentStr[33] = " ";
177 static const int s_indentStrLen = 32;
178 return &s_indentStr[s_indentStrLen - deMin32(s_indentStrLen, indentLevel)];
179 }
180
qpXmlWriter_endDocument(qpXmlWriter * writer)181 deBool qpXmlWriter_endDocument (qpXmlWriter* writer)
182 {
183 DE_ASSERT(writer);
184 DE_ASSERT(writer->xmlIsWriting);
185 DE_ASSERT(writer->xmlElementDepth == 0);
186 closePending(writer);
187 writer->xmlIsWriting = DE_FALSE;
188 return DE_TRUE;
189 }
190
qpXmlWriter_writeString(qpXmlWriter * writer,const char * str)191 deBool qpXmlWriter_writeString (qpXmlWriter* writer, const char* str)
192 {
193 if (writer->xmlPrevIsStartElement)
194 {
195 fprintf(writer->outputFile, ">");
196 writer->xmlPrevIsStartElement = DE_FALSE;
197 }
198
199 return writeEscaped(writer, str);
200 }
201
qpXmlWriter_startElement(qpXmlWriter * writer,const char * elementName,int numAttribs,const qpXmlAttribute * attribs)202 deBool qpXmlWriter_startElement(qpXmlWriter* writer, const char* elementName, int numAttribs, const qpXmlAttribute* attribs)
203 {
204 int ndx;
205
206 closePending(writer);
207
208 fprintf(writer->outputFile, "%s<%s", getIndentStr(writer->xmlElementDepth), elementName);
209
210 for (ndx = 0; ndx < numAttribs; ndx++)
211 {
212 const qpXmlAttribute* attrib = &attribs[ndx];
213 fprintf(writer->outputFile, " %s=\"", attrib->name);
214 switch (attrib->type)
215 {
216 case QP_XML_ATTRIBUTE_STRING:
217 writeEscaped(writer, attrib->stringValue);
218 break;
219
220 case QP_XML_ATTRIBUTE_INT:
221 {
222 char buf[64];
223 sprintf(buf, "%d", attrib->intValue);
224 writeEscaped(writer, buf);
225 break;
226 }
227
228 case QP_XML_ATTRIBUTE_BOOL:
229 writeEscaped(writer, attrib->boolValue ? "True" : "False");
230 break;
231
232 default:
233 DE_ASSERT(DE_FALSE);
234 }
235 fprintf(writer->outputFile, "\"");
236 }
237
238 writer->xmlElementDepth++;
239 writer->xmlPrevIsStartElement = DE_TRUE;
240 return DE_TRUE;
241 }
242
qpXmlWriter_endElement(qpXmlWriter * writer,const char * elementName)243 deBool qpXmlWriter_endElement (qpXmlWriter* writer, const char* elementName)
244 {
245 DE_ASSERT(writer && writer->xmlElementDepth > 0);
246 writer->xmlElementDepth--;
247
248 if (writer->xmlPrevIsStartElement) /* leave flag as-is */
249 {
250 fprintf(writer->outputFile, " />\n");
251 writer->xmlPrevIsStartElement = DE_FALSE;
252 }
253 else
254 fprintf(writer->outputFile, "</%s>\n", /*getIndentStr(writer->xmlElementDepth),*/ elementName);
255
256 return DE_TRUE;
257 }
258
qpXmlWriter_writeBase64(qpXmlWriter * writer,const deUint8 * data,size_t numBytes)259 deBool qpXmlWriter_writeBase64 (qpXmlWriter* writer, const deUint8* data, size_t numBytes)
260 {
261 static const char s_base64Table[64] =
262 {
263 'A','B','C','D','E','F','G','H','I','J','K','L','M',
264 'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
265 'a','b','c','d','e','f','g','h','i','j','k','l','m',
266 'n','o','p','q','r','s','t','u','v','w','x','y','z',
267 '0','1','2','3','4','5','6','7','8','9','+','/'
268 };
269
270 int numWritten = 0;
271 size_t srcNdx = 0;
272 deBool writeIndent = DE_TRUE;
273 const char* indentStr = getIndentStr(writer->xmlElementDepth);
274
275 DE_ASSERT(writer && data && (numBytes > 0));
276
277 /* Close and pending writes. */
278 closePending(writer);
279
280 /* Loop all input chars. */
281 while (srcNdx < numBytes)
282 {
283 size_t numRead = (size_t)deMin32(3, (int)(numBytes - srcNdx));
284 deUint8 s0 = data[srcNdx];
285 deUint8 s1 = (numRead >= 2) ? data[srcNdx+1] : 0;
286 deUint8 s2 = (numRead >= 3) ? data[srcNdx+2] : 0;
287 char d[5];
288
289 srcNdx += numRead;
290
291 d[0] = s_base64Table[s0 >> 2];
292 d[1] = s_base64Table[((s0&0x3)<<4) | (s1>>4)];
293 d[2] = s_base64Table[((s1&0xF)<<2) | (s2>>6)];
294 d[3] = s_base64Table[s2&0x3F];
295 d[4] = 0;
296
297 if (numRead < 3) d[3] = '=';
298 if (numRead < 2) d[2] = '=';
299
300 /* Write indent (if needed). */
301 if (writeIndent)
302 {
303 fprintf(writer->outputFile, "%s", indentStr);
304 writeIndent = DE_FALSE;
305 }
306
307 /* Write data. */
308 fprintf(writer->outputFile, "%s", &d[0]);
309
310 /* EOL every now and then. */
311 numWritten += 4;
312 if (numWritten >= 64)
313 {
314 fprintf(writer->outputFile, "\n");
315 numWritten = 0;
316 writeIndent = DE_TRUE;
317 }
318 }
319
320 /* Last EOL. */
321 if (numWritten > 0)
322 fprintf(writer->outputFile, "\n");
323
324 DE_ASSERT(srcNdx == numBytes);
325 return DE_TRUE;
326 }
327
328 /* Common helper functions. */
329
qpXmlWriter_writeStringElement(qpXmlWriter * writer,const char * elementName,const char * elementContent)330 deBool qpXmlWriter_writeStringElement (qpXmlWriter* writer, const char* elementName, const char* elementContent)
331 {
332 if (!qpXmlWriter_startElement(writer, elementName, 0, DE_NULL) ||
333 (elementContent && !qpXmlWriter_writeString(writer, elementContent)) ||
334 !qpXmlWriter_endElement(writer, elementName))
335 return DE_FALSE;
336
337 return DE_TRUE;
338 }
339