xltdecwbxml.c

SyncML ToolKits,学习syncml的参考工具包.非常好用.

    return rc;
}

/**
 * FUNCTION: pushTok
 *
 * Reset the scanner to the starting position of the current token within
 * the buffer. 
 */
static Ret_t
_pushTok(XltDecScannerPtr_t pScanner)
{
    wbxmlScannerPrivPtr_t pScannerPriv;
    XltUtilStackPtr_t pTagStack;
    XltTagID_t tagid;
    Ret_t rc = 0;

    pScannerPriv = (wbxmlScannerPrivPtr_t)pScanner;
    pTagStack = pScannerPriv->tagstack;

    if (pScannerPriv->curtok->start == NULL)
        return SML_ERR_WRONG_USAGE;

    /* reset scanner to position where tok begins */
    pScannerPriv->pos = pScannerPriv->curtok->start;

    /* correct the tag stack */
    if (pScannerPriv->curtok->type == TOK_TAG_START) {
        rc = pTagStack->pop(pTagStack, &tagid);
    } else if (pScannerPriv->curtok->type == TOK_TAG_END) {
        tagid = pScannerPriv->curtok->tagid;
        rc = pTagStack->push(pTagStack, tagid);
    }
    if (rc) return rc;

    /* invalidate curtok */
    /* T.K. Possible Error. pScannerPriv->curtok is of type XltDecToken_t NOT ...Ptr_t */
    // OrigLine:
    // smlLibMemset(pScannerPriv->curtok, 0, sizeof(XltDecTokenPtr_t));
    pScannerPriv->curtok->type = (XltTokType_t)0;
    
    return SML_ERR_OK;
}

static void
_setBuf(XltDecScannerPtr_t pScanner, const MemPtr_t pBufStart,
        const MemPtr_t pBufEnd)
{
    wbxmlScannerPrivPtr_t pScannerPriv = (wbxmlScannerPrivPtr_t)pScanner;
    pScannerPriv->pos = pBufStart;
    pScannerPriv->bufend = pBufEnd;
}

static MemPtr_t
_getPos(XltDecScannerPtr_t pScanner)
{
    return ((wbxmlScannerPrivPtr_t)pScanner)->pos;
}

/*************************************************************************/
/* Internal Functions                                                    */
/*************************************************************************/

/**
 * FUNCTION: readBytes
 *
 * Advance the position pointer. Description see above.
 */
static Boolean_t
readBytes(wbxmlScannerPrivPtr_t pScanner, Long_t bytes)
{
    if (pScanner->pos + bytes > pScanner->bufend) {
        pScanner->finished = 1;
        return 0;
    }
    pScanner->pos += bytes;
    return 1;
}

/**
 * NOTICE: Entities, Extensions, Processing Instructions and Attributes
 * are not supported by the WBXML scanner.
 *
 * Extensions and Attributes are document-specific and are as such not used 
 * by the SyncML specification.
 * The scanner will just ignore and skip over them. Neither
 * this scanner nor the parser use processing instructions so they are
 * skipped as well.
 */

/**
 * FUNCTION: wbxmlHeader
 *
 * Decode the WBXML header containing version number, document public
 * identifier, character set and a string table.
 */
static Ret_t
wbxmlHeader(wbxmlScannerPrivPtr_t pScanner)
{
    Ret_t rc;

    /* decode the WBXML header */
    if ((rc = wbxmlVersion(pScanner)) != SML_ERR_OK)
        return rc;
    if ((rc = wbxmlPublicID(pScanner)) != SML_ERR_OK)
        return rc;
    if ((rc = wbxmlCharset(pScanner)) != SML_ERR_OK)
        return rc;
    if ((rc = wbxmlStrtbl(pScanner)) != SML_ERR_OK)
        return rc;
    return SML_ERR_OK;
}

/**
 * FUNCTION: wbxmlVersion
 *
 * Decode WBXML version. The scanner returns an error if the major version
 * of the document differs from the major version this scanner supports or
 * if the minor version of the document is larger than the minor version
 * the scanner supports.
 */
static Ret_t
wbxmlVersion(wbxmlScannerPrivPtr_t pScanner)
{
    Byte_t major, minor;

    minor = ((Byte_t)(*pScanner->pos & 0x0F));
     major = ((Byte_t)((*pScanner->pos >> 4) + 1));
   


    if (major != _MAJOR_VERSION || minor > _MINOR_VERSION)
        return SML_ERR_XLT_INCOMP_WBXML_VERS;

    if (!readBytes(pScanner, 1))
        return SML_ERR_XLT_END_OF_BUFFER;

    return SML_ERR_OK;
}

/**
 * FUNCTION: wbxmlPublicID
 *
 * Decodes WBXML Document Public Identifier.
 */
static Ret_t
wbxmlPublicID(wbxmlScannerPrivPtr_t pScanner)
{
    MBINT tmp;
    Ret_t rc;

    if (*pScanner->pos != 0) {
        /* pre-defined numeric identifier */
        if ((rc = parseInt(pScanner, &tmp)) != SML_ERR_OK)
            return rc;
        pScanner->pubID = tmp;
        pScanner->pubIDIdx = 0;
    } else {
        /* public id is given as string table entry (which we
           haven't read at this point so we'll save the reference
           for later) */
        if  (!readBytes(pScanner, 1))
            return SML_ERR_XLT_END_OF_BUFFER;
        if ((rc = parseInt(pScanner, &tmp)) != SML_ERR_OK)
            return rc;
        pScanner->pubID = 0;
        pScanner->pubIDIdx = tmp;
    }
    if (!readBytes(pScanner, 1))
        return SML_ERR_XLT_END_OF_BUFFER;
    return SML_ERR_OK;
}

/**
 * FUNCTION: wbxmlCharset
 *
 * Decode WBXML Charset.
 */
static Ret_t
wbxmlCharset(wbxmlScannerPrivPtr_t pScanner)
{
    /* TODO: if charset iformation has to be processed
       it can be done here. For the moment only UTF-8 is used by SyncML */
    MBINT mibenum;
    Ret_t rc;

    /* charset is given as a single IANA assigned MIBEnum value */
    if ((rc = parseInt(pScanner, &mibenum)) != SML_ERR_OK)
        return rc;
    pScanner->charset = mibenum;

    if (!readBytes(pScanner, 1))
        return SML_ERR_XLT_END_OF_BUFFER;

    return SML_ERR_OK;
}

/**
 * FUNCTION: wbxmlStrtbl
 *
 * Keep a copy of the string table.
 */
static Ret_t
wbxmlStrtbl(wbxmlScannerPrivPtr_t pScanner)
{
    MBINT len;
    Ret_t rc;

    if ((rc = parseInt(pScanner, &len)) != SML_ERR_OK)
        return rc;
    if (!readBytes(pScanner, 1))
        return SML_ERR_XLT_END_OF_BUFFER;
    pScanner->strtbllen = len;
    if (len > 0) {
        if (pScanner->pos + len > pScanner->bufend)
            return SML_ERR_XLT_END_OF_BUFFER;
        if ((pScanner->strtbl = smlLibMalloc(len)) == NULL)
        {
            return SML_ERR_NOT_ENOUGH_SPACE;
        }
        smlLibMemcpy(pScanner->strtbl, pScanner->pos, len);
        readBytes(pScanner, len);
    } else {
        pScanner->strtbl = NULL;
    }

    /* if the public ID was given as a string table reference save a
       reference to the corresponding string for later */
    if (pScanner->pubID == 0) {
        if (pScanner->pubIDIdx > pScanner->strtbllen)
            return SML_ERR_XLT_INVAL_WBXML_DOC;
        pScanner->pubIDStr = (String_t)(pScanner->strtbl + pScanner->pubIDIdx);
    }

    return SML_ERR_OK;
}

static Ret_t
parseInt(wbxmlScannerPrivPtr_t pScanner, MBINT *mbi)
{
    *mbi = 0;
    /* accumulate byte value until continuation flag (MSB) is zero */
    for (;;)  {
        *mbi = *mbi << 7;
        *mbi += *(pScanner->pos) & 0x7F;
        if (!(*pScanner->pos & 0x80)) break;
        if (!readBytes(pScanner, 1))
            return SML_ERR_XLT_END_OF_BUFFER;
    }
    return SML_ERR_OK;
}

static Ret_t
wbxmlStringToken(wbxmlScannerPrivPtr_t pScanner)
{
    SmlPcdataPtr_t pPcdata;
    Ret_t rc;

    if ((pPcdata = (SmlPcdataPtr_t)smlLibMalloc(sizeof(SmlPcdata_t))) == NULL)
        return SML_ERR_NOT_ENOUGH_SPACE;
    /* copy the string into the new PCdata struct */
    if (IS_STR_I(pScanner->pos)) {
        /* inline string */
        if (!readBytes(pScanner, 1))
            return SML_ERR_XLT_END_OF_BUFFER;
        pPcdata->extension   = SML_EXT_UNDEFINED;
        pPcdata->contentType = SML_PCDATA_STRING;
        pPcdata->length = smlLibStrlen((String_t)pScanner->pos);
        if (pScanner->pos + pPcdata->length + 1 > pScanner->bufend) {
            smlLibFree(pPcdata);
            return SML_ERR_XLT_END_OF_BUFFER;
        }
        if ((pPcdata->content = smlLibMalloc(pPcdata->length + 1)) == NULL) {
            smlLibFree(pPcdata);
            return SML_ERR_NOT_ENOUGH_SPACE;
        }
        smlLibStrncpy(pPcdata->content, (String_t)pScanner->pos, pPcdata->length + 1);
        readBytes(pScanner, pPcdata->length + 1);

    } else {
        /* string table reference */
        MBINT offset; /* offset into string table */
        if (!readBytes(pScanner, 1))
            return SML_ERR_XLT_END_OF_BUFFER;
        if ((rc = parseInt(pScanner, &offset)) != SML_ERR_OK) {
            smlLibFree(pPcdata);
            return rc;
        }
        if (offset >= pScanner->strtbllen) {
            smlLibFree(pPcdata);
            return SML_ERR_XLT_INVAL_WBXML_DOC;
        }
        pPcdata->contentType = SML_PCDATA_STRING;
        pPcdata->length = smlLibStrlen((String_t)(pScanner->strtbl + offset));
        if ((pPcdata->content = smlLibMalloc(pPcdata->length + 1)) == NULL) {
            smlLibFree(pPcdata);
            return SML_ERR_NOT_ENOUGH_SPACE;
        }
        smlLibStrncpy(pPcdata->content, (String_t)(pScanner->strtbl + offset), pPcdata->length + 1);
        readBytes(pScanner, 1);
    }

    pScanner->curtok->pcdata = pPcdata;

    pScanner->curtok->type = TOK_CONT;

    return SML_ERR_OK;
}

static Ret_t
wbxmlOpaqueToken(wbxmlScannerPrivPtr_t pScanner)
{
    SmlPcdataPtr_t pPcdata = NULL;
    MBINT len;
    Ret_t rc;

    if (!readBytes(pScanner, 1))
        return SML_ERR_XLT_END_OF_BUFFER;

    /* a mbi indicates the length of the opaque data block that we'll
       copy into new PCdata struct */
    if ((rc = parseInt(pScanner, &len)) != SML_ERR_OK)
        return rc;
    if (!readBytes(pScanner, 1))
        return SML_ERR_XLT_END_OF_BUFFER;
    if (pScanner->pos + len > pScanner->bufend)
        return SML_ERR_XLT_END_OF_BUFFER;
    if ((pPcdata = (SmlPcdataPtr_t)smlLibMalloc(sizeof(SmlPcdata_t))) == NULL)
        return SML_ERR_NOT_ENOUGH_SPACE;
    pPcdata->extension   = SML_EXT_UNDEFINED;
    pPcdata->contentType = SML_PCDATA_OPAQUE;
    pPcdata->length = len;
    /* Modification 2001-07-03 by Luz %%%%%:
     * made sure that content is one null byte longer
     * than indicated opaque content, such that strings that are coded as
     * opaque (happens to be the case with Nokia 9210) can still be read
     * as C-string without need for an intermediate buffer
     */
    /* original:
    if ((pPcdata->content = smlLibMalloc(len)) == NULL) {
        smlLibFree(pPcdata);
        return SML_ERR_NOT_ENOUGH_SPACE;
    }
    */
    /* modified: */
    if ((pPcdata->content = smlLibMalloc(len+1)) == NULL) {
        smlLibFree(pPcdata);
        return SML_ERR_NOT_ENOUGH_SPACE;
    }
    ((char *)pPcdata->content)[len]=0; /* make sure there is a c-string terminator */
    /* end modification */
    
    smlLibMemcpy(pPcdata->content, pScanner->pos, len);
    pScanner->curtok->pcdata = pPcdata;

    readBytes(pScanner, len);

    pScanner->curtok->type = TOK_CONT;

    return SML_ERR_OK;
}

static Ret_t
wbxmlTagToken(wbxmlScannerPrivPtr_t pScanner)
{