xltdecxml.c

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

    if ((pScanner->pos + 9 <= pScanner->bufend) &&
        (smlLibStrncmp((String_t)pScanner->pos, "<!DOCTYPE", 9) == 0))
        if ((rc = xmlDocTypeDecl(pScanner)) != SML_ERR_OK)
            return rc;

    skipS(pScanner);

    return SML_ERR_OK;
}

/**
 * FUNCTION: xmlDocTypeDecl
 *
 * Part of the Prolog scanning
 */
static Ret_t
xmlDocTypeDecl(xmlScannerPrivPtr_t pScanner)
{
    Ret_t rc;
    String_t name = NULL;
    String_t syslit = NULL;
    String_t publit = NULL;

    readBytes(pScanner, 9);
    skipS(pScanner);
    if ((rc = xmlName(pScanner, &name)) != SML_ERR_OK) {
        smlLibFree(name);
        return rc;
    }
    skipS(pScanner);

    /* parse ExternalID */
    if ((pScanner->pos + 6 <= pScanner->bufend) &&
        (smlLibStrncmp((String_t)pScanner->pos, "SYSTEM", 6) == 0)) {
        readBytes(pScanner, 6);
        skipS(pScanner);
        if ((rc = xmlStringConst(pScanner, &syslit)) != SML_ERR_OK) {
            smlLibFree(name);
            smlLibFree(syslit);
            return rc;
        }
    } else if ((pScanner->pos + 6 <= pScanner->bufend) &&
         (smlLibStrncmp((String_t)pScanner->pos, "PUBLIC", 6) == 0)) {
        readBytes(pScanner, 6);
        skipS(pScanner);
        if ((rc = xmlStringConst(pScanner, &publit)) != SML_ERR_OK) {
            smlLibFree(name);
            smlLibFree(publit);
            return rc;
        }
        skipS(pScanner);
        if ((rc = xmlStringConst(pScanner, &syslit)) != SML_ERR_OK) {
            smlLibFree(name);
            smlLibFree(syslit);
            smlLibFree(publit);
            return rc;
        }
    }

    smlLibFree(name); 
    smlLibFree(syslit); 
    smlLibFree(publit); 

    skipS(pScanner);

    if (*pScanner->pos != '>')
        return SML_ERR_XLT_INVAL_XML_DOC;
    readBytes(pScanner, 1);

    return SML_ERR_OK;
}

/**
 * FUNCTION: xmlXMLDecl
 *
 * Part of the Prolog scanning
 */
static Ret_t
xmlXMLDecl(xmlScannerPrivPtr_t pScanner)
{
    String_t name, value;
    Ret_t rc;

    readBytes(pScanner, 5);
    skipS(pScanner);
    
    /* mandatory version info */
    if ((rc = xmlAttribute(pScanner, &name, &value)) != SML_ERR_OK)
        return rc;
    if (smlLibStrcmp(name, "version") != 0) {
        smlLibFree(name);
        smlLibFree(value);
        return SML_ERR_XLT_INVAL_XML_DOC;
    }
    smlLibFree(name);
    smlLibFree(value);

    skipS(pScanner);

    /* optional attributes are encoding and standalone */
    while ((pScanner->pos + 2 <= pScanner->bufend) &&
        (smlLibStrncmp((String_t)pScanner->pos, "?>", 2) != 0)) {
        if ((rc = xmlAttribute(pScanner, &name, &value)) != SML_ERR_OK)
            return rc;
        smlLibFree(name);
        smlLibFree(value);
        skipS(pScanner);
    }

    if (pScanner->pos + 2 > pScanner->bufend)
        return SML_ERR_XLT_END_OF_BUFFER;

    readBytes(pScanner, 2);

    return SML_ERR_OK;
}

/**
 * FUNCTION: xmlAttribute
 *
 * Handle Attributes //function can be used if attributes get necessary
 */
static Ret_t
xmlAttribute(xmlScannerPrivPtr_t pScanner, String_t *name, String_t *value)
{
    Ret_t rc;
    
    skipS(pScanner);

    if ((rc = xmlName(pScanner, name)) != SML_ERR_OK)
        return rc;

    skipS(pScanner);

		/* no attributes found, because this tag has none -> bail out */
		if (*pScanner->pos == '>') { 
			return SML_ERR_XLT_MISSING_CONT;
		}
		if (smlLibStrncmp((String_t)pScanner->pos, "/>", 2) == 0) {
			return SML_ERR_XLT_MISSING_CONT;
		}

    if (*pScanner->pos != '=') {
        smlLibFree(*name);
        *name = NULL;
        *value = NULL;
        return SML_ERR_XLT_INVAL_XML_DOC;
    }
    readBytes(pScanner, 1);

    skipS(pScanner);

    if ((rc = xmlStringConst(pScanner, value)) != SML_ERR_OK) {
        smlLibFree(*name);
        *name = NULL;
        *value = NULL;
        return rc;
    }
    
    return SML_ERR_OK;
}

/**
 * FUNCTION: xmlStringConst
 *
 * Handle Pcdata String Constants
 */
static Ret_t
xmlStringConst(xmlScannerPrivPtr_t pScanner, String_t *value)
{
    String_t end;
    int len;
    char del;

    if ((*pScanner->pos != '"') && (*pScanner->pos != '\'')) {
        *value = NULL;
        return SML_ERR_XLT_INVAL_XML_DOC;
    }
    del = *pScanner->pos;
    readBytes(pScanner, 1);
        
    if ((end = smlLibStrchr((String_t)pScanner->pos, del)) == NULL) {
        *value = NULL;
		
        return SML_ERR_XLT_END_OF_BUFFER;
    }
    len = end - (String_t)pScanner->pos;
    if ((*value = (String_t)smlLibMalloc(len + 1)) == NULL)
	{
       
		return SML_ERR_NOT_ENOUGH_SPACE;
	}
    smlLibMemset(*value, 0, len + 1);
    smlLibStrncpy(*value, (String_t)pScanner->pos, len);
    readBytes(pScanner, len + 1);

    return SML_ERR_OK;
}

/**
 * FUNCTION: xmlCharData
 *
 * Handle Pcdata character data content
 */
static Ret_t
xmlCharData(xmlScannerPrivPtr_t pScanner)
{
    SmlPcdataPtr_t pPCData;
    MemPtr_t begin;
    int len;


    pPCData = (SmlPcdataPtr_t)smlLibMalloc(sizeof(SmlPcdata_t));
    if (pPCData == NULL)
        return SML_ERR_NOT_ENOUGH_SPACE;
    pPCData->contentType = SML_PCDATA_UNDEFINED;
    pPCData->length = 0;
    pPCData->content = NULL;

    begin = pScanner->pos;
    
    if (*pScanner->pos >= *pScanner->bufend) {
        pPCData->content     = NULL;
        pPCData->contentType = SML_PCDATA_UNDEFINED;
        pPCData->extension   = SML_EXT_UNDEFINED;
        pPCData->length      = 0;
   	    pScanner->curtok->type = TOK_CONT;  
        pScanner->curtok->pcdata = pPCData; 
        //smlLibFree(pPCData);
        return SML_ERR_XLT_END_OF_BUFFER;
    }

    while (*pScanner->pos != '<') /* && (*pScanner->pos != '&') */
    {
      if (pScanner->pos >= pScanner->bufend)
      {
        smlLibFree(pPCData);
        return SML_ERR_XLT_INVAL_SYNCML_DOC;
      }
      if (!readBytes(pScanner, 1)) {
          smlLibFree(pPCData);
        return SML_ERR_XLT_END_OF_BUFFER;
      }
	  
    }
    len = pScanner->pos - begin;
    pPCData->content = smlLibMalloc(len + 1);
    if (pPCData->content == NULL){
        smlLibFree(pPCData);
		return SML_ERR_NOT_ENOUGH_SPACE;
	}
    smlLibMemset(pPCData->content, 0, len + 1);
    smlLibMemcpy(pPCData->content, begin, len);
    pPCData->contentType = SML_PCDATA_STRING;
    pPCData->length = len;

    pScanner->curtok->type = TOK_CONT;
    pScanner->curtok->pcdata = pPCData;

    return SML_ERR_OK;
}

/**
 * FUNCTION: xmlName
 *
 * Handle Name Elements
 */
static Ret_t
xmlName(xmlScannerPrivPtr_t pScanner, String_t *name)
{
    MemPtr_t begin;
    String_t tmp;
    int len;

    begin = pScanner->pos;
    while (((*pScanner->pos >= 'a') && (*pScanner->pos <= 'z')) ||
           ((*pScanner->pos >= 'A') && (*pScanner->pos <= 'Z')) ||
           ((*pScanner->pos >= '0') && (*pScanner->pos <= '9')) ||
           (*pScanner->pos == '.') || (*pScanner->pos == '-') ||
           (*pScanner->pos == '_') || (*pScanner->pos == ':'))
        if (!readBytes(pScanner, 1))
            return SML_ERR_XLT_END_OF_BUFFER;
        
    len = pScanner->pos - begin;
		/* T.K. bail out if len is zero without modifying name */
		if (len == 0) return SML_ERR_OK;


    tmp = (String_t)smlLibMalloc(len + 1);
    if (tmp == NULL) {
        *name = NULL;
        return SML_ERR_NOT_ENOUGH_SPACE;
    }
    smlLibMemset(tmp, 0, len + 1);
    smlLibStrncpy(tmp, (String_t)begin, len);
    *name = tmp;
    return SML_ERR_OK;
}

/**
 * FUNCTION: xmlTag
 *
 * Handle XML Tags
 */
static Ret_t
xmlTag(xmlScannerPrivPtr_t pScanner, Byte_t endtag)
{
    Ret_t rc;
    String_t name, attname=NULL, value = NULL, nsprefix = NULL;
	Byte_t nsprelen = 0;
    XltTagID_t tagid;
	SmlPcdataExtension_t ext;


    if (endtag) {
        if (!readBytes(pScanner, 2))
            return SML_ERR_XLT_END_OF_BUFFER;
    } else {
        if (!readBytes(pScanner, 1))
            return SML_ERR_XLT_END_OF_BUFFER;
    }

    if ((rc = xmlName(pScanner, &name)) != SML_ERR_OK)
    {
        if (rc != SML_ERR_NOT_ENOUGH_SPACE)
        {
            return SML_ERR_XLT_INVAL_XML_DOC;
        }
        else
        {
            return rc;
        }
        
    }

	ext = pScanner->ext;
	if (!endtag) {
		/* Namespaces can only be defined on start, never on endtags
		 * but we have to make sure we close a namespace on the corrsponding endtag.
		 * Thats why we a) only open a namespace when it differs from the previous one, and
		 * b) record the tag_id that opend the namespace so we can close it when the 
		 * corresponding endtag is reached.
		 */
               
        if ((rc = xmlAttribute(pScanner, &attname, &value)) == SML_ERR_OK)
        {
			if (smlLibStrncmp(attname, "xmlns", 5) == 0) {
				/* Heureka we found a Namespace :-) */
				/* It's save to check attname[5] here, as it contains at least the terminating '\000' */
				if (attname[5] == ':') { /* we found a namespace prefixdefinition */
                    nsprelen = (Byte_t)smlLibStrlen(&attname[6]);
					nsprefix = smlLibMalloc(nsprelen+1);
                    if (nsprefix == NULL) {
                        smlLibFree(attname);
                        smlLibFree(value);
                        smlLibFree(name);
                        return SML_ERR_NOT_ENOUGH_SPACE;
                    }
					smlLibStrcpy(nsprefix,&attname[6]);						
				}
				ext = getExtByName(value);
				if (ext == 255) {
					smlLibFree(nsprefix); /* doesn't harm, even when empty */
					smlLibFree(attname);
					smlLibFree(value);
					smlLibFree(name);
					return  SML_ERR_XLT_INVALID_CODEPAGE;
				}
			} else {
                if (rc == SML_ERR_NOT_ENOUGH_SPACE){
                    smlLibFree(attname);
                    smlLibFree(value);
                    smlLibFree(name);
                    return SML_ERR_NOT_ENOUGH_SPACE;
                }
                else{
				/* we found an unknown attribute -> bail out */
				smlLibFree(attname);
				smlLibFree(value);
				/* nsprefix is empty here so we save us a function call */
				smlLibFree(name);
				return SML_ERR_XLT_INVAL_XML_DOC;
			}
		}
            
        }
        else if ( rc != SML_ERR_XLT_MISSING_CONT)
        {
            /* xmlAttribute returns an SML_ERR_XLT_MISSING_CONT error when
             * no attribute was found. This is not an error, but everything else is.
             */
            smlLibFree(value);
            smlLibFree(name);
            return rc;
        }