diff --git a/doc/html/libxml-globals.html b/doc/html/libxml-globals.html new file mode 100644 index 00000000..842379b2 --- /dev/null +++ b/doc/html/libxml-globals.html @@ -0,0 +1,1316 @@ +globals
Gnome XML Library Reference Manual
<<< Previous PageHomeUpNext Page >>>

globals

Name

globals -- 

Synopsis


+
+struct      xmlGlobalState;
+typedef     xmlGlobalStatePtr;
+void        xmlInitializeGlobalState        (xmlGlobalStatePtr gs);
+#define     xmlMalloc                       (size)
+#define     xmlRealloc                      (ptr, size)
+#define     xmlFree
+#define     xmlMemStrdup                    (str)
+#define     docbDefaultSAXHandler
+#define     htmlDefaultSAXHandler
+#define     oldXMLWDcompatibility
+#define     xmlBufferAllocScheme
+#define     xmlDefaultBufferSize
+#define     xmlDefaultSAXHandler
+#define     xmlDefaultSAXLocator
+#define     xmlDoValidityCheckingDefaultValue
+#define     xmlGenericError
+#define     xmlGenericErrorContext
+#define     xmlGetWarningsDefaultValue
+#define     xmlIndentTreeOutput
+#define     xmlKeepBlanksDefaultValue
+#define     xmlLineNumbersDefaultValue
+#define     xmlLoadExtDtdDefaultValue
+#define     xmlParserDebugEntities
+#define     xmlParserVersion
+#define     xmlPedanticParserDefaultValue
+#define     xmlSaveNoEmptyTags
+#define     xmlSubstituteEntitiesDefaultValue

Description

Details

struct xmlGlobalState

struct xmlGlobalState 
+{
+	const char *xmlParserVersion;
+
+	xmlSAXLocator xmlDefaultSAXLocator;
+	xmlSAXHandler xmlDefaultSAXHandler;
+	xmlSAXHandler docbDefaultSAXHandler;
+	xmlSAXHandler htmlDefaultSAXHandler;
+
+	xmlFreeFunc xmlFree;
+	xmlMallocFunc xmlMalloc;
+	xmlStrdupFunc xmlMemStrdup;
+	xmlReallocFunc xmlRealloc;
+
+	xmlGenericErrorFunc xmlGenericError;
+	void *xmlGenericErrorContext;
+
+	int oldXMLWDcompatibility;
+
+	xmlBufferAllocationScheme xmlBufferAllocScheme;
+	int xmlDefaultBufferSize;
+
+	int xmlSubstituteEntitiesDefaultValue;
+	int xmlDoValidityCheckingDefaultValue;
+	int xmlGetWarningsDefaultValue;
+	int xmlKeepBlanksDefaultValue;
+	int xmlLineNumbersDefaultValue;
+	int xmlLoadExtDtdDefaultValue;
+	int xmlParserDebugEntities;
+	int xmlPedanticParserDefaultValue;
+
+	int xmlSaveNoEmptyTags;
+	int xmlIndentTreeOutput;
+};

xmlGlobalStatePtr

typedef xmlGlobalState *xmlGlobalStatePtr;

xmlInitializeGlobalState ()

void        xmlInitializeGlobalState        (xmlGlobalStatePtr gs);

xmlInitializeGlobalState() initialize a global state with all the +default values of the library.

gs : a pointer to a newly allocated global state

xmlMalloc()

#define     xmlMalloc(size)

Wrapper for the malloc() function used in the XML library

size : 

xmlRealloc()

#define     xmlRealloc(ptr, size)

Wrapper for the realloc() function used in the XML library

ptr : 
size : 

xmlFree

#define     xmlFree

xmlMemStrdup()

#define     xmlMemStrdup(str)

Wrapper for the strdup() function, xmlStrdup() is usually preferred

str : 

docbDefaultSAXHandler

#define     docbDefaultSAXHandler

htmlDefaultSAXHandler

#define     htmlDefaultSAXHandler

oldXMLWDcompatibility

#define     oldXMLWDcompatibility

xmlBufferAllocScheme

#define     xmlBufferAllocScheme

xmlDefaultBufferSize

#define     xmlDefaultBufferSize

xmlDefaultSAXHandler

#define     xmlDefaultSAXHandler

xmlDefaultSAXLocator

#define     xmlDefaultSAXLocator

xmlDoValidityCheckingDefaultValue

#define     xmlDoValidityCheckingDefaultValue

xmlGenericError

#define     xmlGenericError

xmlGenericErrorContext

#define     xmlGenericErrorContext

xmlGetWarningsDefaultValue

#define     xmlGetWarningsDefaultValue

xmlIndentTreeOutput

#define     xmlIndentTreeOutput

xmlKeepBlanksDefaultValue

#define     xmlKeepBlanksDefaultValue

xmlLineNumbersDefaultValue

#define     xmlLineNumbersDefaultValue

xmlLoadExtDtdDefaultValue

#define     xmlLoadExtDtdDefaultValue

xmlParserDebugEntities

#define     xmlParserDebugEntities

xmlParserVersion

#define     xmlParserVersion

xmlPedanticParserDefaultValue

#define     xmlPedanticParserDefaultValue

xmlSaveNoEmptyTags

#define     xmlSaveNoEmptyTags

xmlSubstituteEntitiesDefaultValue

#define     xmlSubstituteEntitiesDefaultValue

global variable controlling the entity substitution default behaviour



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

hash

Name

hash -- 

Synopsis


+
+struct      xmlHashTable;
+typedef     xmlHashTablePtr;
+void        (*xmlHashDeallocator)           (void *payload,
+                                             xmlChar *name);
+void*       (*xmlHashCopier)                (void *payload,
+                                             xmlChar *name);
+void*       (*xmlHashScanner)               (void *payload,
+                                             void *data,
+                                             xmlChar *name);
+void        (*xmlHashScannerFull)           (void *payload,
+                                             void *data,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3);
+xmlHashTablePtr xmlHashCreate               (int size);
+void        xmlHashFree                     (xmlHashTablePtr table,
+                                             xmlHashDeallocator f);
+int         xmlHashAddEntry                 (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             void *userdata);
+int         xmlHashUpdateEntry              (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             void *userdata,
+                                             xmlHashDeallocator f);
+int         xmlHashAddEntry2                (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             void *userdata);
+int         xmlHashUpdateEntry2             (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             void *userdata,
+                                             xmlHashDeallocator f);
+int         xmlHashAddEntry3                (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3,
+                                             void *userdata);
+int         xmlHashUpdateEntry3             (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3,
+                                             void *userdata,
+                                             xmlHashDeallocator f);
+int         xmlHashRemoveEntry              (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             xmlHashDeallocator f);
+int         xmlHashRemoveEntry2             (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             xmlHashDeallocator f);
+int         xmlHashRemoveEntry3             (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3,
+                                             xmlHashDeallocator f);
+void*       xmlHashLookup                   (xmlHashTablePtr table,
+                                             const xmlChar *name);
+void*       xmlHashLookup2                  (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2);
+void*       xmlHashLookup3                  (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3);
+xmlHashTablePtr xmlHashCopy                 (xmlHashTablePtr table,
+                                             xmlHashCopier f);
+int         xmlHashSize                     (xmlHashTablePtr table);
+void        xmlHashScan                     (xmlHashTablePtr table,
+                                             xmlHashScanner f,
+                                             void *data);
+void        xmlHashScan3                    (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3,
+                                             xmlHashScanner f,
+                                             void *data);
+void        xmlHashScanFull                 (xmlHashTablePtr table,
+                                             xmlHashScannerFull f,
+                                             void *data);
+void        xmlHashScanFull3                (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3,
+                                             xmlHashScannerFull f,
+                                             void *data);

Description

Details

struct xmlHashTable

struct xmlHashTable;

xmlHashTablePtr

typedef xmlHashTable *xmlHashTablePtr;

xmlHashDeallocator ()

void        (*xmlHashDeallocator)           (void *payload,
+                                             xmlChar *name);

payload : 
name : 

xmlHashCopier ()

void*       (*xmlHashCopier)                (void *payload,
+                                             xmlChar *name);

payload : 
name : 

xmlHashScanner ()

void*       (*xmlHashScanner)               (void *payload,
+                                             void *data,
+                                             xmlChar *name);

payload : 
data : 
name : 

xmlHashScannerFull ()

void        (*xmlHashScannerFull)           (void *payload,
+                                             void *data,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3);

payload : 
data : 
name : 
name2 : 
name3 : 

xmlHashCreate ()

xmlHashTablePtr xmlHashCreate               (int size);

Create a new xmlHashTablePtr.

size : the size of the hash table
Returns :the newly created object, or NULL if an error occured.

xmlHashFree ()

void        xmlHashFree                     (xmlHashTablePtr table,
+                                             xmlHashDeallocator f);

Free the hash table and its contents. The userdata is +deallocated with f if provided.

table : the hash table
f : the deallocator function for items in the hash

xmlHashAddEntry ()

int         xmlHashAddEntry                 (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             void *userdata);

Add the userdata to the hash table. This can later be retrieved +by using the name. Duplicate names generate errors.

table : the hash table
name : the name of the userdata
userdata : a pointer to the userdata
Returns :0 the addition succeeded and -1 in case of error.

xmlHashUpdateEntry ()

int         xmlHashUpdateEntry              (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             void *userdata,
+                                             xmlHashDeallocator f);

Add the userdata to the hash table. This can later be retrieved +by using the name. Existing entry for this name will be removed +and freed with f if found.

table : the hash table
name : the name of the userdata
userdata : a pointer to the userdata
f : the deallocator function for replaced item (if any)
Returns :0 the addition succeeded and -1 in case of error.

xmlHashAddEntry2 ()

int         xmlHashAddEntry2                (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             void *userdata);

Add the userdata to the hash table. This can later be retrieved +by using the (name, name2) tuple. Duplicate tuples generate errors.

table : the hash table
name : the name of the userdata
name2 : a second name of the userdata
userdata : a pointer to the userdata
Returns :0 the addition succeeded and -1 in case of error.

xmlHashUpdateEntry2 ()

int         xmlHashUpdateEntry2             (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             void *userdata,
+                                             xmlHashDeallocator f);

Add the userdata to the hash table. This can later be retrieved +by using the (name, name2) tuple. Existing entry for this tuple will +be removed and freed with f if found.

table : the hash table
name : the name of the userdata
name2 : a second name of the userdata
userdata : a pointer to the userdata
f : the deallocator function for replaced item (if any)
Returns :0 the addition succeeded and -1 in case of error.

xmlHashAddEntry3 ()

int         xmlHashAddEntry3                (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3,
+                                             void *userdata);

Add the userdata to the hash table. This can later be retrieved +by using the tuple (name, name2, name3). Duplicate entries generate +errors.

table : the hash table
name : the name of the userdata
name2 : a second name of the userdata
name3 : a third name of the userdata
userdata : a pointer to the userdata
Returns :0 the addition succeeded and -1 in case of error.

xmlHashUpdateEntry3 ()

int         xmlHashUpdateEntry3             (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3,
+                                             void *userdata,
+                                             xmlHashDeallocator f);

Add the userdata to the hash table. This can later be retrieved +by using the tuple (name, name2, name3). Existing entry for this tuple +will be removed and freed with f if found.

table : the hash table
name : the name of the userdata
name2 : a second name of the userdata
name3 : a third name of the userdata
userdata : a pointer to the userdata
f : the deallocator function for replaced item (if any)
Returns :0 the addition succeeded and -1 in case of error.

xmlHashRemoveEntry ()

int         xmlHashRemoveEntry              (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             xmlHashDeallocator f);

Find the userdata specified by the (name, name2, name3) tuple and remove +it from the hash table. Existing userdata for this tuple will be removed +and freed with f.

table : the hash table
name : the name of the userdata
f : the deallocator function for removed item (if any)
Returns :0 if the removal succeeded and -1 in case of error or not found.

xmlHashRemoveEntry2 ()

int         xmlHashRemoveEntry2             (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             xmlHashDeallocator f);

Find the userdata specified by the (name, name2, name3) tuple and remove +it from the hash table. Existing userdata for this tuple will be removed +and freed with f.

table : the hash table
name : the name of the userdata
name2 : a second name of the userdata
f : the deallocator function for removed item (if any)
Returns :0 if the removal succeeded and -1 in case of error or not found.

xmlHashRemoveEntry3 ()

int         xmlHashRemoveEntry3             (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3,
+                                             xmlHashDeallocator f);

Find the userdata specified by the (name, name2, name3) tuple and remove +it from the hash table. Existing userdata for this tuple will be removed +and freed with f.

table : the hash table
name : the name of the userdata
name2 : a second name of the userdata
name3 : a third name of the userdata
f : the deallocator function for removed item (if any)
Returns :0 if the removal succeeded and -1 in case of error or not found.

xmlHashLookup ()

void*       xmlHashLookup                   (xmlHashTablePtr table,
+                                             const xmlChar *name);

Find the userdata specified by the name.

table : the hash table
name : the name of the userdata

xmlHashLookup2 ()

void*       xmlHashLookup2                  (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2);

Find the userdata specified by the (name, name2) tuple.

table : the hash table
name : the name of the userdata
name2 : a second name of the userdata

xmlHashLookup3 ()

void*       xmlHashLookup3                  (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3);

Find the userdata specified by the (name, name2, name3) tuple.

table : the hash table
name : the name of the userdata
name2 : a second name of the userdata
name3 : a third name of the userdata

xmlHashCopy ()

xmlHashTablePtr xmlHashCopy                 (xmlHashTablePtr table,
+                                             xmlHashCopier f);

Scan the hash table and applied f to each value.

table : the hash table
f : the copier function for items in the hash
Returns :the new table or NULL in case of error.

xmlHashSize ()

int         xmlHashSize                     (xmlHashTablePtr table);

Query the number of element installed in the hash table.

table : the hash table
Returns :the number of elements in the hash table or +-1 in case of error

xmlHashScan ()

void        xmlHashScan                     (xmlHashTablePtr table,
+                                             xmlHashScanner f,
+                                             void *data);

Scan the hash table and applied f to each value.

table : the hash table
f : the scanner function for items in the hash
data : extra data passed to f

xmlHashScan3 ()

void        xmlHashScan3                    (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3,
+                                             xmlHashScanner f,
+                                             void *data);

Scan the hash table and applied f to each value matching +(name, name2, name3) tuple. If one of the names is null, +the comparison is considered to match.

table : the hash table
name : the name of the userdata or NULL
name2 : a second name of the userdata or NULL
name3 : a third name of the userdata or NULL
f : the scanner function for items in the hash
data : extra data passed to f

xmlHashScanFull ()

void        xmlHashScanFull                 (xmlHashTablePtr table,
+                                             xmlHashScannerFull f,
+                                             void *data);

Scan the hash table and applied f to each value.

table : the hash table
f : the scanner function for items in the hash
data : extra data passed to f

xmlHashScanFull3 ()

void        xmlHashScanFull3                (xmlHashTablePtr table,
+                                             const xmlChar *name,
+                                             const xmlChar *name2,
+                                             const xmlChar *name3,
+                                             xmlHashScannerFull f,
+                                             void *data);

Scan the hash table and applied f to each value matching +(name, name2, name3) tuple. If one of the names is null, +the comparison is considered to match.

table : the hash table
name : the name of the userdata or NULL
name2 : a second name of the userdata or NULL
name3 : a third name of the userdata or NULL
f : the scanner function for items in the hash
data : extra data passed to f



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

threads

Name

threads -- 

Synopsis


+
+struct      xmlMutex;
+typedef     xmlMutexPtr;
+xmlMutexPtr xmlNewMutex                     (void);
+void        xmlMutexLock                    (xmlMutexPtr tok);
+void        xmlMutexUnlock                  (xmlMutexPtr tok);
+void        xmlFreeMutex                    (xmlMutexPtr tok);
+struct      xmlRMutex;
+typedef     xmlRMutexPtr;
+xmlRMutexPtr xmlNewRMutex                   (void);
+void        xmlRMutexLock                   (xmlRMutexPtr tok);
+void        xmlRMutexUnlock                 (xmlRMutexPtr tok);
+void        xmlFreeRMutex                   (xmlRMutexPtr tok);
+void        xmlInitThreads                  (void);
+void        xmlLockLibrary                  (void);
+void        xmlUnlockLibrary                (void);
+int         xmlGetThreadId                  (void);
+int         xmlIsMainThread                 (void);
+void        xmlCleanupThreads               (void);
+xmlGlobalStatePtr xmlGetGlobalState         (void);

Description

Details

struct xmlMutex

struct xmlMutex;

xmlMutexPtr

typedef xmlMutex *xmlMutexPtr;

xmlNewMutex() is used to allocate a libxml2 token struct for use in +synchronizing access to data.

xmlNewMutex ()

xmlMutexPtr xmlNewMutex                     (void);

Returns : 

xmlMutexLock ()

void        xmlMutexLock                    (xmlMutexPtr tok);

xmlMutexLock() is used to lock a libxml2 token.

tok : the simple mutex

xmlMutexUnlock ()

void        xmlMutexUnlock                  (xmlMutexPtr tok);

xmlMutexUnlock() is used to unlock a libxml2 token.

tok : the simple mutex

xmlFreeMutex ()

void        xmlFreeMutex                    (xmlMutexPtr tok);

xmlFreeMutex() is used to reclaim resources associated with a libxml2 token +struct.

tok : the simple mutex

struct xmlRMutex

struct xmlRMutex;

xmlRMutexPtr

typedef xmlRMutex *xmlRMutexPtr;

xmlNewRMutex ()

xmlRMutexPtr xmlNewRMutex                   (void);

Returns : 

xmlRMutexLock ()

void        xmlRMutexLock                   (xmlRMutexPtr tok);

xmlRMutexLock() is used to lock a libxml2 token_r.

tok : the reentrant mutex

xmlRMutexUnlock ()

void        xmlRMutexUnlock                 (xmlRMutexPtr tok);

xmlRMutexUnlock() is used to unlock a libxml2 token_r.

tok : the reentrant mutex

xmlFreeRMutex ()

void        xmlFreeRMutex                   (xmlRMutexPtr tok);

tok : 

xmlInitThreads ()

void        xmlInitThreads                  (void);

xmlInitThreads() is used to to initialize all the thread related +data of the libxml2 library.

xmlLockLibrary ()

void        xmlLockLibrary                  (void);

xmlLockLibrary() is used to take out a re-entrant lock on the libxml2 +library.

xmlUnlockLibrary ()

void        xmlUnlockLibrary                (void);

xmlUnlockLibrary() is used to release a re-entrant lock on the libxml2 +library.

xmlGetThreadId ()

int         xmlGetThreadId                  (void);

xmlGetThreadId() find the current thread ID number

Returns :the current thread ID number

xmlIsMainThread ()

int         xmlIsMainThread                 (void);

xmlIsMainThread() check wether the current thread is the main thread.

Returns :1 if the current thread is the main thread, 0 otherwise

xmlCleanupThreads ()

void        xmlCleanupThreads               (void);

xmlCleanupThreads() is used to to cleanup all the thread related +data of the libxml2 library once processing has ended.

xmlGetGlobalState ()

xmlGlobalStatePtr xmlGetGlobalState         (void);

xmlGetGlobalState() is called to retrieve the global state for a thread. +keyonce will only be set once during a library invocation and is used +to create globalkey, the key used to store each thread's TSD.

Note: it should not be called for the "main" thread as this thread uses +the existing global variables defined in the library.

Returns :the thread global state or NULL in case of error



<<< Previous PageHomeUpNext Page >>>
catalogglobals
\ No newline at end of file