diff options
Diffstat (limited to 'guththila/src/guththila_xml_writer.c')
| -rw-r--r-- | guththila/src/guththila_xml_writer.c | 2082 |
1 files changed, 2082 insertions, 0 deletions
diff --git a/guththila/src/guththila_xml_writer.c b/guththila/src/guththila_xml_writer.c new file mode 100644 index 0000000..adc2389 --- /dev/null +++ b/guththila/src/guththila_xml_writer.c @@ -0,0 +1,2082 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <guththila_xml_writer.h> + +#define GUTHTHILA_WRITER_SD_DECLARATION "<?xml version=\"1.0\" encoding=\"utf-8\" ?>" + +#ifndef GUTHTHILA_XML_WRITER_TOKEN +#ifndef GUTHTHILA_WRITER_ELEM_FREE +#define GUTHTHILA_WRITER_ELEM_FREE(wr, elem, _env) \ + if ((elem)->prefix) AXIS2_FREE(env->allocator, (elem)->prefix); \ + if ((elem)->name) AXIS2_FREE(env->allocator, (elem)->name); \ + AXIS2_FREE(env->allocator, elem); +#endif +#else +#ifndef GUTHTHILA_WRITER_ELEM_FREE +#define GUTHTHILA_WRITER_ELEM_FREE(wr, elem, _env) \ + if ((elem)->prefix) guththila_tok_list_release_token(&wr->tok_list, (elem)->prefix, _env); \ + if ((elem)->name) guththila_tok_list_release_token(&wr->tok_list, (elem)->name, _env); \ + AXIS2_FREE(env->allocator, elem); +#endif +#endif + +#ifndef GUTHTHILA_XML_WRITER_TOKEN +#ifndef GUTHTHILA_WRITER_CLEAR_NAMESP +#define GUTHTHILA_WRITER_CLEAR_NAMESP(wr, stack_namesp, _no, counter, _namesp, j, _env) \ + for (counter = GUTHTHILA_STACK_TOP_INDEX(*stack_namesp); counter >= _no; counter--) {\ + _namesp = (guththila_xml_writer_namesp_t *) guththila_stack_pop(stack_namesp, _env); \ + if (_namesp) { \ + for (j = 0; j < _namesp->no - 1; j++) { \ + if (_namesp->name[j]) AXIS2_FREE(env->allocator, _namesp->name[j]); \ + if (_namesp->uri[j]) AXIS2_FREE(env->allocator, _namesp->uri[j]); \ + } \ + AXIS2_FREE(env->allocator, _namesp->name); \ + AXIS2_FREE(env->allocator, _namesp->uri); \ + AXIS2_FREE(env->allocator, _namesp); \ + } \ + _namesp = NULL; \ +} +#endif +#else +#ifndef GUTHTHILA_WRITER_CLEAR_NAMESP +#define GUTHTHILA_WRITER_CLEAR_NAMESP(wr, stack_namesp, _no, counter, _namesp, j, _env) \ + for (counter = GUTHTHILA_STACK_TOP_INDEX(*stack_namesp); counter >= _no; counter--) { \ + _namesp = (guththila_xml_writer_namesp_t *) guththila_stack_pop(stack_namesp, _env); \ + if (_namesp) { \ + for (j = 0; j < _namesp->no - 1; j++) { \ + guththila_tok_list_release_token(&wr->tok_list, _namesp->name[j], _env); \ + guththila_tok_list_release_token(&wr->tok_list, _namesp->uri[j], _env); \ + } \ + AXIS2_FREE(env->allocator, _namesp->name); \ + AXIS2_FREE(env->allocator, _namesp->uri); \ + AXIS2_FREE(env->allocator, _namesp); \ + } \ + _namesp = NULL; \ +} +#endif +#endif + +#ifndef GUTHTHILA_WRITER_INIT_ELEMENT +#define GUTHTHILA_WRITER_INIT_ELEMENT_WITH_PREFIX(wr, _elem, _name_start, _name_size, _pref_start, _pref_size) \ + _elem->name = guththila_tok_list_get_token(&wr->tok_list); \ + _elem->prefix = = guththila_tok_list_get_token(&wr->tok_list); \ + _elem->name->start = _name_start; \ + _elem->name->size = _name_size; \ + _elem->prefix->start = _pref_start; \ + _elem->prrefix->size = pref_size; +#endif + +#ifndef GUTHTHILA_WRITER_INIT_ELEMENT +#define GUTHTHILA_WRITER_INIT_ELEMENT_WITHOUT_PREFIX(wr, _elem, _name_start, _name_size) \ + _elem->name = guththila_tok_list_get_token(&(wr)->tok_list); \ + _elem->name->start = _name_start; \ + _elem->name->size = _name_size; \ + _elem->prefix->NULL; +#endif + +/* + #ifndef guththila_write(_wr, _buff, _buff_size) + #define guththila_write(_wr, _buff, _buff_size) \ + if (_wr->type == GUTHTHILA_WRITER_MEMORY){ \ + if (_wr->buffer.size > _wr->buffer.next + _buff_size) {\ + memcpy (_wr->buffer.buff + _wr->buffer.next, _buff, _buff_size);\ + _wr->buffer.next += (int)_buff_size; \ + } else {\ + _wr->buffer.buff = realloc(_wr->buffer.buff, _wr->buffer.size * 2);\ + _wr->buffer.size = _wr->buffer.size * 2; \ + memcpy (_wr->buffer.buff + _wr->buffer.next, _buff, _buff_size);\ + _wr->buffer.next += (int)_buff_size; \ + }\ + } + #endif*/ + +/* + * Write the contents of the buff in to the guththila_xml_writer buffer. + * len indicates the number of items in the buff. + */ +int GUTHTHILA_CALL guththila_write( + guththila_xml_writer_t * wr, + char *buff, + size_t buff_size, + const axutil_env_t * env); + +/* + * Same functionality as the guththila_write only difference is here we are given + * a token to write, not a buffer. + */ +int GUTHTHILA_CALL guththila_write_token( + guththila_xml_writer_t * wr, + guththila_token_t * tok, + const axutil_env_t * env); + +int GUTHTHILA_CALL guththila_write_xtoken( + guththila_xml_writer_t * wr, + char *buff, + size_t buff_len, + const axutil_env_t * env); + +/* + * Private function for free the contents of a empty element. + */ +int GUTHTHILA_CALL guththila_free_empty_element( + guththila_xml_writer_t *wr, + const axutil_env_t *env); + +GUTHTHILA_EXPORT guththila_xml_writer_t * GUTHTHILA_CALL +guththila_create_xml_stream_writer( + guththila_char_t *file_name, + const axutil_env_t * env) +{ + guththila_xml_writer_t * wr = AXIS2_MALLOC(env->allocator, sizeof(guththila_xml_writer_t)); + if(!wr) + return NULL; + wr->out_stream = fopen(file_name, "w"); + if(!wr->out_stream) + { + AXIS2_FREE(env->allocator, wr); + return NULL; + } + if(!guththila_stack_init(&wr->element, env)) + { + fclose(wr->out_stream); + AXIS2_FREE(env->allocator, wr); + return NULL; + } + if(!guththila_stack_init(&wr->namesp, env)) + { + guththila_stack_un_init(&wr->element, env); + fclose(wr->out_stream); + AXIS2_FREE(env->allocator, wr); + return NULL; + } + wr->type = GUTHTHILA_WRITER_FILE; + wr->status = BEGINING; + wr->next = 0; + return wr; +} + +GUTHTHILA_EXPORT guththila_xml_writer_t * GUTHTHILA_CALL +guththila_create_xml_stream_writer_for_memory( + const axutil_env_t * env) +{ + guththila_xml_writer_t * wr = AXIS2_MALLOC(env->allocator, sizeof(guththila_xml_writer_t)); + if(!wr) + return NULL; + if(!guththila_buffer_init(&wr->buffer, GUTHTHILA_BUFFER_DEF_SIZE, env)) + { + AXIS2_FREE(env->allocator, wr); + return NULL; + } + if(!guththila_stack_init(&wr->element, env)) + { + guththila_buffer_un_init(&wr->buffer, env); + AXIS2_FREE(env->allocator, wr); + return NULL; + } + if(!guththila_stack_init(&wr->namesp, env)) + { + guththila_buffer_un_init(&wr->buffer, env); + guththila_stack_un_init(&wr->element, env); + AXIS2_FREE(env->allocator, wr); + return NULL; + } + +#ifdef GUTHTHILA_XML_WRITER_TOKEN + if (!guththila_tok_list_init(&wr->tok_list, env)) + { + guththila_buffer_un_init(&wr->buffer, env); + guththila_stack_un_init(&wr->element, env); + guththila_stack_un_init(&wr->namesp, env); + AXIS2_FREE(env->allocator, wr); + return NULL; + } +#endif + wr->type = GUTHTHILA_WRITER_MEMORY; + wr->status = BEGINING; + wr->next = 0; + return wr; +} + +GUTHTHILA_EXPORT void GUTHTHILA_CALL +guththila_xml_writer_free( + guththila_xml_writer_t * wr, + const axutil_env_t * env) +{ + if(wr->type == GUTHTHILA_WRITER_MEMORY) + { + guththila_buffer_un_init(&wr->buffer, env); + } + else if(wr->type == GUTHTHILA_WRITER_FILE) + { + fclose(wr->out_stream); + } + +#ifdef GUTHTHILA_XML_WRITER_TOKEN + guththila_tok_list_free_data(&wr->tok_list, env); +#endif + guththila_stack_un_init(&wr->element, env); + guththila_stack_un_init(&wr->namesp, env); + AXIS2_FREE(env->allocator, wr); +} + +int GUTHTHILA_CALL +guththila_write( + guththila_xml_writer_t * wr, + guththila_char_t *buff, + size_t buff_len, + const axutil_env_t * env) +{ + size_t remain_len = 0; + size_t temp = 0; + size_t * temp1 = NULL, *temp2 = NULL; + guththila_char_t **temp3 = NULL; + int i = 0; + if(wr->type == GUTHTHILA_WRITER_MEMORY) + { + remain_len = wr->buffer.buffs_size[wr->buffer.cur_buff] + - wr->buffer.data_size[wr->buffer.cur_buff]; + /* We have space */ + if(buff_len < remain_len) + { + memcpy( + wr->buffer.buff[wr->buffer.cur_buff] + wr->buffer.data_size[wr->buffer.cur_buff], + buff, buff_len); + wr->buffer.data_size[wr->buffer.cur_buff] += buff_len; + wr->next += (int)buff_len; + /* We are sure that the difference lies within the int range */ + return (int)buff_len; + } + else + { + if(remain_len != 0) + { + memcpy(wr->buffer.buff[wr->buffer.cur_buff] + + wr->buffer.data_size[wr->buffer.cur_buff], buff, remain_len); + wr->buffer.data_size[wr->buffer.cur_buff] += remain_len; + } + /* We are sure that the difference lies within the int range */ + if(((int)wr->buffer.no_buffers - 1) == wr->buffer.cur_buff) + { + /* Out of allocated array buffers. Need to allocate*/ + wr->buffer.no_buffers = wr->buffer.no_buffers * 2; + temp3 = (guththila_char_t **)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t *) * wr->buffer.no_buffers); + temp1 = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) + * wr->buffer.no_buffers); + temp2 = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) + * wr->buffer.no_buffers); + for(i = 0; i <= wr->buffer.cur_buff; i++) + { + temp3[i] = wr->buffer.buff[i]; + temp1[i] = wr->buffer.data_size[i]; + temp2[i] = wr->buffer.buffs_size[i]; + } + AXIS2_FREE(env->allocator, wr->buffer.data_size); + AXIS2_FREE(env->allocator, wr->buffer.buffs_size); + AXIS2_FREE(env->allocator, wr->buffer.buff); + wr->buffer.buff = temp3; + wr->buffer.buffs_size = temp2; + wr->buffer.data_size = temp1; + } + wr->buffer.cur_buff++; + temp = wr->buffer.buffs_size[wr->buffer.cur_buff - 1] * 2; + while(temp < (buff_len - remain_len)) + { + temp = temp * 2; + } + /* Create a be buffer */ + wr->buffer.buff[wr->buffer.cur_buff] = (guththila_char_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t) * temp); + wr->buffer.buffs_size[wr->buffer.cur_buff] = temp; + memcpy(wr->buffer.buff[wr->buffer.cur_buff], buff + remain_len, buff_len - remain_len); + wr->buffer.data_size[wr->buffer.cur_buff] = buff_len - remain_len; + wr->buffer.pre_tot_data += wr->buffer.data_size[wr->buffer.cur_buff - 1]; + wr->next += (int)buff_len; + /* We are sure that the difference lies within the int range */ + return (int)buff_len; + } + } + else if(wr->type == GUTHTHILA_WRITER_FILE) + { + return (int)fwrite(buff, 1, buff_len, wr->out_stream); + } + return GUTHTHILA_FAILURE; +} + +int GUTHTHILA_CALL +guththila_write_token( + guththila_xml_writer_t * wr, + guththila_token_t * tok, + const axutil_env_t * env) +{ + int i; + size_t remain_len = 0; + size_t temp = 0; + size_t * temp1 = NULL, *temp2 = NULL; + guththila_char_t **temp3 = NULL; + if(wr->type == GUTHTHILA_WRITER_MEMORY) + { + remain_len = wr->buffer.buffs_size[wr->buffer.cur_buff] + - wr->buffer.data_size[wr->buffer.cur_buff]; + if(tok->size < remain_len) + { + memcpy( + wr->buffer.buff[wr->buffer.cur_buff] + wr->buffer.data_size[wr->buffer.cur_buff], + tok->start, tok->size); + + wr->buffer.data_size[wr->buffer.cur_buff] += tok->size; + wr->next += (int)tok->size; + /* We are sure that the difference lies within the int range */ + return (int)tok->size; + } + else + { + if(remain_len != 0) + { + memcpy(wr->buffer.buff[wr->buffer.cur_buff] + + wr->buffer.data_size[wr->buffer.cur_buff], tok->start, remain_len); + + wr->buffer.data_size[wr->buffer.cur_buff] += remain_len; + } + /* We are sure that the difference lies within the int range */ + if(((int)wr->buffer.no_buffers - 1) == wr->buffer.cur_buff) + { + wr->buffer.no_buffers = wr->buffer.no_buffers * 2; + temp3 = (guththila_char_t **)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t *) * wr->buffer.no_buffers); + temp1 = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) + * wr->buffer.no_buffers); + temp2 = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) + * wr->buffer.no_buffers); + for(i = 0; i <= wr->buffer.cur_buff; i++) + { + temp3[i] = wr->buffer.buff[i]; + temp1[i] = wr->buffer.data_size[i]; + temp2[i] = wr->buffer.buffs_size[i]; + } + AXIS2_FREE(env->allocator, wr->buffer.data_size); + AXIS2_FREE(env->allocator, wr->buffer.buffs_size); + AXIS2_FREE(env->allocator, wr->buffer.buff); + wr->buffer.buff = temp3; + wr->buffer.buffs_size = temp2; + wr->buffer.data_size = temp1; + } + wr->buffer.cur_buff++; + temp = wr->buffer.buffs_size[wr->buffer.cur_buff - 1] * 2; + while(temp < (tok->size - remain_len)) + { + temp = temp * 2; + } + wr->buffer.buff[wr->buffer.cur_buff] = (guththila_char_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t) * temp); + + wr->buffer.buffs_size[wr->buffer.cur_buff] = temp; + memcpy(wr->buffer.buff[wr->buffer.cur_buff], tok->start + remain_len, tok->size + - remain_len); + wr->buffer.data_size[wr->buffer.cur_buff] = tok->size - remain_len; + wr->buffer.pre_tot_data += wr->buffer.data_size[wr->buffer.cur_buff - 1]; + wr->next += (int)tok->size; + /* We are sure that the difference lies within the int range */ + return (int)tok->size; + } + } + else if(wr->type == GUTHTHILA_WRITER_FILE) + { + return (int)fwrite(tok->start, 1, tok->size, wr->out_stream); + } + return GUTHTHILA_FAILURE; +} + +int GUTHTHILA_CALL +guththila_write_xtoken( + guththila_xml_writer_t * wr, + guththila_char_t *buff, + size_t buff_len, + const axutil_env_t * env) +{ + int i; + size_t temp = 0; + size_t remain_len = 0; + size_t * temp1 = NULL, *temp2 = NULL; + guththila_char_t **temp3 = NULL; + if(wr->type == GUTHTHILA_WRITER_MEMORY) + { + remain_len = wr->buffer.buffs_size[wr->buffer.cur_buff] + - wr->buffer.data_size[wr->buffer.cur_buff]; + if(buff_len < remain_len) + { + memcpy( + wr->buffer.buff[wr->buffer.cur_buff] + wr->buffer.data_size[wr->buffer.cur_buff], + buff, buff_len); + wr->buffer.data_size[wr->buffer.cur_buff] += buff_len; + wr->next += (int)buff_len; + /* We are sure that the difference lies within the int range */ + return (int)buff_len; + } + else + { + /* We are sure that the difference lies within the int range */ + if(((int)wr->buffer.no_buffers - 1) == wr->buffer.cur_buff) + { + wr->buffer.no_buffers = wr->buffer.no_buffers * 2; + temp3 = (guththila_char_t **)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t *) * wr->buffer.no_buffers); + temp1 = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) + * wr->buffer.no_buffers); + temp2 = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) + * wr->buffer.no_buffers); + for(i = 0; i <= wr->buffer.cur_buff; i++) + { + temp3[i] = wr->buffer.buff[i]; + temp1[i] = wr->buffer.data_size[i]; + temp2[i] = wr->buffer.buffs_size[i]; + } + AXIS2_FREE(env->allocator, wr->buffer.data_size); + AXIS2_FREE(env->allocator, wr->buffer.buffs_size); + AXIS2_FREE(env->allocator, wr->buffer.buff); + wr->buffer.buff = temp3; + wr->buffer.buffs_size = temp2; + wr->buffer.data_size = temp1; + } + temp = wr->buffer.buffs_size[wr->buffer.cur_buff] * 2; + while(temp < (buff_len)) + { + temp = temp * 2; + } + wr->buffer.cur_buff++; + wr->buffer.buff[wr->buffer.cur_buff] = (guththila_char_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t) * temp); + + wr->buffer.buffs_size[wr->buffer.cur_buff] = temp; + memcpy(wr->buffer.buff[wr->buffer.cur_buff], buff, buff_len); + wr->buffer.data_size[wr->buffer.cur_buff] = buff_len; + wr->buffer.pre_tot_data += wr->buffer.data_size[wr->buffer.cur_buff - 1]; + wr->next += (int)buff_len; + /* We are sure that the difference lies within the int range */ + return (int)buff_len; + } + } + else if(wr->type == GUTHTHILA_WRITER_FILE) + { + return (int)fwrite(buff, 1, buff_len, wr->out_stream); + } + return GUTHTHILA_FAILURE; +} + +int GUTHTHILA_CALL +guththila_free_empty_element( + guththila_xml_writer_t *wr, + const axutil_env_t *env) +{ + guththila_xml_writer_element_t * elem = NULL; + guththila_xml_writer_namesp_t * namesp = NULL; + int i = 0, j = 0; + elem = (guththila_xml_writer_element_t *)guththila_stack_pop(&wr->element, env); + if(elem) + { + wr->status = BEGINING; + if(elem->name_sp_stack_no != -1) + { + GUTHTHILA_WRITER_CLEAR_NAMESP(wr, &wr->namesp, + elem->name_sp_stack_no, i, + namesp, j, env); + } + GUTHTHILA_WRITER_ELEM_FREE(wr, elem, env); + return GUTHTHILA_SUCCESS; + } + else + { + return GUTHTHILA_FAILURE; + } +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_start_document( + guththila_xml_writer_t * wr, + const axutil_env_t * env, + char *encoding, + char *version) +{ + char *tmp1 = NULL; + char *tmp2 = GUTHTHILA_WRITER_SD_DECLARATION; + + tmp1 = strchr(tmp2, '\"'); + tmp1++; + guththila_write(wr, tmp2, (int)(tmp1 - tmp2), env); + tmp2 = strchr(tmp1, '\"'); + if(version) + { + guththila_write(wr, version, (int)strlen(version), env); + } + else + { + guththila_write(wr, tmp1, (int)(tmp2 - tmp1), env); + } + tmp2++; + tmp1 = strchr(tmp2, '\"'); + tmp2--; + tmp1++; + guththila_write(wr, tmp2, (int)(tmp1 - tmp2), env); + tmp2 = strchr(tmp1, '\"'); + if(encoding) + { + guththila_write(wr, encoding, (int)strlen(encoding), env); + } + else + { + guththila_write(wr, tmp1, (int)(tmp2 - tmp1), env); + } + guththila_write(wr, tmp2, (int)strlen(tmp2), env); + + return GUTHTHILA_SUCCESS; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_start_element( + guththila_xml_writer_t * wr, + guththila_char_t *start_element, + const axutil_env_t * env) +{ + int cur_pos = 0; + size_t len = 0; + guththila_xml_writer_element_t * element = (guththila_xml_writer_element_t *)AXIS2_MALLOC( + env->allocator, sizeof(guththila_xml_writer_element_t)); + len = strlen(start_element); + if(wr->status == START) + { + /* If we are in a start we need to close and start */ + guththila_write(wr, "><", 2u, env); + cur_pos = wr->next; + guththila_write_xtoken(wr, start_element, len, env); + } + else if(wr->status == START_EMPTY) + { + /* We need to close and start */ + guththila_free_empty_element(wr, env); + guththila_write(wr, "/><", 3u, env); + cur_pos = wr->next; + guththila_write_xtoken(wr, start_element, len, env); + } + else if(wr->status == BEGINING) + { + /* We can start rightaway*/ + guththila_write(wr, "<", 1u, env); + cur_pos = wr->next; + guththila_write_xtoken(wr, start_element, len, env); + } + else + { + return GUTHTHILA_FAILURE; + } + wr->status = START; + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + element->name = strdup(start_element); + element->prefix = NULL; +#else + element->name = guththila_tok_list_get_token(&wr->tok_list, env); + element->name->start = GUTHTHILA_BUF_POS(wr->buffer, cur_pos); + element->name->size = len; + element->prefix = NULL; + +#endif + element->name_sp_stack_no = -1; + return guththila_stack_push(&wr->element, element, env); +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_end_element( + guththila_xml_writer_t * wr, + const axutil_env_t * env) +{ + guththila_xml_writer_element_t * elem = NULL; + guththila_xml_writer_namesp_t * namesp = NULL; + int i = 0, j = 0; + if(wr->status == START) + { + guththila_write(wr, "></", 3u, env); + /* Write the contents of the element at the top */ + elem = (guththila_xml_writer_element_t *)guththila_stack_pop(&wr->element, env); + if(elem) + { + if(elem->prefix) + { + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + guththila_write(wr, elem->prefix, strlen(elem->prefix), env); +#else + guththila_write_token(wr, elem->prefix, env); +#endif + guththila_write(wr, ":", 1u, env); + } + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + guththila_write(wr, elem->name, strlen(elem->name), env); +#else + guththila_write_token(wr, elem->name, env); +#endif + guththila_write(wr, ">", 1u, env); + wr->status = BEGINING; + if(elem->name_sp_stack_no != -1) + { + GUTHTHILA_WRITER_CLEAR_NAMESP(wr, &wr->namesp, + elem->name_sp_stack_no, i, + namesp, j, env); + } + GUTHTHILA_WRITER_ELEM_FREE(wr, elem, env); + return GUTHTHILA_SUCCESS; + } + else + { + return GUTHTHILA_FAILURE; + } + } + else if(wr->status == START_EMPTY) + { + guththila_write(wr, "/>", 2u, env); + elem = (guththila_xml_writer_element_t *)guththila_stack_pop(&wr->element, env); + if(elem) + { + wr->status = BEGINING; + if(elem->name_sp_stack_no != -1) + { + GUTHTHILA_WRITER_CLEAR_NAMESP(wr, &wr->namesp, + elem->name_sp_stack_no, i, + namesp, j, env); + } + GUTHTHILA_WRITER_ELEM_FREE(wr, elem, env); + return GUTHTHILA_SUCCESS; + } + else + { + return GUTHTHILA_FAILURE; + } + } + else if(wr->status == BEGINING) + { + guththila_write(wr, "</", 2u, env); + elem = (guththila_xml_writer_element_t *)guththila_stack_pop(&wr->element, env); + if(elem) + { + if(elem->prefix) + { + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + guththila_write(wr, elem->prefix, strlen(elem->prefix), env); +#else + guththila_write_token(wr, elem->prefix, env); +#endif + guththila_write(wr, ":", 1u, env); + } + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + guththila_write(wr, elem->name, strlen(elem->name), env); +#else + guththila_write_token(wr, elem->name, env); +#endif + guththila_write(wr, ">", 1u, env); + wr->status = BEGINING; + if(elem->name_sp_stack_no != -1) + { + GUTHTHILA_WRITER_CLEAR_NAMESP(wr, &wr->namesp, + elem->name_sp_stack_no, i, + namesp, j, env); + } + GUTHTHILA_WRITER_ELEM_FREE(wr, elem, env); + return GUTHTHILA_SUCCESS; + } + else + { + return GUTHTHILA_FAILURE; + } + } + return GUTHTHILA_FAILURE; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_close( + guththila_xml_writer_t * wr, + const axutil_env_t * env) +{ + return GUTHTHILA_FAILURE; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_characters( + guththila_xml_writer_t * wr, + guththila_char_t *buff, + const axutil_env_t * env) +{ + size_t len = strlen(buff); + if(wr->status == START) + { + wr->status = BEGINING; + guththila_write(wr, ">", 1u, env); + } + else if(wr->status == START_EMPTY) + { + guththila_free_empty_element(wr, env); + wr->status = BEGINING; + guththila_write(wr, "/>", 2u, env); + } + else if(wr->status != BEGINING) + { + return GUTHTHILA_FAILURE; + } + while(len > 0) + { + size_t i = 0; + /* scan buffer until the next special character (&, <, >, ', ") these need to be escaped, + * otherwise XML will not be valid*/ + guththila_char_t *pos = (guththila_char_t*)strpbrk(buff, "&<>'\""); + if(pos) + { + i = pos - buff; + } + else + { + i = len; + } + + /* write everything until the special character */ + if(i > 0) + { + guththila_write(wr, buff, i, env); + buff += i; + len -= i; + } + /* replace the character with the appropriate sequence */ + if(len > 0) + { + if(AXIS2_SUCCESS != guththila_write_escape_character(wr, buff, env)) + return GUTHTHILA_FAILURE; + /* skip the character */ + buff++; + len--; + } + } + return GUTHTHILA_SUCCESS; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_comment( + guththila_xml_writer_t * wr, + guththila_char_t *buff, + const axutil_env_t * env) +{ + if(wr->status == START) + { + wr->status = BEGINING; + guththila_write(wr, "><!--", 5u, env); + guththila_write(wr, buff, strlen(buff), env); + guththila_write(wr, "-->", 3u, env); + return GUTHTHILA_SUCCESS; + } + else if(wr->status == START_EMPTY) + { + guththila_free_empty_element(wr, env); + wr->status = BEGINING; + guththila_write(wr, "/><!--", 6u, env); + guththila_write(wr, buff, strlen(buff), env); + guththila_write(wr, "-->", 3u, env); + return GUTHTHILA_SUCCESS; + } + else if(wr->status == BEGINING) + { + guththila_write(wr, "<!--", 4u, env); + guththila_write(wr, buff, strlen(buff), env); + guththila_write(wr, "-->", 3u, env); + return GUTHTHILA_SUCCESS; + } + return GUTHTHILA_FAILURE; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_escape_character( + guththila_xml_writer_t * wr, + guththila_char_t *buff, + const axutil_env_t * env) +{ + if(buff) + { + switch(buff[0]) + { + case '>': + guththila_write(wr, ">", 4u, env); + break; + case '<': + guththila_write(wr, "<", 4u, env); + break; + case '\'': + guththila_write(wr, "'", 6u, env); + break; + case '"': + guththila_write(wr, """, 6u, env); + break; + case '&': + guththila_write(wr, "&", 5u, env); + break; + default: + return GUTHTHILA_FAILURE; + }; + } + return GUTHTHILA_SUCCESS; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_empty_element( + guththila_xml_writer_t * wr, + guththila_char_t *start_element, + const axutil_env_t * env) +{ + int cur_pos = 0; + size_t len = 0; + guththila_xml_writer_element_t * element = (guththila_xml_writer_element_t *)AXIS2_MALLOC( + env->allocator, sizeof(guththila_xml_writer_element_t)); + len = strlen(start_element); + if(wr->status == START) + { + guththila_write(wr, "><", 2u, env); + cur_pos = wr->next; + guththila_write_xtoken(wr, start_element, len, env); + } + else if(wr->status == START_EMPTY) + { + guththila_free_empty_element(wr, env); + wr->status = BEGINING; + guththila_write(wr, "/><", 3u, env); + cur_pos = wr->next; + guththila_write_xtoken(wr, start_element, len, env); + } + else if(wr->status == BEGINING) + { + guththila_write(wr, "<", 1u, env); + cur_pos = wr->next; + guththila_write_xtoken(wr, start_element, len, env); + } + else + { + return GUTHTHILA_FAILURE; + } + wr->status = START_EMPTY; + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + element->name = strdup(start_element); + element->prefix = NULL; +#else + element->name = guththila_tok_list_get_token(&wr->tok_list, env); + element->name->start = GUTHTHILA_BUF_POS(wr->buffer, cur_pos); + element->name->size = len; + element->prefix = NULL; + +#endif + element->name_sp_stack_no = -1; + return guththila_stack_push(&wr->element, element, env); +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_default_namespace( + guththila_xml_writer_t * wr, + guththila_char_t *namespace_uri, + const axutil_env_t * env) +{ + if(wr->status == START || wr->status == START_EMPTY) + { + guththila_write(wr, " xmlns=\"", 8u, env); + guththila_write(wr, namespace_uri, strlen(namespace_uri), env); + guththila_write(wr, "\"", 1u, env); + return GUTHTHILA_SUCCESS; + } + return GUTHTHILA_FAILURE; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_namespace( + guththila_xml_writer_t * wr, + guththila_char_t *prefix, + guththila_char_t *uri, + const axutil_env_t * env) +{ + int i, j, temp, nmsp_found = GUTHTHILA_FALSE, stack_size; + guththila_xml_writer_namesp_t * namesp = NULL; + guththila_xml_writer_element_t * elem = NULL; + int pref_start = 0, uri_start = 0; + guththila_char_t *pref_start_p = NULL, *uri_start_p = NULL; + guththila_xml_writer_namesp_t * writer_namesp = NULL; + guththila_token_t ** tok_name = NULL, **tok_uri = NULL; + size_t pref_len = strlen(prefix), uri_len = strlen(uri); + stack_size = GUTHTHILA_STACK_SIZE(wr->namesp); + /* Check weather we have met the namespace before */ + for(i = stack_size - 1; i >= 0; i--) + { + writer_namesp = (guththila_xml_writer_namesp_t *)guththila_stack_get_by_index(&wr->namesp, + i, env); + temp = writer_namesp->no; + for(j = 0; j < temp; j++) + { + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + if(!strcmp(prefix, writer_namesp->name[j])) + { + +#else + if (!guththila_tok_str_cmp(writer_namesp->name[j], prefix, pref_len, env)) + { +#endif + nmsp_found = GUTHTHILA_TRUE; + } + } + } + /* Proceed if we didn't find the namespace */ + if(!nmsp_found && (wr->status == START || wr->status == START_EMPTY)) + { + guththila_write(wr, " xmlns:", 7u, env); + pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, pref_start); + guththila_write(wr, "=\"", 2u, env); + uri_start = wr->next; + guththila_write_xtoken(wr, uri, uri_len, env); + uri_start_p = GUTHTHILA_BUF_POS(wr->buffer, uri_start); + guththila_write(wr, "\"", 1u, env); + elem = guththila_stack_peek(&wr->element, env); + if(elem && elem->name_sp_stack_no == -1) + { + namesp = (guththila_xml_writer_namesp_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_xml_writer_namesp_t)); + if(namesp) + { + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + namesp->name = (guththila_char_t **)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t *) * GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE); + namesp->uri = (guththila_char_t **)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t *) * GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE); + namesp->name[0] = strdup(prefix); + namesp->uri[0] = strdup(uri); + +#else + namesp->name = + (guththila_token_t **) AXIS2_MALLOC(env->allocator, + sizeof(guththila_token_t + *) * + GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE); + namesp->uri = + (guththila_token_t **) AXIS2_MALLOC(env->allocator, + sizeof(guththila_token_t + *) * + GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE); + namesp->name[0] = guththila_tok_list_get_token(&wr->tok_list, env); + namesp->name[0]->start = pref_start_p ; + namesp->name[0]->size = pref_len; + namesp->uri[0] = guththila_tok_list_get_token(&wr->tok_list, env); + namesp->uri[0]->start = uri_start_p ; + namesp->uri[0]->size = uri_len; + +#endif + namesp->no = 1; + namesp->size = GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE; + guththila_stack_push(&wr->namesp, namesp, env); + elem->name_sp_stack_no = GUTHTHILA_STACK_TOP_INDEX(wr->namesp); + } + else + { + return GUTHTHILA_FAILURE; + } + } + else if(elem) + { + namesp = guththila_stack_peek(&wr->namesp, env); + if(namesp->no < namesp->size) + { + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + namesp->name[++(namesp->no) - 1] = strdup(prefix); + namesp->uri[namesp->no - 1] = strdup(uri); + +#else + namesp->name[++(namesp->no) - 1] = guththila_tok_list_get_token(&wr->tok_list, env); + namesp->uri[namesp->no - 1] = guththila_tok_list_get_token(&wr->tok_list, env); + namesp->name[namesp->no - 1]->start = pref_start_p; + namesp->name[namesp->no - 1]->size = pref_len; + namesp->uri[namesp->no - 1]->start = uri_start_p; + namesp->uri[namesp->no - 1]->size = uri_len; + +#endif + } + else + { + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + namesp->name = (guththila_char_t **)realloc(namesp->name, + sizeof(guththila_char_t *) * (GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE + + namesp->size)); + namesp->uri = (guththila_char_t **)realloc(namesp->name, sizeof(guththila_char_t *) + * (GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE + namesp->size)); + namesp->size = GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE + namesp->size; + namesp->name[++(namesp->no) - 1] = strdup(prefix); + namesp->uri[namesp->no - 1] = strdup(uri); + +#else + tok_name = + (guththila_token_t **) AXIS2_MALLOC(env->allocator, + sizeof(guththila_token_t *) * + (GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE + + namesp->size)); + tok_uri = + (guththila_token_t **) AXIS2_MALLOC(env->allocator, + sizeof(guththila_token_t *) * + (GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE + + namesp->size)); + for (i = 0; i < namesp->no; i++) + { + tok_name[i] = namesp->name[i]; + tok_uri[i] = namesp->uri[i]; + } + AXIS2_FREE(env->allocator, namesp->name); + AXIS2_FREE(env->allocator, namesp->uri); + namesp->name = tok_name; + namesp->uri = tok_uri; + namesp->size = GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE + namesp->size; + + namesp->name[namesp->no] = guththila_tok_list_get_token(&wr->tok_list, env); + namesp->uri[namesp->no] = guththila_tok_list_get_token(&wr->tok_list, env); + + namesp->name[namesp->no ]->start = pref_start_p; + namesp->name[namesp->no ]->size = pref_len; + namesp->uri[namesp->no ]->start = uri_start_p; + namesp->uri[namesp->no ]->size = uri_len; + namesp->no ++; +#endif + } + } + return GUTHTHILA_SUCCESS; + } + if(nmsp_found) + return GUTHTHILA_SUCCESS; + return GUTHTHILA_FAILURE; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_attribute( + guththila_xml_writer_t * wr, + guththila_char_t *localname, + guththila_char_t *value, + const axutil_env_t * env) +{ + if(wr->status == START || wr->status == START_EMPTY) + { + guththila_write(wr, " ", 1u, env); + guththila_write(wr, localname, strlen(localname), env); + guththila_write(wr, "=\"", 2u, env); + guththila_write(wr, value, strlen(value), env); + guththila_write(wr, "\"", 1u, env); + return GUTHTHILA_SUCCESS; + } + return GUTHTHILA_FAILURE; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_attribute_with_prefix_and_namespace( + guththila_xml_writer_t * wr, + guththila_char_t *prefix, + guththila_char_t *namespace_uri, + guththila_char_t *localname, + guththila_char_t *value, + const axutil_env_t * env) +{ + return guththila_write_namespace(wr, prefix, namespace_uri, env) + && guththila_write_attribute_with_prefix(wr, prefix, localname, value, env); +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_attribute_with_prefix( + guththila_xml_writer_t * wr, + guththila_char_t *prefix, + guththila_char_t *localname, + guththila_char_t *value, + const axutil_env_t * env) +{ + int i, j; + int stack_size = GUTHTHILA_STACK_SIZE(wr->namesp); + int temp; + size_t pref_len = strlen(prefix); + guththila_xml_writer_namesp_t * writer_namesp = NULL; + if(wr->status == START || wr->status == START_EMPTY) + { + /* We need to make sure that there is a namespace defined with the + * given prefix as the name */ + for(i = stack_size - 1; i >= 0; i--) + { + writer_namesp = (guththila_xml_writer_namesp_t *)guththila_stack_get_by_index( + &wr->namesp, i, env); + temp = writer_namesp->no; + for(j = 0; j < temp; j++) + { + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + if(!strcmp(prefix, writer_namesp->name[j])) + { + +#else + if (!guththila_tok_str_cmp + (writer_namesp->name[j], prefix, pref_len, env)) + { + +#endif + guththila_write(wr, " ", 1u, env); + guththila_write(wr, prefix, pref_len, env); + guththila_write(wr, ":", 1u, env); + guththila_write(wr, localname, strlen(localname), env); + guththila_write(wr, "=\"", 2u, env); + guththila_write(wr, value, strlen(value), env); + guththila_write(wr, "\"", 1u, env); + return GUTHTHILA_SUCCESS; + } + } + } + } + return GUTHTHILA_FAILURE; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_attribute_with_namespace( + guththila_xml_writer_t * wr, + guththila_char_t *namesp, + guththila_char_t *loc_name, + guththila_char_t *value, + const axutil_env_t * env) +{ + int i, j; + int stack_size = GUTHTHILA_STACK_SIZE(wr->namesp); + int temp; + guththila_xml_writer_namesp_t * writer_namesp = NULL; + if(wr->status == START || wr->status == START_EMPTY) + { + /* We need to make sure that the namespace is previously declared */ + for(i = stack_size - 1; i >= 0; i--) + { + writer_namesp = (guththila_xml_writer_namesp_t *)guththila_stack_get_by_index( + &wr->namesp, i, env); + temp = writer_namesp->no; + for(j = 0; j < temp; j++) + { +#ifndef GUTHTHILA_XML_WRITER_TOKEN + if(!strcmp(namesp, writer_namesp->uri[j])) + { + guththila_write(wr, " ", 1, env); + guththila_write(wr, writer_namesp->name[j], strlen(writer_namesp->name[j]), env); +#else + if (!guththila_tok_str_cmp + (writer_namesp->uri[j], namesp, strlen(namesp), env)) + { + guththila_write(wr, " ", 1u, env); + guththila_write_token(wr, writer_namesp->name[j], env); +#endif + guththila_write(wr, ":", 1u, env); + guththila_write(wr, loc_name, strlen(loc_name), env); + guththila_write(wr, "=\"", 2u, env); + guththila_write(wr, value, strlen(value), env); + guththila_write(wr, "\"", 1u, env); + return GUTHTHILA_SUCCESS; + } + } + } + } + return GUTHTHILA_FAILURE; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_start_element_with_prefix_and_namespace( + guththila_xml_writer_t * wr, + guththila_char_t *prefix, + guththila_char_t *namespace_uri, + guththila_char_t *local_name, + const axutil_env_t * env) +{ + int i, j, temp, stack_size, nmsp_found = GUTHTHILA_FALSE; + guththila_xml_writer_namesp_t * namesp = NULL; + guththila_xml_writer_element_t * elem = NULL; + int uri_start = 0, pref_start = 0, elem_start = 0, elem_pref_start = 0; + guththila_char_t *uri_start_p = NULL, *pref_start_p = NULL; + guththila_char_t *elem_start_p = NULL, *elem_pref_start_p = NULL ; + size_t uri_len = 0; + size_t pref_len = 0; + size_t elem_len = 0; + guththila_xml_writer_namesp_t * writer_namesp = NULL; + + elem = (guththila_xml_writer_element_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_xml_writer_element_t)); + uri_len = strlen(namespace_uri); + pref_len = strlen(prefix); + elem_len = strlen(local_name); + stack_size = GUTHTHILA_STACK_SIZE(wr->namesp); + /* We have to determine weather we have seen the namespace before */ + for(i = stack_size - 1; i >= 0; i--) + { + writer_namesp = (guththila_xml_writer_namesp_t *)guththila_stack_get_by_index(&wr->namesp, + i, env); + temp = writer_namesp->no; + for(j = 0; j < temp; j++) + { +#ifndef GUTHTHILA_XML_WRITER_TOKEN + if(!strcmp(uri, writer_namesp->uri[j])) + { + +#else + if (!guththila_tok_str_cmp + (writer_namesp->name[j], prefix, pref_len, env)) + { + +#endif + nmsp_found = GUTHTHILA_TRUE; + } + } + } + if(elem) + { + elem->name_sp_stack_no = -1; + if(wr->status == START) + { + guththila_write(wr, "><", 2u, env); + elem_pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + elem_pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_pref_start); + guththila_write(wr, ":", 1u, env); + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, elem_len, env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + if(!nmsp_found) + { + guththila_write(wr, " ", 1u, env); + guththila_write(wr, "xmlns:", 6u, env); + pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, pref_start); + guththila_write(wr, "=\"", 2u, env); + uri_start = wr->next; + guththila_write_xtoken(wr, namespace_uri, uri_len, env); + uri_start_p = GUTHTHILA_BUF_POS(wr->buffer, uri_start); + guththila_write(wr, "\"", 1u, env); + } + } + else if(wr->status == START_EMPTY) + { + guththila_free_empty_element(wr, env); + guththila_write(wr, "/><", 2u, env); + elem_pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + elem_pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_pref_start); + guththila_write(wr, ":", 1u, env); + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, elem_len, env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + if(!nmsp_found) + { + guththila_write(wr, " ", 1u, env); + guththila_write(wr, "xmlns:", 6u, env); + pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, pref_start); + guththila_write(wr, "=\"", 2u, env); + uri_start = wr->next; + guththila_write_xtoken(wr, namespace_uri, uri_len, env); + uri_start_p = GUTHTHILA_BUF_POS(wr->buffer, uri_start); + guththila_write(wr, "\"", 1u, env); + } + wr->status = START; + } + else if(wr->status == BEGINING) + { + guththila_write(wr, "<", 1u, env); + elem_pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + elem_pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_pref_start); + guththila_write(wr, ":", 1u, env); + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, elem_len, env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + if(!nmsp_found) + { + guththila_write(wr, " ", 1u, env); + guththila_write(wr, "xmlns:", 6u, env); + pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, pref_start); + guththila_write(wr, "=\"", 2u, env); + uri_start = wr->next; + guththila_write_xtoken(wr, namespace_uri, uri_len, env); + uri_start_p = GUTHTHILA_BUF_POS(wr->buffer, uri_start); + guththila_write(wr, "\"", 1u, env); + } + wr->status = START; + } + else + { + return GUTHTHILA_FAILURE; + } + if(!nmsp_found) + { + /* If this namespace not defined previously we need to add it */ + namesp = (guththila_xml_writer_namesp_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_xml_writer_namesp_t)); + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + namesp->name = (guththila_char_t **)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t *) * GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE); + namesp->uri = (guththila_char_t **)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t *) * GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE); + namesp->name[0] = strdup(prefix); + namesp->uri[0] = strdup(namespace_uri); + +#else + namesp->name = + (guththila_token_t **) AXIS2_MALLOC(env->allocator, + sizeof(guththila_token_t *) + * + GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE); + namesp->uri = + (guththila_token_t **) AXIS2_MALLOC(env->allocator, + sizeof(guththila_token_t *) + * + GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE); + namesp->name[0] = guththila_tok_list_get_token(&wr->tok_list, env); + namesp->name[0]->start = pref_start_p; + namesp->name[0]->size = pref_len; + namesp->uri[0] = guththila_tok_list_get_token(&wr->tok_list, env); + namesp->uri[0]->start = uri_start_p; + namesp->uri[0]->size = uri_len; +#endif + namesp->no = 1; + namesp->size = GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE; + guththila_stack_push(&wr->namesp, namesp, env); + elem->name_sp_stack_no = GUTHTHILA_STACK_TOP_INDEX(wr->namesp); + } + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + elem->name = strdup(local_name); + elem->prefix = strdup(prefix); +#else + elem->name = guththila_tok_list_get_token(&wr->tok_list, env); + elem->prefix = guththila_tok_list_get_token(&wr->tok_list, env); + elem->name->start = elem_start_p; + elem->name->size = elem_len; + elem->prefix->start = elem_pref_start_p; + elem->prefix->size = pref_len; +#endif + guththila_stack_push(&wr->element, elem, env); + } + else + { + return GUTHTHILA_FAILURE; + } + return GUTHTHILA_SUCCESS; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_start_element_with_namespace( + guththila_xml_writer_t * wr, + guththila_char_t *namespace_uri, + guththila_char_t *local_name, + const axutil_env_t * env) +{ + int i = 0, j = 0; + int stack_size = GUTHTHILA_STACK_SIZE(wr->namesp); + int temp = 0; + int elem_start = 0; + guththila_char_t *elem_start_p = NULL; + size_t elem_len = 0; + guththila_xml_writer_namesp_t * writer_namesp = NULL; + guththila_xml_writer_element_t * element; + + elem_len = strlen(local_name); + element = (guththila_xml_writer_element_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_xml_writer_element_t)); + if(!element) + return GUTHTHILA_FAILURE; + + for(i = stack_size - 1; i >= 0; i--) + { + writer_namesp = (guththila_xml_writer_namesp_t *)guththila_stack_get_by_index(&wr->namesp, + i, env); + temp = writer_namesp->no; + for(j = 0; j < temp; j++) + { +#ifndef GUTHTHILA_XML_WRITER_TOKEN + if(!strcmp(namespace_uri, writer_namesp->uri[j])) +#else + if (!guththila_tok_str_cmp + (writer_namesp->uri[j], namespace_uri, + strlen(namespace_uri), env)) +#endif + { + i = 0; /* force exit from outer loop as well */ + break; + } + } + } + + /* Close off any preceding element and start a new element */ + if(wr->status == START) + { + guththila_write(wr, "><", 2u, env); + } + else if(wr->status == START_EMPTY) + { + guththila_free_empty_element(wr, env); + guththila_write(wr, "/><", 2u, env); + } + else if(wr->status == BEGINING) + { + guththila_write(wr, "<", 1u, env); + } + else + { + return GUTHTHILA_FAILURE; + } + /* If there is a prefix, include it. */ + if(writer_namesp && (j < writer_namesp->no)) + { +#ifndef GUTHTHILA_XML_WRITER_TOKEN + guththila_write(wr, writer_namesp->name[j], strlen(writer_namesp->name[j]), env); +#else + guththila_write_token(wr, writer_namesp->name[j], env); +#endif + guththila_write(wr, ":", 1u, env); + } + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, elem_len, env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + + /* Remember this element's name and prefix, so the closing tag can be written later. */ +#ifndef GUTHTHILA_XML_WRITER_TOKEN + element->name = strdup(local_name); + if(writer_namesp && (j < writer_namesp->no)) + { + element->prefix = strdup(writer_namesp->name[j]); + } + else + { + element->prefix = NULL; + } + +#else + element->name = + guththila_tok_list_get_token(&wr->tok_list, env); + element->name->size = elem_len; + element->name->start = elem_start_p; + if (writer_namesp && (j < writer_namesp->no)) + { + element->prefix = + guththila_tok_list_get_token(&wr->tok_list, env); + element->prefix->size = writer_namesp->name[j]->size; + element->prefix->start = writer_namesp->name[j]->start; + } + else + { + element->prefix = NULL; + } +#endif + + element->name_sp_stack_no = -1; + wr->status = START; + return guththila_stack_push(&wr->element, element, env); +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_start_element_with_prefix( + guththila_xml_writer_t * wr, + guththila_char_t *prefix, + guththila_char_t *local_name, + const axutil_env_t * env) +{ + int i, j; + int stack_size = GUTHTHILA_STACK_SIZE(wr->namesp); + int temp; + int elem_start = 0; + guththila_char_t *elem_start_p = NULL; + size_t elem_len = 0, pref_len = 0; + guththila_xml_writer_namesp_t * writer_namesp = NULL; + elem_len = strlen(local_name); + pref_len = strlen(prefix); + for(i = stack_size - 1; i >= 0; i--) + { + writer_namesp = (guththila_xml_writer_namesp_t *)guththila_stack_get_by_index(&wr-> namesp, + i, env); + temp = writer_namesp->no; + for(j = 0; j < temp; j++) + { + /* if we found a namespace with the given prefix we can proceed */ +#ifndef GUTHTHILA_XML_WRITER_TOKEN + if(!strcmp(prefix, writer_namesp->name[j])) + { +#else + if (!guththila_tok_str_cmp(writer_namesp->name[j], + prefix, pref_len, env)) + { +#endif + guththila_xml_writer_element_t * element = + (guththila_xml_writer_element_t *)AXIS2_MALLOC(env-> allocator, + sizeof(guththila_xml_writer_element_t)); + if(wr->status == START) + { + guththila_write(wr, "><", 2u, env); + guththila_write_xtoken(wr, prefix, pref_len, env); + guththila_write(wr, ":", 1u, env); + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, strlen(local_name), env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + } + else if(wr->status == START_EMPTY) + { + guththila_free_empty_element(wr, env); + guththila_write(wr, "/><", 3u, env); + guththila_write_xtoken(wr, prefix, pref_len, env); + guththila_write(wr, ":", 1u, env); + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, strlen(local_name), env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + } + else if(wr->status == BEGINING) + { + guththila_write(wr, "<", 1u, env); + guththila_write_xtoken(wr, prefix, pref_len, env); + guththila_write(wr, ":", 1u, env); + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, strlen(local_name), env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + } + else + { + return GUTHTHILA_FAILURE; + } + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + element->name = strdup(local_name); + element->prefix = strdup(prefix); +#else + element->name = + guththila_tok_list_get_token(&wr->tok_list, env); + element->name->size = elem_len; + element->name->start = elem_start_p; + element->prefix = guththila_tok_list_get_token(&wr->tok_list, env); + element->prefix->size = writer_namesp->name[j]->size; + element->prefix->start = writer_namesp->name[j]->start; +#endif + wr->status = START; + element->name_sp_stack_no = -1; + return guththila_stack_push(&wr->element, element, env); + } + } + } + return GUTHTHILA_FAILURE; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_empty_element_with_prefix_and_namespace( + guththila_xml_writer_t * wr, + guththila_char_t *prefix, + guththila_char_t *namespace_uri, + guththila_char_t *local_name, + const axutil_env_t * env) +{ + int i, j, temp, stack_size, nmsp_found = GUTHTHILA_FALSE; + guththila_xml_writer_namesp_t * namesp = NULL; + guththila_xml_writer_element_t * elem = NULL; + int uri_start = 0, pref_start = 0, elem_start = 0, elem_pref_start = 0; + guththila_char_t *uri_start_p = NULL, *pref_start_p = NULL; + guththila_char_t *elem_start_p = NULL, *elem_pref_start_p = NULL ; + size_t uri_len = 0; + size_t pref_len = 0; + size_t elem_len = 0; + guththila_xml_writer_namesp_t * writer_namesp = NULL; + + namesp = (guththila_xml_writer_namesp_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_xml_writer_namesp_t)); + elem = (guththila_xml_writer_element_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_xml_writer_element_t)); + uri_len = strlen(namespace_uri); + pref_len = strlen(prefix); + elem_len = strlen(local_name); + stack_size = GUTHTHILA_STACK_SIZE(wr->namesp); + /* Chech weather we have defined this namespace before */ + for(i = stack_size - 1; i >= 0; i--) + { + writer_namesp = (guththila_xml_writer_namesp_t *)guththila_stack_get_by_index(&wr->namesp, + i, env); + temp = writer_namesp->no; + for(j = 0; j < temp; j++) + { +#ifndef GUTHTHILA_XML_WRITER_TOKEN + if(!strcmp(uri, writer_namesp->uri[j])) + { + +#else + if (!guththila_tok_str_cmp + (writer_namesp->name[j], prefix, pref_len, env)) + { + +#endif + nmsp_found = GUTHTHILA_TRUE; + } + } + } + if(namesp && elem) + { + elem->name_sp_stack_no = -1; + if(wr->status == START) + { + guththila_write(wr, "><", 2u, env); + elem_pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + elem_pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_pref_start); + guththila_write(wr, ":", 1u, env); + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, elem_len, env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + if(!nmsp_found) + { + guththila_write(wr, " ", 1u, env); + guththila_write(wr, "xmlns:", 6u, env); + pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, pref_start); + guththila_write(wr, "=\"", 2u, env); + uri_start = wr->next; + guththila_write_xtoken(wr, namespace_uri, uri_len, env); + uri_start_p = GUTHTHILA_BUF_POS(wr->buffer, uri_start); + guththila_write(wr, "\"", 1u, env); + } + wr->status = START_EMPTY; + } + else if(wr->status == START_EMPTY) + { + guththila_free_empty_element(wr, env); + guththila_write(wr, "/><", 2u, env); + elem_pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + elem_pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_pref_start); + guththila_write(wr, ":", 1u, env); + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, elem_len, env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + if(!nmsp_found) + { + guththila_write(wr, " ", 1u, env); + guththila_write(wr, "xmlns:", 6u, env); + pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, pref_start); + guththila_write(wr, "=\"", 2u, env); + uri_start = wr->next; + guththila_write_xtoken(wr, namespace_uri, uri_len, env); + uri_start_p = GUTHTHILA_BUF_POS(wr->buffer, uri_start); + guththila_write(wr, "\"", 1u, env); + } + } + else if(wr->status == BEGINING) + { + guththila_write(wr, "<", 1u, env); + elem_pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + elem_pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_pref_start); + guththila_write(wr, ":", 1u, env); + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, elem_len, env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + if(!nmsp_found) + { + guththila_write(wr, " ", 1u, env); + guththila_write(wr, "xmlns:", 6u, env); + pref_start = wr->next; + guththila_write_xtoken(wr, prefix, pref_len, env); + pref_start_p = GUTHTHILA_BUF_POS(wr->buffer, pref_start); + guththila_write(wr, "=\"", 2u, env); + uri_start = wr->next; + guththila_write_xtoken(wr, namespace_uri, uri_len, env); + uri_start_p = GUTHTHILA_BUF_POS(wr->buffer, uri_start); + guththila_write(wr, "\"", 1u, env); + } + wr->status = START_EMPTY; + } + else + { + return GUTHTHILA_FAILURE; + } + if(!nmsp_found) + { + /* If the namespace is not defined we need to remember it for later*/ +#ifndef GUTHTHILA_XML_WRITER_TOKEN + namesp->name = (guththila_char_t **)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t *) * GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE); + namesp->uri = (guththila_char_t **)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t *) * GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE); + namesp->name[0] = strdup(prefix); + namesp->uri[0] = strdup(namespace_uri); + +#else + namesp->name = + (guththila_token_t **) AXIS2_MALLOC(env->allocator, + sizeof(guththila_token_t *) + * + GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE); + namesp->uri = + (guththila_token_t **) AXIS2_MALLOC(env->allocator, + sizeof(guththila_token_t *) + * + GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE); + namesp->name[0] = guththila_tok_list_get_token(&wr->tok_list, env); + namesp->name[0]->start = pref_start_p; + namesp->name[0]->size = pref_len; + namesp->uri[0] = guththila_tok_list_get_token(&wr->tok_list, env); + namesp->uri[0]->start = uri_start_p; + namesp->uri[0]->size = uri_len; +#endif + namesp->no = 1; + namesp->size = GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE; + guththila_stack_push(&wr->namesp, namesp, env); + elem->name_sp_stack_no = GUTHTHILA_STACK_TOP_INDEX(wr->namesp); + } + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + elem->name = strdup(local_name); + elem->prefix = strdup(prefix); +#else + elem->name = guththila_tok_list_get_token(&wr->tok_list, env); + elem->prefix = guththila_tok_list_get_token(&wr->tok_list, env); + elem->name->start = elem_start_p; + elem->name->size = elem_len; + elem->prefix->start = elem_pref_start_p; + elem->prefix->size = pref_len; +#endif + guththila_stack_push(&wr->element, elem, env); + } + return GUTHTHILA_SUCCESS; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_empty_element_with_namespace( + guththila_xml_writer_t * wr, + guththila_char_t *namespace_uri, + guththila_char_t *local_name, + const axutil_env_t * env) +{ + int i = 0, j = 0; + int stack_size = GUTHTHILA_STACK_SIZE(wr->namesp); + int temp = 0; + int elem_start = 0; + guththila_char_t *elem_start_p = NULL; + size_t elem_len = 0; + guththila_xml_writer_namesp_t * writer_namesp = NULL; + guththila_xml_writer_element_t * element; + + elem_len = strlen(local_name); + element = (guththila_xml_writer_element_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_xml_writer_element_t)); + if(!element) + return GUTHTHILA_FAILURE; + + for(i = stack_size - 1; i >= 0; i--) + { + writer_namesp = (guththila_xml_writer_namesp_t *)guththila_stack_get_by_index(&wr->namesp, + i, env); + temp = writer_namesp->no; + for(j = 0; j < temp; j++) + { +#ifndef GUTHTHILA_XML_WRITER_TOKEN + if(!strcmp(namespace_uri, writer_namesp->uri[j])) +#else + if (!guththila_tok_str_cmp + (writer_namesp->uri[j], namespace_uri, + strlen(namespace_uri), env)) +#endif + { + i = 0; /* force exit from outer loop as well */ + break; + } + } + } + + /* Close off any preceding element and start a new element */ + if(wr->status == START) + { + guththila_write(wr, "><", 2u, env); + } + else if(wr->status == START_EMPTY) + { + guththila_free_empty_element(wr, env); + guththila_write(wr, "/><", 2u, env); + } + else if(wr->status == BEGINING) + { + guththila_write(wr, "<", 1u, env); + } + else + { + return GUTHTHILA_FAILURE; + } + /* If there is a prefix, include it. */ + if(writer_namesp && (j < writer_namesp->no)) + { +#ifndef GUTHTHILA_XML_WRITER_TOKEN + guththila_write(wr, writer_namesp->name[j], strlen(writer_namesp->name[j]), env); +#else + guththila_write_token(wr, writer_namesp->name[j], env); +#endif + guththila_write(wr, ":", 1u, env); + } + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, elem_len, env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + + /* Remember this element's name and prefix, so the closing tag can be written later. */ +#ifndef GUTHTHILA_XML_WRITER_TOKEN + element->name = strdup(local_name); + if(writer_namesp && (j < writer_namesp->no)) + { + element->prefix = strdup(writer_namesp->name[j]); + } + else + { + element->prefix = NULL; + } + +#else + element->name = + guththila_tok_list_get_token(&wr->tok_list, env); + element->name->size = elem_len; + element->name->start = elem_start_p; + if (writer_namesp && (j < writer_namesp->no)) + { + element->prefix = + guththila_tok_list_get_token(&wr->tok_list, env); + element->prefix->size = writer_namesp->name[j]->size; + element->prefix->start = writer_namesp->name[j]->start; + } + else + { + element->prefix = NULL; + } +#endif + + element->name_sp_stack_no = -1; + wr->status = START_EMPTY; + return guththila_stack_push(&wr->element, element, env); +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_empty_element_with_prefix( + guththila_xml_writer_t * wr, + guththila_char_t *prefix, + guththila_char_t *local_name, + const axutil_env_t * env) +{ + int i, j; + int stack_size = GUTHTHILA_STACK_SIZE(wr->namesp); + int temp; + int elem_start = 0; + guththila_char_t *elem_start_p = NULL ; + size_t elem_len = 0, pref_len = 0; + guththila_xml_writer_namesp_t * writer_namesp = NULL; + elem_len = strlen(local_name); + pref_len = strlen(prefix); + for(i = stack_size - 1; i >= 0; i--) + { + writer_namesp = (guththila_xml_writer_namesp_t *)guththila_stack_get_by_index(&wr-> namesp, + i, env); + temp = writer_namesp->no; + for(j = 0; j < temp; j++) + { + /* Proceed if we found the namespace */ +#ifndef GUTHTHILA_XML_WRITER_TOKEN + if(!strcmp(prefix, writer_namesp->name[j])) + { +#else + if (!guththila_tok_str_cmp(writer_namesp->name[j], + prefix, pref_len, env)) + { +#endif + guththila_xml_writer_element_t * element = + (guththila_xml_writer_element_t *)AXIS2_MALLOC(env-> allocator, + sizeof(guththila_xml_writer_element_t)); + if(wr->status == START) + { + guththila_write(wr, "><", 2u, env); + guththila_write_xtoken(wr, prefix, pref_len, env); + guththila_write(wr, ":", 1u, env); + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, strlen(local_name), env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + } + else if(wr->status == START_EMPTY) + { + guththila_free_empty_element(wr, env); + guththila_write(wr, "/><", 3u, env); + guththila_write_xtoken(wr, prefix, pref_len, env); + guththila_write(wr, ":", 1u, env); + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, strlen(local_name), env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + } + else if(wr->status == BEGINING) + { + guththila_write(wr, "<", 1u, env); + guththila_write_xtoken(wr, prefix, pref_len, env); + guththila_write(wr, ":", 1u, env); + elem_start = wr->next; + guththila_write_xtoken(wr, local_name, strlen(local_name), env); + elem_start_p = GUTHTHILA_BUF_POS(wr->buffer, elem_start); + } + else + { + return GUTHTHILA_FAILURE; + } + +#ifndef GUTHTHILA_XML_WRITER_TOKEN + element->name = strdup(local_name); + element->prefix = strdup(prefix); +#else + element->name = + guththila_tok_list_get_token(&wr->tok_list, env); + element->name->size = elem_len; + element->name->start = elem_start_p; + element->prefix = + guththila_tok_list_get_token(&wr->tok_list, env); + element->prefix->size = writer_namesp->name[j]->size; + element->prefix->start = writer_namesp->name[j]->start; +#endif + wr->status = START_EMPTY; + element->name_sp_stack_no = -1; + /* remember the element */ + return guththila_stack_push(&wr->element, element, env); + } + } + } + return GUTHTHILA_FAILURE; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_end_document( + guththila_xml_writer_t * wr, + const axutil_env_t * env) +{ + int i = 0; + int size = GUTHTHILA_STACK_SIZE(wr->element); + if(wr->status == START_EMPTY) + guththila_write_end_element(wr, env); + /* For all the open elements in the element stack close them */ + for(i = 0; i < size; i++) + { + if(!guththila_write_end_element(wr, env)) + { + return GUTHTHILA_FAILURE; + } + } + return GUTHTHILA_SUCCESS; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_line( + guththila_xml_writer_t * wr, + guththila_char_t *element_name, + guththila_char_t *characters, + const axutil_env_t * env) +{ + guththila_write_start_element(wr, element_name, env); + guththila_write_characters(wr, characters, env); + guththila_write_end_element(wr, env); + guththila_write_characters(wr, "\n", env); + return GUTHTHILA_FAILURE; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_memory_buffer( + guththila_xml_writer_t * wr, + const axutil_env_t * env) +{ + if(wr->type == GUTHTHILA_WRITER_MEMORY) + { + return (guththila_char_t *)guththila_buffer_get(&wr->buffer, env); + } + return NULL; +} + +GUTHTHILA_EXPORT unsigned int GUTHTHILA_CALL +guththila_get_memory_buffer_size( + guththila_xml_writer_t * wr, + const axutil_env_t * env) +{ + if(wr->type == GUTHTHILA_WRITER_MEMORY) + { + return (unsigned int)(wr->buffer.pre_tot_data + wr->buffer.data_size[wr->buffer.cur_buff]); + } + return 0; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_prefix_for_namespace( + guththila_xml_writer_t * wr, + guththila_char_t *nmsp, + const axutil_env_t * env) +{ + int i, j; + int stack_size = GUTHTHILA_STACK_SIZE(wr->namesp); + int temp; + guththila_char_t *str = NULL; + guththila_xml_writer_namesp_t * writer_namesp = NULL; + for(i = stack_size - 1; i >= 0; i--) + { + writer_namesp = (guththila_xml_writer_namesp_t *)guththila_stack_get_by_index(&wr-> namesp, + i, env); + temp = writer_namesp->no; + for(j = 0; j < temp; j++) + { + if(!guththila_tok_str_cmp(writer_namesp->uri[j], nmsp, strlen(nmsp), env)) + { + GUTHTHILA_TOKEN_TO_STRING(writer_namesp->uri[j], str, env); + return str; + } + } + } + return NULL; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_to_buffer( + guththila_xml_writer_t * wr, + guththila_char_t *buff, + int size, + const axutil_env_t * env) +{ + /* Just write what ever given. But need to close things before */ + if(wr->status == START) + { + guththila_write(wr, ">", 1u, env); + } + if(wr->status == START_EMPTY) + { + guththila_write(wr, "/>", 2u, env); + } + guththila_write(wr, buff, size, env); + wr->status = BEGINING; + return GUTHTHILA_SUCCESS; +} + |