wbxml_encoder.c

WAP Binary XML 简单地说

    encoder->in_content = FALSE;
    encoder->in_cdata = FALSE;
    encoder->cdata = NULL;

    encoder->xml_encode_header = TRUE;

    /* Default Version: WBXML 1.3 */
    encoder->wbxml_version = WBXML_VERSION_13;

    /**
     * Default Output Charset Encoding is the one found in WBXML Tree,
     * so set it as 'unknown' for now.
     */
    encoder->output_charset = WBXML_CHARSET_UNKNOWN;
    
    encoder->flow_mode = FALSE;
    encoder->pre_last_node_len = 0;
    encoder->textual_publicid = FALSE;

    return encoder;
}


WBXML_DECLARE(void) wbxml_encoder_destroy(WBXMLEncoder *encoder)
{
    if (encoder == NULL)
        return;

    wbxml_buffer_destroy(encoder->output);
    wbxml_buffer_destroy(encoder->output_header);
    wbxml_buffer_destroy(encoder->cdata);

#if defined( WBXML_ENCODER_USE_STRTBL )
    wbxml_list_destroy(encoder->strstbl, wbxml_strtbl_element_destroy_item);
#endif /* WBXML_ENCODER_USE_STRTBL */

    wbxml_free(encoder);
}


WBXML_DECLARE(void) wbxml_encoder_reset(WBXMLEncoder *encoder)
{
    if (encoder == NULL)
        return;

    encoder->tree = NULL;

    wbxml_buffer_destroy(encoder->output);
    encoder->output = NULL;
    
    wbxml_buffer_destroy(encoder->output_header);
    encoder->output_header = NULL;
    
    encoder->current_tag = NULL;
    encoder->current_attr = NULL;
    
    encoder->tagCodePage = 0;
    encoder->attrCodePage = 0;
    
    encoder->in_content = FALSE;
    encoder->in_cdata = FALSE;
    
    wbxml_buffer_destroy(encoder->cdata);
    encoder->cdata = NULL;
    
    encoder->pre_last_node_len = 0;

#if defined( WBXML_ENCODER_USE_STRTBL )
    wbxml_list_destroy(encoder->strstbl, wbxml_strtbl_element_destroy_item);
    encoder->strstbl = NULL;
    encoder->strstbl_len = 0;
#endif /* WBXML_ENCODER_USE_STRTBL */
}


WBXML_DECLARE(void) wbxml_encoder_set_ignore_empty_text(WBXMLEncoder *encoder, WB_BOOL set_ignore)
{
    if (encoder == NULL)
        return;

    encoder->ignore_empty_text = set_ignore;
}


WBXML_DECLARE(void) wbxml_encoder_set_remove_text_blanks(WBXMLEncoder *encoder, WB_BOOL set_remove)
{
    if (encoder == NULL)
        return;

    encoder->remove_text_blanks = set_remove;
}


WBXML_DECLARE(void) wbxml_encoder_set_output_charset(WBXMLEncoder *encoder, WBXMLCharsetMIBEnum charset)
{
  if (encoder == NULL)
    return;

  /* Tell which Output Charset Encoding to use (this overides the Charset Encoding found in WBXML Tree) */
  encoder->output_charset = charset;
}


WBXML_DECLARE(void) wbxml_encoder_set_use_strtbl(WBXMLEncoder *encoder, WB_BOOL use_strtbl)
{
#if defined( WBXML_ENCODER_USE_STRTBL )
    if (encoder == NULL)
        return;

    encoder->use_strtbl = use_strtbl;
#endif /* WBXML_ENCODER_USE_STRTBL */
}


WBXML_DECLARE(void) wbxml_encoder_set_wbxml_version(WBXMLEncoder *encoder, WBXMLVersion version)
{
    if (encoder == NULL)
        return;

    if (version != WBXML_VERSION_UNKNOWN)
        encoder->wbxml_version = version;
}


WBXML_DECLARE(void) wbxml_encoder_set_xml_gen_type(WBXMLEncoder *encoder, WBXMLGenXMLType gen_type)
{
    if (encoder == NULL)
        return;

    encoder->xml_gen_type = gen_type;
}


WBXML_DECLARE(void) wbxml_encoder_set_indent(WBXMLEncoder *encoder, WB_UTINY indent)
{
    if (encoder == NULL)
        return;

    encoder->indent_delta = indent;
}


WBXML_DECLARE(void) wbxml_encoder_set_tree(WBXMLEncoder *encoder, WBXMLTree *tree)
{
    if (encoder == NULL)
        return;

    encoder->tree = tree;
}


WBXML_DECLARE(WBXMLError) wbxml_encoder_encode_tree_to_wbxml(WBXMLEncoder *encoder, WB_UTINY **wbxml, WB_ULONG *wbxml_len)
{
    WBXMLError ret = WBXML_OK;

    /* Check Parameters */
    if (encoder == NULL)
        return WBXML_ERROR_BAD_PARAMETER;
    
    /* Init ret values */
    *wbxml = NULL;
    *wbxml_len = 0;

    /* We output WBXML */
    wbxml_encoder_set_output_type(encoder, WBXML_ENCODER_OUTPUT_WBXML);

    /* Encode */
    if ((ret = encoder_encode_tree(encoder)) != WBXML_OK)
        return ret;

    /* Get result */
    return wbxml_encoder_get_output(encoder, wbxml, wbxml_len);
}


WBXML_DECLARE(WBXMLError) wbxml_encoder_encode_tree_to_xml(WBXMLEncoder *encoder, WB_UTINY **xml, WB_ULONG *xml_len)
{
    WBXMLError ret = WBXML_OK;

    /* Check Parameters */
    if (encoder == NULL)
        return WBXML_ERROR_BAD_PARAMETER;
    
    /* Init ret values */
    *xml = NULL;
    *xml_len = 0;

    /* We output WBXML */
    wbxml_encoder_set_output_type(encoder, WBXML_ENCODER_OUTPUT_XML);

    /* Encode */
    if ((ret = encoder_encode_tree(encoder)) != WBXML_OK)
        return ret;

    /* Get result */
    return wbxml_encoder_get_output(encoder, xml, xml_len);
}


WBXML_DECLARE(WBXMLError) wbxml_encoder_set_flow_mode(WBXMLEncoder *encoder, WB_BOOL flow_mode)
{
    if (encoder == NULL)
        return WBXML_ERROR_BAD_PARAMETER;
    
    encoder->flow_mode = TRUE;
    
    /* Don't use String Tables */
    wbxml_encoder_set_use_strtbl(encoder, FALSE);
    
    return WBXML_OK;
}


WBXML_DECLARE(void) wbxml_encoder_set_output_type(WBXMLEncoder *encoder, WBXMLEncoderOutputType output_type)
{
    if (encoder == NULL)
        return;
    
    encoder->output_type = output_type;
}


WBXML_DECLARE(void) wbxml_encoder_set_lang(WBXMLEncoder *encoder, WBXMLLanguage lang)
{
    if (encoder == NULL)
        return;

    encoder->lang = wbxml_tables_get_table(lang);
}


WBXML_DECLARE(void) wbxml_encoder_set_text_public_id(WBXMLEncoder *encoder, WB_BOOL gen_text)
{
    if (encoder == NULL)
        return;
    
    encoder->textual_publicid = gen_text;
}


WBXML_DECLARE(WBXMLError) wbxml_encoder_encode_node(WBXMLEncoder *encoder, WBXMLTreeNode *node)
{
    return wbxml_encoder_encode_node_with_elt_end(encoder, node, TRUE);
}


WBXML_DECLARE(WBXMLError) wbxml_encoder_encode_node_with_elt_end(WBXMLEncoder *encoder, WBXMLTreeNode *node, WB_BOOL enc_end)
{
    WB_ULONG   prev_len = 0;
    WBXMLError ret      = WBXML_OK;
    
    if ((encoder == NULL) || (node == NULL))
        return WBXML_ERROR_BAD_PARAMETER;
    
    if (encoder->flow_mode == FALSE) {
        WBXML_WARNING((WBXML_ENCODER, "You should NOT call wbxml_encoder_encode_node() if you are not in Flow Mode encoding ! (use wbxml_encoder_set_flow_mode(encoder, TRUE))"));
    }
    
    /* Check that language table has been set */
    if (encoder->lang == NULL)
        return WBXML_ERROR_BAD_PARAMETER;
    
    /* Init Output Buffer if needed */
    if (!encoder_init_output(encoder))
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;
    
    /* Backup length */
    prev_len = wbxml_buffer_len(encoder->output);
    
    /* Check if result header is not already built */
    if ((encoder->flow_mode == TRUE) && (encoder->output_header == NULL) &&
        !((encoder->xml_encode_header == FALSE) && (encoder->output_type == WBXML_ENCODER_OUTPUT_XML)))
    {
        /* Build result header */
        switch (encoder->output_type) {
        case WBXML_ENCODER_OUTPUT_XML:
            if ((encoder->output_header = wbxml_buffer_create("", 0, WBXML_ENCODER_XML_HEADER_MALLOC_BLOCK)) == NULL)
                ret = WBXML_ERROR_NOT_ENOUGH_MEMORY;
            else
                ret = xml_fill_header(encoder, encoder->output_header);
            break;
            
        case WBXML_ENCODER_OUTPUT_WBXML:
            if ((encoder->output_header = wbxml_buffer_create("", 0, WBXML_ENCODER_WBXML_HEADER_MALLOC_BLOCK)) == NULL)
                ret = WBXML_ERROR_NOT_ENOUGH_MEMORY;
            else
                ret = wbxml_fill_header(encoder, encoder->output_header);
            break;
            
        default:
            ret = WBXML_ERROR_BAD_PARAMETER;
            break;
        }
    }
    
    if (ret != WBXML_OK)
        return ret;
    
    if ((ret = parse_node(encoder, node, enc_end)) == WBXML_OK)
        encoder->pre_last_node_len = prev_len;
    
    return ret;
}


WBXML_DECLARE(WBXMLError) wbxml_encoder_encode_tree(WBXMLEncoder *encoder, WBXMLTree *tree)
{
    const WBXMLLangEntry *lang = NULL;
    WBXMLError            ret  = WBXML_OK;
    
    if ((encoder == NULL) || (tree == NULL))
        return WBXML_ERROR_BAD_PARAMETER;
    
    /* Backup encoder lang */
    lang = encoder->lang;
    
    /* Set Tree lang to encoder */
    encoder->lang = tree->lang;
    
    /* Encode root node */
    ret = wbxml_encoder_encode_node(encoder, tree->root);
    
    /* Revert encoder lang */
    encoder->lang = lang;
    
    return ret;
}


WBXML_DECLARE(WBXMLError) wbxml_encoder_encode_raw_elt_start(WBXMLEncoder *encoder, WBXMLTreeNode *node, WB_BOOL has_content)
{
    /* Init Output Buffer if needed */
    if (!encoder_init_output(encoder))
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;
    
    return parse_element(encoder, node, has_content);
}


WBXML_DECLARE(WBXMLError) wbxml_encoder_encode_raw_elt_end(WBXMLEncoder *encoder, WBXMLTreeNode *node, WB_BOOL has_content)
{
    /* Init Output Buffer if needed */
    if (!encoder_init_output(encoder))
        return WBXML_ERROR_NOT_ENOUGH_MEMORY;
    
    return parse_element_end(encoder, node, has_content);
}


WBXML_DECLARE(WBXMLError) wbxml_encoder_get_output(WBXMLEncoder *encoder, WB_UTINY **result, WB_ULONG *result_len)
{
    if ((encoder == NULL) || (result == NULL) || (result_len == NULL))
        return WBXML_ERROR_BAD_PARAMETER;
    
    switch (encoder->output_type) {
    case WBXML_ENCODER_OUTPUT_XML:
        return xml_build_result(encoder, result, result_len);
        
    case WBXML_ENCODER_OUTPUT_WBXML:
        return wbxml_build_result(encoder, result, result_len);
        
    default:
        return WBXML_ERROR_BAD_PARAMETER;
    }
}


WBXML_DECLARE(WB_ULONG) wbxml_encoder_get_output_len(WBXMLEncoder *encoder)
{
    if (encoder == NULL)
        return 0;
    
    return wbxml_buffer_len(encoder->output_header) + wbxml_buffer_len(encoder->output);
}


WBXML_DECLARE(void) wbxml_encoder_delete_output_bytes(WBXMLEncoder *encoder, WB_ULONG nb)
{
    if (encoder == NULL)
        return;
    
    wbxml_buffer_delete(encoder->output, wbxml_buffer_len(encoder->output) - nb, nb);
}


WBXML_DECLARE(void) wbxml_encoder_delete_last_node(WBXMLEncoder *encoder)
{
    if (encoder == NULL)
        return;
    
    wbxml_encoder_delete_output_bytes(encoder, wbxml_buffer_len(encoder->output) - encoder->pre_last_node_len);
}


/***************************************************
 *    Private Functions
 */