blob: 5850b41508fd68eac17ec0a66dab6627912fa136 [file] [log] [blame]
/*-------------------------------------------------------------------------
* drawElements Quality Program Helper Library
* -------------------------------------------
*
* Copyright 2014 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*//*!
* \file
* \brief XML Writer.
*//*--------------------------------------------------------------------*/
#include "qpXmlWriter.h"
#include "deMemory.h"
#include "deInt32.h"
/*------------------------------------------------------------------------
* qpXmlWriter stand-alone implementation.
*----------------------------------------------------------------------*/
#include "deMemPool.h"
#include "dePoolArray.h"
struct qpXmlWriter_s
{
FILE* outputFile;
deBool xmlPrevIsStartElement;
deBool xmlIsWriting;
int xmlElementDepth;
};
static deBool writeEscaped (qpXmlWriter* writer, const char* str)
{
char buf[256 + 10];
char* d = &buf[0];
const char* s = str;
deBool isEOS = DE_FALSE;
do
{
/* Check for characters that need to be escaped. */
const char* repl = DE_NULL;
switch (*s)
{
case 0: isEOS = DE_TRUE; break;
case '<': repl = "&lt;"; break;
case '>': repl = "&gt;"; break;
case '&': repl = "&amp;"; break;
case '\'': repl = "&apos;"; break;
case '"': repl = "&quot;"; break;
/* Non-printable characters. */
case 1: repl = "&lt;SOH&gt;"; break;
case 2: repl = "&lt;STX&gt;"; break;
case 3: repl = "&lt;ETX&gt;"; break;
case 4: repl = "&lt;EOT&gt;"; break;
case 5: repl = "&lt;ENQ&gt;"; break;
case 6: repl = "&lt;ACK&gt;"; break;
case 7: repl = "&lt;BEL&gt;"; break;
case 8: repl = "&lt;BS&gt;"; break;
case 11: repl = "&lt;VT&gt;"; break;
case 12: repl = "&lt;FF&gt;"; break;
case 14: repl = "&lt;SO&gt;"; break;
case 15: repl = "&lt;SI&gt;"; break;
case 16: repl = "&lt;DLE&gt;"; break;
case 17: repl = "&lt;DC1&gt;"; break;
case 18: repl = "&lt;DC2&gt;"; break;
case 19: repl = "&lt;DC3&gt;"; break;
case 20: repl = "&lt;DC4&gt;"; break;
case 21: repl = "&lt;NAK&gt;"; break;
case 22: repl = "&lt;SYN&gt;"; break;
case 23: repl = "&lt;ETB&gt;"; break;
case 24: repl = "&lt;CAN&gt;"; break;
case 25: repl = "&lt;EM&gt;"; break;
case 26: repl = "&lt;SUB&gt;"; break;
case 27: repl = "&lt;ESC&gt;"; break;
case 28: repl = "&lt;FS&gt;"; break;
case 29: repl = "&lt;GS&gt;"; break;
case 30: repl = "&lt;RS&gt;"; break;
case 31: repl = "&lt;US&gt;"; break;
default: /* nada */ break;
}
/* Write out char or escape sequence. */
if (repl)
{
s++;
strcpy(d, repl);
d += strlen(repl);
}
else
*d++ = *s++;
/* Write buffer if EOS or buffer full. */
if (isEOS || ((d - &buf[0]) >= 4))
{
*d = 0;
fprintf(writer->outputFile, "%s", buf);
d = &buf[0];
}
} while (!isEOS);
fflush(writer->outputFile);
DE_ASSERT(d == &buf[0]); /* buffer must be empty */
return DE_TRUE;
}
qpXmlWriter* qpXmlWriter_createFileWriter (FILE* outputFile, deBool useCompression)
{
qpXmlWriter* writer = (qpXmlWriter*)deCalloc(sizeof(qpXmlWriter));
if (!writer)
return DE_NULL;
DE_UNREF(useCompression); /* no compression supported. */
writer->outputFile = outputFile;
return writer;
}
void qpXmlWriter_destroy (qpXmlWriter* writer)
{
DE_ASSERT(writer);
deFree(writer);
}
static deBool closePending (qpXmlWriter* writer)
{
if (writer->xmlPrevIsStartElement)
{
fprintf(writer->outputFile, ">\n");
writer->xmlPrevIsStartElement = DE_FALSE;
}
return DE_TRUE;
}
void qpXmlWriter_flush (qpXmlWriter* writer)
{
closePending(writer);
}
deBool qpXmlWriter_startDocument (qpXmlWriter* writer)
{
DE_ASSERT(writer && !writer->xmlIsWriting);
writer->xmlIsWriting = DE_TRUE;
writer->xmlElementDepth = 0;
writer->xmlPrevIsStartElement = DE_FALSE;
fprintf(writer->outputFile, "<?xml version=\"1.0\" encoding=\"UTF-8\"?>\n");
return DE_TRUE;
}
static const char* getIndentStr (int indentLevel)
{
static const char s_indentStr[33] = " ";
static const int s_indentStrLen = 32;
return &s_indentStr[s_indentStrLen - deMin32(s_indentStrLen, indentLevel)];
}
deBool qpXmlWriter_endDocument (qpXmlWriter* writer)
{
DE_ASSERT(writer);
DE_ASSERT(writer->xmlIsWriting);
DE_ASSERT(writer->xmlElementDepth == 0);
closePending(writer);
writer->xmlIsWriting = DE_FALSE;
return DE_TRUE;
}
deBool qpXmlWriter_writeString (qpXmlWriter* writer, const char* str)
{
if (writer->xmlPrevIsStartElement)
{
fprintf(writer->outputFile, ">");
writer->xmlPrevIsStartElement = DE_FALSE;
}
return writeEscaped(writer, str);
}
deBool qpXmlWriter_startElement(qpXmlWriter* writer, const char* elementName, int numAttribs, const qpXmlAttribute* attribs)
{
int ndx;
closePending(writer);
fprintf(writer->outputFile, "%s<%s", getIndentStr(writer->xmlElementDepth), elementName);
for (ndx = 0; ndx < numAttribs; ndx++)
{
const qpXmlAttribute* attrib = &attribs[ndx];
fprintf(writer->outputFile, " %s=\"", attrib->name);
switch (attrib->type)
{
case QP_XML_ATTRIBUTE_STRING:
writeEscaped(writer, attrib->stringValue);
break;
case QP_XML_ATTRIBUTE_INT:
{
char buf[64];
sprintf(buf, "%d", attrib->intValue);
writeEscaped(writer, buf);
break;
}
case QP_XML_ATTRIBUTE_BOOL:
writeEscaped(writer, attrib->boolValue ? "True" : "False");
break;
default:
DE_ASSERT(DE_FALSE);
}
fprintf(writer->outputFile, "\"");
}
writer->xmlElementDepth++;
writer->xmlPrevIsStartElement = DE_TRUE;
return DE_TRUE;
}
deBool qpXmlWriter_endElement (qpXmlWriter* writer, const char* elementName)
{
DE_ASSERT(writer && writer->xmlElementDepth > 0);
writer->xmlElementDepth--;
if (writer->xmlPrevIsStartElement) /* leave flag as-is */
{
fprintf(writer->outputFile, " />\n");
writer->xmlPrevIsStartElement = DE_FALSE;
}
else
fprintf(writer->outputFile, "</%s>\n", /*getIndentStr(writer->xmlElementDepth),*/ elementName);
return DE_TRUE;
}
deBool qpXmlWriter_writeBase64 (qpXmlWriter* writer, const deUint8* data, int numBytes)
{
static const char s_base64Table[64] =
{
'A','B','C','D','E','F','G','H','I','J','K','L','M',
'N','O','P','Q','R','S','T','U','V','W','X','Y','Z',
'a','b','c','d','e','f','g','h','i','j','k','l','m',
'n','o','p','q','r','s','t','u','v','w','x','y','z',
'0','1','2','3','4','5','6','7','8','9','+','/'
};
int numWritten = 0;
int srcNdx = 0;
deBool writeIndent = DE_TRUE;
const char* indentStr = getIndentStr(writer->xmlElementDepth);
DE_ASSERT(writer && data && (numBytes > 0));
/* Close and pending writes. */
closePending(writer);
/* Loop all input chars. */
while (srcNdx < numBytes)
{
int numRead = deMin32(3, numBytes - srcNdx);
deUint8 s0 = data[srcNdx];
deUint8 s1 = (numRead >= 2) ? data[srcNdx+1] : 0;
deUint8 s2 = (numRead >= 3) ? data[srcNdx+2] : 0;
char d[5];
srcNdx += numRead;
d[0] = s_base64Table[s0 >> 2];
d[1] = s_base64Table[((s0&0x3)<<4) | (s1>>4)];
d[2] = s_base64Table[((s1&0xF)<<2) | (s2>>6)];
d[3] = s_base64Table[s2&0x3F];
d[4] = 0;
if (numRead < 3) d[3] = '=';
if (numRead < 2) d[2] = '=';
/* Write indent (if needed). */
if (writeIndent)
{
fprintf(writer->outputFile, "%s", indentStr);
writeIndent = DE_FALSE;
}
/* Write data. */
fprintf(writer->outputFile, "%s", &d[0]);
/* EOL every now and then. */
numWritten += 4;
if (numWritten >= 64)
{
fprintf(writer->outputFile, "\n");
numWritten = 0;
writeIndent = DE_TRUE;
}
}
/* Last EOL. */
if (numWritten > 0)
fprintf(writer->outputFile, "\n");
DE_ASSERT(srcNdx == numBytes);
return DE_TRUE;
}
/* Common helper functions. */
deBool qpXmlWriter_writeStringElement (qpXmlWriter* writer, const char* elementName, const char* elementContent)
{
if (!qpXmlWriter_startElement(writer, elementName, 0, DE_NULL) ||
(elementContent && !qpXmlWriter_writeString(writer, elementContent)) ||
!qpXmlWriter_endElement(writer, elementName))
return DE_FALSE;
return DE_TRUE;
}