From 80ce373e9ae7340ad2165f243c47071291ccb9e1 Mon Sep 17 00:00:00 2001 From: Daniel Veillard Date: Mon, 7 Oct 2002 17:39:30 +0000 Subject: [PATCH] Regenerated the docs and added a set of files missing from CVS, Daniel --- doc/gnome-xml.sgml | 6 + doc/html/book1.html | 15 + doc/html/index.sgml | 66 + doc/html/libxml-catalog.html | 2 +- doc/html/libxml-lib.html | 15 + doc/html/libxml-schemasinternals.html | 1547 ++++ doc/html/libxml-valid.html | 5 +- doc/html/libxml-xmlautomata.html | 2582 ++++++ doc/html/libxml-xmlregexp.html | 1356 +++ doc/html/libxml-xmlschemas.html | 1922 ++++ doc/html/libxml-xmlschemastypes.html | 844 ++ doc/html/libxml-xmlunicode.html | 11736 ++++++++++++++++++++++++ doc/libxml2-api.xml | 196 +- doc/libxml2-refs.xml | 131 +- 14 files changed, 20370 insertions(+), 53 deletions(-) create mode 100644 doc/html/libxml-schemasinternals.html create mode 100644 doc/html/libxml-xmlautomata.html create mode 100644 doc/html/libxml-xmlregexp.html create mode 100644 doc/html/libxml-xmlschemas.html create mode 100644 doc/html/libxml-xmlschemastypes.html create mode 100644 doc/html/libxml-xmlunicode.html diff --git a/doc/gnome-xml.sgml b/doc/gnome-xml.sgml index f856e4f6..d8fa1ca3 100644 --- a/doc/gnome-xml.sgml +++ b/doc/gnome-xml.sgml @@ -28,6 +28,9 @@ + + + ]> @@ -116,6 +119,9 @@ &xmlregexp; &xmlautomata; &xmlunicode; + &xmlschemas; + &xmlschemastypes; + &schemasInternals; diff --git a/doc/html/book1.html b/doc/html/book1.html index 32e8874d..43b3367e 100644 --- a/doc/html/book1.html +++ b/doc/html/book1.html @@ -261,6 +261,21 @@ HREF="libxml-xmlautomata.html" HREF="libxml-xmlunicode.html" >xmlunicode -- 
xmlschemas -- 
xmlschemastypes -- 
schemasInternals -- 
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/doc/html/libxml-catalog.html b/doc/html/libxml-catalog.html index 69826778..f22959dc 100644 --- a/doc/html/libxml-catalog.html +++ b/doc/html/libxml-catalog.html @@ -2145,7 +2145,7 @@ CLASS="PARAMETER" WIDTH="80%" ALIGN="LEFT" VALIGN="TOP" -> a list of file path separated by ':' or spaces a space-separated list of catalog files.xmlunicode -- 
xmlschemas -- 
xmlschemastypes -- 
schemasInternals -- 

schemasInternals

Gnome XML Library Reference Manual
<<< Previous PageHomeUp 

schemasInternals

Name

schemasInternals -- 

Synopsis


+
+enum        xmlSchemaTypeType;
+enum        xmlSchemaContentType;
+struct      xmlSchemaVal;
+typedef     xmlSchemaValPtr;
+struct      xmlSchemaType;
+typedef     xmlSchemaTypePtr;
+struct      xmlSchemaFacet;
+typedef     xmlSchemaFacetPtr;
+struct      xmlSchemaAnnot;
+typedef     xmlSchemaAnnotPtr;
+#define     XML_SCHEMAS_ANYATTR_SKIP
+#define     XML_SCHEMAS_ANYATTR_LAX
+#define     XML_SCHEMAS_ANYATTR_STRICT
+struct      xmlSchemaAttribute;
+typedef     xmlSchemaAttributePtr;
+struct      xmlSchemaAttributeGroup;
+typedef     xmlSchemaAttributeGroupPtr;
+#define     XML_SCHEMAS_TYPE_MIXED
+#define     XML_SCHEMAS_ELEM_NILLABLE
+#define     XML_SCHEMAS_ELEM_GLOBAL
+#define     XML_SCHEMAS_ELEM_DEFAULT
+#define     XML_SCHEMAS_ELEM_FIXED
+#define     XML_SCHEMAS_ELEM_ABSTRACT
+#define     XML_SCHEMAS_ELEM_TOPLEVEL
+#define     XML_SCHEMAS_ELEM_REF
+struct      xmlSchemaElement;
+typedef     xmlSchemaElementPtr;
+#define     XML_SCHEMAS_FACET_UNKNOWN
+#define     XML_SCHEMAS_FACET_PRESERVE
+#define     XML_SCHEMAS_FACET_REPLACE
+#define     XML_SCHEMAS_FACET_COLLAPSE
+struct      xmlSchemaNotation;
+typedef     xmlSchemaNotationPtr;
+#define     XML_SCHEMAS_QUALIF_ELEM
+#define     XML_SCHEMAS_QUALIF_ATTR
+struct      xmlSchema;
+void        xmlSchemaFreeType               (xmlSchemaTypePtr type);

Description

Details

enum xmlSchemaTypeType

typedef enum {
+    XML_SCHEMA_TYPE_BASIC = 1,
+    XML_SCHEMA_TYPE_ANY,
+    XML_SCHEMA_TYPE_FACET,
+    XML_SCHEMA_TYPE_SIMPLE,
+    XML_SCHEMA_TYPE_COMPLEX,
+    XML_SCHEMA_TYPE_SEQUENCE,
+    XML_SCHEMA_TYPE_CHOICE,
+    XML_SCHEMA_TYPE_ALL,
+    XML_SCHEMA_TYPE_SIMPLE_CONTENT,
+    XML_SCHEMA_TYPE_COMPLEX_CONTENT,
+    XML_SCHEMA_TYPE_UR,
+    XML_SCHEMA_TYPE_RESTRICTION,
+    XML_SCHEMA_TYPE_EXTENSION,
+    XML_SCHEMA_TYPE_ELEMENT,
+    XML_SCHEMA_TYPE_ATTRIBUTE,
+    XML_SCHEMA_TYPE_ATTRIBUTEGROUP,
+    XML_SCHEMA_TYPE_GROUP,
+    XML_SCHEMA_TYPE_NOTATION,
+    XML_SCHEMA_TYPE_LIST,
+    XML_SCHEMA_TYPE_UNION,
+    XML_SCHEMA_FACET_MININCLUSIVE = 1000,
+    XML_SCHEMA_FACET_MINEXCLUSIVE,
+    XML_SCHEMA_FACET_MAXINCLUSIVE,
+    XML_SCHEMA_FACET_MAXEXCLUSIVE,
+    XML_SCHEMA_FACET_TOTALDIGITS,
+    XML_SCHEMA_FACET_FRACTIONDIGITS,
+    XML_SCHEMA_FACET_PATTERN,
+    XML_SCHEMA_FACET_ENUMERATION,
+    XML_SCHEMA_FACET_WHITESPACE,
+    XML_SCHEMA_FACET_LENGTH,
+    XML_SCHEMA_FACET_MAXLENGTH,
+    XML_SCHEMA_FACET_MINLENGTH
+} xmlSchemaTypeType;

enum xmlSchemaContentType

typedef enum {
+    XML_SCHEMA_CONTENT_UNKNOWN = 0,
+    XML_SCHEMA_CONTENT_EMPTY = 1,
+    XML_SCHEMA_CONTENT_ELEMENTS,
+    XML_SCHEMA_CONTENT_MIXED,
+    XML_SCHEMA_CONTENT_SIMPLE,
+    XML_SCHEMA_CONTENT_MIXED_OR_ELEMENTS,
+    XML_SCHEMA_CONTENT_BASIC,
+    XML_SCHEMA_CONTENT_ANY
+} xmlSchemaContentType;

struct xmlSchemaVal

struct xmlSchemaVal;

xmlSchemaValPtr

typedef xmlSchemaVal *xmlSchemaValPtr;

struct xmlSchemaType

struct xmlSchemaType {
+    xmlSchemaTypeType type;	/* The kind of type */
+    struct _xmlSchemaType *next;/* the next type if in a sequence ... */
+    xmlChar *name;
+    xmlChar *id;
+    xmlChar *ref;
+    xmlChar *refNs;
+    xmlSchemaAnnotPtr annot;
+    xmlSchemaTypePtr subtypes;
+    xmlSchemaAttributePtr attributes;
+    xmlNodePtr node;
+    int minOccurs;
+    int maxOccurs;
+
+    int flags;
+    xmlSchemaContentType contentType;
+    xmlChar *base;
+    xmlChar *baseNs;
+    xmlSchemaTypePtr baseType;
+    xmlSchemaFacetPtr facets;
+};

xmlSchemaTypePtr

typedef xmlSchemaType *xmlSchemaTypePtr;

struct xmlSchemaFacet

struct xmlSchemaFacet {
+    xmlSchemaTypeType type;	/* The kind of type */
+    struct _xmlSchemaFacet *next;/* the next type if in a sequence ... */
+    xmlChar *value;
+    xmlChar *id;
+    xmlSchemaAnnotPtr annot;
+    xmlNodePtr node;
+    int fixed;
+    int whitespace;
+    xmlSchemaValPtr val;
+    xmlRegexpPtr    regexp;
+};

xmlSchemaFacetPtr

typedef xmlSchemaFacet *xmlSchemaFacetPtr;

struct xmlSchemaAnnot

struct xmlSchemaAnnot {
+    struct _xmlSchemaAnnot *next;
+    xmlNodePtr content;         /* the annotation */
+};

xmlSchemaAnnotPtr

typedef xmlSchemaAnnot *xmlSchemaAnnotPtr;

XML_SCHEMAS_ANYATTR_SKIP

#define XML_SCHEMAS_ANYATTR_SKIP	1

XML_SCHEMAS_ANYATTR_LAX

#define XML_SCHEMAS_ANYATTR_LAX		2

XML_SCHEMAS_ANYATTR_STRICT

#define XML_SCHEMAS_ANYATTR_STRICT	3

struct xmlSchemaAttribute

struct xmlSchemaAttribute {
+    xmlSchemaTypeType type;	/* The kind of type */
+    struct _xmlSchemaAttribute *next;/* the next attribute if in a group ... */
+    xmlChar *name;
+    xmlChar *id;
+    xmlChar *ref;
+    xmlChar *refNs;
+    xmlChar *typeName;
+    xmlChar *typeNs;
+    xmlSchemaAnnotPtr annot;
+
+    xmlSchemaTypePtr base;
+    int occurs;
+    xmlChar *defValue;
+    xmlSchemaTypePtr subtypes;
+};

xmlSchemaAttributePtr

typedef xmlSchemaAttribute *xmlSchemaAttributePtr;

struct xmlSchemaAttributeGroup

struct xmlSchemaAttributeGroup {
+    xmlSchemaTypeType type;	/* The kind of type */
+    struct _xmlSchemaAttribute *next;/* the next attribute if in a group ... */
+    xmlChar *name;
+    xmlChar *id;
+    xmlChar *ref;
+    xmlChar *refNs;
+    xmlSchemaAnnotPtr annot;
+
+    xmlSchemaAttributePtr attributes;
+};

xmlSchemaAttributeGroupPtr

typedef xmlSchemaAttributeGroup *xmlSchemaAttributeGroupPtr;

XML_SCHEMAS_TYPE_MIXED

#define XML_SCHEMAS_TYPE_MIXED		1 << 0

XML_SCHEMAS_ELEM_NILLABLE

#define XML_SCHEMAS_ELEM_NILLABLE	1 << 0

XML_SCHEMAS_ELEM_GLOBAL

#define XML_SCHEMAS_ELEM_GLOBAL		1 << 1

XML_SCHEMAS_ELEM_DEFAULT

#define XML_SCHEMAS_ELEM_DEFAULT	1 << 2

XML_SCHEMAS_ELEM_FIXED

#define XML_SCHEMAS_ELEM_FIXED		1 << 3

XML_SCHEMAS_ELEM_ABSTRACT

#define XML_SCHEMAS_ELEM_ABSTRACT	1 << 4

XML_SCHEMAS_ELEM_TOPLEVEL

#define XML_SCHEMAS_ELEM_TOPLEVEL	1 << 5

XML_SCHEMAS_ELEM_REF

#define XML_SCHEMAS_ELEM_REF		1 << 6

struct xmlSchemaElement

struct xmlSchemaElement {
+    xmlSchemaTypeType type;	/* The kind of type */
+    struct _xmlSchemaType *next;/* the next type if in a sequence ... */
+    xmlChar *name;
+    xmlChar *id;
+    xmlChar *ref;
+    xmlChar *refNs;
+    xmlSchemaAnnotPtr annot;
+    xmlSchemaTypePtr subtypes;
+    xmlSchemaAttributePtr attributes;
+    xmlNodePtr node;
+    int minOccurs;
+    int maxOccurs;
+
+    int flags;
+    xmlChar *targetNamespace;
+    xmlChar *namedType;
+    xmlChar *namedTypeNs;
+    xmlChar *substGroup;
+    xmlChar *substGroupNs;
+    xmlChar *scope;
+    xmlChar *value;
+    struct _xmlSchemaElement *refDecl;
+    xmlRegexpPtr contModel;
+    xmlSchemaContentType contentType;
+};

xmlSchemaElementPtr

typedef xmlSchemaElement *xmlSchemaElementPtr;

XML_SCHEMAS_FACET_UNKNOWN

#define XML_SCHEMAS_FACET_UNKNOWN	0

XML_SCHEMAS_FACET_PRESERVE

#define XML_SCHEMAS_FACET_PRESERVE	1

XML_SCHEMAS_FACET_REPLACE

#define XML_SCHEMAS_FACET_REPLACE	2

XML_SCHEMAS_FACET_COLLAPSE

#define XML_SCHEMAS_FACET_COLLAPSE	3

struct xmlSchemaNotation

struct xmlSchemaNotation {
+    xmlSchemaTypeType type;	/* The kind of type */
+    xmlChar *name;
+    xmlSchemaAnnotPtr annot;
+    xmlChar *identifier;
+};

xmlSchemaNotationPtr

typedef xmlSchemaNotation *xmlSchemaNotationPtr;

XML_SCHEMAS_QUALIF_ELEM

#define XML_SCHEMAS_QUALIF_ELEM		1 << 0

XML_SCHEMAS_QUALIF_ATTR

#define XML_SCHEMAS_QUALIF_ATTR		1 << 1

struct xmlSchema

struct xmlSchema {
+    xmlChar *name;        /* schema name */
+    xmlChar *targetNamespace;     /* the target namespace */
+    xmlChar *version;
+    xmlChar *id;
+    xmlDocPtr doc;
+    xmlSchemaAnnotPtr annot;
+    int flags;
+
+    xmlHashTablePtr typeDecl;
+    xmlHashTablePtr attrDecl;
+    xmlHashTablePtr attrgrpDecl;
+    xmlHashTablePtr elemDecl;
+    xmlHashTablePtr notaDecl;
+
+    xmlHashTablePtr schemasImports;
+
+    void *_private;	/* unused by the library for users or bindings */
+};

xmlSchemaFreeType ()

void        xmlSchemaFreeType               (xmlSchemaTypePtr type);

Deallocate a Schema Type structure.

\ No newline at end of file diff --git a/doc/html/libxml-valid.html b/doc/html/libxml-valid.html index 708d0c63..e5b39c6f 100644 --- a/doc/html/libxml-valid.html +++ b/doc/html/libxml-valid.html @@ -4326,8 +4326,9 @@ HREF="libxml-tree.html#XMLATTRPTR" >

Determine whether an attribute is of type ID. In case we have DTD(s) -then this is simple, otherwise we use an heuristic: name ID (upper -or lowercase).

xmlautomata
Gnome XML Library Reference Manual
<<< Previous PageHomeUpNext Page >>>

xmlautomata

Name

xmlautomata -- 

Synopsis


+
+struct      xmlAutomata;
+typedef     xmlAutomataPtr;
+struct      xmlAutomataState;
+typedef     xmlAutomataStatePtr;
+xmlAutomataPtr xmlNewAutomata               (void);
+void        xmlFreeAutomata                 (xmlAutomataPtr am);
+xmlAutomataStatePtr xmlAutomataGetInitState (xmlAutomataPtr am);
+int         xmlAutomataSetFinalState        (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr state);
+xmlAutomataStatePtr xmlAutomataNewState     (xmlAutomataPtr am);
+xmlAutomataStatePtr xmlAutomataNewTransition
+                                            (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to,
+                                             const xmlChar *token,
+                                             void *data);
+xmlAutomataStatePtr xmlAutomataNewCountTrans
+                                            (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to,
+                                             const xmlChar *token,
+                                             int min,
+                                             int max,
+                                             void *data);
+xmlAutomataStatePtr xmlAutomataNewOnceTrans (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to,
+                                             const xmlChar *token,
+                                             int min,
+                                             int max,
+                                             void *data);
+xmlAutomataStatePtr xmlAutomataNewAllTrans  (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to,
+                                             int lax);
+xmlAutomataStatePtr xmlAutomataNewEpsilon   (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to);
+xmlAutomataStatePtr xmlAutomataNewCountedTrans
+                                            (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to,
+                                             int counter);
+xmlAutomataStatePtr xmlAutomataNewCounterTrans
+                                            (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to,
+                                             int counter);
+int         xmlAutomataNewCounter           (xmlAutomataPtr am,
+                                             int min,
+                                             int max);
+xmlRegexpPtr xmlAutomataCompile             (xmlAutomataPtr am);
+int         xmlAutomataIsDeterminist        (xmlAutomataPtr am);

Description

Details

struct xmlAutomata

struct xmlAutomata;

xmlAutomataPtr

typedef xmlAutomata *xmlAutomataPtr;

A libxml automata description, It can be compiled into a regexp

struct xmlAutomataState

struct xmlAutomataState;

xmlAutomataStatePtr

typedef xmlAutomataState *xmlAutomataStatePtr;

A state int the automata description,

xmlNewAutomata ()

xmlAutomataPtr xmlNewAutomata               (void);

Create a new automata

xmlFreeAutomata ()

void        xmlFreeAutomata                 (xmlAutomataPtr am);

Free an automata

xmlAutomataSetFinalState ()

int         xmlAutomataSetFinalState        (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr state);

Makes that state a final state

xmlAutomataNewState ()

xmlAutomataStatePtr xmlAutomataNewState     (xmlAutomataPtr am);

Create a new disconnected state in the automata

xmlAutomataNewTransition ()

xmlAutomataStatePtr xmlAutomataNewTransition
+                                            (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to,
+                                             const xmlChar *token,
+                                             void *data);

If to is NULL, this create first a new target state in the automata +and then adds a an epsilon transition from the from state to the +target state

xmlAutomataNewCountTrans ()

xmlAutomataStatePtr xmlAutomataNewCountTrans
+                                            (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to,
+                                             const xmlChar *token,
+                                             int min,
+                                             int max,
+                                             void *data);

If to is NULL, this create first a new target state in the automata +and then adds a transition from the from state to the target state +activated by a succession of input of value token and whose number +is between min and max

xmlAutomataNewOnceTrans ()

xmlAutomataStatePtr xmlAutomataNewOnceTrans (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to,
+                                             const xmlChar *token,
+                                             int min,
+                                             int max,
+                                             void *data);

If to is NULL, this create first a new target state in the automata +and then adds a transition from the from state to the target state +activated by a succession of input of value token and whose number +is between min and max, moreover that transistion can only be crossed +once.

xmlAutomataNewAllTrans ()

xmlAutomataStatePtr xmlAutomataNewAllTrans  (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to,
+                                             int lax);

If to is NULL, this create first a new target state in the automata +and then adds a an ALL transition from the from state to the +target state. That transition is an epsilon transition allowed only when +all transitions from the from node have been activated.

xmlAutomataNewCountedTrans ()

xmlAutomataStatePtr xmlAutomataNewCountedTrans
+                                            (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to,
+                                             int counter);

If to is NULL, this create first a new target state in the automata +and then adds an epsilon transition from the from state to the target state +which will increment the counter provided

xmlAutomataNewCounterTrans ()

xmlAutomataStatePtr xmlAutomataNewCounterTrans
+                                            (xmlAutomataPtr am,
+                                             xmlAutomataStatePtr from,
+                                             xmlAutomataStatePtr to,
+                                             int counter);

If to is NULL, this create first a new target state in the automata +and then adds an epsilon transition from the from state to the target state +which will be allowed only if the counter is within the right range.

xmlAutomataCompile ()

xmlRegexpPtr xmlAutomataCompile             (xmlAutomataPtr am);

Compile the automata into a Reg Exp ready for being executed. +The automata should be free after this point.

xmlAutomataIsDeterminist ()

int         xmlAutomataIsDeterminist        (xmlAutomataPtr am);

Checks if an automata is determinist.

\ No newline at end of file diff --git a/doc/html/libxml-xmlregexp.html b/doc/html/libxml-xmlregexp.html new file mode 100644 index 00000000..c550d4ea --- /dev/null +++ b/doc/html/libxml-xmlregexp.html @@ -0,0 +1,1356 @@ +xmlregexp
Gnome XML Library Reference Manual
<<< Previous PageHomeUpNext Page >>>

xmlregexp

Name

xmlregexp -- 

Description

Details

struct xmlRegexp

struct xmlRegexp;

xmlRegexpPtr

typedef xmlRegexp *xmlRegexpPtr;

A libxml regular expression, they can actually be far more complex +thank the POSIX regex expressions.

struct xmlRegExecCtxt

struct xmlRegExecCtxt;

xmlRegExecCtxtPtr

typedef xmlRegExecCtxt *xmlRegExecCtxtPtr;

A libxml progressive regular expression evaluation context

xmlRegexpCompile ()

xmlRegexpPtr xmlRegexpCompile               (const xmlChar *regexp);

Parses a regular expression conforming to XML Schemas Part 2 Datatype +Appendix F and build an automata suitable for testing strings against +that regular expression

xmlRegFreeRegexp ()

void        xmlRegFreeRegexp                (xmlRegexpPtr regexp);

Free a regexp

xmlRegexpExec ()

int         xmlRegexpExec                   (xmlRegexpPtr comp,
+                                             const xmlChar *value);

Check if the regular expression generate the value

xmlRegexpPrint ()

void        xmlRegexpPrint                  (FILE *output,
+                                             xmlRegexpPtr regexp);

Print the content of the compiled regular expression

xmlRegexpIsDeterminist ()

int         xmlRegexpIsDeterminist          (xmlRegexpPtr comp);

Check if the regular expression is determinist

xmlRegExecCallbacks ()

void        (*xmlRegExecCallbacks)          (xmlRegExecCtxtPtr exec,
+                                             const xmlChar *token,
+                                             void *transdata,
+                                             void *inputdata);

xmlRegNewExecCtxt ()

xmlRegExecCtxtPtr xmlRegNewExecCtxt         (xmlRegexpPtr comp,
+                                             xmlRegExecCallbacks callback,
+                                             void *data);

xmlRegFreeExecCtxt ()

void        xmlRegFreeExecCtxt              (xmlRegExecCtxtPtr exec);

Free the structures associated to a regular expression evaulation context.

\ No newline at end of file diff --git a/doc/html/libxml-xmlschemas.html b/doc/html/libxml-xmlschemas.html new file mode 100644 index 00000000..e8e80f47 --- /dev/null +++ b/doc/html/libxml-xmlschemas.html @@ -0,0 +1,1922 @@ +xmlschemas
Gnome XML Library Reference Manual
<<< Previous PageHomeUpNext Page >>>

xmlschemas

Name

xmlschemas -- 

Synopsis


+
+enum        xmlSchemaValidError;
+struct      xmlSchema;
+typedef     xmlSchemaPtr;
+void        (*xmlSchemaValidityErrorFunc)   (void *ctx,
+                                             const char *msg,
+                                             ...);
+void        (*xmlSchemaValidityWarningFunc) (void *ctx,
+                                             const char *msg,
+                                             ...);
+struct      xmlSchemaParserCtxt;
+typedef     xmlSchemaParserCtxtPtr;
+struct      xmlSchemaValidCtxt;
+typedef     xmlSchemaValidCtxtPtr;
+xmlSchemaParserCtxtPtr xmlSchemaNewParserCtxt
+                                            (const char *URL);
+void        xmlSchemaFreeParserCtxt         (xmlSchemaParserCtxtPtr ctxt);
+void        xmlSchemaSetParserErrors        (xmlSchemaParserCtxtPtr ctxt,
+                                             xmlSchemaValidityErrorFunc err,
+                                             xmlSchemaValidityWarningFunc warn,
+                                             void *ctx);
+xmlSchemaPtr xmlSchemaParse                 (xmlSchemaParserCtxtPtr ctxt);
+void        xmlSchemaFree                   (xmlSchemaPtr schema);
+void        xmlSchemaDump                   (FILE *output,
+                                             xmlSchemaPtr schema);
+void        xmlSchemaSetValidErrors         (xmlSchemaValidCtxtPtr ctxt,
+                                             xmlSchemaValidityErrorFunc err,
+                                             xmlSchemaValidityWarningFunc warn,
+                                             void *ctx);
+xmlSchemaValidCtxtPtr xmlSchemaNewValidCtxt (xmlSchemaPtr schema);
+void        xmlSchemaFreeValidCtxt          (xmlSchemaValidCtxtPtr ctxt);
+int         xmlSchemaValidateDoc            (xmlSchemaValidCtxtPtr ctxt,
+                                             xmlDocPtr instance);
+int         xmlSchemaValidateStream         (xmlSchemaValidCtxtPtr ctxt,
+                                             xmlParserInputBufferPtr input,
+                                             xmlCharEncoding enc,
+                                             xmlSAXHandlerPtr sax,
+                                             void *user_data);

Description

Details

enum xmlSchemaValidError

typedef enum {
+    XML_SCHEMAS_ERR_OK		= 0,
+    XML_SCHEMAS_ERR_NOROOT	= 1,
+    XML_SCHEMAS_ERR_UNDECLAREDELEM,
+    XML_SCHEMAS_ERR_NOTTOPLEVEL,
+    XML_SCHEMAS_ERR_MISSING,
+    XML_SCHEMAS_ERR_WRONGELEM,
+    XML_SCHEMAS_ERR_NOTYPE,
+    XML_SCHEMAS_ERR_NOROLLBACK,
+    XML_SCHEMAS_ERR_ISABSTRACT,
+    XML_SCHEMAS_ERR_NOTEMPTY,
+    XML_SCHEMAS_ERR_ELEMCONT,
+    XML_SCHEMAS_ERR_HAVEDEFAULT,
+    XML_SCHEMAS_ERR_NOTNILLABLE,
+    XML_SCHEMAS_ERR_EXTRACONTENT,
+    XML_SCHEMAS_ERR_INVALIDATTR,
+    XML_SCHEMAS_ERR_INVALIDELEM,
+    XML_SCHEMAS_ERR_NOTDETERMINIST,
+    XML_SCHEMAS_ERR_CONSTRUCT,
+    XML_SCHEMAS_ERR_INTERNAL,
+    XML_SCHEMAS_ERR_NOTSIMPLE,
+    XML_SCHEMAS_ERR_ATTRUNKNOWN,
+    XML_SCHEMAS_ERR_ATTRINVALID,
+    XML_SCHEMAS_ERR_,
+    XML_SCHEMAS_ERR_XXX
+} xmlSchemaValidError;

struct xmlSchema

struct xmlSchema {
+    xmlChar *name;        /* schema name */
+    xmlChar *targetNamespace;     /* the target namespace */
+    xmlChar *version;
+    xmlChar *id;
+    xmlDocPtr doc;
+    xmlSchemaAnnotPtr annot;
+    int flags;
+
+    xmlHashTablePtr typeDecl;
+    xmlHashTablePtr attrDecl;
+    xmlHashTablePtr attrgrpDecl;
+    xmlHashTablePtr elemDecl;
+    xmlHashTablePtr notaDecl;
+};

xmlSchemaPtr

typedef xmlSchema *xmlSchemaPtr;

xmlSchemaValidityErrorFunc ()

void        (*xmlSchemaValidityErrorFunc)   (void *ctx,
+                                             const char *msg,
+                                             ...);

xmlSchemaValidityWarningFunc ()

void        (*xmlSchemaValidityWarningFunc) (void *ctx,
+                                             const char *msg,
+                                             ...);

struct xmlSchemaParserCtxt

struct xmlSchemaParserCtxt;

xmlSchemaParserCtxtPtr

typedef xmlSchemaParserCtxt *xmlSchemaParserCtxtPtr;

struct xmlSchemaValidCtxt

struct xmlSchemaValidCtxt;

A Schemas validation context

xmlSchemaValidCtxtPtr

typedef xmlSchemaValidCtxt *xmlSchemaValidCtxtPtr;

xmlSchemaNewParserCtxt ()

xmlSchemaParserCtxtPtr xmlSchemaNewParserCtxt
+                                            (const char *URL);

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

xmlSchemaFreeParserCtxt ()

void        xmlSchemaFreeParserCtxt         (xmlSchemaParserCtxtPtr ctxt);

Free the resources associated to the schema parser context

xmlSchemaSetParserErrors ()

void        xmlSchemaSetParserErrors        (xmlSchemaParserCtxtPtr ctxt,
+                                             xmlSchemaValidityErrorFunc err,
+                                             xmlSchemaValidityWarningFunc warn,
+                                             void *ctx);

xmlSchemaParse ()

xmlSchemaPtr xmlSchemaParse                 (xmlSchemaParserCtxtPtr ctxt);

Load, XML 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

xmlSchemaFree ()

void        xmlSchemaFree                   (xmlSchemaPtr schema);

Deallocate a Schema structure.

xmlSchemaDump ()

void        xmlSchemaDump                   (FILE *output,
+                                             xmlSchemaPtr schema);

Dump a Schema structure.

xmlSchemaSetValidErrors ()

void        xmlSchemaSetValidErrors         (xmlSchemaValidCtxtPtr ctxt,
+                                             xmlSchemaValidityErrorFunc err,
+                                             xmlSchemaValidityWarningFunc warn,
+                                             void *ctx);

Set the error and warning callback informations

xmlSchemaNewValidCtxt ()

xmlSchemaValidCtxtPtr xmlSchemaNewValidCtxt (xmlSchemaPtr schema);

Create an XML Schemas validation context based on the given schema

xmlSchemaFreeValidCtxt ()

void        xmlSchemaFreeValidCtxt          (xmlSchemaValidCtxtPtr ctxt);

Free the resources associated to the schema validation context

\ No newline at end of file diff --git a/doc/html/libxml-xmlschemastypes.html b/doc/html/libxml-xmlschemastypes.html new file mode 100644 index 00000000..abf00d05 --- /dev/null +++ b/doc/html/libxml-xmlschemastypes.html @@ -0,0 +1,844 @@ +xmlschemastypes
Gnome XML Library Reference Manual
<<< Previous PageHomeUpNext Page >>>

xmlschemastypes

Name

xmlschemastypes -- 

Description

Details

xmlSchemaInitTypes ()

void        xmlSchemaInitTypes              (void);

xmlSchemaCleanupTypes ()

void        xmlSchemaCleanupTypes           (void);

Cleanup the default XML Schemas type library

xmlSchemaGetPredefinedType ()

xmlSchemaTypePtr xmlSchemaGetPredefinedType (const xmlChar *name,
+                                             const xmlChar *ns);

Lookup a type in the default XML Schemas type library

xmlSchemaValidatePredefinedType ()

int         xmlSchemaValidatePredefinedType (xmlSchemaTypePtr type,
+                                             const xmlChar *value,
+                                             xmlSchemaValPtr *val);

Check that a value conforms to the lexical space of the predefined type. +if true a value is computed and returned in val.

xmlSchemaFreeValue ()

void        xmlSchemaFreeValue              (xmlSchemaValPtr val);

Cleanup the default XML Schemas type library

\ No newline at end of file diff --git a/doc/html/libxml-xmlunicode.html b/doc/html/libxml-xmlunicode.html new file mode 100644 index 00000000..7921d35d --- /dev/null +++ b/doc/html/libxml-xmlunicode.html @@ -0,0 +1,11736 @@ +xmlunicode
Gnome XML Library Reference Manual
<<< Previous PageHomeUpNext Page >>>

xmlunicode

Name

xmlunicode -- 

Synopsis


+
+int         xmlUCSIsAlphabeticPresentationForms
+                                            (int code);
+int         xmlUCSIsArabic                  (int code);
+int         xmlUCSIsArabicPresentationFormsA
+                                            (int code);
+int         xmlUCSIsArabicPresentationFormsB
+                                            (int code);
+int         xmlUCSIsArmenian                (int code);
+int         xmlUCSIsArrows                  (int code);
+int         xmlUCSIsBasicLatin              (int code);
+int         xmlUCSIsBengali                 (int code);
+int         xmlUCSIsBlockElements           (int code);
+int         xmlUCSIsBopomofo                (int code);
+int         xmlUCSIsBopomofoExtended        (int code);
+int         xmlUCSIsBoxDrawing              (int code);
+int         xmlUCSIsBraillePatterns         (int code);
+int         xmlUCSIsByzantineMusicalSymbols (int code);
+int         xmlUCSIsCJKCompatibility        (int code);
+int         xmlUCSIsCJKCompatibilityForms   (int code);
+int         xmlUCSIsCJKCompatibilityIdeographs
+                                            (int code);
+int         xmlUCSIsCJKCompatibilityIdeographsSupplement
+                                            (int code);
+int         xmlUCSIsCJKRadicalsSupplement   (int code);
+int         xmlUCSIsCJKSymbolsandPunctuation
+                                            (int code);
+int         xmlUCSIsCJKUnifiedIdeographs    (int code);
+int         xmlUCSIsCJKUnifiedIdeographsExtensionA
+                                            (int code);
+int         xmlUCSIsCJKUnifiedIdeographsExtensionB
+                                            (int code);
+int         xmlUCSIsCherokee                (int code);
+int         xmlUCSIsCombiningDiacriticalMarks
+                                            (int code);
+int         xmlUCSIsCombiningHalfMarks      (int code);
+int         xmlUCSIsCombiningMarksforSymbols
+                                            (int code);
+int         xmlUCSIsControlPictures         (int code);
+int         xmlUCSIsCurrencySymbols         (int code);
+int         xmlUCSIsCyrillic                (int code);
+int         xmlUCSIsDeseret                 (int code);
+int         xmlUCSIsDevanagari              (int code);
+int         xmlUCSIsDingbats                (int code);
+int         xmlUCSIsEnclosedAlphanumerics   (int code);
+int         xmlUCSIsEnclosedCJKLettersandMonths
+                                            (int code);
+int         xmlUCSIsEthiopic                (int code);
+int         xmlUCSIsGeneralPunctuation      (int code);
+int         xmlUCSIsGeometricShapes         (int code);
+int         xmlUCSIsGeorgian                (int code);
+int         xmlUCSIsGothic                  (int code);
+int         xmlUCSIsGreek                   (int code);
+int         xmlUCSIsGreekExtended           (int code);
+int         xmlUCSIsGujarati                (int code);
+int         xmlUCSIsGurmukhi                (int code);
+int         xmlUCSIsHalfwidthandFullwidthForms
+                                            (int code);
+int         xmlUCSIsHangulCompatibilityJamo (int code);
+int         xmlUCSIsHangulJamo              (int code);
+int         xmlUCSIsHangulSyllables         (int code);
+int         xmlUCSIsHebrew                  (int code);
+int         xmlUCSIsHighPrivateUseSurrogates
+                                            (int code);
+int         xmlUCSIsHighSurrogates          (int code);
+int         xmlUCSIsHiragana                (int code);
+int         xmlUCSIsIPAExtensions           (int code);
+int         xmlUCSIsIdeographicDescriptionCharacters
+                                            (int code);
+int         xmlUCSIsKanbun                  (int code);
+int         xmlUCSIsKangxiRadicals          (int code);
+int         xmlUCSIsKannada                 (int code);
+int         xmlUCSIsKatakana                (int code);
+int         xmlUCSIsKhmer                   (int code);
+int         xmlUCSIsLao                     (int code);
+int         xmlUCSIsLatin1Supplement        (int code);
+int         xmlUCSIsLatinExtendedA          (int code);
+int         xmlUCSIsLatinExtendedB          (int code);
+int         xmlUCSIsLatinExtendedAdditional (int code);
+int         xmlUCSIsLetterlikeSymbols       (int code);
+int         xmlUCSIsLowSurrogates           (int code);
+int         xmlUCSIsMalayalam               (int code);
+int         xmlUCSIsMathematicalAlphanumericSymbols
+                                            (int code);
+int         xmlUCSIsMathematicalOperators   (int code);
+int         xmlUCSIsMiscellaneousSymbols    (int code);
+int         xmlUCSIsMiscellaneousTechnical  (int code);
+int         xmlUCSIsMongolian               (int code);
+int         xmlUCSIsMusicalSymbols          (int code);
+int         xmlUCSIsMyanmar                 (int code);
+int         xmlUCSIsNumberForms             (int code);
+int         xmlUCSIsOgham                   (int code);
+int         xmlUCSIsOldItalic               (int code);
+int         xmlUCSIsOpticalCharacterRecognition
+                                            (int code);
+int         xmlUCSIsOriya                   (int code);
+int         xmlUCSIsPrivateUse              (int code);
+int         xmlUCSIsRunic                   (int code);
+int         xmlUCSIsSinhala                 (int code);
+int         xmlUCSIsSmallFormVariants       (int code);
+int         xmlUCSIsSpacingModifierLetters  (int code);
+int         xmlUCSIsSpecials                (int code);
+int         xmlUCSIsSuperscriptsandSubscripts
+                                            (int code);
+int         xmlUCSIsSyriac                  (int code);
+int         xmlUCSIsTags                    (int code);
+int         xmlUCSIsTamil                   (int code);
+int         xmlUCSIsTelugu                  (int code);
+int         xmlUCSIsThaana                  (int code);
+int         xmlUCSIsThai                    (int code);
+int         xmlUCSIsTibetan                 (int code);
+int         xmlUCSIsUnifiedCanadianAboriginalSyllabics
+                                            (int code);
+int         xmlUCSIsYiRadicals              (int code);
+int         xmlUCSIsYiSyllables             (int code);
+int         xmlUCSIsBlock                   (int code,
+                                             const char *block);
+int         xmlUCSIsCatC                    (int code);
+int         xmlUCSIsCatCc                   (int code);
+int         xmlUCSIsCatCf                   (int code);
+int         xmlUCSIsCatCo                   (int code);
+int         xmlUCSIsCatCs                   (int code);
+int         xmlUCSIsCatL                    (int code);
+int         xmlUCSIsCatLl                   (int code);
+int         xmlUCSIsCatLm                   (int code);
+int         xmlUCSIsCatLo                   (int code);
+int         xmlUCSIsCatLt                   (int code);
+int         xmlUCSIsCatLu                   (int code);
+int         xmlUCSIsCatM                    (int code);
+int         xmlUCSIsCatMc                   (int code);
+int         xmlUCSIsCatMe                   (int code);
+int         xmlUCSIsCatMn                   (int code);
+int         xmlUCSIsCatN                    (int code);
+int         xmlUCSIsCatNd                   (int code);
+int         xmlUCSIsCatNl                   (int code);
+int         xmlUCSIsCatNo                   (int code);
+int         xmlUCSIsCatP                    (int code);
+int         xmlUCSIsCatPc                   (int code);
+int         xmlUCSIsCatPd                   (int code);
+int         xmlUCSIsCatPe                   (int code);
+int         xmlUCSIsCatPf                   (int code);
+int         xmlUCSIsCatPi                   (int code);
+int         xmlUCSIsCatPo                   (int code);
+int         xmlUCSIsCatPs                   (int code);
+int         xmlUCSIsCatS                    (int code);
+int         xmlUCSIsCatSc                   (int code);
+int         xmlUCSIsCatSk                   (int code);
+int         xmlUCSIsCatSm                   (int code);
+int         xmlUCSIsCatSo                   (int code);
+int         xmlUCSIsCatZ                    (int code);
+int         xmlUCSIsCatZl                   (int code);
+int         xmlUCSIsCatZp                   (int code);
+int         xmlUCSIsCatZs                   (int code);
+int         xmlUCSIsCat                     (int code,
+                                             const char *cat);

Description

Details

xmlUCSIsAlphabeticPresentationForms ()

int         xmlUCSIsAlphabeticPresentationForms
+                                            (int code);

Check whether the character is part of AlphabeticPresentationForms UCS Block

xmlUCSIsArabic ()

int         xmlUCSIsArabic                  (int code);

Check whether the character is part of Arabic UCS Block

xmlUCSIsArabicPresentationFormsA ()

int         xmlUCSIsArabicPresentationFormsA
+                                            (int code);

Check whether the character is part of ArabicPresentationForms-A UCS Block

xmlUCSIsArabicPresentationFormsB ()

int         xmlUCSIsArabicPresentationFormsB
+                                            (int code);

Check whether the character is part of ArabicPresentationForms-B UCS Block

xmlUCSIsArmenian ()

int         xmlUCSIsArmenian                (int code);

Check whether the character is part of Armenian UCS Block

xmlUCSIsArrows ()

int         xmlUCSIsArrows                  (int code);

Check whether the character is part of Arrows UCS Block

xmlUCSIsBasicLatin ()

int         xmlUCSIsBasicLatin              (int code);

Check whether the character is part of BasicLatin UCS Block

xmlUCSIsBengali ()

int         xmlUCSIsBengali                 (int code);

Check whether the character is part of Bengali UCS Block

xmlUCSIsBlockElements ()

int         xmlUCSIsBlockElements           (int code);

Check whether the character is part of BlockElements UCS Block

xmlUCSIsBopomofo ()

int         xmlUCSIsBopomofo                (int code);

Check whether the character is part of Bopomofo UCS Block

xmlUCSIsBopomofoExtended ()

int         xmlUCSIsBopomofoExtended        (int code);

Check whether the character is part of BopomofoExtended UCS Block

xmlUCSIsBoxDrawing ()

int         xmlUCSIsBoxDrawing              (int code);

Check whether the character is part of BoxDrawing UCS Block

xmlUCSIsBraillePatterns ()

int         xmlUCSIsBraillePatterns         (int code);

Check whether the character is part of BraillePatterns UCS Block

xmlUCSIsByzantineMusicalSymbols ()

int         xmlUCSIsByzantineMusicalSymbols (int code);

Check whether the character is part of ByzantineMusicalSymbols UCS Block

xmlUCSIsCJKCompatibility ()

int         xmlUCSIsCJKCompatibility        (int code);

Check whether the character is part of CJKCompatibility UCS Block

xmlUCSIsCJKCompatibilityForms ()

int         xmlUCSIsCJKCompatibilityForms   (int code);

Check whether the character is part of CJKCompatibilityForms UCS Block

xmlUCSIsCJKCompatibilityIdeographs ()

int         xmlUCSIsCJKCompatibilityIdeographs
+                                            (int code);

Check whether the character is part of CJKCompatibilityIdeographs UCS Block

xmlUCSIsCJKCompatibilityIdeographsSupplement ()

int         xmlUCSIsCJKCompatibilityIdeographsSupplement
+                                            (int code);

Check whether the character is part of CJKCompatibilityIdeographsSupplement UCS Block

xmlUCSIsCJKRadicalsSupplement ()

int         xmlUCSIsCJKRadicalsSupplement   (int code);

Check whether the character is part of CJKRadicalsSupplement UCS Block

xmlUCSIsCJKSymbolsandPunctuation ()

int         xmlUCSIsCJKSymbolsandPunctuation
+                                            (int code);

Check whether the character is part of CJKSymbolsandPunctuation UCS Block

xmlUCSIsCJKUnifiedIdeographs ()

int         xmlUCSIsCJKUnifiedIdeographs    (int code);

Check whether the character is part of CJKUnifiedIdeographs UCS Block

xmlUCSIsCJKUnifiedIdeographsExtensionA ()

int         xmlUCSIsCJKUnifiedIdeographsExtensionA
+                                            (int code);

Check whether the character is part of CJKUnifiedIdeographsExtensionA UCS Block

xmlUCSIsCJKUnifiedIdeographsExtensionB ()

int         xmlUCSIsCJKUnifiedIdeographsExtensionB
+                                            (int code);

Check whether the character is part of CJKUnifiedIdeographsExtensionB UCS Block

xmlUCSIsCherokee ()

int         xmlUCSIsCherokee                (int code);

Check whether the character is part of Cherokee UCS Block

xmlUCSIsCombiningDiacriticalMarks ()

int         xmlUCSIsCombiningDiacriticalMarks
+                                            (int code);

Check whether the character is part of CombiningDiacriticalMarks UCS Block

xmlUCSIsCombiningHalfMarks ()

int         xmlUCSIsCombiningHalfMarks      (int code);

Check whether the character is part of CombiningHalfMarks UCS Block

xmlUCSIsCombiningMarksforSymbols ()

int         xmlUCSIsCombiningMarksforSymbols
+                                            (int code);

Check whether the character is part of CombiningMarksforSymbols UCS Block

xmlUCSIsControlPictures ()

int         xmlUCSIsControlPictures         (int code);

Check whether the character is part of ControlPictures UCS Block

xmlUCSIsCurrencySymbols ()

int         xmlUCSIsCurrencySymbols         (int code);

Check whether the character is part of CurrencySymbols UCS Block

xmlUCSIsCyrillic ()

int         xmlUCSIsCyrillic                (int code);

Check whether the character is part of Cyrillic UCS Block

xmlUCSIsDeseret ()

int         xmlUCSIsDeseret                 (int code);

Check whether the character is part of Deseret UCS Block

xmlUCSIsDevanagari ()

int         xmlUCSIsDevanagari              (int code);

Check whether the character is part of Devanagari UCS Block

xmlUCSIsDingbats ()

int         xmlUCSIsDingbats                (int code);

Check whether the character is part of Dingbats UCS Block

xmlUCSIsEnclosedAlphanumerics ()

int         xmlUCSIsEnclosedAlphanumerics   (int code);

Check whether the character is part of EnclosedAlphanumerics UCS Block

xmlUCSIsEnclosedCJKLettersandMonths ()

int         xmlUCSIsEnclosedCJKLettersandMonths
+                                            (int code);

Check whether the character is part of EnclosedCJKLettersandMonths UCS Block

xmlUCSIsEthiopic ()

int         xmlUCSIsEthiopic                (int code);

Check whether the character is part of Ethiopic UCS Block

xmlUCSIsGeneralPunctuation ()

int         xmlUCSIsGeneralPunctuation      (int code);

Check whether the character is part of GeneralPunctuation UCS Block

xmlUCSIsGeometricShapes ()

int         xmlUCSIsGeometricShapes         (int code);

Check whether the character is part of GeometricShapes UCS Block

xmlUCSIsGeorgian ()

int         xmlUCSIsGeorgian                (int code);

Check whether the character is part of Georgian UCS Block

xmlUCSIsGothic ()

int         xmlUCSIsGothic                  (int code);

Check whether the character is part of Gothic UCS Block

xmlUCSIsGreek ()

int         xmlUCSIsGreek                   (int code);

Check whether the character is part of Greek UCS Block

xmlUCSIsGreekExtended ()

int         xmlUCSIsGreekExtended           (int code);

Check whether the character is part of GreekExtended UCS Block

xmlUCSIsGujarati ()

int         xmlUCSIsGujarati                (int code);

Check whether the character is part of Gujarati UCS Block

xmlUCSIsGurmukhi ()

int         xmlUCSIsGurmukhi                (int code);

Check whether the character is part of Gurmukhi UCS Block

xmlUCSIsHalfwidthandFullwidthForms ()

int         xmlUCSIsHalfwidthandFullwidthForms
+                                            (int code);

Check whether the character is part of HalfwidthandFullwidthForms UCS Block

xmlUCSIsHangulCompatibilityJamo ()

int         xmlUCSIsHangulCompatibilityJamo (int code);

Check whether the character is part of HangulCompatibilityJamo UCS Block

xmlUCSIsHangulJamo ()

int         xmlUCSIsHangulJamo              (int code);

Check whether the character is part of HangulJamo UCS Block

xmlUCSIsHangulSyllables ()

int         xmlUCSIsHangulSyllables         (int code);

Check whether the character is part of HangulSyllables UCS Block

xmlUCSIsHebrew ()

int         xmlUCSIsHebrew                  (int code);

Check whether the character is part of Hebrew UCS Block

xmlUCSIsHighPrivateUseSurrogates ()

int         xmlUCSIsHighPrivateUseSurrogates
+                                            (int code);

Check whether the character is part of HighPrivateUseSurrogates UCS Block

xmlUCSIsHighSurrogates ()

int         xmlUCSIsHighSurrogates          (int code);

Check whether the character is part of HighSurrogates UCS Block

xmlUCSIsHiragana ()

int         xmlUCSIsHiragana                (int code);

Check whether the character is part of Hiragana UCS Block

xmlUCSIsIPAExtensions ()

int         xmlUCSIsIPAExtensions           (int code);

Check whether the character is part of IPAExtensions UCS Block

xmlUCSIsIdeographicDescriptionCharacters ()

int         xmlUCSIsIdeographicDescriptionCharacters
+                                            (int code);

Check whether the character is part of IdeographicDescriptionCharacters UCS Block

xmlUCSIsKanbun ()

int         xmlUCSIsKanbun                  (int code);

Check whether the character is part of Kanbun UCS Block

xmlUCSIsKangxiRadicals ()

int         xmlUCSIsKangxiRadicals          (int code);

Check whether the character is part of KangxiRadicals UCS Block

xmlUCSIsKannada ()

int         xmlUCSIsKannada                 (int code);

Check whether the character is part of Kannada UCS Block

xmlUCSIsKatakana ()

int         xmlUCSIsKatakana                (int code);

Check whether the character is part of Katakana UCS Block

xmlUCSIsKhmer ()

int         xmlUCSIsKhmer                   (int code);

Check whether the character is part of Khmer UCS Block

xmlUCSIsLao ()

int         xmlUCSIsLao                     (int code);

Check whether the character is part of Lao UCS Block

xmlUCSIsLatin1Supplement ()

int         xmlUCSIsLatin1Supplement        (int code);

Check whether the character is part of Latin-1Supplement UCS Block

xmlUCSIsLatinExtendedA ()

int         xmlUCSIsLatinExtendedA          (int code);

Check whether the character is part of LatinExtended-A UCS Block

xmlUCSIsLatinExtendedB ()

int         xmlUCSIsLatinExtendedB          (int code);

Check whether the character is part of LatinExtended-B UCS Block

xmlUCSIsLatinExtendedAdditional ()

int         xmlUCSIsLatinExtendedAdditional (int code);

Check whether the character is part of LatinExtendedAdditional UCS Block

xmlUCSIsLetterlikeSymbols ()

int         xmlUCSIsLetterlikeSymbols       (int code);

Check whether the character is part of LetterlikeSymbols UCS Block

xmlUCSIsLowSurrogates ()

int         xmlUCSIsLowSurrogates           (int code);

Check whether the character is part of LowSurrogates UCS Block

xmlUCSIsMalayalam ()

int         xmlUCSIsMalayalam               (int code);

Check whether the character is part of Malayalam UCS Block

xmlUCSIsMathematicalAlphanumericSymbols ()

int         xmlUCSIsMathematicalAlphanumericSymbols
+                                            (int code);

Check whether the character is part of MathematicalAlphanumericSymbols UCS Block

xmlUCSIsMathematicalOperators ()

int         xmlUCSIsMathematicalOperators   (int code);

Check whether the character is part of MathematicalOperators UCS Block

xmlUCSIsMiscellaneousSymbols ()

int         xmlUCSIsMiscellaneousSymbols    (int code);

Check whether the character is part of MiscellaneousSymbols UCS Block

xmlUCSIsMiscellaneousTechnical ()

int         xmlUCSIsMiscellaneousTechnical  (int code);

Check whether the character is part of MiscellaneousTechnical UCS Block

xmlUCSIsMongolian ()

int         xmlUCSIsMongolian               (int code);

Check whether the character is part of Mongolian UCS Block

xmlUCSIsMusicalSymbols ()

int         xmlUCSIsMusicalSymbols          (int code);

Check whether the character is part of MusicalSymbols UCS Block

xmlUCSIsMyanmar ()

int         xmlUCSIsMyanmar                 (int code);

Check whether the character is part of Myanmar UCS Block

xmlUCSIsNumberForms ()

int         xmlUCSIsNumberForms             (int code);

Check whether the character is part of NumberForms UCS Block

xmlUCSIsOgham ()

int         xmlUCSIsOgham                   (int code);

Check whether the character is part of Ogham UCS Block

xmlUCSIsOldItalic ()

int         xmlUCSIsOldItalic               (int code);

Check whether the character is part of OldItalic UCS Block

xmlUCSIsOpticalCharacterRecognition ()

int         xmlUCSIsOpticalCharacterRecognition
+                                            (int code);

Check whether the character is part of OpticalCharacterRecognition UCS Block

xmlUCSIsOriya ()

int         xmlUCSIsOriya                   (int code);

Check whether the character is part of Oriya UCS Block

xmlUCSIsPrivateUse ()

int         xmlUCSIsPrivateUse              (int code);

Check whether the character is part of PrivateUse UCS Block

xmlUCSIsRunic ()

int         xmlUCSIsRunic                   (int code);

Check whether the character is part of Runic UCS Block

xmlUCSIsSinhala ()

int         xmlUCSIsSinhala                 (int code);

Check whether the character is part of Sinhala UCS Block

xmlUCSIsSmallFormVariants ()

int         xmlUCSIsSmallFormVariants       (int code);

Check whether the character is part of SmallFormVariants UCS Block

xmlUCSIsSpacingModifierLetters ()

int         xmlUCSIsSpacingModifierLetters  (int code);

Check whether the character is part of SpacingModifierLetters UCS Block

xmlUCSIsSpecials ()

int         xmlUCSIsSpecials                (int code);

Check whether the character is part of Specials UCS Block

xmlUCSIsSuperscriptsandSubscripts ()

int         xmlUCSIsSuperscriptsandSubscripts
+                                            (int code);

Check whether the character is part of SuperscriptsandSubscripts UCS Block

xmlUCSIsSyriac ()

int         xmlUCSIsSyriac                  (int code);

Check whether the character is part of Syriac UCS Block

xmlUCSIsTags ()

int         xmlUCSIsTags                    (int code);

Check whether the character is part of Tags UCS Block

xmlUCSIsTamil ()

int         xmlUCSIsTamil                   (int code);

Check whether the character is part of Tamil UCS Block

xmlUCSIsTelugu ()

int         xmlUCSIsTelugu                  (int code);

Check whether the character is part of Telugu UCS Block

xmlUCSIsThaana ()

int         xmlUCSIsThaana                  (int code);

Check whether the character is part of Thaana UCS Block

xmlUCSIsThai ()

int         xmlUCSIsThai                    (int code);

Check whether the character is part of Thai UCS Block

xmlUCSIsTibetan ()

int         xmlUCSIsTibetan                 (int code);

Check whether the character is part of Tibetan UCS Block

xmlUCSIsUnifiedCanadianAboriginalSyllabics ()

int         xmlUCSIsUnifiedCanadianAboriginalSyllabics
+                                            (int code);

Check whether the character is part of UnifiedCanadianAboriginalSyllabics UCS Block

xmlUCSIsYiRadicals ()

int         xmlUCSIsYiRadicals              (int code);

Check whether the character is part of YiRadicals UCS Block

xmlUCSIsYiSyllables ()

int         xmlUCSIsYiSyllables             (int code);

Check whether the character is part of YiSyllables UCS Block

xmlUCSIsBlock ()

int         xmlUCSIsBlock                   (int code,
+                                             const char *block);

Check whether the caracter is part of the UCS Block

xmlUCSIsCatC ()

int         xmlUCSIsCatC                    (int code);

Check whether the character is part of C UCS Category

xmlUCSIsCatCc ()

int         xmlUCSIsCatCc                   (int code);

Check whether the character is part of Cc UCS Category

xmlUCSIsCatCf ()

int         xmlUCSIsCatCf                   (int code);

Check whether the character is part of Cf UCS Category

xmlUCSIsCatCo ()

int         xmlUCSIsCatCo                   (int code);

Check whether the character is part of Co UCS Category

xmlUCSIsCatCs ()

int         xmlUCSIsCatCs                   (int code);

Check whether the character is part of Cs UCS Category

xmlUCSIsCatL ()

int         xmlUCSIsCatL                    (int code);

Check whether the character is part of L UCS Category

xmlUCSIsCatLl ()

int         xmlUCSIsCatLl                   (int code);

Check whether the character is part of Ll UCS Category

xmlUCSIsCatLm ()

int         xmlUCSIsCatLm                   (int code);

Check whether the character is part of Lm UCS Category

xmlUCSIsCatLo ()

int         xmlUCSIsCatLo                   (int code);

Check whether the character is part of Lo UCS Category

xmlUCSIsCatLt ()

int         xmlUCSIsCatLt                   (int code);

Check whether the character is part of Lt UCS Category

xmlUCSIsCatLu ()

int         xmlUCSIsCatLu                   (int code);

Check whether the character is part of Lu UCS Category

xmlUCSIsCatM ()

int         xmlUCSIsCatM                    (int code);

Check whether the character is part of M UCS Category

xmlUCSIsCatMc ()

int         xmlUCSIsCatMc                   (int code);

Check whether the character is part of Mc UCS Category

xmlUCSIsCatMe ()

int         xmlUCSIsCatMe                   (int code);

Check whether the character is part of Me UCS Category

xmlUCSIsCatMn ()

int         xmlUCSIsCatMn                   (int code);

Check whether the character is part of Mn UCS Category

xmlUCSIsCatN ()

int         xmlUCSIsCatN                    (int code);

Check whether the character is part of N UCS Category

xmlUCSIsCatNd ()

int         xmlUCSIsCatNd                   (int code);

Check whether the character is part of Nd UCS Category

xmlUCSIsCatNl ()

int         xmlUCSIsCatNl                   (int code);

Check whether the character is part of Nl UCS Category

xmlUCSIsCatNo ()

int         xmlUCSIsCatNo                   (int code);

Check whether the character is part of No UCS Category

xmlUCSIsCatP ()

int         xmlUCSIsCatP                    (int code);

Check whether the character is part of P UCS Category

xmlUCSIsCatPc ()

int         xmlUCSIsCatPc                   (int code);

Check whether the character is part of Pc UCS Category

xmlUCSIsCatPd ()

int         xmlUCSIsCatPd                   (int code);

Check whether the character is part of Pd UCS Category

xmlUCSIsCatPe ()

int         xmlUCSIsCatPe                   (int code);

Check whether the character is part of Pe UCS Category

xmlUCSIsCatPf ()

int         xmlUCSIsCatPf                   (int code);

Check whether the character is part of Pf UCS Category

xmlUCSIsCatPi ()

int         xmlUCSIsCatPi                   (int code);

Check whether the character is part of Pi UCS Category

xmlUCSIsCatPo ()

int         xmlUCSIsCatPo                   (int code);

Check whether the character is part of Po UCS Category

xmlUCSIsCatPs ()

int         xmlUCSIsCatPs                   (int code);

Check whether the character is part of Ps UCS Category

xmlUCSIsCatS ()

int         xmlUCSIsCatS                    (int code);

Check whether the character is part of S UCS Category

xmlUCSIsCatSc ()

int         xmlUCSIsCatSc                   (int code);

Check whether the character is part of Sc UCS Category

xmlUCSIsCatSk ()

int         xmlUCSIsCatSk                   (int code);

Check whether the character is part of Sk UCS Category

xmlUCSIsCatSm ()

int         xmlUCSIsCatSm                   (int code);

Check whether the character is part of Sm UCS Category

xmlUCSIsCatSo ()

int         xmlUCSIsCatSo                   (int code);

Check whether the character is part of So UCS Category

xmlUCSIsCatZ ()

int         xmlUCSIsCatZ                    (int code);

Check whether the character is part of Z UCS Category

xmlUCSIsCatZl ()

int         xmlUCSIsCatZl                   (int code);

Check whether the character is part of Zl UCS Category

xmlUCSIsCatZp ()

int         xmlUCSIsCatZp                   (int code);

Check whether the character is part of Zp UCS Category

xmlUCSIsCatZs ()

int         xmlUCSIsCatZs                   (int code);

Check whether the character is part of Zs UCS Category

xmlUCSIsCat ()

int         xmlUCSIsCat                     (int code,
+                                             const char *cat);

Check whether the caracter is part of the UCS Category

\ No newline at end of file diff --git a/doc/libxml2-api.xml b/doc/libxml2-api.xml index eaffaa64..a91c952b 100644 --- a/doc/libxml2-api.xml +++ b/doc/libxml2-api.xml @@ -118,47 +118,43 @@ - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -1316,6 +1312,48 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -1536,6 +1574,76 @@ Whether the memory debugging is configured in + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + Macro. A comment in a HTML document is really implemented the same way as a comment in an XML document. @@ -1665,6 +1773,8 @@ Skips the end of line chars. + + Take a block of UTF-8 chars in and try to convert it to an ASCII plus HTML entities block of chars out. @@ -4681,7 +4791,7 @@ - Determine whether an attribute is of type ID. In case we have DTD(s) then this is simple, otherwise we use an heuristic: name ID (upper or lowercase). + Determine whether an attribute is of type ID. In case we have DTD(s) then this is done if DTD loading has been requested. In the case of HTML documents parsed with the HTML parser, then ID detection is done systematically. @@ -4915,7 +5025,7 @@ Load the catalogs and makes their definitions effective for the default external entity loader. this function is not thread safe, catalog initialization should preferably be done once at startup - + Global setting, indicate that the parser should load DTD while not validating. Disabled by default. diff --git a/doc/libxml2-refs.xml b/doc/libxml2-refs.xml index b0b2cdac..eab9e13d 100644 --- a/doc/libxml2-refs.xml +++ b/doc/libxml2-refs.xml @@ -14,6 +14,41 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -64,6 +99,7 @@ + @@ -1497,6 +1533,43 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -1558,6 +1631,7 @@ + @@ -6389,6 +6463,44 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + @@ -11810,6 +11922,7 @@ + @@ -11921,6 +12034,7 @@ + @@ -11973,6 +12087,7 @@ + @@ -12600,6 +12715,7 @@ + @@ -13054,7 +13170,6 @@ - @@ -13990,6 +14105,7 @@ + @@ -14074,7 +14190,6 @@ - @@ -15137,7 +15252,6 @@ - @@ -16100,6 +16214,7 @@ + @@ -16549,7 +16664,6 @@ - @@ -16713,7 +16827,6 @@ - @@ -16803,6 +16916,9 @@ + + + @@ -16814,7 +16930,6 @@ - @@ -17302,6 +17417,9 @@ + + + @@ -17926,7 +18044,6 @@ -