summaryrefslogtreecommitdiff
path: root/src/xine-utils
diff options
context:
space:
mode:
Diffstat (limited to 'src/xine-utils')
-rw-r--r--src/xine-utils/monitor.c46
-rw-r--r--src/xine-utils/xmllexer.c165
-rw-r--r--src/xine-utils/xmlparser.c53
3 files changed, 154 insertions, 110 deletions
diff --git a/src/xine-utils/monitor.c b/src/xine-utils/monitor.c
index 59d8a63d2..906cd9278 100644
--- a/src/xine-utils/monitor.c
+++ b/src/xine-utils/monitor.c
@@ -32,41 +32,42 @@
#ifndef NDEBUG
-static long long int profiler_times[MAX_ID] ;
-static long long int profiler_start[MAX_ID] ;
-static long profiler_calls[MAX_ID] ;
-static const char *profiler_label[MAX_ID] ;
+typedef struct {
+ uint64_t p_times;
+ uint64_t p_start;
+ long p_calls;
+ const char *p_label;
+} xine_profiler_t;
+
+static xine_profiler_t profiler[MAX_ID];
void xine_profiler_init () {
- memset(profiler_times, 0, sizeof(profiler_times));
- memset(profiler_start, 0, sizeof(profiler_start));
- memset(profiler_calls, 0, sizeof(profiler_calls));
- memset(profiler_label, 0, sizeof(profiler_label));
+ memset(profiler, 0, sizeof(profiler));
}
int xine_profiler_allocate_slot (const char *label) {
int id;
- for (id = 0; id < MAX_ID && profiler_label[id] != NULL; id++)
+ for (id = 0; id < MAX_ID && profiler[id].p_label != NULL; id++)
;
if (id >= MAX_ID)
return -1;
- profiler_label[id] = label;
+ profiler[id].p_label = label;
return id;
}
#if defined(ARCH_X86_32)
-static __inline__ unsigned long long int rdtsc(void)
+static __inline__ uint64_t rdtsc(void)
{
unsigned long long int x;
__asm__ volatile ("rdtsc\n\t" : "=A" (x));
return x;
}
#elif defined(ARCH_X86_64)
-static __inline__ unsigned long long int rdtsc(void)
+static __inline__ uint64_t rdtsc(void)
{
unsigned long long int a, d;
__asm__ volatile ("rdtsc\n\t" : "=a" (a), "=d" (d));
@@ -78,7 +79,7 @@ void xine_profiler_start_count (int id) {
if ( id >= MAX_ID || id < 0 ) return;
#if defined(ARCH_X86) || defined(ARCH_X86_64)
- profiler_start[id] = rdtsc();
+ profiler[id].p_start = rdtsc();
#endif
}
@@ -86,18 +87,19 @@ void xine_profiler_stop_count (int id) {
if ( id >= MAX_ID || id < 0 ) return;
#if defined(ARCH_X86) || defined(ARCH_X86_64)
- profiler_times[id] += rdtsc() - profiler_start[id];
+ profiler[id].p_times += rdtsc() - profiler[id].p_start;
#endif
- profiler_calls[id]++;
+ profiler[id].p_calls++;
}
void xine_profiler_print_results (void) {
int i;
#if defined(ARCH_X86) || defined(ARCH_X86_64)
- static long long int cpu_speed; /* cpu cyles/usec */
+ static uint64_t cpu_speed; /* cpu cyles/usec */
+
if (!cpu_speed) {
- long long int tsc_start, tsc_end;
+ uint64_t tsc_start, tsc_end;
struct timeval tv_start, tv_end;
tsc_start = rdtsc();
@@ -119,13 +121,13 @@ void xine_profiler_print_results (void) {
"----------------------------------------------------------------------------\n",
"ID", "name", "cpu cycles", "calls", "cycles/call", "usec/call");
for (i=0; i<MAX_ID; i++) {
- if (profiler_label[i]) {
+ if (profiler[i].p_label) {
printf ("%2d: %-24.24s %12lld %9ld",
- i, profiler_label[i], profiler_times[i], profiler_calls[i]);
- if (profiler_calls[i]) {
- printf(" %12lld", profiler_times[i] / profiler_calls[i]);
+ i, profiler[i].p_label, profiler[i].p_times, profiler[i].p_calls);
+ if (profiler[i].p_calls) {
+ printf(" %12lld", profiler[i].p_times / profiler[i].p_calls);
#if defined(ARCH_X86) || defined(ARCH_X86_64)
- printf(" %9lld", profiler_times[i] / (cpu_speed * profiler_calls[i]));
+ printf(" %9lld", profiler[i].p_times / (cpu_speed * profiler[i].p_calls));
#endif
}
printf ("\n");
diff --git a/src/xine-utils/xmllexer.c b/src/xine-utils/xmllexer.c
index a535b7aca..c37510903 100644
--- a/src/xine-utils/xmllexer.c
+++ b/src/xine-utils/xmllexer.c
@@ -48,15 +48,11 @@
/* private constants*/
/* private global variables */
-static const char * lexbuf;
-static int lexbuf_size = 0;
-static int lexbuf_pos = 0;
-static int in_comment = 0;
-static char *lex_malloc = NULL;
+struct lexer * static_lexer;
enum utf { UTF32BE, UTF32LE, UTF16BE, UTF16LE };
-static void lex_convert (const char * buf, int size, enum utf utf)
+static void lex_convert (struct lexer * lexer, const char * buf, int size, enum utf utf)
{
char *utf8 = malloc (size * (utf >= UTF16BE ? 3 : 6) + 1);
char *bp = utf8;
@@ -88,8 +84,16 @@ static void lex_convert (const char * buf, int size, enum utf utf)
}
}
*bp = 0;
- lexbuf_size = bp - utf8;
- lexbuf = lex_malloc = realloc (utf8, lexbuf_size + 1);
+ lexer->lexbuf_size = bp - utf8;
+ lexer->lexbuf = lexer->lex_malloc = realloc (utf8, lexer->lexbuf_size + 1);
+}
+
+/* for ABI compatibility */
+void lexer_init(const char * buf, int size) {
+ if (static_lexer) {
+ lexer_finalize_r(static_lexer);
+ }
+ static_lexer = lexer_init_r(buf, size);
}
static enum {
@@ -98,35 +102,40 @@ static enum {
CDATA,
} lex_mode = NORMAL;
-void lexer_init(const char * buf, int size) {
+struct lexer *lexer_init_r(const char * buf, int size) {
static const char boms[] = { 0xFF, 0xFE, 0, 0, 0xFE, 0xFF },
bom_utf8[] = { 0xEF, 0xBB, 0xBF };
+ struct lexer * lexer = calloc (1, sizeof (*lexer));
- free (lex_malloc);
- lex_malloc = NULL;
-
- lexbuf = buf;
- lexbuf_size = size;
+ lexer->lexbuf = buf;
+ lexer->lexbuf_size = size;
if (size >= 4 && !memcmp (buf, boms + 2, 4))
- lex_convert (buf + 4, size - 4, UTF32BE);
+ lex_convert (lexer, buf + 4, size - 4, UTF32BE);
else if (size >= 4 && !memcmp (buf, boms, 4))
- lex_convert (buf + 4, size - 4, UTF32LE);
+ lex_convert (lexer, buf + 4, size - 4, UTF32LE);
else if (size >= 3 && !memcmp (buf, bom_utf8, 3))
{
- lexbuf += 3;
- lexbuf_size -= 3;
+ lexer->lexbuf += 3;
+ lexer->lexbuf_size -= 3;
}
else if (size >= 2 && !memcmp (buf, boms + 4, 2))
- lex_convert (buf + 2, size - 2, UTF16BE);
+ lex_convert (lexer, buf + 2, size - 2, UTF16BE);
else if (size >= 2 && !memcmp (buf, boms, 2))
- lex_convert (buf + 2, size - 2, UTF16LE);
+ lex_convert (lexer, buf + 2, size - 2, UTF16LE);
- lexbuf_pos = 0;
- lex_mode = NORMAL;
- in_comment = 0;
+ lexer->lexbuf_pos = 0;
+ lexer->lex_mode = NORMAL;
+ lexer->in_comment = 0;
lprintf("buffer length %d\n", size);
+ return lexer;
+}
+
+void lexer_finalize_r(struct lexer * lexer)
+{
+ free(lexer->lex_malloc);
+ free(lexer);
}
typedef enum {
@@ -147,19 +156,25 @@ typedef enum {
STATE_IDENT /* must be last */
} lexer_state_t;
+/* for ABI compatibility */
int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
+ return lexer_get_token_d_r(static_lexer, _tok, _tok_size, fixed);
+}
+
+int lexer_get_token_d_r(struct lexer * lexer, char ** _tok, int * _tok_size, int fixed) {
char *tok = *_tok;
int tok_size = *_tok_size;
+
int tok_pos = 0;
lexer_state_t state = STATE_IDLE;
char c;
if (tok) {
- while ((tok_pos < tok_size) && (lexbuf_pos < lexbuf_size)) {
- c = lexbuf[lexbuf_pos];
- lprintf("c=%c, state=%d, lex_mode=%d, in_comment=%d\n", c, state, lex_mode, in_comment);
+ while ((tok_pos < tok_size) && (lexer->lexbuf_pos < lexer->lexbuf_size)) {
+ c = lexer->lexbuf[lexer->lexbuf_pos];
+ lprintf("c=%c, state=%d, in_comment=%d\n", c, state, lexer->in_comment);
- switch (lex_mode) {
+ switch (lexer->lex_mode) {
case NORMAL:
switch (state) {
/* init state */
@@ -192,7 +207,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
break;
case '/':
- if (!in_comment)
+ if (!lexer->in_comment)
state = STATE_T_M_STOP_2;
tok[tok_pos] = c;
tok_pos++;
@@ -219,7 +234,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
break;
case '?':
- if (!in_comment)
+ if (!lexer->in_comment)
state = STATE_T_TI_STOP;
tok[tok_pos] = c;
tok_pos++;
@@ -231,14 +246,14 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
tok_pos++;
break;
}
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
break;
/* end of line */
case STATE_EOL:
if (c == '\n' || (c == '\r')) {
tok[tok_pos] = c;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
tok_pos++;
} else {
tok[tok_pos] = '\0';
@@ -250,7 +265,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
case STATE_SEPAR:
if (c == ' ' || (c == '\t')) {
tok[tok_pos] = c;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
tok_pos++;
} else {
tok[tok_pos] = '\0';
@@ -263,20 +278,20 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
switch (c) {
case '/':
tok[tok_pos] = c;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
tok_pos++; /* FIXME */
tok[tok_pos] = '\0';
return T_M_START_2;
break;
case '!':
tok[tok_pos] = c;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
tok_pos++;
state = STATE_T_COMMENT;
break;
case '?':
tok[tok_pos] = c;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
tok_pos++; /* FIXME */
tok[tok_pos] = '\0';
return T_TI_START;
@@ -290,8 +305,8 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
/* T_M_STOP_1 */
case STATE_T_M_STOP_1:
tok[tok_pos] = '\0';
- if (!in_comment)
- lex_mode = DATA;
+ if (!lexer->in_comment)
+ lexer->lex_mode = DATA;
return T_M_STOP_1;
break;
@@ -299,11 +314,11 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
case STATE_T_M_STOP_2:
if (c == '>') {
tok[tok_pos] = c;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
tok_pos++; /* FIXME */
tok[tok_pos] = '\0';
- if (!in_comment)
- lex_mode = DATA;
+ if (!lexer->in_comment)
+ lexer->lex_mode = DATA;
return T_M_STOP_2;
} else {
tok[tok_pos] = '\0';
@@ -320,7 +335,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
/* T_STRING */
case STATE_T_STRING_DOUBLE:
tok[tok_pos] = c;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
if (c == '\"') { /* " */
tok[tok_pos] = '\0'; /* FIXME */
return T_STRING;
@@ -332,33 +347,33 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
case STATE_T_COMMENT:
switch (c) {
case '-':
- lexbuf_pos++;
- if (lexbuf[lexbuf_pos] == '-')
+ lexer->lexbuf_pos++;
+ if (lexer->lexbuf[lexer->lexbuf_pos] == '-')
{
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
tok[tok_pos++] = '-'; /* FIXME */
tok[tok_pos++] = '-';
tok[tok_pos] = '\0';
- in_comment = 1;
+ lexer->in_comment = 1;
return T_C_START;
}
break;
case 'D':
- lexbuf_pos++;
- if (strncmp(lexbuf + lexbuf_pos, "OCTYPE", 6) == 0) {
+ lexer->lexbuf_pos++;
+ if (strncmp(lexer->lexbuf + lexer->lexbuf_pos, "OCTYPE", 6) == 0) {
strncpy(tok + tok_pos, "DOCTYPE", 7); /* FIXME */
- lexbuf_pos += 6;
+ lexer->lexbuf_pos += 6;
return T_DOCTYPE_START;
} else {
return T_ERROR;
}
break;
case '[':
- lexbuf_pos++;
- if (strncmp(lexbuf + lexbuf_pos, "CDATA[", 6) == 0) {
+ lexer->lexbuf_pos++;
+ if (strncmp(lexer->lexbuf + lexer->lexbuf_pos, "CDATA[", 6) == 0) {
strncpy (tok + tok_pos, "[CDATA[", 7); /* FIXME */
- lexbuf_pos += 6;
- lex_mode = CDATA;
+ lexer->lexbuf_pos += 6;
+ lexer->lex_mode = CDATA;
return T_CDATA_START;
} else{
return T_ERROR;
@@ -374,11 +389,11 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
case STATE_T_TI_STOP:
if (c == '>') {
tok[tok_pos] = c;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
tok_pos++; /* FIXME */
tok[tok_pos] = '\0';
- if (!in_comment)
- lex_mode = DATA;
+ if (!lexer->in_comment)
+ lexer->lex_mode = DATA;
return T_TI_STOP;
} else {
tok[tok_pos] = '\0';
@@ -392,13 +407,13 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
case '-':
tok[tok_pos] = c;
tok_pos++;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
state = STATE_T_C_STOP;
break;
default:
tok[tok_pos] = c;
tok_pos++;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
state = STATE_IDENT;
}
break;
@@ -409,21 +424,21 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
case '>':
tok[tok_pos] = c;
tok_pos++;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
tok[tok_pos] = '\0'; /* FIX ME */
if (strlen(tok) != 3) {
tok[tok_pos - 3] = '\0';
- lexbuf_pos -= 3;
+ lexer->lexbuf_pos -= 3;
return T_IDENT;
} else {
- in_comment = 0;
+ lexer->in_comment = 0;
return T_C_STOP;
}
break;
default:
tok[tok_pos] = c;
tok_pos++;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
state = STATE_IDENT;
}
break;
@@ -431,7 +446,7 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
/* T_STRING (single quotes) */
case STATE_T_STRING_SINGLE:
tok[tok_pos] = c;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
if (c == '\'') { /* " */
tok[tok_pos] = '\0'; /* FIXME */
return T_STRING;
@@ -458,19 +473,19 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
case '?':
tok[tok_pos] = c;
tok_pos++;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
state = STATE_T_TI_STOP;
break;
case '-':
tok[tok_pos] = c;
tok_pos++;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
state = STATE_T_DASHDASH;
break;
default:
tok[tok_pos] = c;
tok_pos++;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
}
break;
default:
@@ -484,12 +499,12 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
{
case '<':
tok[tok_pos] = '\0';
- lex_mode = NORMAL;
+ lexer->lex_mode = NORMAL;
return T_DATA;
default:
tok[tok_pos] = c;
tok_pos++;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
}
break;
@@ -497,26 +512,26 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
switch (c)
{
case ']':
- if (strncmp(lexbuf + lexbuf_pos, "]]>", 3) == 0) {
- lexbuf_pos += 3;
- lex_mode = DATA;
+ if (strncmp(lexer->lexbuf + lexer->lexbuf_pos, "]]>", 3) == 0) {
+ lexer->lexbuf_pos += 3;
+ lexer->lex_mode = DATA;
return T_CDATA_STOP;
} else {
tok[tok_pos] = c;
tok_pos++;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
}
break;
default:
tok[tok_pos] = c;
tok_pos++;
- lexbuf_pos++;
+ lexer->lexbuf_pos++;
}
break;
}
}
lprintf ("loop done tok_pos = %d, tok_size=%d, lexbuf_pos=%d, lexbuf_size=%d\n",
- tok_pos, tok_size, lexbuf_pos, lexbuf_size);
+ tok_pos, tok_size, lexer->lexbuf_pos, lexer->lexbuf_size);
/* pb */
if (tok_pos >= tok_size) {
@@ -527,12 +542,12 @@ int lexer_get_token_d(char ** _tok, int * _tok_size, int fixed) {
lprintf("token buffer is too small\n");
lprintf("increasing buffer size to %d bytes\n", *_tok_size);
if (*_tok) {
- return lexer_get_token_d (_tok, _tok_size, 0);
+ return lexer_get_token_d_r (lexer, _tok, _tok_size, 0);
} else {
return T_ERROR;
}
} else {
- if (lexbuf_pos >= lexbuf_size) {
+ if (lexer->lexbuf_pos >= lexer->lexbuf_size) {
/* Terminate the current token */
tok[tok_pos] = '\0';
switch (state) {
diff --git a/src/xine-utils/xmlparser.c b/src/xine-utils/xmlparser.c
index c5acf8739..7ae0626eb 100644
--- a/src/xine-utils/xmlparser.c
+++ b/src/xine-utils/xmlparser.c
@@ -55,7 +55,7 @@
#define MAX_RECURSION 10
/* private global variables */
-static int xml_parser_mode;
+xml_parser_t * static_xml_parser;
/* private functions */
@@ -106,10 +106,24 @@ static void free_xml_property(xml_property_t * property) {
free(property);
}
+/* for ABI compatibility */
void xml_parser_init(const char * buf, int size, int mode) {
+ if (static_xml_parser) {
+ xml_parser_finalize_r(static_xml_parser);
+ }
+ static_xml_parser = xml_parser_init_r(buf, size, mode);
+}
- lexer_init(buf, size);
- xml_parser_mode = mode;
+xml_parser_t *xml_parser_init_r(const char * buf, int size, int mode) {
+ xml_parser_t *xml_parser = malloc(sizeof(*xml_parser));
+ xml_parser->lexer = lexer_init_r(buf, size);
+ xml_parser->mode = mode;
+ return xml_parser;
+}
+
+void xml_parser_finalize_r(xml_parser_t *xml_parser) {
+ lexer_finalize_r(xml_parser->lexer);
+ free(xml_parser);
}
static void xml_parser_free_props(xml_property_t *current_property) {
@@ -223,7 +237,9 @@ static xml_node_t *xml_parser_append_text (xml_node_t *node, xml_node_t *subnode
#define Q_STATE(CURRENT,NEW) (STATE_##NEW + state - STATE_##CURRENT)
-static int xml_parser_get_node_internal (char ** token_buffer, int * token_buffer_size,
+
+static int xml_parser_get_node_internal (xml_parser_t *xml_parser,
+ char ** token_buffer, int * token_buffer_size,
char ** pname_buffer, int * pname_buffer_size,
char ** nname_buffer, int * nname_buffer_size,
xml_node_t *current_node, char *root_names[], int rec, int flags)
@@ -245,7 +261,7 @@ static int xml_parser_get_node_internal (char ** token_buffer, int * token_buffe
memset (tok, 0, *token_buffer_size);
- while ((bypass_get_token) || (res = lexer_get_token_d(token_buffer, token_buffer_size, 0)) != T_ERROR) {
+ while ((bypass_get_token) || (res = lexer_get_token_d_r(xml_parser->lexer, token_buffer, token_buffer_size, 0)) != T_ERROR) {
tok = *token_buffer;
bypass_get_token = 0;
lprintf("info: %d - %d : '%s'\n", state, res, tok);
@@ -302,7 +318,7 @@ static int xml_parser_get_node_internal (char ** token_buffer, int * token_buffe
current_property = NULL;
/* save node name */
- if (xml_parser_mode == XML_PARSER_CASE_INSENSITIVE) {
+ if (xml_parser->mode == XML_PARSER_CASE_INSENSITIVE) {
strtoupper(tok);
}
if (state == STATE_Q_NODE) {
@@ -343,7 +359,7 @@ static int xml_parser_get_node_internal (char ** token_buffer, int * token_buffe
subtree->props = properties;
lprintf("info: rec %d new subtree %s\n", rec, node_name);
root_names[rec + 1] = strdup (node_name);
- parse_res = xml_parser_get_node_internal (token_buffer, token_buffer_size,
+ parse_res = xml_parser_get_node_internal (xml_parser, token_buffer, token_buffer_size,
pname_buffer, pname_buffer_size,
nname_buffer, nname_buffer_size,
subtree, root_names, rec + 1, flags);
@@ -390,7 +406,7 @@ static int xml_parser_get_node_internal (char ** token_buffer, int * token_buffe
case (T_IDENT):
/* save property name */
new_prop:
- if (xml_parser_mode == XML_PARSER_CASE_INSENSITIVE) {
+ if (xml_parser->mode == XML_PARSER_CASE_INSENSITIVE) {
strtoupper(tok);
}
/* make sure the buffer for the property name is big enough */
@@ -431,7 +447,7 @@ static int xml_parser_get_node_internal (char ** token_buffer, int * token_buffe
switch (res) {
case (T_IDENT):
/* must be equal to root_name */
- if (xml_parser_mode == XML_PARSER_CASE_INSENSITIVE) {
+ if (xml_parser->mode == XML_PARSER_CASE_INSENSITIVE) {
strtoupper(tok);
}
if (strcmp(tok, root_names[rec]) == 0) {
@@ -643,7 +659,7 @@ static int xml_parser_get_node_internal (char ** token_buffer, int * token_buffe
}
}
-static int xml_parser_get_node (xml_node_t *current_node, int flags)
+static int xml_parser_get_node (xml_parser_t *xml_parser, xml_node_t *current_node, int flags)
{
int res = 0;
int token_buffer_size = TOKEN_SIZE;
@@ -655,7 +671,8 @@ static int xml_parser_get_node (xml_node_t *current_node, int flags)
char *root_names[MAX_RECURSION + 1];
root_names[0] = "";
- res = xml_parser_get_node_internal (&token_buffer, &token_buffer_size,
+ res = xml_parser_get_node_internal (xml_parser,
+ &token_buffer, &token_buffer_size,
&pname_buffer, &pname_buffer_size,
&nname_buffer, &nname_buffer_size,
current_node, root_names, 0, flags);
@@ -667,12 +684,17 @@ static int xml_parser_get_node (xml_node_t *current_node, int flags)
return res;
}
+/* for ABI compatibility */
int xml_parser_build_tree_with_options(xml_node_t **root_node, int flags) {
+ return xml_parser_build_tree_with_options_r(static_xml_parser, root_node, flags);
+}
+
+int xml_parser_build_tree_with_options_r(xml_parser_t *xml_parser, xml_node_t **root_node, int flags) {
xml_node_t *tmp_node, *pri_node, *q_node;
int res;
tmp_node = new_xml_node();
- res = xml_parser_get_node(tmp_node, flags);
+ res = xml_parser_get_node(xml_parser, tmp_node, flags);
/* delete any top-level [CDATA] nodes */;
pri_node = tmp_node->child;
@@ -715,8 +737,13 @@ int xml_parser_build_tree_with_options(xml_node_t **root_node, int flags) {
return res;
}
+/* for ABI compatibility */
int xml_parser_build_tree(xml_node_t **root_node) {
- return xml_parser_build_tree_with_options (root_node, 0);
+ return xml_parser_build_tree_with_options_r (static_xml_parser, root_node, 0);
+}
+
+int xml_parser_build_tree_r(xml_parser_t *xml_parser, xml_node_t **root_node) {
+ return xml_parser_build_tree_with_options_r(xml_parser, root_node, 0);
}
const char *xml_parser_get_property (const xml_node_t *node, const char *name) {
generated by cgit v1.2.3 (git 2.25.1) at 2025-10-17 12:15:02 +0000