rpparser.cpp

linux下的一款播放器

                    // Init the parser interface
                    retVal = m_pParser->Init(this,  // this class holds the response interface
                                             NULL,  // no special encoding
                                             bXMLStrictness); // strict XML parsing or not
                    if (SUCCEEDED(retVal))
                    {
                        retVal = SetupLegalAttrLUT();
                        if (SUCCEEDED(retVal))
                        {
                            retVal = SetupIDMaps();
                            if (SUCCEEDED(retVal))
                            {
                                // Clear the RealPix error flag
                                m_bRealPixError = FALSE;
                                // Set the state
                                m_ulState       = kStateInitialized;
                            }
                        }
                    }
                }
            }
            else
            {
                retVal = HXR_OUTOFMEMORY;
            }
            HX_RELEASE(pParser);
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

STDMETHODIMP PXRealPixParser::Parse(IHXBuffer* pFileBuffer, BOOL bIsFinal, REF(IHXBuffer*) rpErrorText)
{
    HX_RESULT retVal = HXR_OK;

    if (pFileBuffer)
    {
        if (m_pParser && m_pTagToIDMap &&
            m_pAttrToIDMap && m_pLegalAttrLUT)
        {
            // Parse the buffer
            retVal = m_pParser->Parse(pFileBuffer, bIsFinal);
            if (FAILED(retVal))
            {
                // If the m_bRealPixError flag is set, then this error
                // was a RealPix error as opposed to an XML error. If
                // it was a RealPix error, then m_pErrorText should already
                // contain an error string. If it was an XML error, then we
                // need to get the error string from the XML parser.
                HX_RELEASE(rpErrorText);
                if (m_bRealPixError && m_pErrorText)
                {
                    // We just need to assign m_pErrorText to the output buffer
                    rpErrorText = m_pErrorText;
                    rpErrorText->AddRef();
                }
                else
                {
                    // This was an error detected by the XML parser,
                    // so we need to get the error string from the parser
                    m_pParser->GetCurrentErrorText(rpErrorText);
                }
            }
            else
            {
                // Check to make sure we have some effects.
                if (m_pRealPixFile->GetNumEffects())
                {
                    // We parsed ok, so now we need to do a lot of post-parse initialization.
                    retVal = m_pRealPixFile->PostParseInit();
                }
                else
                {
                    HX_RELEASE(rpErrorText);
                    SetError(IDS_ERR_PIX_NOEFFECTS, 0, 0, NULL, NULL, rpErrorText);
                    retVal = HXR_FAIL;
                }
            }
//            if (bIsFinal)
//            {
//                m_pParser->Close();
//            }
        }
        else
        {
            retVal = HXR_UNEXPECTED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

STDMETHODIMP PXRealPixParser::HandleStartElement(const char* pName,
                                                 IHXValues* pAttributes,
                                                 UINT32      ulLineNumber,
                                                 UINT32      ulColumnNumber)
{
    HX_RESULT retVal = HXR_OK;

    // Check the input
    if (pName && pAttributes)
    {
        if (m_ulState >= kStateInitialized)
        {
            // First look up the tag ID
            UINT32 ulTagID = 0;
            retVal         = GetTagIDFromName(pName, ulTagID);
            if (SUCCEEDED(retVal))
            {
                // Loop through the attributes, checking to make sure each one
                // is a legal attribute of this tag
                const char* pszAttr = NULL;
                IHXBuffer* pValue  = NULL;
                HX_RESULT   rv      = pAttributes->GetFirstPropertyCString(pszAttr, pValue);
                while (SUCCEEDED(rv))
                {
                    if (!IsLegalAttr(ulTagID, pszAttr))
                    {
                        if (m_ulStrictnessLevel == REALPIX_STRICTNESS_HIGH)
                        {
                            retVal = HXR_FAIL;
                            break;
                        }
                        else if (m_ulStrictnessLevel == REALPIX_STRICTNESS_MEDIUM)
                        {
                            IHXBuffer* pErr = NULL;
                            SetError(IDS_ERR_PIX_ILLEGALATTR, ulLineNumber, ulColumnNumber, pszAttr, pName, pErr);
                            ReportError(HXLOG_WARNING, HXR_OK, pErr);
                            HX_RELEASE(pErr);
                        }
                    }
                    HX_RELEASE(pValue);
                    rv = pAttributes->GetNextPropertyCString(pszAttr, pValue);
                }
                HX_RELEASE(pValue);

                if (SUCCEEDED(retVal))
                {
                    // Now check to see if all the REQUIRED attributes for this
                    // tag are present.
                    const char* pszReqAttr = NULL;
                    rv                     = GetFirstRequiredAttribute(ulTagID, pszReqAttr);
                    while (SUCCEEDED(rv))
                    {
                        // Check if this attribute is present
                        IHXBuffer* pTmp = NULL;
                        retVal           = pAttributes->GetPropertyCString(pszReqAttr, pTmp);
                        HX_RELEASE(pTmp);
                        if (FAILED(retVal))
                        {
                            break;
                        }

                        // Get the next required attribute ID
                        rv = GetNextRequiredAttribute(ulTagID, pszReqAttr);
                    }

                    if (SUCCEEDED(retVal))
                    {
                        // All of the attributes were legal, and all the required
                        // attributes were present, so process the tag
                        retVal = ParseTag(ulTagID, pAttributes, ulLineNumber, ulColumnNumber, m_pErrorText);
                        if (FAILED(retVal))
                        {
                            m_bRealPixError = TRUE;
                        }
                    }
                    else
                    {
                        // We are missing a required attribute
                        m_bRealPixError = TRUE;
                        HX_RELEASE(m_pErrorText);
                        SetError(IDS_ERR_PIX_MISSREQATTR, ulLineNumber, ulColumnNumber,
                                 pszReqAttr, pName, m_pErrorText);
                    }
                }
                else
                {
                    // One of the attributes of this tag wasn't legal
                    m_bRealPixError = TRUE;
                    HX_RELEASE(m_pErrorText);
                    SetError(IDS_ERR_PIX_ILLEGALATTR, ulLineNumber, ulColumnNumber,
                             pszAttr, pName, m_pErrorText);
                }
            }
            else
            {
                // This is not a legal tag name
                m_bRealPixError = TRUE;
                HX_RELEASE(m_pErrorText);
                SetError(IDS_ERR_PIX_UNKNOWNTAG, ulLineNumber, ulColumnNumber,
                         pName, NULL, m_pErrorText);
            }
        }
        else
        {
            retVal = HXR_UNEXPECTED;
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

STDMETHODIMP PXRealPixParser::HandleEndElement(const char* pName,
                                               UINT32      ulLineNumber,
                                               UINT32      ulColumnNumber)
{
    HX_RESULT retVal = HXR_OK;

    if (pName)
    {
        // Get the tag ID
        UINT32 ulTagID = 0;
        retVal         = GetTagIDFromName(pName, ulTagID);
        if (SUCCEEDED(retVal))
        {
            if (ulTagID == kTagRoot)
            {
                if (m_ulState == kStateSawHead)
                {
                    m_ulState = kStateSawRootEnd;
                }
                else
                {
                    m_bRealPixError = TRUE;
                    retVal          = HXR_FAIL;
                    HX_RELEASE(m_pErrorText);
                    SetError(IDS_ERR_PIX_INVALIDHEAD, ulLineNumber, ulColumnNumber, NULL, NULL, m_pErrorText);
                }
            }
        }
        else
        {
            // This not a known tag
            m_bRealPixError = TRUE;
            HX_RELEASE(m_pErrorText);
            SetError(IDS_ERR_PIX_UNKNOWNTAG, ulLineNumber, ulColumnNumber,
                     pName, NULL, m_pErrorText);
        }
    }
    else
    {
        retVal = HXR_INVALID_PARAMETER;
    }

    return retVal;
}

STDMETHODIMP PXRealPixParser::HandleCharacterData(IHXBuffer* pBuffer,
                                                  UINT32      ulLineNumber,
                                                  UINT32      ulColumnNumber)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}

STDMETHODIMP PXRealPixParser::HandleProcessingInstruction(const char* pTarget,
                                                          IHXValues* pAttributes,
                                                          UINT32      ulLineNumber,
                                                          UINT32      ulColumnNumber)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}

STDMETHODIMP PXRealPixParser::HandleUnparsedEntityDecl(const char* pEntityName,
                                                       const char* pSystemID,
                                                       const char* pPublicID,
                                                       const char* pNotationName,
                                                       UINT32      ulLineNumber,
                                                       UINT32      ulColumnNumber)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}

STDMETHODIMP PXRealPixParser::HandleNotationDecl(const char* pNotationName,
                                                 const char* pSystemID,
                                                 const char* pPublicID,
                                                 UINT32      ulLineNumber,
                                                 UINT32      ulColumNumber)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}

STDMETHODIMP PXRealPixParser::HandleComment(const char* pComment,
                                            UINT32      ulLineNumber,
                                            UINT32      ulColumnNumber)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}

STDMETHODIMP PXRealPixParser::HandleUnparsedDoctypeDecl(const char* pDoctype,
                                                        const char* pSystemID,
                                                        const char* pPublicID,
                                                        UINT32      ulLineNumber,
                                                        UINT32      ulColumnNumber)
{
    HX_RESULT retVal = HXR_OK;

    return retVal;
}