debugXML

Name

debugXML -- 

Synopsis



void        xmlDebugDumpString              (FILE *output,
                                             const xmlChar *str);
void        xmlDebugDumpAttr                (FILE *output,
                                             xmlAttrPtr attr,
                                             int depth);
void        xmlDebugDumpAttrList            (FILE *output,
                                             xmlAttrPtr attr,
                                             int depth);
void        xmlDebugDumpOneNode             (FILE *output,
                                             xmlNodePtr node,
                                             int depth);
void        xmlDebugDumpNode                (FILE *output,
                                             xmlNodePtr node,
                                             int depth);
void        xmlDebugDumpNodeList            (FILE *output,
                                             xmlNodePtr node,
                                             int depth);
void        xmlDebugDumpDocumentHead        (FILE *output,
                                             xmlDocPtr doc);
void        xmlDebugDumpDocument            (FILE *output,
                                             xmlDocPtr doc);
void        xmlDebugDumpDTD                 (FILE *output,
                                             xmlDtdPtr dtd);
void        xmlDebugDumpEntities            (FILE *output,
                                             xmlDocPtr doc);
void        xmlLsOneNode                    (FILE *output,
                                             xmlNodePtr node);
int         xmlLsCountNode                  (xmlNodePtr node);
char*       (*xmlShellReadlineFunc)         (char *prompt);
struct      xmlShellCtxt;
typedef     xmlShellCtxtPtr;
int         (*xmlShellCmd)                  (xmlShellCtxtPtr ctxt,
                                             char *arg,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);
void        xmlShellPrintXPathError         (int errorType,
                                             const char *arg);
void        xmlShellPrintNode               (xmlNodePtr node);
void        xmlShellPrintXPathResult        (xmlXPathObjectPtr list);
int         xmlShellList                    (xmlShellCtxtPtr ctxt,
                                             char *arg,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);
int         xmlShellBase                    (xmlShellCtxtPtr ctxt,
                                             char *arg,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);
int         xmlShellDir                     (xmlShellCtxtPtr ctxt,
                                             char *arg,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);
int         xmlShellCat                     (xmlShellCtxtPtr ctxt,
                                             char *arg,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);
int         xmlShellLoad                    (xmlShellCtxtPtr ctxt,
                                             char *filename,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);
int         xmlShellWrite                   (xmlShellCtxtPtr ctxt,
                                             char *filename,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);
int         xmlShellSave                    (xmlShellCtxtPtr ctxt,
                                             char *filename,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);
int         xmlShellValidate                (xmlShellCtxtPtr ctxt,
                                             char *dtd,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);
int         xmlShellDu                      (xmlShellCtxtPtr ctxt,
                                             char *arg,
                                             xmlNodePtr tree,
                                             xmlNodePtr node2);
int         xmlShellPwd                     (xmlShellCtxtPtr ctxt,
                                             char *buffer,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);
void        xmlShell                        (xmlDocPtr doc,
                                             char *filename,
                                             xmlShellReadlineFunc input,
                                             FILE *output);

Description

Details

>xmlDebugDumpString ()

void        xmlDebugDumpString              (FILE *output,
                                             const xmlChar *str);

Dumps informations about the string, shorten it if necessary

output : the FILE * for the output
str : the string


>xmlDebugDumpAttr ()

void        xmlDebugDumpAttr                (FILE *output,
                                             xmlAttrPtr attr,
                                             int depth);

Dumps debug information for the attribute

output : the FILE * for the output
attr : the attribute
depth : the indentation level.


>xmlDebugDumpAttrList ()

void        xmlDebugDumpAttrList            (FILE *output,
                                             xmlAttrPtr attr,
                                             int depth);

Dumps debug information for the attribute list

output : the FILE * for the output
attr : the attribute list
depth : the indentation level.


>xmlDebugDumpOneNode ()

void        xmlDebugDumpOneNode             (FILE *output,
                                             xmlNodePtr node,
                                             int depth);

Dumps debug information for the element node, it is not recursive

output : the FILE * for the output
node : the node
depth : the indentation level.


>xmlDebugDumpNode ()

void        xmlDebugDumpNode                (FILE *output,
                                             xmlNodePtr node,
                                             int depth);

Dumps debug information for the element node, it is recursive

output : the FILE * for the output
node : the node
depth : the indentation level.


>xmlDebugDumpNodeList ()

void        xmlDebugDumpNodeList            (FILE *output,
                                             xmlNodePtr node,
                                             int depth);

Dumps debug information for the list of element node, it is recursive

output : the FILE * for the output
node : the node list
depth : the indentation level.


>xmlDebugDumpDocumentHead ()

void        xmlDebugDumpDocumentHead        (FILE *output,
                                             xmlDocPtr doc);

Dumps debug information cncerning the document, not recursive

output : the FILE * for the output
doc : the document


>xmlDebugDumpDocument ()

void        xmlDebugDumpDocument            (FILE *output,
                                             xmlDocPtr doc);

Dumps debug information for the document, it's recursive

output : the FILE * for the output
doc : the document


>xmlDebugDumpDTD ()

void        xmlDebugDumpDTD                 (FILE *output,
                                             xmlDtdPtr dtd);

Dumps debug information for the DTD

output : the FILE * for the output
dtd : the DTD


>xmlDebugDumpEntities ()

void        xmlDebugDumpEntities            (FILE *output,
                                             xmlDocPtr doc);

Dumps debug information for all the entities in use by the document

output : the FILE * for the output
doc : the document


>xmlLsOneNode ()

void        xmlLsOneNode                    (FILE *output,
                                             xmlNodePtr node);

Dump to output the type and name of node.

output : the FILE * for the output
node : the node to dump


>xmlLsCountNode ()

int         xmlLsCountNode                  (xmlNodePtr node);

Count the children of node.

node : the node to count
Returns :the number of children of node.


>xmlShellReadlineFunc ()

char*       (*xmlShellReadlineFunc)         (char *prompt);

This is a generic signature for the XML shell input function

prompt : a string prompt
Returns :a string which will be freed by the Shell


>struct xmlShellCtxt

struct xmlShellCtxt {
    char *filename;
    xmlDocPtr doc;
    xmlNodePtr node;
    xmlXPathContextPtr pctxt;
    int loaded;
    FILE *output;
    xmlShellReadlineFunc input;
};

A debugging shell context TODO: add the defined function tables.


>xmlShellCtxtPtr

typedef xmlShellCtxt *xmlShellCtxtPtr;


>xmlShellCmd ()

int         (*xmlShellCmd)                  (xmlShellCtxtPtr ctxt,
                                             char *arg,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);

This is a generic signature for the XML shell functions

ctxt : a shell context
arg : a string argument
node : a first node
node2 : a second node
Returns :an int, negative returns indicating errors


>xmlShellPrintXPathError ()

void        xmlShellPrintXPathError         (int errorType,
                                             const char *arg);

Print the xpath error to libxml default error channel

errorType : valid xpath error id
arg : the argument that cause xpath to fail


>xmlShellPrintNode ()

void        xmlShellPrintNode               (xmlNodePtr node);

Print node to stdout

node : a non-null node to print to stdout


>xmlShellPrintXPathResult ()

void        xmlShellPrintXPathResult        (xmlXPathObjectPtr list);

Prints result to stdout

list : 


>xmlShellList ()

int         xmlShellList                    (xmlShellCtxtPtr ctxt,
                                             char *arg,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);

Implements the XML shell function "ls" Does an Unix like listing of the given node (like a directory)

ctxt : the shell context
arg : unused
node : a node
node2 : unused
Returns :0


>xmlShellBase ()

int         xmlShellBase                    (xmlShellCtxtPtr ctxt,
                                             char *arg,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);

Implements the XML shell function "base" dumps the current XML base of the node

ctxt : the shell context
arg : unused
node : a node
node2 : unused
Returns :0


>xmlShellDir ()

int         xmlShellDir                     (xmlShellCtxtPtr ctxt,
                                             char *arg,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);

Implements the XML shell function "dir" dumps informations about the node (namespace, attributes, content).

ctxt : the shell context
arg : unused
node : a node
node2 : unused
Returns :0


>xmlShellCat ()

int         xmlShellCat                     (xmlShellCtxtPtr ctxt,
                                             char *arg,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);

Implements the XML shell function "cat" dumps the serialization node content (XML or HTML).

ctxt : the shell context
arg : unused
node : a node
node2 : unused
Returns :0


>xmlShellLoad ()

int         xmlShellLoad                    (xmlShellCtxtPtr ctxt,
                                             char *filename,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);

Implements the XML shell function "load" loads a new document specified by the filename

ctxt : the shell context
filename : the file name
node : unused
node2 : unused
Returns :0 or -1 if loading failed


>xmlShellWrite ()

int         xmlShellWrite                   (xmlShellCtxtPtr ctxt,
                                             char *filename,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);

Implements the XML shell function "write" Write the current node to the filename, it saves the serialization of the subtree under the node specified

ctxt : the shell context
filename : the file name
node : a node in the tree
node2 : unused
Returns :0 or -1 in case of error


>xmlShellSave ()

int         xmlShellSave                    (xmlShellCtxtPtr ctxt,
                                             char *filename,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);

Implements the XML shell function "save" Write the current document to the filename, or it's original name

ctxt : the shell context
filename : the file name (optional)
node : unused
node2 : unused
Returns :0 or -1 in case of error


>xmlShellValidate ()

int         xmlShellValidate                (xmlShellCtxtPtr ctxt,
                                             char *dtd,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);

Implements the XML shell function "validate" Validate the document, if a DTD path is provided, then the validation is done against the given DTD.

ctxt : the shell context
dtd : the DTD URI (optional)
node : unused
node2 : unused
Returns :0 or -1 in case of error


>xmlShellDu ()

int         xmlShellDu                      (xmlShellCtxtPtr ctxt,
                                             char *arg,
                                             xmlNodePtr tree,
                                             xmlNodePtr node2);

Implements the XML shell function "du" show the structure of the subtree under node tree If tree is null, the command works on the current node.

ctxt : the shell context
arg : unused
tree : a node defining a subtree
node2 : unused
Returns :0 or -1 in case of error


>xmlShellPwd ()

int         xmlShellPwd                     (xmlShellCtxtPtr ctxt,
                                             char *buffer,
                                             xmlNodePtr node,
                                             xmlNodePtr node2);

Implements the XML shell function "pwd" Show the full path from the root to the node, if needed building thumblers when similar elements exists at a given ancestor level. The output is compatible with XPath commands.

ctxt : the shell context
buffer : the output buffer
node : 
node2 : unused
Returns :0 or -1 in case of error


>xmlShell ()

void        xmlShell                        (xmlDocPtr doc,
                                             char *filename,
                                             xmlShellReadlineFunc input,
                                             FILE *output);

Implements the XML shell This allow to load, validate, view, modify and save a document using a environment similar to a UNIX commandline.

doc : the initial document
filename : the output buffer
input : the line reading function
output : the output FILE*