symbian_dll_patch_to_35.txt

symbina上可以使用一个xml解析器,对开发网络应用很有好处

Index: include/iksemel.h
===================================================================
--- include/iksemel.h	(revision 35)
+++ include/iksemel.h	(working copy)
@@ -3,44 +3,57 @@
 ** This code is free software; you can redistribute it and/or
 ** modify it under the terms of GNU Lesser General Public License.
 */
-
 #ifndef IKSEMEL_H
 #define IKSEMEL_H 1
 
 #ifdef __cplusplus
-#include <cstddef>	/* size_t for C++ */
+
+#ifndef __SYMBIAN32__ 
+#include <cstddef>	/* size_t for non-Symbian C++ */
+#endif
+
 extern "C" {
+#ifdef __SYMBIAN32__
+#include <stddef.h>	/* size_t for C++ using Symbian headers */
+#include <e32def.h>     /* for IMPORT_C */
+#endif
+
 #else
+
 #include <stddef.h>	/* size_t for C */
+#ifdef __SYMBIAN32__
+#include <e32def.h>     /* for IMPORT_C */
 #endif
 
+#endif
+
 /*****  object stack  *****/
 
 struct ikstack_struct;
 typedef struct ikstack_struct ikstack;
 
-ikstack *iks_stack_new (size_t meta_chunk, size_t data_chunk);
-void *iks_stack_alloc (ikstack *s, size_t size);
-char *iks_stack_strdup (ikstack *s, const char *src, size_t len);
-char *iks_stack_strcat (ikstack *s, char *old, size_t old_len, const char *src, size_t src_len);
-void iks_stack_stat (ikstack *s, size_t *allocated, size_t *used);
-void iks_stack_delete (ikstack *s);
+IMPORT_C ikstack *iks_stack_new (size_t meta_chunk, size_t data_chunk);
+IMPORT_C void *iks_stack_alloc (ikstack *s, size_t size);
+IMPORT_C char *iks_stack_strdup (ikstack *s, const char *src, size_t len);
+IMPORT_C char *iks_stack_strcat (ikstack *s, char *old, size_t old_len, const char *src, size_t src_len);
+IMPORT_C void iks_stack_stat (ikstack *s, size_t *allocated, size_t *used);
+IMPORT_C void iks_stack_delete (ikstack *s);
 
 /*****  utilities  *****/
 
-void *iks_malloc (size_t size);
-void iks_free (void *ptr);
-void iks_set_mem_funcs (void *(*malloc_func)(size_t size), void (*free_func)(void *ptr));
+IMPORT_C void *iks_malloc (size_t size);
+IMPORT_C void iks_free (void *ptr);
+IMPORT_C void iks_set_mem_funcs (void *(*malloc_func)(size_t size), void (*free_func)(void *ptr));
 
-char *iks_strdup (const char *src);
-char *iks_strcat (char *dest, const char *src);
-int iks_strcmp (const char *a, const char *b);
-int iks_strcasecmp (const char *a, const char *b);
-int iks_strncmp (const char *a, const char *b, size_t n);
-int iks_strncasecmp (const char *a, const char *b, size_t n);
-size_t iks_strlen (const char *src);
-char *iks_escape (ikstack *s, char *src, size_t len);
-char *iks_unescape (ikstack *s, char *src, size_t len);
+IMPORT_C char *iks_strdup (const char *src);
+IMPORT_C char *iks_strcat (char *dest, const char *src);
+IMPORT_C int iks_strcmp (const char *a, const char *b);
+IMPORT_C int iks_strcasecmp (const char *a, const char *b);
+IMPORT_C int iks_strncmp (const char *a, const char *b, size_t n);
+IMPORT_C int iks_strncasecmp (const char *a, const char *b, size_t n);
+IMPORT_C size_t iks_strlen (const char *src);
+IMPORT_C char *iks_escape (ikstack *s, char *src, size_t len);
+IMPORT_C char *iks_unescape (ikstack *s, char *src, size_t len);
 
 /*****  dom tree  *****/
 
@@ -54,37 +67,37 @@
 struct iks_struct;
 typedef struct iks_struct iks;
 
-iks *iks_new (const char *name);
-iks *iks_new_within (const char *name, ikstack *s);
-iks *iks_insert (iks *x, const char *name);
-iks *iks_insert_cdata (iks *x, const char *data, size_t len);
-iks *iks_insert_attrib (iks *x, const char *name, const char *value);
-iks *iks_insert_node (iks *x, iks *y);
-void iks_hide (iks *x);
-void iks_delete (iks *x);
-iks *iks_next (iks *x);
-iks *iks_next_tag (iks *x);
-iks *iks_prev (iks *x);
-iks *iks_prev_tag (iks *x);
-iks *iks_parent (iks *x);
-iks *iks_root (iks *x);
-iks *iks_child (iks *x);
-iks *iks_first_tag (iks *x);
-iks *iks_attrib (iks *x);
-iks *iks_find (iks *x, const char *name);
-char *iks_find_cdata (iks *x, const char *name);
-char *iks_find_attrib (iks *x, const char *name);
-iks *iks_find_with_attrib (iks *x, const char *tagname, const char *attrname, const char *value);
-ikstack *iks_stack (iks *x);
-enum ikstype iks_type (iks *x);
-char *iks_name (iks *x);
-char *iks_cdata (iks *x);
-size_t iks_cdata_size (iks *x);
-int iks_has_children (iks *x);
-int iks_has_attribs (iks *x);
-char *iks_string (ikstack *s, iks *x);
-iks *iks_copy (iks *x);
-iks *iks_copy_within (iks *x, ikstack *s);
+IMPORT_C iks *iks_new (const char *name);
+IMPORT_C iks *iks_new_within (const char *name, ikstack *s);
+IMPORT_C iks *iks_insert (iks *x, const char *name);
+IMPORT_C iks *iks_insert_cdata (iks *x, const char *data, size_t len);
+IMPORT_C iks *iks_insert_attrib (iks *x, const char *name, const char *value);
+IMPORT_C iks *iks_insert_node (iks *x, iks *y);
+IMPORT_C void iks_hide (iks *x);
+IMPORT_C void iks_delete (iks *x);
+IMPORT_C iks *iks_next (iks *x);
+IMPORT_C iks *iks_next_tag (iks *x);
+IMPORT_C iks *iks_prev (iks *x);
+IMPORT_C iks *iks_prev_tag (iks *x);
+IMPORT_C iks *iks_parent (iks *x);
+IMPORT_C iks *iks_root (iks *x);
+IMPORT_C iks *iks_child (iks *x);
+IMPORT_C iks *iks_first_tag (iks *x);
+IMPORT_C iks *iks_attrib (iks *x);
+IMPORT_C iks *iks_find (iks *x, const char *name);
+IMPORT_C char *iks_find_cdata (iks *x, const char *name);
+IMPORT_C char *iks_find_attrib (iks *x, const char *name);
+IMPORT_C iks *iks_find_with_attrib (iks *x, const char *tagname, const char *attrname, const char *value);
+IMPORT_C ikstack *iks_stack (iks *x);
+IMPORT_C enum ikstype iks_type (iks *x);
+IMPORT_C char *iks_name (iks *x);
+IMPORT_C char *iks_cdata (iks *x);
+IMPORT_C size_t iks_cdata_size (iks *x);
+IMPORT_C int iks_has_children (iks *x);
+IMPORT_C int iks_has_attribs (iks *x);
+IMPORT_C char *iks_string (ikstack *s, iks *x);
+IMPORT_C iks *iks_copy (iks *x);
+IMPORT_C iks *iks_copy_within (iks *x, ikstack *s);
 
 /*****  sax parser  *****/
 
@@ -108,15 +121,15 @@
 struct iksparser_struct;
 typedef struct iksparser_struct  iksparser;
 
-iksparser *iks_sax_new (void *user_data, iksTagHook *tagHook, iksCDataHook *cdataHook);
-iksparser *iks_sax_extend (ikstack *s, void *user_data, iksTagHook *tagHook, iksCDataHook *cdataHook, iksDeleteHook *deleteHook);
-ikstack *iks_parser_stack (iksparser *prs);
-void *iks_user_data (iksparser *prs);
-unsigned long iks_nr_bytes (iksparser *prs);
-unsigned long iks_nr_lines (iksparser *prs);
-int iks_parse (iksparser *prs, const char *data, size_t len, int finish);
-void iks_parser_reset (iksparser *prs);
-void iks_parser_delete (iksparser *prs);
+IMPORT_C iksparser *iks_sax_new (void *user_data, iksTagHook *tagHook, iksCDataHook *cdataHook);
+IMPORT_C iksparser *iks_sax_extend (ikstack *s, void *user_data, iksTagHook *tagHook, iksCDataHook *cdataHook, iksDeleteHook *deleteHook);
+IMPORT_C ikstack *iks_parser_stack (iksparser *prs);
+IMPORT_C void *iks_user_data (iksparser *prs);
+IMPORT_C unsigned long iks_nr_bytes (iksparser *prs);
+IMPORT_C unsigned long iks_nr_lines (iksparser *prs);
+IMPORT_C int iks_parse (iksparser *prs, const char *data, size_t len, int finish);
+IMPORT_C void iks_parser_reset (iksparser *prs);
+IMPORT_C void iks_parser_delete (iksparser *prs);
 
 /*****  dom parser  *****/
 
@@ -126,11 +139,11 @@
 	IKS_FILE_RWERR
 };
 
-iksparser *iks_dom_new (iks **iksptr);
-void iks_set_size_hint (iksparser *prs, size_t approx_size);
-iks *iks_tree (const char *xml_str, size_t len, int *err);
-int iks_load (const char *fname, iks **xptr);
-int iks_save (const char *fname, iks *x);
+IMPORT_C iksparser *iks_dom_new (iks **iksptr);
+IMPORT_C void iks_set_size_hint (iksparser *prs, size_t approx_size);
+IMPORT_C iks *iks_tree (const char *xml_str, size_t len, int *err);
+IMPORT_C int iks_load (const char *fname, iks **xptr);
+IMPORT_C int iks_save (const char *fname, iks *x);
 
 /*****  transport layer  *****/
 
@@ -202,25 +215,25 @@
 typedef int (iksStreamHook)(void *user_data, int type, iks *node);
 typedef void (iksLogHook)(void *user_data, const char *data, size_t size, int is_incoming);
 
-iksparser *iks_stream_new (char *name_space, void *user_data, iksStreamHook *streamHook);
-void *iks_stream_user_data (iksparser *prs);
-void iks_set_log_hook (iksparser *prs, iksLogHook *logHook);
-int iks_connect_tcp (iksparser *prs, const char *server, int port);
-int iks_connect_fd (iksparser *prs, int fd);
-int iks_connect_via (iksparser *prs, const char *server, int port, const char *server_name);
-int iks_connect_with (iksparser *prs, const char *server, int port, const char *server_name, ikstransport *trans);
-int iks_connect_async (iksparser *prs, const char *server, int port, void *notify_data, iksAsyncNotify *notify_func);
-int iks_connect_async_with (iksparser *prs, const char *server, int port, const char *server_name, ikstransport *trans, void *notify_data, iksAsyncNotify *notify_func);
-int iks_fd (iksparser *prs);
-int iks_recv (iksparser *prs, int timeout);
-int iks_send_header (iksparser *prs, const char *to);
-int iks_send (iksparser *prs, iks *x);
-int iks_send_raw (iksparser *prs, const char *xmlstr);
-void iks_disconnect (iksparser *prs);
-int iks_has_tls (void);
-int iks_is_secure (iksparser *prs);
-int iks_start_tls (iksparser *prs);
-int iks_start_sasl (iksparser *prs, enum ikssasltype type, char *username, char *pass);
+IMPORT_C iksparser *iks_stream_new (char *name_space, void *user_data, iksStreamHook *streamHook);
+IMPORT_C void *iks_stream_user_data (iksparser *prs);
+IMPORT_C void iks_set_log_hook (iksparser *prs, iksLogHook *logHook);
+IMPORT_C int iks_connect_tcp (iksparser *prs, const char *server, int port);
+IMPORT_C int iks_connect_fd (iksparser *prs, int fd);
+IMPORT_C int iks_connect_via (iksparser *prs, const char *server, int port, const char *server_name);
+IMPORT_C int iks_connect_with (iksparser *prs, const char *server, int port, const char *server_name, ikstransport *trans);
+IMPORT_C int iks_connect_async (iksparser *prs, const char *server, int port, void *notify_data, iksAsyncNotify *notify_func);
+IMPORT_C int iks_connect_async_with (iksparser *prs, const char *server, int port, const char *server_name, ikstransport *trans, void *notify_data, iksAsyncNotify *notify_func);
+IMPORT_C int iks_fd (iksparser *prs);
+IMPORT_C int iks_recv (iksparser *prs, int timeout);
+IMPORT_C int iks_send_header (iksparser *prs, const char *to);
+IMPORT_C int iks_send (iksparser *prs, iks *x);
+IMPORT_C int iks_send_raw (iksparser *prs, const char *xmlstr);
+IMPORT_C void iks_disconnect (iksparser *prs);
+IMPORT_C int iks_has_tls (void);
+IMPORT_C int iks_is_secure (iksparser *prs);
+IMPORT_C int iks_start_tls (iksparser *prs);
+IMPORT_C int iks_start_sasl (iksparser *prs, enum ikssasltype type, char *username, char *pass);
 
 /*****  jabber  *****/
 
@@ -278,8 +291,8 @@
 	char *full;
 } iksid;
 
-iksid *iks_id_new (ikstack *s, const char *jid);
-int iks_id_cmp (iksid *a, iksid *b, int parts);
+IMPORT_C iksid *iks_id_new (ikstack *s, const char *jid);
+IMPORT_C int iks_id_cmp (iksid *a, iksid *b, int parts);
 
 enum ikspaktype {
 	IKS_PAK_NONE = 0,
@@ -332,14 +345,14 @@
 
 ikspak *iks_packet (iks *x);
 
-iks *iks_make_auth (iksid *id, const char *pass, const char *sid);
-iks *iks_make_msg (enum iksubtype type, const char *to, const char *body);
-iks *iks_make_s10n (enum iksubtype type, const char *to, const char *msg);
-iks *iks_make_pres (enum ikshowtype show, const char *status);
-iks *iks_make_iq (enum iksubtype type, const char *xmlns);
-iks *iks_make_resource_bind(iksid *id);
-iks *iks_make_session(void);
-int iks_stream_features(iks *x);
+IMPORT_C iks *iks_make_auth (iksid *id, const char *pass, const char *sid);
+IMPORT_C iks *iks_make_msg (enum iksubtype type, const char *to, const char *body);
+IMPORT_C iks *iks_make_s10n (enum iksubtype type, const char *to, const char *msg);
+IMPORT_C iks *iks_make_pres (enum ikshowtype show, const char *status);
+IMPORT_C iks *iks_make_iq (enum iksubtype type, const char *xmlns);
+IMPORT_C iks *iks_make_resource_bind(iksid *id);
+IMPORT_C iks *iks_make_session(void);
+IMPORT_C int iks_stream_features(iks *x);
 
 /*****  jabber packet filter  *****/
 
@@ -363,42 +376,42 @@
 struct iksrule_struct;
 typedef struct iksrule_struct iksrule;
 
-iksfilter *iks_filter_new (void);
-iksrule *iks_filter_add_rule (iksfilter *f, iksFilterHook *filterHook, void *user_data, ...);
-void iks_filter_remove_rule (iksfilter *f, iksrule *rule);
-void iks_filter_remove_hook (iksfilter *f, iksFilterHook *filterHook);
-void iks_filter_packet (iksfilter *f, ikspak *pak);
-void iks_filter_delete (iksfilter *f);
+IMPORT_C iksfilter *iks_filter_new (void);
+IMPORT_C iksrule *iks_filter_add_rule (iksfilter *f, iksFilterHook *filterHook, void *user_data, ...);
+IMPORT_C void iks_filter_remove_rule (iksfilter *f, iksrule *rule);
+IMPORT_C void iks_filter_remove_hook (iksfilter *f, iksFilterHook *filterHook);
+IMPORT_C void iks_filter_packet (iksfilter *f, ikspak *pak);
+IMPORT_C void iks_filter_delete (iksfilter *f);
 
 /*****  sha1  *****/
 
 struct iksha_struct;
 typedef struct iksha_struct iksha;
 
-iksha *iks_sha_new (void);
-void iks_sha_reset (iksha *sha);
-void iks_sha_hash (iksha *sha, const unsigned char *data, size_t len, int finish);
-void iks_sha_print (iksha *sha, char *hash);
-void iks_sha_delete (iksha *sha);
-void iks_sha (const char *data, char *hash);
+IMPORT_C iksha *iks_sha_new (void);
+IMPORT_C void iks_sha_reset (iksha *sha);
+IMPORT_C void iks_sha_hash (iksha *sha, const unsigned char *data, size_t len, int finish);
+IMPORT_C void iks_sha_print (iksha *sha, char *hash);
+IMPORT_C void iks_sha_delete (iksha *sha);
+IMPORT_C void iks_sha (const char *data, char *hash);
 
 /*****  md5  *****/
 
 struct ikmd5_struct;
 typedef struct iksmd5_struct iksmd5;
 
-iksmd5 *iks_md5_new(void);
-void iks_md5_reset(iksmd5 *md5);
-void iks_md5_hash(iksmd5 *md5, const unsigned char *data, size_t slen, int finish);
-void iks_md5_delete(iksmd5 *md5);
-void iks_md5_print(iksmd5 *md5, char *buf);
-void iks_md5_digest(iksmd5 *md5, unsigned char *digest);
-void iks_md5(const char *data, char *buf);
+IMPORT_C iksmd5 *iks_md5_new(void);
+IMPORT_C void iks_md5_reset(iksmd5 *md5);
+IMPORT_C void iks_md5_hash(iksmd5 *md5, const unsigned char *data, size_t slen, int finish);
+IMPORT_C void iks_md5_delete(iksmd5 *md5);
+IMPORT_C void iks_md5_print(iksmd5 *md5, char *buf);
+IMPORT_C void iks_md5_digest(iksmd5 *md5, unsigned char *digest);
+IMPORT_C void iks_md5(const char *data, char *buf);
 
 /*****  base64  *****/
 
-char *iks_base64_decode(const char *buf);
-char *iks_base64_encode(const char *buf, int len);
+IMPORT_C char *iks_base64_decode(const char *buf);
+IMPORT_C char *iks_base64_encode(const char *buf, int len);
 
 #ifdef __cplusplus
 }
Index: src/dom.c
===================================================================
--- src/dom.c	(revision 35)
+++ src/dom.c	(working copy)
@@ -61,7 +61,7 @@
 	data->current = NULL;
 }
 
-iksparser *
+EXPORT_C iksparser *
 iks_dom_new (iks **iksptr)
 {
 	ikstack *s;
@@ -77,7 +77,7 @@
 	return iks_sax_extend (s, data, (iksTagHook *) tagHook, (iksCDataHook *) cdataHook, (iksDeleteHook *) deleteHook);
 }
 
-void
+EXPORT_C void
 iks_set_size_hint (iksparser *prs, size_t approx_size)
 {
 	size_t cs;
@@ -88,7 +88,7 @@
 	data->chunk_size = cs;
 }
 
-iks *
+EXPORT_C iks *
 iks_tree (const char *xml_str, size_t len, int *err)
 {
 	iksparser *prs;
@@ -107,7 +107,7 @@
 	return x;
 }
 
-int
+EXPORT_C int
 iks_load (const char *fname, iks **xptr)
 {
 	iksparser *prs;
@@ -155,7 +155,7 @@
 	return ret;
 }
 
-int
+EXPORT_C int
 iks_save (const char *fname, iks *x)
 {
 	FILE *f;
Index: src/utility.c
===================================================================
--- src/utility.c	(revision 35)
+++ src/utility.c	(working copy)
@@ -9,44 +9,69 @@
 
 /*****  malloc wrapper  *****/
 
+/*
+** Symbian which doesn't allow non-const static 
+** data in DLLs, so we use the Symbian specific 
+** Thread Local Storage (TLS) based helper functions in
+** malloc_hook.cpp instead.
+*/
+#ifdef SYMBIAN_TLS_MALLOC_WRAPPERS
+#include "malloc_hook.h"
+#endif
+
+#ifndef SYMBIAN_TLS_MALLOC_WRAPPERS
 static void *(*my_malloc_func)(size_t size);
 static void (*my_free_func)(void *ptr);
+#endif
 
-void *
+EXPORT_C void *
 iks_malloc (size_t size)
 {
+#ifdef SYMBIAN_TLS_MALLOC_WRAPPERS
+    TMallocFunc my_malloc_func = get_malloc_func_using_tls();
+#endif 
 	if (my_malloc_func)
 		return my_malloc_func (size);
 	else
 		return malloc (size);
 }
 
-void
+EXPORT_C void
 iks_free (void *ptr)
 {
+#ifdef SYMBIAN_TLS_MALLOC_WRAPPERS
+    TFreeFunc my_free_func = get_free_func_using_tls();
+#endif
 	if (my_free_func)
 		my_free_func (ptr);
 	else
 		free (ptr);
 }
 
-void
+EXPORT_C void
 iks_set_mem_funcs (void *(*malloc_func)(size_t size), void (*free_func)(void *ptr))
 {
+#ifdef SYMBIAN_TLS_MALLOC_WRAPPERS
+    /* We don't expect this to fail unless the system is under catastrophic
+    ** memory stress, in which case it would be a safe NOP. 
+    */
+    set_mem_funcs_using_tls(malloc_func, free_func);
+#else
 	my_malloc_func = malloc_func;
 	my_free_func = free_func;
+#endif
 }
 
 /*****  NULL-safe Functions  *****/
 
-char *
+EXPORT_C char *
 iks_strdup (const char *src)
 {
 	if (src) return strdup(src);
 	return NULL;
 }
 
-char *
+EXPORT_C char *
 iks_strcat (char *dest, const char *src)
 {
 	size_t len;
@@ -59,35 +84,35 @@
 	return dest + len;
 }
 
-int
+EXPORT_C int
 iks_strcmp (const char *a, const char *b)
 {