wml_compiler.c File Reference

#include <time.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <string.h>
#include <math.h>
#include <ctype.h>
#include <inttypes.h>
#include <libxml/xmlmemory.h>
#include <libxml/tree.h>
#include <libxml/debugXML.h>
#include <libxml/encoding.h>
#include <libxml/parser.h>
#include <libxml/xmlerror.h>
#include "gwlib/gwlib.h"
#include "wml_compiler.h"
#include "xml_definitions.h"
#include "wbxml_tokens.def"
#include "xml_shared.h"
#include "wml_definitions.h"

Go to the source code of this file.

Data Structures
struct	wml_externalid_t
struct	wbxml_version_t
struct	wml_table_t
struct	wml_table3_t
struct	wml_binary_t
struct	string_table_t
struct	string_table_proposal_t
struct	wml_hash_t
struct	wml_attribute_t

Macros
#define	NUMBERED(name, strings)   static const wml_externalid_t name##_strings[] = { strings };
#define	ASSIGN(string, number)   { string, number },
#define	NUMBER_OF_WML_EXTERNALID   ((long) sizeof(public_ids_strings)/sizeof(public_ids_strings[0]))
#define	NUMBER_OF_WBXML_VERSION   sizeof(wbxml_version)/sizeof(wbxml_version[0])

Typedefs
typedef struct wml_externalid_t	wml_externalid_t
typedef struct wbxml_version_t	wbxml_version_t

Enumerations
enum	var_esc_t { NOESC, ESC, UNESC, FAILED }

Functions
static int	parse_document (xmlDocPtr document, Octstr *charset, wml_binary_t **wbxml, Octstr *version)
static int	parse_node (xmlNodePtr node, wml_binary_t **wbxml)
static int	parse_element (xmlNodePtr node, wml_binary_t **wbxml)
static int	parse_attribute (xmlAttrPtr attr, wml_binary_t **wbxml)
static int	parse_attr_value (Octstr *attr_value, List *tokens, wml_binary_t **wbxml, int charset, var_esc_t default_esc)
static int	parse_text (xmlNodePtr node, wml_binary_t **wbxml)
static int	parse_cdata (xmlNodePtr node, wml_binary_t **wbxml)
static int	parse_st_octet_string (Octstr *ostr, int cdata, var_esc_t default_esc, wml_binary_t **wbxml)
static void	parse_st_end (wml_binary_t **wbxml)
static void	parse_entities (Octstr *wml_source)
static int	parse_variable (Octstr *text, int start, var_esc_t default_esc, Octstr **output, wml_binary_t **wbxml)
static Octstr *	get_variable (Octstr *text, int start)
static var_esc_t	check_variable_syntax (Octstr *variable, var_esc_t default_esc)
static wml_binary_t *	wml_binary_create (void)
static void	wml_binary_destroy (wml_binary_t *wbxml)
static void	wml_binary_output (Octstr *ostr, wml_binary_t *wbxml)
static void	output_st_char (int byte, wml_binary_t **wbxml)
static void	output_st_octet_string (Octstr *ostr, wml_binary_t **wbxml)
static void	output_variable (Octstr *variable, Octstr **output, var_esc_t escaped, wml_binary_t **wbxml)
static wml_hash_t *	hash_create (char *text, unsigned char token)
static wml_attribute_t *	attribute_create (void)
static void	attr_dict_construct (wml_table3_t *attributes, Dict *attr_dict)
static void	hash_destroy (void *p)
static void	attribute_destroy (void *p)
static int	hash_cmp (void *hash1, void *hash2)
static int	check_do_elements (xmlNodePtr node)
static var_esc_t	check_variable_name (xmlNodePtr node)
static Octstr *	get_do_element_name (xmlNodePtr node)
static int	check_if_url (int hex)
static int	check_if_emphasis (xmlNodePtr node)
static int	wml_table_len (wml_table_t *table)
static int	wml_table3_len (wml_table3_t *table)
static string_table_t *	string_table_create (int offset, Octstr *ostr)
static void	string_table_destroy (string_table_t *node)
static string_table_proposal_t *	string_table_proposal_create (Octstr *ostr)
static void	string_table_proposal_destroy (string_table_proposal_t *node)
static void	string_table_build (xmlNodePtr node, wml_binary_t **wbxml)
static void	string_table_collect_strings (xmlNodePtr node, List *strings)
static List *	string_table_collect_words (List *strings)
static List *	string_table_sort_list (List *start)
static List *	string_table_add_many (List *sorted, wml_binary_t **wbxml)
static unsigned long	string_table_add (Octstr *ostr, wml_binary_t **wbxml)
static void	string_table_apply (Octstr *ostr, wml_binary_t **wbxml)
static void	string_table_output (Octstr *ostr, wml_binary_t **wbxml)
static void	xml_error (void)
int	wml_compile (Octstr *wml_text, Octstr *charset, Octstr **wml_binary, Octstr *version)
void	wml_init (int wml_xml_strict)
void	wml_shutdown ()

Variables
static wbxml_version_t	wbxml_version []
Dict *	wml_elements_dict
Dict *	wml_attributes_dict
List *	wml_attr_values_list
List *	wml_URL_values_list
int	wml_xml_parser_opt

Macro Definition Documentation

ASSIGN

#define ASSIGN	(		string,
			number
	)		{ string, number },

Definition at line 105 of file wml_compiler.c.

NUMBER_OF_WBXML_VERSION

#define NUMBER_OF_WBXML_VERSION   sizeof(wbxml_version)/sizeof(wbxml_version[0])

Definition at line 125 of file wml_compiler.c.

Referenced by parse_document().

NUMBER_OF_WML_EXTERNALID

#define NUMBER_OF_WML_EXTERNALID   ((long) sizeof(public_ids_strings)/sizeof(public_ids_strings[0]))

Definition at line 108 of file wml_compiler.c.

Referenced by parse_document().

NUMBERED

#define NUMBERED	(		name,
			strings
	)		static const wml_externalid_t name##_strings[] = { strings };

Definition at line 103 of file wml_compiler.c.

Typedef Documentation

wbxml_version_t

typedef struct wbxml_version_t wbxml_version_t

Definition at line 115 of file wml_compiler.c.

wml_externalid_t

typedef struct wml_externalid_t wml_externalid_t

Definition at line 101 of file wml_compiler.c.

Enumeration Type Documentation

var_esc_t

enum var_esc_t

Enumerator
NOESC
ESC
UNESC
FAILED

Definition at line 128 of file wml_compiler.c.

{ NOESC, ESC, UNESC, FAILED } var_esc_t;

Function Documentation

attr_dict_construct()

static void attr_dict_construct ( wml_table3_t *  attributes, Dict *  attr_dict  )

static

Definition at line 1422 of file wml_compiler.c.

References wml_attribute_t::attribute, attribute_create(), wml_attribute_t::binary, dict_put(), gwlist_append(), hash_create(), octstr_create, wml_table3_t::token, token, and wml_attribute_t::value_list.

Referenced by wml_init().

{
    int i = 0;
    wml_attribute_t *node = NULL;
    wml_hash_t *temp = NULL;

    node = attribute_create();

    do {
    if (node->attribute == NULL)
        node->attribute = octstr_create(attributes[i].text1);
    else if (strcmp(attributes[i].text1, attributes[i-1].text1) != 0) {
        dict_put(attr_dict, node->attribute, node);
        node = attribute_create();
        node->attribute = octstr_create(attributes[i].text1);
    }

    if (attributes[i].text2 == NULL)
        node->binary = attributes[i].token;
    else {
        temp = hash_create(attributes[i].text2, attributes[i].token);
        gwlist_append(node->value_list, (void *)temp);
    }   
    i++;
    } while (attributes[i].text1 != NULL);

    dict_put(attr_dict, node->attribute, node);
}

attribute_create()

static wml_attribute_t * attribute_create ( void  )

static

Definition at line 1403 of file wml_compiler.c.

References wml_attribute_t::attribute, wml_attribute_t::binary, gwlist_create, and wml_attribute_t::value_list.

Referenced by attr_dict_construct().

{
    wml_attribute_t *attr;

    attr = gw_malloc(sizeof(wml_attribute_t));
    attr->attribute = NULL;
    attr->binary = 0;
    attr->value_list = gwlist_create();

    return attr;
}

attribute_destroy()

static void attribute_destroy ( void *  p )

static

Definition at line 1476 of file wml_compiler.c.

References wml_attribute_t::attribute, gwlist_destroy(), hash_destroy(), octstr_destroy(), and wml_attribute_t::value_list.

Referenced by wml_init().

{
    wml_attribute_t *node;

    if (p == NULL)
    return;

    node = p;

    octstr_destroy(node->attribute);
    gwlist_destroy(node->value_list, hash_destroy);
    gw_free(node);
}

check_do_elements()

static int check_do_elements ( xmlNodePtr  node )

static

Definition at line 1517 of file wml_compiler.c.

References error(), get_do_element_name(), gwlist_append(), gwlist_create, gwlist_destroy(), gwlist_get(), gwlist_len(), name, octstr_compare(), octstr_destroy(), and octstr_destroy_item().

Referenced by parse_element().

{
    xmlNodePtr child;
    int i, status = 0;
    Octstr *name = NULL;
    List *name_list = NULL;
    
    name_list = gwlist_create();

    if ((child = node->children) != NULL) {
        while (child != NULL) {
            if (child->name && strcmp((char *)child->name, "do") == 0) {
                name = get_do_element_name(child);

                if (name == NULL) {
                    error(0, "WML compiler: no name or type in a do element");
                    return -1;
                }

                for (i = 0; i < gwlist_len(name_list); i ++)
                    if (octstr_compare(gwlist_get(name_list, i), name) == 0) {
                        octstr_destroy(name);
                        status = -1;
                        break;
                    }
                if (status != -1)
                    gwlist_append(name_list, name);
                else
                    break;
            }
            child = child->next;
        }
    }

    gwlist_destroy(name_list, octstr_destroy_item);

    return status;
}

check_if_emphasis()

static int check_if_emphasis ( xmlNodePtr  node )

static

Definition at line 1652 of file wml_compiler.c.

Referenced by parse_text().

{
    if (node == NULL || node->name == NULL)
    return 0;

    if (strcmp((char *)node->name, "b") == 0)
    return 1;
    if (strcmp((char *)node->name, "big") == 0)
    return 1;
    if (strcmp((char *)node->name, "em") == 0)
    return 1;
    if (strcmp((char *)node->name, "i") == 0)
    return 1;
    if (strcmp((char *)node->name, "small") == 0)
    return 1;
    if (strcmp((char *)node->name, "strong") == 0)
    return 1;
    if (strcmp((char *)node->name, "u") == 0)
    return 1;

    return 0;
}

check_if_url()

static int check_if_url ( int  hex )

static

Definition at line 1634 of file wml_compiler.c.

Referenced by parse_attribute().

{
    switch ((unsigned char) hex) {
    case 0x4A: case 0x4B: case 0x4C: /* href, href http://, href https:// */
    case 0x32: case 0x58: case 0x59: /* src, src http://, src https:// */
    return 1;
    break;
    }
    return 0;
}

check_variable_name()

static var_esc_t check_variable_name ( xmlNodePtr  node )

static

Definition at line 1563 of file wml_compiler.c.

References check_variable_syntax(), create_octstr_from_node, error(), FAILED, name, NOESC, and octstr_destroy().

Referenced by parse_element().

{
    Octstr *name = NULL;
    xmlAttrPtr attr; 
    var_esc_t ret = FAILED;

    if ((attr = node->properties) != NULL) {
        while (attr != NULL) {
            if (attr->name && strcmp((char *)attr->name, "name") == 0) {
                name = create_octstr_from_node((char *)attr->children);
                break;
            }
            attr = attr->next;
        }
    }

    if (attr == NULL) {
        error(0, "WML compiler: no name in a setvar element");
        return FAILED;
    }

    ret = check_variable_syntax(name, NOESC);
    octstr_destroy(name);
    
    return ret;
}

check_variable_syntax()

static var_esc_t check_variable_syntax ( Octstr *  variable, var_esc_t  default_esc  )

static

Definition at line 1095 of file wml_compiler.c.

References error(), ESC, FAILED, NOESC, octstr_convert_range(), octstr_copy, octstr_destroy(), octstr_get_char(), octstr_len(), octstr_search_char(), octstr_str_compare(), octstr_truncate(), UNESC, and warning().

Referenced by check_variable_name(), and parse_variable().

{
    Octstr *escape;
    char ch;
    int pos, len, i;
    var_esc_t ret;

    if ((pos = octstr_search_char(variable, ':', 0)) > 0) {
    len = octstr_len(variable) - pos;
    escape = octstr_copy(variable, pos + 1, len - 1);
    octstr_truncate(variable, pos);
    octstr_truncate(escape, len);
    octstr_convert_range(escape, 0, octstr_len(escape), tolower);

    if (octstr_str_compare(escape, "noesc") == 0 ||
        octstr_str_compare(escape, "n") == 0 )
        ret = NOESC;
    else if (octstr_str_compare(escape, "unesc") == 0 ||
         octstr_str_compare(escape, "u") == 0 )
        ret = UNESC;
    else if (octstr_str_compare(escape, "escape") == 0 ||
         octstr_str_compare(escape, "e") == 0 )
        ret = ESC;
    else {
        error(0, "WML compiler: syntax error in variable escaping.");
        octstr_destroy(escape);
        return FAILED;
    }
    octstr_destroy(escape);
    } else
    ret = default_esc;

    ch = octstr_get_char(variable, 0);
    if (!(isalpha((int)ch)) && ch != '_') {
    error(0, "WML compiler: syntax error in variable; name starting "
          "with %c.", ch);
    return FAILED;
    } else
    for (i = 1; i < (int) octstr_len(variable); i++)
        if (!isalnum((int)(ch = octstr_get_char(variable, 0))) && 
        ch != '_') {
        warning(0, "WML compiler: syntax error in variable.");
        return FAILED;
        }

    return ret;
}

get_do_element_name()

static Octstr * get_do_element_name ( xmlNodePtr  node )

static

Definition at line 1598 of file wml_compiler.c.

References create_octstr_from_node, and name.

Referenced by check_do_elements().

{
    Octstr *name = NULL;
    xmlAttrPtr attr; 

    if ((attr = node->properties) != NULL) {
        while (attr != NULL) {
            if (attr->name && strcmp((char *)attr->name, "name") == 0) {
                name = create_octstr_from_node((char *)attr->children);
                break;
            }
            attr = attr->next;
        }

        if (attr == NULL) {
            attr = node->properties;
            while (attr != NULL) {
                if (attr->name && strcmp((char *)attr->name, "type") == 0) {
                    name = create_octstr_from_node((char *)attr->children);
                    break;
                }
                attr = attr->next;
            }
        }
    }

    return name;
}

get_variable()

static Octstr * get_variable ( Octstr *  text, int  start  )

static

Definition at line 1054 of file wml_compiler.c.

References error(), gw_assert(), octstr_copy, octstr_create, octstr_get_char(), octstr_len(), octstr_search_char(), start, and text.

Referenced by parse_variable().

{
    Octstr *var = NULL;
    long end;
    int ch;

    gw_assert(text != NULL);
    gw_assert(start >= 0 && start <= (int) octstr_len(text));

    ch = octstr_get_char(text, start);

    if (ch == '$') {
    var = octstr_create("$");
    } else if (ch == '(') {
    start ++;
    end = octstr_search_char(text, ')', start);
    if (end == -1)
        error(0, "WML compiler: braces opened, but not closed for a "
          "variable.");
    else if (end - start == 0)
        error(0, "WML compiler: empty braces without variable.");
    else
        var = octstr_copy(text, start, end - start);
    } else {
    end = start + 1;
    while (isalnum(ch = octstr_get_char(text, end)) || (ch == '_'))
        end ++;

    var = octstr_copy(text, start, end - start);
    }

    return var;
}

hash_cmp()

static int hash_cmp ( void *  hash1, void *  hash2  )

static

Definition at line 1497 of file wml_compiler.c.

References gw_assert(), and octstr_search().

Referenced by parse_attribute().

{
    int ret = 0;

    gw_assert(item != NULL && pattern != NULL);
    gw_assert(((wml_hash_t *)item)->item != NULL);

    if (octstr_search(pattern, ((wml_hash_t *)item)->item, 0) == 0)
    ret = 1;

    return ret;
}

hash_create()

static wml_hash_t * hash_create ( char *  text, unsigned char  token  )

static

Definition at line 1384 of file wml_compiler.c.

References wml_hash_t::binary, wml_hash_t::item, octstr_create, text, and token.

Referenced by attr_dict_construct(), and wml_init().

{
    wml_hash_t *table_node;

    table_node = gw_malloc(sizeof(wml_hash_t));
    table_node->item = octstr_create(text);
    table_node->binary = token;

    return table_node;
}

hash_destroy()

static void hash_destroy ( void *  p )

static

Definition at line 1457 of file wml_compiler.c.

References wml_hash_t::item, and octstr_destroy().

Referenced by attribute_destroy(), wml_init(), and wml_shutdown().

{
    wml_hash_t *node;

    if (p == NULL)
        return;

    node = p;

    octstr_destroy(node->item);
    gw_free(node);
}

output_st_char()

static void output_st_char ( int  byte, wml_binary_t **  wbxml  )

static

Definition at line 1335 of file wml_compiler.c.

References octstr_append_char().

Referenced by parse_attr_value(), parse_attribute(), parse_element(), parse_st_end(), and string_table_apply().

{
    octstr_append_char((*wbxml)->wbxml_string, byte);
}

output_st_octet_string()

static void output_st_octet_string ( Octstr *  ostr, wml_binary_t **  wbxml  )

static

Definition at line 1347 of file wml_compiler.c.

References octstr_insert(), and octstr_len().

Referenced by parse_st_octet_string(), and string_table_apply().

{
    octstr_insert((*wbxml)->wbxml_string, ostr, 
          octstr_len((*wbxml)->wbxml_string));
}

output_variable()

static void output_variable ( Octstr *  variable, Octstr **  output, var_esc_t  escaped, wml_binary_t **  wbxml  )

static

Definition at line 1359 of file wml_compiler.c.

References ESC, octstr_append_char(), octstr_append_uintvar(), string_table_add(), UNESC, WBXML_EXT_T_0, WBXML_EXT_T_1, and WBXML_EXT_T_2.

Referenced by parse_variable().

{
  switch (escaped)
    {
    case ESC:
      octstr_append_char(*output, WBXML_EXT_T_0);
      break;
    case UNESC:
      octstr_append_char(*output, WBXML_EXT_T_1);
      break;
    default:
      octstr_append_char(*output, WBXML_EXT_T_2);
      break;
    }

  octstr_append_uintvar(*output, string_table_add(variable, wbxml));
}

parse_attr_value()

static int parse_attr_value ( Octstr *  attr_value, List *  tokens, wml_binary_t **  wbxml, int  charset, var_esc_t  default_esc  )

static

Definition at line 834 of file wml_compiler.c.

References wml_hash_t::binary, charset, charset_convert(), error(), gw_assert(), gwlist_get(), gwlist_len(), wml_hash_t::item, octstr_copy, octstr_delete(), octstr_destroy(), octstr_len(), octstr_search(), octstr_search_char(), output_st_char(), and parse_st_octet_string().

Referenced by parse_attribute().

{
    int i, pos, wbxml_hex;
    wml_hash_t *temp = NULL;
    Octstr *cut_text = NULL;
    char *tmp;

    /*
     * Beware that libxml2 does internal encoding in UTF-8 while parsing.
     * So if our original WML source had a different encoding set, we have
     * to transcode at least here. Only transcode if target encoding differs
     * from libxml2's internal encoding (UTF-8).
     */
    tmp = (char*) xmlGetCharEncodingName(charset);
    if (charset != XML_CHAR_ENCODING_UTF8 && 
        charset_convert(attr_value, "UTF-8", 
                        tmp) != 0) {
        error(0, "Failed to convert XML attribute value from charset "
                 "<%s> to <%s>, will leave as is.", "UTF-8", 
                 tmp ? tmp : "(undef)");
    }


    /*
     * The attribute value is search for text strings that can be replaced 
     * with one byte codes. Note that the algorith is not foolproof; seaching 
     * is done in an order and the text before first hit is not checked for 
     * those tokens that are after the hit in the order. Most likely it would 
     * be waste of time anyway. String table is not used here, since at least 
     * Nokia 7110 doesn't seem to understand string table references here.
     */

    /* A fast patch to allow reserved names to be variable names. May produce 
       a little longer binary at some points. --tuo */
    if (octstr_search_char(attr_value, '$', 0) >= 0) {
    if (parse_st_octet_string(attr_value, 0, default_esc, wbxml) != 0)
        return -1;
    } else {

    for (i = 0; i < gwlist_len(tokens); i++) {
        temp = gwlist_get(tokens, i);
        pos = octstr_search(attr_value, temp->item, 0);
        switch (pos) {
        case -1:
        break;
        case 0:
        wbxml_hex = temp->binary;
        output_st_char(wbxml_hex, wbxml);   
        octstr_delete(attr_value, 0, octstr_len(temp->item));   
        break;
        default:
        /* 
         *  There is some text before the first hit, that has to 
         *  be handled too. 
         */
        gw_assert(pos <= octstr_len(attr_value));
    
        cut_text = octstr_copy(attr_value, 0, pos);
        if (parse_st_octet_string(cut_text, 0, default_esc, wbxml) != 0)
            return -1;
        octstr_destroy(cut_text);
        
        wbxml_hex = temp->binary;
        output_st_char(wbxml_hex, wbxml);   

        octstr_delete(attr_value, 0, pos + octstr_len(temp->item));
        break;
        }
    }

    /* 
     * If no hits, then the attr_value is handled as a normal text, 
     * otherwise the remaining part is searched for other hits too. 
     */

    if ((int) octstr_len(attr_value) > 0) {
        if (i < gwlist_len(tokens))
        parse_attr_value(attr_value, tokens, wbxml, charset, default_esc);
        else
        if (parse_st_octet_string(attr_value, 0, default_esc, wbxml) != 0)
            return -1;
    }
    }

    return 0;
}

parse_attribute()

static int parse_attribute ( xmlAttrPtr  attr, wml_binary_t **  wbxml  )

static

Definition at line 740 of file wml_compiler.c.

References wml_attribute_t::attribute, wml_hash_t::binary, wml_attribute_t::binary, check_if_url(), create_octstr_from_node, dict_get(), error(), ESC, gwlist_search(), hash_cmp(), wml_hash_t::item, name, NOESC, octstr_append_uintvar(), octstr_copy, octstr_create, octstr_destroy(), octstr_duplicate, octstr_get_cstr, octstr_len(), octstr_str_compare(), output_st_char(), parse_attr_value(), string_table_add(), wml_attribute_t::value_list, warning(), WBXML_LITERAL, wml_attr_values_list, wml_attributes_dict, and wml_URL_values_list.

Referenced by parse_element().

{
    int status = 0;
    int coded_length = 0;
    unsigned char wbxml_hex = 0x00;
    wml_hash_t *hit = NULL;
    wml_attribute_t *attribute = NULL;
    Octstr *name = NULL, *pattern = NULL, *p = NULL;

    name = octstr_create((char *)attr->name);

    if (attr->children != NULL)
    pattern = create_octstr_from_node((char *)attr->children);
    else 
    pattern = NULL;

    /* Check if the attribute is found on the code page. */

    if ((attribute = dict_get(wml_attributes_dict, name)) != NULL) {
    if (attr->children == NULL || 
        (hit = gwlist_search(attribute->value_list, (void *)pattern, 
                   hash_cmp)) == NULL) {
                if(attribute->binary == 0x00) {
                    warning(0, "WML compiler: can't compile attribute %s%s%s%s", 
                               octstr_get_cstr(attribute->attribute), 
                   (attr->children != NULL ? "=\"": ""), 
                   (attr->children != NULL ? octstr_get_cstr(pattern) : ""), 
                   (attr->children != NULL ? "\"": ""));
                wbxml_hex = WBXML_LITERAL;
                output_st_char(wbxml_hex, wbxml);
                output_st_char(string_table_add(octstr_duplicate(name), wbxml), wbxml);
        } else {
            wbxml_hex = attribute->binary;
            output_st_char(wbxml_hex, wbxml);
        }
    } else if (hit->binary) {
        wbxml_hex = hit->binary;
        coded_length = octstr_len(hit->item);
        output_st_char(wbxml_hex, wbxml);
    } else
        status = -1;
    } else {
    /* The attribute was not on the code page, it has to be encoded as a 
       string. */
    wbxml_hex = WBXML_LITERAL;
    output_st_char(wbxml_hex, wbxml);
    octstr_append_uintvar((*wbxml)->wbxml_string,string_table_add(octstr_duplicate(name), wbxml));
    warning(0, "WML compiler: Unknown attribute in WML source: <%s>", 
        octstr_get_cstr(name));
    }

    if (status >= 0) {
    var_esc_t default_esc;

    default_esc = (octstr_str_compare (name, "href") == 0) ? ESC : NOESC;

    /* The rest of the attribute is coded as a inline string. */
    if (pattern != NULL && 
        coded_length < (int) octstr_len(pattern)) {
        if (coded_length == 0)
        p = create_octstr_from_node((char *)attr->children); 
        else
        p = octstr_copy(pattern, coded_length, 
                octstr_len(pattern) - coded_length); 

        if (check_if_url(wbxml_hex))
        status = parse_attr_value(p, wml_URL_values_list,
                      wbxml, attr->doc->charset, default_esc);
        else
        status = parse_attr_value(p, wml_attr_values_list,
                      wbxml, attr->doc->charset, default_esc);
        if (status != 0)
        error(0, 
              "WML compiler: could not output attribute "
              "value as a string.");
        octstr_destroy(p);
    }
    }

    /* Memory cleanup. */
    octstr_destroy(name);

    if (pattern != NULL)
    octstr_destroy(pattern);

    return status;
}

parse_cdata()

static int parse_cdata ( xmlNodePtr  node, wml_binary_t **  wbxml  )

static

Definition at line 986 of file wml_compiler.c.

References create_octstr_from_node, NOESC, octstr_destroy(), and parse_st_octet_string().

Referenced by parse_node().

{
    int ret = 0;
    Octstr *temp;

    temp = create_octstr_from_node((char *)node);

    parse_st_octet_string(temp, 1, NOESC, wbxml);
    
    /* Memory cleanup. */
    octstr_destroy(temp);

    return ret;
}

parse_document()

static int parse_document ( xmlDocPtr  document, Octstr *  charset, wml_binary_t **  wbxml, Octstr *  version  )

static

Definition at line 571 of file wml_compiler.c.

References charset, debug(), error(), info(), NUMBER_OF_WBXML_VERSION, NUMBER_OF_WML_EXTERNALID, octstr_compare(), octstr_create, octstr_destroy(), octstr_get_cstr, octstr_imm(), parse_charset(), parse_node(), string_table_build(), wbxml_version_t::value, warning(), wbxml_version, and xml_error().

Referenced by wml_compile().

{
    xmlNodePtr node;
    Octstr *externalID = NULL;
    long i;

    if (document == NULL) {
        error(0, "WML compiler: XML parsing failed, no parsed document.");
        error(0, "Most probably an error in the WML source.");
        return -1;
    }

    /* Return WBXML version dependent on device given Encoding-Version */
    if (version == NULL) {
        (*wbxml)->wbxml_version = 0x01; /* WBXML Version number 1.1 */
        info(0, "WBXML: No wbxml version given, assuming 1.1");
    } else {
        for (i = 0; i < NUMBER_OF_WBXML_VERSION; i++) {
            if (octstr_compare(version, octstr_imm(wbxml_version[i].string)) == 0) {
                (*wbxml)->wbxml_version = wbxml_version[i].value;
                debug("parse_document",0,"WBXML: Encoding with wbxml version <%s>",
                      octstr_get_cstr(version));
                break;
            }
        }
        if (i == NUMBER_OF_WBXML_VERSION) {
            (*wbxml)->wbxml_version = 0x01; /* WBXML Version number 1.1 */
            warning(0, "WBXML: Unknown wbxml version, assuming 1.1 (<%s> is unknown)",
                    octstr_get_cstr(version));
        }
    }

    /* Return WML Version dependent on xml ExternalID string */
    if ((document->intSubset != NULL) && (document->intSubset->ExternalID != NULL))    
        externalID = octstr_create((char *)document->intSubset->ExternalID);
    if (externalID == NULL) {
        (*wbxml)->wml_public_id = 0x04; /* WML 1.1 Public ID */
        warning(0, "WBXML: WML without ExternalID, assuming 1.1");
    } else {
        for (i = 0; i < NUMBER_OF_WML_EXTERNALID; i++) {
            if (octstr_compare(externalID, octstr_imm(public_ids_strings[i].string)) == 0) {
                (*wbxml)->wml_public_id = public_ids_strings[i].value;
                debug("parse_document",0,"WBXML: WML with ExternalID <%s>",
                      octstr_get_cstr(externalID));
                break;
            }
        }
        if (i == NUMBER_OF_WML_EXTERNALID) {
            (*wbxml)->wml_public_id = 0x04; /* WML 1.1 Public ID */
            warning(0, "WBXML: WML with unknown ExternalID, assuming 1.1 "
                    "(<%s> is unknown)",
                    octstr_get_cstr(externalID));
        }
    }
    octstr_destroy(externalID);
    
    (*wbxml)->string_table_length = 0x00; /* String table length=0 */

    /*
     * Make sure we set the charset encoding right. If none is given
     * then set UTF-8 as default.
     */
    (*wbxml)->character_set = charset ? 
        parse_charset(charset) : parse_charset(octstr_imm("UTF-8"));

    node = xmlDocGetRootElement(document);
    
    if (node == NULL) {
        error(0, "WML compiler: XML parsing failed, no document root element.");
        error(0, "Most probably an error in the WML source.");
        xml_error();
        return -1;
    }
    
    string_table_build(node, wbxml);

    return parse_node(node, wbxml);
}

parse_element()

static int parse_element ( xmlNodePtr  node, wml_binary_t **  wbxml  )

static

Definition at line 660 of file wml_compiler.c.

References check_do_elements(), check_variable_name(), dict_get(), element_check_content(), error(), FAILED, name, octstr_append_uintvar(), octstr_create, octstr_destroy(), octstr_duplicate, octstr_get_cstr, output_st_char(), parse_attribute(), parse_st_end(), string_table_add(), warning(), WBXML_CONTENT_BIT, WBXML_LITERAL, and wml_elements_dict.

Referenced by parse_node().

{
    int add_end_tag = 0;
    unsigned char wbxml_hex = 0, status_bits;
    xmlAttrPtr attribute;
    Octstr *name;
    wml_hash_t *element;

    name = octstr_create((char *)node->name);

    /* Check, if the tag can be found from the code page. */
    if ((element = dict_get(wml_elements_dict, name)) != NULL) {
    wbxml_hex = element->binary;
    /* A conformance patch: no do-elements of same name in a card or
       template. An extremely ugly patch. --tuo */
    if (wbxml_hex == 0x27 || /* Card */
        wbxml_hex == 0x3B)   /* Template */
        if (check_do_elements(node) == -1) {
        add_end_tag = -1;
        error(0, "WML compiler: Two or more do elements with same"
                 " name in a card or template element.");
        }
    /* A conformance patch: if variable in setvar has a bad name, it's
       ignored. */
    if (wbxml_hex == 0x3E) /* Setvar */
        if (check_variable_name(node) == FAILED) {
        octstr_destroy(name);
        return add_end_tag;
        }
    if ((status_bits = element_check_content(node)) > 0) {
        wbxml_hex = wbxml_hex | status_bits;
        /* If this node has children, the end tag must be added after 
           them. */
        if ((status_bits & WBXML_CONTENT_BIT) == WBXML_CONTENT_BIT)
        add_end_tag = 1;
    }
    
    output_st_char(wbxml_hex, wbxml);
    } else {    
    /* The tag was not on the code page, it has to be encoded as a 
       string. */
    wbxml_hex = WBXML_LITERAL;
    if ((status_bits = element_check_content(node)) > 0) {
        wbxml_hex = wbxml_hex | status_bits;
        /* If this node has children, the end tag must be added after 
           them. */
        if ((status_bits & WBXML_CONTENT_BIT) == WBXML_CONTENT_BIT)
        add_end_tag = 1;
    }
    output_st_char(wbxml_hex, wbxml);
    octstr_append_uintvar((*wbxml)->wbxml_string,string_table_add(octstr_duplicate(name), wbxml));
    warning(0, "WML compiler: Unknown tag in WML source: <%s>", 
        octstr_get_cstr(name));
    }

    /* Encode the attribute list for this node and add end tag after the 
       list. */

    if(node->properties != NULL) {
    attribute = node->properties;
    while (attribute != NULL) {
        parse_attribute(attribute, wbxml);
        attribute = attribute->next;
    }
    parse_st_end(wbxml);
    }

    octstr_destroy(name);
    return add_end_tag;
}

parse_entities()

static void parse_entities ( Octstr *  wml_source )

static

Definition at line 1237 of file wml_compiler.c.

References octstr_create, octstr_delete(), octstr_destroy(), octstr_imm(), octstr_insert(), and octstr_search().

Referenced by wml_compile().

{
    static char entity_nbsp[] = " ";
    static char entity_shy[] = "­";
    static char nbsp[] = " ";
    static char shy[] = "­";
    int pos = 0;
    Octstr *temp;

    if ((pos = octstr_search(wml_source, octstr_imm(entity_nbsp),
                 pos)) >= 0) {
    temp = octstr_create(nbsp);
    while (pos >= 0) {
        octstr_delete(wml_source, pos, strlen(entity_nbsp));
        octstr_insert(wml_source, temp, pos);
        pos = octstr_search(wml_source, 
                octstr_imm(entity_nbsp), pos);
    }
    octstr_destroy(temp);
    }

    pos = 0;
    if ((pos = octstr_search(wml_source, octstr_imm(entity_shy),
                 pos)) >= 0) {
    temp = octstr_create(shy);
    while (pos >= 0) {
        octstr_delete(wml_source, pos, strlen(entity_shy));
        octstr_insert(wml_source, temp, pos);
        pos = octstr_search(wml_source, 
                octstr_imm(entity_shy), pos);
    }
    octstr_destroy(temp);
    }   
}

parse_node()

static int parse_node ( xmlNodePtr  node, wml_binary_t **  wbxml  )

static

Definition at line 502 of file wml_compiler.c.

References error(), parse_cdata(), parse_element(), parse_st_end(), and parse_text().

Referenced by parse_document().

{
    int status = 0;
    
    /* Call for the parser function of the node type. */
    switch (node->type) {
    case XML_ELEMENT_NODE:
    status = parse_element(node, wbxml);
    break;
    case XML_TEXT_NODE:
    status = parse_text(node, wbxml);
    break;
    case XML_CDATA_SECTION_NODE:
    status = parse_cdata(node, wbxml);
    break;
    case XML_COMMENT_NODE:
    case XML_PI_NODE:
    /* Comments and PIs are ignored. */
    break;
    /*
     * XML has also many other node types, these are not needed with 
     * WML. Therefore they are assumed to be an error.
     */
    default:
    error(0, "WML compiler: Unknown XML node in the WML source.");
    return -1;
    break;
    }

    /* 
     * If node is an element with content, it will need an end tag after it's
     * children. The status for it is returned by parse_element.
     */
    switch (status) {
    case 0:

    if (node->children != NULL)
        if (parse_node(node->children, wbxml) == -1)
        return -1;
    break;
    case 1:
    if (node->children != NULL)
        if (parse_node(node->children, wbxml) == -1)
        return -1;
    parse_st_end(wbxml);
    break;

    case -1: /* Something went wrong in the parsing. */
    return -1;
    default:
    error(0,
          "WML compiler: undefined return value in a parse function.");
    return -1;
    break;
    }

    if (node->next != NULL)
    if (parse_node(node->next, wbxml) == -1)
        return -1;

    return 0;
}

parse_st_end()

static void parse_st_end ( wml_binary_t **  wbxml )

static

Definition at line 928 of file wml_compiler.c.

References output_st_char(), and WBXML_END.

Referenced by parse_element(), and parse_node().

{
    output_st_char(WBXML_END, wbxml);
}

parse_st_octet_string()

static int parse_st_octet_string ( Octstr *  ostr, int  cdata, var_esc_t  default_esc, wml_binary_t **  wbxml  )

static

Definition at line 1152 of file wml_compiler.c.

References octstr_copy, octstr_create, octstr_destroy(), octstr_get_char(), octstr_insert(), octstr_len(), octstr_search_char(), octstr_truncate(), output_st_octet_string(), parse_variable(), start, and string_table_apply().

Referenced by parse_attr_value(), parse_cdata(), and parse_text().

{
    Octstr *output, *var, *temp = NULL;
    int var_len;
    int start = 0, pos = 0, len;

    /* No variables? Ok, let's take the easy way... (CDATA never contains 
       variables.) */

    if ((pos = octstr_search_char(ostr, '$', 0)) < 0 || cdata == 1) {
    string_table_apply(ostr, wbxml);
    return 0;
    }

    len = octstr_len(ostr);
    output = octstr_create("");
    var = octstr_create("");

    while (pos < len) {
    if (octstr_get_char(ostr, pos) == '$') {
        if (pos > start) {
        temp = octstr_copy(ostr, start, pos - start);
        octstr_insert(output, temp, octstr_len(output));
        octstr_destroy(temp);
        }
      
        if ((var_len = parse_variable(ostr, pos, default_esc, &var, wbxml)) > 0)    {
        if (octstr_len(var) > 0) {
            if (octstr_get_char(var, 0) == '$')
            /*
             * No, it's not actually variable, but $-character 
             * escaped as "$$". So everything should be packed 
             * into one string. 
             */
            octstr_insert(output, var, octstr_len(output));
            else {
            /*
             * The string is output as a inline string and the 
             * variable as a string table variable reference. 
             */
            if (octstr_len(output) > 0)
                string_table_apply(output, wbxml);
            octstr_truncate(output, 0);
            output_st_octet_string(var, wbxml);
            }
            /* Variable had a syntax error, so it's skipped. */
        }

        pos = pos + var_len;
        start = pos;
        } else
        return -1;
    } else
        pos ++;
    }

    /* Was there still something after the last variable? */
    if (start < pos) {
    if (octstr_len(output) == 0) {
        octstr_destroy(output);
        output = octstr_copy(ostr, start, pos - start);
    } else {
        temp = octstr_copy(ostr, start, pos - start);
        octstr_insert(output, temp, octstr_len(output));
        octstr_destroy(temp);
    }
    }

    if (octstr_len(output) > 0)
    string_table_apply(output, wbxml);
  
    octstr_destroy(output);
    octstr_destroy(var);
  
    return 0;
}

parse_text()

static int parse_text ( xmlNodePtr  node, wml_binary_t **  wbxml  )

static

Definition at line 940 of file wml_compiler.c.

References charset_convert(), check_if_emphasis(), create_octstr_from_node, error(), NOESC, octstr_destroy(), octstr_len(), octstr_shrink_blanks(), octstr_strip_blanks(), and parse_st_octet_string().

Referenced by parse_node().

{
    int ret;
    Octstr *temp;
    char* tmp;

    temp = create_octstr_from_node((char *)node); /* returns string in UTF-8 */

    /*
     * Beware that libxml2 does internal encoding in UTF-8 while parsing.
     * So if our original WML source had a different encoding set, we have
     * to transcode at least here. Only transcode if target encoding differs
     * from libxml2's internal encoding (UTF-8).
     */
    tmp = (char*) xmlGetCharEncodingName(node->doc->charset);
    if (node->doc->charset != XML_CHAR_ENCODING_UTF8 && 
        charset_convert(temp, "UTF-8", 
                        tmp) != 0) {
        error(0, "Failed to convert XML text entity from charset "
                 "<%s> to <%s>, will leave as is.", "UTF-8", 
                 tmp ? tmp : "(undef)");
    }

    octstr_shrink_blanks(temp);
    if (!check_if_emphasis(node->prev) && !check_if_emphasis(node->next))
    octstr_strip_blanks(temp);

    if (octstr_len(temp) == 0)
        ret = 0;
    else 
        ret = parse_st_octet_string(temp, 0, NOESC, wbxml);

    /* Memory cleanup. */
    octstr_destroy(temp);

    return ret;
}

parse_variable()

static int parse_variable ( Octstr *  text, int  start, var_esc_t  default_esc, Octstr **  output, wml_binary_t **  wbxml  )

static

Definition at line 1014 of file wml_compiler.c.

References check_variable_syntax(), FAILED, get_variable(), octstr_append_char(), octstr_destroy(), octstr_get_char(), octstr_len(), octstr_truncate(), output_variable(), start, and text.

Referenced by parse_st_octet_string().

{
    var_esc_t esc;
    int ret;
    Octstr *variable;

    variable = get_variable(text, start + 1);
    octstr_truncate(*output, 0);

    if (variable == NULL)
    return 0;

    if (octstr_get_char(variable, 0) == '$') {
    octstr_append_char(*output, '$');
    octstr_destroy(variable);
    ret = 2;
    } else {
    if (octstr_get_char(text, start + 1) == '(')
        ret = octstr_len(variable) + 3;
    else
        ret = octstr_len(variable) + 1;

    if ((esc = check_variable_syntax(variable, default_esc)) != FAILED)
        output_variable(variable, output, esc, wbxml);
    else
        octstr_destroy(variable);
    }

    return ret;
}

string_table_add()

static unsigned long string_table_add ( Octstr *  ostr, wml_binary_t **  wbxml  )

static

Definition at line 1972 of file wml_compiler.c.

References gwlist_append(), gwlist_get(), gwlist_len(), octstr_compare(), octstr_destroy(), octstr_len(), string_table_t::offset, string_table_t::string, and string_table_create().

Referenced by output_variable(), parse_attribute(), parse_element(), and string_table_add_many().

{
    string_table_t *item = NULL;
    unsigned long i, offset = 0;

    /* Check whether the string is unique. */
    for (i = 0; i < (unsigned long)gwlist_len((*wbxml)->string_table); i++) {
    item = gwlist_get((*wbxml)->string_table, i);
    if (octstr_compare(item->string, ostr) == 0) {
        octstr_destroy(ostr);
        return item->offset;
    }
    }

    /* Create a new list item for the string table. */
    offset = (*wbxml)->string_table_length;

    item = string_table_create(offset, ostr);

    (*wbxml)->string_table_length = 
    (*wbxml)->string_table_length + octstr_len(ostr) + 1;
    gwlist_append((*wbxml)->string_table, item);

    return offset;
}

string_table_add_many()

static List * string_table_add_many ( List *  sorted, wml_binary_t **  wbxml  )

static

Definition at line 1905 of file wml_compiler.c.

References string_table_proposal_t::count, gwlist_append(), gwlist_create, gwlist_destroy(), gwlist_extract_first(), gwlist_len(), octstr_duplicate, octstr_len(), string_table_proposal_t::string, string_table_add(), string_table_proposal_destroy(), and WBXML_STRING_TABLE_MIN.

Referenced by string_table_build().

{
    string_table_proposal_t *item = NULL;
    List *list = NULL;

    list = gwlist_create();

    while (gwlist_len(sorted)) {
    item = gwlist_extract_first(sorted);

    if (item->count > 1 && octstr_len(item->string) > 
        WBXML_STRING_TABLE_MIN) {
        string_table_add(octstr_duplicate(item->string), wbxml);
        string_table_proposal_destroy(item);
    } else
        gwlist_append(list, item);
    }

    gwlist_destroy(sorted, NULL);

    return list;
}

string_table_apply()

static void string_table_apply ( Octstr *  ostr, wml_binary_t **  wbxml  )

static

Definition at line 2006 of file wml_compiler.c.

References gwlist_get(), gwlist_len(), octstr_append_char(), octstr_append_uintvar(), octstr_compare(), octstr_create, octstr_delete(), octstr_destroy(), octstr_get_char(), octstr_insert(), octstr_len(), octstr_search(), octstr_truncate(), string_table_t::offset, output_st_char(), output_st_octet_string(), string_table_t::string, WBXML_STR_END, WBXML_STR_I, WBXML_STR_T, and WBXML_STRING_TABLE_MIN.

Referenced by parse_st_octet_string().

{
    Octstr *input = NULL;
    string_table_t *item = NULL;
    long i = 0, word_s = 0, str_e = 0;

    input = octstr_create("");

    for (i = 0; i < gwlist_len((*wbxml)->string_table); i++) {
    item = gwlist_get((*wbxml)->string_table, i);

    if (octstr_len(item->string) > WBXML_STRING_TABLE_MIN)
        /* No use to replace 1 to 3 character substring, the reference 
           will eat the saving up. A variable will be in the string table 
           even though it's only 1 character long. */
        if ((word_s = octstr_search(ostr, item->string, 0)) >= 0) {
        /* Check whether the octet string are equal if they are equal 
           in length. */
        if (octstr_len(ostr) == octstr_len(item->string)) {
            if ((word_s = octstr_compare(ostr, item->string)) == 0)
            {
            octstr_truncate(ostr, 0);
            octstr_append_char(ostr, WBXML_STR_T);
            octstr_append_uintvar(ostr, item->offset);
            str_e = 1;
            }
        }
        /* Check the possible substrings. */
        else if (octstr_len(ostr) > octstr_len(item->string))
        {
            if (word_s + octstr_len(item->string) == octstr_len(ostr))
            str_e = 1;

            octstr_delete(ostr, word_s, octstr_len(item->string));

            octstr_truncate(input, 0);
            /* Substring in the start? No STR_END then. */
            if (word_s > 0)
            octstr_append_char(input, WBXML_STR_END);
                  
            octstr_append_char(input, WBXML_STR_T);
            octstr_append_uintvar(input, item->offset);

            /* Subtring the end? No need to start a new one. */
            if ( word_s < octstr_len(ostr))
            octstr_append_char(input, WBXML_STR_I);

            octstr_insert(ostr, input, word_s);
        }
        /* If te string table entry is longer than the string, it can 
           be skipped. */
        }
    }

    octstr_destroy(input);

    if (octstr_get_char(ostr, 0) != WBXML_STR_T)
    output_st_char(WBXML_STR_I, wbxml);
    if (!str_e)
    octstr_append_char(ostr, WBXML_STR_END);    

    output_st_octet_string(ostr, wbxml);
}

string_table_build()

static void string_table_build ( xmlNodePtr  node, wml_binary_t **  wbxml  )

static

Definition at line 1780 of file wml_compiler.c.

References gwlist_create, gwlist_destroy(), gwlist_extract_first(), gwlist_len(), string_table_add_many(), string_table_collect_strings(), string_table_collect_words(), string_table_proposal_destroy(), and string_table_sort_list().

Referenced by parse_document().

{
    string_table_proposal_t *item = NULL;
    List *list = NULL;

    list = gwlist_create();

    string_table_collect_strings(node, list);

    list = string_table_add_many(string_table_sort_list(list), wbxml);

    list =  string_table_collect_words(list);

    /* Don't add strings if there aren't any. (no NULLs please) */
    if (list) {
    list = string_table_add_many(string_table_sort_list(list), wbxml);
    }

    /* Memory cleanup. */
    while (gwlist_len(list)) {
    item = gwlist_extract_first(list);
    string_table_proposal_destroy(item);
    }

    gwlist_destroy(list, NULL);
}

string_table_collect_strings()

static void string_table_collect_strings ( xmlNodePtr  node, List *  strings  )

static

Definition at line 1815 of file wml_compiler.c.

References create_octstr_from_node, gwlist_append(), octstr_destroy(), octstr_len(), octstr_shrink_blanks(), octstr_strip_blanks(), octstr_strip_nonalphanums(), and WBXML_STRING_TABLE_MIN.

Referenced by string_table_build().

{
    Octstr *string;
    xmlAttrPtr attribute;

    switch (node->type) {
    case XML_TEXT_NODE:
    string = create_octstr_from_node((char *)node);
        
    octstr_shrink_blanks(string);
    octstr_strip_blanks(string);
    if (octstr_len(string) > WBXML_STRING_TABLE_MIN)
        octstr_strip_nonalphanums(string);

    if (octstr_len(string) > WBXML_STRING_TABLE_MIN)
        gwlist_append(strings, string);
    else 
        octstr_destroy(string);
    break;
    case XML_ELEMENT_NODE:
    if(node->properties != NULL) {
        attribute = node->properties;
        while (attribute != NULL) {
        if (attribute->children != NULL)
            string_table_collect_strings(attribute->children, strings);
        attribute = attribute->next;
        }
    }
    break;
    default:
    break;
    }

    if (node->children != NULL)
    string_table_collect_strings(node->children, strings);

    if (node->next != NULL)
    string_table_collect_strings(node->next, strings);
}

string_table_collect_words()

static List * string_table_collect_words ( List *  strings )

static

Definition at line 1935 of file wml_compiler.c.

References gwlist_append(), gwlist_destroy(), gwlist_extract_first(), gwlist_len(), octstr_split_words(), string_table_proposal_t::string, and string_table_proposal_destroy().

Referenced by string_table_build().

{
    Octstr *word = NULL;
    string_table_proposal_t *item = NULL;
    List *list = NULL, *temp_list = NULL;

    while (gwlist_len(strings)) {
    item = gwlist_extract_first(strings);

    if (list == NULL) {
        list = octstr_split_words(item->string);
        string_table_proposal_destroy(item);
    } else {
        temp_list = octstr_split_words(item->string);

        while ((word = gwlist_extract_first(temp_list)) != NULL)
        gwlist_append(list, word);

        gwlist_destroy(temp_list, NULL);
        string_table_proposal_destroy(item);
    }
    }

    gwlist_destroy(strings, NULL);

    return list;
}

string_table_create()

static string_table_t * string_table_create ( int  offset, Octstr *  ostr  )

static

Definition at line 1713 of file wml_compiler.c.

References string_table_t::offset, and string_table_t::string.

Referenced by string_table_add().

{
    string_table_t *node;

    node = gw_malloc(sizeof(string_table_t));
    node->offset = offset;
    node->string = ostr;

    return node;
}

string_table_destroy()

static void string_table_destroy ( string_table_t *  node )

static

Definition at line 1730 of file wml_compiler.c.

References octstr_destroy(), and string_table_t::string.

Referenced by string_table_output().

{
    if (node != NULL) {
    octstr_destroy(node->string);
    gw_free(node);
    }
}

string_table_output()

static void string_table_output ( Octstr *  ostr, wml_binary_t **  wbxml  )

static

Definition at line 2077 of file wml_compiler.c.

References gwlist_extract_first(), octstr_append_char(), octstr_insert(), octstr_len(), string_table_t::string, string_table_destroy(), and WBXML_STR_END.

Referenced by wml_binary_output().

{
    string_table_t *item;

    while ((item = gwlist_extract_first((*wbxml)->string_table)) != NULL) {
    octstr_insert(ostr, item->string, octstr_len(ostr));
    octstr_append_char(ostr, WBXML_STR_END);
    string_table_destroy(item);
    }
}

string_table_proposal_create()

static string_table_proposal_t * string_table_proposal_create ( Octstr *  ostr )

static

Definition at line 1745 of file wml_compiler.c.

References string_table_proposal_t::count, and string_table_proposal_t::string.

Referenced by string_table_sort_list().

{
    string_table_proposal_t *node;

    node = gw_malloc(sizeof(string_table_proposal_t));
    node->count = 1;
    node->string = ostr;

    return node;
}

string_table_proposal_destroy()

static void string_table_proposal_destroy ( string_table_proposal_t *  node )

static

Definition at line 1763 of file wml_compiler.c.

References octstr_destroy(), and string_table_proposal_t::string.

Referenced by string_table_add_many(), string_table_build(), and string_table_collect_words().

{
    if (node != NULL) {
    octstr_destroy(node->string);
    gw_free(node);
    }
}

string_table_sort_list()

static List * string_table_sort_list ( List *  start )

static

Definition at line 1863 of file wml_compiler.c.

References string_table_proposal_t::count, gwlist_append(), gwlist_create, gwlist_destroy(), gwlist_extract_first(), gwlist_get(), gwlist_len(), octstr_compare(), octstr_destroy(), start, string_table_proposal_t::string, and string_table_proposal_create().

Referenced by string_table_build().

{
    int i;
    Octstr *string = NULL;
    string_table_proposal_t *item = NULL;
    List *sorted = NULL;

    sorted = gwlist_create();

    while (gwlist_len(start)) {
    string = gwlist_extract_first(start);
      
    /* Check whether the string is unique. */
    for (i = 0; i < gwlist_len(sorted); i++) {
        item = gwlist_get(sorted, i);
        if (octstr_compare(item->string, string) == 0) {
        octstr_destroy(string);
        string = NULL;
        item->count ++;
        break;
        }
    }
    
    if (string != NULL) {
        item = string_table_proposal_create(string);
        gwlist_append(sorted, item);
    }
    }

    gwlist_destroy(start, NULL);

    return sorted;
}

wml_binary_create()

static wml_binary_t * wml_binary_create ( void  )

static

Definition at line 1279 of file wml_compiler.c.

References wml_binary_t::character_set, gwlist_create, octstr_create, wml_binary_t::string_table, wml_binary_t::string_table_length, wml_binary_t::wbxml_string, wml_binary_t::wbxml_version, and wml_binary_t::wml_public_id.

Referenced by wml_compile().

{
    wml_binary_t *wbxml;

    wbxml = gw_malloc(sizeof(wml_binary_t));
    wbxml->wbxml_version = 0x00;
    wbxml->wml_public_id = 0x00;
    wbxml->character_set = 0x00;
    wbxml->string_table_length = 0x00;
    wbxml->string_table = gwlist_create();
    wbxml->wbxml_string = octstr_create("");

    return wbxml;
}

wml_binary_destroy()

static void wml_binary_destroy ( wml_binary_t *  wbxml )

static

Definition at line 1300 of file wml_compiler.c.

References gwlist_destroy(), octstr_destroy(), wml_binary_t::string_table, and wml_binary_t::wbxml_string.

Referenced by wml_compile().

{
    if (wbxml != NULL) {
    gwlist_destroy(wbxml->string_table, NULL);
    octstr_destroy(wbxml->wbxml_string);
    gw_free(wbxml);
    }
}

wml_binary_output()

static void wml_binary_output ( Octstr *  ostr, wml_binary_t *  wbxml  )

static

Definition at line 1315 of file wml_compiler.c.

References wml_binary_t::character_set, octstr_append_char(), octstr_append_uintvar(), octstr_insert(), octstr_len(), wml_binary_t::string_table_length, string_table_output(), wml_binary_t::wbxml_string, wml_binary_t::wbxml_version, and wml_binary_t::wml_public_id.

Referenced by wml_compile().

{
    octstr_append_char(ostr, wbxml->wbxml_version);
    octstr_append_uintvar(ostr, wbxml->wml_public_id);
    octstr_append_uintvar(ostr, wbxml->character_set);
    octstr_append_uintvar(ostr, wbxml->string_table_length);

    if (wbxml->string_table_length > 0)
    string_table_output(ostr, &wbxml);

    octstr_insert(ostr, wbxml->wbxml_string, octstr_len(ostr));
}

wml_compile()

int wml_compile	(	Octstr *	wml_text,
		Octstr *	charset,
		Octstr **	wml_binary,
		Octstr *	version
	)

Definition at line 360 of file wml_compiler.c.

References charset, debug(), error(), octstr_create, octstr_get_cstr, octstr_len(), octstr_search_char(), octstr_strip_blanks(), parse_document(), parse_entities(), size, wml_binary_create(), wml_binary_destroy(), wml_binary_output(), wml_xml_parser_opt, and xml_error().

Referenced by convert_wml_to_wmlc(), and main().

{
    int ret = 0;
    size_t size;
    xmlDocPtr pDoc = NULL;
    char *wml_c_text;
    wml_binary_t *wbxml = NULL;

    *wml_binary = octstr_create("");
    wbxml = wml_binary_create();

    /* Remove the extra space from start and the end of the WML Document. */
    octstr_strip_blanks(wml_text);

    /* Check the WML-code for \0-characters and for WML entities. Fast patch.
       -- tuo */
    parse_entities(wml_text);

    size = octstr_len(wml_text);
    wml_c_text = octstr_get_cstr(wml_text);
    
    debug("wml_compile",0, "WML: Given charset: %s", octstr_get_cstr(charset));

    if (octstr_search_char(wml_text, '\0', 0) != -1) {    
        error(0, "WML compiler: Compiling error: "
                 "\\0 character found in the middle of the WML source.");
        ret = -1;
    } else {
        /* 
         * An empty octet string for the binary output is created, the wml 
         * source is parsed into a parsing tree and the tree is then compiled 
         * into binary.
         */
         
        pDoc = xmlReadMemory(wml_c_text, size, NULL, octstr_get_cstr(charset), 
                             wml_xml_parser_opt);
        
        if (pDoc != NULL) {
            /* 
             * If we have a set internal encoding, then apply this information 
             * to the XML parsing tree document for later transcoding ability.
             */
            if (charset)
                pDoc->charset = xmlParseCharEncoding(octstr_get_cstr(charset));

            ret = parse_document(pDoc, charset, &wbxml, version);
            wml_binary_output(*wml_binary, wbxml);
        } else {    
            error(0, "WML compiler: Compiling error: "
                     "libxml2 returned a NULL pointer");
            xml_error();
            ret = -1;
        }
    }

    wml_binary_destroy(wbxml);

    if (pDoc) 
        xmlFreeDoc(pDoc);

    return ret;
}

wml_init()

void wml_init

(

int

wml_xml_strict

)

Definition at line 429 of file wml_compiler.c.

References attr_dict_construct(), attribute_destroy(), dict_create(), dict_put(), gwlist_append(), gwlist_create, hash_create(), hash_destroy(), wml_hash_t::item, text, token, wml_attr_values_list, wml_attribute_values, wml_attributes, wml_attributes_dict, wml_elements, wml_elements_dict, wml_table3_len(), wml_table_len(), wml_URL_values, wml_URL_values_list, wml_xml_parser_opt, and wml_xml_strict.

Referenced by main().

{
    int i = 0, len = 0;
    wml_hash_t *temp = NULL;
    
    /* The wml elements into a hash table. */
    len = wml_table_len(wml_elements);
    wml_elements_dict = dict_create(len, hash_destroy);

    for (i = 0; i < len; i++) {
    temp = hash_create(wml_elements[i].text, wml_elements[i].token);
    dict_put(wml_elements_dict, temp->item, temp);
    }

    /* Attributes. */
    len = wml_table3_len(wml_attributes);
    wml_attributes_dict = dict_create(len, attribute_destroy);
    attr_dict_construct(wml_attributes, wml_attributes_dict);

    /* Attribute values. */
    len = wml_table_len(wml_attribute_values);
    wml_attr_values_list = gwlist_create();

    for (i = 0; i < len; i++) {
    temp = hash_create(wml_attribute_values[i].text, 
               wml_attribute_values[i].token);
    gwlist_append(wml_attr_values_list, temp);
    }

    /* URL values. */
    len = wml_table_len(wml_URL_values);
    wml_URL_values_list = gwlist_create();

    for (i = 0; i < len; i++) {
    temp = hash_create(wml_URL_values[i].text, wml_URL_values[i].token);
    gwlist_append(wml_URL_values_list, temp);
    }
    
    /* Strict XML parsing. */
    wml_xml_parser_opt = wml_xml_strict ? 
            (XML_PARSE_NOERROR | XML_PARSE_NONET) :
            (XML_PARSE_RECOVER | XML_PARSE_NOERROR | XML_PARSE_NONET);
}

wml_shutdown()

void wml_shutdown

(

void

)

Definition at line 479 of file wml_compiler.c.

References dict_destroy(), gwlist_destroy(), hash_destroy(), wml_attr_values_list, wml_attributes_dict, wml_elements_dict, and wml_URL_values_list.

Referenced by main().

{
    dict_destroy(wml_elements_dict);
    dict_destroy(wml_attributes_dict);
    gwlist_destroy(wml_attr_values_list, hash_destroy);
    gwlist_destroy(wml_URL_values_list, hash_destroy);
}

wml_table3_len()

static int wml_table3_len ( wml_table3_t *  table )

static

Definition at line 1696 of file wml_compiler.c.

Referenced by wml_init().

{
    int i = 0;

    while (table[i].text1 != NULL)
    i++;

    return i;
}

wml_table_len()

static int wml_table_len ( wml_table_t *  table )

static

Definition at line 1680 of file wml_compiler.c.

References text.

Referenced by wml_init().

{
    int i = 0;

    while (table[i].text != NULL)
    i++;

    return i;
}

xml_error()

static void xml_error ( void  )

static

Definition at line 334 of file wml_compiler.c.

References error(), msg, octstr_destroy(), octstr_format(), octstr_get_cstr, octstr_imm(), and octstr_replace().

Referenced by parse_document(), and wml_compile().

{
    xmlErrorPtr err; 
    Octstr *msg;
    
    /* we should have an error, but be more sensitive */
    if ((err = xmlGetLastError()) == NULL)
        return;
        
    /* replace annoying line feeds */    
    msg = octstr_format("%s", err->message);
    octstr_replace(msg, octstr_imm("\n"), octstr_imm(" "));
    error(0,"XML error: code: %d, level: %d, line: %d, %s",
          err->code, err->level, err->line, octstr_get_cstr(msg));
    octstr_destroy(msg);
}

Variable Documentation

wbxml_version

wbxml_version_t wbxml_version[]

static

Initial value:

= {
    { "1.1", 0x01 },
    { "1.2", 0x02 },
    { "1.3", 0x03 },
    { "1.4", 0x04 },
    { "1.5", 0x05 }
}

Definition at line 117 of file wml_compiler.c.

Referenced by parse_document().

wml_attr_values_list

List* wml_attr_values_list

Definition at line 222 of file wml_compiler.c.

Referenced by parse_attribute(), wml_init(), and wml_shutdown().

wml_attributes_dict

Dict* wml_attributes_dict

Definition at line 220 of file wml_compiler.c.

Referenced by parse_attribute(), wml_init(), and wml_shutdown().

wml_elements_dict

Dict* wml_elements_dict

Definition at line 218 of file wml_compiler.c.

Referenced by parse_element(), wml_init(), and wml_shutdown().

wml_URL_values_list

List* wml_URL_values_list

Definition at line 224 of file wml_compiler.c.

Referenced by parse_attribute(), wml_init(), and wml_shutdown().

wml_xml_parser_opt

int wml_xml_parser_opt

Definition at line 226 of file wml_compiler.c.

Referenced by wml_compile(), and wml_init().