diff --git a/convertxml/BUILD.gn b/convertxml/BUILD.gn index a2ac7c536b7250ae16d2459827d607085065270f..da283f8a1f8d1e7ee7bd7e8866416a1f50c012c5 100755 --- a/convertxml/BUILD.gn +++ b/convertxml/BUILD.gn @@ -14,11 +14,19 @@ import("//build/ohos.gni") import("//build/ohos/ace/ace.gni") +action("build_ts_js") { + script = "//base/compileruntime/js_api_module/convertxml/build_ts_js.py" + depfile = "$target_gen_dir/$target_name.d" + outputs = [target_out_dir + "/js_convertxml.js" + ] +} + base_output_path = get_label_info(":js_convertxml", "target_out_dir") js_xml_obj_path = base_output_path + "/convertxml.o" gen_js_obj("js_convertxml") { - input = "//base/compileruntime/js_api_module/convertxml/js_convertxml.js" + input = "$target_out_dir/js_convertxml.js" output = js_xml_obj_path + dep = ":build_ts_js" } ohos_shared_library("convertxml") { diff --git a/convertxml/build_ts_js.py b/convertxml/build_ts_js.py new file mode 100644 index 0000000000000000000000000000000000000000..76b3fb1d214431aed2af31099e77b9804794d4d1 --- /dev/null +++ b/convertxml/build_ts_js.py @@ -0,0 +1,21 @@ +#!/usr/bin/env python +# -*- coding: utf-8 -*- +# Copyright (c) 2021 Huawei Device Co., Ltd. +# 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. +import os + +if __name__ == '__main__': + + build_path = os.path.abspath(os.path.join(os.getcwd(), "../..")) + os.chdir("%s/base/compileruntime/js_api_module/convertxml" % build_path) + os.system('../../../../developtools/ace-ets2bundle/compiler/node_modules/typescript/bin/tsc') \ No newline at end of file diff --git a/convertxml/js_convertxml.cpp b/convertxml/js_convertxml.cpp index 727565fbfb941d4e75a6feea024641ce787c9ef3..65a409449cc5d6fbc39227e9b032f7c44c4e0005 100755 --- a/convertxml/js_convertxml.cpp +++ b/convertxml/js_convertxml.cpp @@ -114,12 +114,16 @@ void ConvertXml::GetPrevNodeList(xmlNodePtr curNode) if (curNode->type == xmlElementType::XML_PI_NODE && !m_Options.ignoreInstruction) { SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type)); SetKeyValue(elementsObject, m_Options.name, (char*)curNode->name); - SetKeyValue(elementsObject, m_Options.instruction, (const char*)xmlNodeGetContent(curNode)); + if (xmlNodeGetContent(curNode) != nullptr) { + SetKeyValue(elementsObject, m_Options.instruction, (const char*)xmlNodeGetContent(curNode)); + } m_prevObj.push_back(elementsObject); } if (curNode->type == xmlElementType::XML_COMMENT_NODE && !m_Options.ignoreComment) { SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type)); - SetKeyValue(elementsObject, m_Options.comment, (const char*)xmlNodeGetContent(curNode)); + if (xmlNodeGetContent(curNode) != nullptr) { + SetKeyValue(elementsObject, m_Options.comment, (const char*)xmlNodeGetContent(curNode)); + } m_prevObj.push_back(elementsObject); } if (curNode->type == xmlElementType::XML_DTD_NODE && !m_Options.ignoreDoctype) { @@ -147,34 +151,44 @@ void ConvertXml::SetAttributes(xmlNodePtr curNode, napi_value &elementsObject) void ConvertXml::SetXmlElementType(xmlNodePtr curNode, napi_value &elementsObject, bool &bFlag) { if (curNode->type == xmlElementType::XML_PI_NODE && !m_Options.ignoreInstruction) { - SetKeyValue(elementsObject, m_Options.instruction.c_str(), (const char*)xmlNodeGetContent(curNode)); - bFlag = true; + if (xmlNodeGetContent(curNode) != nullptr) { + SetKeyValue(elementsObject, m_Options.instruction.c_str(), (const char*)xmlNodeGetContent(curNode)); + bFlag = true; + } } else if (curNode->type == xmlElementType::XML_COMMENT_NODE && !m_Options.ignoreComment) { - SetKeyValue(elementsObject, m_Options.comment.c_str(), (const char*)xmlNodeGetContent(curNode)); - bFlag = true; + if (xmlNodeGetContent(curNode) != nullptr) { + SetKeyValue(elementsObject, m_Options.comment.c_str(), (const char*)xmlNodeGetContent(curNode)); + bFlag = true; + } } else if (curNode->type == xmlElementType::XML_CDATA_SECTION_NODE && !m_Options.ignoreCdata) { - SetKeyValue(elementsObject, m_Options.cdata, (const char*)xmlNodeGetContent(curNode)); - bFlag = true; + if (xmlNodeGetContent(curNode) != nullptr) { + SetKeyValue(elementsObject, m_Options.cdata, (const char*)xmlNodeGetContent(curNode)); + bFlag = true; + } } } void ConvertXml::SetNodeInfo(xmlNodePtr curNode, napi_value &elementsObject) { - if (curNode->type == xmlElementType::XML_PI_NODE) { - if (!m_Options.ignoreInstruction) { - SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type)); - } + if (curNode->type == xmlElementType::XML_TEXT_NODE) { + return; } else { - SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type)); - } - if ((curNode->type != xmlElementType::XML_COMMENT_NODE) && - (curNode->type != xmlElementType::XML_CDATA_SECTION_NODE)) { - if (!(curNode->type == xmlElementType::XML_PI_NODE && m_Options.ignoreInstruction)) { - SetKeyValue(elementsObject, m_Options.name, (char*)curNode->name); + if (curNode->type == xmlElementType::XML_PI_NODE) { + if (!m_Options.ignoreInstruction) { + SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type)); + } + } else { + SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type)); + } + if ((curNode->type != xmlElementType::XML_COMMENT_NODE) && + (curNode->type != xmlElementType::XML_CDATA_SECTION_NODE)) { + if (!(curNode->type == xmlElementType::XML_PI_NODE && m_Options.ignoreInstruction)) { + SetKeyValue(elementsObject, m_Options.name, (char*)curNode->name); + } } } } -void ConvertXml::SetEndInfo(xmlNodePtr curNode, napi_value &elementsObject, bool &bFlag, bool &bText, int32_t index) +void ConvertXml::SetEndInfo(xmlNodePtr curNode, napi_value &elementsObject, bool &bFlag) { SetKeyValue(elementsObject, m_Options.type, GetNodeType(curNode->type)); if (curNode->type == xmlElementType::XML_ELEMENT_NODE) { @@ -182,16 +196,17 @@ void ConvertXml::SetEndInfo(xmlNodePtr curNode, napi_value &elementsObject, bool bFlag = true; } else if (curNode->type == xmlElementType::XML_TEXT_NODE) { if (m_Options.trim) { - SetKeyValue(elementsObject, m_Options.text, Trim((const char*)xmlNodeGetContent(curNode))); + if (xmlNodeGetContent(curNode) != nullptr) { + SetKeyValue(elementsObject, m_Options.text, Trim((const char*)xmlNodeGetContent(curNode))); + } } else { - SetKeyValue(elementsObject, m_Options.text, (const char*)xmlNodeGetContent(curNode)); + if (xmlNodeGetContent(curNode) != nullptr) { + SetKeyValue(elementsObject, m_Options.text, (const char*)xmlNodeGetContent(curNode)); + } } if (!m_Options.ignoreText) { bFlag = true; } - if (index != 0) { - bText = false; - } } } @@ -208,21 +223,17 @@ void ConvertXml::GetXMLInfo(xmlNodePtr curNode, napi_value &object, int flag) { napi_value elements = nullptr; napi_create_array(env_, &elements); - napi_value recvElement; + napi_value recvElement = nullptr; napi_create_array(env_, &recvElement); xmlNodePtr pNode = curNode; int32_t index = 0; int32_t index1 = 0; bool bFlag = false; - bool bText = true; while (pNode != nullptr) { bFlag = false; - bText = true; napi_value elementsObject = nullptr; napi_create_object(env_, &elementsObject); - if (flag == 0 || (index % 2 != 0)) { // 2:pNode - SetNodeInfo(pNode, elementsObject); - } + SetNodeInfo(pNode, elementsObject); SetAttributes(pNode, elementsObject); napi_value tempElement = nullptr; napi_create_array(env_, &tempElement); @@ -233,16 +244,15 @@ void ConvertXml::GetXMLInfo(xmlNodePtr curNode, napi_value &object, int flag) curNode = pNode->children; GetXMLInfo(curNode, elementsObject, 1); bFlag = true; - } else if (index % 2 != 0) { // 2:pNode + } else { SetXmlElementType(pNode, elementsObject, bFlag); - } else if (pNode->next == nullptr) { - SetEndInfo(pNode, elementsObject, bFlag, bText, index); + SetEndInfo(pNode, elementsObject, bFlag); } } SetPrevInfo(recvElement, flag, index1); - if (elementsObject != nullptr && bFlag && bText) { - napi_set_element(env_, recvElement, index1++, elementsObject); - elementsObject = nullptr; + if (elementsObject != nullptr && bFlag) { + napi_set_element(env_, recvElement, index1++, elementsObject); + elementsObject = nullptr; } index++; pNode = pNode->next; @@ -252,37 +262,8 @@ void ConvertXml::GetXMLInfo(xmlNodePtr curNode, napi_value &object, int flag) } } -napi_value ConvertXml::convert(std::string strXml) +void ConvertXml::SetSpacesInfo(napi_value &object) { - xmlDocPtr doc = NULL; - xmlNodePtr curNode = NULL; - napi_status status = napi_ok; - size_t len = strXml.size(); - doc = xmlParseMemory(strXml.c_str(), len); - if (!doc) { - xmlFreeDoc(doc); - } - napi_value object = nullptr; - status = napi_create_object(env_, &object); - if (status != napi_ok) { - return NULL; - } - napi_value subObject = nullptr; - napi_value subSubObject = nullptr; - napi_value napiKey = nullptr; - napi_create_object(env_, &subSubObject); - napi_create_object(env_, &subObject); - napi_create_string_utf8(env_, (const char*)doc->version, NAPI_AUTO_LENGTH, &napiKey); - napi_set_named_property(env_, subSubObject, "version", napiKey); - napi_create_string_utf8(env_, (const char*)doc->encoding, NAPI_AUTO_LENGTH, &napiKey); - napi_set_named_property(env_, subSubObject, "encoding", napiKey); - if (!m_Options.ignoreDeclaration) { - napi_set_named_property(env_, subObject, m_Options.attributes.c_str(), subSubObject); - napi_set_named_property(env_, object, m_Options.declaration.c_str(), subObject); - } - curNode = xmlDocGetRootElement(doc); - GetPrevNodeList(curNode); - GetXMLInfo(curNode, object, 0); napi_value iTemp = nullptr; switch (m_SpaceType) { case (SpaceType::T_INT32): @@ -297,7 +278,50 @@ napi_value ConvertXml::convert(std::string strXml) break; default: break; + } +} + +napi_value ConvertXml::convert(std::string strXml) +{ + xmlDocPtr doc = nullptr; + xmlNodePtr curNode = nullptr; + napi_status status = napi_ok; + napi_value object = nullptr; + status = napi_create_object(env_, &object); + if (status != napi_ok) { + return nullptr; } + Replace(strXml, "\\r", "\r"); + Replace(strXml, "\\n", "\n"); + Replace(strXml, "\\v", "\v"); + Replace(strXml, "]]> version != nullptr) { + SetKeyValue(subSubObject, "version", (const char*)doc->version); + } + if (doc != nullptr && doc->encoding != nullptr) { + SetKeyValue(subSubObject, "encoding", (const char*)doc->encoding); + } + if (!m_Options.ignoreDeclaration && strXml.find("xml") != std::string::npos) { + napi_set_named_property(env_, subObject, m_Options.attributes.c_str(), subSubObject); + napi_set_named_property(env_, object, m_Options.declaration.c_str(), subObject); + } + if (doc != nullptr) { + curNode = xmlDocGetRootElement(doc); + GetPrevNodeList(curNode); + GetXMLInfo(curNode, object, 0); + } + SetSpacesInfo(object); return object; } @@ -310,9 +334,10 @@ napi_status ConvertXml::DealNapiStrValue(napi_value napi_StrValue, std::string & if (status != napi_ok) { return status; } - buffer = new char[bufferSize + 1]; - napi_get_value_string_utf8(env_, napi_StrValue, buffer, bufferSize + 1, &bufferSize); - + if (bufferSize > 0) { + buffer = new char[bufferSize + 1]; + napi_get_value_string_utf8(env_, napi_StrValue, buffer, bufferSize + 1, &bufferSize); + } if (buffer != nullptr) { result = buffer; delete []buffer; @@ -341,8 +366,9 @@ void ConvertXml::DealSpaces(napi_value napi_obj) void ConvertXml::DealIgnore(napi_value napi_obj) { - std::vectorvctIgnore = { "compact", "trim", "ignoreDeclaration", "ignoreInstruction", - "ignoreAttributes", "ignoreComment", "ignoreCdata", "ignoreDoctype", "ignoreText" }; + std::vector vctIgnore = {"compact", "trim", "ignoreDeclaration", "ignoreInstruction", + "ignoreAttributes", "ignoreComment", "ignoreCdata", + "ignoreDoctype", "ignoreText"}; for (size_t i = 0; i < vctIgnore.size(); ++i) { napi_value recvTemp = nullptr; bool bRecv = false; @@ -426,8 +452,9 @@ void ConvertXml::SetDefaultKey(size_t i, std::string strRecv) void ConvertXml::DealOptions(napi_value napi_obj) { - std::vectorvctOptions = { "declarationKey", "instructionKey", "attributesKey", "textKey", - "cdataKey", "doctypeKey", "commentKey", "parentKey", "typeKey", "nameKey", "elementsKey" }; + std::vector vctOptions = {"declarationKey", "instructionKey", "attributesKey", "textKey", + "cdataKey", "doctypeKey", "commentKey", "parentKey", "typeKey", + "nameKey", "elementsKey"}; for (size_t i = 0; i < vctOptions.size(); ++i) { napi_value recvTemp = nullptr; std::string strRecv = ""; @@ -439,3 +466,117 @@ void ConvertXml::DealOptions(napi_value napi_obj) DealIgnore(napi_obj); DealSpaces(napi_obj); } + +void ConvertXml::DealSingleLine(std::string &strXml, napi_value &object) +{ + size_t iXml = 0; + if ((iXml = strXml.find("xml")) != std::string::npos) { + m_XmlInfo.bXml = true; + napi_value declObj = nullptr; + napi_create_object(env_, &declObj); + napi_value attrObj = nullptr; + bool bFlag = false; + napi_create_object(env_, &attrObj); + if (strXml.find("version=") != std::string::npos) { + m_XmlInfo.bVersion = true; + SetKeyValue(attrObj, "version", "1.0"); + bFlag = true; + } + if (strXml.find("encoding=") != std::string::npos) { + m_XmlInfo.bEncoding = false; + SetKeyValue(attrObj, "encoding", "utf-8"); + bFlag = true; + } + if (bFlag) { + napi_set_named_property(env_, declObj, m_Options.attributes.c_str(), attrObj); + napi_set_named_property(env_, object, m_Options.declaration.c_str(), declObj); + } else { + napi_set_named_property(env_, object, m_Options.declaration.c_str(), declObj); + } + if (strXml.find(">", iXml) == strXml.size() - 1) { + strXml = ""; + } else { + strXml = strXml.substr(0, strXml.rfind("<", iXml)) + strXml.substr(strXml.find(">", iXml) + 1); + } + } + size_t iCount = 0; + size_t iLen = strXml.size(); + for (; iCount < iLen; ++iCount) { + if (strXml[iCount] != ' ' && strXml[iCount] != '\v' && + strXml[iCount] != '\t' && strXml[iCount] != '\n') { + break; + } + } + if (iCount < iLen) { + DealComplex(strXml, object); + } +} + +void ConvertXml::DealComplex(std::string &strXml, napi_value &object) +{ + if (strXml.find(""; + } else { + strXml = "" + strXml + ""; + } + xmlDocPtr doc = nullptr; + xmlNodePtr curNode = nullptr; + size_t len = strXml.size(); + doc = xmlParseMemory(strXml.c_str(), len); + if (!doc) { + xmlFreeDoc(doc); + } + if (doc) { + curNode = xmlDocGetRootElement(doc); + curNode = curNode->children; + napi_value elements = nullptr; + napi_create_array(env_, &elements); + bool bHasEle = false; + int index = 0; + bool bCData = false; + if (strXml.find("type == xmlElementType::XML_CDATA_SECTION_NODE && + curNode->next && curNode->next->type == xmlElementType::XML_TEXT_NODE && + curNode->next->next && curNode->next->next->type == xmlElementType::XML_CDATA_SECTION_NODE) { + if (xmlNodeGetContent(curNode->next) != nullptr) { + std::string strTemp = (char*)xmlNodeGetContent(curNode->next); + Replace(strTemp, " ", ""); + Replace(strTemp, "\v", ""); + Replace(strTemp, "\t", ""); + Replace(strTemp, "\n", ""); + if (strTemp == "") { + curNode = curNode->next->next; + } + } + } else { + curNode = curNode->next; + } +} \ No newline at end of file diff --git a/convertxml/js_convertxml.h b/convertxml/js_convertxml.h index bbe2381f45ee7f6bed5299e47fec8a62e98ed162..380fab061d5f01912e2b37e8dc2449bfecf5fb2e 100755 --- a/convertxml/js_convertxml.h +++ b/convertxml/js_convertxml.h @@ -30,33 +30,41 @@ enum class SpaceType { }; struct Options { - std::string declaration = "_declaration"; - std::string instruction = "_instruction"; - std::string attributes = "_attributes"; - std::string text = "_text"; - std::string cdata = "_cdata"; - std::string doctype = "_doctype"; - std::string comment = "_comment"; - std::string parent = "_parent"; - std::string type = "_type"; - std::string name = "_name"; - std::string elements = "_elements"; - bool compact = false; - bool trim = false; - bool nativetype = false; - bool nativetypeattributes = false; - bool addparent = false; - bool alwaysArray = false; - bool alwaysChildren = false; - bool instructionHasAttributes = false; - bool ignoreDeclaration = false; - bool ignoreInstruction = false; - bool ignoreAttributes = false; - bool ignoreComment = false; - bool ignoreCdata = false; - bool ignoreDoctype = false; - bool ignoreText = false; - bool spaces = false; + std::string declaration = "_declaration"; + std::string instruction = "_instruction"; + std::string attributes = "_attributes"; + std::string text = "_text"; + std::string cdata = "_cdata"; + std::string doctype = "_doctype"; + std::string comment = "_comment"; + std::string parent = "_parent"; + std::string type = "_type"; + std::string name = "_name"; + std::string elements = "_elements"; + bool compact = false; + bool trim = false; + bool nativetype = false; + bool nativetypeattributes = false; + bool addparent = false; + bool alwaysArray = false; + bool alwaysChildren = false; + bool instructionHasAttributes = false; + bool ignoreDeclaration = false; + bool ignoreInstruction = false; + bool ignoreAttributes = false; + bool ignoreComment = false; + bool ignoreCdata = false; + bool ignoreDoctype = false; + bool ignoreText = false; + bool spaces = false; +}; + +struct XmlInfo { + bool bXml = false; + bool bVersion = false; + std::string strVersion = ""; + bool bEncoding = false; + std::string strEncoding = ""; }; class ConvertXml { @@ -66,7 +74,7 @@ public: void SetAttributes(xmlNodePtr curNode, napi_value &elementsObject); void SetXmlElementType(xmlNodePtr curNode, napi_value &elementsObject, bool &bFlag); void SetNodeInfo(xmlNodePtr curNode, napi_value &elementsObject); - void SetEndInfo(xmlNodePtr curNode, napi_value &elementsObject, bool &bFlag, bool &bText, int32_t index); + void SetEndInfo(xmlNodePtr curNode, napi_value &elementsObject, bool &bFlag); void GetXMLInfo(xmlNodePtr curNode, napi_value &object, int flag = 0); napi_value convert(std::string strXml); std::string GetNodeType(xmlElementType enumType); @@ -79,6 +87,11 @@ public: void DealIgnore(napi_value napi_obj); void SetPrevInfo(napi_value &recvElement, int flag, int32_t &index1); void SetDefaultKey(size_t i, std::string strRecv); + void SetSpacesInfo(napi_value &object); + void DealSingleLine(std::string &strXml, napi_value &object); + void DealComplex(std::string &strXml, napi_value &object); + void Replace(std::string &str, const std::string src, const std::string dst); + void DealCDataInfo(bool bCData, xmlNodePtr &curNode); private: napi_env env_; SpaceType m_SpaceType; @@ -86,5 +99,6 @@ private: std::string m_strSpace; Options m_Options; std::vector m_prevObj; + XmlInfo m_XmlInfo; }; #endif \ No newline at end of file diff --git a/convertxml/js_convertxml.js b/convertxml/js_convertxml.js index a0305b036471c70e26b7e2e989878f63a6464e36..e045ea7af880775d6a90ebbe6fda58f36bca7b02 100755 --- a/convertxml/js_convertxml.js +++ b/convertxml/js_convertxml.js @@ -21,14 +21,106 @@ class ConvertXml { this.convertxmlclass = new convertXml.ConvertXml(); } convert(strXml, options) { + strXml = DealXml(strXml); let converted = this.convertxmlclass.convert(strXml, options); let space = 0; if (converted.hasOwnProperty("spaces")) { space = converted.spaces; delete converted.spaces; } - return JSON.stringify(converted, null, space); + var strEnd = JSON.stringify(converted, null, space); + var idx = 0; + while ((idx = strEnd.indexOf('\\t')) != -1) { + strEnd = strEnd.substring(0, idx) + '\t' + strEnd.substring(idx + 2); + } + while ((idx = strEnd.indexOf('\\n')) != -1) { + strEnd = strEnd.substring(0, idx) + '\n' + strEnd.substring(idx + 2); + } + while ((idx = strEnd.indexOf('\\')) != -1) { + strEnd = strEnd.substring(0, idx) + '' + strEnd.substring(idx + 1); + } + return strEnd; + } +} + +function DealXml(strXml) +{ + var idx = 0; + var idxSec = 0; + var idxThir = 0; + var idxCData = 0; + var idxCDataSec = 0; + while ((idx = strXml.indexOf(']]>', idxSec)) != -1) { + idxThir = strXml.indexOf('<', idx); + strXml = DealReplace(strXml, idx, idxThir); + if (strXml.indexOf('<', idx) != -1) { + idxCData = strXml.indexOf('', idxCData); + var i = idx + 1; + for (; i < idxThir ; i++) { + var cXml = strXml.charAt(i) + switch (cXml) { + case '\n': + strXml = strXml.substring(0, i) + '\\n' + strXml.substring(i + 1); + break; + case '\v': + strXml = strXml.substring(0, i) + '\\v' + strXml.substring(i + 1); + break; + case '\t': + strXml = strXml.substring(0, i) + '\\t' + strXml.substring(i + 1); + break; + default: + break; + } + } + idxCDataSec = idxSec; + } + } + else { + break; + } + } + return strXml; +} + +function DealReplace(strXml, idx, idxThir) +{ + var i = idx + 1; + for (; i < idxThir ; i++) { + var cXml = strXml.charAt(i); + if (cXml != '\n' && cXml != '\v' && cXml != '\t' && cXml != ' ') + { + break; + } + } + var j = idx + 1; + for (; j < strXml.indexOf('<', idx) ; j++) { + var cXml = strXml.charAt(j); + if (i != idxThir) { + switch (cXml) { + case '\n': + strXml = strXml.substring(0, j) + '\\n' + strXml.substring(j + 1); + break; + case '\v': + strXml = strXml.substring(0, j) + '\\v' + strXml.substring(j + 1); + break; + case '\t': + strXml = strXml.substring(0, j) + '\\t' + strXml.substring(j + 1); + break; + default: + break; + } + } else { + strXml = strXml.substring(0, j) + strXml.substring(j + 1); + --j; + } } + return strXml; } export default { diff --git a/convertxml/native_module_convertxml.cpp b/convertxml/native_module_convertxml.cpp index 25223d8adad4cf2b0b437238bfab6b4d63aaa71f..cfca087e5b7449af1fed82288be92e85b525d6a5 100755 --- a/convertxml/native_module_convertxml.cpp +++ b/convertxml/native_module_convertxml.cpp @@ -106,7 +106,8 @@ static napi_module ConvertXmlModule = { .reserved = { 0 }, }; -extern "C" __attribute__ ((constructor)) void RegisterModule() { +extern "C" __attribute__ ((constructor)) void RegisterModule() +{ napi_module_register(&ConvertXmlModule); } diff --git a/convertxml/src/js_convertxml.ts b/convertxml/src/js_convertxml.ts new file mode 100644 index 0000000000000000000000000000000000000000..93ebb9808f01181f6586a05b5c15830969bcace9 --- /dev/null +++ b/convertxml/src/js_convertxml.ts @@ -0,0 +1,130 @@ +/* + * Copyright (c) 2021 Huawei Device Co., Ltd. + * 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. + */ + +declare function requireInternal(s : string) : any; +const convertXml = requireInternal("ConvertXML"); +class ConvertXml { + convertxmlclass; + constructor() { + this.convertxmlclass = new convertXml.ConvertXml(); + } + convert(strXml : string, options : any) { + strXml = DealXml(strXml); + let converted = this.convertxmlclass.convert(strXml, options); + let space = 0; + if (converted.hasOwnProperty("spaces")) { + space = converted.spaces; + delete converted.spaces; + } + var strEnd = JSON.stringify(converted, null, space); + var idx = 0; + while ((idx = strEnd.indexOf('\\t')) != -1) { + strEnd = strEnd.substring(0, idx) + '\t' + strEnd.substring(idx + 2); + } + while ((idx = strEnd.indexOf('\\n')) != -1) { + strEnd = strEnd.substring(0, idx) + '\n' + strEnd.substring(idx + 2); + } + while ((idx = strEnd.indexOf('\\')) != -1) { + strEnd = strEnd.substring(0, idx) + '' + strEnd.substring(idx + 1); + } + return strEnd; + } +} + +function DealXml(strXml : string) +{ + var idx = 0; + var idxSec = 0; + var idxThir = 0; + var idxCData = 0; + var idxCDataSec = 0; + while ((idx = strXml.indexOf(']]>', idxSec)) != -1) { + idxThir = strXml.indexOf('<', idx); + strXml = DealReplace(strXml, idx, idxThir); + if (strXml.indexOf('<', idx) != -1) { + idxCData = strXml.indexOf('', idxCData); + var i = idx + 1; + for (; i < idxThir ; i++) { + var cXml = strXml.charAt(i) + switch (cXml) { + case '\n': + strXml = strXml.substring(0, i) + '\\n' + strXml.substring(i + 1); + break; + case '\v': + strXml = strXml.substring(0, i) + '\\v' + strXml.substring(i + 1); + break; + case '\t': + strXml = strXml.substring(0, i) + '\\t' + strXml.substring(i + 1); + break; + default: + break; + } + } + idxCDataSec = idxSec; + } + } + else { + break; + } + } + return strXml; +} + +function DealReplace(strXml : string, idx : any, idxThir : any) +{ + var i = idx + 1; + for (; i < idxThir ; i++) { + var cXml = strXml.charAt(i); + if (cXml != '\n' && cXml != '\v' && cXml != '\t' && cXml != ' ') + { + break; + } + } + var j = idx + 1; + for (; j < strXml.indexOf('<', idx) ; j++) { + var cXml = strXml.charAt(j); + if (i != idxThir) { + switch (cXml) { + case '\n': + strXml = strXml.substring(0, j) + '\\n' + strXml.substring(j + 1); + break; + case '\v': + strXml = strXml.substring(0, j) + '\\v' + strXml.substring(j + 1); + break; + case '\t': + strXml = strXml.substring(0, j) + '\\t' + strXml.substring(j + 1); + break; + default: + break; + } + } else { + strXml = strXml.substring(0, j) + strXml.substring(j + 1); + --j; + } + } + return strXml; +} + +export default { + ConvertXml : ConvertXml +} + + diff --git a/convertxml/tsconfig.json b/convertxml/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..e61c432fb367e0ad07c331afe78981340e2fd317 --- /dev/null +++ b/convertxml/tsconfig.json @@ -0,0 +1,14 @@ +{ +"compilerOptions": { + "target": "es6", + "module": "es6", + "rootDir": "./src", + //"outFile": "./", /* Specify a file that bundles all outputs into one JavaScript file. If `declaration` is true, also designates a file that bundles all .d.ts output. */ + "outDir": "../../../../out/ohos-arm-release/obj/base/compileruntime/js_api_module/convertxml/", /* Specify an output folder for all emitted files. */ + "esModuleInterop": true, + "forceConsistentCasingInFileNames": true, + "strict": true, + "skipLibCheck": true, + "noImplicitThis": false, + } +} diff --git a/uri/js_uri.cpp b/uri/js_uri.cpp index 3af8ab0c9e651343528f5e1b2bca77c21d5525ec..34452121891811f25686dfb49a533cf1a2d2b1fe 100755 --- a/uri/js_uri.cpp +++ b/uri/js_uri.cpp @@ -15,14 +15,14 @@ #include "js_uri.h" #include "utils/log.h" namespace OHOS::Uri { - std::bitset g_ruleAlpha; - std::bitset g_ruleScheme; - std::bitset g_ruleUrlc; - std::bitset g_rulePath; - std::bitset g_ruleUserInfo; - std::bitset g_ruleScope; - std::bitset g_ruleDigit; - std::bitset g_rulePort; + std::bitset g_ruleAlpha; + std::bitset g_ruleScheme; + std::bitset g_ruleUrlc; + std::bitset g_rulePath; + std::bitset g_ruleUserInfo; + std::bitset g_ruleScope; + std::bitset g_ruleDigit; + std::bitset g_rulePort; void Uri::PreliminaryWork() const { std::string digitAggregate = "0123456789"; diff --git a/uri/native_module_uri.cpp b/uri/native_module_uri.cpp index cb013be86fad1ddea9a9f16941cf4596062376e5..c0ee394a58b6818a7273f96830b3479fa3035cae 100755 --- a/uri/native_module_uri.cpp +++ b/uri/native_module_uri.cpp @@ -264,7 +264,7 @@ namespace OHOS::Uri { DECLARE_NAPI_GETTER("isFailed", IsFailed), }; NAPI_CALL(env, napi_define_class(env, uriClassName, strlen(uriClassName), UriConstructor, - nullptr, sizeof(uriDesc) / sizeof(uriDesc[0]), uriDesc, &uriClass)); + nullptr, sizeof(uriDesc) / sizeof(uriDesc[0]), uriDesc, &uriClass)); static napi_property_descriptor desc[] = { DECLARE_NAPI_PROPERTY("Uri", uriClass) }; diff --git a/url/js_url.cpp b/url/js_url.cpp index ba9f1b93303998245c5fce2510b399e6e78a845f..1b53b245079c25590b9fe717a8776b117ad7a624 100755 --- a/url/js_url.cpp +++ b/url/js_url.cpp @@ -1705,7 +1705,7 @@ namespace OHOS::Url { (charaEncode & 0x0000003F)]; // Acquisition method of the second byte output += output1 + output2; } else if ((charaEncode >= 0x0000E000) || - (charaEncode <= 0x0000D7FF)) { // Convert the Unicode code into three bytes + (charaEncode <= 0x0000D7FF)) { // Convert the Unicode code into three bytes std::string output1 = reviseChar[0x000000E0 | (charaEncode / 4096)]; // 4096:Acquisition method of the first byte std::string output2 = reviseChar[numOfAscii | @@ -1935,7 +1935,7 @@ namespace OHOS::Url { sname = ToUSVString(name); } delete[] name; - for (std::vector::iterator iter = searchParams.begin(); iter != searchParams.end();) { + for (auto iter = searchParams.begin(); iter != searchParams.end();) { if (*iter == sname) { iter = searchParams.erase(iter, iter + 2); // 2:Searching for the number and number of keys and values } else { @@ -2032,7 +2032,7 @@ namespace OHOS::Url { delete[] buffer1; } bool flag = false; - for (std::vector::iterator it = searchParams.begin(); it < searchParams.end() - 1;) { + for (auto it = searchParams.begin(); it < (searchParams.end() - 1);) { if (*it == cppName) { if (!flag) { *(it + 1) = cppValue; diff --git a/url/native_module_url.cpp b/url/native_module_url.cpp index 279f4316738e6d8449c3ebcb9578845a00c8589c..61497a7688a52cbef7eca2803c708d9cc3ba977b 100755 --- a/url/native_module_url.cpp +++ b/url/native_module_url.cpp @@ -884,7 +884,7 @@ namespace OHOS::Url { DECLARE_NAPI_GETTER("GetIsIpv6", GetIsIpv6), }; NAPI_CALL(env, napi_define_class(env, urlClassName, strlen(urlClassName), UrlConstructor, - nullptr, sizeof(UrlDesc) / sizeof(UrlDesc[0]), UrlDesc, &urlClass)); + nullptr, sizeof(UrlDesc) / sizeof(UrlDesc[0]), UrlDesc, &urlClass)); static napi_property_descriptor desc[] = { DECLARE_NAPI_PROPERTY("Url", urlClass) };