axmlite.cpp

研读AxCrypt对加解密的处理方法

// Desc   : add node
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
LPXNode _tagXMLNode::AppendChild( LPCTSTR name /*= NULL*/, LPCTSTR value /*= NULL*/ )
{
    return AppendChild( CreateNode( name, value ) );
}

//========================================================
// Name   : AppendChild
// Desc   : add node
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
LPXNode _tagXMLNode::AppendChild( LPXNode node )
{
    node->parent = this;
    childs.push_back( node );
    return node;
}

//========================================================
// Name   : RemoveChild
// Desc   : detach node and delete object
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
bool _tagXMLNode::RemoveChild( LPXNode node )
{
    XNodes::iterator it = GetChildIterator( node );
    if( it != NULL)
    {
        delete *it;
        childs.erase( it );
        return true;
    }
    return false;
}

//========================================================
// Name   : GetAttr
// Desc   : get attribute with index in attribute list
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
XAttr *_tagXMLNode::GetAttr(size_t i) {
    if (i >= 0 && i < attrs.size()) {
        return attrs[i];
    }
    return NULL;
}

//========================================================
// Name   : GetAttrIterator
// Desc   : get attribute iterator
// Param  : 
// Return : std::vector<LPXAttr>::iterator
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
XAttrs::iterator _tagXMLNode::GetAttrIterator( LPXAttr attr )
{
    XAttrs::iterator it = attrs.begin();
    for( ; it != attrs.end() ; ++(it) )
    {
        if( *it == attr )
            return it;
    }
    return NULL;
}

//========================================================
// Name   : AppendAttr
// Desc   : add attribute
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
LPXAttr _tagXMLNode::AppendAttr( LPXAttr attr )
{
    attr->parent = this;
    attrs.push_back( attr );
    return attr;
}

//========================================================
// Name   : RemoveAttr
// Desc   : detach attribute and delete object
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
bool _tagXMLNode::RemoveAttr( LPXAttr attr )
{
    XAttrs::iterator it = GetAttrIterator( attr );
    if( it != NULL)
    {
        delete *it;
        attrs.erase( it );
        return true;
    }
    return false;
}

//========================================================
// Name   : CreateNode
// Desc   : Create node object and return it
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
LPXNode _tagXMLNode::CreateNode( LPCTSTR name /*= NULL*/, LPCTSTR value /*= NULL*/ )
{
    LPXNode node = new XNode;
    node->name = name;
    node->value = value;
    return node;
}

//========================================================
// Name   : CreateAttr
// Desc   : create Attribute object and return it
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
LPXAttr _tagXMLNode::CreateAttr( LPCTSTR name /*= NULL*/, LPCTSTR value /*= NULL*/ )
{
    LPXAttr attr = new XAttr;
    attr->name = name;
    attr->value = value;
    return attr;
}

//========================================================
// Name   : AppendAttr
// Desc   : add attribute
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
LPXAttr _tagXMLNode::AppendAttr( LPCTSTR name /*= NULL*/, LPCTSTR value /*= NULL*/ )
{
    return AppendAttr( CreateAttr( name, value ) );
}

//========================================================
// Name   : DetachChild
// Desc   : no delete object, just detach in list
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
LPXNode _tagXMLNode::DetachChild( LPXNode node )
{
    XNodes::iterator it = GetChildIterator( node );
    if( it != NULL )
    {
        childs.erase( it );
        return node;
    }
    return NULL;
}

//========================================================
// Name   : DetachAttr
// Desc   : no delete object, just detach in list
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
LPXAttr _tagXMLNode::DetachAttr( LPXAttr attr )
{
    XAttrs::iterator it = GetAttrIterator( attr );
    if( it != NULL )
    {
        attrs.erase( it );
        return attr;
    }
    return NULL;
}

//========================================================
// Name   : CopyNode
// Desc   : copy current level node with own attributes
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
void _tagXMLNode::CopyNode(LPXNode node) {
    Close();

    parent = node->parent;
    name = node->name;
    value = node->value;

    // copy attributes
    for (size_t i = 0 ; i < node->attrs.size(); i++) {
        LPXAttr attr = node->attrs[i];
        if (attr) {
            AppendAttr(attr->name.c_str(), attr->value.c_str());
        }
    }
}

//========================================================
// Name   : _CopyBranch
// Desc   : recursive internal copy branch 
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
void _tagXMLNode::_CopyBranch(LPXNode node) {
    CopyNode( node );

    for (size_t i = 0; i < node->childs.size(); i++) {
        LPXNode child = node->childs[i];
        if (child) {
            LPXNode mychild = new XNode;
            mychild->CopyNode( child );
            AppendChild( mychild );

            mychild->_CopyBranch( child );
        }
    }
}

//========================================================
// Name   : AppendChildBranch
// Desc   : add child branch ( deep-copy )
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
LPXNode _tagXMLNode::AppendChildBranch( LPXNode node )
{
    LPXNode child = new XNode;
    child->CopyBranch( node );

    return AppendChild( child );
}

//========================================================
// Name   : CopyBranch
// Desc   : copy branch ( deep-copy )
// Param  :
// Return : 
//--------------------------------------------------------
// Coder    Date                      Desc
// bro      2002-10-29
//========================================================
void _tagXMLNode::CopyBranch( LPXNode branch )
{
    Close();
    
    _CopyBranch( branch );
}


_tagXMLEntitys::_tagXMLEntitys( LPXENTITY entities, size_t count )
{
    for( size_t i = 0; i < count; i++) {
        push_back( entities[i] );
    }
}

LPXENTITY _tagXMLEntitys::GetEntity(int entity) {
    for (size_t i = 0 ; i < size(); i ++ ) {
        if (at(i).entity == entity) {
            return LPXENTITY(&at(i));
        }
    }
    return NULL;
}

LPXENTITY _tagXMLEntitys::GetEntity(LPTSTR entity) {
    for (size_t i = 0 ; i < size(); i ++ ) {
        LPTSTR ref = (LPTSTR)at(i).ref;
        LPTSTR ps = entity;
        while (ref && *ref) {
            if (*ref++ != *ps++) {
                break;
            }
        }
        if (ref && !*ref) {  // found!
            return LPXENTITY(&at(i));
        }
    }
    return NULL;
}

size_t _tagXMLEntitys::GetEntityCount( LPCTSTR str )
{
    size_t nCount = 0;
    LPTSTR ps = (LPTSTR)str;
    while( ps && *ps ) {
        if( GetEntity( *ps++ ) ) nCount ++;
    }
    return nCount;
}

// Does not include a nul char in the result
size_t
_tagXMLEntitys::Ref2Entity(LPCTSTR estr, LPTSTR str, size_t strlen) {
    LPTSTR pes = (LPTSTR)estr;
    LPTSTR ps = str;
    LPTSTR ps_end = ps+strlen;
    while (pes && *pes && ps < ps_end) {
        LPXENTITY ent = GetEntity( pes );
        if (ent) {
            // copy entity meanning char
            *ps = ent->entity;
            pes += ent->ref_len;
        } else {
            *ps = *pes++;   // default character copy
        }
        ps++;
    }
    //*ps = '\0';
    
    // total copied characters
    return ps-str;  
}

// Does not include a nul char in the result
size_t
_tagXMLEntitys::Entity2Ref(LPCTSTR str, LPTSTR estr, size_t estrlen) {
    LPTSTR ps = (LPTSTR)str;
    LPTSTR pes = (LPTSTR)estr;
    LPTSTR pes_end = pes + estrlen;
    while (ps && *ps && pes < pes_end) {
        LPXENTITY ent = GetEntity(*ps);
        if (ent) {
            // copy entity string
            LPTSTR ref = (LPTSTR)ent->ref;
            while (ref && *ref) {
                *pes++ = *ref++;
            }
        } else {
            *pes++ = *ps;   // default character copy
        }
        ps++;
    }
    //*pes = '\0';
    
    // total copied characters
    return pes-estr;
}

std::string
_tagXMLEntitys::Ref2Entity(LPCTSTR estr) {
    std::string es;
    if (estr) {
        size_t len = _tcslen(estr);
        es.resize(len);
        //LPTSTR esbuf = es.GetBufferSetLength( len+1 );
        //if( esbuf )
        //    Ref2Entity( estr, esbuf, len );
        len = Ref2Entity(estr, &*es.begin(), len);
        es.resize(len);
    }
    return es;
}

std::string
_tagXMLEntitys::Entity2Ref(LPCTSTR str) {
    std::string s;
    if (str) {
        size_t nEntityCount = GetEntityCount(str);
        if (nEntityCount == 0) {
            return std::string(str);
        }
        // ???? /SS What is really the meaning of this?
        size_t len = _tcslen(str) + nEntityCount*10 ;
        s.resize(len);
        len = Entity2Ref(str, &*s.begin(), len);
        s.resize(len);
        //LPTSTR sbuf = s.GetBufferSetLength( len+1 );
        //if( sbuf )
        //    Entity2Ref( str, sbuf, len );
    }
    return s;
}

std::string XRef2Entity( LPCTSTR estr )
{
    return entityDefault.Ref2Entity( estr );
}

std::string XEntity2Ref( LPCTSTR str )
{
    return entityDefault.Entity2Ref( str );
}