cxml.c

一个简单的在unix 处理xml解析的程序。程序流程简单功能清晰。对想自已写xml处理程序的应有一定的帮助

    nPos = pXml->nTree.nRootPos;

    /*在XML中定位节点名*/
    XML_LocateNode( pXml, &nPos, pszPath );
    DETECT_NULL( nPos );

    /*删除XML的节点*/
    XML_DelNodeByPos( pXml, nPos );

    return NORMAL;

}

/*-------------------------------------------------------------------------*/

/*-------------------------------------------------------------------------*/

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_LocateNode( IN PCXMLSTRUCT pXml, IN OUT PPOS pPos, IN LPCSTR pszPath )
{
    /*在XML的节点pPos及其子节点中定位pszPath的位置，并通过pPos返回其值*/
    /*pszPath不含根节点的路径*/
    POS nPos;

    DETECT_NULL( pXml );
    DETECT_NULL( pXml->nTree.nRootPos );
    DETECT_NULL( pPos );
    DETECT( TREE_NodeIsValid( &( pXml->nTree ), *pPos ) );

    if ( pXml->nTree.nRootPos == *pPos ) {
        /*是根节点*/
        TREE_GetChildHead( &( pXml->nTree ), pPos );
        while( *pPos != NULL ) {
            /*遍历子节点*/
            nPos = *pPos;
            if ( VERIFY_NORMAL( XML_Locate( ( PXMLSTRUCT )pXml, &nPos, pszPath, 0 ) ) ) {
                /*是成功返回*/
                if ( nPos != NULL ) {
                    *pPos = nPos;
                    return NORMAL;
                }
            }

            /*定位下一个子节点*/
            TREE_GetNext( &( pXml->nTree ), pPos );

        }
    }
    else {
        /*是子节点*/
        ASSERT_NORMAL( XML_Locate( ( PXMLSTRUCT )pXml, pPos, pszPath, 0 ) );
    }

    if ( *pPos == NULL )
        return INVALID;

    return NORMAL;

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_Locate( IN PXMLSTRUCT pXml, IN OUT PPOS pPos, IN LPCSTR pszPath, IN UINT nMode )
{
    /*在某一节点中定位pszPath指定的节点，其中，
    如果pPos不为根节点，pszPath应该包含本节点的名字的路径；
    否则此函数不能处理或处理出错，在使用时，应该更加注意。
    此函数在对某个节点搜索时，应该不要使用参数：XML_LOCLAST。*/
    POS nPos, nPosLoc;
    PXMLNODE pNode;
    UINT nLen;

    char szInPath[XML_PATH_LEN + XML_PATH_LEN + 1];
    char szName[XML_NAME_LEN + 1], szPath[XML_PATH_LEN + 1], szLocPath[XML_PATH_LEN + 1];
    char tmpName[XML_NAME_LEN + 1];

    DETECT_NULL( pXml );
    DETECT_NULL( pXml->nTree.nRootPos );
    DETECT_NULL( pPos );

    DETECT( TREE_NodeIsValid( &( pXml->nTree ), *pPos ) );

    DETECT_NULL( pszPath );
    DETECT( strlen( pszPath ) <= XML_PATH_LEN );

    /*判断是否是根节点*/
    memset( szInPath, 0, sizeof( szInPath ) );
    if ( pXml->nTree.nRootPos == *pPos ) {
        nLen = sizeof( szInPath );
        XML_GetRootName( ( PCXMLSTRUCT )pXml, szInPath, &nLen );
        #ifndef _WIN32
        sprintf( szInPath + strlen( szInPath ), strlen( pszPath ) ? "/%s" : "%s", pszPath );
        #else
        wsprintf( szInPath + strlen( szInPath ), strlen( pszPath ) ? "/%s" : "%s", pszPath );
        #endif
    }
    else {
        #ifndef _WIN32
        sprintf( szInPath, "%s", pszPath );
        #else
        wsprintf( szInPath, "%s", pszPath );
        #endif
    }

    /*取节点的值*/
    TREE_GetVal( ( PCTREESTRUCT )&( pXml->nTree ), *pPos, ( LPVOID * )&pNode );
    
    memset( tmpName, 0, sizeof( tmpName ) );
    strcpy( tmpName, pNode->szName + 1 );
    tmpName[strlen( tmpName ) - 1] = 0;

    if ( ( strcmp( pNode->szName, szInPath ) == 0 ) || ( strcmp( tmpName, szInPath ) == 0 ) ) {
        /*找到*/
        return NORMAL;

    }

    /*取余下的路径*/
    GetLeavePath( szInPath, szPath );

    /*如果取路径失败*/
    if ( !VERIFY_NORMAL( GetRootName( szInPath, szName ) ) ) {
        *pPos = NULL;
        return INVALID;
    }

    /*如果节点名不匹配*/
    if ( strcmp( szName, pNode->szName ) != 0 ) {
        *pPos = NULL;
        return NORMAL;
    }

    /*备份节点位置*/
    nPosLoc = *pPos;

    /*在此加入定位的方式，如以第一次出现的方式定位或以最后一次的出现定位*/
    /*------------------------------------------------------------------*/
    /*在子节点中搜索匹配的节点名*/
    if ( nMode & XML_LOCLAST ) {
        /*从最后面往前找*/
        TREE_GetChildTail( ( PCTREESTRUCT )&( pXml->nTree ), pPos );
    }
    else {
        /*从最前面往后找*/
        TREE_GetChildHead( ( PCTREESTRUCT )&( pXml->nTree ), pPos );
    }

    while( *pPos != NULL ) {
        /*存在子节点*/
        nPos = *pPos;
        ASSERT_NORMAL( XML_Locate( pXml, &nPos, szPath, nMode ) );

        if ( nPos != NULL ) {
            *pPos = nPos;
            return NORMAL;
        }

        /*如果没有找到，则定位下一个子节点*/
        if ( nMode & XML_LOCLAST ) {
            TREE_GetPrior( ( PCTREESTRUCT )&( pXml->nTree ), pPos );
        }
        else {
            TREE_GetNext( ( PCTREESTRUCT )&( pXml->nTree ), pPos );
        }

    }

    /*判断是否是需要自动增长节点*/
    if ( ( *pPos == NULL ) && ( nMode & XML_AUTOGROW ) ) {
        /*自动增长节点*/
        while( strlen( szPath ) ) {
            if ( !VERIFY_NORMAL( GetRootName( ( LPCSTR )szPath, ( LPSTR )szName ) ) ) {
                *pPos = NULL;
                return INVALID;
            }

            /*插入子节点*/
            ASSERT_NORMAL( XML_InsertChildTail( pXml, nPosLoc, szName, NULL, NULL ) );

            TREE_GetChildTail( ( PCTREESTRUCT )&( pXml->nTree ), &nPosLoc );
            *pPos = nPosLoc;

            strcpy( szLocPath, szPath );
            GetLeavePath( ( LPCSTR )szLocPath, ( LPSTR )szPath );

        }

    }

    return NORMAL;

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_LocateNext( IN PCXMLSTRUCT pXml, IN OUT PPOS pPos )
{
    /*定位下一个节点，是延续XML_LocateNode(AtNode)函数的操作*/
    DETECT_NULL( pXml );
    DETECT_NULL( pXml->nTree.nRootPos );
    DETECT_NULL( pPos );
    DETECT( TREE_NodeIsValid( &( pXml->nTree ), *pPos ) );

    /*定位下一个节点*/
    ASSERT_NORMAL( TREE_GetNext( ( PCTREESTRUCT )&( pXml->nTree ), pPos ) );

    return NORMAL;

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_LocatePrior( IN PCXMLSTRUCT pXml, IN OUT PPOS pPos )
{
    /*定位下一个节点，是延续XML_LocateNode(AtNode)函数的操作*/
    DETECT_NULL( pXml );
    DETECT_NULL( pXml->nTree.nRootPos );
    DETECT_NULL( pPos );
    DETECT( TREE_NodeIsValid( &( pXml->nTree ), *pPos ) );

    /*定位下一个节点*/
    ASSERT_NORMAL( TREE_GetPrior( ( PCTREESTRUCT )&( pXml->nTree ), pPos ) );

    return NORMAL;

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_LocateNextTwin( IN PCXMLSTRUCT pXml, IN OUT PPOS pPos )
{
    /*定位下一个节点，其中节点名为：pPos的节点名，是延续XML_LocateNode(AtNode)函数的操作*/
    char szName[XML_NAME_LEN + 1];
    PXMLNODE pNode;

    DETECT_NULL( pXml );
    DETECT_NULL( pXml->nTree.nRootPos );
    DETECT_NULL( pPos );
    DETECT( TREE_NodeIsValid( &( pXml->nTree ), *pPos ) );

    /*取节点名*/
    ASSERT_NORMAL( TREE_GetVal( &( pXml->nTree ), *pPos, ( LPVOID * )&pNode ) );
    DETECT_NULL( pNode );
    strcpy( szName, pNode->szName );

    /*定位下一个节点*/
    ASSERT_NORMAL( TREE_GetNext( ( PCTREESTRUCT )&( pXml->nTree ), pPos ) );
    while( *pPos != NULL ) {
        ASSERT_NORMAL( TREE_GetVal( &( pXml->nTree ), *pPos, ( LPVOID * )&pNode ) );
        if ( strcmp( szName, pNode->szName ) == 0 ) {
            return NORMAL;
        }

        ASSERT_NORMAL( TREE_GetNext( ( PCTREESTRUCT )&( pXml->nTree ), pPos ) );
    }

    return INVALID;

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_LocatePriorTwin( IN PCXMLSTRUCT pXml, IN OUT PPOS pPos )
{
    /*定位下一个节点，其中节点名为：pPos的节点名，是延续XML_LocateNode(AtNode)函数的操作*/
    char szName[XML_NAME_LEN + 1];
    PXMLNODE pNode;

    DETECT_NULL( pXml );
    DETECT_NULL( pXml->nTree.nRootPos );
    DETECT_NULL( pPos );
    DETECT( TREE_NodeIsValid( &( pXml->nTree ), *pPos ) );

    /*取节点名*/
    ASSERT_NORMAL( TREE_GetVal( &( pXml->nTree ), *pPos, ( LPVOID * )&pNode ) );
    DETECT_NULL( pNode );
    strcpy( szName, pNode->szName );

    /*定位下一个节点*/
    ASSERT_NORMAL( TREE_GetPrior( ( PCTREESTRUCT )&( pXml->nTree ), pPos ) );
    while( *pPos != NULL ) {
        ASSERT_NORMAL( TREE_GetVal( &( pXml->nTree ), *pPos, ( LPVOID * )&pNode ) );
        if ( strcmp( szName, pNode->szName ) == 0 ) {
            return NORMAL;
        }

        ASSERT_NORMAL( TREE_GetPrior( ( PCTREESTRUCT )&( pXml->nTree ), pPos ) );
    }

    return INVALID;

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_LocateParent( IN PCXMLSTRUCT pXml, IN OUT PPOS pPos )
{
    /*此函数定位父节点的位置，增加于2003-05-19*/
    DETECT_NULL( pXml );
    DETECT_NULL( pXml->nTree.nRootPos );
    DETECT_NULL( pPos );
    DETECT( TREE_NodeIsValid( &( pXml->nTree ), *pPos ) );

    /*定位父节点*/
    ASSERT_NORMAL( TREE_GetParent( ( PCTREESTRUCT )&( pXml->nTree ), pPos ) );

    return NORMAL;

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_LocateSubNode( IN PCXMLSTRUCT pXml, IN POS nPos, IN LPCSTR pszPath, IN UINT nMode, OUT PPOS pSubPos )
{
    /*在节点中定位子节点，如果路径pszPath指定的节点不在nPos中，则返回出错*/
    UINT nNewMode;
    UINT nPathLen;
    char sztmpPath[XML_MAX_PATH + 1];
    char szInPath[XML_MAX_PATH + 1];
    LPSTR p1;
    char szName[XML_NAME_LEN + 1];

    DETECT_NULL( pXml );
    DETECT_NULL( pXml->nTree.nRootPos );
    DETECT_NULL( pSubPos );
    DETECT( TREE_NodeIsValid( &( pXml->nTree ), nPos ) );

    DETECT_NULL( pszPath );
    DETECT( strlen( pszPath ) <= XML_PATH_LEN );

    nPathLen = sizeof( sztmpPath );
    memset( sztmpPath, 0, sizeof( sztmpPath ) );

    ASSERT_NORMAL( XML_GetNodePath( ( PCXMLSTRUCT )pXml, nPos, sztmpPath, &nPathLen ) );

    /*转换路径*/
    nPathLen = ( UINT )sizeof( szInPath );
    ASSERT_NORMAL( XML_ConvertPath( pszPath, szInPath, &nPathLen ) );

    /*判断路径pszPath所指定的节点的路径是否是nPos的子节点的路径*/
    DETECT_NULL( ( p1 = ( LPSTR )strstr( szInPath, sztmpPath ) ) );
    DETECT( strcmp( szInPath, sztmpPath ) != 0 );

    ASSERT_NORMAL( GetLastName( ( LPCSTR )sztmpPath, ( LPSTR )szName ) );
    p1 += ( strlen( sztmpPath ) - strlen( szName ) );

    /*取节点的相对路径，包含此节点的名字*/
    strcpy( sztmpPath, p1 );
    *pSubPos = nPos;

    nNewMode = ( nMode & XML_LOCLAST ) | ( nMode & XML_LOCFIRST );

    return XML_Locate( ( PXMLSTRUCT )pXml, pSubPos, sztmpPath, nNewMode );

}

/*-------------------------------------------------------------------------*/
/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_InsertRoot( IN OUT PXMLSTRUCT pXml, IN LPCSTR pszName, IN LPCSTR pszData, IN PCNODEPROPERTY pProp )
{
    /*插入XML的根节点*/
    PXMLNODE pNode;
    UINT nNameLen, nDataLen, nLen, nProperLen, iLoop;
    char tmpName[XML_NAME_LEN + 1];

    DETECT_NULL( pXml );
    /*可以修改为：在任何情况下，都可以插入根节点*/
    DETECT( pXml->nTree.nRootPos == NULL );

    ASSERT_NORMAL( GetRootName( pszName, tmpName ) );

    nNameLen = ( UINT )strlen( tmpName );
    nDataLen = ( pszData == NULL ? 0 : ( UINT )strlen( pszData ) ) + Calu_Var_Chgs( ( LPCSTR )( pszData ) ) * 4;

    DETECT( nNameLen <= XML_NAME_LEN );
    DETECT( nDataLen <= XML_DATA_LEN );

    /*计算属性的长度*/
	nProperLen = 0;
	if ( pProp != NULL ) {
		for( iLoop = 0; iLoop < pProp->nCount; iLoop ++ ) {
			nProperLen += ( UINT )( strlen( pProp->pVal[iLoop].szName ) + 2 \
				+ strlen( pProp->pVal[iLoop].szData ) \
                + Calu_Var_Chgs( pProp->pVal[iLoop].szData ) * 4 + 2 );
		}
	}

	/*计算XML的长度*/
	nLen = nNameLen * 2 + 2 + nDataLen + nProperLen;
    DETECT( nLen <= pXml->nMaxLen );

    if ( VERIFY_NULL( pNode = ( PXMLNODE )XML_AllocNode( ( LPCSTR )tmpName, pszData, pProp ) ) &&
        VERIFY_NORMAL( TREE_InsertRoot( &( pXml->nTree ), ( LPCVOID )pNode ) ) ) {
        pXml->nLen += nLen;
        return NORMAL;

    }

    if ( pNode != NULL )
        XML_FreeNode( pNode );

    return EXCEPTION;

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_InsertNode( IN OUT PXMLSTRUCT pXml, IN LPCSTR pszPath, IN LPCSTR pszData, IN PCNODEPROPERTY pProp, IN UINT nMode )
{
    /*在XML中按指定模式插入指定的节点信息*/
    PXMLNODE pNode;
    POS nPos, nPosLoc;

    char szPath[XML_PATH_LEN + 1];
    char szName[XML_NAME_LEN + 1];

    DETECT_NULL( pXml );
    DETECT_NULL( pXml->nTree.nRootPos );