Go to the first, previous, next, last section, table of contents.


The Pxp_types module

type ext_id =
    System of string
  | Public of (string * string)
  | Anonymous

external identifiers are either "system identifiers" (filenames or URLs), or "public identifiers" Public(id,sysid) where "id" is the representation of the public ID, and "sysid" a fallback system ID, or the empty string.

New in PXP: Sometimes the external ID is not known. This case can be referred to as Anonymous ID.

Encoding: The identifiers are _always_ encoded as UTF8 strings, regardless of whether another encoding is configured for the parser. TODO: umsetzen

type dtd_id =
    External of ext_id       (* DTD is completely

 external *)
  | Derived of ext_id        (* DTD is derived from an

 external DTD *)
  | Internal                 (* DTD is completely internal *)
;;
type content_model_type =
    Unspecified              (* A specification of the model has not yet been
			      * found
			      *)
  | Empty                    (* Nothing is allowed as content *)
  | Any                      (* Everything is allowed as content *)
  | Mixed of mixed_spec list (* The contents consist of elements
 and PCDATA 
			      * in arbitrary order. What is allowed in
			      * particular is given as mixed_spec.
			      *)
  | Regexp of regexp_spec    (* The contents are elements following this regular
			      * expression
			      *)
and mixed_spec =
    MPCDATA                  (* PCDATA children are allowed *)
  | MChild of string         (* This kind of Element is allowed *)
and regexp_spec =
    Optional of regexp_spec  (* subexpression? *)
  | Repeated of regexp_spec  (* subexpression* *)
  | Repeated1 of regexp_spec (* subexpression+ *)
  | Alt of regexp_spec list  (* subexpr1 | subexpr2 | ... | subexprN *)
  | Seq of regexp_spec list  (* subexpr1 , subexpr2 , ... , subexprN *)
  | Child of string          (* This kind of Element is allowed here *)
;;
type att_type =
    A_cdata                    (* CDATA *)
  | A_id                       (* ID *)
  | A_idref                    (* IDREF *)
  | A_idrefs                   (* IDREFS *)
  | A_entity                   (* ENTITY *)
  | A_entities                 (* ENTiTIES *)
  | A_nmtoken                  (* NMTOKEN *)
  | A_nmtokens                 (* NMTOKENS *)
  | A_notation of string list  (* NOTATION (name1 | name2 | ... | nameN) *)
  | A_enum of string list      (* (name1 | name2 | ... | nameN) *)
;;
type att_default =
    D_required           (* #REQUIRED *)
  | D_implied            (* #IMPLIED *)
  | D_default of string  (* <value> -- The value is already expanded *)
  | D_fixed of string    (* FIXED <value> -- The value is already expanded *)
;;
type att_value =
    Value of string           (* a single value *)
  | Valuelist of string list  (* a list of values *)
  | Implied_value             (* a value left out *)
;;

class
 type collect_warnings =
  object 
    method warn : string -> unit
  end
;;

class drop_warnings : collect_warnings;;
type encoding = Netconversion.encoding;;

We accept all encodings for character sets which are defined in Netconversion (package netstring).

type rep_encoding =

The subset of 'encoding' that may be used for internal representation of strings. Note: The following encodings are ASCII-compatible! This is an important property used throghout the whole PXP code.

  [ `Enc_utf8       (* UTF-8 *)
  | `Enc_iso88591   (* ISO-8859-1 *)
  ]
;;
exception Validation_error of string

Violation of a validity constraint

exception WF_error of string

Violation of a well-formedness constraint

exception Error of string

Other error

exception Character_not_supported
exception At of (string * exn)

The string is a description where the exn happened. The exn value can again be At(_,_) (for example, when an entity within an entity causes the error).

exception Undeclared

Indicates that declaration is available and because of this every kind of usage is allowed.

val string_of_exn : exn -> string

Converts a Markup exception into a readable string

type output_stream =
    Out_buffer of Buffer.t
  | Out_channel of out_channel
  | Out_function of (string -> int -> int -> unit)

val write : output_stream -> string -> int -> int -> unit

write os s pos len: Writes the string to the buffer/channel/stream


Go to the first, previous, next, last section, table of contents.