cxml.c

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

        }

    }

    DETECT( nDataSize >= 1 );
    strcpy( pszData, "" );

    return ( ( nSubPos != NULL ) ? NORMAL : INVALID );

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_SetSubVal( \
                     IN PXMLSTRUCT pXml, \
                     IN POS nPos, \
                     IN LPCSTR pszPath, \
                     IN LPCSTR pszData \
                     )
{
    /*在节点中设置其子节点的值，其中，pszPath指的是绝对路径*/
    PXMLNODE pNode;
    POS nSubPos;

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

    DETECT( pszData == NULL || ( strlen( pszData ) + Calu_Var_Chgs( pszData ) * 4 ) <= XML_DATA_LEN );

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

    ASSERT_NORMAL( XML_LocateSubNode( ( PCXMLSTRUCT )pXml, nPos, pszPath, XML_LOCFIRST, &nSubPos ) );

    DETECT_NULL( nSubPos );

    ASSERT_NORMAL( TREE_GetVal( ( PCTREESTRUCT )&( pXml->nTree ), nSubPos, ( LPVOID * )&pNode ) );
    ASSERT_NORMAL( XML_SetInfoByPos( pXml, nSubPos, ( LPCSTR )( pNode->szName ), pszData ) );

    return NORMAL;

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_ExportNode( IN PCXMLSTRUCT pXml, IN POS nPos, IN UINT nLevel, IN BOOL bShort, OUT LPSTR pszMsg, OUT UINT *pnLen )
{
    /*导出XML的节点到缓冲区pszMsg中，其中，nLevel也可以使用TREE_GetDepth函数来取*/
    PXMLNODE pNode;
    UINT nLocLen, nLen, nLoop, nPropLen;
    BOOL bNoData;

    char szEndName[XML_NAME_LEN + 1];
    char szNodePath[XML_MAX_PATH + 5];
    char szData[XML_DATA_LEN + 100];
    LPSTR pszLocMsg;

    pszLocMsg = pszMsg;

    memset( szEndName, 0, sizeof( szEndName ) );
    memset( szNodePath, 0, sizeof( szNodePath ) );

    TREE_GetVal( ( PCTREESTRUCT )&( pXml->nTree ), nPos, ( LPVOID * )&pNode );
    MakeEndName( ( LPCSTR )( pNode->szName ), ( LPSTR )szEndName );

    nLen = nLevel;
    memset( pszMsg, '\t', nLevel );
    pszMsg = pszLocMsg + nLen;

    #ifndef _WIN32
	sprintf( szNodePath, "%s", pNode->szName );
    #else
        wsprintf( szNodePath, "%s", pNode->szName );
    #endif
	szNodePath[ strlen( szNodePath ) - 1 ] = 0;

	/*可能溢出，所以要判断长*/
    for( nLoop = 0; nLoop < pNode->nProperty.nCount; nLoop++ ) {
        /*先进行数据转换*/
        memset( szData, 0, sizeof( szData ) );
        XML_TransValue( ( LPCSTR )(pNode->nProperty.pVal[nLoop].szData ), szData );

        nPropLen = ( UINT )( strlen( szNodePath ) + 1 + strlen( pNode->nProperty.pVal[nLoop].szName ) + 2 + strlen( szData ) + 1 );
        if ( nPropLen > XML_MAX_PATH ) break; /*超长退出*/
        #ifndef _WIN32
        sprintf( szNodePath + strlen( szNodePath ), " %s=\"%s\"", pNode->nProperty.pVal[nLoop].szName, szData );
        #else
        wsprintf( szNodePath + strlen( szNodePath ), " %s=\"%s\"", pNode->nProperty.pVal[nLoop].szName, szData );
        #endif

	}

    if ( TREE_GetChildCount( ( PCTREESTRUCT )&( pXml->nTree ), nPos ) == 0 ) {
        if ( pNode->pszData != NULL ) {
            if ( strlen( pNode->pszData ) ) {
                bNoData = FALSE;

            }
            else {
                bNoData = TRUE;

            }

        }
        else {
            bNoData = TRUE;

        }

    }
    else {
        bNoData = FALSE;

    }

    /*填写精简格式*/
    if ( bNoData && bShort ) {
        szNodePath[ strlen( szNodePath ) ] = '/';

    }

	szNodePath[ strlen( szNodePath ) ] = '>';

	nLen += ( UINT )strlen( szNodePath );
	strcpy( pszMsg, szNodePath );

    pszMsg = pszLocMsg + nLen;

    if ( TREE_GetChildCount( ( PCTREESTRUCT )&( pXml->nTree ), nPos ) == 0 ) {
        if ( !bNoData ) {
            /*先进行数据转换*/
            XML_TransValue( ( LPCSTR )(pNode->pszData ), szData );
            TrimLast( szData );      /*CDeve Add For ChinaLife*/
            nLen += ( UINT )strlen( szData );
            strcpy( pszMsg, szData );
            pszMsg = pszLocMsg + nLen;
        }

    }
    else {
        nLen++;
        strcpy( pszMsg, "\n" );
        pszMsg = pszLocMsg + nLen;

        TREE_GetChildHead( ( PCTREESTRUCT )&( pXml->nTree ), &nPos );

        while ( nPos != NULL ) {
            XML_ExportNode( pXml, nPos, nLevel + 1, bShort, pszMsg, &nLocLen );

            nLen += nLocLen;
            pszMsg = pszLocMsg + nLen;

            TREE_GetNext( ( PCTREESTRUCT )&( pXml->nTree ), &nPos );

        }

        nLen += nLevel;
        memset( pszMsg, '\t', nLevel );
        pszMsg = pszLocMsg + nLen;

    }

    if ( ! ( bNoData && bShort ) ) {
        nLen += ( UINT )strlen( szEndName );
        strcpy( pszMsg, szEndName );
        pszMsg = pszLocMsg + nLen;

    }

    nLen++;
    strcpy( pszMsg, "\n" );

    *pnLen = nLen;

    return NORMAL;

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_Export( IN PCXMLSTRUCT pXml, IN BOOL bShort, OUT LPSTR pszXMLMsg, IN OUT UINT *pnSize )
{
    /*导出XML到一个缓冲区，返回实际的长度*/
    UINT nLen;

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

    DETECT_NULL( pszXMLMsg );
    DETECT( *pnSize > pXml->nLen );

    XML_ExportNode( pXml, pXml->nTree.nRootPos, 0, bShort, pszXMLMsg, &nLen );
    *pnSize = nLen;

    return NORMAL;

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_ExportToFile( IN PCXMLSTRUCT pXml, IN LPCSTR pszFile, IN BOOL bShort, IN BOOL bLangInfo )
{
    /*导出XML到文件中，并且按bLangInfo提供解释时的语言环境*/
    LPSTR pszXMLText;
    #ifdef _WIN32
    HANDLE hFile;
    #else
    FILE *fFile;
    #endif
    DWORD dWriteSize;
    UINT nSize;

    DETECT_NULL( pXml );

    /*分配XML信息缓冲区*/
    if ( ( bLangInfo == UTF8 ) || ( bLangInfo == UTF16 ) ) {
        nSize = pXml->nLen * 2 + 1024;

    }
    else {
        nSize = pXml->nLen + 1024;
        
    }

    DETECT_NULL( pszXMLText = ( LPSTR )AllocMemory( nSize ) );

    ASSERT_NORMAL( XML_ExportExt( pXml, bShort, bLangInfo, pszXMLText, &nSize ) );

    /*打开文件*/
    #ifdef _WIN32
    if ( ( hFile = CreateFile( pszFile, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, \
        FILE_ATTRIBUTE_NORMAL, NULL ) ) == INVALID_HANDLE_VALUE ) {
    #else
    if ( ( fFile = fopen( pszFile, "wb" ) ) == NULL ) {
    #endif
        FreeMemory( ( LPVOID )pszXMLText );
        return EXCEPTION;

    }

    #ifdef _WIN32
    if ( bLangInfo == UTF16 ) {
        unsigned short nUncTag = 0xFEFF;
        WriteFile( hFile, &nUncTag, ( DWORD ) sizeof( nUncTag ), &dWriteSize, NULL );

    }

    WriteFile( hFile, pszXMLText, ( DWORD ) nSize, &dWriteSize, NULL );

    CloseHandle( hFile );
    #else
    if ( bLangInfo == UTF16 ) {
        unsigned short nUncTag = 0xFEFF;
        fwrite( &nUncTag, ( DWORD ) sizeof( nUncTag ), 1, fFile );

    }

    fwrite( pszXMLText, ( DWORD ) nSize, 1, fFile );

    fclose( fFile );
    #endif

    FreeMemory( ( LPVOID )pszXMLText );

    return NORMAL;

}

/*-------------------------------------------------------------------------*/
void STDCALL XML_TransValue( IN LPCSTR pszMsg, OUT LPSTR pszVal )
{
    LPSTR p1, p2;

    p1 = ( LPSTR ) pszMsg;
    p2 = pszVal;

    *p2 = 0;

    while ( *p1 ) {
        if ( *p1 == '<' || *p1 == '&' || *p1 == '\'' || *p1 == '\"' ) {
            #ifndef _WIN32
            sprintf( p2, "&#%d;", *p1++ );
            #else
            wsprintf( p2, "&#%d;", *p1++ );
            #endif
            p2 = pszVal + strlen( pszVal );
        }
        else {
            *p2 ++ = *p1 ++;
        }
    }

    *p2 = 0;

}

/*-------------------------------------------------------------------------*/
RESULT STDCALL XML_ValueTrans( IN LPCSTR pszMsg, IN UINT nLen, OUT LPSTR pszVal )
{
    /*XML中值的转换，主要是引用实体的转换*/
    char szBuffer[10];
    char *p1, *p2;
    UINT nStrLen;

    /*初始化设置*/
    pszVal[0] = 0;

    p2 = ( char * )pszMsg;

    /*可能要循环处理*/
    while( TRUE ) {
        p1 = strchr( p2, '&' );
        if ( ( p1 == NULL ) || ( ( UINT )( p1 - pszMsg ) >= nLen ) ) {
            /*完成数据填写*/
            memcpy( pszVal + ( nStrLen = ( UINT )strlen( pszVal ) ), p2, nLen - ( p2 - pszMsg ) );
            pszVal[nStrLen + nLen - ( p2 - pszMsg )] = 0;
            return NORMAL;

        }
        else {
            /*填写数据*/
            memcpy( pszVal + ( nStrLen = ( UINT )strlen( pszVal ) ), p2, p1 - p2 );
            pszVal[nStrLen + ( p1 - p2 )] = 0;

        }

        /*定位分号*/
        p2 = strchr( p1, ';' );
        if ( ( p2 == NULL ) || ( ( UINT )( p2 - pszMsg ) >= nLen ) ) {
            return INVALID;

        }

        if ( p1[1] != '#' ) {
            char cFixed;
            /*定位是否为固有实体引用 < > & ' "*/
            if      ( !memcmp( p1, "&lt;", 4 ) ) {
                /* 是< */
                cFixed = '<';

            }
            else if ( !memcmp( p1, "&gt;", 4 ) ) {
                /* 是> */
                cFixed = '>';

            }
            else if ( !memcmp( p1, "&amp;", 5 ) ) {
                /* 是& */
                cFixed = '&';

            }
            else if ( !memcmp( p1, "&apos;", 6 ) ) {
                /* 是' */
                cFixed = '\'';

            }
            else if ( !memcmp( p1, "&quot;", 6 ) ) {
                /* 是" */
                cFixed = '\"';

            }
            else
                return INVALID;

            #ifndef _WIN32
            sprintf( pszVal + strlen( pszVal ), "%c", cFixed );
            #else
            wsprintf( pszVal + strlen( pszVal ), "%c", cFixed );
            #endif

            p2++;
            continue;

        }

        if ( ( p2 - ( p1 + 2 ) ) > 5 ) {
            /*数据会超出65535*/
            return INVALID;

        }

        memset( szBuffer, 0, sizeof( szBuffer ) );
        memcpy( szBuffer, ( p1 + 2 ), p2 - ( p1 + 2 ) );

        /*本处理只处理ASCII码，UNICODE码以后再说*/
        if ( szBuffer[0] == 'x' ) {
            /*十六进制的数据*/
            UINT nLoop;
            UINT nTimes;
            BYTE cb;

            nStrLen = 0;
            nTimes = 1;
            for( nLoop = ( UINT )strlen( szBuffer ); nLoop > 1; nLoop -- ) {
                if ( ( ToUpper( szBuffer[nLoop - 1] ) >= 'A' ) && ( ToUpper( szBuffer[nLoop -1] ) <= 'F' ) ) {
                    cb = 10 + ToUpper( szBuffer[nLoop - 1] ) - 'A';
                }
                else if ( ( szBuffer[nLoop - 1] >= '0' ) && ( szBuffer[nLoop -1] <= '9' ) ) {
                    cb = szBuffer[nLoop -1] - '0';
                }
                else
                    return INVALID;

                nStrLen += ( UINT )( nTimes * cb );
                nTimes *= 16;

            }

            if ( nStrLen == 0 ) return INVALID;
            if ( nStrLen > 255 )
                nStrLen = ( UINT )( ' ' );
            #ifndef _WIN32