Gnome XML Library Reference Manual
<<< Previous Page | Home | Up | Next Page >>>

# catalog

## Name

catalog --

## Synopsis

    #define     XML_CATALOGS_NAMESPACE
    #define     XML_CATALOG_PI
    enum        xmlCatalogPrefer;
    enum        xmlCatalogAllow;
    struct      xmlCatalog;
    typedef     xmlCatalogPtr;
    xmlCatalogPtr xmlNewCatalog                 (int sgml);
    xmlCatalogPtr xmlLoadACatalog               (const char *filename);
    xmlCatalogPtr xmlLoadSGMLSuperCatalog       (const char *filename);
    int         xmlConvertSGMLCatalog           (xmlCatalogPtr catal);
    int         xmlACatalogAdd                  (xmlCatalogPtr catal,
                                                 const xmlChar *type,
                                                 const xmlChar *orig,
                                                 const xmlChar *replace);
    int         xmlACatalogRemove               (xmlCatalogPtr catal,
                                                 const xmlChar *value);
    xmlChar*    xmlACatalogResolve              (xmlCatalogPtr catal,
                                                 const xmlChar *pubID,
                                                 const xmlChar *sysID);
    xmlChar*    xmlACatalogResolveSystem        (xmlCatalogPtr catal,
                                                 const xmlChar *sysID);
    xmlChar*    xmlACatalogResolvePublic        (xmlCatalogPtr catal,
                                                 const xmlChar *pubID);
    xmlChar*    xmlACatalogResolveURI           (xmlCatalogPtr catal,
                                                 const xmlChar *URI);
    void        xmlACatalogDump                 (xmlCatalogPtr catal,
                                                 FILE *out);
    void        xmlFreeCatalog                  (xmlCatalogPtr catal);
    int         xmlCatalogIsEmpty               (xmlCatalogPtr catal);
    void        xmlInitializeCatalog            (void);
    int         xmlLoadCatalog                  (const char *filename);
    void        xmlLoadCatalogs                 (const char *paths);
    void        xmlCatalogCleanup               (void);
    void        xmlCatalogDump                  (FILE *out);
    xmlChar*    xmlCatalogResolve               (const xmlChar *pubID,
                                                 const xmlChar *sysID);
    xmlChar*    xmlCatalogResolveSystem         (const xmlChar *sysID);
    xmlChar*    xmlCatalogResolvePublic         (const xmlChar *pubID);
    xmlChar*    xmlCatalogResolveURI            (const xmlChar *URI);
    int         xmlCatalogAdd                   (const xmlChar *type,
                                                 const xmlChar *orig,
                                                 const xmlChar *replace);
    int         xmlCatalogRemove                (const xmlChar *value);
    xmlDocPtr   xmlParseCatalogFile             (const char *filename);
    int         xmlCatalogConvert               (void);
    void        xmlCatalogFreeLocal             (void *catalogs);
    void*       xmlCatalogAddLocal              (void *catalogs,
                                                 const xmlChar *URL);
    xmlChar*    xmlCatalogLocalResolve          (void *catalogs,
                                                 const xmlChar *pubID,
                                                 const xmlChar *sysID);
    xmlChar*    xmlCatalogLocalResolveURI       (void *catalogs,
                                                 const xmlChar *URI);
    int         xmlCatalogSetDebug              (int level);
    xmlCatalogPrefer xmlCatalogSetDefaultPrefer (xmlCatalogPrefer prefer);
    void        xmlCatalogSetDefaults           (xmlCatalogAllow allow);
    xmlCatalogAllow xmlCatalogGetDefaults       (void);
    const xmlChar* xmlCatalogGetSystem          (const xmlChar *sysID);
    const xmlChar* xmlCatalogGetPublic          (const xmlChar *pubID);

## Description

## Details

### XML_CATALOGS_NAMESPACE

    #define     XML_CATALOGS_NAMESPACE

The namespace for the XML Catalogs elements.

### XML_CATALOG_PI

    #define     XML_CATALOG_PI

The specific XML Catalog Processing Instuction name.

### enum xmlCatalogPrefer

    typedef enum {
        XML_CATA_PREFER_NONE = 0,
        XML_CATA_PREFER_PUBLIC = 1,
        XML_CATA_PREFER_SYSTEM
    } xmlCatalogPrefer;

### enum xmlCatalogAllow

    typedef enum {
        XML_CATA_ALLOW_NONE = 0,
        XML_CATA_ALLOW_GLOBAL = 1,
        XML_CATA_ALLOW_DOCUMENT = 2,
        XML_CATA_ALLOW_ALL = 3
    } xmlCatalogAllow;

### struct xmlCatalog

    struct xmlCatalog;

### xmlCatalogPtr

### xmlNewCatalog ()

    xmlCatalogPtr xmlNewCatalog                 (int sgml);

create a new Catalog.

`sgml` : |
Returns : |

### xmlLoadACatalog ()

    xmlCatalogPtr xmlLoadACatalog               (const char *filename);

Load the catalog and build the associated data structures. This can be either an XML Catalog or an SGML Catalog It will recurse in SGML CATALOG entries. On the other hand XML Catalogs are not handled recursively.

`filename` : |
Returns : |

### xmlLoadSGMLSuperCatalog ()

    xmlCatalogPtr xmlLoadSGMLSuperCatalog       (const char *filename);

Load an SGML super catalog. It won't expand CATALOG or DELEGATE references. This is only needed for manipulating SGML Super Catalogs like adding and removing CATALOG or DELEGATE entries.

`filename` : |
Returns : |

### xmlConvertSGMLCatalog ()

    int         xmlConvertSGMLCatalog           (xmlCatalogPtr catal);

Convert all the SGML catalog entries as XML ones

`catal` : |
Returns : |

### xmlACatalogAdd ()

    int         xmlACatalogAdd                  (xmlCatalogPtr catal,
                                                 const xmlChar *type,
                                                 const xmlChar *orig,
                                                 const xmlChar *replace);

Add an entry in the catalog, it may overwrite existing but different entries.

`catal` : |
`type` : |
`orig` : |
`replace` : |
Returns : |

### xmlACatalogRemove ()

    int         xmlACatalogRemove               (xmlCatalogPtr catal,
                                                 const xmlChar *value);

Remove an entry from the catalog

`catal` : |
`value` : |
Returns : |

### xmlACatalogResolve ()

    xmlChar*    xmlACatalogResolve              (xmlCatalogPtr catal,
                                                 const xmlChar *pubID,
                                                 const xmlChar *sysID);

Do a complete resolution lookup of an External Identifier

`catal` : |
`pubID` : |
`sysID` : |
Returns : |

### xmlACatalogResolveSystem ()

    xmlChar*    xmlACatalogResolveSystem        (xmlCatalogPtr catal,
                                                 const xmlChar *sysID);

Try to lookup the catalog resource for a system ID

`catal` : |
`sysID` : |
Returns : |

### xmlACatalogResolvePublic ()

    xmlChar*    xmlACatalogResolvePublic        (xmlCatalogPtr catal,
                                                 const xmlChar *pubID);

Try to lookup the system ID associated to a public ID in that catalog

`catal` : |
`pubID` : |
Returns : |

### xmlACatalogResolveURI ()

    xmlChar*    xmlACatalogResolveURI           (xmlCatalogPtr catal,
                                                 const xmlChar *URI);

Do a complete resolution lookup of an URI

`catal` : |
`URI` : |
Returns : |

### xmlACatalogDump ()

    void        xmlACatalogDump                 (xmlCatalogPtr catal,
                                                 FILE *out);

Free up all the memory associated with catalogs

`catal` : |
`out` : |

### xmlFreeCatalog ()

    void        xmlFreeCatalog                  (xmlCatalogPtr catal);

Free the memory allocated to a Catalog

`catal` : |

### xmlCatalogIsEmpty ()

    int         xmlCatalogIsEmpty               (xmlCatalogPtr catal);

Check is a catalog is empty

`catal` : |
Returns : |

### xmlInitializeCatalog ()

    void        xmlInitializeCatalog            (void);

Do the catalog initialization. this function is not thread safe, catalog initialization should preferably be done once at startup

### xmlLoadCatalog ()

    int         xmlLoadCatalog                  (const char *filename);

Load the catalog and makes its definitions effective for the default external entity loader. It will recurse in SGML CATALOG entries. this function is not thread safe, catalog initialization should preferably be done once at startup

`filename` : |
Returns : |

### xmlLoadCatalogs ()

    void        xmlLoadCatalogs                 (const char *paths);

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

`paths` : |

### xmlCatalogCleanup ()

    void        xmlCatalogCleanup               (void);

Free up all the memory associated with catalogs

### xmlCatalogDump ()

    void        xmlCatalogDump                  (FILE *out);

Free up all the memory associated with catalogs

`out` : |

### xmlCatalogResolve ()

    xmlChar*    xmlCatalogResolve               (const xmlChar *pubID,
                                                 const xmlChar *sysID);

Do a complete resolution lookup of an External Identifier

`pubID` : |
`sysID` : |
Returns : |

### xmlCatalogResolveSystem ()

    xmlChar*    xmlCatalogResolveSystem         (const xmlChar *sysID);

Try to lookup the catalog resource for a system ID

`sysID` : |
Returns : |

### xmlCatalogResolvePublic ()

    xmlChar*    xmlCatalogResolvePublic         (const xmlChar *pubID);

Try to lookup the system ID associated to a public ID

`pubID` : |
Returns : |

### xmlCatalogResolveURI ()

    xmlChar*    xmlCatalogResolveURI            (const xmlChar *URI);

Do a complete resolution lookup of an URI

`URI` : |
Returns : |

### xmlCatalogAdd ()

    int         xmlCatalogAdd                   (const xmlChar *type,
                                                 const xmlChar *orig,
                                                 const xmlChar *replace);

Add an entry in the catalog, it may overwrite existing but different entries. If called before any other catalog routine, allows to override the default shared catalog put in place by xmlInitializeCatalog();

`type` : |
`orig` : |
`replace` : |
Returns : |

### xmlCatalogRemove ()

    int         xmlCatalogRemove                (const xmlChar *value);

Remove an entry from the catalog

`value` : |
Returns : |

### xmlParseCatalogFile ()

    xmlDocPtr   xmlParseCatalogFile             (const char *filename);

parse an XML file and build a tree. It's like xmlParseFile() except it bypass all catalog lookups.

`filename` : |
Returns : |

### xmlCatalogConvert ()

    int         xmlCatalogConvert               (void);

Convert all the SGML catalog entries as XML ones

Returns : |

### xmlCatalogFreeLocal ()

    void        xmlCatalogFreeLocal             (void *catalogs);

Free up the memory associated to the catalog list

`catalogs` : |

### xmlCatalogAddLocal ()

    void*       xmlCatalogAddLocal              (void *catalogs,
                                                 const xmlChar *URL);

Add the new entry to the catalog list

`catalogs` : |
`URL` : |

### xmlCatalogLocalResolve ()

    xmlChar*    xmlCatalogLocalResolve          (void *catalogs,
                                                 const xmlChar *pubID,
                                                 const xmlChar *sysID);

Do a complete resolution lookup of an External Identifier using a document's private catalog list

`catalogs` : |
`pubID` : |
`sysID` : |
Returns : |

### xmlCatalogLocalResolveURI ()

    xmlChar*    xmlCatalogLocalResolveURI       (void *catalogs,
                                                 const xmlChar *URI);

Do a complete resolution lookup of an URI using a document's private catalog list

`catalogs` : |
`URI` : |
Returns : |

### xmlCatalogSetDebug ()

    int         xmlCatalogSetDebug              (int level);

Used to set the debug level for catalog operation, 0 disable debugging, 1 enable it

`level` : |
Returns : |

### xmlCatalogSetDefaultPrefer ()

    xmlCatalogPrefer xmlCatalogSetDefaultPrefer (xmlCatalogPrefer prefer);

Allows to set the preference between public and system for deletion in XML Catalog resolution. C.f. section 4.1.1 of the spec Values accepted are XML_CATA_PREFER_PUBLIC or XML_CATA_PREFER_SYSTEM

`prefer` : |
Returns : |

### xmlCatalogSetDefaults ()

    void        xmlCatalogSetDefaults           (xmlCatalogAllow allow);

Used to set the user preference w.r.t. to what catalogs should be accepted

`allow` : |

### xmlCatalogGetDefaults ()

    xmlCatalogAllow xmlCatalogGetDefaults       (void);

Used to get the user preference w.r.t. to what catalogs should be accepted

Returns : |

### xmlCatalogGetSystem ()

    const xmlChar* xmlCatalogGetSystem          (const xmlChar *sysID);

Try to lookup the system ID associated to a public ID DEPRECATED, use xmlCatalogResolveSystem()

`sysID` : |
Returns : |

### xmlCatalogGetPublic ()

    const xmlChar* xmlCatalogGetPublic          (const xmlChar *pubID);

Try to lookup the system ID associated to a public ID DEPRECATED, use xmlCatalogResolvePublic()

`pubID` : |
Returns : |

<<< Previous Page | Home | Up | Next Page >>>
xmlIO | c14n