| OLD | NEW |
| (Empty) |
| 1 /* libs/graphics/ports/SkXMLParser_expat.cpp | |
| 2 ** | |
| 3 ** Copyright 2006, The Android Open Source Project | |
| 4 ** | |
| 5 ** Licensed under the Apache License, Version 2.0 (the "License"); | |
| 6 ** you may not use this file except in compliance with the License. | |
| 7 ** You may obtain a copy of the License at | |
| 8 ** | |
| 9 ** http://www.apache.org/licenses/LICENSE-2.0 | |
| 10 ** | |
| 11 ** Unless required by applicable law or agreed to in writing, software | |
| 12 ** distributed under the License is distributed on an "AS IS" BASIS, | |
| 13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 14 ** See the License for the specific language governing permissions and | |
| 15 ** limitations under the License. | |
| 16 */ | |
| 17 | |
| 18 #include "SkXMLParser.h" | |
| 19 #include "SkString.h" | |
| 20 #include "SkStream.h" | |
| 21 | |
| 22 #include "expat.h" | |
| 23 | |
| 24 #ifdef SK_BUILD_FOR_PPI | |
| 25 #define CHAR_16_TO_9 | |
| 26 #endif | |
| 27 | |
| 28 #if defined CHAR_16_TO_9 | |
| 29 inline size_t sk_wcslen(const short* char16) { | |
| 30 const short* start = char16; | |
| 31 while (*char16) | |
| 32 char16++; | |
| 33 return char16 - start; | |
| 34 } | |
| 35 | |
| 36 inline const char* ConvertUnicodeToChar(const short* ch16, size_t len, SkAutoMal
loc& ch8Malloc) { | |
| 37 char* ch8 = (char*) ch8Malloc.get(); | |
| 38 int index; | |
| 39 for (index = 0; index < len; index++) | |
| 40 ch8[index] = (char) ch16[index]; | |
| 41 ch8[index] = '\0'; | |
| 42 return ch8; | |
| 43 } | |
| 44 #endif | |
| 45 | |
| 46 static void XMLCALL start_proc(void *data, const char *el, const char **attr) | |
| 47 { | |
| 48 #if defined CHAR_16_TO_9 | |
| 49 size_t len = sk_wcslen((const short*) el); | |
| 50 SkAutoMalloc el8(len + 1); | |
| 51 el = ConvertUnicodeToChar((const short*) el, len, el8); | |
| 52 #endif | |
| 53 if (((SkXMLParser*)data)->startElement(el)) { | |
| 54 XML_StopParser((XML_Parser) ((SkXMLParser*)data)->fParser, false); | |
| 55 return; | |
| 56 } | |
| 57 while (*attr) | |
| 58 { | |
| 59 const char* attr0 = attr[0]; | |
| 60 const char* attr1 = attr[1]; | |
| 61 #if defined CHAR_16_TO_9 | |
| 62 size_t len0 = sk_wcslen((const short*) attr0); | |
| 63 SkAutoMalloc attr0_8(len0 + 1); | |
| 64 attr0 = ConvertUnicodeToChar((const short*) attr0, len0, attr0_8); | |
| 65 size_t len1 = sk_wcslen((const short*) attr1); | |
| 66 SkAutoMalloc attr1_8(len1 + 1); | |
| 67 attr1 = ConvertUnicodeToChar((const short*) attr1, len1, attr1_8); | |
| 68 #endif | |
| 69 if (((SkXMLParser*)data)->addAttribute(attr0, attr1)) { | |
| 70 XML_StopParser((XML_Parser) ((SkXMLParser*)data)->fParser, false); | |
| 71 return; | |
| 72 } | |
| 73 attr += 2; | |
| 74 } | |
| 75 } | |
| 76 | |
| 77 static void XMLCALL end_proc(void *data, const char *el) | |
| 78 { | |
| 79 #if defined CHAR_16_TO_9 | |
| 80 size_t len = sk_wcslen((const short*) el); | |
| 81 SkAutoMalloc el8(len + 1); | |
| 82 el = ConvertUnicodeToChar((const short*) el, len, el8); | |
| 83 #endif | |
| 84 if (((SkXMLParser*)data)->endElement(el)) | |
| 85 XML_StopParser((XML_Parser) ((SkXMLParser*)data)->fParser, false); | |
| 86 } | |
| 87 | |
| 88 static void XMLCALL text_proc(void* data, const char* text, int len) | |
| 89 { | |
| 90 #if defined CHAR_16_TO_9 | |
| 91 SkAutoMalloc text8(len + 1); | |
| 92 text = ConvertUnicodeToChar((const short*) text, len, text8); | |
| 93 #endif | |
| 94 if (((SkXMLParser*)data)->text(text, len)) | |
| 95 XML_StopParser((XML_Parser) ((SkXMLParser*)data)->fParser, false); | |
| 96 } | |
| 97 | |
| 98 bool SkXMLParser::parse(const char doc[], size_t len) | |
| 99 { | |
| 100 if (len == 0) { | |
| 101 fError->fCode = SkXMLParserError::kEmptyFile; | |
| 102 reportError(NULL); | |
| 103 return false; | |
| 104 } | |
| 105 XML_Parser p = XML_ParserCreate(NULL); | |
| 106 SkASSERT(p); | |
| 107 fParser = p; | |
| 108 XML_SetElementHandler(p, start_proc, end_proc); | |
| 109 XML_SetCharacterDataHandler(p, text_proc); | |
| 110 XML_SetUserData(p, this); | |
| 111 | |
| 112 bool success = true; | |
| 113 int error = XML_Parse(p, doc, len, true); | |
| 114 if (error == XML_STATUS_ERROR) { | |
| 115 reportError(p); | |
| 116 success = false; | |
| 117 } | |
| 118 XML_ParserFree(p); | |
| 119 return success; | |
| 120 } | |
| 121 | |
| 122 bool SkXMLParser::parse(SkStream& input) | |
| 123 { | |
| 124 size_t len = input.read(NULL, 0); | |
| 125 SkAutoMalloc am(len); | |
| 126 char* doc = (char*)am.get(); | |
| 127 | |
| 128 input.rewind(); | |
| 129 size_t len2 = input.read(doc, len); | |
| 130 SkASSERT(len2 == len); | |
| 131 | |
| 132 return this->parse(doc, len2); | |
| 133 } | |
| 134 | |
| 135 void SkXMLParser::reportError(void* p) | |
| 136 { | |
| 137 XML_Parser parser = (XML_Parser) p; | |
| 138 if (fError && parser) { | |
| 139 fError->fNativeCode = XML_GetErrorCode(parser); | |
| 140 fError->fLineNumber = XML_GetCurrentLineNumber(parser); | |
| 141 } | |
| 142 } | |
| 143 | |
| 144 void SkXMLParser::GetNativeErrorString(int error, SkString* str) | |
| 145 { | |
| 146 if (str) | |
| 147 str->set(XML_ErrorString((XML_Error) error)); | |
| 148 } | |
| 149 | |
| OLD | NEW |