## relaxng

relaxng —

## Synopsis

    struct      xmlRelaxNG;
    typedef     xmlRelaxNGPtr;
    void        (*xmlRelaxNGValidityErrorFunc)  (void *ctx,
                                                 const char *msg,
                                                 ...);
    void        (*xmlRelaxNGValidityWarningFunc)
                                                (void *ctx,
                                                 const char *msg,
                                                 ...);
    struct      xmlRelaxNGParserCtxt;
    typedef     xmlRelaxNGParserCtxtPtr;
    struct      xmlRelaxNGValidCtxt;
    typedef     xmlRelaxNGValidCtxtPtr;
    enum        xmlRelaxNGValidErr;
    xmlRelaxNGParserCtxtPtr xmlRelaxNGNewParserCtxt
                                                (const char *URL);
    xmlRelaxNGParserCtxtPtr xmlRelaxNGNewMemParserCtxt
                                                (const char *buffer,
                                                 int size);
    xmlRelaxNGParserCtxtPtr xmlRelaxNGNewDocParserCtxt
                                                (xmlDocPtr doc);
    void        xmlRelaxNGFreeParserCtxt        (xmlRelaxNGParserCtxtPtr ctxt);
    void        xmlRelaxNGSetParserErrors       (xmlRelaxNGParserCtxtPtr ctxt,
                                                 xmlRelaxNGValidityErrorFunc err,
                                                 xmlRelaxNGValidityWarningFunc warn,
                                                 void *ctx);
    int         xmlRelaxNGGetParserErrors       (xmlRelaxNGParserCtxtPtr ctxt,
                                                 xmlRelaxNGValidityErrorFunc *err,
                                                 xmlRelaxNGValidityWarningFunc *warn,
                                                 void **ctx);
    xmlRelaxNGPtr xmlRelaxNGParse               (xmlRelaxNGParserCtxtPtr ctxt);
    void        xmlRelaxNGFree                  (xmlRelaxNGPtr schema);
    void        xmlRelaxNGDump                  (FILE *output,
                                                 xmlRelaxNGPtr schema);
    void        xmlRelaxNGDumpTree              (FILE *output,
                                                 xmlRelaxNGPtr schema);
    void        xmlRelaxNGSetValidErrors        (xmlRelaxNGValidCtxtPtr ctxt,
                                                 xmlRelaxNGValidityErrorFunc err,
                                                 xmlRelaxNGValidityWarningFunc warn,
                                                 void *ctx);
    int         xmlRelaxNGGetValidErrors        (xmlRelaxNGValidCtxtPtr ctxt,
                                                 xmlRelaxNGValidityErrorFunc *err,
                                                 xmlRelaxNGValidityWarningFunc *warn,
                                                 void **ctx);
    xmlRelaxNGValidCtxtPtr xmlRelaxNGNewValidCtxt
                                                (xmlRelaxNGPtr schema);
    void        xmlRelaxNGFreeValidCtxt         (xmlRelaxNGValidCtxtPtr ctxt);
    int         xmlRelaxNGValidateDoc           (xmlRelaxNGValidCtxtPtr ctxt,
                                                 xmlDocPtr doc);
    void        xmlRelaxNGCleanupTypes          (void);
    int         xmlRelaxNGValidatePushElement   (xmlRelaxNGValidCtxtPtr ctxt,
                                                 xmlDocPtr doc,
                                                 xmlNodePtr elem);
    int         xmlRelaxNGValidatePushCData     (xmlRelaxNGValidCtxtPtr ctxt,
                                                 const xmlChar *data,
                                                 int len);
    int         xmlRelaxNGValidatePopElement    (xmlRelaxNGValidCtxtPtr ctxt,
                                                 xmlDocPtr doc,
                                                 xmlNodePtr elem);
    int         xmlRelaxNGValidateFullElement   (xmlRelaxNGValidCtxtPtr ctxt,
                                                 xmlDocPtr doc,
                                                 xmlNodePtr elem);

## Description

## Details

### struct xmlRelaxNG

    struct xmlRelaxNG;

### xmlRelaxNGPtr

    typedef xmlRelaxNG *xmlRelaxNGPtr;

### xmlRelaxNGValidityErrorFunc ()

    void        (*xmlRelaxNGValidityErrorFunc)  (void *ctx,
                                                 const char *msg,
                                                 ...);

`ctx` : |
`msg` : |
`...` : |

### xmlRelaxNGValidityWarningFunc ()

    void        (*xmlRelaxNGValidityWarningFunc)
                                                (void *ctx,
                                                 const char *msg,
                                                 ...);

`ctx` : |
`msg` : |
`...` : |

### struct xmlRelaxNGParserCtxt

    struct xmlRelaxNGParserCtxt;

### xmlRelaxNGParserCtxtPtr

    typedef xmlRelaxNGParserCtxt *xmlRelaxNGParserCtxtPtr;

### struct xmlRelaxNGValidCtxt

    struct xmlRelaxNGValidCtxt;

A RelaxNGs validation context

### xmlRelaxNGValidCtxtPtr

    typedef xmlRelaxNGValidCtxt *xmlRelaxNGValidCtxtPtr;

### enum xmlRelaxNGValidErr

    typedef enum {
        XML_RELAXNG_OK = 0,
        XML_RELAXNG_ERR_MEMORY,
        XML_RELAXNG_ERR_TYPE,
        XML_RELAXNG_ERR_TYPEVAL,
        XML_RELAXNG_ERR_DUPID,
        XML_RELAXNG_ERR_TYPECMP,
        XML_RELAXNG_ERR_NOSTATE,
        XML_RELAXNG_ERR_NODEFINE,
        XML_RELAXNG_ERR_LISTEXTRA,
        XML_RELAXNG_ERR_LISTEMPTY,
        XML_RELAXNG_ERR_INTERNODATA,
        XML_RELAXNG_ERR_INTERSEQ,
        XML_RELAXNG_ERR_INTEREXTRA,
        XML_RELAXNG_ERR_ELEMNAME,
        XML_RELAXNG_ERR_ATTRNAME,
        XML_RELAXNG_ERR_ELEMNONS,
        XML_RELAXNG_ERR_ATTRNONS,
        XML_RELAXNG_ERR_ELEMWRONGNS,
        XML_RELAXNG_ERR_ATTRWRONGNS,
        XML_RELAXNG_ERR_ELEMEXTRANS,
        XML_RELAXNG_ERR_ATTREXTRANS,
        XML_RELAXNG_ERR_ELEMNOTEMPTY,
        XML_RELAXNG_ERR_NOELEM,
        XML_RELAXNG_ERR_NOTELEM,
        XML_RELAXNG_ERR_ATTRVALID,
        XML_RELAXNG_ERR_CONTENTVALID,
        XML_RELAXNG_ERR_EXTRACONTENT,
        XML_RELAXNG_ERR_INVALIDATTR,
        XML_RELAXNG_ERR_DATAELEM,
        XML_RELAXNG_ERR_VALELEM,
        XML_RELAXNG_ERR_LISTELEM,
        XML_RELAXNG_ERR_DATATYPE,
        XML_RELAXNG_ERR_VALUE,
        XML_RELAXNG_ERR_LIST,
        XML_RELAXNG_ERR_NOGRAMMAR,
        XML_RELAXNG_ERR_EXTRADATA,
        XML_RELAXNG_ERR_LACKDATA,
        XML_RELAXNG_ERR_INTERNAL,
        XML_RELAXNG_ERR_ELEMWRONG,
        XML_RELAXNG_ERR_TEXTWRONG
    } xmlRelaxNGValidErr;

### xmlRelaxNGNewParserCtxt ()

    xmlRelaxNGParserCtxtPtr xmlRelaxNGNewParserCtxt
                                                (const char *URL);

Create an XML RelaxNGs parse context for that file/resource expected to contain an XML RelaxNGs file.

`URL` : | the location of the schema
Returns : | the parser context or NULL in case of error

### xmlRelaxNGNewMemParserCtxt ()

    xmlRelaxNGParserCtxtPtr xmlRelaxNGNewMemParserCtxt
                                                (const char *buffer,
                                                 int size);

Create an XML RelaxNGs parse context for that memory buffer expected to contain an XML RelaxNGs file.

`buffer` : | a pointer to a char array containing the schemas
`size` : | the size of the array
Returns : | the parser context or NULL in case of error

### xmlRelaxNGNewDocParserCtxt ()

    xmlRelaxNGParserCtxtPtr xmlRelaxNGNewDocParserCtxt
                                                (xmlDocPtr doc);

Create an XML RelaxNGs parser context for that document. Note: since the process of compiling a RelaxNG schemas modifies the document, the `doc` parameter is duplicated internally.

`doc` : | a preparsed document tree
Returns : | the parser context or NULL in case of error

### xmlRelaxNGFreeParserCtxt ()

    void        xmlRelaxNGFreeParserCtxt        (xmlRelaxNGParserCtxtPtr ctxt);

Free the resources associated to the schema parser context

`ctxt` : | the schema parser context

### xmlRelaxNGSetParserErrors ()

    void        xmlRelaxNGSetParserErrors       (xmlRelaxNGParserCtxtPtr ctxt,
                                                 xmlRelaxNGValidityErrorFunc err,
                                                 xmlRelaxNGValidityWarningFunc warn,
                                                 void *ctx);

Set the callback functions used to handle errors for a validation context

`ctxt` : | a Relax-NG validation context
`err` : | the error callback
`warn` : | the warning callback
`ctx` : | contextual data for the callbacks

### xmlRelaxNGGetParserErrors ()

    int         xmlRelaxNGGetParserErrors       (xmlRelaxNGParserCtxtPtr ctxt,
                                                 xmlRelaxNGValidityErrorFunc *err,
                                                 xmlRelaxNGValidityWarningFunc *warn,
                                                 void **ctx);

Get the callback information used to handle errors for a validation context

`ctxt` : | a Relax-NG validation context
`err` : | the error callback result
`warn` : | the warning callback result
`ctx` : | contextual data for the callbacks result
Returns : | -1 in case of failure, 0 otherwise.

### xmlRelaxNGParse ()

    xmlRelaxNGPtr xmlRelaxNGParse               (xmlRelaxNGParserCtxtPtr ctxt);

parse a schema definition resource and build an internal XML Shema struture which can be used to validate instances. *WARNING* this interface is highly subject to change

`ctxt` : | a Relax-NG parser context
Returns : | the internal XML RelaxNG structure built from the resource or NULL in case of error

### xmlRelaxNGFree ()

    void        xmlRelaxNGFree                  (xmlRelaxNGPtr schema);

Deallocate a RelaxNG structure.

`schema` : | a schema structure

### xmlRelaxNGDump ()

    void        xmlRelaxNGDump                  (FILE *output,
                                                 xmlRelaxNGPtr schema);

Dump a RelaxNG structure back

`output` : | the file output
`schema` : | a schema structure

### xmlRelaxNGDumpTree ()

    void        xmlRelaxNGDumpTree              (FILE *output,
                                                 xmlRelaxNGPtr schema);

Dump the transformed RelaxNG tree.

`output` : | the file output
`schema` : | a schema structure

### xmlRelaxNGSetValidErrors ()

    void        xmlRelaxNGSetValidErrors        (xmlRelaxNGValidCtxtPtr ctxt,
                                                 xmlRelaxNGValidityErrorFunc err,
                                                 xmlRelaxNGValidityWarningFunc warn,
                                                 void *ctx);

Set the error and warning callback informations

`ctxt` : | a Relax-NG validation context
`err` : | the error function
`warn` : | the warning function
`ctx` : | the functions context

### xmlRelaxNGGetValidErrors ()

    int         xmlRelaxNGGetValidErrors        (xmlRelaxNGValidCtxtPtr ctxt,
                                                 xmlRelaxNGValidityErrorFunc *err,
                                                 xmlRelaxNGValidityWarningFunc *warn,
                                                 void **ctx);

Get the error and warning callback informations

`ctxt` : | a Relax-NG validation context
`err` : | the error function result
`warn` : | the warning function result
`ctx` : | the functions context result
Returns : | -1 in case of error and 0 otherwise

### xmlRelaxNGNewValidCtxt ()

    xmlRelaxNGValidCtxtPtr xmlRelaxNGNewValidCtxt
                                                (xmlRelaxNGPtr schema);

Create an XML RelaxNGs validation context based on the given schema

`schema` : | a precompiled XML RelaxNGs
Returns : | the validation context or NULL in case of error

### xmlRelaxNGFreeValidCtxt ()

    void        xmlRelaxNGFreeValidCtxt         (xmlRelaxNGValidCtxtPtr ctxt);

Free the resources associated to the schema validation context

`ctxt` : | the schema validation context

### xmlRelaxNGValidateDoc ()

    int         xmlRelaxNGValidateDoc           (xmlRelaxNGValidCtxtPtr ctxt,
                                                 xmlDocPtr doc);

Validate a document tree in memory.

`ctxt` : | a Relax-NG validation context
`doc` : | a parsed document tree
Returns : | 0 if the document is valid, a positive error code number otherwise and -1 in case of internal or API error.

### xmlRelaxNGCleanupTypes ()

    void        xmlRelaxNGCleanupTypes          (void);

Cleanup the default Schemas type library associated to RelaxNG

### xmlRelaxNGValidatePushElement ()

    int         xmlRelaxNGValidatePushElement   (xmlRelaxNGValidCtxtPtr ctxt,
                                                 xmlDocPtr doc,
                                                 xmlNodePtr elem);

Push a new element start on the RelaxNG validation stack.

`ctxt` : | the validation context
`doc` : | a document instance
`elem` : | an element instance
Returns : | 1 if no validation problem was found or 0 if validating the element requires a full node, and -1 in case of error.

### xmlRelaxNGValidatePushCData ()

    int         xmlRelaxNGValidatePushCData     (xmlRelaxNGValidCtxtPtr ctxt,
                                                 const xmlChar *data,
                                                 int len);

check the CData parsed for validation in the current stack

`ctxt` : | the RelaxNG validation context
`data` : | some character data read
`len` : | the lenght of the data
Returns : | 1 if no validation problem was found or -1 otherwise

### xmlRelaxNGValidatePopElement ()

    int         xmlRelaxNGValidatePopElement    (xmlRelaxNGValidCtxtPtr ctxt,
                                                 xmlDocPtr doc,
                                                 xmlNodePtr elem);

Pop the element end from the RelaxNG validation stack.

`ctxt` : | the RelaxNG validation context
`doc` : | a document instance
`elem` : | an element instance
Returns : | 1 if no validation problem was found or 0 otherwise

### xmlRelaxNGValidateFullElement ()

    int         xmlRelaxNGValidateFullElement   (xmlRelaxNGValidCtxtPtr ctxt,
                                                 xmlDocPtr doc,
                                                 xmlNodePtr elem);

Validate a full subtree when xmlRelaxNGValidatePushElement() returned 0 and the content of the node has been expanded.

`ctxt` : | the validation context
`doc` : | a document instance
`elem` : | an element instance
Returns : | 1 if no validation problem was found or -1 in case of error.