非标准的xml解析器的C++实现：三、解析器的初步实现

如同我之前的一篇文章说的那样，我没有支持DTD与命名空间，

当前实现出来的解析器，只能与xmlhttp对比，因为chrome浏览器解析大文档有bug，至于其他人实现的，我就不一一测试了，既然都决定自己实现了，我只选择大公司的代码做对比。

测试文档大小：3M bytes，约90000个节点。

aqx::xdoc ：耗时 70-80ms，内存占用30-40M bytes，30和40主要是32位和64位的区别，如果要追求最少的内存占用，还可以更极端一些，解析速度很难再有本质的提升了，后续要完善的支持，也不会影响解析速度。

xmlhttp: 耗时3000-4000 ms，内存占用约 800M bytes。

目前测试过的系统有:

windows vc++ (vs2017) x86 x64

linux centos7 g++ version(9.1.1) x86 x64

windows中支持3种编码格式：utf-8  utf-16 对应操作系统的ascii编码，在简体中文windows中，也就是通常我们说的gb2312了。

然后目前，我不太可能针对实现细节将原理讲清楚，讲真的，C++的可读性真的非常糟糕，但对于这种需求，还是得用它，这种代码，我自己写完看着不难受，但对别人来说很可能是噩梦，同样的道理，我看别人的C++代码，也会困惑，要让看不懂代码的人，也理解实现细节，这是非常不科学的事。。。

好了，废话不说了，上代码：

//xml.hpp
#pragma once

#include 
#include <set>
#include 
#include 

//encode_adaptive.h - windows only
#pragma once
#include <string>
#include "tcvt.h"

#ifndef _nf
#define _nf ((size_t)-1)
#endif
namespace aqx {

    namespace encode_adaptive {


        static constexpr auto unknow{ static_cast<int>(-1) };
        static constexpr auto sys{ static_cast<int>(0) };
        static constexpr auto utf16{ static_cast<int>(1) };
        static constexpr auto utf8{ static_cast<int>(2) };
        static int profile_predict(unsigned char *_Text, size_t _Size, int &_Off, int _Def = 0) {

            if (_Size >= 3) {
                if (_Text[0] == 0xEF &&
                    _Text[1] == 0xBB &&
                    _Text[2] == 0xBF) {
                    _Off = 3;
                    return 2;
                }
            }
            if (_Size >= 2) {
                if (_Text[0] == 0xFF && _Text[1] == 0xFE) {
                    _Off = 2;
                    return 1;
                }
            }

            _Off = 0;
            size_t s = _Size;
            if (s > 0x10)
                s = 0x10;
            int x = 0;
            for (size_t i = 0; i < s; i++) {
                if (_Text[i] == 0)
                    x++;
            }

            if (_Size == s && x == 1)
                return _Def;
            if (!x)
                return _Def;
            return 1;
        }

        template
        static int profile_adaptive(char *_Text, size_t _Size, _Ty &_Result, int _Def = 0) {
            int _StartOff = 0;
            int _SrcCode = encode_adaptive::profile_predict((unsigned char*)_Text, _Size, _StartOff, _Def);
            size_t _TargetCode = 0;
            if (sizeof(decltype(*_Result.c_str())) == 2)
                _TargetCode = 1;
            std::wstring _utf16;
            if (_SrcCode == 2)
                aqx::utf16_from_utf8(_utf16, _Text + _StartOff);
            else if (_SrcCode == 1)
                _utf16 = (wchar_t*)(_Text + _StartOff);
            else
                aqx::utf16_from_asc(_utf16, _Text + _StartOff);
            auto _proc0 = [](void *_Res, std::wstring &_wstr) { asc_from_utf16(*(std::string*)_Res, _wstr); };
            auto _proc1 = [](void *_Res, std::wstring &_wstr) { *(std::wstring*)(_Res) = _wstr; };
            auto _proc2 = [](void *_Res, std::wstring &_wstr) { aqx::utf8_from_utf16(*(std::string*)(_Res), _wstr); };

            if (_TargetCode == 0)
                _proc0(&_Result, _utf16);
            else
                _proc1(&_Result, _utf16);
            return _SrcCode;
        }

        template
        static size_t specifiy(char *_Text, int _Srcec, int _Targetec, _Ty &_Result) {
            if (sizeof(_Ty::_Mybase::_Alty::value_type) == 1 && _Targetec == 1)
                return _nf;
            if (sizeof(_Ty::_Mybase::_Alty::value_type) == 2 && _Targetec != 1)
                return _nf;
            if (_Srcec == 2) {

                if (_Targetec == 2)
                {
                    *(std::string*)&_Result = (_Text);
                    return _Result.length();
                }
                else if (_Targetec == 1)
                    return utf16_from_utf8(*(std::wstring*)&_Result, _Text);
                else
                    return asc_from_utf8(*(std::string*)&_Result, _Text);

            }
            else if (_Srcec == 1)
            {
                if (_Targetec == 2)
                    return utf8_from_utf16(*(std::string*)&_Result, (wchar_t*)_Text);
                else if (_Targetec == 1) {
                    *(std::wstring*)&_Result = (wchar_t*)(_Text);
                    return _Result.length();
                }
                else
                    return asc_from_utf16(*(std::string*)&_Result, (wchar_t*)_Text);
            }
            else
            {
                if (_Targetec == 2)
                    return utf8_from_asc(*(std::string*)&_Result, _Text);
                else if (_Targetec == 1)
                    return utf16_from_asc(*(std::wstring*)&_Result, _Text);
                else {
                    *(std::string*)&_Result = (_Text);
                    return _Result.length();
                }
            }
            return _nf;
        }


        static void unknow_append(void *_Res, std::string _Str) { *(std::string*)(_Res) += _Str; }
        static void unknow_wappend(void *_Res, std::wstring _Str) { *(std::wstring*)(_Res) += _Str; }





        static int xmlec_nbom_wchar(wchar_t *_Text, size_t _Size) {
            if (_Size < 7) return -1;//小于7字节的xml文档是不成立的
            auto p = wcschr(_Text, L'<');
            if (!p) return -1;
            if (p[1] == L'?') {
                if (p != _Text) return -3;//xml声明没有位于xml文件头部
                p = wcsstr(_Text + 2, L"?>");
                if (!p) return -4;//没有找到xml声明结尾
            }
            return 1;
        }

        static int xmlec_nbom_char(char *_Text, size_t _Size) {
            auto p = strchr(_Text, '<');
            if (!p) return -1;

            if (!p[1]) //找到第一个<，如果他它之后一个字符是0，则考虑它是不是utf16
            {
                if (p - _Text == _Size - 1) return -2;//如果它已经是字符串最后一个有效字符，直接报错。
                if (_Size % 2) return -2; //长度不是偶数，说明绝对不可能是utf16
                return xmlec_nbom_wchar((wchar_t*)_Text, (_Size >> 1));
            }

            if (p[1] == '?') {
                if (p != _Text) return -3;//xml声明没有位于xml文件头部
                p = strstr(_Text + 2, "?>");
                if (!p) return -4;//没有找到xml声明结尾
                auto s = (p - _Text) + 2;
                std::string str(_Text, p - _Text + 2);
                std::transform(str.begin(), str.end(), str.begin(), toupper);
                if (str.find("UTF-8") != _nf) return 2;
                if (str.find("GBK") != _nf) return 0;
                if (str.find("GB2312") != _nf) return 0;
            }

            return 2;
        }

        static int xmlec_predict(char *_Text, size_t _Size, int *err_number, size_t *_Off = NULL, int _Default = 2) {
            *err_number = 0;
            if (_Size < 7) {
                //小于7字节的xml文档是不成立的
                *err_number = 29;
                return -1;
            }

            //先基于bom判断
            if ((unsigned char)(_Text[0]) == 0xEF && (unsigned char)(_Text[1]) == 0xBB && (unsigned char)(_Text[2]) == 0xBF) {
                if (_Off) *_Off = 3;
                auto p = strchr(_Text + 3, '<');
                if (!p) {
                    *err_number = 29;
                    return -1;
                }

                if (p[1] == '?')
                {
                    if (p != _Text + 3) {

                        *err_number = 31;
                        return -1;
                    }
                    p = strstr(_Text + 5, "?>");
                    if (!p) {
                        *err_number = 32;
                        return -1;
                    }
                }

                return 2;
            }
            else if ((unsigned char)(_Text[0]) == 0xFF && (unsigned char)(_Text)[1] == 0xFE) {
                if (_Off) *_Off = 2;
                auto p = wcschr((wchar_t*)_Text + 1, L'<');
                if (!p) {
                    *err_number = 29;
                    return -1;
                }

                if (p[1] == L'?')
                {
                    if (p != (wchar_t*)_Text + 1) {
                        *err_number = 31;
                        return -1;
                    }
                    p = wcsstr((wchar_t*)_Text + 3, L"?>");
                    if (!p) {
                        *err_number = 32;
                        return -1;
                    }

                }
                return 1;
            }

            if (_Off) *_Off = 0;
            int n = xmlec_nbom_char(_Text, _Size);
            if (n < -1) {

                if (n == -2)
                    *err_number = 29;
                else if (n == -3)
                    *err_number = 31;
                else if (n == -4)
                    *err_number = 32;

                return -1;
            }
            else if (n >= 0) return n;
            if (!(_Size % 2))
                n = xmlec_nbom_wchar((wchar_t*)_Text, (_Size >> 1));

            if (n < -1) {

                if (n == -2)
                    *err_number = 29;
                else if (n == -3)
                    *err_number = 31;
                else if (n == -4)
                    *err_number = 32;

                return -1;
            }

            return _Default;
        }


    };

}

//tcvt.h - windows only

#pragma once
#if defined(_WIN32) || defined(_WIN64)
#ifndef _WINDOWS_
#include 
#endif
#endif

namespace aqx {

    static size_t _mbs2wcs(int _Cp, const std::string &_Mbs, std::wstring &_Wcs) {
        int n = MultiByteToWideChar(_Cp, 0, _Mbs.c_str(), (int)_Mbs.length(), nullptr, 0);
        _Wcs.resize(n);
        return MultiByteToWideChar(_Cp, 0, _Mbs.c_str(), (int)_Mbs.length(), (wchar_t*)_Wcs.data(), (int)_Wcs.capacity());
    }

    static size_t _wcs2mbs(int _Cp, const std::wstring &_Wcs, std::string &_Mbs) {
        int n = WideCharToMultiByte(_Cp, 0, _Wcs.c_str(), (int)_Wcs.length(), nullptr, 0, NULL, FALSE);
        _Mbs.resize(n);
        return WideCharToMultiByte(_Cp, 0, _Wcs.c_str(), (int)_Wcs.length(), (char*)_Mbs.data(), (int)_Mbs.capacity(), NULL, FALSE);
    }

    
    static size_t utf8_from_asc(std::string &_Result, const std::string &_Asc) {
        std::wstring _Tmp;
        _mbs2wcs(CP_ACP, _Asc, _Tmp);
        return _wcs2mbs(CP_UTF8, _Tmp, _Result);
    }

    static size_t utf16_from_asc(std::wstring &_Result, const std::string &_Asc) {
        return _mbs2wcs(CP_ACP, _Asc, _Result);
    }

    static size_t asc_from_utf8(std::string &_Result, const std::string &_U8s) {
        std::wstring _Tmp;
        _mbs2wcs(CP_UTF8, _U8s, _Tmp);
        return _wcs2mbs(CP_ACP, _Tmp, _Result);
    }

    static size_t utf16_from_utf8(std::wstring &_Result, const std::string &_U8s) {
        return _mbs2wcs(CP_UTF8, _U8s, _Result);
    }

    static size_t utf8_from_utf16(std::string &_Result, const std::wstring &_Wcs) {
        return _wcs2mbs(CP_UTF8, _Wcs, _Result);
    }

    static size_t asc_from_utf16(std::string &_Result, const std::wstring &_Wcs) {
        return _wcs2mbs(CP_ACP, _Wcs, _Result);
    }

}

#include "pch.h"
#include 
#include "xml.hpp"
#include 

int main()
{
    
    setlocale(LC_ALL, "");

    // 支持三种编码格式：aqx::xts_utf16 aqx::xts_utf8 aqx::xts_asc
    aqx::xdoc doc;
    auto t = clock();
    int err = doc.load_file(L"G:\\vs2017\\test\\生成\\test.xml");
    printf("解析文档耗时：%d ms\n", clock() - t);
    if (err) {
        printf("%s\n", doc.get_error_info().c_str());
        return 0;
    }
    auto e = doc.get_element(L"CATALOG2");
    printf("%ls\n", e.get_inner_xml().c_str());
    system("pause");
    return 0;
}