IntenseFinance/gnucash
3
0
Fork 0
mirror of https://github.com/Gnucash/gnucash.git synced 2025-02-25 18:55:30 -06:00
Code Issues Packages Projects Releases Wiki Activity

gratuitous rearrangement of parenthesis.

Browse Source 
git-svn-id: svn+ssh://svn.gnucash.org/repo/gnucash/trunk@6429 57a11ea4-9604-0410-9ed3-97b8803252fd
This commit is contained in:
Linas Vepstas 2001-12-30 21:17:47 +00:00
parent 2bba2f9126
commit 77829f9487
1 changed files with 95 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

147
src/backend/file/sixtp.c
View File

@ -1,6 +1,6 @@
/******************************************************************** /********************************************************************
* sixtp.c -- functions for XML parsing * * sixtp.c -- functions for XML parsing *
* Copyright 2001 Gnumatic, Inc. * * Copyright (c) 2001 Gnumatic, Inc. *
* * * *
* This program is free software; you can redistribute it and/or * * This program is free software; you can redistribute it and/or *
* modify it under the terms of the GNU General Public License as * * modify it under the terms of the GNU General Public License as *
@ -39,20 +39,24 @@ static short module = MOD_IO;
/************************************************************************/ /************************************************************************/
gboolean gboolean
is_child_result_from_node_named(sixtp_child_result *cr, const char *tag) { is_child_result_from_node_named(sixtp_child_result *cr, const char *tag)
{
return((cr->type == SIXTP_CHILD_RESULT_NODE) return((cr->type == SIXTP_CHILD_RESULT_NODE)
&& &&
(safe_strcmp(cr->tag, tag) == 0)); (safe_strcmp(cr->tag, tag) == 0));
} }
void void
sixtp_child_free_data(sixtp_child_result *result) { sixtp_child_free_data(sixtp_child_result *result)
{
if(result->data) g_free(result->data); if(result->data) g_free(result->data);
} }
void void
sixtp_child_result_destroy(sixtp_child_result *r) { sixtp_child_result_destroy(sixtp_child_result *r)
if(r->should_cleanup && r->cleanup_handler) { {
if(r->should_cleanup && r->cleanup_handler)
{
r->cleanup_handler(r); r->cleanup_handler(r);
} }
if(r->type == SIXTP_CHILD_RESULT_NODE) g_free(r->tag); if(r->type == SIXTP_CHILD_RESULT_NODE) g_free(r->tag);
@ -60,7 +64,8 @@ sixtp_child_result_destroy(sixtp_child_result *r) {
} }
void void
sixtp_child_result_print(sixtp_child_result *cr, FILE *f) { sixtp_child_result_print(sixtp_child_result *cr, FILE *f)
{
fprintf(f, "((tag %s) (data %p))", fprintf(f, "((tag %s) (data %p))",
cr->tag ? cr->tag : "(null)", cr->tag ? cr->tag : "(null)",
cr->data); cr->data);
@ -70,39 +75,44 @@ sixtp_child_result_print(sixtp_child_result *cr, FILE *f) {
void void
sixtp_set_start(sixtp *parser, sixtp_start_handler start_handler) { sixtp_set_start(sixtp *parser, sixtp_start_handler start_handler)
{
parser->start_handler = start_handler; parser->start_handler = start_handler;
} }
void void
sixtp_set_before_child(sixtp *parser, sixtp_before_child_handler handler) { sixtp_set_before_child(sixtp *parser, sixtp_before_child_handler handler)
{
parser->before_child = handler; parser->before_child = handler;
} }
void void
sixtp_set_after_child(sixtp *parser, sixtp_after_child_handler handler) { sixtp_set_after_child(sixtp *parser, sixtp_after_child_handler handler)
{
parser->after_child = handler; parser->after_child = handler;
} }
void void
sixtp_set_end(sixtp *parser, sixtp_end_handler end_handler) { sixtp_set_end(sixtp *parser, sixtp_end_handler end_handler)
{
parser->end_handler = end_handler; parser->end_handler = end_handler;
} }
void void
sixtp_set_chars(sixtp *parser, sixtp_characters_handler char_handler) { sixtp_set_chars(sixtp *parser, sixtp_characters_handler char_handler)
{
parser->characters_handler = char_handler; parser->characters_handler = char_handler;
} }
void void
sixtp_set_cleanup_result(sixtp *parser, sixtp_set_cleanup_result(sixtp *parser, sixtp_result_handler handler)
sixtp_result_handler handler) { {
parser->cleanup_result = handler; parser->cleanup_result = handler;
} }
void void
sixtp_set_cleanup_chars(sixtp *parser, sixtp_set_cleanup_chars(sixtp *parser, sixtp_result_handler handler)
sixtp_result_handler handler) { {
parser->cleanup_chars = handler; parser->cleanup_chars = handler;
} }
@ -113,19 +123,20 @@ sixtp_set_fail(sixtp *parser,
} }
void void
sixtp_set_result_fail(sixtp *parser, sixtp_set_result_fail(sixtp *parser, sixtp_result_handler handler)
sixtp_result_handler handler) { {
parser->result_fail_handler = handler; parser->result_fail_handler = handler;
} }
void void
sixtp_set_chars_fail(sixtp *parser, sixtp_set_chars_fail(sixtp *parser, sixtp_result_handler handler)
sixtp_result_handler handler) { {
parser->chars_fail_handler = handler; parser->chars_fail_handler = handler;
} }
sixtp * sixtp *
sixtp_new(void) { sixtp_new(void)
{
sixtp *s = g_new0(sixtp, 1); sixtp *s = g_new0(sixtp, 1);
if(s) { if(s) {
@ -225,7 +236,8 @@ static void sixtp_destroy_child(gpointer key, gpointer value,
gpointer user_data); gpointer user_data);
static void static void
sixtp_destroy_node(sixtp *sp, GHashTable *corpses) { sixtp_destroy_node(sixtp *sp, GHashTable *corpses)
{
g_return_if_fail(sp); g_return_if_fail(sp);
g_return_if_fail(corpses); g_return_if_fail(corpses);
g_hash_table_foreach(sp->children, sixtp_destroy_child, corpses); g_hash_table_foreach(sp->children, sixtp_destroy_child, corpses);
@ -234,7 +246,8 @@ sixtp_destroy_node(sixtp *sp, GHashTable *corpses) {
} }
static void static void
sixtp_destroy_child(gpointer key, gpointer value, gpointer user_data) { sixtp_destroy_child(gpointer key, gpointer value, gpointer user_data)
{
GHashTable *corpses = (GHashTable *) user_data; GHashTable *corpses = (GHashTable *) user_data;
sixtp *child = (sixtp *) value; sixtp *child = (sixtp *) value;
gpointer lookup_key; gpointer lookup_key;
@ -244,19 +257,22 @@ sixtp_destroy_child(gpointer key, gpointer value, gpointer user_data) {
key ? (char *) key : "(null)"); key ? (char *) key : "(null)");
g_free(key); g_free(key);
if(!corpses) { if(!corpses)
{
PERR("no corpses in sixtp_destroy_child <%s>\n", PERR("no corpses in sixtp_destroy_child <%s>\n",
key ? (char *) key : "(null)"); key ? (char *) key : "(null)");
return; return;
} }
if(!child) { if(!child)
{
PERR("no child in sixtp_destroy_child <%s>\n", PERR("no child in sixtp_destroy_child <%s>\n",
key ? (char *) key : ""); key ? (char *) key : "");
return; return;
} }
if(!g_hash_table_lookup_extended(corpses, (gconstpointer) child, if(!g_hash_table_lookup_extended(corpses, (gconstpointer) child,
&lookup_key, &lookup_value)) { &lookup_key, &lookup_value))
{
/* haven't killed this one yet. */ /* haven't killed this one yet. */
g_hash_table_insert(corpses, child, (gpointer) 1); g_hash_table_insert(corpses, child, (gpointer) 1);
sixtp_destroy_node(child, corpses); sixtp_destroy_node(child, corpses);
@ -264,7 +280,8 @@ sixtp_destroy_child(gpointer key, gpointer value, gpointer user_data) {
} }
void void
sixtp_destroy(sixtp *sp) { sixtp_destroy(sixtp *sp)
{
GHashTable *corpses; GHashTable *corpses;
g_return_if_fail(sp); g_return_if_fail(sp);
corpses = g_hash_table_new(g_direct_hash, g_direct_equal); corpses = g_hash_table_new(g_direct_hash, g_direct_equal);
@ -276,7 +293,8 @@ sixtp_destroy(sixtp *sp) {
/***********************************************************************/ /***********************************************************************/
gboolean gboolean
sixtp_add_sub_parser(sixtp *parser, const gchar* tag, sixtp *sub_parser) { sixtp_add_sub_parser(sixtp *parser, const gchar* tag, sixtp *sub_parser)
{
g_return_val_if_fail(parser, FALSE); g_return_val_if_fail(parser, FALSE);
g_return_val_if_fail(tag, FALSE); g_return_val_if_fail(tag, FALSE);
g_return_val_if_fail(sub_parser, FALSE); g_return_val_if_fail(sub_parser, FALSE);
@ -352,7 +370,8 @@ sixtp_add_some_sub_parsers(sixtp *tochange, int cleanup, ...)
void void
sixtp_sax_start_handler(void *user_data, sixtp_sax_start_handler(void *user_data,
const xmlChar *name, const xmlChar *name,
const xmlChar **attrs) { const xmlChar **attrs)
{
sixtp_sax_data *pdata = (sixtp_sax_data *) user_data; sixtp_sax_data *pdata = (sixtp_sax_data *) user_data;
sixtp_stack_frame *current_frame = NULL; sixtp_stack_frame *current_frame = NULL;
sixtp *current_parser = NULL; sixtp *current_parser = NULL;
@ -378,7 +397,8 @@ sixtp_sax_start_handler(void *user_data,
(gpointer) &next_parser_tag, (gpointer) &next_parser_tag,
(gpointer) &next_parser); (gpointer) &next_parser);
if(!lookup_success) { if(!lookup_success)
{
/* magic catch all value */ /* magic catch all value */
lookup_success = g_hash_table_lookup_extended( lookup_success = g_hash_table_lookup_extended(
current_parser->children, SIXTP_MAGIC_CATCHER, current_parser->children, SIXTP_MAGIC_CATCHER,
@ -392,11 +412,13 @@ sixtp_sax_start_handler(void *user_data,
} }
} }
if(current_frame->parser->before_child) { if(current_frame->parser->before_child)
{
GSList *parent_data_from_children = NULL; GSList *parent_data_from_children = NULL;
gpointer parent_data_for_children = NULL; gpointer parent_data_for_children = NULL;
if(g_slist_length(pdata->stack) > 1) { if(g_slist_length(pdata->stack) > 1)
{
/* we're not in the top level node */ /* we're not in the top level node */
sixtp_stack_frame *parent_frame = sixtp_stack_frame *parent_frame =
(sixtp_stack_frame *) pdata->stack->next->data; (sixtp_stack_frame *) pdata->stack->next->data;
@ -422,7 +444,8 @@ sixtp_sax_start_handler(void *user_data,
pdata->stack = g_slist_prepend(pdata->stack, (gpointer) new_frame); pdata->stack = g_slist_prepend(pdata->stack, (gpointer) new_frame);
if(next_parser->start_handler) { if(next_parser->start_handler)
{
pdata->parsing_ok = pdata->parsing_ok =
next_parser->start_handler(current_frame->data_from_children, next_parser->start_handler(current_frame->data_from_children,
current_frame->data_for_children, current_frame->data_for_children,
@ -435,7 +458,8 @@ sixtp_sax_start_handler(void *user_data,
} }
void void
sixtp_sax_characters_handler(void *user_data, const xmlChar *text, int len) { sixtp_sax_characters_handler(void *user_data, const xmlChar *text, int len)
{
sixtp_sax_data *pdata = (sixtp_sax_data *) user_data; sixtp_sax_data *pdata = (sixtp_sax_data *) user_data;
sixtp_stack_frame *frame; sixtp_stack_frame *frame;
@ -447,7 +471,8 @@ sixtp_sax_characters_handler(void *user_data, const xmlChar *text, int len) {
} }
frame = (sixtp_stack_frame *) pdata->stack->data; frame = (sixtp_stack_frame *) pdata->stack->data;
if(frame->parser->characters_handler) { if(frame->parser->characters_handler)
{
gpointer result = NULL; gpointer result = NULL;
pdata->parsing_ok = pdata->parsing_ok =
@ -457,8 +482,8 @@ sixtp_sax_characters_handler(void *user_data, const xmlChar *text, int len) {
&result, &result,
text, text,
len); len);
if(pdata->parsing_ok) { if(pdata->parsing_ok && result)
if(result) { {
/* push the result onto the current "child" list. */ /* push the result onto the current "child" list. */
sixtp_child_result *child_data = g_new0(sixtp_child_result, 1); sixtp_child_result *child_data = g_new0(sixtp_child_result, 1);
@ -470,13 +495,13 @@ sixtp_sax_characters_handler(void *user_data, const xmlChar *text, int len) {
child_data->fail_handler = frame->parser->chars_fail_handler; child_data->fail_handler = frame->parser->chars_fail_handler;
frame->data_from_children = g_slist_prepend(frame->data_from_children, frame->data_from_children = g_slist_prepend(frame->data_from_children,
child_data); child_data);
}
} }
} }
} }
void void
sixtp_sax_end_handler(void *user_data, const xmlChar *name) { sixtp_sax_end_handler(void *user_data, const xmlChar *name)
{
sixtp_sax_data *pdata = (sixtp_sax_data *) user_data; sixtp_sax_data *pdata = (sixtp_sax_data *) user_data;
sixtp_stack_frame *current_frame; sixtp_stack_frame *current_frame;
sixtp_stack_frame *parent_frame; sixtp_stack_frame *parent_frame;
@ -495,13 +520,16 @@ sixtp_sax_end_handler(void *user_data, const xmlChar *name) {
/* time to make sure we got the right closing tag. Is this really /* time to make sure we got the right closing tag. Is this really
necessary? */ necessary? */
if(safe_strcmp(current_frame->tag, name) != 0) { if(safe_strcmp(current_frame->tag, name) != 0)
{
PWARN ("bad closing tag");
pdata->parsing_ok = FALSE; pdata->parsing_ok = FALSE;
return; return;
} }
/* tag's OK, proceed. */ /* tag's OK, proceed. */
if(current_frame->parser->end_handler) { if(current_frame->parser->end_handler)
{
pdata->parsing_ok = pdata->parsing_ok =
current_frame->parser->end_handler(current_frame->data_for_children, current_frame->parser->end_handler(current_frame->data_for_children,
current_frame->data_from_children, current_frame->data_from_children,
@ -514,7 +542,8 @@ sixtp_sax_end_handler(void *user_data, const xmlChar *name) {
g_return_if_fail(pdata->parsing_ok); g_return_if_fail(pdata->parsing_ok);
if(current_frame->frame_data) { if(current_frame->frame_data)
{
/* push the result onto the parent's child result list. */ /* push the result onto the parent's child result list. */
child_result_data = g_new(sixtp_child_result, 1); child_result_data = g_new(sixtp_child_result, 1);
@ -545,12 +574,14 @@ sixtp_sax_end_handler(void *user_data, const xmlChar *name) {
parent_frame = (sixtp_stack_frame *) parent_frame = (sixtp_stack_frame *)
((g_slist_length(pdata->stack) > 1) ? (pdata->stack->next->data) : NULL); ((g_slist_length(pdata->stack) > 1) ? (pdata->stack->next->data) : NULL);
if(current_frame->parser->after_child) { if(current_frame->parser->after_child)
{
/* reset pointer after stack pop */ /* reset pointer after stack pop */
GSList *parent_data_from_children = NULL; GSList *parent_data_from_children = NULL;
gpointer parent_data_for_children = NULL; gpointer parent_data_for_children = NULL;
if(parent_frame) { if(parent_frame)
{
/* we're not in the top level node */ /* we're not in the top level node */
sixtp_stack_frame *parent_frame = sixtp_stack_frame *parent_frame =
(sixtp_stack_frame *) pdata->stack->next->data; (sixtp_stack_frame *) pdata->stack->next->data;
@ -574,13 +605,15 @@ sixtp_sax_end_handler(void *user_data, const xmlChar *name) {
} }
xmlEntityPtr xmlEntityPtr
sixtp_sax_get_entity_handler(void *user_data, const CHAR *name) { sixtp_sax_get_entity_handler(void *user_data, const CHAR *name)
{
return xmlGetPredefinedEntity(name); return xmlGetPredefinedEntity(name);
} }
void void
sixtp_handle_catastrophe(sixtp_sax_data *sax_data) { sixtp_handle_catastrophe(sixtp_sax_data *sax_data)
{
/* Something has gone wrong. To handle it, we have to traverse the /* Something has gone wrong. To handle it, we have to traverse the
stack, calling, at each level, the frame failure handler (the stack, calling, at each level, the frame failure handler (the
handler for the current, unfinished block) and then the sibling handler for the current, unfinished block) and then the sibling
@ -595,19 +628,24 @@ sixtp_handle_catastrophe(sixtp_sax_data *sax_data) {
PERR("parse failed at \n"); PERR("parse failed at \n");
sixtp_print_frame_stack(sax_data->stack, stderr); sixtp_print_frame_stack(sax_data->stack, stderr);
while(*stack) { while(*stack)
{
sixtp_stack_frame *current_frame = (sixtp_stack_frame *) (*stack)->data; sixtp_stack_frame *current_frame = (sixtp_stack_frame *) (*stack)->data;
/* cleanup the current frame */ /* cleanup the current frame */
if(current_frame->parser->fail_handler) { if(current_frame->parser->fail_handler)
{
GSList *sibling_data; GSList *sibling_data;
gpointer parent_data; gpointer parent_data;
if((*stack)->next == NULL) { if((*stack)->next == NULL)
{
/* This is the top of the stack... */ /* This is the top of the stack... */
parent_data = NULL; parent_data = NULL;
sibling_data = NULL; sibling_data = NULL;
} else { }
else
{
sixtp_stack_frame *parent_frame = sixtp_stack_frame *parent_frame =
(sixtp_stack_frame *) (*stack)->next->data; (sixtp_stack_frame *) (*stack)->next->data;
parent_data = parent_frame->data_for_children; parent_data = parent_frame->data_for_children;
@ -624,14 +662,17 @@ sixtp_handle_catastrophe(sixtp_sax_data *sax_data) {
} }
/* now cleanup any children's results */ /* now cleanup any children's results */
for(lp = current_frame->data_from_children; lp; lp = lp->next) { for(lp = current_frame->data_from_children; lp; lp = lp->next)
{
sixtp_child_result *cresult = (sixtp_child_result *) lp->data; sixtp_child_result *cresult = (sixtp_child_result *) lp->data;
if(cresult->fail_handler) { if(cresult->fail_handler)
{
cresult->fail_handler(cresult); cresult->fail_handler(cresult);
} }
} }
if((*stack)->next == NULL) { if((*stack)->next == NULL)
{
/* This is the top of the stack. The top frame seems to want to /* This is the top of the stack. The top frame seems to want to
* be destroyed by sixtp_context_destroy. */ * be destroyed by sixtp_context_destroy. */
break; break;
@ -811,3 +852,5 @@ gnc_is_our_xml_file(const char *filename, const char *first_tag)
return FALSE; return FALSE;
} }
/************************* END OF FILE *********************************/