[r2003-05-31 10:32:42 by cvscast] support for expat

Original author: cvscast
Date: 2003-05-31 10:32:43+00:00

Makefile.distrib

@@ -22,14 +22,17 @@ endif
 
 VERSION = 0.0.9
 
+SYNTAX_PARSER = -pp '$(SYNTAX)'
+
+CAMLC_P = ocamlc
 ifeq ($(PROFILE), true)
-	CAMLC_P = ocamlcp -p a
 	CAMLOPT_P = ocamlopt -p
-	SYNTAX_PARSER = 
+	ifeq ($(NATIVE), false) 
+         CAMLC_P = ocamlcp -p a
+         SYNTAX_PARSER = 
+        endif
 else
-	CAMLC_P = ocamlc
-	CAMLOPT_P = ocamlopt
-	SYNTAX_PARSER = -pp '$(SYNTAX)'
+	CAMLOPT_P = ocamlopt -inline 25
 endif
 
 OPT = -warn-error A
@@ -38,10 +41,10 @@ CAMLOPT = ocamlfind $(CAMLOPT_P) $(OPT) $(PACKAGES)
 
 ifeq ($(NATIVE), true)
 	EXTENSION = cmx
-	LINK = $(CAMLOPT) -linkpkg gramlib.cmxa
+	LINK = $(CAMLOPT) -linkpkg gramlib.cmxa mlexpat.cmxa 
 else
 	EXTENSION = cmo
-	LINK = $(CAMLC) -custom -linkpkg gramlib.cma
+	LINK = $(CAMLC) -custom -linkpkg gramlib.cma mlexpat.cma
 endif
 
 all: cduce dtd2cduce local_website
@@ -76,7 +79,7 @@ WEBIFACE  = $(OBJECTS) driver/examples.cmo driver/webiface.cmo
 DTD2CDUCE = tools/dtd2cduce.cmo
 
 DEPEND = $(DIRS:=/*.ml) $(DIRS:=/*.mli)
-INCLUDES = $(DIRS:%=-I %)
+INCLUDES = $(DIRS:%=-I %) -I expat
 
 cduce: $(CDUCE:.cmo=.$(EXTENSION))
 	$(LINK) $(INCLUDES) -o $@ $^
@@ -100,6 +103,7 @@ clean:
 	for i in $(CLEAN_DIRS); do \
 	(cd $$i; rm -f *.cmi *.cmo *.cma *.cmx *.o *~); \
 	done
+	(cd expat; make clean)
 	rm -f `find . -name "*~"`
 	rm -f *.cmi *.cmo *.cma *.cmx *.a *.cmxa *.o *~
 	rm -f cduce ocamlprof.dump
@@ -113,6 +117,10 @@ clean:
 misc/q_symbol.cmo: misc/q_symbol.ml
 	$(CAMLC) -c $<
 
+.PHONY: expat
+expat:
+	(cd expat; make)
+
 .ml.cmo:
 	$(CAMLC) -c $(SYNTAX_PARSER) $(INCLUDES) $<
 

depend

@@ -74,10 +74,12 @@ runtime/eval.cmo: misc/q_symbol.cmo types/ident.cmo types/patterns.cmi runtime/r
     typing/typed.cmo types/types.cmi runtime/value.cmi runtime/eval.cmi 
 runtime/eval.cmx: misc/q_symbol.cmo types/ident.cmx types/patterns.cmx runtime/run_dispatch.cmx \
     typing/typed.cmx types/types.cmx runtime/value.cmx runtime/eval.cmi 
-runtime/load_xml.cmo: misc/q_symbol.cmo types/atoms.cmi misc/encodings.cmi types/ident.cmo \
-    parser/location.cmi runtime/value.cmi runtime/load_xml.cmi 
-runtime/load_xml.cmx: misc/q_symbol.cmo types/atoms.cmx misc/encodings.cmx types/ident.cmx \
-    parser/location.cmx runtime/value.cmx runtime/load_xml.cmi 
+runtime/load_xml.cmo: misc/q_symbol.cmo types/atoms.cmi misc/encodings.cmi expat/expat.cmi \
+    types/ident.cmo parser/location.cmi runtime/value.cmi \
+    runtime/load_xml.cmi 
+runtime/load_xml.cmx: misc/q_symbol.cmo types/atoms.cmx misc/encodings.cmx expat/expat.cmx \
+    types/ident.cmx parser/location.cmx runtime/value.cmx \
+    runtime/load_xml.cmi 
 runtime/print_xml.cmo: misc/q_symbol.cmo types/atoms.cmi misc/encodings.cmi types/ident.cmo \
     parser/location.cmi types/sequence.cmi runtime/value.cmi 
 runtime/print_xml.cmx: misc/q_symbol.cmo types/atoms.cmx misc/encodings.cmx types/ident.cmx \
@@ -102,10 +104,12 @@ driver/cduce.cmx: misc/q_symbol.cmo parser/ast.cmx runtime/eval.cmx types/ident.
     parser/location.cmx parser/parser.cmx types/patterns.cmx types/sample.cmx \
     misc/state.cmx typing/typed.cmx typing/typer.cmx types/types.cmx \
     runtime/value.cmx parser/wlexer.cmx driver/cduce.cmi 
-driver/run.cmo: misc/q_symbol.cmo driver/cduce.cmi types/ident.cmo parser/location.cmi \
-    types/sequence.cmi misc/state.cmi runtime/value.cmi parser/wlexer.cmo 
-driver/run.cmx: misc/q_symbol.cmo driver/cduce.cmx types/ident.cmx parser/location.cmx \
-    types/sequence.cmx misc/state.cmx runtime/value.cmx parser/wlexer.cmx 
+driver/run.cmo: misc/q_symbol.cmo driver/cduce.cmi types/ident.cmo runtime/load_xml.cmi \
+    parser/location.cmi types/sequence.cmi misc/state.cmi runtime/value.cmi \
+    parser/wlexer.cmo 
+driver/run.cmx: misc/q_symbol.cmo driver/cduce.cmx types/ident.cmx runtime/load_xml.cmx \
+    parser/location.cmx types/sequence.cmx misc/state.cmx runtime/value.cmx \
+    parser/wlexer.cmx 
 driver/webiface.cmo: misc/q_symbol.cmo driver/cduce.cmi driver/examples.cmo parser/location.cmi \
     misc/state.cmi 
 driver/webiface.cmx: misc/q_symbol.cmo driver/cduce.cmx driver/examples.cmx parser/location.cmx \

driver/run.ml

@@ -17,6 +17,8 @@ let specs =
           "   specify filename for persistency";
     "--quiet", Arg.Set Cduce.quiet, 
            "  suppress normal output (typing, results)";
+    "--expat", Arg.Unit (fun () -> Load_xml.use_parser := `Expat),
+           "  use expat instead of PXP to parse XML documents";
     "-v", Arg.Unit version,
       "       print CDuce version";
     "--version", Arg.Unit version,

expat/LICENCE

+Copyright (c) 2002, 2003 by Maas-Maarten Zeeman
+
+The package ocaml-expat is copyright by Maas-Maarten Zeeman.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this document and the ocaml-expat software ("the Software"),
+to deal in the Software without restriction, including without
+limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+The Software is provided ``as is'', without warranty of any kind,
+express or implied, including but not limited to the warranties of
+merchantability, fitness for a particular purpose and noninfringement.
+In no event shall Maas-Maarten Zeeman be liable for any claim, damages
+or other liability, whether in an action of contract, tort or
+otherwise, arising from, out of or in connection with the Software or
+the use or other dealings in the software.

expat/Makefile

+EXPAT_LIB=-L/usr/lib -lexpat
+EXPAT_LIBDIR=/usr/lib
+EXPAT_INCDIR=/usr/include
+
+libmlexpat.a: expat_stubs.o expat.cmo expat.cmx
+	ocamlmklib -verbose -o mlexpat $^ $(EXPAT_LIB)
+
+expat.cmo: expat.cmi expat.ml
+	ocamlc -c expat.ml
+
+expat.cmx: expat.cmi expat.ml
+	ocamlopt -c expat.ml
+
+expat.cmi: expat.mli
+	ocamlc -c expat.mli
+
+clean:
+	rm -f *.o *.a *.so *.cmo *.cmx *.cmi *.cma *.cmxa

expat/expat.ml

+(***********************************************************************)
+(* The OcamlExpat library                                              *)
+(*                                                                     *)
+(* Copyright 2002, 2003 Maas-Maarten Zeeman. All rights reserved. See  *) 
+(* LICENCE for details.                                                *)
+(***********************************************************************)
+
+(* $Id: expat.ml,v 1.1 2003/05/31 10:32:42 cvscast Exp $ *)
+
+type expat_parser
+
+type xml_error =
+    XML_ERROR_NONE
+  | XML_ERROR_NO_MEMORY
+  | XML_ERROR_SYNTAX
+  | XML_ERROR_NO_ELEMENTS
+  | XML_ERROR_INVALID_TOKEN
+  | XML_ERROR_UNCLOSED_TOKEN
+  | XML_ERROR_PARTIAL_CHAR
+  | XML_ERROR_TAG_MISMATCH
+  | XML_ERROR_DUPLICATE_ATTRIBUTE
+  | XML_ERROR_JUNK_AFTER_DOC_ELEMENT
+  | XML_ERROR_PARAM_ENTITY_REF
+  | XML_ERROR_UNDEFINED_ENTITY
+  | XML_ERROR_RECURSIVE_ENTITY_REF
+  | XML_ERROR_ASYNC_ENTITY
+  | XML_ERROR_BAD_CHAR_REF
+  | XML_ERROR_BINARY_ENTITY_REF
+  | XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF
+  | XML_ERROR_MISPLACED_XML_PI
+  | XML_ERROR_UNKNOWN_ENCODING
+  | XML_ERROR_INCORRECT_ENCODING
+  | XML_ERROR_UNCLOSED_CDATA_SECTION
+  | XML_ERROR_EXTERNAL_ENTITY_HANDLING
+  | XML_ERROR_NOT_STANDALONE
+  | XML_ERROR_UNEXPECTED_STATE
+  | XML_ERROR_ENTITY_DECLARED_IN_PE
+  | XML_ERROR_FEATURE_REQUIRES_XML_DTD
+  | XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING
+
+exception Expat_error of xml_error
+
+external xml_error_to_string : xml_error -> string = "expat_XML_ErrorString"
+
+(* exception is currently too minimalistic, but it's a start *)
+let _ = Callback.register_exception "expat_error" 
+    (Expat_error XML_ERROR_NONE) 
+
+external expat_version : unit -> string = "expat_XML_ExpatVersion"
+
+(* calls to create a parser *)
+external parser_create : encoding:string -> expat_parser = 
+  "expat_XML_ParserCreate"
+external parser_create_ns : encoding:string -> separator:char -> expat_parser = 
+  "expat_XML_ParserCreateNS"
+
+(* calls needed to parse *)
+external parse : expat_parser -> string -> unit =  "expat_XML_Parse"
+external parse_sub : expat_parser -> string -> int -> int -> unit =  "expat_XML_Parse_sub"
+external final : expat_parser -> unit = "expat_XML_Final"
+
+(* start element handler calls *)
+external set_start_element_handler : expat_parser -> 
+  (string -> (string * string) list -> unit) -> unit = 
+    "expat_XML_SetStartElementHandler"
+external reset_start_element_handler : expat_parser -> unit = 
+  "expat_XML_ResetStartElementHandler"
+
+(* end element handler calls *)
+external set_end_element_handler : expat_parser -> (string -> unit) -> unit = 
+  "expat_XML_SetEndElementHandler"
+external reset_end_element_handler : expat_parser -> unit = 
+  "expat_XML_ResetEndElementHandler"
+
+(* character data handler calls *)
+external set_character_data_handler : expat_parser -> (string -> unit) -> unit = 
+  "expat_XML_SetCharacterDataHandler"
+external reset_character_data_handler : expat_parser -> unit = 
+  "expat_XML_ResetCharacterDataHandler"
+
+(* processing instruction handler calls *)
+external set_processing_instruction_handler : expat_parser -> 
+  (string -> string -> unit) -> unit =
+    "expat_XML_SetProcessingInstructionHandler"
+external reset_processing_instruction_handler : expat_parser -> unit =
+  "expat_XML_ResetProcessingInstructionHandler"
+
+(* comment handler *)
+external set_comment_handler : expat_parser -> (string -> unit) -> unit =
+  "expat_XML_SetCommentHandler"
+external reset_comment_handler : expat_parser -> unit =
+  "expat_XML_ResetCommentHandler"
+
+(* some general parser query calls *)
+external get_current_byte_index : expat_parser -> int = 
+  "expat_XML_GetCurrentByteIndex"
+external get_current_column_number : expat_parser -> int = 
+  "expat_XML_GetCurrentColumnNumber"
+external get_current_line_number : expat_parser -> int = 
+  "expat_XML_GetCurrentLineNumber"
+external get_current_byte_count : expat_parser -> int = 
+  "expat_XML_GetCurrentByteCount"
+
+
+

expat/expat.mli

+(***********************************************************************)
+(* The OcamlExpat library                                              *)
+(*                                                                     *)
+(* Copyright 2002, 2003 Maas-Maarten Zeeman. All rights reserved. See  *) 
+(* LICENCE for details.                                                *)
+(***********************************************************************)
+
+(* $Id: expat.mli,v 1.1 2003/05/31 10:32:42 cvscast Exp $ *)
+
+(** The Ocaml Expat library provides an interface to the Expat XML Parser.
+
+    Expat is a library, written C, for parsing XML documents. It's the
+    underlying for Mozilla, Perl's [XML::Parser], Python's
+    [xml.parser.expat], and other open source XML parsers. 
+
+    To use this library, link with 
+      [ocamlc expat.cma] 
+    or 
+      [ocamlopt expat.cmxa] 
+
+    @author Maas-Maarten Zeeman 
+*)
+
+(** The type of expat parsers *)
+type expat_parser
+
+(** {5 Parser Creation} *)
+
+(** Create a new XML parser. If encoding is not empty, it specifies
+    a character encoding to use for the document. This overrides the
+    document encoding declaration. Expat has four built in encodings.
+    [US-ASCII], [UTF-8], [UTF-16], [ISO-8859-1] *)
+val parser_create : encoding:string -> expat_parser
+
+(** Create a new XML parser that has namespace processing in effect *)
+val parser_create_ns : encoding:string -> separator:char -> expat_parser
+
+(** {5 Parsing} *)
+
+(** Let the parser parse a chunk of an XML document. 
+    @raise Expat_error error *)
+val parse : expat_parser -> string -> unit
+val parse_sub : expat_parser -> string -> int -> int -> unit
+
+(** Inform the parser that the entire document has been parsed.  *) 
+val final : expat_parser -> unit
+
+(** {5 Handler Setting and Resetting} 
+
+ The strings that are passed to the handlers are always encoded in
+ [UTF-8]. Your application is responsible for translation of these
+ strings into other encodings.
+ *)
+
+(** {6 Start element setting and resetting} *)
+
+val set_start_element_handler : expat_parser -> 
+  (string -> (string * string) list -> unit) -> unit 
+val reset_start_element_handler : expat_parser -> unit 
+
+(** {6 End element setting and resetting} *)
+
+val set_end_element_handler : expat_parser -> (string -> unit) -> unit 
+val reset_end_element_handler : expat_parser -> unit 
+
+(** {6 Character data hander setting and resetting} *)
+
+val set_character_data_handler : expat_parser -> (string -> unit) -> unit 
+val reset_character_data_handler : expat_parser -> unit
+
+(** {6 Processing Instruction handler setting and resetting} *)
+
+val set_processing_instruction_handler : expat_parser -> 
+  (string -> string -> unit) -> unit
+val reset_processing_instruction_handler : expat_parser -> unit
+
+(** {6 Comment handler setting and resetting} *)
+
+val set_comment_handler : expat_parser -> (string -> unit) -> unit
+val reset_comment_handler : expat_parser -> unit
+
+(** {5 Parse Position Functions} *)
+
+val get_current_byte_index : expat_parser -> int
+val get_current_column_number : expat_parser -> int
+val get_current_line_number : expat_parser -> int
+val get_current_byte_count : expat_parser -> int
+
+(** {5 Error Reporting} *)
+
+type xml_error =
+    XML_ERROR_NONE 
+  | XML_ERROR_NO_MEMORY
+  | XML_ERROR_SYNTAX
+  | XML_ERROR_NO_ELEMENTS
+  | XML_ERROR_INVALID_TOKEN
+  | XML_ERROR_UNCLOSED_TOKEN
+  | XML_ERROR_PARTIAL_CHAR
+  | XML_ERROR_TAG_MISMATCH
+  | XML_ERROR_DUPLICATE_ATTRIBUTE
+  | XML_ERROR_JUNK_AFTER_DOC_ELEMENT
+  | XML_ERROR_PARAM_ENTITY_REF
+  | XML_ERROR_UNDEFINED_ENTITY
+  | XML_ERROR_RECURSIVE_ENTITY_REF
+  | XML_ERROR_ASYNC_ENTITY
+  | XML_ERROR_BAD_CHAR_REF
+  | XML_ERROR_BINARY_ENTITY_REF
+  | XML_ERROR_ATTRIBUTE_EXTERNAL_ENTITY_REF
+  | XML_ERROR_MISPLACED_XML_PI
+  | XML_ERROR_UNKNOWN_ENCODING
+  | XML_ERROR_INCORRECT_ENCODING
+  | XML_ERROR_UNCLOSED_CDATA_SECTION
+  | XML_ERROR_EXTERNAL_ENTITY_HANDLING
+  | XML_ERROR_NOT_STANDALONE
+  | XML_ERROR_UNEXPECTED_STATE
+  | XML_ERROR_ENTITY_DECLARED_IN_PE
+  | XML_ERROR_FEATURE_REQUIRES_XML_DTD
+  | XML_ERROR_CANT_CHANGE_FEATURE_ONCE_PARSING
+
+(** Exception raised by parse function to report error conditions *)
+exception Expat_error of xml_error
+
+(** Converts a xml_error to a string *)
+val xml_error_to_string : xml_error -> string  
+
+(** {5 Miscellaneous Functions} *)
+
+(** Return the Expat library version as a string (e.g. "expat_1.95.1" *)
+val expat_version : unit -> string
+
+
+
+

expat/expat_stubs.c

+/***********************************************************************/
+/* The OcamlExpat library                                              */
+/*                                                                     */
+/* Copyright 2002, 2003 Maas-Maarten Zeeman. All rights reserved. See  */ 
+/* LICENCE for details.                                                */
+/***********************************************************************/
+
+/* $Id: expat_stubs.c,v 1.1 2003/05/31 10:32:42 cvscast Exp $ */
+
+/* Stub code to interface Ocaml with Expat */
+
+#include <stdio.h>
+#include <string.h>
+#include <expat.h>
+
+#include <caml/mlvalues.h>
+#include <caml/custom.h>
+#include <caml/alloc.h>
+#include <caml/memory.h>
+#include <caml/callback.h>
+#include <caml/fail.h>
+
+#define XML_Parser_val(v) (*((XML_Parser *) Data_custom_val(v)))
+
+/* Define the place where the handlers will be located inside the
+ * handler tuple which is registered as global root. Handlers for
+ * new functions should go here.
+ */
+#define NUM_HANDLERS 5
+enum expat_handler {
+  EXPAT_START_ELEMENT_HANDLER,
+  EXPAT_END_ELEMENT_HANDLER,
+  EXPAT_CHARACTER_DATA_HANDLER,
+  EXPAT_PROCESSING_INSTRUCTION_HANDLER,
+  EXPAT_COMMENT_HANDLER
+};
+
+static void 
+xml_parser_finalize(value parser) 
+{ 
+  XML_Parser xml_parser = XML_Parser_val(parser);
+  value *handlers = XML_GetUserData(xml_parser);
+
+  remove_global_root(handlers);
+  stat_free(handlers);
+
+  XML_ParserFree(xml_parser);  
+}
+
+static int 
+xml_parser_compare(value v1, value v2) 
+{ 
+  XML_Parser p1 = XML_Parser_val(v1);
+  XML_Parser p2 = XML_Parser_val(v2);
+  if(p1 == p2) return 0;
+  if(p1 < p2) return -1; 
+  return 1;
+}
+
+static long 
+xml_parser_hash(value v) 
+{ 
+  return (long) XML_Parser_val(v);
+}
+
+static struct custom_operations xml_parser_ops = {
+  "Expat_XML_Parser",
+  xml_parser_finalize,
+  xml_parser_compare,
+  xml_parser_hash,
+  custom_serialize_default,
+  custom_deserialize_default    
+};
+
+static XML_Parser
+parser_create(char *encoding)
+{
+  if(encoding[0] == '\0') 
+    return XML_ParserCreate(NULL);
+  return XML_ParserCreate(encoding);
+}
+
+static XML_Parser
+parser_create_ns(char *encoding, char sep)
+{
+  if(encoding[0] == '\0')
+    return XML_ParserCreateNS(NULL, sep);
+  return XML_ParserCreateNS(encoding, sep);
+}
+
+static value
+create_ocaml_expat_parser(XML_Parser xml_parser)
+{
+  CAMLparam0();
+  CAMLlocal1(parser);
+  int i;
+  value *handlers;
+
+  /* I don't know how to find out how much memory the parser consumes, so
+   * I've set some figures here, which seems to do well.
+   */
+  parser = alloc_custom(&xml_parser_ops, sizeof(XML_Parser), 1, 5000);
+  Store_field(parser, 1, Val_bp(xml_parser));
+    
+  /* Malloc a value for a tuple which will contain the callback
+   * handlers and register it as global root. 
+   */
+  handlers = stat_alloc(sizeof *handlers);
+  register_global_root(handlers);
+  *handlers = alloc_tuple(NUM_HANDLERS);
+  for(i = 0; i < NUM_HANDLERS; i++) {
+    Field(*handlers, i) = Val_unit;
+  }
+
+  /* Associate it as user data with the parser. This is possible because 
+   * a global root will not be relocated. 
+   */
+  XML_SetUserData(xml_parser, handlers);
+  
+  CAMLreturn (parser);
+}
+
+CAMLprim value 
+expat_XML_ParserCreate(value encoding)
+{
+  return create_ocaml_expat_parser(parser_create(String_val(encoding)));
+}
+
+CAMLprim value
+expat_XML_ParserCreateNS(value encoding, value sep)
+{ 
+  return create_ocaml_expat_parser(parser_create_ns(String_val(encoding),
+						    (char) Long_val(sep)));
+}
+
+CAMLprim value
+expat_XML_GetCurrentByteIndex(value parser)
+{
+  return Val_long(XML_GetCurrentByteIndex(XML_Parser_val(parser))); 
+}
+
+/*
+ * Return the current byte count
+ */
+CAMLprim value
+expat_XML_GetCurrentByteCount(value parser)
+{
+  return Val_long(XML_GetCurrentByteCount(XML_Parser_val(parser))); 
+}
+
+/* 
+ * Return the current column number
+ */
+CAMLprim value
+expat_XML_GetCurrentColumnNumber(value parser)
+{
+  return Val_long(XML_GetCurrentColumnNumber(XML_Parser_val(parser)));
+}
+
+/* 
+ * Returns the current line number
+ */
+CAMLprim value
+expat_XML_GetCurrentLineNumber(value parser)
+{
+  return Val_long(XML_GetCurrentLineNumber(XML_Parser_val(parser)));
+}
+
+/*
+ * Return the expat version number as a string
+ */
+value
+expat_XML_ExpatVersion(value unit)
+{
+  return copy_string(XML_ExpatVersion());
+}
+
+/*
+ * Return a string with the expat error message.
+ */
+CAMLprim value
+expat_XML_ErrorString(value error_code)
+{
+  CAMLparam1(error_code);
+  const char *error_string = XML_ErrorString(Int_val(error_code));
+
+  /* XML_ErrorString(XML_ERROR_NONE) returns NULL, this check
+   * will return an empty string whenever this happens. Note:
+   * it checks for NULL, because that is the safest way.
+   */
+  if (error_string == NULL) 
+    CAMLreturn (alloc_string(0));
+  CAMLreturn (copy_string(error_string));
+}
+
+/* 
+ * Raise an expat_error exception
+ */
+static void
+expat_error(int error_code)
+{
+  static value * expat_error_exn = NULL;
+
+  if(expat_error_exn == NULL) {
+    expat_error_exn = caml_named_value("expat_error");
+    if(expat_error_exn == NULL) {
+      invalid_argument("Exception Expat_error not initialized");
+    }
+  }
+
+  raise_with_arg(*expat_error_exn, Val_long(error_code));
+}
+
+/*
+ * The parse call
+ */
+CAMLprim value
+expat_XML_Parse(value parser, value string)
+{
+  CAMLparam2(parser, string);
+  XML_Parser xml_parser =  XML_Parser_val(parser);
+
+  if(!XML_Parse(xml_parser, String_val(string), string_length(string), 0)) {
+    expat_error(XML_GetErrorCode(xml_parser));
+  }
+  
+  CAMLreturn (Val_unit);
+}
+
+CAMLprim value
+expat_XML_Parse_sub(value parser, value string, value pos, value len)
+{
+  CAMLparam2(parser, string);
+  XML_Parser xml_parser =  XML_Parser_val(parser);
+
+  if(!XML_Parse(xml_parser, String_val(string)+Int_val(pos), Int_val(len), 0)) {
+    expat_error(XML_GetErrorCode(xml_parser));
+  }
+  
+  CAMLreturn (Val_unit);
+}
+
+/*
+ * The final call
+ */
+CAMLprim value
+expat_XML_Final(value parser)
+{
+  CAMLparam1(parser);