diff options
Diffstat (limited to 'guththila')
38 files changed, 7735 insertions, 0 deletions
diff --git a/guththila/AUTHORS b/guththila/AUTHORS new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/guththila/AUTHORS diff --git a/guththila/COPYING b/guththila/COPYING new file mode 100644 index 0000000..6b0b127 --- /dev/null +++ b/guththila/COPYING @@ -0,0 +1,203 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed 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. + diff --git a/guththila/ChangeLog b/guththila/ChangeLog new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/guththila/ChangeLog diff --git a/guththila/INSTALL b/guththila/INSTALL new file mode 100644 index 0000000..1cdc320 --- /dev/null +++ b/guththila/INSTALL @@ -0,0 +1,12 @@ +Getting Guththila source working on Linux +============================================= +Build the source +This can be done using the following command sequence: + ./configure + make + make install + use './configure --help' for options + +NOTE: If you don't provide a --prefix configure option, it will by default +install into /usr/local/guththila directory. + diff --git a/guththila/LICENSE b/guththila/LICENSE new file mode 100644 index 0000000..6b0b127 --- /dev/null +++ b/guththila/LICENSE @@ -0,0 +1,203 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed 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. + diff --git a/guththila/Makefile.am b/guththila/Makefile.am new file mode 100644 index 0000000..b94c0c2 --- /dev/null +++ b/guththila/Makefile.am @@ -0,0 +1,12 @@ +datadir=$(prefix) +SUBDIRS = src +includedir=$(prefix)/include/axis2-1.6.0/ +include_HEADERS=$(top_builddir)/include/*.h +data_DATA= INSTALL README AUTHORS NEWS LICENSE COPYING +#EXTRA_DIST = build.sh autogen.sh CREDITS LICENSE +dist-hook: + rm -rf `find $(distdir)/ -type d -name .svn` + rm -rf `find $(distdir)/ -type d -name .deps` + +EXTRA_DIST=LICENSE + diff --git a/guththila/NEWS b/guththila/NEWS new file mode 100644 index 0000000..e69de29 --- /dev/null +++ b/guththila/NEWS diff --git a/guththila/README b/guththila/README new file mode 100644 index 0000000..8c40b8b --- /dev/null +++ b/guththila/README @@ -0,0 +1,41 @@ +
+ Apache Axis2/C Guththila
+ ========================
+
+ What Is It?
+ -----------
+
+ Guththila is Streaming XML Parser for the Apache Axis2/C.
+
+ The Latest Version
+ ------------------
+
+ You can get the latest svn checkout of Apache Axis2/C Guththila module from
+
+ https://svn.apache.org/repos/asf/webservices/axis2/trunk/c/guththila
+
+ Installation
+ ------------
+
+ Please see the file called INSTALL.
+
+ Licensing
+ ---------
+
+ Please see the file called LICENSE.
+
+ Contacts
+ --------
+
+ o If you want freely available support for using Apache Axis2/C Guththila please
+ join the Apache Axis2/C user community by subscribing to users mailing
+ list, axis-c-user@ws.apache.org' as described at
+ http://ws.apache.org/axis2/c/mail-lists.html
+
+ o If you have a bug report for Apache Axis2/C Guththila please log-in and create a JIRA issue
+ at http://issues.apache.org/jira/browse/AXIS2C
+
+ o If you want to participate actively in developing Apache Axis2/C Guththila please
+ subscribe to the `axis-c-dev@ws.apache.org' mailing list as described at
+ http://ws.apache.org/axis2/c/mail-lists.html
+
diff --git a/guththila/autogen.sh b/guththila/autogen.sh new file mode 100755 index 0000000..8ca13d8 --- /dev/null +++ b/guththila/autogen.sh @@ -0,0 +1,51 @@ +#!/bin/bash + +echo -n 'Running libtoolize...' +if [ `uname -s` = Darwin ] +then + LIBTOOLIZE=glibtoolize +else + LIBTOOLIZE=libtoolize +fi + +if $LIBTOOLIZE --force > /dev/null 2>&1; then + + echo 'done.' +else + echo 'failed.' + exit 1 +fi + +echo -n 'Running aclocal...' +if aclocal > /dev/null 2>&1; then + echo 'done.' +else + echo 'failed.' + exit 1 +fi + +echo -n 'Running autoheader...' +if autoheader > /dev/null 2>&1; then + echo 'done.' +else + echo 'failed.' + exit 1 +fi + +echo -n 'Running autoconf...' +if autoconf > /dev/null 2>&1; then + echo 'done.' +else + echo 'failed.' + exit 1 +fi + +echo -n 'Running automake...' +if automake --add-missing > /dev/null 2>&1; then + echo 'done.' +else + echo 'failed.' + exit 1 +fi + +echo 'done' diff --git a/guththila/build.sh b/guththila/build.sh new file mode 100755 index 0000000..48dfd02 --- /dev/null +++ b/guththila/build.sh @@ -0,0 +1,4 @@ +./autogen.sh +./configure --prefix=${AXIS2C_HOME} --with-axis2_util=${AXIS2C_HOME}/include +make +make install diff --git a/guththila/configure.ac b/guththila/configure.ac new file mode 100644 index 0000000..5a6951b --- /dev/null +++ b/guththila/configure.ac @@ -0,0 +1,81 @@ +dnl run autogen.sh to generate the configure script. + +AC_PREREQ(2.59) + +AC_INIT(guththilac-src, 1.6.0) +AC_CANONICAL_SYSTEM +AM_CONFIG_HEADER(config.h) +dnl AM_INIT_AUTOMAKE([tar-ustar]) +AM_INIT_AUTOMAKE +AC_PREFIX_DEFAULT(/usr/local/guththila) + +m4_ifdef([_A][M_PROG_TAR],[_A][M_SET_OPTION([tar-ustar])]) + +dnl Checks for programs. +AC_PROG_CC +AC_PROG_CXX +AC_PROG_CPP +AC_PROG_LIBTOOL +AC_PROG_INSTALL +AC_PROG_LN_S +AC_PROG_MAKE_SET + +dnl check for flavours of varargs macros (test from GLib) +AC_MSG_CHECKING(for ISO C99 varargs macros in C) +AC_TRY_COMPILE([],[ +int a(int p1, int p2, int p3); +#define call_a(...) a(1,__VA_ARGS__) +call_a(2,3); +],axis2c_have_iso_c_varargs=yes,axis2c_have_iso_c_varargs=no) +AC_MSG_RESULT($axis2c_have_iso_c_varargs) + +AC_MSG_CHECKING(for GNUC varargs macros) +AC_TRY_COMPILE([],[ +int a(int p1, int p2, int p3); +#define call_a(params...) a(1,params) +call_a(2,3); +],axis2c_have_gnuc_varargs=yes,axis2c_have_gnuc_varargs=no) +AC_MSG_RESULT($axis2c_have_gnuc_varargs) + +dnl Output varargs tests +if test x$axis2c_have_iso_c_varargs = xyes; then + AC_DEFINE(HAVE_ISO_VARARGS,1,[Have ISO C99 varargs macros]) +fi +if test x$axis2c_have_gnuc_varargs = xyes; then + AC_DEFINE(HAVE_GNUC_VARARGS,1,[Have GNU-style varargs macros]) +fi + +dnl Checks for libraries. +AC_CHECK_LIB(dl, dlopen) + +CFLAGS="$CFLAGS -D_LARGEFILE64_SOURCE -DAXIS2_GUTHTHILA_ENABLED" + +if test "$GCC" = "yes"; then + CFLAGS="$CFLAGS -ansi -ggdb3 -Wall -Wno-implicit-function-declaration " +fi + + +dnl Checks for header files. +AC_HEADER_STDC +AC_CHECK_HEADERS([stdio.h stdlib.h string.h]) + +dnl Checks for typedefs, structures, and compiler characteristics. +AC_C_CONST + +dnl Checks for library functions. +AC_FUNC_MALLOC +AC_FUNC_REALLOC +#AC_CHECK_FUNCS([memmove]) + + +UTILINC=$axis2_utilinc +VERSION_NO="6:0:6" + +AC_SUBST(UTILINC) +AC_SUBST(VERSION_NO) + +AC_CONFIG_FILES([Makefile \ + src/Makefile \ + ]) + +AC_OUTPUT diff --git a/guththila/include/guththila.h b/guththila/include/guththila.h new file mode 100644 index 0000000..663883d --- /dev/null +++ b/guththila/include/guththila.h @@ -0,0 +1,353 @@ + +/* + * 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. + */ +#ifndef GUTHTHILA_H +#define GUTHTHILA_H + +#include <guththila_defines.h> +#include <guththila_token.h> +#include <guththila_reader.h> +#include <guththila_xml_writer.h> +#include <guththila_attribute.h> +#include <guththila_namespace.h> +#include <guththila_buffer.h> +#include <guththila_stack.h> +#include <guththila_error.h> + +#include <axutil_utils.h> + +/* +All the functions in this library does not check weather the given arguments are NULL. +It is the responsblity of the user to check weather the arguments contain NULL values. +*/ +EXTERN_C_START() + +enum guththila_status +{ + S_0 = 0, + S_1, + S_2, + S_3 +}; + +enum guththila_UTF16_endianess +{ + None = 1, + LE, + BE +}; + +typedef enum guththila_type +{ + type_file_name = 0, + type_memory_buffer, + type_reader, + type_io +} guththila_type_t; + +enum guththila_event_types +{ + GUTHTHILA_START_DOCUMENT =0, + GUTHTHILA_END_ELEMENT, + GUTHTHILA_CHARACTER, + GUTHTHILA_ENTITY_REFERANCE, + GUTHTHILA_COMMENT, + GUTHTHILA_SPACE, + GUTHTHILA_START_ELEMENT, + GUTHTHILA_EMPTY_ELEMENT +}; + +typedef struct guththila_s +{ + guththila_tok_list_t tokens; /* Token cache */ + + guththila_buffer_t buffer; /* Holding incoming xml string */ + + guththila_reader_t *reader; /* Reading the data */ + + guththila_token_t *prefix; /* Prefix of the xml element */ + + guththila_token_t *name; /* xml element local name */ + + guththila_token_t *value; /* text of a xml element */ + + guththila_stack_t elem; /* elements are put in a stack */ + + guththila_stack_t attrib; /* Attributes are put in a stack */ + + guththila_stack_t namesp; /* namespaces are put in a stack */ + + int status; + + int guththila_event; /* Current event */ + + size_t next; /* Keep track of the position in the xml string */ + + int last_start; /* Keep track of the starting position of the last token */ + + guththila_token_t *temp_prefix; /* Temporery location for prefixes */ + + guththila_token_t *temp_name; /* Temporery location for names */ + + guththila_token_t *temp_tok; /* We don't know this until we close it */ +} guththila_t; + +/* + * An element will contain one of these things if it has namespaces + * */ +typedef struct guththila_elem_namesp_s +{ + guththila_namespace_t *namesp; /* Array of namespaces */ + int no; /*Number of namespace in the element */ + int size; /* Allocated size */ +} guththila_elem_namesp_t; + +/* + * Element. + */ +typedef struct guththila_element_s +{ + guththila_token_t *name; /* local name */ + + guththila_token_t *prefix; /* prefix */ + + int is_namesp; /* Positive if a namespace is present */ +} guththila_element_t; + +/* Initialize the parser */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_init(guththila_t * m, void *reader, + const axutil_env_t * env); + +/* Uninitialize the parser */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_un_init(guththila_t * m, const axutil_env_t * env); + +/* Still not used */ +typedef void(GUTHTHILA_CALL * guththila_error_func)(void *arg, + const guththila_char_t *msg, + guththila_error_level level, + void *locator); + +/* + * Parse the xml and return an event. If something went wrong it will return -1. + * The events are of the type guththila_event_types. According to the event + * user can get the required information using the appriate functions. + * @param g pointer to a guththila_t structure + * @param env the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_next(guththila_t * g, const axutil_env_t * env); + +/* + * Return the number of attributes in the current element. + * @param g pointer to a guththila_t structure + * @param env the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_get_attribute_count(guththila_t * g, const axutil_env_t * env); + +/* + * Return the attribute name. + * @param g pointer to a guththila_t structure + * @param att pointer to a attribute + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t * GUTHTHILA_CALL +guththila_get_attribute_name(guththila_t * g, guththila_attr_t * att, + const axutil_env_t * env); + +/* + * Return the attribute value. + * @param g pointer to a guththila_t structure + * @param att pointer to a attribute + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t * GUTHTHILA_CALL +guththila_get_attribute_value(guththila_t * g, + guththila_attr_t * att, + const axutil_env_t * env); + +/* + * Return the attribute prefix. + * @param g pointer to a guththila_t structure + * @param att pointer to a attribute + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_attribute_prefix(guththila_t * g, + guththila_attr_t * att, + const axutil_env_t * env); + +/* + * Return the attribute + * @param g pointer to a guththila_t structure + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_attr_t *GUTHTHILA_CALL +guththila_get_attribute(guththila_t * g, const axutil_env_t * env); + +/* + * Return the name of the attribute by the attribute bumber. + * First attribute will be 1. + * @param g pointer to a guththila_t structure + * @param index position of the attribute + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_attribute_name_by_number(guththila_t * g, int index, + const axutil_env_t *env); + +/* + * Return the attribute value by number. + * First attribute will be 1. + * @param g pointer to a guththila_t structure + * @param index position of the attribute + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_attribute_value_by_number(guththila_t * g, int index, + const axutil_env_t *env); + +/* + * Return the prefix of the attribute. + * First attribute will be 1. + * @param g pointer to a guththila_t structure + * @param index position of the attribute + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_attribute_prefix_by_number(guththila_t * g, int index, + const axutil_env_t *env); + +/* + * Return the name of the element. + * @param g pointer to a guththila_t structure + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_name(guththila_t * g, const axutil_env_t * env); + +/* + * Return the prefix of the element. + * @param g pointer to a guththila_t structure + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_prefix(guththila_t * g, const axutil_env_t * env); + +/* + * Return the text of the element. + * @param g pointer to a guththila_t structure + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_value(guththila_t * g, const axutil_env_t * env); + +/* + * Return the namespace of the element. + * @param g pointer to a guththila_t structure + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_namespace_t *GUTHTHILA_CALL +guththila_get_namespace(guththila_t * g, const axutil_env_t * env); + +/* + * Return the number of namespaces in the element. + * @param g pointer to a guththila_t structure + * @param env the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_get_namespace_count(guththila_t * g, const axutil_env_t * env); + +/* + * Return the namespace uri of the given namespace. + * @param g pointer to a guththila_t structure + * @param ns pointer to a namespace + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t * GUTHTHILA_CALL +guththila_get_namespace_uri(guththila_t * g, guththila_namespace_t * ns, + const axutil_env_t * env); + +/* + * Return the prefix of the namespace. + * @param g pointer to a guththila_t structure + * @param ns pointer to a namespace + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_namespace_prefix(guththila_t * p, guththila_namespace_t * ns, + const axutil_env_t * env); + +/* + * Return the prefix of the namespace at the given position. + * First namespace will have the value 1. + * @param g pointer to a guththila_t structure + * @param index position of the namespace + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_namespace_prefix_by_number(guththila_t * g, int index, + const axutil_env_t *env); + +/* + * Get the uri of the namespace at the given position. + * First namespace will have the value 1. + * @param g pointer to a guththila_t structure + * @param index position of the namespace + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_namespace_uri_by_number(guththila_t * g, int index, + const axutil_env_t *env); + +/* + * Get the attribute namespace of the attribute at the given position. + * @param g pointer to a guththila_t structure + * @param index position of the namespace + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_attribute_namespace_by_number(guththila_t *g, int index, + const axutil_env_t *env); + +/* + * Get the encoding. at the moment we don't support UNICODE + * @param g pointer to a guththila_t structure + * @param env the environment + */ +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_encoding(guththila_t * p, const axutil_env_t * env); + +/* + * To do. Implement a proper error handling mechanism. + * @param g pointer to a guththila_t structure + * @param env the environment + */ +GUTHTHILA_EXPORT void GUTHTHILA_CALL +guththila_set_error_handler(guththila_t * m, guththila_error_func, + const axutil_env_t * env); + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_current_buffer( + guththila_t * m, + const axutil_env_t * env); + +EXTERN_C_END() +#endif + diff --git a/guththila/include/guththila_attribute.h b/guththila/include/guththila_attribute.h new file mode 100644 index 0000000..8752283 --- /dev/null +++ b/guththila/include/guththila_attribute.h @@ -0,0 +1,127 @@ + +/* + * 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. + */ +#ifndef GUTHTHILA_ATTRIBUTE_H +#define GUTHTHILA_ATTRIBUTE_H + +#include <guththila_defines.h> +#include <guththila_token.h> +#include <axutil_utils.h> + +EXTERN_C_START() + +#ifndef GUTHTHILA_ATTR_DEF_SIZE +#define GUTHTHILA_ATTR_DEF_SIZE 16 +#endif + +/* Representation of an attribute */ +typedef struct guththila_attr_s +{ + guththila_token_t *pref; /* Prefix */ + guththila_token_t *name; /* Name */ + guththila_token_t *val; /* Value */ +} guththila_attr_t; + +typedef struct guththila_attr_list_s +{ + guththila_attr_t *list; + guththila_stack_t fr_stack; + int size; + int capacity; +} guththila_attr_list_t; + +/** +* Create function of guththila_attr_list_t type structure +* @param env environment, MUST NOT be NULL. +* return new pointer to structure guththila_attr_list_s with initializing stack +* fr_stack +*/ +guththila_attr_list_t * +GUTHTHILA_CALL guththila_attr_list_create(const axutil_env_t * env); + +/** + * Initializing function of guththila_attr_list_t type structure,same + * thing done by the create method + * @param at_list keeps the list of attributes in this structure using + * a guththila_stack_t variable + * @param env environment, MUST NOT be NULL. + * return status of op AXIS2_SUCCESS on success, + * AXIS2_FAILURE on error + */ +int GUTHTHILA_CALL +guththila_attr_list_init( + guththila_attr_list_t * at_list, + const axutil_env_t * env); + +/** + * @param at_list keeps the list of attributes in this structure using + * a guththila_stack_t variable + * @param env environment, MUST NOT be NULL. + * return the top value of the stack which is inside guththila_attr_list_t + */ +guththila_attr_t * +GUTHTHILA_CALL guththila_attr_list_get(guththila_attr_list_t * at_list, + const axutil_env_t * env); + + +/** + * This method push the given attribute in to the stack which is a + * member of guththila_attr_list_t + * @param at_list keeps the list of attributes in this structure using + * a guththila_stack_t variable + * @param attr contains attribute with attribute name,value,and prefix + * @param env environment, MUST NOT be NULL. + * return status of op AXIS2_SUCCESS on success, + * AXIS2_FAILURE on error + */ +int GUTHTHILA_CALL +guththila_attr_list_release( + guththila_attr_list_t * at_list, + guththila_attr_t * attr, + const axutil_env_t * env); + +/** + * Free method for the stack which is inside guththila_attr_list_s + * structure, free the stack and other members + * @param at_list keeps the list of attributes in this structure using + * a guththila_stack_t variable + * @param env environment, MUST NOT be NULL. + * return status of op AXIS2_SUCCESS on success, + * AXIS2_FAILURE on error + */ +void GUTHTHILA_CALL +msuila_attr_list_free_data( + guththila_attr_list_t * at_list, + const axutil_env_t * env); + +/** + * Free method for guththila_attr_list_s structure,this free at_list too. + * @param at_list keeps the list of attributes in this structure using + * a guththila_stack_t variable + * @param attr contains attribute with attribute name,value,and prefix + * @param env environment, MUST NOT be NULL. + * return status of op AXIS2_SUCCESS on success, + * AXIS2_FAILURE on error + */ +void GUTHTHILA_CALL +guththila_attr_list_free( + guththila_attr_list_t * at_list, + const axutil_env_t * env); + +EXTERN_C_END() +#endif /* */ + diff --git a/guththila/include/guththila_buffer.h b/guththila/include/guththila_buffer.h new file mode 100644 index 0000000..8f94fde --- /dev/null +++ b/guththila/include/guththila_buffer.h @@ -0,0 +1,152 @@ + +/* + * 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. + */ +#ifndef GUTHTHILA_BUFFER_H +#define GUTHTHILA_BUFFER_H + +#include <guththila_defines.h> +#include <axutil_utils.h> + +EXTERN_C_START() + +typedef enum guththila_buffer_type +{ + GUTHTHILA_SINGLE_BUFFER = 0, /* One buffer */ + GUTHTHILA_MULTIPLE_BUFFER /* Mulitple buffers in a buff array */ +} guththila_buffer_type_t; + +typedef struct guththila_buffer_s +{ + /* Required to manupulate multiple buffers */ + size_t *data_size; /* Array containing filled sizes of buffers */ + size_t *buffs_size; /* Array containing actual sizes of buffers */ + guththila_char_t **buff; /* Array of buffers */ + int cur_buff; /* Current buffer */ + int cur_buff_pos; /* Position of the current buffer */ + size_t pre_tot_data; /* All the data in the previous buffers. Not include cur */ + unsigned int no_buffers; /* No of buffers */ + short type; /* Buffer type */ + guththila_char_t *xml; /* All the buffers serialized together */ +} guththila_buffer_t; + +#define GUTHTHILA_BUFFER_DEF_SIZE 16384 +#define GUTHTHILA_BUFFER_DEF_MIN_SIZE 512 +#define GUTHTHILA_BUFFER_NUMBER_OF_BUFFERS 16 + +#ifndef GUTHTHILA_BUFFER_SIZE +#define GUTHTHILA_BUFFER_SIZE(_buffer) (_buffer.size) +#endif + +#ifndef GUTHTHILA_BUFFER_CURRENT_BUFF +#define GUTHTHILA_BUFFER_CURRENT_BUFF(_buffer) ((_buffer).buff[(_buffer).cur_buff] + (_buffer).data_size[(_buffer).cur_buff]) +#endif + +#ifndef GUTHTHILA_BUFFER_CURRENT_BUFF_SIZE +#define GUTHTHILA_BUFFER_CURRENT_BUFF_SIZE(_buffer) ((_buffer).buffs_size[(_buffer).cur_buff] - (_buffer).data_size[(_buffer).cur_buff]) +#endif + +#ifndef GUTHTHILA_BUFFER_CURRENT_DATA_SIZE +#define GUTHTHILA_BUFFER_CURRENT_DATA_SIZE(_buffer) ((_buffer).data_size[(_buffer).cur_buff]) +#endif + +#ifndef GUTHTHILA_BUFFER_PRE_DATA_SIZE +#define GUTHTHILA_BUFFER_PRE_DATA_SIZE(_buffer) ((_buffer).pre_tot_data) +#endif + +/*We never consider tokens not in the current buffer*/ +#ifndef GUTHTHILA_BUF_POS +#define GUTHTHILA_BUF_POS(_buffer, _pos) ((_buffer).buff[(_buffer).cur_buff] + _pos - (_buffer).pre_tot_data) +#endif + +/** + * This method is the create method of guththila_buffer_s structure + * @param buffer structure which is going to create + * @param size size of the buffer which is going to create + * @param env environment, MUST NOT be NULL. + * return status of op AXIS2_SUCCESS on success, + * AXIS2_FAILURE on error + */ +int GUTHTHILA_CALL +guththila_buffer_init(guththila_buffer_t * buffer, + int size, + const axutil_env_t * env); + +/** + * This is the free method of guththila_buffer_s structure + * @param buffer structure which is going to create + * @param env environment, MUST NOT be NULL. + * return status of op AXIS2_SUCCESS on success, + * AXIS2_FAILURE on error + */ +int GUTHTHILA_CALL +guththila_buffer_un_init(guththila_buffer_t * buffer, + const axutil_env_t * env); + +/** + * This method creates a new buffer and copy the content of given + * data by buffer variable + * @param mu_buff structure which is going to create + * @param buffer data to copy in to new buffer + * @param size size of the buffer to create + * @param env environment, MUST NOT be NULL. + * return status of op AXIS2_SUCCESS on success, + * AXIS2_FAILURE on error + */ +int GUTHTHILA_CALL +guththila_buffer_init_for_buffer(guththila_buffer_t * mu_buff, + guththila_char_t *buffer, + int size, + const axutil_env_t * env); + +void *GUTHTHILA_CALL +guththila_get_position(guththila_buffer_t * buffer, + int pos, + const axutil_env_t * env); + +int GUTHTHILA_CALL +guththila_buffer_next(guththila_buffer_t * buffer, + const axutil_env_t * env); + + +/** + * This method create new xml element which is having the + * size of cur_buff + * data by buffer variable + * @param buffer + * @param env environment, MUST NOT be NULL. + * return xml element of guththila_buffer_s structure + */ +void *GUTHTHILA_CALL +guththila_buffer_get(guththila_buffer_t * buffer, + const axutil_env_t * env); + + +int GUTHTHILA_CALL +guththila_buffer_shift(guththila_buffer_t * buffer, + int no, const axutil_env_t * env); + +int GUTHTHILA_CALL +guththila_buffer_insert_data(guththila_buffer_t * buffer, + void *buff, size_t buff_len, + const axutil_env_t * env); + +EXTERN_C_END() +#endif + + + + diff --git a/guththila/include/guththila_defines.h b/guththila/include/guththila_defines.h new file mode 100644 index 0000000..d297f55 --- /dev/null +++ b/guththila/include/guththila_defines.h @@ -0,0 +1,73 @@ + +/* + * 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. + */ +#ifndef GUTHTHILA_DEFINES_H +#define GUTHTHILA_DEFINES_H + +#if defined(_WIN32) +#define GUTHTHILA_EXPORT __declspec(dllexport) +#else +#define GUTHTHILA_EXPORT +#endif + +#if defined(__GNUC__) +#if defined(__i386) +#define GUTHTHILA_CALL __attribute__((cdecl)) +#else +#define GUTHTHILA_CALL +#endif +#else +#if defined(__unix) +#define GUTHTHILA_CALL +#else +#define GUTHTHILA_CALL __stdcall +#endif +#endif + +#ifndef guththila_char_t +#define guththila_char_t char +#endif + +#ifndef GUTHTHILA_SUCCESS +#define GUTHTHILA_SUCCESS 1 +#endif + +#ifndef GUTHTHILA_FAILURE +#define GUTHTHILA_FAILURE 0 +#endif + +#ifdef __cplusplus +#define EXTERN_C_START() extern "C" { +#define EXTERN_C_END() } +#else +#define EXTERN_C_START() +#define EXTERN_C_END() +#endif + +#ifndef GUTHTHILA_EOF +#define GUTHTHILA_EOF (-1) +#endif + +#ifndef GUTHTHILA_FALSE +#define GUTHTHILA_FALSE 0 +#endif + +#ifndef GUTHTHILA_TRUE +#define GUTHTHILA_TRUE 1 +#endif + +#endif diff --git a/guththila/include/guththila_error.h b/guththila/include/guththila_error.h new file mode 100644 index 0000000..834e954 --- /dev/null +++ b/guththila/include/guththila_error.h @@ -0,0 +1,96 @@ + +/* + * 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 <guththila_defines.h> + +#ifndef GUTHTHILA_ERROR_H +#define GUTHTHILA_ERROR_H +EXTERN_C_START() typedef enum guththila_error_l +{ + GUTHTHILA_VALIDITY_ERROR, + GUTHTHILA_VALIDITY_WARNING, + GUTHTHILA_PARSER_ERROR, + GUTHTHILA_PARSER_WARNING +} guththila_error_level; +enum guththila_error_codes +{ + GUTHTHILA_ERROR_NONE = + 0, GUTHTHILA_ERROR_NO_MEMORY, + GUTHTHILA_ERROR_INVALID_NULL_PARAMETER, + GUTHTHILA_ERROR_INVALID_ITERATOR_STATE, + GUTHTHILA_ERROR_INVALID_NODE_TYPE, + GUTHTHILA_STREAM_WRITER_ERROR_NOT_IN_GUTHTHILA_START_ELEMENT, + GUTHTHILA_STREAM_WRITER_ERROR_WRITING_TO_STREAM, + GUTHTHILA_STREAM_WRITER_ERROR_STREAM_STRUCT_NULL, + GUTHTHILA_STREAM_WRITER_ERROR_LOCAL_NAME_NULL, + GUTHTHILA_STREAM_WRITER_ERROR_GUTHTHILA_namespace_t_NULL, + GUTHTHILA_STREAM_WRITER_ERROR_PREFIX_NULL, + GUTHTHILA_STREAM_WRITER_ERROR_GUTHTHILA_namespace_t_NOT_DECLARED, + GUTHTHILA_STREAM_WRITER_ERROR_GUTHTHILA_element_t_GUTHTHILA_stack_t_EMPTY, + GUTHTHILA_STREAM_WRITER_ERROR_ILLEGAL_STATE, + GUTHTHILA_STREAM_WRITER_ERROR_GUTHTHILA_COMMENT_NULL, + GUTHTHILA_STREAM_WRITER_ERROR_ILLEGAL_GUTHTHILA_COMMENT, + GUTHTHILA_STREAM_WRITER_ERROR_PROCESSING_INSTRUCTION_TARGET_NULL, + GUTHTHILA_STREAM_WRITER_ERROR_CDATA_NULL, + GUTHTHILA_STREAM_WRITER_ERROR_ILLEGAL_CDATA, + GUTHTHILA_STREAM_WRITER_ERROR_DTD_NULL, + GUTHTHILA_STREAM_WRITER_ERROR_ENTITY_REF_NULL, + GUTHTHILA_STREAM_WRITER_ERROR_ILLEGAL_XML_VERSION, + GUTHTHILA_STREAM_WRITER_ERROR_TEXT_NULL, + GUTHTHILA_STREAM_WRITER_ERROR_ILLEGAL_PREFIX, + GUTHTHILA_STREAM_WRITER_ERROR_OUT_OF_MEMORY, + GUTHTHILA_STREAM_WRITER_ERROR_FILE_NOT_FOUND, + GUTHTHILA_STREAM_READER_ERROR_OUT_OF_MEMORY, + GUTHTHILA_ERROR_INVALID_ENCODING_DECLARATION, + GUTHTHILA_ERROR_UNEXPECTED_UTF16_EOF, + GUTHTHILA_ERROR_UNEXPECTED_EOF, + GUTHTHILA_ERROR_PROCESS_EQUAL, + GUTHTHILA_ERROR_INCORRECT_VERSION_INFO, + GUTHTHILA_ERROR_INCORRECT_XML_DECLARATION, + GUTHTHILA_ERROR_VERSION_INFO_NOT_FOUND, + GUTHTHILA_ERROR_ENCODING_DECLARATION_ERROR, + GUTHTHILA_ERROR_STANDALONE_ERROR_IN_YES, + GUTHTHILA_ERROR_STANDALONE_ERROR_IN_NO, + GUTHTHILA_ERROR_STANDALONE_ERROR_YES_OR_NO_NOT_AVAILABLE, + GUTHTHILA_ERROR_MISSING_GREATER_SIGN_IN_XML_DECLARATION, + GUTHTHILA_ERROR_INVALID_NAME_STARTING_CHARACTER, + GUTHTHILA_ERROR_QUOTES_NOT_FOUND_BEFORE_ATTRIBUTE_VALUE, + GUTHTHILA_ERROR_EMPTY_ELEMENT_NOT_CLOSED, + GUTHTHILA_ERROR_END_TAG_NOT_CLOSED, + GUTHTHILA_ERROR_MORE_HYPENS_OCCURED_IN_COMMENT, + GUTHTHILA_ERROR_TOKENIZE_ERROR, + GUTHTHILA_ERROR_INVALID_TOKEN_TYPE, + GUTHTHILA_ERROR_NULL_ATTRIBUTE_NAME, + GUTHTHILA_ERROR_NULL_ATTRIBUTE_VALUE, + GUTHTHILA_ERROR_NULL_ATTRIBUTE_PREFIX, + GUTHTHILA_ERROR_REQUESTED_NUMBER_GREATER_THAN_STACK_SIZE, + GUTHTHILA_WRITER_ERROR_EMPTY_ARGUMENTS, + GUTHTHILA_WRITER_ERROR_NON_EXSISTING_PREFIX, + GUTHTHILA_WRITER_ERROR_EMPTY_WRITER, + GUTHTHILA_WRITER_ERROR_NON_MATCHING_ELEMENTS, + GUTHTHILA_WRITER_ERROR_INVALID_BUFFER, + GUTHTHILA_WRITER_ERROR_INVALID_CHAR_IN_NAME, + GUTHTHILA_WRITER_ERROR_XML_STRING_IN_NAME, + GUTHTHILA_WRITER_ERROR_EXCESS_HYPENS_IN_COMMENT, + GUTHTHILA_WRITER_ERROR_INVALID_CHAR_IN_ATTRIBUTE, + GUTHTHILA_WRITER_ERROR_NON_EXSISTING_URI, + GUTHTHILA_WRITER_ERROR_SAME_ATTRIBUTE_REPEAT, + GUTHTHILA_ERROR_ATTRIBUTE_FREE +}; +EXTERN_C_END() +#endif /* */ + diff --git a/guththila/include/guththila_namespace.h b/guththila/include/guththila_namespace.h new file mode 100644 index 0000000..a845665 --- /dev/null +++ b/guththila/include/guththila_namespace.h @@ -0,0 +1,76 @@ + +/* + * 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. + */ +#ifndef GUTHTHILA_NAMESPACE_H +#define GUTHTHILA_NAMESPACE_H + +#include <guththila_defines.h> +#include <guththila_token.h> +#include <axutil_utils.h> +EXTERN_C_START() + +#ifndef GUTHTHILA_NAMESPACE_DEF_SIZE +#define GUTHTHILA_NAMESPACE_DEF_SIZE 4 +#endif + +typedef struct guththila_namespace_s +{ + guththila_token_t *name; /* Name */ + guththila_token_t *uri; /* URI */ +} guththila_namespace_t; + +typedef struct guththila_namespace_list_s +{ + guththila_namespace_t *list; + guththila_stack_t fr_stack; + int size; + int capacity; +} guththila_namespace_list_t; + +guththila_namespace_list_t *GUTHTHILA_CALL +guththila_namespace_list_create( + const axutil_env_t * env); + +int GUTHTHILA_CALL +guththila_namespace_list_init( + guththila_namespace_list_t * at_list, + const axutil_env_t * env); + +guththila_namespace_t * GUTHTHILA_CALL +guththila_namespace_list_get( + guththila_namespace_list_t *at_list, + const axutil_env_t * env); + +int GUTHTHILA_CALL +guththila_namespace_list_release( + guththila_namespace_list_t * at_list, + guththila_namespace_t * namesp, + const axutil_env_t * env); + +void GUTHTHILA_CALL +msuila_namespace_list_free_data( + guththila_namespace_list_t * at_list, + const axutil_env_t * env); + +void GUTHTHILA_CALL +guththila_namespace_list_free( + guththila_namespace_list_t * at_list, + const axutil_env_t * env); + +EXTERN_C_END() +#endif + diff --git a/guththila/include/guththila_reader.h b/guththila/include/guththila_reader.h new file mode 100644 index 0000000..cad53a1 --- /dev/null +++ b/guththila/include/guththila_reader.h @@ -0,0 +1,115 @@ + +/* + * 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. + */ +#ifndef GUTHTHILA_READER_H +#define GUTHTHILA_READER_H + +#include <stdio.h> +#include <guththila_defines.h> +#include <axutil_utils.h> + +EXTERN_C_START() + +typedef int(GUTHTHILA_CALL * GUTHTHILA_READ_INPUT_CALLBACK)( + guththila_char_t *buffer, + int size, + void *ctx); + +enum guththila_reader_type +{ + GUTHTHILA_FILE_READER = 1, + GUTHTHILA_IO_READER, + GUTHTHILA_MEMORY_READER +}; + +typedef struct guththila_reader_s +{ + int type; /* Type of reader */ + FILE *fp; /* File pointer */ + guththila_char_t *buff; /* Buffer */ + int buff_size; /* Buff size */ + GUTHTHILA_READ_INPUT_CALLBACK input_read_callback; /* Call back */ + void *context; /* Context */ +} guththila_reader_t; + +#ifndef GUTHTHILA_READER_SET_LAST_START +#define GUTHTHILA_READER_SET_LAST_START(_reader, _start) ((_reader)->start = _start) +#endif + +#ifndef GUTHTHILA_READER_STEP_BACK +#define GUTHTHILA_READER_STEP_BACK(_reader) ((_reader->next--)) +#endif + +/* + * Reading a file. + * @param filename name of the file + * @param env environment + */ +GUTHTHILA_EXPORT guththila_reader_t * GUTHTHILA_CALL +guththila_reader_create_for_file(guththila_char_t *filename, + const axutil_env_t * env); + +/* + * Reading from a call back function. + * @param input_read_callback function pointer to read data + * @param ctx context + * @param env environment + */ +GUTHTHILA_EXPORT guththila_reader_t * GUTHTHILA_CALL +guththila_reader_create_for_io(GUTHTHILA_READ_INPUT_CALLBACK + input_read_callback, void *ctx, + const axutil_env_t * env); + +/* + * Reading from memory buffer. + * @param buffer buffer + * @param size size of the buffer + * @param env environment + */ +GUTHTHILA_EXPORT guththila_reader_t * GUTHTHILA_CALL +guththila_reader_create_for_memory(void *buffer, + int size, + const axutil_env_t * env); + +/* + * Read the specified number of character to the given buffer. + * @param r reader + * @param buffer buffer to place the read data + * @param offset position to place the data on the given buffer + * @param length number of bytes to read + * @param env environment + * @return number of bytes put in to the buffer. -1 if end of the read. + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_reader_read( + guththila_reader_t * r, + guththila_char_t * buffer, + int offset, + int length, + const axutil_env_t * env); + +/* + * Free the reader. + * @param r reader + * @param env environment + */ +GUTHTHILA_EXPORT void GUTHTHILA_CALL guththila_reader_free( + guththila_reader_t * r, + const axutil_env_t * env); + +EXTERN_C_END() +#endif /* */ + diff --git a/guththila/include/guththila_stack.h b/guththila/include/guththila_stack.h new file mode 100644 index 0000000..3520d73 --- /dev/null +++ b/guththila/include/guththila_stack.h @@ -0,0 +1,96 @@ + +/* + * 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. + */ +#ifndef GUTHTHILA_STACK_H +#define GUTHTHILA_STACK_H + +#include <stdio.h> +#include <stdlib.h> + +#include <guththila_defines.h> +#include <axutil_utils.h> +#define GUTHTHILA_STACK_DEFAULT 16 + +EXTERN_C_START() + +typedef struct guththila_stack_s +{ + /* Number of Items in the stack */ + int top; + /* Max number of Items that can be hold in data */ + int max; + void ** data; +} guththila_stack_t; + +#ifndef GUTHTHILA_STACK_SIZE +#define GUTHTHILA_STACK_SIZE(_stack) ((_stack).top) +#endif + +#ifndef GUTHTHILA_STACK_TOP_INDEX +#define GUTHTHILA_STACK_TOP_INDEX(_stack) (((_stack).top - 1)) +#endif + +int GUTHTHILA_CALL +guththila_stack_init( + guththila_stack_t * stack, + const axutil_env_t * env); + +void GUTHTHILA_CALL +guththila_stack_free( + guththila_stack_t * stack, + const axutil_env_t * env); + +void GUTHTHILA_CALL +guththila_stack_un_init( + guththila_stack_t * stack, + const axutil_env_t * env); + +void * GUTHTHILA_CALL +guththila_stack_pop( + guththila_stack_t * stack, + const axutil_env_t * env); + +int GUTHTHILA_CALL +guththila_stack_push( + guththila_stack_t * stack, + void *data, + const axutil_env_t * env); + +void * GUTHTHILA_CALL +guththila_stack_peek( + guththila_stack_t * stack, + const axutil_env_t * env); + +void * GUTHTHILA_CALL +guththila_stack_get_by_index( + guththila_stack_t * stack, + int index, + const axutil_env_t * env); + +int GUTHTHILA_CALL +guththila_stack_del_top( + guththila_stack_t * stack, + const axutil_env_t * env); + +int GUTHTHILA_CALL +guththila_stack_is_empty( + guththila_stack_t * stack, + const axutil_env_t * env); + +EXTERN_C_END() +#endif + diff --git a/guththila/include/guththila_token.h b/guththila/include/guththila_token.h new file mode 100644 index 0000000..ae8719c --- /dev/null +++ b/guththila/include/guththila_token.h @@ -0,0 +1,174 @@ + +/* + * 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. + */ +#ifndef GUTHTHILA_TOKEN_H +#define GUTHTHILA_TOKEN_H + +#include <guththila_defines.h> +#include <guththila_stack.h> + +EXTERN_C_START() + +typedef struct guththila_token_s +{ + short type; + guththila_char_t *start; + int _start; + size_t size; + int last; + int ref; +} guththila_token_t; + +enum guththila_token_type +{ + _Unknown = 1, + _name, + _attribute_name, + _attribute_value, + _prefix, + _char_data, + _text_data +}; + +typedef struct guththila_tok_list_s +{ + guththila_stack_t fr_stack; + guththila_token_t **list; + int no_list; + int cur_list; + int *capacity; +} guththila_tok_list_t; + +#ifndef GUTHTHILA_TOK_DEF_SIZE +#define GUTHTHILA_TOK_DEF_SIZE 16 +#endif + +#ifndef GUTHTHILA_TOK_DEF_LIST_SIZE +#define GUTHTHILA_TOK_DEF_LIST_SIZE 16 +#endif + +#ifndef GUTHTHILA_TOKEN_LEN +#define GUTHTHILA_TOKEN_LEN(tok) (tok->size) +#endif + +#ifndef GUTHTHILA_TOKEN_TO_STRING +#define GUTHTHILA_TOKEN_TO_STRING(tok, string, _env) \ + { \ + string = (guththila_char_t *) AXIS2_MALLOC(_env->allocator, (GUTHTHILA_TOKEN_LEN(tok) + 1) * sizeof(guththila_char_t)); \ + memcpy(string, (tok)->start, GUTHTHILA_TOKEN_LEN(tok)); \ + string[GUTHTHILA_TOKEN_LEN(tok)] = 0; \ + } +#endif + +/* + * Initialize token list. + */ +int GUTHTHILA_CALL +guththila_tok_list_init( + guththila_tok_list_t * tok_list, + const axutil_env_t * env); + +/* + * Free the token list. Allocated tokens are not free. + */ +void GUTHTHILA_CALL +guththila_tok_list_free( + guththila_tok_list_t * tok_list, + const axutil_env_t * env); + +/* + * Get a token from the list. + */ +guththila_token_t * +GUTHTHILA_CALL guththila_tok_list_get_token( + guththila_tok_list_t * tok_list, + const axutil_env_t * env); + +/* + * Release a token to the token list. + */ +int GUTHTHILA_CALL +guththila_tok_list_release_token( + guththila_tok_list_t * tok_list, + guththila_token_t * token, + const axutil_env_t * env); + +/* + * Free the tokens in the token list. + */ +void GUTHTHILA_CALL +guththila_tok_list_free_data( + guththila_tok_list_t * tok_list, + const axutil_env_t * env); + +/* + * Grow the token list. + */ +int GUTHTHILA_CALL +guththila_tok_list_grow( + guththila_tok_list_t * tok_list, + const axutil_env_t * env); + +/* + * Compare a token with a string. + * Return 0 if match. + */ +int GUTHTHILA_CALL +guththila_tok_str_cmp( + guththila_token_t * tok, + guththila_char_t *str, + size_t str_len, + const axutil_env_t * env); + +/* + * Compare two tokens for string equalance + * Return 0 if match. + */ +int GUTHTHILA_CALL +guththila_tok_tok_cmp( + guththila_token_t * tok1, + guththila_token_t * tok2, + const axutil_env_t * env); + +void GUTHTHILA_CALL +guththila_set_token( + guththila_token_t* tok, + guththila_char_t* start, + short type, + int size, + int _start, + int last, + int ref, + const axutil_env_t* env); + +EXTERN_C_END() +#endif + + + + + + + + + + + + + + + diff --git a/guththila/include/guththila_xml_writer.h b/guththila/include/guththila_xml_writer.h new file mode 100644 index 0000000..afc5a26 --- /dev/null +++ b/guththila/include/guththila_xml_writer.h @@ -0,0 +1,507 @@ + +/* + * 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. + */ +#ifndef GUTHTHILA_XML_WRITER_H +#define GUTHTHILA_XML_WRITER_H + +#include <guththila_token.h> +#include <guththila_defines.h> +#include <guththila_buffer.h> +#include <guththila.h> +#include <axutil_utils.h> + +EXTERN_C_START() +#define GUTHTHILA_XML_WRITER_TOKEN + +/* +Design notes:- +namesp member of guththila_xml_writer_s is populated with malloc created objects. +Providing a list for this seems expensive because most of the times only few +namespaces are present in a XML document. + +element member of guththila_xml_writer_s must be povided the list capablity. This +is particularly important in very deep XML documents. +*/ +typedef enum guththila_writer_type_s +{ + GUTHTHILA_WRITER_FILE = 1, + GUTHTHILA_WRITER_MEMORY +} guththila_writer_type_t; + +typedef struct guththila_writer_s +{ + short type; + FILE *out_stream; + guththila_buffer_t *buffer; + int next; +} +guththila_writer_t; + +typedef enum guththila_writer_status_s +{ + /*Started writing a non empty element */ + START = 1, + /*Started writing a empty element */ + START_EMPTY, + /*We are in a position to begin wrting an element */ + BEGINING +} guththila_writer_status_t; + +/*Main structure which provides the writer capability*/ +typedef struct guththila_xml_writer_s +{ + guththila_stack_t element; + guththila_stack_t namesp; + guththila_writer_t *writer; +#ifdef GUTHTHILA_XML_WRITER_TOKEN + guththila_tok_list_t tok_list; +#endif + /* Type of this writer. Can be file writer or memory writer */ + guththila_writer_type_t type; + + FILE *out_stream; + guththila_buffer_t buffer; + guththila_writer_status_t status; + int next; +} guththila_xml_writer_t; + +/*TODO: we need to came up with common implementation of followng two structures in writer and reader*/ + +/* +This is a private structure for keeping track of the elements. When we start to write an element this structure will be pop +*/ +typedef struct guththila_xml_writer_element_s +{ +#ifdef GUTHTHILA_XML_WRITER_TOKEN + guththila_token_t *prefix; + guththila_token_t *name; +#else + guththila_char_t *prefix; + guththila_char_t *name; +#endif + /* contains the number of the stack which holds the namespaces + for this element. When we close this element all the namespaces + that are below this should also must be closed */ + int name_sp_stack_no; +} +guththila_xml_writer_element_t; + +typedef struct guththila_xml_writer_namesp_s +{ + /* These are double pointers because a single element may contain multple + namespace declarations */ +#ifdef GUTHTHILA_XML_WRITER_TOKEN + guththila_token_t **name; + guththila_token_t **uri; +#else + guththila_char_t **name; + guththila_char_t **uri; +#endif + int no; /*number of namespaces */ + int size; +} +guththila_xml_writer_namesp_t; + +#define GUTHTHILA_XML_WRITER_NAMESP_DEF_SIZE 4 + +/*Writer functions*/ + +/* + * Create a writer which writes to a file. + * @param file_name name of the file + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT guththila_xml_writer_t *GUTHTHILA_CALL +guththila_create_xml_stream_writer( + char *file_name, + const axutil_env_t * env); + +/* + * Create a writer which writes to a memory buffer. + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT guththila_xml_writer_t *GUTHTHILA_CALL +guththila_create_xml_stream_writer_for_memory( + const axutil_env_t * env); + +/* + * Jus write what ever the content in the buffer. If the writer was in + * a start of a element it will close it. + * @param wr pointer to the writer + * @param buff buffer containing the data + * @param size size of the buffer + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_to_buffer( + guththila_xml_writer_t * wr, + char *buff, + int size, + const axutil_env_t * env); + +/* + * Write the name space with the given prifix and namespace. + * @param wr pointer to the writer + * @param prefix prefix of the namespace + * @param uri uri of the namespace + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_namespace( + guththila_xml_writer_t * wr, + char *prefix, + char *uri, + const axutil_env_t * env); + +/* + * Write the name space with the given prifix and namespace. + * @param wr pointer to the writer + * @param prefix prefix of the namespace + * @param uri uri of the namespace + * @param local_name name of the attribute + * @param value value of the attribute + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_do_write_attribute_with_prefix_and_namespace( + guththila_xml_writer_t * wr, + char *prefix, + char *uri, + char *local_name, + char *value, + const axutil_env_t * env); + + +/* + * Write the start document element with the xml version and encoding. + * @param wr pointer to the writer + * @param env pointer to the environment + * @param encoding encoding of the XML. + * @param version xml version + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_start_document( + guththila_xml_writer_t * wr, + const axutil_env_t * env, + char *encoding, + char *version); + +/* + * Write the start element. + * @param wr pointer to the writer + * @param name name of the element + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_start_element( + guththila_xml_writer_t * wr, + char *name, + const axutil_env_t * env); + +/* + * Write the end element. + * @param wr pointer to the writer + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_end_element( + guththila_xml_writer_t * wr, + const axutil_env_t * env); + +/* + * Not implemented. + * @param wr pointer to the writer + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_close( + guththila_xml_writer_t * wr, + const axutil_env_t * env); + +/* + * Write the text content of a element. + * @param wr pointer to the writer + * @param buff character string + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_characters( + guththila_xml_writer_t * wr, + char *buff, + const axutil_env_t * env); + +/* + * Write comment with the given text data. + * @param wr pointer to the writer + * @param buff character string + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_comment( + guththila_xml_writer_t * wr, + char *buff, + const axutil_env_t * env); + +/* + * Write scape character. + * @param wr pointer to the writer + * @param buff character string + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_escape_character( + guththila_xml_writer_t * wr, + char *buff, + const axutil_env_t * env); + +/* + * Start to write an empty element with the given name. + * @param wr pointer to the writer + * @param name name of the element + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_empty_element( + guththila_xml_writer_t * wr, + char *name, + const axutil_env_t * env); + +/* + * Write a defualt namespace. + * @param wr pointer to the writer + * @param uri uri of the namespace + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_default_namespace( + guththila_xml_writer_t * wr, + char *uri, + const axutil_env_t * env); + +/* + * Write a attribute with the given name and value. + * @param wr pointer to the writer + * @param localname name of the attribute + * @param value value of the attribute + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_attribute( + guththila_xml_writer_t * wr, + char *localname, + char *value, + const axutil_env_t * env); + +/* + * Write a attribute with the given name and value and namespace. + * @param wr pointer to the writer + * @param prefix prefix of the attribute + * @param namespace_uri uri of the namespace + * @param localname name of the attribute + * @param value value of the attribute + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_attribute_with_prefix_and_namespace( + guththila_xml_writer_t * wr, + char *prefix, + char *namespace_uri, + char *localname, + char *value, + const axutil_env_t * env); + +/* + * Write a attribute with the given name, value and prefix. If the prefix + * is not defined previously as a namespace this method will fail. + * @param wr pointer to the writer + * @param prefix prefix of the attribute + * @param localname name of the attribute + * @param value value of the attribute + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_attribute_with_prefix( + guththila_xml_writer_t * wr, + char *prefix, + char *localname, + char *value, + const axutil_env_t * env); + +/* + * Write a attribute with the given name, value and namespace uri. + * If the namespace is not defined previously as a namespace this + * method will fail. The prefix corresponding to the namespace uri + * will be used. + * @param wr pointer to the writer + * @param namesp namespace uri + * @param localname name of the attribute + * @param value value of the attribute + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_attribute_with_namespace( + guththila_xml_writer_t * wr, + char *namesp, + char *localname, + char *value, + const axutil_env_t * env); + +/* + * Write a start element with prefix and namespace. If the namespace is not + * defined previoully new namespace will be written. + * @param wr pointer to the writer + * @param prefix prefix of the attribute + * @param namespace_uri uri + * @param localname name of the attribute + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_start_element_with_prefix_and_namespace( + guththila_xml_writer_t * wr, + char *prefix, + char *namespace_uri, + char *local_name, + const axutil_env_t * env); + +/* + * Write a start element with the namespace. If the namespace is not + * defined previously method will fail. + * @param wr pointer to the writer + * @param namespace_uri uri + * @param localname name of the attribute + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_start_element_with_namespace( + guththila_xml_writer_t * wr, + char *namespace_uri, + char *local_name, + const axutil_env_t * env); + +/* + * Write a start element with the prefix. If the prefix is not + * defined previously method will fail. + * @param wr pointer to the writer + * @param namespace_uri uri + * @param localname name of the attribute + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_start_element_with_prefix( + guththila_xml_writer_t * wr, + char *prefix, + char *local_name, + const axutil_env_t * env); + +/* + * Write a empty element with prefix and namespace. If the namespace is not + * defined previoully new namespace will be written. + * @param wr pointer to the writer + * @param prefix prefix of the attribute + * @param namespace_uri uri + * @param localname name of the attribute + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_empty_element_with_prefix_and_namespace( + guththila_xml_writer_t * wr, + char *prefix, + char *namespace_uri, + char *local_name, + const axutil_env_t * env); + +/* + * Write a empty element with the namespace. If the namespace is not + * defined previously method will fail. + * @param wr pointer to the writer + * @param namespace_uri uri + * @param localname name of the attribute + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_empty_element_with_namespace( + guththila_xml_writer_t * wr, + char *namespace_uri, + char *local_name, + const axutil_env_t * env); + +/* + * Write a empty element with the prefix. If the prefix is not + * defined previously method will fail. + * @param wr pointer to the writer + * @param namespace_uri uri + * @param localname name of the attribute + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_write_empty_element_with_prefix( + guththila_xml_writer_t * wr, + char *prefix, + char *local_name, + const axutil_env_t * env); + +/* + * Close all the elements that were started by writing the end elements. + * @param wr pointer to the writer + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_end_document( + guththila_xml_writer_t * wr, + const axutil_env_t * env); +/* + * Write a new element with the name, then write the characters as text, + * then close the element and write a new line. + * @param wr pointer to the writer + * @element_name name of the element + * @characters text of the new element + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL guththila_write_line( + guththila_xml_writer_t * wr, + char *element_name, + char *characters, + const axutil_env_t * env); + +/* + * Get the memory buffer that is written. + * @param wr pointer to the writer + * @param env pointer to the environment + * @return memory buffer + */ +GUTHTHILA_EXPORT char *GUTHTHILA_CALL guththila_get_memory_buffer( + guththila_xml_writer_t * wr, + const axutil_env_t * env); + +/* + * Get the size of the memory buffer. + * @param wr pointer to the writer + * @param env pointer to the environment + * @return size of the buffer + */ +GUTHTHILA_EXPORT unsigned int GUTHTHILA_CALL +guththila_get_memory_buffer_size( + guththila_xml_writer_t * wr, + const axutil_env_t * env); + +/* + * Free the writer. + * @param wr pointer to the writer + * @param env pointer to the environment + */ +GUTHTHILA_EXPORT void GUTHTHILA_CALL guththila_xml_writer_free( + guththila_xml_writer_t * wr, + const axutil_env_t * env); +/* + * Get the prefix for the namespace. + * @param wr pointer to the writer + * @namespace namespace uri + * @param env pointer to the environment + * @return prefix for the namspace uri + */ +GUTHTHILA_EXPORT char *GUTHTHILA_CALL guththila_get_prefix_for_namespace( + guththila_xml_writer_t * wr, + char *namespace, + const axutil_env_t * env); + +EXTERN_C_END() +#endif diff --git a/guththila/samples/guththila_main.c b/guththila/samples/guththila_main.c new file mode 100644 index 0000000..687e490 --- /dev/null +++ b/guththila/samples/guththila_main.c @@ -0,0 +1,186 @@ +/* + * 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 "guththila.h" +#include "guththila_defines.h" + +int +main( + int argc, + char *argv[]) +{ + int c; + axutil_allocator_t *allocator; + guththila_reader_t *red; + axutil_env_t *environment; + guththila_t *parser; + char *xml_buffer; + allocator = axutil_allocator_init(NULL); + xml_buffer + = "<?xml version = \"1.0\"?><test a=\"din\">addddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddddd123</test>"; + environment = axutil_env_create(allocator); + + if(argc > 1) + red = guththila_reader_create_for_file(environment, argv[1]); + else + { + if(xml_buffer) + { + int size = 0; + size = strlen(xml_buffer); + red = guththila_reader_create_for_memory(environment, (void *)xml_buffer, size, NULL); + } + } + + parser = guththila_create(environment, red); + guththila_read(environment, parser); + + while((c = guththila_next(environment, parser)) != -1) + { + switch(c) + { + case GUTHTHILA_START_DOCUMENT: + { + int ix; + printf("<?xml "); + + ix = guththila_get_attribute_count(environment, parser); + for(; ix > 0; ix--) + { + guththila_attribute_t *a; + char *p; + a = guththila_get_attribute(environment, parser); + p = guththila_get_attribute_name(environment, parser, a); + printf("%s=\"", p); + AXIS2_FREE(allocator, p); + p = guththila_get_attribute_value(environment, parser, a); + printf("%s\" ", p); + AXIS2_FREE(allocator, p); + guththila_attribute_free(environment, a); + } + printf("?>\n"); + } + break; + case GUTHTHILA_START_ELEMENT: + case GUTHTHILA_EMPTY_ELEMENT: + { + int ia; + int d; + char *p; + guththila_depth_t *depth; + + printf("<"); + p = guththila_get_prefix(environment, parser); + if(p) + { + printf("%s:", p); + AXIS2_FREE(allocator, p); + } + p = guththila_get_name(environment, parser); + printf("%s", p); + AXIS2_FREE(allocator, p); + + ia = guththila_get_attribute_count(environment, parser); + for(; ia > 0; ia--) + { + /* p = guththila_get_attribute_prefix_by_number + (parser, ia); */ + p = guththila_get_attribute_prefix_by_number(environment, parser, ia); + if(p) + { + printf(" %s:", p); + AXIS2_FREE(allocator, p); + p = guththila_get_attribute_name_by_number(environment, parser, ia); + printf("%s=\"", p); + AXIS2_FREE(allocator, p); + p = guththila_get_attribute_value_by_number(environment, parser, ia); + printf("%s\"", p); + AXIS2_FREE(allocator, p); + } + else + { + p = guththila_get_attribute_name_by_number(environment, parser, ia); + printf(" %s=\"", p); + AXIS2_FREE(allocator, p); + p = guththila_get_attribute_value_by_number(environment, parser, ia); + printf("%s\"", p); + AXIS2_FREE(allocator, p); + } + } + depth = (guththila_depth_t *)axutil_stack_get(parser->dep, environment); + d = depth->count; + for(; d > 0; d--) + { + p = guththila_get_namespace_prefix_by_number(environment, parser, d); + if(strncmp(p, "xmlns", 5)) + { + printf(" xmlns:"); + printf("%s=\"", p); + } + else + printf(" xmlns=\""); + AXIS2_FREE(allocator, p); + p = guththila_get_namespace_uri_by_number(environment, parser, d); + printf("%s\"", p); + AXIS2_FREE(allocator, p); + } + if(parser->guththila_event == GUTHTHILA_START_ELEMENT) + printf(">"); + else if(parser->guththila_event == GUTHTHILA_EMPTY_ELEMENT) + printf("/>"); + else + printf("error \n"); + + } + break; + case GUTHTHILA_END_ELEMENT: + { + char *p; + printf("</"); + p = guththila_get_prefix(environment, parser); + if(p) + { + printf("%s:", p); + AXIS2_FREE(allocator, p); + } + p = guththila_get_name(environment, parser); + printf("%s", p); + AXIS2_FREE(allocator, p); + printf(">"); + } + break; + case GUTHTHILA_CHARACTER: + { + char *p = NULL; + p = guththila_get_value(environment, parser); + /* if (!parser->is_whitespace) */ + /* { */ + /* printf(p); */ + /* } */ + printf("%s", p); + AXIS2_FREE(allocator, p); + } + break; + case GUTHTHILA_COMMENT: + break; + }; + } + guththila_reader_free(environment, red); + guththila_free(environment, parser); + axutil_env_free(environment); + return 0; +} diff --git a/guththila/samples/guththila_writer_main.c b/guththila/samples/guththila_writer_main.c new file mode 100644 index 0000000..9dc1218 --- /dev/null +++ b/guththila/samples/guththila_writer_main.c @@ -0,0 +1,71 @@ +/* + * 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 <guththila_buffer.h> +#include <guththila_reader.h> +#include <guththila_writer.h> +#include <guththila.h> +#include <axis2_util.h> +#define MAXA 100000 +int +main( + int argc, + char *argv[]) +{ + char *t; + axutil_allocator_t *allocator; + axutil_env_t *env; + guththila_t *parser; + char *xml = NULL; + FILE *file = NULL; + allocator = axutil_allocator_init(NULL); + env = axutil_env_create(allocator); + parser = guththila_create(env, NULL); + guththila_create_xml_stream_writer_for_memory(env, parser); + guththila_write_start_element(env, parser, "two"); + guththila_write_default_namespace(env, parser, "http://another.host.com"); + guththila_write_start_element_with_prefix_and_namespace(env, parser, "ws", + "http://www.wso2.org", "wso2"); + guththila_write_start_element_with_prefix(env, parser, "ws", "stacks"); + guththila_write_attribute_with_prefix(env, parser, "ws", "stack", "axis2"); + guththila_write_characters(env, parser, + "testadfjaldjf;ajf;lkajdfa;lkjfd;ajdf11111111111122334455"); + guththila_write_end_document(env, parser); + + xml = (char *)AXIS2_MALLOC(env->allocator, MAXA + 1); + memset(xml, 0, MAXA + 1); + if(!argv[1]) + { + file = fopen("/home/dinesh/tmp/mbox_backup/mbox.archived", "r"); + } + else + file = fopen(argv[1], "r"); + + if(file) + fread(xml, 1, MAXA, file); + + guththila_write_to_buffer(env, parser, xml); + t = guththila_writer_get_buffer(env, parser->xsw->writer); + printf("%s \n", t); + free(xml); + fclose(file); + guththila_xml_writer_free(env, parser); + guththila_free(env, parser); + axutil_env_free(env); + return 0; +} diff --git a/guththila/src/Makefile.am b/guththila/src/Makefile.am new file mode 100644 index 0000000..f738e48 --- /dev/null +++ b/guththila/src/Makefile.am @@ -0,0 +1,18 @@ +lib_LTLIBRARIES = libguththila.la + +libguththila_la_LDFLAGS = -version-info $(VERSION_NO) + +libguththila_la_SOURCES = guththila_buffer.c \ + guththila_namespace.c \ + guththila_token.c \ + guththila_reader.c \ + guththila_attribute.c \ + guththila_xml_parser.c \ + guththila_stack.c \ + guththila_xml_writer.c + +libguththila_la_LIBADD = ../../util/src/libaxutil.la + +INCLUDES = -I$(top_builddir)/include \ + -I ../../util/include + diff --git a/guththila/src/guththila_attribute.c b/guththila/src/guththila_attribute.c new file mode 100644 index 0000000..f13ca34 --- /dev/null +++ b/guththila/src/guththila_attribute.c @@ -0,0 +1,144 @@ +/* + * 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 <guththila_attribute.h> +#include <guththila_stack.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +int GUTHTHILA_CALL +guththila_attr_list_grow( + guththila_attr_list_t * at_list, + int addition, + const axutil_env_t * env) +{ + int i = 0; + + if(addition > 0 || (addition < 0 && at_list->capacity + addition > 0 && at_list->capacity + + addition >= at_list->size)) + { + at_list->list = (guththila_attr_t *)realloc(at_list->list, sizeof(guththila_attr_t) + * (at_list->capacity + addition)); + + if(at_list->list) + { + for(i = at_list->capacity; i < at_list->capacity + addition; i++) + { + guththila_stack_push(&at_list->fr_stack, at_list->list + i, env); + } + + at_list->capacity += addition; + } + else + { + return GUTHTHILA_FAILURE; + } + } + return 0; +} + +guththila_attr_list_t *GUTHTHILA_CALL +guththila_attr_list_create( + const axutil_env_t * env) +{ + int i = 0; + guththila_attr_list_t * at_list = (guththila_attr_list_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_attr_list_t)); + + if(!at_list) + return NULL; + + at_list->list = (guththila_attr_t *)AXIS2_MALLOC(env->allocator, sizeof(guththila_attr_t) + * GUTHTHILA_ATTR_DEF_SIZE); + + if(at_list->list && guththila_stack_init(&at_list->fr_stack, env)) + { + at_list->capacity = GUTHTHILA_ATTR_DEF_SIZE; + at_list->size = 0; + for(i = 0; i < GUTHTHILA_ATTR_DEF_SIZE; i++) + { + guththila_stack_push(&at_list->fr_stack, at_list->list + i, env); + } + return at_list; + } + return NULL; +} + +int GUTHTHILA_CALL +guththila_attr_list_init( + guththila_attr_list_t * at_list, + const axutil_env_t * env) +{ + int i = 0; + at_list->list = (guththila_attr_t *)AXIS2_MALLOC(env->allocator, sizeof(guththila_attr_t) + * GUTHTHILA_ATTR_DEF_SIZE); + + if(at_list->list && guththila_stack_init(&at_list->fr_stack, env)) + { + at_list->capacity = GUTHTHILA_ATTR_DEF_SIZE; + at_list->size = 0; + for(i = 0; i < GUTHTHILA_ATTR_DEF_SIZE; i++) + { + guththila_stack_push(&at_list->fr_stack, at_list->list + i, env); + } + return GUTHTHILA_SUCCESS; + } + return GUTHTHILA_FAILURE; +} + +guththila_attr_t *GUTHTHILA_CALL +guththila_attr_list_get( + guththila_attr_list_t * at_list, + const axutil_env_t * env) +{ + if(at_list->fr_stack.top > 0 || guththila_attr_list_grow(at_list, GUTHTHILA_ATTR_DEF_SIZE, env)) + { + return guththila_stack_pop(&at_list->fr_stack, env); + } + + return NULL; +} + +int GUTHTHILA_CALL +guththila_attr_list_release( + guththila_attr_list_t * at_list, + guththila_attr_t * attr, + const axutil_env_t * env) +{ + + return guththila_stack_push(&at_list->fr_stack, attr, env); + +} + +void GUTHTHILA_CALL +msuila_attr_list_free_data( + guththila_attr_list_t * at_list, + const axutil_env_t * env) +{ + AXIS2_FREE(env->allocator, at_list->list); + guththila_stack_un_init(&at_list->fr_stack, env); +} + +void GUTHTHILA_CALL +guththila_attr_list_free( + guththila_attr_list_t * at_list, + const axutil_env_t * env) +{ + AXIS2_FREE(env->allocator, at_list->list); + guththila_stack_un_init(&at_list->fr_stack, env); + AXIS2_FREE(env->allocator, at_list); +} diff --git a/guththila/src/guththila_buffer.c b/guththila/src/guththila_buffer.c new file mode 100644 index 0000000..77f97f4 --- /dev/null +++ b/guththila/src/guththila_buffer.c @@ -0,0 +1,134 @@ +/* + * 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_buffer.h> + +int GUTHTHILA_CALL +guththila_buffer_init( + guththila_buffer_t * buffer, + int size, + const axutil_env_t * env) +{ + + buffer->type = GUTHTHILA_MULTIPLE_BUFFER; + buffer->data_size = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) + * GUTHTHILA_BUFFER_NUMBER_OF_BUFFERS); + buffer->buffs_size = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) + * GUTHTHILA_BUFFER_NUMBER_OF_BUFFERS); + buffer->buff = (guththila_char_t **)AXIS2_MALLOC(env->allocator, sizeof(guththila_char_t *) + * GUTHTHILA_BUFFER_NUMBER_OF_BUFFERS); + buffer->cur_buff = -1; + buffer->pre_tot_data = 0; + buffer->no_buffers = GUTHTHILA_BUFFER_NUMBER_OF_BUFFERS; + buffer->xml = NULL; + if(size > 0) + { + buffer->buff[0] = (guththila_char_t *)AXIS2_MALLOC(env->allocator, sizeof(guththila_char_t) + * size); + buffer->data_size[0] = 0; + buffer->buffs_size[0] = size; + buffer->cur_buff = 0; + } + return GUTHTHILA_SUCCESS; +} + +int GUTHTHILA_CALL +guththila_buffer_un_init( + guththila_buffer_t * buffer, + const axutil_env_t * env) +{ + int i = 0; + + if(buffer->type == GUTHTHILA_SINGLE_BUFFER && buffer->buff && buffer->cur_buff == 0) + { + + if(buffer->buffs_size) + AXIS2_FREE(env->allocator, buffer->buffs_size); + if(buffer->data_size) + AXIS2_FREE(env->allocator, buffer->data_size); + if(buffer->xml) + AXIS2_FREE(env->allocator, buffer->xml); + + AXIS2_FREE(env->allocator, buffer->buff); + + } + else if(buffer->type == GUTHTHILA_MULTIPLE_BUFFER && buffer->buff) + { + for(i = 0; i <= buffer->cur_buff; i++) + { + AXIS2_FREE(env->allocator, buffer->buff[i]); + } + if(buffer->xml) + AXIS2_FREE(env->allocator, buffer->xml); + AXIS2_FREE(env->allocator, buffer->buff); + if(buffer->data_size) + AXIS2_FREE(env->allocator, buffer->data_size); + if(buffer->buffs_size) + AXIS2_FREE(env->allocator, buffer->buffs_size); + } + return GUTHTHILA_SUCCESS; +} + +int GUTHTHILA_CALL +guththila_buffer_init_for_buffer( + guththila_buffer_t * buffer, + char *buff, + int size, + const axutil_env_t * env) +{ + buffer->type = GUTHTHILA_SINGLE_BUFFER; + buffer->buff + = (char **)AXIS2_MALLOC(env->allocator, sizeof(char *) * GUTHTHILA_BUFFER_DEF_SIZE); + buffer->buff[0] = buff; + buffer->cur_buff = 0; + buffer->buffs_size = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) + * GUTHTHILA_BUFFER_DEF_SIZE); + buffer->buffs_size[0] = size; + buffer->pre_tot_data = 0; + buffer->data_size = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) + * GUTHTHILA_BUFFER_DEF_SIZE); + buffer->data_size[0] = size; + buffer->no_buffers = 1; + buffer->xml = NULL; + return GUTHTHILA_SUCCESS; +} + +void *GUTHTHILA_CALL +guththila_buffer_get( + guththila_buffer_t * buffer, + const axutil_env_t * env) +{ + size_t size = 0, current_size = 0; + int i = 0; + + for(i = 0; i <= buffer->cur_buff; i++) + { + size += buffer->data_size[i]; + } + buffer->xml = (char *)AXIS2_MALLOC(env->allocator, sizeof(char) * (size + 1)); + for(i = 0; i <= buffer->cur_buff; i++) + { + memcpy(buffer->xml + current_size, buffer->buff[i], buffer->data_size[i]); + current_size += buffer->data_size[i]; + } + + buffer->xml[current_size] = '\0'; + return buffer->xml; +} + diff --git a/guththila/src/guththila_namespace.c b/guththila/src/guththila_namespace.c new file mode 100644 index 0000000..7cd9a50 --- /dev/null +++ b/guththila/src/guththila_namespace.c @@ -0,0 +1,139 @@ +/* + * 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 <guththila_namespace.h> +#include <guththila_stack.h> +#include <stdio.h> +#include <stdlib.h> +#include <string.h> + +int GUTHTHILA_CALL +guththila_namespace_list_grow( + guththila_namespace_list_t * namesp_list, + int addition, + const axutil_env_t * env) +{ + int i = 0; + if(addition > 0 || (addition < 0 && namesp_list->capacity + addition > 0 + && namesp_list->capacity + addition >= namesp_list->size)) + { + namesp_list->list = (guththila_namespace_t *)realloc(namesp_list->list, + sizeof(guththila_namespace_t) * (namesp_list->capacity + addition)); + if(namesp_list->list) + { + for(i = namesp_list->capacity; i < namesp_list->capacity + addition; i++) + { + guththila_stack_push(&namesp_list->fr_stack, namesp_list->list + i, env); + } + namesp_list->capacity += addition; + } + else + { + return GUTHTHILA_FAILURE; + } + } + return 0; +} + +guththila_namespace_list_t *GUTHTHILA_CALL +guththila_namespace_list_create( + const axutil_env_t * env) +{ + int i = 0; + guththila_namespace_list_t * namesp_list = (guththila_namespace_list_t *)AXIS2_MALLOC( + env->allocator, sizeof(guththila_namespace_list_t)); + + if(!namesp_list) + return NULL; + + namesp_list->list = (guththila_namespace_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_namespace_t) * GUTHTHILA_NAMESPACE_DEF_SIZE); + + if(namesp_list->list && guththila_stack_init(&namesp_list->fr_stack, env)) + { + namesp_list->capacity = GUTHTHILA_NAMESPACE_DEF_SIZE; + namesp_list->size = 0; + for(i = 0; i < GUTHTHILA_NAMESPACE_DEF_SIZE; i++) + { + guththila_stack_push(&namesp_list->fr_stack, namesp_list->list + i, env); + } + return namesp_list; + } + return NULL; +} + +int GUTHTHILA_CALL +guththila_namespace_list_init( + guththila_namespace_list_t * namesp_list, + const axutil_env_t * env) +{ + int i = 0; + namesp_list->list = (guththila_namespace_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_namespace_t) * GUTHTHILA_NAMESPACE_DEF_SIZE); + if(namesp_list->list && guththila_stack_init(&namesp_list->fr_stack, env)) + { + namesp_list->capacity = GUTHTHILA_NAMESPACE_DEF_SIZE; + namesp_list->size = 0; + for(i = 0; i < GUTHTHILA_NAMESPACE_DEF_SIZE; i++) + { + guththila_stack_push(&namesp_list->fr_stack, namesp_list->list + i, env); + } + return GUTHTHILA_SUCCESS; + } + return GUTHTHILA_FAILURE; +} + +guththila_namespace_t *GUTHTHILA_CALL +guththila_namespace_list_get( + guththila_namespace_list_t *namesp_list, + const axutil_env_t * env) +{ + if(namesp_list->fr_stack.top > 0 || guththila_namespace_list_grow(namesp_list, + GUTHTHILA_NAMESPACE_DEF_SIZE, env)) + { + return guththila_stack_pop(&namesp_list->fr_stack, env); + } + return NULL; +} + +int GUTHTHILA_CALL +guththila_namespace_list_release( + guththila_namespace_list_t * namesp_list, + guththila_namespace_t * namespace, + const axutil_env_t * env) +{ + return guththila_stack_push(&namesp_list->fr_stack, namespace, env); +} + +void GUTHTHILA_CALL +msuila_namespace_list_free_data( + guththila_namespace_list_t * namesp_list, + const axutil_env_t * env) +{ + AXIS2_FREE(env->allocator, namesp_list->list); + guththila_stack_un_init(&namesp_list->fr_stack, env); +} + +void GUTHTHILA_CALL +guththila_namespace_list_free( + guththila_namespace_list_t * namesp_list, + const axutil_env_t * env) +{ + + guththila_stack_un_init(&namesp_list->fr_stack, env); + AXIS2_FREE(env->allocator, namesp_list->list); + AXIS2_FREE(env->allocator, namesp_list); +} diff --git a/guththila/src/guththila_reader.c b/guththila/src/guththila_reader.c new file mode 100644 index 0000000..bcb0efd --- /dev/null +++ b/guththila/src/guththila_reader.c @@ -0,0 +1,115 @@ +/* + * 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 <stdlib.h> +#include <string.h> +#include <guththila_reader.h> +GUTHTHILA_EXPORT guththila_reader_t * GUTHTHILA_CALL +guththila_reader_create_for_file( + guththila_char_t *file_name, + const axutil_env_t * env) +{ + guththila_reader_t * reader = NULL; + + FILE * f = NULL; + if(!file_name) + return NULL; + reader = (guththila_reader_t *)AXIS2_MALLOC(env->allocator, sizeof(guththila_reader_t)); + if(!reader) + return NULL; + f = fopen(file_name, "r"); + if(!f) + { + AXIS2_FREE(env->allocator, reader); + return NULL; + } + reader->fp = f; + reader->type = GUTHTHILA_FILE_READER; + return reader; +} + +GUTHTHILA_EXPORT guththila_reader_t * GUTHTHILA_CALL +guththila_reader_create_for_memory( + void *buffer, + int size, + const axutil_env_t * env) +{ + guththila_reader_t * reader = (guththila_reader_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_reader_t)); + if(reader) + { + reader->type = GUTHTHILA_MEMORY_READER; + reader->buff = buffer; + reader->buff_size = size; + reader->fp = NULL; + return reader; + } + return NULL; +} + +GUTHTHILA_EXPORT guththila_reader_t * GUTHTHILA_CALL +guththila_reader_create_for_io( + GUTHTHILA_READ_INPUT_CALLBACK input_read_callback, + void *ctx, + const axutil_env_t * env) +{ + guththila_reader_t * reader = (guththila_reader_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_reader_t)); + if(reader) + { + reader->input_read_callback = input_read_callback; + reader->context = ctx; + reader->type = GUTHTHILA_IO_READER; + return reader; + } + return NULL; +} +GUTHTHILA_EXPORT void GUTHTHILA_CALL +guththila_reader_free( + guththila_reader_t * r, + const axutil_env_t * env) +{ + if(r->type == GUTHTHILA_FILE_READER && r->fp) + { + fclose(r->fp); + } + if(r->type == GUTHTHILA_IO_READER && r->context) + { + AXIS2_FREE(env->allocator, r->context); + } + AXIS2_FREE(env->allocator, r); + +} +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_reader_read( + guththila_reader_t * r, + guththila_char_t * buffer, + int offset, + int length, + const axutil_env_t * env) +{ + int rt = r->type; + switch(rt) + { + case GUTHTHILA_FILE_READER: + return (int)fread(buffer + offset, 1, length, r->fp); + case GUTHTHILA_IO_READER: + return r->input_read_callback((buffer + offset), length, r->context); + default: + return 0; + } +} + diff --git a/guththila/src/guththila_stack.c b/guththila/src/guththila_stack.c new file mode 100644 index 0000000..fd629c1 --- /dev/null +++ b/guththila/src/guththila_stack.c @@ -0,0 +1,135 @@ +/* + * 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 <guththila_stack.h> + +int GUTHTHILA_CALL +guththila_stack_init( + guththila_stack_t * stack, + const axutil_env_t * env) +{ + stack->top = 0; + stack->data = (void **)AXIS2_MALLOC(env->allocator, sizeof(void **) * GUTHTHILA_STACK_DEFAULT); + if(!stack->data) + { + return GUTHTHILA_FAILURE; + } + else + { + stack->max = GUTHTHILA_STACK_DEFAULT; + return GUTHTHILA_SUCCESS; + } +} + +void GUTHTHILA_CALL +guththila_stack_free( + guththila_stack_t * stack, + const axutil_env_t * env) +{ + if(stack->data) + AXIS2_FREE(env->allocator, stack->data); + AXIS2_FREE(env->allocator, stack); +} + +void GUTHTHILA_CALL +guththila_stack_un_init( + guththila_stack_t * stack, + const axutil_env_t * env) +{ + if(stack->data) + AXIS2_FREE(env->allocator, stack->data); +} + +void *GUTHTHILA_CALL +guththila_stack_pop( + guththila_stack_t * stack, + const axutil_env_t * env) +{ + if(stack->top > 0) + { + return stack->data[--(stack->top)]; + } + return NULL; +} + +int GUTHTHILA_CALL +guththila_stack_push( + guththila_stack_t * stack, + void *data, + const axutil_env_t * env) +{ + int top = stack->top++; + if(top >= stack->max) + { + void **temp = NULL; + int i = 0; + temp = (void **)AXIS2_MALLOC(env->allocator, sizeof(void **) * (stack->max *= 2)); + for(i = 0; i < top; ++i) + { + temp[i] = stack->data[i]; + } + AXIS2_FREE(env->allocator, stack->data); + stack->data = temp; + } + stack->data[top] = data; + return top; +} + +void *GUTHTHILA_CALL +guththila_stack_peek( + guththila_stack_t * stack, + const axutil_env_t * env) +{ + if(stack->top > 0) + { + return stack->data[stack->top - 1]; + } + else + { + return NULL; + } +} + +int GUTHTHILA_CALL +guththila_stack_del_top( + guththila_stack_t * stack, + const axutil_env_t * env) +{ + if(stack->top > 0) + { + AXIS2_FREE(env->allocator, stack->data[stack->top]); + return GUTHTHILA_SUCCESS; + } + return GUTHTHILA_FAILURE; +} + +int GUTHTHILA_CALL +guththila_stack_is_empty( + guththila_stack_t * stack, + const axutil_env_t * env) +{ + return stack->top == 0 ? 1 : 0; +} + +void *GUTHTHILA_CALL +guththila_stack_get_by_index( + guththila_stack_t * stack, + int index, + const axutil_env_t * env) +{ + return index < stack->top ? stack->data[index] : NULL; +} + diff --git a/guththila/src/guththila_token.c b/guththila/src/guththila_token.c new file mode 100644 index 0000000..6272850 --- /dev/null +++ b/guththila/src/guththila_token.c @@ -0,0 +1,221 @@ +/* + * 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 <guththila_token.h> +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +#define TOK_LIST_FREE(tok_list) \ + (if (tok_list) { AXIS2_FREE(tok_list)} ) + +#define TOK_LIST_SIZE(tok_list) (tok_list->size) + +int GUTHTHILA_CALL +guththila_tok_list_grow( + guththila_tok_list_t * tok_list, + const axutil_env_t * env) +{ + int i = 0; + + if(tok_list->cur_list < tok_list->no_list - 1) + { + int cur = ++tok_list->cur_list; + int cur_cap = tok_list->capacity[cur - 1] * 2; + guththila_token_t *list = (guththila_token_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_token_t) * cur_cap); + for(i = 0; i < cur_cap; ++i) + { + guththila_stack_push(&tok_list->fr_stack, &list[i], env); + } + tok_list->capacity[cur] = cur_cap; + tok_list->list[cur] = list; + return GUTHTHILA_SUCCESS; + } + else + { + guththila_token_t ** list = NULL; + int *capacity = NULL; + list = (guththila_token_t **)AXIS2_MALLOC(env->allocator, sizeof(guththila_token_t *) + * tok_list->no_list * 2); + capacity = (int *)AXIS2_MALLOC(env->allocator, sizeof(int) * tok_list->no_list * 2); + if(list) + { + int cur_list = tok_list->cur_list; + for(i = 0; i <= cur_list; ++i) + { + list[i] = tok_list->list[i]; + capacity[i] = tok_list->capacity[i]; + } + tok_list->no_list = tok_list->no_list * 2; + AXIS2_FREE(env->allocator, tok_list->list); + tok_list->list = list; + AXIS2_FREE(env->allocator, tok_list->capacity); + tok_list->capacity = capacity; + guththila_tok_list_grow(tok_list, env); + } + } + return GUTHTHILA_FAILURE; +} + +int GUTHTHILA_CALL +guththila_tok_list_init( + guththila_tok_list_t * tok_list, + const axutil_env_t * env) +{ + int i = 0; + tok_list->list = (guththila_token_t **)AXIS2_MALLOC(env->allocator, sizeof(guththila_token_t *) + * GUTHTHILA_TOK_DEF_LIST_SIZE); + if(tok_list->list && guththila_stack_init(&tok_list->fr_stack, env)) + { + tok_list->capacity = (int *)AXIS2_MALLOC(env->allocator, sizeof(int) + * GUTHTHILA_TOK_DEF_LIST_SIZE); + if(tok_list->capacity) + { + tok_list->no_list = GUTHTHILA_TOK_DEF_LIST_SIZE; + tok_list->list[0] = (guththila_token_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_token_t) * GUTHTHILA_TOK_DEF_SIZE); + for(i = 0; i < GUTHTHILA_TOK_DEF_SIZE; i++) + { + guththila_stack_push(&tok_list->fr_stack, &tok_list->list[0][i], env); + } + tok_list->capacity[0] = GUTHTHILA_TOK_DEF_SIZE; + tok_list->cur_list = 0; + tok_list->no_list = GUTHTHILA_TOK_DEF_LIST_SIZE; + return GUTHTHILA_SUCCESS; + } + } + return GUTHTHILA_FAILURE; +} + +void GUTHTHILA_CALL +guththila_tok_list_free( + guththila_tok_list_t * tok_list, + const axutil_env_t * env) +{ + int i = 0; + guththila_stack_un_init(&tok_list->fr_stack, env); + for(; i <= tok_list->cur_list; i++) + { + AXIS2_FREE(env->allocator, tok_list->list[i]); + } + AXIS2_FREE(env->allocator, tok_list->list); + AXIS2_FREE(env->allocator, tok_list->capacity); + AXIS2_FREE(env->allocator, tok_list); +} + +void GUTHTHILA_CALL +guththila_tok_list_free_data( + guththila_tok_list_t * tok_list, + const axutil_env_t * env) +{ + int i = 0; + guththila_stack_un_init(&tok_list->fr_stack, env); + for(; i <= tok_list->cur_list; i++) + { + AXIS2_FREE(env->allocator, tok_list->list[i]); + } + AXIS2_FREE(env->allocator, tok_list->capacity); + AXIS2_FREE(env->allocator, tok_list->list); +} + +guththila_token_t *GUTHTHILA_CALL +guththila_tok_list_get_token( + guththila_tok_list_t * tok_list, + const axutil_env_t * env) +{ + if(tok_list->fr_stack.top > 0 || guththila_tok_list_grow(tok_list, env)) + { + return guththila_stack_pop(&tok_list->fr_stack, env); + } + return NULL; +} + +int GUTHTHILA_CALL +guththila_tok_list_release_token( + guththila_tok_list_t * tok_list, + guththila_token_t * token, + const axutil_env_t * env) +{ + return guththila_stack_push(&tok_list->fr_stack, token, env); +} + +int GUTHTHILA_CALL +guththila_tok_str_cmp( + guththila_token_t * tok, + guththila_char_t *str, + size_t str_len, + const axutil_env_t * env) +{ + unsigned int i = 0; + if(tok->size != str_len) + return -1; + for(; i < tok->size; i++) + { + if(tok->start[i] != str[i]) + { + return -1; + } + } + return 0; +} + +int GUTHTHILA_CALL +guththila_tok_tok_cmp( + guththila_token_t * tok1, + guththila_token_t * tok2, + const axutil_env_t * env) +{ + unsigned int i = 0; + + if(tok1 && tok2) + { + if(tok1->size != tok2->size) + return -1; + for(; i < tok1->size; i++) + { + if(tok1->start[i] != tok2->start[i]) + { + return -1; + } + } + return 0; + } + return -1; +} + +void GUTHTHILA_CALL +guththila_set_token( + guththila_token_t* tok, + guththila_char_t* start, + short type, + int size, + int _start, + int last, + int ref, + const axutil_env_t* env) +{ + if(start) + { + tok->start = start; + tok->type = type; + tok->_start = _start; + tok->size = size; + tok->last = last; + tok->ref = ref; + } +} diff --git a/guththila/src/guththila_xml_parser.c b/guththila/src/guththila_xml_parser.c new file mode 100644 index 0000000..7c636a5 --- /dev/null +++ b/guththila/src/guththila_xml_parser.c @@ -0,0 +1,1792 @@ + +/* + * 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 <ctype.h> +#include <guththila.h> + +#define GUTHTHILA_VALIDATION_PARSER + +/* + * Read the next char from the reader and return it. + */ +static int +guththila_next_char( + guththila_t * m, + const axutil_env_t * env); + +/* part of guththila_next_char method. this was included as macro for performance. 99% of the time + * following will be called, so having it as next_char method is very expensive (method calling + * overhead is higher) so, common case is checked as part of the macro and if not satisfied, method + * is called + */ +#define GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c)\ +{\ + int result_found = 0;\ + if(!buffer)\ + {\ + if(m->reader->type == GUTHTHILA_MEMORY_READER)\ + {\ + buffer = m->buffer.buff[0];\ + data_size = m->buffer.data_size[0];\ + previous_size = 0;\ + }\ + else\ + {\ + if(m->buffer.cur_buff != -1)\ + {\ + buffer = m->buffer.buff[m->buffer.cur_buff];\ + data_size = GUTHTHILA_BUFFER_CURRENT_DATA_SIZE(m->buffer);\ + previous_size = GUTHTHILA_BUFFER_PRE_DATA_SIZE(m->buffer);\ + }\ + else\ + {\ + c = guththila_next_char(m, env);\ + if(c < 0)\ + return -1;\ + result_found = 1;\ + }\ + }\ + }\ +\ + if(!result_found)\ + {\ + size_t index = m->next++ - previous_size;\ + if(index < data_size)\ + {\ + c = buffer[index];\ + }\ + else\ + {\ + buffer = NULL;\ + data_size = -1;\ + --(m->next);\ + if(m->reader->type == GUTHTHILA_MEMORY_READER)\ + {\ + return -1;\ + }\ + else\ + {\ + c = guththila_next_char(m, env);\ + if(c < 0)\ + return -1;\ + }\ + }\ + }\ +} + +/* + * Read the specified number of characters at once. + */ +static int +guththila_next_no_char( + guththila_t * m, + int eof, + guththila_char_t *bytes, + size_t no, + const axutil_env_t * env); + +/* + * Close a token that is opened previously. + */ +static void +guththila_token_close( + guththila_t * m, + guththila_token_t * tok, + int tok_type, + int referer, + const axutil_env_t * env); + +/* + * Process the XMl declaration part of a XML document. + */ +static int +guththila_process_xml_dec( + guththila_t * m, + const axutil_env_t * env); + +/* + * Return non zero value if the given argument is a space. (c < 0x21) is added to improve the + * performance. common case is printable characters. and if given character is printable, we can + * return false immediately. + */ +#define GUTHTHILA_IS_SPACE(c) ((c < 0x21) && (c == 0x20 || c == 0xD || c == 0xA || c == 0x9)) + +/* + * Read characters until all the white spaces are read. + */ +#define GUTHTHILA_SKIP_SPACES(m, c, buffer, data_size, previous_size, _env)while(GUTHTHILA_IS_SPACE(c)){GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, _env, c);} + + +#define GUTHTHILA_XML_NAME "xml" + +#define GUTHTHILA_XML_URI "http://www.w3.org/XML/1998/namespace" + +/* + * Open a token. When we open a token we don't know it's type. We only + * set the starting values. + */ +#define GUTHTHILA_TOKEN_OPEN(m, tok, _env) \ + m->temp_tok = guththila_tok_list_get_token(&m->tokens, _env); \ + m->temp_tok->type = _Unknown; \ + m->temp_tok->_start = (int)m->next; \ + m->last_start = (int)m->next - 1; +/* We are sure that the difference lies within the int range */ + +/* + * Read until we met a = character. + */ +#define GUTHTHILA_PROCESS_EQU(m, c, ic, buffer, data_size, previous_size, _env)\ +{\ + GUTHTHILA_SKIP_SPACES(m, c, buffer, data_size, previous_size, _env); \ + if (c == '=')\ + { \ + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, _env, ic); \ + GUTHTHILA_SKIP_SPACES(m, ic, buffer, data_size, previous_size, _env); \ + }\ +} + +/* + * Initialize a attribute to the values given. + */ +#define GUTHTHILA_ATTRIBUTE_INITIALIZE(_attr, _pref, _name, _val) \ + (_attr->pref = (_pref)); \ + (_attr->name = (_name)); \ + (_attr->val = (_val)); + +/* + * Initialize namespace to the values given. + */ +#define GUTHTHILA_NAMESPACE_INITIALIZE(_namesp, _name, _uri) \ + (_namesp->name = _name); \ + (_namesp->uri = _uri); + +/* + * Determine weahter a given character is a valid starting char for a xml name. + */ +#define GUTHTHILA_IS_VALID_STARTING_CHAR(c) (isalpha(c) || '_' == c || ':' == c) + +/* + * Initialize the variables in the guththila_t structure. + */ +#define GUTHTHILA_VARIABLE_INITIALZE(m) \ + m->temp_prefix = NULL; \ + m->temp_name = NULL; \ + m->temp_tok = NULL; \ + if (m->value) guththila_tok_list_release_token(&m->tokens, m->value, env); \ + m->name = NULL; \ + m->prefix = NULL; \ + m->value = NULL; + +/* + * Initialize the guththila_t structure with the reader. + * All the values will be set to default values. + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_init( + guththila_t * m, + void *reader, + const axutil_env_t * env) +{ + guththila_token_t* temp_name = NULL; + guththila_token_t* temp_tok = NULL; + guththila_elem_namesp_t* e_namesp = NULL; + + if(!((guththila_reader_t *)reader)) + return GUTHTHILA_FAILURE; + m->reader = (guththila_reader_t *)reader; + if(!guththila_tok_list_init(&m->tokens, env)) + { + return GUTHTHILA_FAILURE; + } + if(m->reader->type == GUTHTHILA_MEMORY_READER) + { + guththila_buffer_init_for_buffer(&m->buffer, m->reader->buff, m->reader->buff_size, env); + } + else if(m->reader->type == GUTHTHILA_FILE_READER || m->reader->type == GUTHTHILA_IO_READER) + { + guththila_buffer_init(&m->buffer, 0, env); + } + guththila_stack_init(&m->elem, env); + guththila_stack_init(&m->attrib, env); + guththila_stack_init(&m->namesp, env); + temp_name = guththila_tok_list_get_token(&m->tokens, env); + temp_tok = guththila_tok_list_get_token(&m->tokens, env); + if(temp_tok && temp_name) + { + guththila_set_token(temp_name, GUTHTHILA_XML_NAME, 0, (int)strlen(GUTHTHILA_XML_NAME), 1, + 0, 0, env); + + guththila_set_token(temp_tok, GUTHTHILA_XML_URI, 0, (int)strlen(GUTHTHILA_XML_URI), 1, 0, + 0, env); + + } + + e_namesp = (guththila_elem_namesp_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_elem_namesp_t)); + if(e_namesp && temp_tok && temp_name) + { + e_namesp->namesp = (guththila_namespace_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_namespace_t) * GUTHTHILA_NAMESPACE_DEF_SIZE); + } + if(e_namesp->namesp) + { + e_namesp->no = 1; + e_namesp->size = GUTHTHILA_NAMESPACE_DEF_SIZE; + e_namesp->namesp[0].name = temp_name; + e_namesp->namesp[0].uri = temp_tok; + guththila_stack_push(&m->namesp, e_namesp, env); + } + else + { + if(temp_name) + { + AXIS2_FREE(env->allocator, temp_name); + temp_name = NULL; + } + if(temp_tok) + { + AXIS2_FREE(env->allocator, temp_tok); + temp_tok = NULL; + } + if(e_namesp) + { + AXIS2_FREE(env->allocator, e_namesp); + e_namesp = NULL; + } + return GUTHTHILA_FAILURE; + } + m->name = NULL; + m->prefix = NULL; + m->value = NULL; + m->status = S_1; + m->guththila_event = -1; + m->next = 0; + m->last_start = -1; + m->temp_name = NULL; + m->temp_prefix = NULL; + m->temp_tok = NULL; + return GUTHTHILA_SUCCESS; +} + +/* + * Uninitialize a guththila_t structure. This method deallocates all the + * resources that are held in the guththila_t structure. + */ +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_un_init( + guththila_t * m, + const axutil_env_t * env) +{ + int size = 0, i = 0, j = 0; + guththila_attr_t * attr = NULL; + guththila_element_t* elem = NULL; + guththila_elem_namesp_t * e_namesp = NULL; + + if(m->prefix) + { + guththila_tok_list_release_token(&m->tokens, m->prefix, env); + } + if(m->name) + { + guththila_tok_list_release_token(&m->tokens, m->name, env); + } + if(m->value) + { + guththila_tok_list_release_token(&m->tokens, m->value, env); + } + if(m->temp_tok) + { + guththila_tok_list_release_token(&m->tokens, m->temp_tok, env); + } + if(m->temp_name) + { + guththila_tok_list_release_token(&m->tokens, m->temp_name, env); + } + if(m->temp_prefix) + { + guththila_tok_list_release_token(&m->tokens, m->temp_prefix, env); + } + size = GUTHTHILA_STACK_SIZE(m->attrib); + for(i = 0; i < size; i++) + { + attr = (guththila_attr_t *)guththila_stack_pop(&m->attrib, env); + if(attr) + { + if(attr->name) + guththila_tok_list_release_token(&m->tokens, attr->name, env); + if(attr->pref) + guththila_tok_list_release_token(&m->tokens, attr->pref, env); + AXIS2_FREE(env->allocator, attr); + } + } + guththila_stack_un_init(&m->attrib, env); + +#ifndef GUTHTHILA_VALIDATION_PARSER + guththila_namespace_t * namesp = NULL; + + size = GUTHTHILA_STACK_SIZE(m->namesp); + for (i = 0; i < size; i++) + { + namesp = + (guththila_namespace_t *) guththila_stack_pop(&m->namesp, env); + if (namesp) + { + if (namesp->name) + guththila_tok_list_release_token(&m->tokens, namesp->name, env); + if (namesp->uri) + guththila_tok_list_release_token(&m->tokens, namesp->uri, env); + AXIS2_FREE(env->allocator, namesp); + } + } +#else + + size = GUTHTHILA_STACK_SIZE(m->namesp); + for(i = 0; i < size; i++) + { + e_namesp = (guththila_elem_namesp_t *)guththila_stack_pop(&m->namesp, env); + if(e_namesp) + { + for(j = 0; j < e_namesp->no; j++) + { + if(e_namesp->namesp[j].name) + { + guththila_tok_list_release_token(&m->tokens, e_namesp->namesp[j].name, env); + } + if(e_namesp->namesp[j].uri) + { + guththila_tok_list_release_token(&m->tokens, e_namesp->namesp[j].uri, env); + } + } + AXIS2_FREE(env->allocator, e_namesp->namesp); + AXIS2_FREE(env->allocator, e_namesp); + } + } +#endif + + size = GUTHTHILA_STACK_SIZE(m->elem); + for(i = 0; i < size; i++) + { + elem = (guththila_element_t *)guththila_stack_pop(&m->elem, env); + if(elem) + { + if(elem->name) + guththila_tok_list_release_token(&m->tokens, elem->name, env); + if(elem->prefix) + guththila_tok_list_release_token(&m->tokens, elem->prefix, env); + AXIS2_FREE(env->allocator, elem); + } + } + guththila_stack_un_init(&m->elem, env); + guththila_stack_un_init(&m->namesp, env); + guththila_tok_list_free_data(&m->tokens, env); + guththila_buffer_un_init(&m->buffer, env); + AXIS2_FREE(env->allocator, m); + return GUTHTHILA_SUCCESS; +} + +/* + * Replace the references with the corresponding actual values. + */ +static void +guththila_token_evaluate_references( + guththila_token_t * tok) +{ + size_t size = tok->size; + guththila_char_t *start = tok->start; + guththila_char_t *pos = NULL; + size_t i, j; + + pos = (guththila_char_t *)memchr(start, '&', size); + if(pos) + { + i = pos - start; + } + else + { + i = size; + } + /*for(i = 0; (i < size) && (start[i] != '&'); i++) + ;*/ + if(i < size) + { + j = i; + while(i < size) + { + if(((i + 3) < size) && (start[i + 1] == 'g') && (start[i + 2] == 't') && (start[i + 3] + == ';')) + { + /* replace first char of sequence with > */ + start[j++] = '>'; + /* skip remainder of sequence */ + i += 4; + } + else if(((i + 3) < size) && (start[i + 1] == 'l') && (start[i + 2] == 't') && (start[i + + 3] == ';')) + { + /* replace first char of sequence with < */ + start[j++] = '<'; + /* skip remainder of sequence */ + i += 4; + } + else if(((i + 4) < size) && (start[i + 1] == 'a') && (start[i + 2] == 'm') && (start[i + + 3] == 'p') && (start[i + 4] == ';')) + { + /* replace first char of sequence with & */ + start[j++] = '&'; + /* skip remainder of sequence */ + i += 5; + } + else if(((i + 5) < size) && (start[i + 1] == 'a') && (start[i + 2] == 'p') && (start[i + + 3] == 'o') && (start[i + 4] == 's') && (start[i + 5] == ';')) + { + /* replace first char of sequence with ' */ + start[j++] = '\''; + /* skip remainder of sequence */ + i += 6; + } + else if(((i + 5) < size) && (start[i + 1] == 'q') && (start[i + 2] == 'u') && (start[i + + 3] == 'o') && (start[i + 4] == 't') && (start[i + 5] == ';')) + { + /* replace first char of sequence with " */ + start[j++] = '\"'; + /* skip remainder of sequence */ + i += 6; + } + else + { + /* ampersand does not start a sequence; + skip it and continue scanning */ + /* could insert character reference decoding here */ + start[j++] = start[i++]; + } + /* copy characters downward until the next ampersand */ + for(; (i < size) && ('&' != (start[j] = start[i])); i++, j++) + ; + } + tok->size = j; + } +} + +/* + * Close a token. This method accepts the type of the token as a parameter. + */ +static void +guththila_token_close( + guththila_t * m, + guththila_token_t * tok, + int tok_type, + int referer, + const axutil_env_t * env) +{ + guththila_attr_t * attr = NULL; + guththila_element_t * elem = NULL; + guththila_elem_namesp_t * e_namesp = NULL; + guththila_namespace_t * namesp; + int i = 0; + /* We are sure that the difference lies within the short range */ + m->temp_tok->type = (short)tok_type; + m->temp_tok->size = m->next - m->temp_tok->_start; + m->temp_tok->start = GUTHTHILA_BUF_POS(m->buffer, m->next - 1) - m->temp_tok->size; + m->temp_tok->ref = referer; + m->last_start = -1; + switch(tok_type) + { + case _attribute_name: + m->temp_name = m->temp_tok; + m->temp_tok = NULL; + break; + case _char_data: + m->value = m->temp_tok; + m->temp_tok = NULL; + break; + case _text_data: + guththila_token_evaluate_references(m->temp_tok); + m->value = m->temp_tok; + m->temp_tok = NULL; + break; + case _attribute_value: + guththila_token_evaluate_references(m->temp_tok); + /* Chech weather we are at a xml namespace declaration */ + if((m->temp_prefix && (guththila_tok_str_cmp(m->temp_prefix, "xmlns", 5u, env) == 0)) + || (guththila_tok_str_cmp(m->temp_name, "xmlns", 5u, env) == 0)) + /*checks inside the m->temp_name to parse the default namespace*/ + /*checks inside the m->temp_prefix to parse namespace with prefix*/ + { +#ifndef GUTHTHILA_VALIDATION_PARSER + namesp = + (guththila_namespace_t *) + AXIS2_MALLOC(sizeof(guththila_namespace_t)); + GUTHTHILA_NAMESPACE_INITIALIZE(namesp, m->temp_name, m->temp_tok); + guththila_stack_push(&m->namesp, namesp); +#else + elem = (guththila_element_t *)guththila_stack_peek(&m->elem, env); + /* This is the first namespace */ + if(elem && !elem->is_namesp) + { + e_namesp = (guththila_elem_namesp_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_elem_namesp_t)); + if(e_namesp) + { + e_namesp->namesp = (guththila_namespace_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_namespace_t) * GUTHTHILA_NAMESPACE_DEF_SIZE); + if(e_namesp->namesp) + { + e_namesp->no = 1; + e_namesp->size = GUTHTHILA_NAMESPACE_DEF_SIZE; + e_namesp->namesp[0].name = m->temp_name; + e_namesp->namesp[0].uri = m->temp_tok; + guththila_stack_push(&m->namesp, e_namesp, env); + elem->is_namesp = 1; + } + else + { + AXIS2_FREE(env->allocator, e_namesp); + e_namesp = NULL; + } + } + } + /* Already there is a namespace */ + else if(elem && elem->is_namesp) + { + e_namesp = (guththila_elem_namesp_t *)guththila_stack_peek(&m->namesp, env); + /* if we have enough space allocated */ + if(e_namesp->no < e_namesp->size) + { + e_namesp->namesp[e_namesp->no].name = m->temp_name; + e_namesp->namesp[e_namesp->no].uri = m->temp_tok; + e_namesp->no++; + } + else + { + namesp = (guththila_namespace_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_namespace_t) * e_namesp->size * 2); + if(namesp) + { + for(i = 0; i < e_namesp->no; i++) + { + namesp[i].name = e_namesp->namesp[i].name; + namesp[i].uri = e_namesp->namesp[i].uri; + } + AXIS2_FREE(env->allocator, e_namesp->namesp); + e_namesp->namesp = namesp; + e_namesp->size *= 2; + + e_namesp->namesp[e_namesp->no].name = m->temp_name; + e_namesp->namesp[e_namesp->no].uri = m->temp_tok; + e_namesp->no++; + } + } + } +#endif + } + else + { + /* It is just a attribute */ + attr = (guththila_attr_t *)AXIS2_MALLOC(env->allocator, sizeof(guththila_attr_t)); + + GUTHTHILA_ATTRIBUTE_INITIALIZE(attr, + m->temp_prefix, + m->temp_name, + m->temp_tok); + guththila_stack_push(&m->attrib, attr, env); + } + m->temp_prefix = NULL; + m->temp_name = NULL; + m->temp_tok = NULL; + break; + case _prefix: + m->temp_prefix = m->temp_tok; + m->temp_tok = NULL; + break; + default: + m->prefix = m->temp_prefix; + m->name = m->temp_tok; + m->temp_tok = NULL; + m->temp_prefix = NULL; + break; + } +} + +int GUTHTHILA_CALL +guththila_validate_namespaces( + guththila_t *m, + const axutil_env_t *env) +{ + int size = 0, i = 0, nmsp_no = 0, j = 0, k = 0; + int namesp_found = GUTHTHILA_FALSE; + guththila_elem_namesp_t *e_namesp = NULL; + + size = GUTHTHILA_STACK_SIZE(m->attrib); + /* Loop through all the attributes */ + for(i = 0; i < size; i++) + { + guththila_attr_t *attr = (guththila_attr_t *)guththila_stack_get_by_index(&m->attrib, i, + env); + if(attr && attr->pref) + { + /* We have a attribute prefix. Need to validate the prefix */ + nmsp_no = GUTHTHILA_STACK_SIZE(m->namesp); + for(j = nmsp_no - 1; j >= 0; j--) + { + e_namesp = (guththila_elem_namesp_t *)guththila_stack_get_by_index(&m->namesp, j, + env); + for(k = 0; k < e_namesp->no; k++) + { + if(!guththila_tok_tok_cmp(e_namesp->namesp[k].name, attr->pref, env)) + { + namesp_found = GUTHTHILA_TRUE; + j = -1; /* force exit from second for loop */ + break; + } + } + } + if(!namesp_found) + return GUTHTHILA_FAILURE; + } + } + /* If the element has a prefix. Need to validate the prefix*/ + if(m->prefix) + { + namesp_found = AXIS2_FALSE; + nmsp_no = GUTHTHILA_STACK_SIZE(m->namesp); + for(j = nmsp_no - 1; j >= 0; j--) + { + e_namesp = (guththila_elem_namesp_t *)guththila_stack_get_by_index(&m->namesp, j, env); + for(k = 0; k < e_namesp->no; k++) + { + if(!guththila_tok_tok_cmp(e_namesp->namesp[k].name, m->prefix, env)) + { + namesp_found = GUTHTHILA_TRUE; + j = -1; /* force exit from outer loop */ + break; + } + } + } + if(!namesp_found) + return AXIS2_FAILURE; + } + return GUTHTHILA_SUCCESS; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_next( + guththila_t * m, + const axutil_env_t * env) +{ + guththila_element_t * elem = NULL; + guththila_elem_namesp_t * nmsp = NULL; + guththila_token_t * tok = NULL; + int quote = 0, ref = 0; + int c = -1; + guththila_attr_t * attr = NULL; + int size = 0, i = 0, nmsp_counter, loop = 0, white_space = 0; + size_t data_size = -1; + size_t previous_size = -1; + guththila_char_t *buffer = NULL; + + /* Need to release the resources for attributes */ + size = GUTHTHILA_STACK_SIZE(m->attrib); + for(i = 0; i < size; i++) + { + attr = (guththila_attr_t *)guththila_stack_pop(&m->attrib, env); + if(attr) + { + if(attr->name) + guththila_tok_list_release_token(&m->tokens, attr->name, env); + if(attr->pref) + guththila_tok_list_release_token(&m->tokens, attr->pref, env); + AXIS2_FREE(env->allocator, attr); + } + } + +#ifdef GUTHTHILA_VALIDATION_PARSER + if(m->guththila_event == GUTHTHILA_END_ELEMENT && m->name) + { + guththila_tok_list_release_token(&m->tokens, m->name, env); + if(m->prefix) + { + guththila_tok_list_release_token(&m->tokens, m->prefix, env); + } + } + /* If the previous event was a empty element we need to do some clean up */ + else if(m->guththila_event == GUTHTHILA_EMPTY_ELEMENT) + { + elem = (guththila_element_t *)guththila_stack_pop(&m->elem, env); + if(elem->is_namesp) + { + nmsp = (guththila_elem_namesp_t *)guththila_stack_pop(&m->namesp, env); + for(nmsp_counter = 0; nmsp_counter < nmsp->no; nmsp_counter++) + { + if(nmsp->namesp[nmsp_counter].name) + guththila_tok_list_release_token(&m->tokens, nmsp->namesp[nmsp_counter]. name, + env); + if(nmsp->namesp[nmsp_counter].uri) + guththila_tok_list_release_token(&m->tokens, nmsp->namesp[nmsp_counter]. uri, + env); + } + AXIS2_FREE(env->allocator, nmsp->namesp); + AXIS2_FREE(env->allocator, nmsp); + } + if(elem->name) + guththila_tok_list_release_token(&m->tokens, elem->name, env); + if(elem->prefix) + guththila_tok_list_release_token(&m->tokens, elem->prefix, env); + AXIS2_FREE(env->allocator, elem); + } + GUTHTHILA_VARIABLE_INITIALZE(m); +#endif + /* Actual XML parsing logic */ + do + { + loop = 0; + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + if(m->status == S_1) + { + while(isspace(c)) + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + } + if('<' == c) + { + m->status = S_2; + } + else + { + return -1; + } + } + if(m->status != S_2) + { + return -1; + } + if(c == '<') + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + if(c != '?' && c != '!' && c != '/') + { + /* We are at the beginning of a xml element */ + if(GUTHTHILA_IS_VALID_STARTING_CHAR(c)) + { + GUTHTHILA_TOKEN_OPEN(m, tok, env); + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + while(!GUTHTHILA_IS_SPACE(c) && c != '>' && c != '/') + { + if(c != ':') + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + } + else + { + /* We know for sure that this is a prefix */ + guththila_token_close(m, tok, _prefix, 0, env); + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + GUTHTHILA_TOKEN_OPEN(m, tok, env); + } + } + /* XML element name */ + guththila_token_close(m, tok, _name, 0, env); +#ifdef GUTHTHILA_VALIDATION_PARSER + elem = (guththila_element_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_element_t)); + elem->name = m->name; + elem->prefix = m->prefix; + elem->is_namesp = 0; + guththila_stack_push(&m->elem, elem, env); +#endif + } + GUTHTHILA_SKIP_SPACES(m, c, buffer, data_size, previous_size, env); + /* Process the attributes */ + for(;;) + { + /* Empty element */ + if(c == '/') + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + if(c == '>') + { + m->guththila_event = GUTHTHILA_EMPTY_ELEMENT; + if(!guththila_validate_namespaces(m, env)) + return -1; + else + return GUTHTHILA_EMPTY_ELEMENT; + } + else + { + return -1; + } + } + /* Normal element */ + else if(c == '>') + { + m->guththila_event = GUTHTHILA_START_ELEMENT; + if(!guththila_validate_namespaces(m, env)) + return -1; + else + return GUTHTHILA_START_ELEMENT; + } + /* We are in the middle of a element */ + else + { + /* Process the attributes */ + if(GUTHTHILA_IS_VALID_STARTING_CHAR(c)) + { + GUTHTHILA_TOKEN_OPEN(m, tok, env); + + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + while(!GUTHTHILA_IS_SPACE(c) && c != '=') + { + if(c != ':') + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + } + else if(c == ':') + { + /* Prefix */ + guththila_token_close(m, tok, _prefix, 0, env); + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + GUTHTHILA_TOKEN_OPEN(m, tok, env); + } + } + /* Attribute name*/ + guththila_token_close(m, tok, _attribute_name, 0, env); + } + else + { + return -1; + } + /* Attribute Value */ + GUTHTHILA_PROCESS_EQU(m, c, quote, buffer, data_size, previous_size, env); + if(quote == '\'' || quote == '\"') + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + GUTHTHILA_TOKEN_OPEN(m, tok, env); + while(c != quote) + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + } + guththila_token_close(m, tok, _attribute_value, 0, env); + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + GUTHTHILA_SKIP_SPACES(m, c, buffer, data_size, previous_size, env); + } + else + { + return -1; + } + } + } /* for(;;) */ + } + else if(c == '/') + { + /* End Element */ + m->guththila_event = GUTHTHILA_END_ELEMENT; + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + if(GUTHTHILA_IS_VALID_STARTING_CHAR(c)) + { + GUTHTHILA_TOKEN_OPEN(m, tok, env); + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + while(!GUTHTHILA_IS_SPACE(c) && c != '>') + { + if(c != ':') + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + } + else + { + /* Prefix */ + guththila_token_close(m, tok, _prefix, 0, env); + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + GUTHTHILA_TOKEN_OPEN(m, tok, env); + } + } + /* name */ + guththila_token_close(m, tok, _name, 0, env); + +#ifdef GUTHTHILA_VALIDATION_PARSER + elem = (guththila_element_t *)guththila_stack_pop(&m->elem, env); + if(!elem || (!elem->prefix && m->prefix) || (elem->prefix && !m->prefix)) + return -1; + if(guththila_tok_tok_cmp(m->name, elem->name, env)) + { + return -1; + } + if(elem->prefix && m->prefix && guththila_tok_tok_cmp(m->prefix, elem->prefix, + env)) + { + return -1; + } + /* Releasing the namespace related resources */ + if(elem->is_namesp) + { + nmsp = (guththila_elem_namesp_t *)guththila_stack_pop(&m->namesp, env); + for(nmsp_counter = 0; nmsp_counter < nmsp->no; nmsp_counter++) + { + if(nmsp->namesp[nmsp_counter].name) + guththila_tok_list_release_token(&m->tokens, + nmsp-> namesp[nmsp_counter]. name, env); + if(nmsp->namesp[nmsp_counter].uri) + guththila_tok_list_release_token(&m->tokens, + nmsp-> namesp[nmsp_counter]. uri, env); + } + AXIS2_FREE(env->allocator, nmsp->namesp); + AXIS2_FREE(env->allocator, nmsp); + } + /* Release the tokens */ + if(elem->name) + guththila_tok_list_release_token(&m->tokens, elem->name, env); + if(elem->prefix) + guththila_tok_list_release_token(&m->tokens, elem->prefix, env); + AXIS2_FREE(env->allocator, elem); +#endif + GUTHTHILA_SKIP_SPACES(m, c, buffer, data_size, previous_size, env); + if(c != '>') + return -1; + return GUTHTHILA_END_ELEMENT; + } + return -1; + } + else if(c == '!') + { + /* Comment */ + guththila_char_t c_arra[16] = { 0 }; + if(2 == guththila_next_no_char(m, 0, c_arra, 2, env) && '-' == c_arra[0] && '-' + == c_arra[1]) + { + int loop_state = 1; + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + GUTHTHILA_TOKEN_OPEN(m, tok, env); + while(loop_state) + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + if('-' == c) + { + if(2 == guththila_next_no_char(m, 0, c_arra, 2, env) && '-' + == c_arra[0]) + { + if('>' == c_arra[1]) + { + m->guththila_event = GUTHTHILA_COMMENT; + /* position after first hyphen, as if we just scanned it */ + m->next = m->next - 2; + guththila_token_close(m, tok, _char_data, 0, env); + m->next = m->next + 2; + return GUTHTHILA_COMMENT; + } + else + { + return -1; + } + } + } + } + } + else + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + while('<' != c) + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + } + } + } + else if(c == '?') + { + /* XML declaration */ + c = guththila_process_xml_dec(m, env); + if(c != -1) + return GUTHTHILA_START_DOCUMENT; + else + return -1; + } + } + else + { + /* Text */ + m->guththila_event = GUTHTHILA_CHARACTER; + if(!GUTHTHILA_IS_SPACE(c)) + white_space = 0; + else + white_space = 1; + GUTHTHILA_TOKEN_OPEN(m, tok, env); + + /* code given below is having two do-while loop wrapped by another do-while loop. + * This is done to improve the performance for big messages. Most of the cases, the + * content will be not whitespace, so checking for whitespace even if we already found + * that we have some valid characters is big overhead. Hence better to do the looping + * separately to find white_space = false and normal case + */ + do + { + if(white_space) + { + do + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + if(!GUTHTHILA_IS_SPACE(c) && c != '<') + { + white_space = 0; + break; + } + } + while(c != '<'); + } + else + { + do + { + if(buffer) + { + guththila_char_t *pos = NULL; + size_t index = m->next - previous_size; + pos = (guththila_char_t*)memchr(buffer + index, '<', data_size - index); + if(pos) + { + m->next += pos - (buffer + index); + } + else + { + m->next = previous_size + data_size; + } + + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + } + else + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + } + }while(c != '<'); + } + } + while(c != '<'); + guththila_token_close(m, tok, _text_data, ref, env); + m->next--; + if(white_space) + { +#ifndef GUTHTHILA_IGNORE_SPACES + m->guththila_event = GUTHTHILA_SPACE; + return GUTHTHILA_SPACE; +#else + loop = 1; + if (m->value) + { + guththila_tok_list_release_token(&m->tokens, m->value, + env); + m->value = NULL; + } +#endif + } + + else + return GUTHTHILA_CHARACTER; + } + } + while(loop); + return c; +} + +/* Process the XML declaration */ +static int +guththila_process_xml_dec( + guththila_t * m, + const axutil_env_t * env) +{ + guththila_token_t * tok = NULL; + guththila_char_t c_arra[16] = { 0 }; + int c = -1; + int quote = -1; + int nc = -1; + size_t data_size = -1; + size_t previous_size = -1; + guththila_char_t *buffer = NULL; + if(3 == guththila_next_no_char(m, GUTHTHILA_EOF, c_arra, 3, env) && 'x' == c_arra[0] && 'm' + == c_arra[1] && 'l' == c_arra[2]) + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + GUTHTHILA_SKIP_SPACES(m, c, buffer, data_size, previous_size, env); + if(c == 'v') + { + GUTHTHILA_TOKEN_OPEN(m, tok, env); + if(6 == guththila_next_no_char(m, 0, c_arra, 6, env) && 'e' == c_arra[0] && 'r' + == c_arra[1] && 's' == c_arra[2] && 'i' == c_arra[3] && 'o' == c_arra[4] && 'n' + == c_arra[5]) + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + guththila_token_close(m, tok, _attribute_name, 0, env); + GUTHTHILA_PROCESS_EQU(m, c, quote, buffer, data_size, previous_size, env); + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, nc); + GUTHTHILA_TOKEN_OPEN(m, tok, env); + while(nc != quote) + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, nc); + } + guththila_token_close(m, tok, _attribute_value, 0, env); + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + GUTHTHILA_SKIP_SPACES(m, c, buffer, data_size, previous_size, env); + } + else + { + return -1; + } + } + if(c == 'e') + { + GUTHTHILA_TOKEN_OPEN(m, tok, env); + if(7 == guththila_next_no_char(m, 0, c_arra, 7, env) && 'n' == c_arra[0] && 'c' + == c_arra[1] && 'o' == c_arra[2] && 'd' == c_arra[3] && 'i' == c_arra[4] && 'n' + == c_arra[5] && 'g' == c_arra[6]) + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + guththila_token_close(m, tok, _attribute_name, 0, env); + GUTHTHILA_PROCESS_EQU(m, c, quote, buffer, data_size, previous_size, env); + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, nc); + GUTHTHILA_TOKEN_OPEN(m, tok, env); + while(nc != quote) + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, nc); + } + guththila_token_close(m, tok, _attribute_value, 0, env); + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + GUTHTHILA_SKIP_SPACES(m, c, buffer, data_size, previous_size, env); + } + } + if(c == 's') + { + GUTHTHILA_TOKEN_OPEN(m, tok, env); + if(9 == guththila_next_no_char(m, 0, c_arra, 9, env) && 't' == c_arra[0] && 'a' + == c_arra[1] && 'n' == c_arra[2] && 'd' == c_arra[3] && 'a' == c_arra[4] && 'l' + == c_arra[5] && 'o' == c_arra[6] && 'n' == c_arra[7] && 'e' == c_arra[8]) + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + guththila_token_close(m, tok, _attribute_name, 0, env); + GUTHTHILA_PROCESS_EQU(m, c, quote, buffer, data_size, previous_size, env); + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, nc); + GUTHTHILA_TOKEN_OPEN(m, tok, env); + while(nc != quote) + { + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, nc); + } + guththila_token_close(m, tok, _attribute_value, 0, env); + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, c); + GUTHTHILA_SKIP_SPACES(m, c, buffer, data_size, previous_size, env); + } + } + if(c == '?') + { + int nc; + GUTHTHILA_NEXT_CHAR(m, buffer, data_size, previous_size, env, nc); + if('>' == nc) + { + m->guththila_event = GUTHTHILA_START_DOCUMENT; + } + else + { + return -1; + } + } + } + return c; +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_get_attribute_count( + guththila_t * m, + const axutil_env_t * env) +{ + return GUTHTHILA_STACK_SIZE(m->attrib); +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_attribute_name( + guththila_t * m, + guththila_attr_t * att, + const axutil_env_t * env) +{ + guththila_char_t *str = NULL; + if(att->name) + { + GUTHTHILA_TOKEN_TO_STRING(att->name, str, env); + return str; + } + return NULL; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_attribute_value( + guththila_t * m, + guththila_attr_t * att, + const axutil_env_t * env) +{ + guththila_char_t *str = NULL; + if(att->val) + { + GUTHTHILA_TOKEN_TO_STRING(att->val, str, env); + return str; + } + return NULL; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_attribute_prefix( + guththila_t * m, + guththila_attr_t * att, + const axutil_env_t * env) +{ + guththila_char_t *str = NULL; + if(att->pref) + { + GUTHTHILA_TOKEN_TO_STRING(att->pref, str, env); + return str; + } + return NULL; +} + +GUTHTHILA_EXPORT guththila_attr_t *GUTHTHILA_CALL +guththila_get_attribute( + guththila_t * m, + const axutil_env_t * env) +{ + return (guththila_attr_t *)guththila_stack_pop(&m->attrib, env); +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_attribute_name_by_number( + guththila_t * m, + int i, + const axutil_env_t *env) +{ + guththila_char_t *str = NULL; + guththila_attr_t * attr = (guththila_attr_t *)guththila_stack_get_by_index(&m->attrib, i - 1, + env); + if(attr->name) + { + GUTHTHILA_TOKEN_TO_STRING(attr->name, str, env); + return str; + } + return NULL; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_attribute_value_by_number( + guththila_t * m, + int i, + const axutil_env_t *env) +{ + guththila_char_t *str = NULL; + guththila_attr_t * attr = (guththila_attr_t *)guththila_stack_get_by_index(&m->attrib, i - 1, + env); + if(attr->val) + { + GUTHTHILA_TOKEN_TO_STRING(attr->val, str, env); + return str; + } + return NULL; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_attribute_prefix_by_number( + guththila_t * m, + int i, + const axutil_env_t *env) +{ + guththila_char_t *str = NULL; + guththila_attr_t * attr = (guththila_attr_t *)guththila_stack_get_by_index(&m->attrib, i - 1, + env); + if(attr && attr->pref) + { + GUTHTHILA_TOKEN_TO_STRING(attr->pref, str, env); + return str; + } + return NULL; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_name( + guththila_t * m, + const axutil_env_t * env) +{ + guththila_char_t *str = NULL; + if(m->name) + { + GUTHTHILA_TOKEN_TO_STRING(m->name, str, env); + return str; + } + return NULL; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_prefix( + guththila_t * m, + const axutil_env_t * env) +{ + guththila_char_t *str = NULL; + if(m->prefix) + { + GUTHTHILA_TOKEN_TO_STRING(m->prefix, str, env); + return str; + } + return NULL; +} + +GUTHTHILA_EXPORT guththila_char_t * GUTHTHILA_CALL +guththila_get_value( + guththila_t * m, + const axutil_env_t * env) +{ + guththila_char_t *str = NULL; + if(m->value) + { + GUTHTHILA_TOKEN_TO_STRING(m->value, str, env); + return str; + } + return NULL; +} + +GUTHTHILA_EXPORT guththila_namespace_t *GUTHTHILA_CALL +guththila_get_namespace( + guththila_t * m, + const axutil_env_t * env) +{ + +#ifndef GUTHTHILA_VALIDATION_PARSER + return (guththila_namespace_t *) guththila_stack_pop(&m->namesp, env); +#else + return NULL; +#endif +} + +GUTHTHILA_EXPORT int GUTHTHILA_CALL +guththila_get_namespace_count( + guththila_t * m, + const axutil_env_t * env) +{ + +#ifndef GUTHTHILA_VALIDATION_PARSER + return GUTHTHILA_STACK_SIZE(m->namesp); +#else + guththila_elem_namesp_t * nmsp = NULL; + if(((guththila_element_t *)guththila_stack_peek(&m->elem, env))->is_namesp) + { + nmsp = (guththila_elem_namesp_t *)guththila_stack_peek(&m->namesp, env); + return nmsp->no; + } + return 0; + +#endif +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_namespace_uri( + guththila_t * m, + guththila_namespace_t * ns, + const axutil_env_t * env) +{ + guththila_char_t *str = NULL; + if(ns->uri) + { + GUTHTHILA_TOKEN_TO_STRING(ns->uri, str, env); + return str; + } + return NULL; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_namespace_prefix( + guththila_t * m, + guththila_namespace_t * ns, + const axutil_env_t * env) +{ + guththila_char_t *str = NULL; + if(ns->name) + { + GUTHTHILA_TOKEN_TO_STRING(ns->name, str, env); + return str; + } + return NULL; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_namespace_prefix_by_number( + guththila_t * m, + int i, + const axutil_env_t *env) +{ + guththila_char_t *str = NULL; + +#ifndef GUTHTHILA_VALIDATION_PARSER + if (GUTHTHILA_STACK_SIZE(m->namesp) >= i) + { + namesp = guththila_stack_get_by_index(&m->namesp, i - 1, env); + if (namesp && namesp->name) + { + GUTHTHILA_TOKEN_TO_STRING(namesp->name, str, env); + return str; + } + } + +#else + guththila_elem_namesp_t * nmsp = NULL; + if(((guththila_element_t *)guththila_stack_peek(&m->elem, env))->is_namesp) + { + nmsp = (guththila_elem_namesp_t *)guththila_stack_peek(&m->namesp, env); + if(nmsp && nmsp->no >= i) + { + GUTHTHILA_TOKEN_TO_STRING(nmsp->namesp[i - 1].name, str, env); + return str; + } + } +#endif /* */ + return NULL; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_namespace_uri_by_number( + guththila_t * m, + int i, + const axutil_env_t *env) +{ + guththila_char_t *str = NULL; +#ifndef GUTHTHILA_VALIDATION_PARSER + if (GUTHTHILA_STACK_SIZE(m->namesp) >= i) + { + namesp = guththila_stack_get_by_index(&m->namesp, i - 1, env); + if (namesp && namesp->uri) + { + GUTHTHILA_TOKEN_TO_STRING(namesp->uri, str, env); + return str; + } + } +#else + guththila_elem_namesp_t * nmsp = NULL; + if(((guththila_element_t *)guththila_stack_peek(&m->elem, env))->is_namesp) + { + nmsp = (guththila_elem_namesp_t *)guththila_stack_peek(&m->namesp, env); + if(nmsp && nmsp->no >= i) + { + GUTHTHILA_TOKEN_TO_STRING(nmsp->namesp[i - 1].uri, str, env); + return str; + } + } +#endif + return NULL; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_attribute_namespace_by_number( + guththila_t * m, + int i, + const axutil_env_t *env) +{ + +#ifndef GUTHTHILA_VALIDATION_PARSER + return NULL; + +#else + guththila_attr_t * attr = NULL; + guththila_char_t* str = NULL; + int j = 0, k = 0, count = 0; + guththila_elem_namesp_t * nmsp = NULL; + if(i <= GUTHTHILA_STACK_SIZE(m->attrib)) + { + attr = (guththila_attr_t *)guththila_stack_get_by_index(&m->attrib, i - 1, env); + if(attr && attr->pref) + { + count = GUTHTHILA_STACK_SIZE(m->namesp); + for(j = count - 1; j >= 0; j--) + { + nmsp = (guththila_elem_namesp_t *)guththila_stack_get_by_index(&m->namesp, j, env); + for(k = 0; k < nmsp->no; k++) + { + if(!guththila_tok_tok_cmp(nmsp->namesp[k].name, attr->pref, env)) + { + GUTHTHILA_TOKEN_TO_STRING(nmsp->namesp[k].uri, str, env); + return str; + } + } + } + } + } + return NULL; + +#endif +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_encoding( + guththila_t * m, + const axutil_env_t * env) +{ + return "UTF-8"; +} + +/* Return the next character */ +static int +guththila_next_char( + guththila_t * m, + const axutil_env_t * env) +{ + int c; + size_t data_move, i; + int temp; + guththila_char_t **temp1; + size_t * temp2, *temp3; + + /* we have a buffered reader. Easiest case just fetch the character from + * the buffer. Here we have a single buffer. + * */ + if(m->reader->type == GUTHTHILA_MEMORY_READER) + { + size_t index = m->next++; + if(index < m->buffer.data_size[0]) + { + return m->buffer.buff[0][index]; + } + } + else + { + /* comlex stuff. We have a array of buffers */ + if(m->buffer.cur_buff != -1 && m->next < GUTHTHILA_BUFFER_PRE_DATA_SIZE(m->buffer) + + GUTHTHILA_BUFFER_CURRENT_DATA_SIZE(m->buffer)) + { + /* What we are looking for is already in the buffer */ + c = m->buffer.buff[m->buffer.cur_buff][m->next++ - GUTHTHILA_BUFFER_PRE_DATA_SIZE( + m->buffer)]; + return c; + } + else if(m->buffer.cur_buff != -1 && m->next >= GUTHTHILA_BUFFER_PRE_DATA_SIZE(m->buffer) + + GUTHTHILA_BUFFER_CURRENT_DATA_SIZE(m->buffer)) + { + /* if we have don't have enough space in current buffer, have to create new buffer */ + if(m->buffer.buffs_size[m->buffer.cur_buff] < + GUTHTHILA_BUFFER_CURRENT_DATA_SIZE(m->buffer) + GUTHTHILA_BUFFER_DEF_MIN_SIZE) + { + if(m->buffer.cur_buff == (int)m->buffer.no_buffers - 1) + { + /* we are out of allocated buffers. Need to allocate more buffers */ + temp = m->buffer.no_buffers * 2; + temp1 = (guththila_char_t **)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t *) * temp); + temp2 = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) * temp); + temp3 = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) * temp); + if(!temp1 || !temp2 || !temp3) + return (-1); + for(i = 0; i < m->buffer.no_buffers; i++) + { + temp1[i] = m->buffer.buff[i]; + temp2[i] = m->buffer.buffs_size[i]; + temp3[i] = m->buffer.data_size[i]; + } + AXIS2_FREE(env->allocator, m->buffer.buff); + AXIS2_FREE(env->allocator, m->buffer.data_size); + AXIS2_FREE(env->allocator, m->buffer.buffs_size); + m->buffer.buff = temp1; + m->buffer.buffs_size = temp2; + m->buffer.data_size = temp3; + m->buffer.no_buffers *= 2; + } + m->buffer.buff[m->buffer.cur_buff + 1] = (guththila_char_t *)AXIS2_MALLOC( + env->allocator, + sizeof(guththila_char_t) * m->buffer.buffs_size[m->buffer.cur_buff] * 2); + if(!m->buffer.buff[m->buffer.cur_buff + 1]) + return -1; + m->buffer.cur_buff++; + m->buffer.buffs_size[m->buffer.cur_buff] = + m->buffer.buffs_size[m->buffer.cur_buff - 1] * 2; + m->buffer.data_size[m->buffer.cur_buff] = 0; + /* We need to have the content for one token in a single buffer. + * So if the space is not sufficient we have to move first part + * of the token to the next buffer */ + if(m->last_start != -1) + { + data_move = m->buffer.data_size[m->buffer.cur_buff - 1] - + (m->last_start - m->buffer.pre_tot_data); + memcpy(m->buffer.buff[m->buffer.cur_buff], m->buffer.buff[m->buffer.cur_buff - 1] + + m->buffer.data_size[m->buffer.cur_buff - 1] - data_move, data_move); + m->buffer.data_size[m->buffer.cur_buff - 1] -= data_move; + m->buffer.data_size[m->buffer.cur_buff] += data_move; + } + m->buffer.pre_tot_data += m->buffer.data_size[m->buffer.cur_buff - 1]; + } + temp = guththila_reader_read(m->reader, GUTHTHILA_BUFFER_CURRENT_BUFF(m->buffer), 0, + (int)GUTHTHILA_BUFFER_CURRENT_BUFF_SIZE(m->buffer), env); + if(temp > 0) + { + m->buffer.data_size[m->buffer.cur_buff] += temp; + } + else + { + return -1; + } + c = m->buffer.buff[m->buffer.cur_buff][m->next++ - GUTHTHILA_BUFFER_PRE_DATA_SIZE( + m->buffer)]; + return c; + } + /* Initial stage. We dont' have the array of buffers allocated*/ + else if(m->buffer.cur_buff == -1) + { + m->buffer.buff[0] = (guththila_char_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t) * GUTHTHILA_BUFFER_DEF_SIZE); + m->buffer.buffs_size[0] = GUTHTHILA_BUFFER_DEF_SIZE; + m->buffer.cur_buff = 0; + temp = guththila_reader_read(m->reader, m->buffer.buff[0], 0, + GUTHTHILA_BUFFER_DEF_SIZE, env); + m->buffer.data_size[0] = temp; + c = m->buffer.buff[0][m->next++]; + return c; + } + } + return -1; +} + +/* Same functionality as the guththila_next_char. But insted of reading + * one character this function reads several characters at once + * */ +static int +guththila_next_no_char( + guththila_t * m, + int eof, + guththila_char_t *bytes, + size_t no, + const axutil_env_t * env) +{ + int temp, data_move; + size_t i; + guththila_char_t **temp1; + size_t * temp2, *temp3; + if(m->reader->type == GUTHTHILA_MEMORY_READER && m->next + no - 1 + < GUTHTHILA_BUFFER_CURRENT_DATA_SIZE(m->buffer) && m->buffer.cur_buff != -1) + { + for(i = 0; i < no; i++) + { + bytes[i] = m->buffer.buff[0][m->next++]; + } + return (int)no; + /* We are sure that the difference lies within the int range */ + } + else if(m->reader->type == GUTHTHILA_IO_READER || m->reader->type == GUTHTHILA_FILE_READER) + { + if(m->next < GUTHTHILA_BUFFER_PRE_DATA_SIZE(m->buffer) + + GUTHTHILA_BUFFER_CURRENT_DATA_SIZE(m->buffer) + no && m->buffer.cur_buff != -1) + { + for(i = 0; i < no; i++) + { + bytes[i] = m->buffer.buff[m->buffer.cur_buff][m->next++ + - GUTHTHILA_BUFFER_PRE_DATA_SIZE(m->buffer)]; + } + return (int)no; + /* We are sure that the difference lies within the int range */ + } + else if(m->next >= GUTHTHILA_BUFFER_PRE_DATA_SIZE(m->buffer) + + GUTHTHILA_BUFFER_CURRENT_DATA_SIZE(m->buffer) + no && m->buffer.cur_buff != -1) + { + /* We are sure that the difference lies within the int range */ + if(m->buffer.cur_buff == (int)m->buffer.no_buffers - 1) + { + temp = m->buffer.no_buffers * 2; + temp1 = (guththila_char_t **)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t *) * temp); + temp2 = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) * temp); + temp3 = (size_t *)AXIS2_MALLOC(env->allocator, sizeof(size_t) * temp); + if(!temp1 || !temp2 || !temp3) + return (-1); + for(i = 0; i < m->buffer.no_buffers; i++) + { + temp1[i] = m->buffer.buff[i]; + temp2[i] = m->buffer.buffs_size[i]; + temp3[i] = m->buffer.data_size[i]; + } + AXIS2_FREE(env->allocator, m->buffer.buff); + AXIS2_FREE(env->allocator, m->buffer.data_size); + AXIS2_FREE(env->allocator, m->buffer.buffs_size); + m->buffer.buff = temp1; + m->buffer.buffs_size = temp2; + m->buffer.data_size = temp3; + m->buffer.no_buffers *= 2; + } + m->buffer.buff[m->buffer.cur_buff + 1] = (guththila_char_t *)AXIS2_MALLOC( + env->allocator, sizeof(guththila_char_t) * m->buffer.data_size[m->buffer.cur_buff] + * 2); + if(!m->buffer.buff[m->buffer.cur_buff + 1]) + return -1; + m->buffer.cur_buff++; + m->buffer.buffs_size[m->buffer.cur_buff] = m->buffer.buffs_size[m->buffer.cur_buff - 1] + * 2; + m->buffer.data_size[m->buffer.cur_buff] = 0; + data_move = (int)m->next; + /* We are sure that the difference lies within the int range */ + if((m->last_start != -1) && (m->last_start < data_move)) + data_move = m->last_start; + data_move = (int)m->buffer.data_size[m->buffer.cur_buff - 1] - (data_move + - (int)m->buffer.pre_tot_data); + /* We are sure that the difference lies within the int range */ + if(data_move) + { + memcpy(m->buffer.buff[m->buffer.cur_buff], m->buffer.buff[m->buffer.cur_buff - 1] + + m->buffer.data_size[m->buffer.cur_buff - 1] - data_move, data_move); + m->buffer.data_size[m->buffer.cur_buff - 1] -= data_move; + m->buffer.data_size[m->buffer.cur_buff] += data_move; + } + m->buffer.pre_tot_data += m->buffer.data_size[m->buffer.cur_buff - 1]; + temp = guththila_reader_read(m->reader, GUTHTHILA_BUFFER_CURRENT_BUFF(m->buffer), 0, + (int)GUTHTHILA_BUFFER_CURRENT_BUFF_SIZE(m-> buffer), env); + /* We are sure that the difference lies within the int range */ + if(temp > 0) + { + m->buffer.data_size[m->buffer.cur_buff] += temp; + } + else + { + return -1; + } + for(i = 0; i < no; i++) + { + bytes[i] = m->buffer.buff[m->buffer.cur_buff][m->next++ + - GUTHTHILA_BUFFER_PRE_DATA_SIZE(m->buffer)]; + } + return (int)no; + /* We are sure that the difference lies within the int range */ + } + else if(m->buffer.cur_buff == -1) + { + m->buffer.buff[0] = (guththila_char_t *)AXIS2_MALLOC(env->allocator, + sizeof(guththila_char_t) * GUTHTHILA_BUFFER_DEF_SIZE); + m->buffer.buffs_size[0] = GUTHTHILA_BUFFER_DEF_SIZE; + m->buffer.cur_buff = 0; + temp = guththila_reader_read(m->reader, m->buffer.buff[0], 0, + GUTHTHILA_BUFFER_DEF_SIZE, env); + m->buffer.data_size[0] = temp; + for(i = 0; i < no; i++) + { + bytes[i] = m->buffer.buff[m->buffer.cur_buff][m->next++ + - GUTHTHILA_BUFFER_PRE_DATA_SIZE(m->buffer)]; + } + return (int)no; + /* We are sure that the difference lies within the int range */ + } + } + return -1; +} + +GUTHTHILA_EXPORT guththila_char_t *GUTHTHILA_CALL +guththila_get_current_buffer( + guththila_t * m, + const axutil_env_t * env) +{ + return guththila_buffer_get(&m->buffer, env); +} + 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; +} + diff --git a/guththila/tests/resources/om b/guththila/tests/resources/om new file mode 120000 index 0000000..3bd0c61 --- /dev/null +++ b/guththila/tests/resources/om @@ -0,0 +1 @@ +../../../axiom/test/resources/xml/om/
\ No newline at end of file diff --git a/guththila/tests/resources/soap b/guththila/tests/resources/soap new file mode 120000 index 0000000..9674db5 --- /dev/null +++ b/guththila/tests/resources/soap @@ -0,0 +1 @@ +../../../axiom/test/resources/xml/soap
\ No newline at end of file diff --git a/guththila/tests/s b/guththila/tests/s new file mode 100755 index 0000000..7e9f4f8 --- /dev/null +++ b/guththila/tests/s @@ -0,0 +1,13 @@ +#!/usr/bin/perl -w +use strict; + +if ($ARGV[0] == 1) +{ + print "compiling writer\n"; + system "gcc -Wall -g3 -O0 -o writer guththila_writer_main.c -L\$AXIS2C_HOME/lib -I\$AXIS2C_HOME/include -lguththila -laxis2_util"; +} +else +{ + print "compiling reader tests \n"; + system "gcc -Wall -g3 -O0 -o reader *.c \-L\$AXIS2C_HOME/lib \-I\$AXIS2C_HOME/include -lcheck -lguththila \-laxis2_util"; +} diff --git a/guththila/tests/test.c b/guththila/tests/test.c new file mode 100644 index 0000000..cebbe02 --- /dev/null +++ b/guththila/tests/test.c @@ -0,0 +1,200 @@ +#include <check.h> +#include <guththila.h> +#include "guththila_defines.h" +#include "test.h" + +void +setup( + void) +{ + allocator = axutil_allocator_init(NULL); + env = axutil_env_create(allocator); +} + +void +teardown( + void) +{ + guththila_reader_free(env, red); + guththila_free(env, parser); + axutil_env_free(env); +} + +START_TEST(test_guththila) +{ + red = guththila_reader_create_for_file(env, "resources/om/axis.xml"); + parser = guththila_create(env, red); + fail_if(red == NULL, "guththila reader failed"); + fail_if(parser == NULL, "guththila parser failed"); +} + +END_TEST +START_TEST( + test_guththila_start_element) +{ + int c = 0; + char *p; + red = guththila_reader_create_for_file(env, "resources/om/axis.xml"); + parser = guththila_create(env, red); + guththila_read(env, parser); + c = guththila_next(env, parser); + + while((c != GUTHTHILA_START_ELEMENT)) + c = guththila_next(env, parser); + p = guththila_get_name(env, parser); + fail_unless((c == GUTHTHILA_START_ELEMENT), "no start element found"); + fail_if((p == NULL), "no name found"); + fail_unless(!strcmp(p, "root"), "root element differed"); + c = 0; + + while((c != GUTHTHILA_START_ELEMENT)) + c = guththila_next(env, parser); + p = guththila_get_name(env, parser); + fail_unless((c == GUTHTHILA_START_ELEMENT), "no start element found"); + fail_if((p == NULL), "no name found"); + fail_unless(!strcmp(p, "a"), "a element differed"); + + c = 0; + while((c != GUTHTHILA_START_ELEMENT)) + c = guththila_next(env, parser); + p = guththila_get_name(env, parser); + fail_unless(!strcmp(p, "b"), "b element differed"); +} + +END_TEST +START_TEST( + test_guththila_empty_element) +{ + int c = 0; + char *p; + red = guththila_reader_create_for_file(env, "resources/om/axis.xml"); + parser = guththila_create(env, red); + guththila_read(env, parser); + c = guththila_next(env, parser); + + while((c != GUTHTHILA_EMPTY_ELEMENT)) + c = guththila_next(env, parser); + p = guththila_get_name(env, parser); + fail_unless((c == GUTHTHILA_EMPTY_ELEMENT), "no empty element found"); + fail_if((p == NULL), "no name found"); + fail_unless(!strcmp(p, "a.1"), "a.1 element differed"); + + c = 0; + + while((c != GUTHTHILA_EMPTY_ELEMENT)) + c = guththila_next(env, parser); + p = guththila_get_name(env, parser); + fail_unless((c == GUTHTHILA_EMPTY_ELEMENT), "no empty element found"); + fail_if((p == NULL), "no name found"); + fail_unless(!strcmp(p, "a.2"), "a.2 element differed"); + + c = 0; + while((c != GUTHTHILA_START_ELEMENT)) + c = guththila_next(env, parser); + + c = 0; + while((c != GUTHTHILA_EMPTY_ELEMENT)) + c = guththila_next(env, parser); + p = guththila_get_name(env, parser); + fail_unless((c == GUTHTHILA_EMPTY_ELEMENT), "no empty element found"); + fail_if((p == NULL), "no name found"); + fail_unless(!strcmp(p, "b.1"), "b.1 element differed"); +} + +END_TEST +START_TEST( + test_guththila_end_element) +{ + int c = 0; + char *p; + red = guththila_reader_create_for_file(env, "resources/om/axis.xml"); + parser = guththila_create(env, red); + guththila_read(env, parser); + c = guththila_next(env, parser); + + while((c != GUTHTHILA_END_ELEMENT)) + c = guththila_next(env, parser); + p = guththila_get_name(env, parser); + fail_unless((c == GUTHTHILA_END_ELEMENT), "no end element found"); + fail_if((p == NULL), "no name found"); + fail_unless(!strcmp(p, "a"), "a element differed"); + + c = 0; + while((c != GUTHTHILA_END_ELEMENT)) + c = guththila_next(env, parser); + p = guththila_get_name(env, parser); + fail_unless((c == GUTHTHILA_END_ELEMENT), "no endelement found"); + fail_if((p == NULL), "no name found"); + fail_unless(!strcmp(p, "b"), "b element differed"); + + c = 0; + while((c != GUTHTHILA_END_ELEMENT)) + c = guththila_next(env, parser); + p = guththila_get_name(env, parser); + fail_unless((c == GUTHTHILA_END_ELEMENT), "no empty element found"); + fail_if((p == NULL), "no name found"); + fail_unless(!strcmp(p, "root"), "root element differed"); +} + +END_TEST +START_TEST( + test_guththila_character) +{ + int c = 0; + int i = 0; + char *p; + red = guththila_reader_create_for_file(env, "resources/om/numbers.xml"); + parser = guththila_create(env, red); + guththila_read(env, parser); + c = guththila_next(env, parser); + while(i < 3) + { + if(c == GUTHTHILA_START_ELEMENT) + i++; + c = guththila_next(env, parser); + } + + if(c == GUTHTHILA_CHARACTER) + p = guththila_get_value(env, parser); + fail_unless(!strcmp(p, "3"), "3 not found"); + + c = 0; + while((c != GUTHTHILA_CHARACTER) || (parser->is_whitespace)) + c = guththila_next(env, parser); + p = guththila_get_value(env, parser); + fail_unless(!strcmp(p, "24"), "24 not found"); + +} +END_TEST Suite * +guththila_suite( + void) +{ + Suite *s = suite_create("Guththila"); + + /* Core test case */ + TCase *tc_core = tcase_create("Core"); + tcase_add_checked_fixture(tc_core, setup, teardown); + tcase_add_test(tc_core, test_guththila); + tcase_add_test(tc_core, test_guththila_start_element); + tcase_add_test(tc_core, test_guththila_empty_element); + tcase_add_test(tc_core, test_guththila_end_element); + tcase_add_test(tc_core, test_guththila_character); + suite_add_tcase(s, tc_core); + return s; +} + +int +main( + void) +{ + int number_failed; + Suite *s = guththila_suite(); + Suite *att = guththila_attribute_suite(); + SRunner *sr = srunner_create(s); + srunner_add_suite(sr, att); + srunner_set_log(sr, "guththila.log"); + srunner_run_all(sr, CK_NORMAL); + number_failed = srunner_ntests_failed(sr); + srunner_free(sr); + return (number_failed == 0) ? EXIT_SUCCESS : EXIT_FAILURE; +} diff --git a/guththila/tests/test.h b/guththila/tests/test.h new file mode 100644 index 0000000..93bebff --- /dev/null +++ b/guththila/tests/test.h @@ -0,0 +1,23 @@ +#ifndef _GUTHTHILA_TESTS_ +#define _GUTHTHILA_TESTS_ +#include <check.h> +#include <guththila.h> +#include "guththila_defines.h" + +axutil_allocator_t *allocator; +guththila_reader_t *red; +axutil_env_t *env; +guththila_t *parser; + +void setup( + void); +void teardown( + void); + +Suite *guththila_suite( + void); + +Suite *guththila_attribute_suite( + void); + +#endif diff --git a/guththila/tests/test_attribute.c b/guththila/tests/test_attribute.c new file mode 100644 index 0000000..bd6c4b5 --- /dev/null +++ b/guththila/tests/test_attribute.c @@ -0,0 +1,84 @@ +#include <guththila.h> +#include <check.h> +#include "test.h" + +START_TEST(test_attribute) +{ + int count = 0;; + int c = 0; + guththila_attribute_t *att; + red = guththila_reader_create_for_file(env, "resources/om/evaluate.xml"); + parser = guththila_create(env, red); + guththila_read(env, parser); + c = guththila_next(env, parser); + while (!count) + { + c = guththila_next(env, parser); + count = guththila_get_attribute_count(env, parser); + if (count) + att = guththila_get_attribute(env, parser); + } + fail_if(count == 0, "guththila attribute count failed"); + fail_unless(!strcmp + (guththila_get_attribute_name(env, parser, att), "color"), + "guththila attribute name failed"); + fail_unless(!strcmp + (guththila_get_attribute_value(env, parser, att), "brown"), + "guththila attribute value failed"); +} + +END_TEST +START_TEST( + test_attribute_prefix) +{ + int count = 0; + ; + int c = 0; + guththila_attribute_t *att; + red = guththila_reader_create_for_file(env, "resources/soap/soapmessage.xml"); + parser = guththila_create(env, red); + guththila_read(env, parser); + c = guththila_next(env, parser); + while(!count) + { + c = guththila_next(env, parser); + count = guththila_get_attribute_count(env, parser); + if(count) + att = guththila_get_attribute(env, parser); + } + fail_if(count == 0, "guththila attribute count failed"); + fail_unless(!strcmp(guththila_get_attribute_prefix(env, parser, att), "soapenv"), + "guththila attribute count failed"); + fail_unless(!strcmp(guththila_get_attribute_name(env, parser, att), "mustUnderstand"), + "guththila attribute count failed"); + fail_unless(!strcmp(guththila_get_attribute_value(env, parser, att), "0"), + "guththila attribute count failed"); + count = 0; + while(!count) + { + c = guththila_next(env, parser); + count = guththila_get_attribute_count(env, parser); + if(count) + att = guththila_get_attribute(env, parser); + } + fail_unless(!strcmp(guththila_get_attribute_prefix(env, parser, att), "soapenv"), + "guththila attribute count failed"); + fail_unless(!strcmp(guththila_get_attribute_name(env, parser, att), "mustUnderstand"), + "guththila attribute count failed"); + fail_if(!strcmp(guththila_get_attribute_value(env, parser, att), "1"), + "guththila attribute count failed"); +} +END_TEST Suite * +guththila_attribute_suite( + void) +{ + Suite *s = suite_create("Guththila_attribute"); + + /* Core test case */ + TCase *tc_core = tcase_create("attribute"); + tcase_add_checked_fixture(tc_core, setup, teardown); + tcase_add_test(tc_core, test_attribute); + tcase_add_test(tc_core, test_attribute_prefix); + suite_add_tcase(s, tc_core); + return s; +} |