Menu
▾
▴
[perl-xml-cvs] CVS: XML-LibXML-XPathContext xpath.h,1.1.1.1,1.2 xpath.c,1.1.1.1,1.2 perl-libxml-sax.h,1.1.1.1,1.2 perl-libxml-sax.c,1.1.1.1,1.2 perl-libxml-mm.h,1.1.1.1,1.2 perl-libxml-mm.c,1.1.1.1,1.2 dom.h,1.1.1.1,1.2 dom.c,1.1.1.1,1.2
Update of /cvsroot/perl-xml/XML-LibXML-XPathContext
In directory sc8-pr-cvs1:/tmp/cvs-serv2917
Modified Files:
xpath.h xpath.c perl-libxml-sax.h perl-libxml-sax.c
perl-libxml-mm.h perl-libxml-mm.c dom.h dom.c
Log Message:
added xpc_ prefix to all exported symbols
Index: xpath.h
===================================================================
RCS file: /cvsroot/perl-xml/XML-LibXML-XPathContext/xpath.h,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -d -r1.1.1.1 -r1.2
--- xpath.h 14 Mar 2003 14:32:02 -0000 1.1.1.1
+++ xpath.h 20 May 2003 15:25:50 -0000 1.2
@@ -5,12 +5,12 @@
#include <libxml/xpath.h>
void
-perlDocumentFunction( xmlXPathParserContextPtr ctxt, int nargs );
+xpc_perlDocumentFunction( xmlXPathParserContextPtr ctxt, int nargs );
xmlNodeSetPtr
-domXPathSelect( xmlXPathContextPtr ctxt, xmlChar * xpathstring );
+xpc_domXPathSelect( xmlXPathContextPtr ctxt, xmlChar * xpathstring );
xmlXPathObjectPtr
-domXPathFind( xmlXPathContextPtr ctxt, xmlChar * xpathstring );
+xpc_domXPathFind( xmlXPathContextPtr ctxt, xmlChar * xpathstring );
#endif
Index: xpath.c
===================================================================
RCS file: /cvsroot/perl-xml/XML-LibXML-XPathContext/xpath.c,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -d -r1.1.1.1 -r1.2
--- xpath.c 14 Mar 2003 14:32:00 -0000 1.1.1.1
+++ xpath.c 20 May 2003 15:25:50 -0000 1.2
@@ -8,7 +8,7 @@
#include "dom.h"
void
-perlDocumentFunction(xmlXPathParserContextPtr ctxt, int nargs){
+xpc_perlDocumentFunction(xmlXPathParserContextPtr ctxt, int nargs){
xmlXPathObjectPtr obj = NULL, obj2 = NULL;
xmlChar *base = NULL, *URI = NULL;
@@ -48,7 +48,7 @@
valuePush(ctxt,
xmlXPathNewNodeSet(obj->nodesetval->nodeTab[i]));
}
- perlDocumentFunction(ctxt, 2);
+ xpc_perlDocumentFunction(ctxt, 2);
newobj = valuePop(ctxt);
ret->nodesetval = xmlXPathNodeSetMerge(ret->nodesetval,
newobj->nodesetval);
@@ -124,7 +124,7 @@
**/
xmlXPathObjectPtr
-domXPathFind( xmlXPathContextPtr ctxt, xmlChar * path ) {
+xpc_domXPathFind( xmlXPathContextPtr ctxt, xmlChar * path ) {
xmlXPathObjectPtr res = NULL;
if ( ctxt->node != NULL && path != NULL ) {
@@ -178,11 +178,11 @@
}
xmlNodeSetPtr
-domXPathSelect( xmlXPathContextPtr ctxt, xmlChar * path ) {
+xpc_domXPathSelect( xmlXPathContextPtr ctxt, xmlChar * path ) {
xmlNodeSetPtr rv = NULL;
xmlXPathObjectPtr res = NULL;
- res = domXPathFind( ctxt, path );
+ res = xpc_domXPathFind( ctxt, path );
if (res != NULL) {
/* here we have to transfer the result from the internal
Index: perl-libxml-sax.h
===================================================================
RCS file: /cvsroot/perl-xml/XML-LibXML-XPathContext/perl-libxml-sax.h,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -d -r1.1.1.1 -r1.2
--- perl-libxml-sax.h 14 Mar 2003 14:32:02 -0000 1.1.1.1
+++ perl-libxml-sax.h 20 May 2003 15:25:50 -0000 1.2
@@ -18,15 +18,15 @@
/* has to be called in BOOT sequence */
void
-PmmSAXInitialize();
+xpc_PmmSAXInitialize();
void
-PmmSAXInitContext( xmlParserCtxtPtr ctxt, SV * parser );
+xpc_PmmSAXInitContext( xmlParserCtxtPtr ctxt, SV * parser );
void
-PmmSAXCloseContext( xmlParserCtxtPtr ctxt );
+xpc_PmmSAXCloseContext( xmlParserCtxtPtr ctxt );
xmlSAXHandlerPtr
-PSaxGetHandler();
+xpc_PSaxGetHandler();
#endif
Index: perl-libxml-sax.c
===================================================================
RCS file: /cvsroot/perl-xml/XML-LibXML-XPathContext/perl-libxml-sax.c,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -d -r1.1.1.1 -r1.2
--- perl-libxml-sax.c 14 Mar 2003 14:32:03 -0000 1.1.1.1
+++ perl-libxml-sax.c 20 May 2003 15:25:50 -0000 1.2
@@ -35,9 +35,9 @@
xmlSAXLocator * locator;
xmlDocPtr ns_stack_root;
SV * handler;
-} PmmSAXVector;
+} xpc_PmmSAXVector;
-typedef PmmSAXVector* PmmSAXVectorPtr;
+typedef xpc_PmmSAXVector* xpc_PmmSAXVectorPtr;
static U32 PrefixHash; /* pre-computed */
static U32 NsURIHash;
@@ -50,12 +50,12 @@
static U32 VersionHash;
static U32 EncodingHash;
-/* helper function C2Sv is ment to work faster than the perl-libxml-mm
+/* helper function xpc_C2Sv is ment to work faster than the perl-libxml-mm
version. this shortcut is usefull, because SAX handles only UTF8
strings, so there is no conversion logic required.
*/
SV*
-_C2Sv( const xmlChar *string, const xmlChar *dummy )
+_xpc_C2Sv( const xmlChar *string, const xmlChar *dummy )
{
dTHX;
@@ -77,7 +77,7 @@
}
void
-PmmSAXInitialize()
+xpc_PmmSAXInitialize()
{
PERL_HASH(PrefixHash, "Prefix", 6);
PERL_HASH(NsURIHash, "NamespaceURI", 12);
@@ -91,18 +91,18 @@
PERL_HASH(EncodingHash, "Encoding", 8);
}
-xmlSAXHandlerPtr PSaxGetHandler();
+xmlSAXHandlerPtr xpc_PSaxGetHandler();
void
-PmmSAXInitContext( xmlParserCtxtPtr ctxt, SV * parser )
+xpc_PmmSAXInitContext( xmlParserCtxtPtr ctxt, SV * parser )
{
xmlNodePtr ns_stack = NULL;
- PmmSAXVectorPtr vec = NULL;
+ xpc_PmmSAXVectorPtr vec = NULL;
SV ** th;
dTHX;
- vec = (PmmSAXVector*) xmlMalloc( sizeof(PmmSAXVector) );
+ vec = (xpc_PmmSAXVector*) xmlMalloc( sizeof(xpc_PmmSAXVector) );
vec->ns_stack_root = xmlNewDoc(NULL);
vec->ns_stack = xmlNewDocNode(vec->ns_stack_root,
@@ -126,15 +126,15 @@
if ( ctxt->sax ) {
xmlFree( ctxt->sax );
}
- ctxt->sax = PSaxGetHandler();
+ ctxt->sax = xpc_PSaxGetHandler();
ctxt->_private = (void*)vec;
}
void
-PmmSAXCloseContext( xmlParserCtxtPtr ctxt )
+xpc_PmmSAXCloseContext( xmlParserCtxtPtr ctxt )
{
- PmmSAXVector * vec = (PmmSAXVectorPtr) ctxt->_private;
+ xpc_PmmSAXVector * vec = (xpc_PmmSAXVectorPtr) ctxt->_private;
dTHX;
if ( vec->handler != NULL ) {
@@ -156,7 +156,7 @@
xmlNsPtr
-PmmGetNsMapping( xmlNodePtr ns_stack, const xmlChar * prefix )
+xpc_PmmGetNsMapping( xmlNodePtr ns_stack, const xmlChar * prefix )
{
if ( ns_stack != NULL ) {
return xmlSearchNs( ns_stack->doc, ns_stack, prefix );
@@ -167,7 +167,7 @@
void
-PSaxStartPrefix( PmmSAXVectorPtr sax, const xmlChar * prefix,
+xpc_PSaxStartPrefix( xpc_PmmSAXVectorPtr sax, const xmlChar * prefix,
const xmlChar * uri, SV * handler )
{
dTHX;
@@ -182,15 +182,15 @@
param = newHV();
hv_store(param, "NamespaceURI", 12,
- _C2Sv(uri, NULL), NsURIHash);
+ _xpc_C2Sv(uri, NULL), NsURIHash);
if ( prefix != NULL ) {
hv_store(param, "Prefix", 6,
- _C2Sv(prefix, NULL), PrefixHash);
+ _xpc_C2Sv(prefix, NULL), PrefixHash);
}
else {
hv_store(param, "Prefix", 6,
- _C2Sv((const xmlChar*)"", NULL), PrefixHash);
+ _xpc_C2Sv((const xmlChar*)"", NULL), PrefixHash);
}
PUSHMARK(SP) ;
@@ -213,7 +213,7 @@
}
void
-PSaxEndPrefix( PmmSAXVectorPtr sax, const xmlChar * prefix,
+xpc_PSaxEndPrefix( xpc_PmmSAXVectorPtr sax, const xmlChar * prefix,
const xmlChar * uri, SV * handler )
{
dTHX;
@@ -226,15 +226,15 @@
SAVETMPS;
param = newHV();
hv_store(param, "NamespaceURI", 12,
- _C2Sv(uri, NULL), NsURIHash);
+ _xpc_C2Sv(uri, NULL), NsURIHash);
if ( prefix != NULL ) {
hv_store(param, "Prefix", 6,
- _C2Sv(prefix, NULL), PrefixHash);
+ _xpc_C2Sv(prefix, NULL), PrefixHash);
}
else {
hv_store(param, "Prefix", 6,
- _C2Sv((const xmlChar *)"", NULL), PrefixHash);
+ _xpc_C2Sv((const xmlChar *)"", NULL), PrefixHash);
}
PUSHMARK(SP) ;
@@ -259,7 +259,7 @@
}
void
-PmmExtendNsStack( PmmSAXVectorPtr sax , const xmlChar * name) {
+xpc_PmmExtendNsStack( xpc_PmmSAXVectorPtr sax , const xmlChar * name) {
xmlNodePtr newNS = NULL;
xmlChar * localname = NULL;
xmlChar * prefix = NULL;
@@ -294,14 +294,14 @@
}
void
-PmmNarrowNsStack( PmmSAXVectorPtr sax, SV *handler )
+xpc_PmmNarrowNsStack( xpc_PmmSAXVectorPtr sax, SV *handler )
{
xmlNodePtr parent = sax->ns_stack->parent;
xmlNsPtr list = sax->ns_stack->nsDef;
while ( list ) {
if ( !xmlStrEqual(list->prefix, (const xmlChar*)"xml") ) {
- PSaxEndPrefix( sax, list->prefix, list->href, handler );
+ xpc_PSaxEndPrefix( sax, list->prefix, list->href, handler );
}
list = list->next;
}
@@ -311,7 +311,7 @@
}
void
-PmmAddNamespace( PmmSAXVectorPtr sax, const xmlChar * name,
+xpc_PmmAddNamespace( xpc_PmmSAXVectorPtr sax, const xmlChar * name,
const xmlChar * href, SV *handler)
{
xmlNsPtr ns = NULL;
@@ -349,11 +349,11 @@
xmlFree( localname );
}
- PSaxStartPrefix( sax, name, href, handler );
+ xpc_PSaxStartPrefix( sax, name, href, handler );
}
HV *
-PmmGenElementSV( pTHX_ PmmSAXVectorPtr sax, const xmlChar * name )
+xpc_PmmGenElementSV( pTHX_ xpc_PmmSAXVectorPtr sax, const xmlChar * name )
{
HV * retval = newHV();
SV * tmp;
@@ -362,7 +362,7 @@
if ( name != NULL && xmlStrlen( name ) ) {
hv_store(retval, "Name", 4,
- _C2Sv(name, NULL), NameHash);
+ _xpc_C2Sv(name, NULL), NameHash);
if ( sax->ns_stack->ns != NULL ) {
ns = sax->ns_stack->ns;
@@ -370,26 +370,26 @@
if ( ns != NULL ) {
hv_store(retval, "NamespaceURI", 12,
- _C2Sv(ns->href, NULL), NsURIHash);
+ _xpc_C2Sv(ns->href, NULL), NsURIHash);
if ( ns->prefix ) {
hv_store(retval, "Prefix", 6,
- _C2Sv(ns->prefix, NULL), PrefixHash);
+ _xpc_C2Sv(ns->prefix, NULL), PrefixHash);
}
else {
hv_store(retval, "Prefix", 6,
- _C2Sv((const xmlChar *)"",NULL), PrefixHash);
+ _xpc_C2Sv((const xmlChar *)"",NULL), PrefixHash);
}
hv_store(retval, "LocalName", 9,
- _C2Sv(sax->ns_stack->name, NULL), LocalNameHash);
+ _xpc_C2Sv(sax->ns_stack->name, NULL), LocalNameHash);
}
else {
hv_store(retval, "NamespaceURI", 12,
- _C2Sv((const xmlChar *)"",NULL), NsURIHash);
+ _xpc_C2Sv((const xmlChar *)"",NULL), NsURIHash);
hv_store(retval, "Prefix", 6,
- _C2Sv((const xmlChar *)"",NULL), PrefixHash);
+ _xpc_C2Sv((const xmlChar *)"",NULL), PrefixHash);
hv_store(retval, "LocalName", 9,
- _C2Sv(name, NULL), LocalNameHash);
+ _xpc_C2Sv(name, NULL), LocalNameHash);
}
}
@@ -397,7 +397,7 @@
}
xmlChar *
-PmmGenNsName( const xmlChar * name, const xmlChar * nsURI )
+xpc_PmmGenNsName( const xmlChar * name, const xmlChar * nsURI )
{
int namelen = 0;
int urilen = 0;
@@ -419,7 +419,7 @@
}
HV *
-PmmGenAttributeHashSV( pTHX_ PmmSAXVectorPtr sax,
+xpc_PmmGenAttributeHashSV( pTHX_ xpc_PmmSAXVectorPtr sax,
const xmlChar **attr, SV * handler )
{
HV * retval = NULL;
@@ -450,59 +450,59 @@
localname = xmlSplitQName(NULL, name, &prefix);
hv_store(atV, "Name", 4,
- _C2Sv(name, NULL), NameHash);
+ _xpc_C2Sv(name, NULL), NameHash);
if ( value != NULL ) {
hv_store(atV, "Value", 5,
- _C2Sv(value, NULL), ValueHash);
+ _xpc_C2Sv(value, NULL), ValueHash);
}
if ( xmlStrEqual( (const xmlChar *)"xmlns", name ) ) {
/* a default namespace */
- PmmAddNamespace( sax, NULL, value, handler);
+ xpc_PmmAddNamespace( sax, NULL, value, handler);
nsURI = (const xmlChar*)NSDEFAULTURI;
hv_store(atV, "Prefix", 6,
- _C2Sv(name, NULL), PrefixHash);
+ _xpc_C2Sv(name, NULL), PrefixHash);
hv_store(atV, "LocalName", 9,
- _C2Sv((const xmlChar *)"",NULL), LocalNameHash);
+ _xpc_C2Sv((const xmlChar *)"",NULL), LocalNameHash);
hv_store(atV, "NamespaceURI", 12,
- _C2Sv((const xmlChar *)NSDEFAULTURI,NULL),
+ _xpc_C2Sv((const xmlChar *)NSDEFAULTURI,NULL),
NsURIHash);
}
else if (xmlStrncmp((const xmlChar *)"xmlns:", name, 6 ) == 0 ) {
- PmmAddNamespace( sax,
+ xpc_PmmAddNamespace( sax,
localname,
value,
handler);
hv_store(atV, "Prefix", 6,
- _C2Sv(prefix, NULL), PrefixHash);
+ _xpc_C2Sv(prefix, NULL), PrefixHash);
hv_store(atV, "LocalName", 9,
- _C2Sv(localname, NULL), LocalNameHash);
+ _xpc_C2Sv(localname, NULL), LocalNameHash);
hv_store(atV, "NamespaceURI", 12,
- _C2Sv((const xmlChar *)NSDEFAULTURI,NULL),
+ _xpc_C2Sv((const xmlChar *)NSDEFAULTURI,NULL),
NsURIHash);
}
else if ( prefix != NULL
- && (ns = PmmGetNsMapping( sax->ns_stack, prefix ) ) ) {
+ && (ns = xpc_PmmGetNsMapping( sax->ns_stack, prefix ) ) ) {
hv_store(atV, "NamespaceURI", 12,
- _C2Sv(ns->href, NULL), NsURIHash);
+ _xpc_C2Sv(ns->href, NULL), NsURIHash);
hv_store(atV, "Prefix", 6,
- _C2Sv(ns->prefix, NULL), PrefixHash);
+ _xpc_C2Sv(ns->prefix, NULL), PrefixHash);
hv_store(atV, "LocalName", 9,
- _C2Sv(localname, NULL), LocalNameHash);
+ _xpc_C2Sv(localname, NULL), LocalNameHash);
}
else {
hv_store(atV, "NamespaceURI", 12,
- _C2Sv((const xmlChar *)"", NULL), NsURIHash);
+ _xpc_C2Sv((const xmlChar *)"", NULL), NsURIHash);
hv_store(atV, "Prefix", 6,
- _C2Sv((const xmlChar *)"", NULL), PrefixHash);
+ _xpc_C2Sv((const xmlChar *)"", NULL), PrefixHash);
hv_store(atV, "LocalName", 9,
- _C2Sv(name, NULL), LocalNameHash);
+ _xpc_C2Sv(name, NULL), LocalNameHash);
}
- keyname = PmmGenNsName( localname != NULL ? localname : name,
+ keyname = xpc_PmmGenNsName( localname != NULL ? localname : name,
nsURI );
len = xmlStrlen( keyname );
@@ -533,20 +533,20 @@
}
HV *
-PmmGenCharDataSV( pTHX_ PmmSAXVectorPtr sax, const xmlChar * data )
+xpc_PmmGenCharDataSV( pTHX_ xpc_PmmSAXVectorPtr sax, const xmlChar * data )
{
HV * retval = newHV();
if ( data != NULL && xmlStrlen( data ) ) {
hv_store(retval, "Data", 4,
- _C2Sv(data, NULL), DataHash);
+ _xpc_C2Sv(data, NULL), DataHash);
}
return retval;
}
HV *
-PmmGenPISV( pTHX_ PmmSAXVectorPtr sax,
+xpc_PmmGenPISV( pTHX_ xpc_PmmSAXVectorPtr sax,
const xmlChar * target,
const xmlChar * data )
{
@@ -554,15 +554,15 @@
if ( target != NULL && xmlStrlen( target ) ) {
hv_store(retval, "Target", 6,
- _C2Sv(target, NULL), TargetHash);
+ _xpc_C2Sv(target, NULL), TargetHash);
if ( data != NULL && xmlStrlen( data ) ) {
hv_store(retval, "Data", 4,
- _C2Sv(data, NULL), DataHash);
+ _xpc_C2Sv(data, NULL), DataHash);
}
else {
hv_store(retval, "Data", 4,
- _C2Sv((const xmlChar *)"", NULL), DataHash);
+ _xpc_C2Sv((const xmlChar *)"", NULL), DataHash);
}
}
@@ -570,10 +570,10 @@
}
int
-PSaxStartDocument(void * ctx)
+xpc_PSaxStartDocument(void * ctx)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
- PmmSAXVectorPtr sax = (PmmSAXVectorPtr)ctxt->_private;
+ xpc_PmmSAXVectorPtr sax = (xpc_PmmSAXVectorPtr)ctxt->_private;
int count = 0;
dTHX;
HV* empty;
@@ -610,16 +610,16 @@
empty = newHV();
if ( ctxt->version != NULL ) {
hv_store(empty, "Version", 7,
- _C2Sv(ctxt->version, NULL), VersionHash);
+ _xpc_C2Sv(ctxt->version, NULL), VersionHash);
}
else {
hv_store(empty, "Version", 7,
- _C2Sv((const xmlChar *)"1.0", NULL), VersionHash);
+ _xpc_C2Sv((const xmlChar *)"1.0", NULL), VersionHash);
}
if ( ctxt->encoding != NULL ) {
hv_store(empty, "Encoding", 8,
- _C2Sv(ctxt->encoding, NULL), EncodingHash);
+ _xpc_C2Sv(ctxt->encoding, NULL), EncodingHash);
}
rv = newRV_noinc((SV*)empty);
@@ -643,10 +643,10 @@
}
int
-PSaxEndDocument(void * ctx)
+xpc_PSaxEndDocument(void * ctx)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
- PmmSAXVectorPtr sax = (PmmSAXVectorPtr)ctxt->_private;
+ xpc_PmmSAXVectorPtr sax = (xpc_PmmSAXVectorPtr)ctxt->_private;
int count = 0;
dTHX;
@@ -673,10 +673,10 @@
}
int
-PSaxStartElement(void *ctx, const xmlChar * name, const xmlChar** attr)
+xpc_PSaxStartElement(void *ctx, const xmlChar * name, const xmlChar** attr)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
- PmmSAXVectorPtr sax = (PmmSAXVectorPtr)ctxt->_private;
+ xpc_PmmSAXVectorPtr sax = (xpc_PmmSAXVectorPtr)ctxt->_private;
int count = 0;
dTHX;
HV * attrhash = NULL;
@@ -690,10 +690,10 @@
ENTER;
SAVETMPS;
- PmmExtendNsStack(sax, name);
+ xpc_PmmExtendNsStack(sax, name);
- attrhash = PmmGenAttributeHashSV(aTHX_ sax, attr, handler );
- element = PmmGenElementSV(aTHX_ sax, name);
+ attrhash = xpc_PmmGenAttributeHashSV(aTHX_ sax, attr, handler );
+ element = xpc_PmmGenElementSV(aTHX_ sax, name);
arv = newRV_noinc((SV*)attrhash);
hv_store( element,
@@ -726,9 +726,9 @@
}
int
-PSaxEndElement(void *ctx, const xmlChar * name) {
+xpc_PSaxEndElement(void *ctx, const xmlChar * name) {
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
- PmmSAXVectorPtr sax = (PmmSAXVectorPtr)ctxt->_private;
+ xpc_PmmSAXVectorPtr sax = (xpc_PmmSAXVectorPtr)ctxt->_private;
dTHX;
int count;
SV * handler = sax->handler;
@@ -743,7 +743,7 @@
PUSHMARK(SP) ;
XPUSHs(handler);
- element = PmmGenElementSV(aTHX_ sax, name);
+ element = xpc_PmmGenElementSV(aTHX_ sax, name);
rv = newRV_noinc((SV*)element);
XPUSHs(rv);
@@ -761,15 +761,15 @@
FREETMPS ;
LEAVE ;
- PmmNarrowNsStack(sax, handler);
+ xpc_PmmNarrowNsStack(sax, handler);
return 1;
}
int
-PSaxCharacters(void *ctx, const xmlChar * ch, int len) {
+xpc_PSaxCharacters(void *ctx, const xmlChar * ch, int len) {
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
- PmmSAXVectorPtr sax = (PmmSAXVectorPtr)ctxt->_private;
+ xpc_PmmSAXVectorPtr sax = (xpc_PmmSAXVectorPtr)ctxt->_private;
int count = 0;
dTHX;
HV* element;
@@ -794,7 +794,7 @@
PUSHMARK(SP) ;
XPUSHs(handler);
- element = PmmGenCharDataSV(aTHX_ sax,data);
+ element = xpc_PmmGenCharDataSV(aTHX_ sax,data);
rv = newRV_noinc((SV*)element);
XPUSHs(rv);
PUTBACK;
@@ -818,9 +818,9 @@
}
int
-PSaxComment(void *ctx, const xmlChar * ch) {
+xpc_PSaxComment(void *ctx, const xmlChar * ch) {
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
- PmmSAXVectorPtr sax = (PmmSAXVectorPtr)ctxt->_private;
+ xpc_PmmSAXVectorPtr sax = (xpc_PmmSAXVectorPtr)ctxt->_private;
int count = 0;
dTHX;
HV* element;
@@ -838,7 +838,7 @@
PUSHMARK(SP) ;
XPUSHs(handler);
- element = PmmGenCharDataSV(aTHX_ sax,data);
+ element = xpc_PmmGenCharDataSV(aTHX_ sax,data);
rv = newRV_noinc((SV*)element);
XPUSHs(rv);
PUTBACK;
@@ -862,9 +862,9 @@
}
int
-PSaxCDATABlock(void *ctx, const xmlChar * ch, int len) {
+xpc_PSaxCDATABlock(void *ctx, const xmlChar * ch, int len) {
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
- PmmSAXVectorPtr sax = (PmmSAXVectorPtr)ctxt->_private;
+ xpc_PmmSAXVectorPtr sax = (xpc_PmmSAXVectorPtr)ctxt->_private;
int count = 0;
dTHX;
@@ -895,7 +895,7 @@
PUSHMARK(SP) ;
XPUSHs(handler);
- element = PmmGenCharDataSV(aTHX_ sax,data);
+ element = xpc_PmmGenCharDataSV(aTHX_ sax,data);
rv = newRV_noinc((SV*)element);
XPUSHs(rv);
PUTBACK;
@@ -933,10 +933,10 @@
}
int
-PSaxProcessingInstruction( void * ctx, const xmlChar * target, const xmlChar * data )
+xpc_PSaxProcessingInstruction( void * ctx, const xmlChar * target, const xmlChar * data )
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
- PmmSAXVectorPtr sax = (PmmSAXVectorPtr)ctxt->_private;
+ xpc_PmmSAXVectorPtr sax = (xpc_PmmSAXVectorPtr)ctxt->_private;
int count = 0;
dTHX;
HV* empty = newHV();
@@ -953,7 +953,7 @@
PUSHMARK(SP) ;
XPUSHs(handler);
- element = (SV*)PmmGenPISV(aTHX_ sax, (const xmlChar *)target, data);
+ element = (SV*)xpc_PmmGenPISV(aTHX_ sax, (const xmlChar *)target, data);
rv = newRV_noinc((SV*)element);
XPUSHs(rv);
@@ -976,10 +976,10 @@
}
int
-PmmSaxWarning(void * ctx, const char * msg, ...)
+xpc_PmmSaxWarning(void * ctx, const char * msg, ...)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
- PmmSAXVectorPtr sax = (PmmSAXVectorPtr)ctxt->_private;
+ xpc_PmmSAXVectorPtr sax = (xpc_PmmSAXVectorPtr)ctxt->_private;
va_list args;
SV * svMessage;
@@ -1025,10 +1025,10 @@
int
-PmmSaxError(void * ctx, const char * msg, ...)
+xpc_PmmSaxError(void * ctx, const char * msg, ...)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
- PmmSAXVectorPtr sax = (PmmSAXVectorPtr)ctxt->_private;
+ xpc_PmmSAXVectorPtr sax = (xpc_PmmSAXVectorPtr)ctxt->_private;
va_list args;
SV * svMessage;
@@ -1067,10 +1067,10 @@
int
-PmmSaxFatalError(void * ctx, const char * msg, ...)
+xpc_PmmSaxFatalError(void * ctx, const char * msg, ...)
{
xmlParserCtxtPtr ctxt = (xmlParserCtxtPtr)ctx;
- PmmSAXVectorPtr sax = (PmmSAXVectorPtr)ctxt->_private;
+ xpc_PmmSAXVectorPtr sax = (xpc_PmmSAXVectorPtr)ctxt->_private;
va_list args;
SV * svMessage;
@@ -1111,33 +1111,33 @@
* XML::LibXML::SAX instead!
*/
xmlSAXHandlerPtr
-PSaxGetHandler()
+xpc_PSaxGetHandler()
{
xmlSAXHandlerPtr retval = (xmlSAXHandlerPtr)xmlMalloc(sizeof(xmlSAXHandler));
memset(retval, 0, sizeof(xmlSAXHandler));
- retval->startDocument = (startDocumentSAXFunc)&PSaxStartDocument;
+ retval->startDocument = (startDocumentSAXFunc)&xpc_PSaxStartDocument;
/* libxml2 will not handle perls returnvalue correctly, so we have
* to end the document ourselfes
*/
- retval->endDocument = NULL; /* (endDocumentSAXFunc)&PSaxEndDocument; */
+ retval->endDocument = NULL; /* (endDocumentSAXFunc)&xpc_PSaxEndDocument; */
- retval->startElement = (startElementSAXFunc)&PSaxStartElement;
- retval->endElement = (endElementSAXFunc)&PSaxEndElement;
+ retval->startElement = (startElementSAXFunc)&xpc_PSaxStartElement;
+ retval->endElement = (endElementSAXFunc)&xpc_PSaxEndElement;
- retval->characters = (charactersSAXFunc)&PSaxCharacters;
- retval->ignorableWhitespace = (ignorableWhitespaceSAXFunc)&PSaxCharacters;
+ retval->characters = (charactersSAXFunc)&xpc_PSaxCharacters;
+ retval->ignorableWhitespace = (ignorableWhitespaceSAXFunc)&xpc_PSaxCharacters;
- retval->comment = (commentSAXFunc)&PSaxComment;
- retval->cdataBlock = (cdataBlockSAXFunc)&PSaxCDATABlock;
+ retval->comment = (commentSAXFunc)&xpc_PSaxComment;
+ retval->cdataBlock = (cdataBlockSAXFunc)&xpc_PSaxCDATABlock;
- retval->processingInstruction = (processingInstructionSAXFunc)&PSaxProcessingInstruction;
+ retval->processingInstruction = (processingInstructionSAXFunc)&xpc_PSaxProcessingInstruction;
/* warning functions should be internal */
- retval->warning = (warningSAXFunc)&PmmSaxWarning;
- retval->error = (errorSAXFunc)&PmmSaxError;
- retval->fatalError = (fatalErrorSAXFunc)&PmmSaxFatalError;
+ retval->warning = (warningSAXFunc)&xpc_PmmSaxWarning;
+ retval->error = (errorSAXFunc)&xpc_PmmSaxError;
+ retval->fatalError = (fatalErrorSAXFunc)&xpc_PmmSaxFatalError;
return retval;
}
Index: perl-libxml-mm.h
===================================================================
RCS file: /cvsroot/perl-xml/XML-LibXML-XPathContext/perl-libxml-mm.h,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -d -r1.1.1.1 -r1.2
--- perl-libxml-mm.h 14 Mar 2003 14:32:03 -0000 1.1.1.1
+++ perl-libxml-mm.h 20 May 2003 15:25:50 -0000 1.2
@@ -45,7 +45,7 @@
#define xs_warn(string)
#endif
-struct _ProxyNode {
+struct _xpc_ProxyNode {
xmlNodePtr node;
xmlNodePtr owner;
int count;
@@ -53,38 +53,38 @@
};
/* helper type for the proxy structure */
-typedef struct _ProxyNode ProxyNode;
+typedef struct _xpc_ProxyNode xpc_ProxyNode;
/* pointer to the proxy structure */
-typedef ProxyNode* ProxyNodePtr;
+typedef xpc_ProxyNode* xpc_ProxyNodePtr;
/* this my go only into the header used by the xs */
-#define SvPROXYNODE(x) ((ProxyNodePtr)SvIV(SvRV(x)))
-#define PmmPROXYNODE(x) ((ProxyNodePtr)x->_private)
+#define SvPROXYNODE(x) ((xpc_ProxyNodePtr)SvIV(SvRV(x)))
+#define xpc_PmmPROXYNODE(x) ((xpc_ProxyNodePtr)x->_private)
-#define PmmREFCNT(node) node->count
-#define PmmREFCNT_inc(node) node->count++
-#define PmmNODE(xnode) xnode->node
-#define PmmOWNER(node) node->owner
-#define PmmOWNERPO(node) ((node && PmmOWNER(node)) ? (ProxyNodePtr)PmmOWNER(node)->_private : node)
-#define PmmENCODING(node) node->encoding
+#define xpc_PmmREFCNT(node) node->count
+#define xpc_PmmREFCNT_inc(node) node->count++
+#define xpc_PmmNODE(xnode) xnode->node
+#define xpc_PmmOWNER(node) node->owner
+#define xpc_PmmOWNERPO(node) ((node && xpc_PmmOWNER(node)) ? (xpc_ProxyNodePtr)xpc_PmmOWNER(node)->_private : node)
+#define xpc_PmmENCODING(node) node->encoding
-ProxyNodePtr
-PmmNewNode(xmlNodePtr node);
+xpc_ProxyNodePtr
+xpc_PmmNewNode(xmlNodePtr node);
-ProxyNodePtr
-PmmNewFragment(xmlDocPtr document);
+xpc_ProxyNodePtr
+xpc_PmmNewFragment(xmlDocPtr document);
SV*
-PmmCreateDocNode( unsigned int type, ProxyNodePtr pdoc, ...);
+xpc_PmmCreateDocNode( unsigned int type, xpc_ProxyNodePtr pdoc, ...);
int
-PmmREFCNT_dec( ProxyNodePtr node );
+xpc_PmmREFCNT_dec( xpc_ProxyNodePtr node );
SV*
-PmmNodeToSv( xmlNodePtr node, ProxyNodePtr owner );
+xpc_PmmNodeToSv( xmlNodePtr node, xpc_ProxyNodePtr owner );
-/* PmmSvNodeExt
+/* xpc_PmmSvNodeExt
* TYPE
* Function
* PARAMETER
@@ -101,9 +101,9 @@
* the default value should be allways '1'.
*/
xmlNodePtr
-PmmSvNodeExt( SV * perlnode, int copy );
+xpc_PmmSvNodeExt( SV * perlnode, int copy );
-/* PmmSvNode
+/* xpc_PmmSvNode
* TYPE
* Macro
* PARAMETER
@@ -111,36 +111,36 @@
*
* DESCRIPTION
*
- * PmmSvNode fetches the libxml node such as PmmSvNodeExt does. It is
+ * xpc_PmmSvNode fetches the libxml node such as xpc_PmmSvNodeExt does. It is
* a wrapper, that sets the copy always to 1, which is good for all
* cases XML::LibXML uses.
*/
-#define PmmSvNode(n) PmmSvNodeExt(n,1)
+#define xpc_PmmSvNode(n) xpc_PmmSvNodeExt(n,1)
xmlNodePtr
-PmmSvOwner( SV * perlnode );
+xpc_PmmSvOwner( SV * perlnode );
SV*
-PmmSetSvOwner(SV * perlnode, SV * owner );
+xpc_PmmSetSvOwner(SV * perlnode, SV * owner );
void
-PmmFixOwner(ProxyNodePtr node, ProxyNodePtr newOwner );
+xpc_PmmFixOwner(xpc_ProxyNodePtr node, xpc_ProxyNodePtr newOwner );
void
-PmmFixOwnerNode(xmlNodePtr node, ProxyNodePtr newOwner );
+xpc_PmmFixOwnerNode(xmlNodePtr node, xpc_ProxyNodePtr newOwner );
int
-PmmContextREFCNT_dec( ProxyNodePtr node );
+xpc_PmmContextREFCNT_dec( xpc_ProxyNodePtr node );
SV*
-PmmContextSv( xmlParserCtxtPtr ctxt );
+xpc_PmmContextSv( xmlParserCtxtPtr ctxt );
xmlParserCtxtPtr
-PmmSvContext( SV * perlctxt );
+xpc_PmmSvContext( SV * perlctxt );
/**
- * NAME PmmCopyNode
+ * NAME xpc_PmmCopyNode
* TYPE function
*
* returns libxml2 node
@@ -152,10 +152,10 @@
* XML::LibXSLT reuses it.
*/
xmlNodePtr
-PmmCloneNode( xmlNodePtr node , int deep );
+xpc_PmmCloneNode( xmlNodePtr node , int deep );
/**
- * NAME PmmNodeToGdomeSv
+ * NAME xpc_PmmNodeToGdomeSv
* TYPE function
*
* returns XML::GDOME node
@@ -169,25 +169,25 @@
*
*/
SV *
-PmmNodeToGdomeSv( xmlNodePtr node );
+xpc_PmmNodeToGdomeSv( xmlNodePtr node );
/**
- * NAME PmmNodeTypeName
+ * NAME xpc_PmmNodeTypeName
* TYPE function
*
* returns the perl class name for the given node
*
* SYNOPSIS
- * CLASS = PmmNodeTypeName( node );
+ * CLASS = xpc_PmmNodeTypeName( node );
*/
const char*
-PmmNodeTypeName( xmlNodePtr elem );
+xpc_PmmNodeTypeName( xmlNodePtr elem );
xmlChar*
-PmmEncodeString( const char *encoding, const char *string );
+xpc_PmmEncodeString( const char *encoding, const char *string );
char*
-PmmDecodeString( const char *encoding, const xmlChar *string);
+xpc_PmmDecodeString( const char *encoding, const xmlChar *string);
/* string manipulation will go elsewhere! */
@@ -205,7 +205,7 @@
*
*/
SV*
-C2Sv( const xmlChar *string, const xmlChar *encoding );
+xpc_C2Sv( const xmlChar *string, const xmlChar *encoding );
/*
* NAME sv_to_c_string
@@ -221,12 +221,12 @@
*
*/
xmlChar *
-Sv2C( SV* scalar, const xmlChar *encoding );
+xpc_Sv2C( SV* scalar, const xmlChar *encoding );
SV*
-nodeC2Sv( const xmlChar * string, xmlNodePtr refnode );
+nodexpc_C2Sv( const xmlChar * string, xmlNodePtr refnode );
xmlChar *
-nodeSv2C( SV * scalar, xmlNodePtr refnode );
+nodexpc_Sv2C( SV * scalar, xmlNodePtr refnode );
#endif
Index: perl-libxml-mm.c
===================================================================
RCS file: /cvsroot/perl-xml/XML-LibXML-XPathContext/perl-libxml-mm.c,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -d -r1.1.1.1 -r1.2
--- perl-libxml-mm.c 14 Mar 2003 14:32:01 -0000 1.1.1.1
+++ perl-libxml-mm.c 20 May 2003 15:25:50 -0000 1.2
@@ -48,7 +48,7 @@
* memory leak problems that way.
**/
const char*
-PmmNodeTypeName( xmlNodePtr elem ){
+xpc_PmmNodeTypeName( xmlNodePtr elem ){
const char *name = "XML::LibXML::Node";
if ( elem != NULL ) {
@@ -107,7 +107,7 @@
* track how intense the nodes of a document are used and will not
* delete the nodes unless they are not refered from somewhere else.
*/
-struct _ProxyNode {
+struct _xpc_ProxyNode {
xmlNodePtr node;
xmlNodePtr owner;
int count;
@@ -115,31 +115,31 @@
};
/* helper type for the proxy structure */
-typedef struct _ProxyNode ProxyNode;
+typedef struct _xpc_ProxyNode xpc_ProxyNode;
/* pointer to the proxy structure */
-typedef ProxyNode* ProxyNodePtr;
+typedef xpc_ProxyNode* xpc_ProxyNodePtr;
/* this my go only into the header used by the xs */
-#define SvPROXYNODE(x) ((ProxyNodePtr)SvIV(SvRV(x)))
+#define SvPROXYNODE(x) ((xpc_ProxyNodePtr)SvIV(SvRV(x)))
#define SvNAMESPACE(x) ((xmlNsPtr)SvIV(SvRV(x)))
-#define PmmREFCNT(node) node->count
-#define PmmREFCNT_inc(node) node->count++
-#define PmmNODE(thenode) thenode->node
-#define PmmOWNER(node) node->owner
-#define PmmOWNERPO(node) ((node && PmmOWNER(node)) ? (ProxyNodePtr)PmmOWNER(node)->_private : node)
+#define xpc_PmmREFCNT(node) node->count
+#define xpc_PmmREFCNT_inc(node) node->count++
+#define xpc_PmmNODE(thenode) thenode->node
+#define xpc_PmmOWNER(node) node->owner
+#define xpc_PmmOWNERPO(node) ((node && xpc_PmmOWNER(node)) ? (xpc_ProxyNodePtr)xpc_PmmOWNER(node)->_private : node)
-#define PmmENCODING(node) node->encoding
-#define PmmNodeEncoding(node) ((ProxyNodePtr)(node->_private))->encoding
+#define xpc_PmmENCODING(node) node->encoding
+#define xpc_PmmNodeEncoding(node) ((xpc_ProxyNodePtr)(node->_private))->encoding
/* creates a new proxy node from a given node. this function is aware
* about the fact that a node may already has a proxy structure.
*/
-ProxyNodePtr
-PmmNewNode(xmlNodePtr node)
+xpc_ProxyNodePtr
+xpc_PmmNewNode(xmlNodePtr node)
{
- ProxyNodePtr proxy = NULL;
+ xpc_ProxyNodePtr proxy = NULL;
if ( node == NULL ) {
warn( "no node found\n" );
@@ -147,8 +147,8 @@
}
if ( node->_private == NULL ) {
- proxy = (ProxyNodePtr)malloc(sizeof(struct _ProxyNode));
- /* proxy = (ProxyNodePtr)Newz(0, proxy, 0, ProxyNode); */
+ proxy = (xpc_ProxyNodePtr)malloc(sizeof(struct _xpc_ProxyNode));
+ /* proxy = (xpc_ProxyNodePtr)Newz(0, proxy, 0, xpc_ProxyNode); */
if (proxy != NULL) {
proxy->node = node;
proxy->owner = NULL;
@@ -157,25 +157,25 @@
}
}
else {
- proxy = (ProxyNodePtr)node->_private;
+ proxy = (xpc_ProxyNodePtr)node->_private;
}
return proxy;
}
-ProxyNodePtr
-PmmNewFragment(xmlDocPtr doc)
+xpc_ProxyNodePtr
+xpc_PmmNewFragment(xmlDocPtr doc)
{
- ProxyNodePtr retval = NULL;
+ xpc_ProxyNodePtr retval = NULL;
xmlNodePtr frag = NULL;
xs_warn("new frag\n");
frag = xmlNewDocFragment( doc );
- retval = PmmNewNode(frag);
+ retval = xpc_PmmNewNode(frag);
if ( doc ) {
xs_warn("inc document\n");
- PmmREFCNT_inc(((ProxyNodePtr)doc->_private));
+ xpc_PmmREFCNT_inc(((xpc_ProxyNodePtr)doc->_private));
retval->owner = (xmlNodePtr)doc;
}
@@ -186,7 +186,7 @@
* has several diffrent nodetypes.
*/
void
-PmmFreeNode( xmlNodePtr node )
+xpc_PmmFreeNode( xmlNodePtr node )
{
switch( node->type ) {
case XML_DOCUMENT_NODE:
@@ -223,22 +223,22 @@
/* decrements the proxy counter. if the counter becomes zero or less,
this method will free the proxy node. If the node is part of a
- subtree, PmmREFCNT_def will fix the reference counts and delete
+ subtree, xpc_PmmREFCNT_def will fix the reference counts and delete
the subtree if it is not required any more.
*/
int
-PmmREFCNT_dec( ProxyNodePtr node )
+xpc_PmmREFCNT_dec( xpc_ProxyNodePtr node )
{
xmlNodePtr libnode = NULL;
- ProxyNodePtr owner = NULL;
+ xpc_ProxyNodePtr owner = NULL;
int retval = 0;
if ( node ) {
- retval = PmmREFCNT(node)--;
- if ( PmmREFCNT(node) <= 0 ) {
+ retval = xpc_PmmREFCNT(node)--;
+ if ( xpc_PmmREFCNT(node) <= 0 ) {
xs_warn( "NODE DELETATION\n" );
- libnode = PmmNODE( node );
+ libnode = xpc_PmmNODE( node );
if ( libnode != NULL ) {
if ( libnode->_private != node ) {
xs_warn( "lost node\n" );
@@ -249,25 +249,25 @@
}
}
- PmmNODE( node ) = NULL;
- if ( PmmOWNER(node) && PmmOWNERPO(node) ) {
+ xpc_PmmNODE( node ) = NULL;
+ if ( xpc_PmmOWNER(node) && xpc_PmmOWNERPO(node) ) {
xs_warn( "DOC NODE!\n" );
- owner = PmmOWNERPO(node);
- PmmOWNER( node ) = NULL;
+ owner = xpc_PmmOWNERPO(node);
+ xpc_PmmOWNER( node ) = NULL;
if( libnode != NULL && libnode->parent == NULL ) {
/* this is required if the node does not directly
* belong to the document tree
*/
xs_warn( "REAL DELETE" );
- PmmFreeNode( libnode );
+ xpc_PmmFreeNode( libnode );
}
xs_warn( "decrease owner" );
- PmmREFCNT_dec( owner );
+ xpc_PmmREFCNT_dec( owner );
}
else if ( libnode != NULL ) {
xs_warn( "STANDALONE REAL DELETE" );
- PmmFreeNode( libnode );
+ xpc_PmmFreeNode( libnode );
}
/* Safefree( node ); */
free( node );
@@ -293,27 +293,27 @@
* nodes.
*/
SV*
-PmmNodeToSv( xmlNodePtr node, ProxyNodePtr owner )
+xpc_PmmNodeToSv( xmlNodePtr node, xpc_ProxyNodePtr owner )
{
- ProxyNodePtr dfProxy= NULL;
+ xpc_ProxyNodePtr dfProxy= NULL;
SV * retval = &PL_sv_undef;
const char * CLASS = "XML::LibXML::Node";
if ( node != NULL ) {
/* find out about the class */
- CLASS = PmmNodeTypeName( node );
+ CLASS = xpc_PmmNodeTypeName( node );
xs_warn(" return new perl node\n");
xs_warn( CLASS );
if ( node->_private ) {
- dfProxy = PmmNewNode(node);
+ dfProxy = xpc_PmmNewNode(node);
}
else {
- dfProxy = PmmNewNode(node);
+ dfProxy = xpc_PmmNewNode(node);
if ( dfProxy != NULL ) {
if ( owner != NULL ) {
- dfProxy->owner = PmmNODE( owner );
- PmmREFCNT_inc( owner );
+ dfProxy->owner = xpc_PmmNODE( owner );
+ xpc_PmmREFCNT_inc( owner );
}
else {
xs_warn("node contains himself");
@@ -326,7 +326,7 @@
retval = NEWSV(0,0);
sv_setref_pv( retval, CLASS, (void*)dfProxy );
- PmmREFCNT_inc(dfProxy);
+ xpc_PmmREFCNT_inc(dfProxy);
switch ( node->type ) {
case XML_DOCUMENT_NODE:
@@ -348,7 +348,7 @@
}
xmlNodePtr
-PmmCloneNode( xmlNodePtr node, int recursive )
+xpc_PmmCloneNode( xmlNodePtr node, int recursive )
{
xmlNodePtr retval = NULL;
@@ -390,28 +390,28 @@
*/
xmlNodePtr
-PmmSvNodeExt( SV* perlnode, int copy )
+xpc_PmmSvNodeExt( SV* perlnode, int copy )
{
xmlNodePtr retval = NULL;
- ProxyNodePtr proxy = NULL;
+ xpc_ProxyNodePtr proxy = NULL;
if ( perlnode != NULL && perlnode != &PL_sv_undef ) {
/* if ( sv_derived_from(perlnode, "XML::LibXML::Node") */
/* && SvPROXYNODE(perlnode) != NULL ) { */
-/* retval = PmmNODE( SvPROXYNODE(perlnode) ) ; */
+/* retval = xpc_PmmNODE( SvPROXYNODE(perlnode) ) ; */
/* } */
xs_warn(" perlnode found\n" );
if ( sv_derived_from(perlnode, "XML::LibXML::Node") ) {
proxy = SvPROXYNODE(perlnode);
if ( proxy != NULL ) {
xs_warn( "is a xmlNodePtr structure\n" );
- retval = PmmNODE( proxy ) ;
+ retval = xpc_PmmNODE( proxy ) ;
}
if ( retval != NULL
- && ((ProxyNodePtr)retval->_private) != proxy ) {
+ && ((xpc_ProxyNodePtr)retval->_private) != proxy ) {
xs_warn( "no node in proxy node" );
- PmmNODE( proxy ) = NULL;
+ xpc_PmmNODE( proxy ) = NULL;
retval = NULL;
}
}
@@ -427,7 +427,7 @@
xs_warn( "no XML::LibXML node found in GDOME object" );
}
else if ( copy == 1 ) {
- retval = PmmCloneNode( retval, 1 );
+ retval = xpc_PmmCloneNode( retval, 1 );
}
}
}
@@ -440,32 +440,32 @@
/* extracts the libxml2 owner node from a perl reference
*/
xmlNodePtr
-PmmSvOwner( SV* perlnode )
+xpc_PmmSvOwner( SV* perlnode )
{
xmlNodePtr retval = NULL;
if ( perlnode != NULL
&& perlnode != &PL_sv_undef
&& SvPROXYNODE(perlnode) != NULL ) {
- retval = PmmOWNER( SvPROXYNODE(perlnode) );
+ retval = xpc_PmmOWNER( SvPROXYNODE(perlnode) );
}
return retval;
}
-/* reverse to PmmSvOwner(). sets the owner of the current node. this
+/* reverse to xpc_PmmSvOwner(). sets the owner of the current node. this
* will increase the proxy count of the owner.
*/
SV*
-PmmSetSvOwner( SV* perlnode, SV* extra )
+xpc_PmmSetSvOwner( SV* perlnode, SV* extra )
{
if ( perlnode != NULL && perlnode != &PL_sv_undef ) {
- PmmOWNER( SvPROXYNODE(perlnode)) = PmmNODE( SvPROXYNODE(extra) );
- PmmREFCNT_inc( SvPROXYNODE(extra) );
+ xpc_PmmOWNER( SvPROXYNODE(perlnode)) = xpc_PmmNODE( SvPROXYNODE(extra) );
+ xpc_PmmREFCNT_inc( SvPROXYNODE(extra) );
}
return perlnode;
}
void
-PmmFixOwnerList( xmlNodePtr list, ProxyNodePtr parent )
+xpc_PmmFixOwnerList( xmlNodePtr list, xpc_ProxyNodePtr parent )
{
if ( list ) {
xmlNodePtr iterator = list;
@@ -483,14 +483,14 @@
}
if ( iterator->_private != NULL ) {
- PmmFixOwner( (ProxyNodePtr)iterator->_private, parent );
+ xpc_PmmFixOwner( (xpc_ProxyNodePtr)iterator->_private, parent );
}
else {
if ( iterator->type != XML_ATTRIBUTE_NODE
&& iterator->properties != NULL ){
- PmmFixOwnerList( (xmlNodePtr)iterator->properties, parent );
+ xpc_PmmFixOwnerList( (xmlNodePtr)iterator->properties, parent );
}
- PmmFixOwnerList(iterator->children, parent);
+ xpc_PmmFixOwnerList(iterator->children, parent);
}
iterator = iterator->next;
}
@@ -503,7 +503,7 @@
* where the documents or the owner node may get changed. this method is
* aware about nodes that already belong to a certain owner node.
*
- * the method uses the internal methods PmmFixNode and PmmChildNodes to
+ * the method uses the internal methods xpc_PmmFixNode and xpc_PmmChildNodes to
* do the real updates.
*
* in the worst case this traverses the subtree twice durig a node
@@ -512,12 +512,12 @@
* owner may differ this double traversing makes sense.
*/
int
-PmmFixOwner( ProxyNodePtr nodetofix, ProxyNodePtr parent )
+xpc_PmmFixOwner( xpc_ProxyNodePtr nodetofix, xpc_ProxyNodePtr parent )
{
- ProxyNodePtr oldParent = NULL;
+ xpc_ProxyNodePtr oldParent = NULL;
if ( nodetofix != NULL ) {
- switch ( PmmNODE(nodetofix)->type ) {
+ switch ( xpc_PmmNODE(nodetofix)->type ) {
case XML_ENTITY_DECL:
case XML_ATTRIBUTE_DECL:
case XML_NAMESPACE_DECL:
@@ -528,8 +528,8 @@
break;
}
- if ( PmmOWNER(nodetofix) ) {
- oldParent = PmmOWNERPO(nodetofix);
+ if ( xpc_PmmOWNER(nodetofix) ) {
+ oldParent = xpc_PmmOWNERPO(nodetofix);
}
/* The owner data is only fixed if the node is neither a
@@ -539,28 +539,28 @@
*/
if( oldParent != parent ) {
if ( parent && parent != nodetofix ){
- PmmOWNER(nodetofix) = PmmNODE(parent);
- PmmREFCNT_inc( parent );
+ xpc_PmmOWNER(nodetofix) = xpc_PmmNODE(parent);
+ xpc_PmmREFCNT_inc( parent );
}
else {
- PmmOWNER(nodetofix) = NULL;
+ xpc_PmmOWNER(nodetofix) = NULL;
}
if ( oldParent && oldParent != nodetofix )
- PmmREFCNT_dec(oldParent);
+ xpc_PmmREFCNT_dec(oldParent);
- if ( PmmNODE(nodetofix)->type != XML_ATTRIBUTE_NODE
- && PmmNODE(nodetofix)->properties != NULL ) {
- PmmFixOwnerList( (xmlNodePtr)PmmNODE(nodetofix)->properties,
+ if ( xpc_PmmNODE(nodetofix)->type != XML_ATTRIBUTE_NODE
+ && xpc_PmmNODE(nodetofix)->properties != NULL ) {
+ xpc_PmmFixOwnerList( (xmlNodePtr)xpc_PmmNODE(nodetofix)->properties,
parent );
}
- if ( parent == NULL || PmmNODE(nodetofix)->parent == NULL ) {
+ if ( parent == NULL || xpc_PmmNODE(nodetofix)->parent == NULL ) {
/* fix to self */
parent = nodetofix;
}
- PmmFixOwnerList(PmmNODE(nodetofix)->children, parent);
+ xpc_PmmFixOwnerList(xpc_PmmNODE(nodetofix)->children, parent);
}
else {
xs_warn( "node doesn't need to get fixed" );
@@ -571,24 +571,24 @@
}
void
-PmmFixOwnerNode( xmlNodePtr node, ProxyNodePtr parent )
+xpc_PmmFixOwnerNode( xmlNodePtr node, xpc_ProxyNodePtr parent )
{
if ( node != NULL && parent != NULL ) {
if ( node->_private != NULL ) {
- PmmFixOwner( node->_private, parent );
+ xpc_PmmFixOwner( node->_private, parent );
}
else {
- PmmFixOwnerList(node->children, parent );
+ xpc_PmmFixOwnerList(node->children, parent );
}
}
}
-ProxyNodePtr
-PmmNewContext(xmlParserCtxtPtr node)
+xpc_ProxyNodePtr
+xpc_PmmNewContext(xmlParserCtxtPtr node)
{
- ProxyNodePtr proxy = NULL;
+ xpc_ProxyNodePtr proxy = NULL;
- proxy = (ProxyNodePtr)xmlMalloc(sizeof(ProxyNode));
+ proxy = (xpc_ProxyNodePtr)xmlMalloc(sizeof(xpc_ProxyNode));
if (proxy != NULL) {
proxy->node = (xmlNodePtr)node;
proxy->owner = NULL;
@@ -601,26 +601,26 @@
}
int
-PmmContextREFCNT_dec( ProxyNodePtr node )
+xpc_PmmContextREFCNT_dec( xpc_ProxyNodePtr node )
{
xmlParserCtxtPtr libnode = NULL;
int retval = 0;
if ( node ) {
- retval = PmmREFCNT(node)--;
- if ( PmmREFCNT(node) <= 0 ) {
+ retval = xpc_PmmREFCNT(node)--;
+ if ( xpc_PmmREFCNT(node) <= 0 ) {
xs_warn( "NODE DELETATION\n" );
- libnode = (xmlParserCtxtPtr)PmmNODE( node );
+ libnode = (xmlParserCtxtPtr)xpc_PmmNODE( node );
if ( libnode != NULL ) {
if (libnode->_private != NULL ) {
if ( libnode->_private != (void*)node ) {
- PmmSAXCloseContext( libnode );
+ xpc_PmmSAXCloseContext( libnode );
}
else {
xmlFree( libnode->_private );
}
libnode->_private = NULL;
}
- PmmNODE( node ) = NULL;
+ xpc_PmmNODE( node ) = NULL;
xmlFreeParserCtxt(libnode);
}
}
@@ -630,19 +630,19 @@
}
SV*
-PmmContextSv( xmlParserCtxtPtr ctxt )
+xpc_PmmContextSv( xmlParserCtxtPtr ctxt )
{
- ProxyNodePtr dfProxy= NULL;
+ xpc_ProxyNodePtr dfProxy= NULL;
SV * retval = &PL_sv_undef;
const char * CLASS = "XML::LibXML::ParserContext";
void * saxvector = NULL;
if ( ctxt != NULL ) {
- dfProxy = PmmNewContext(ctxt);
+ dfProxy = xpc_PmmNewContext(ctxt);
retval = NEWSV(0,0);
sv_setref_pv( retval, CLASS, (void*)dfProxy );
- PmmREFCNT_inc(dfProxy);
+ xpc_PmmREFCNT_inc(dfProxy);
}
else {
xs_warn( "no node found!" );
@@ -652,7 +652,7 @@
}
xmlParserCtxtPtr
-PmmSvContext( SV * scalar )
+xpc_PmmSvContext( SV * scalar )
{
xmlParserCtxtPtr retval = NULL;
@@ -660,7 +660,7 @@
&& scalar != &PL_sv_undef
&& sv_isa( scalar, "XML::LibXML::ParserContext" )
&& SvPROXYNODE(scalar) != NULL ) {
- retval = (xmlParserCtxtPtr)PmmNODE( SvPROXYNODE(scalar) );
+ retval = (xmlParserCtxtPtr)xpc_PmmNODE( SvPROXYNODE(scalar) );
}
else {
if ( scalar == NULL
@@ -681,7 +681,7 @@
}
xmlChar*
-PmmFastEncodeString( int charset,
+xpc_PmmFastEncodeString( int charset,
const xmlChar *string,
const xmlChar *encoding )
{
@@ -727,7 +727,7 @@
}
xmlChar*
-PmmFastDecodeString( int charset,
+xpc_PmmFastDecodeString( int charset,
const xmlChar *string,
const xmlChar *encoding)
{
@@ -777,7 +777,7 @@
* while the encodig has the name of the encoding of string
**/
xmlChar*
-PmmEncodeString( const char *encoding, const xmlChar *string ){
+xpc_PmmEncodeString( const char *encoding, const xmlChar *string ){
xmlCharEncoding enc;
xmlChar *ret = NULL;
xmlCharEncodingHandlerPtr coder = NULL;
@@ -786,7 +786,7 @@
if( encoding != NULL ) {
xs_warn( encoding );
enc = xmlParseCharEncoding( encoding );
- ret = PmmFastEncodeString( enc, string, (const xmlChar *)encoding );
+ ret = xpc_PmmFastEncodeString( enc, string, (const xmlChar *)encoding );
}
else {
/* if utf-8 is requested we do nothing */
@@ -802,18 +802,18 @@
* encoding is the coding name
**/
char*
-PmmDecodeString( const char *encoding, const xmlChar *string){
+xpc_PmmDecodeString( const char *encoding, const xmlChar *string){
char *ret=NULL;
xmlCharEncoding enc;
xmlBufferPtr in = NULL, out = NULL;
xmlCharEncodingHandlerPtr coder = NULL;
if ( string != NULL ) {
- xs_warn( "PmmDecodeString called" );
+ xs_warn( "xpc_PmmDecodeString called" );
if( encoding != NULL ) {
enc = xmlParseCharEncoding( encoding );
- ret = (char*)PmmFastDecodeString( enc, string, (const xmlChar*)encoding );
- xs_warn( "PmmDecodeString done" );
+ ret = (char*)xpc_PmmFastDecodeString( enc, string, (const xmlChar*)encoding );
+ xs_warn( "xpc_PmmDecodeString done" );
}
else {
ret = (char*)xmlStrdup(string);
@@ -824,7 +824,7 @@
SV*
-C2Sv( const xmlChar *string, const xmlChar *encoding )
+xpc_C2Sv( const xmlChar *string, const xmlChar *encoding )
{
SV *retval = &PL_sv_undef;
xmlCharEncoding enc;
@@ -866,7 +866,7 @@
}
xmlChar *
-Sv2C( SV* scalar, const xmlChar *encoding )
+xpc_Sv2C( SV* scalar, const xmlChar *encoding )
{
xmlChar *retval = NULL;
@@ -884,8 +884,8 @@
#else
if ( encoding != NULL ) {
#endif
- xs_warn( "domEncodeString!" );
- ts= PmmEncodeString( (const char *)encoding, string );
+ xs_warn( "xpc_domEncodeString!" );
+ ts= xpc_PmmEncodeString( (const char *)encoding, string );
xs_warn( "done!" );
if ( string != NULL ) {
xmlFree(string);
@@ -904,7 +904,7 @@
}
SV*
-nodeC2Sv( const xmlChar * string, xmlNodePtr refnode )
+nodexpc_C2Sv( const xmlChar * string, xmlNodePtr refnode )
{
/* this is a little helper function to avoid to much redundand
code in LibXML.xs */
@@ -915,7 +915,7 @@
xmlDocPtr real_doc = refnode->doc;
if ( real_doc && real_doc->encoding != NULL ) {
- xmlChar * decoded = PmmFastDecodeString( PmmNodeEncoding(real_doc) ,
+ xmlChar * decoded = xpc_PmmFastDecodeString( xpc_PmmNodeEncoding(real_doc) ,
(const xmlChar *)string,
(const xmlChar*)real_doc->encoding);
len = xmlStrlen( decoded );
@@ -938,7 +938,7 @@
retval = newSVpvn( (const char *)decoded, len );
}
- /* retval = C2Sv( decoded, real_doc->encoding ); */
+ /* retval = xpc_C2Sv( decoded, real_doc->encoding ); */
xmlFree( decoded );
}
else {
@@ -953,7 +953,7 @@
}
xmlChar *
-nodeSv2C( SV * scalar, xmlNodePtr refnode )
+nodexpc_Sv2C( SV * scalar, xmlNodePtr refnode )
{
/* this function requires conditionized compiling, because we
request a function, that does not exists in earlier versions of
@@ -981,8 +981,8 @@
#else
if ( real_dom->encoding != NULL ) {
#endif
- xs_warn( "domEncodeString!" );
- ts= PmmFastEncodeString( PmmNodeEncoding(real_dom),
+ xs_warn( "xpc_domEncodeString!" );
+ ts= xpc_PmmFastEncodeString( xpc_PmmNodeEncoding(real_dom),
string,
(const xmlChar*)real_dom->encoding );
xs_warn( "done!" );
@@ -1010,11 +1010,11 @@
xs_warn("no encoding !!");
#endif
- return Sv2C( scalar, NULL );
+ return xpc_Sv2C( scalar, NULL );
}
SV *
-PmmNodeToGdomeSv( xmlNodePtr node )
+xpc_PmmNodeToGdomeSv( xmlNodePtr node )
{
SV * retval = &PL_sv_undef;
Index: dom.h
===================================================================
RCS file: /cvsroot/perl-xml/XML-LibXML-XPathContext/dom.h,v
retrieving revision 1.1.1.1
retrieving revision 1.2
diff -u -d -r1.1.1.1 -r1.2
--- dom.h 14 Mar 2003 14:32:04 -0000 1.1.1.1
+++ dom.h 20 May 2003 15:25:50 -0000 1.2
@@ -31,10 +31,10 @@
/**
- * NAME domParseChar
+ * NAME xpc_domParseChar
* TYPE function
* SYNOPSIS
- * int utf8char = domParseChar( curchar, &len );
+ * int utf8char = xpc_domParseChar( curchar, &len );
*
* The current char value, if using UTF-8 this may actually span
* multiple bytes in the given string. This function parses an utf8
@@ -50,7 +50,7 @@
* 2) not all perl versions XML::LibXML intends to run with have native
* UTF8 support.
*
- * domParseChar() allows to use the very same code with all versions
+ * xpc_domParseChar() allows to use the very same code with all versions
* of perl :)
*
* Returns the current char value and its length
@@ -60,19 +60,19 @@
* character is -1!
*/
int
-domParseChar( xmlChar *characters, int *len );
+xpc_domParseChar( xmlChar *characters, int *len );
xmlNodePtr
-domReadWellBalancedString( xmlDocPtr doc, xmlChar* string, int repair );
+xpc_domReadWellBalancedString( xmlDocPtr doc, xmlChar* string, int repair );
/**
- * NAME domIsParent
+ * NAME xpc_domIsParent
* TYPE function
*
* tests if a node is an ancestor of another node
*
* SYNOPSIS
- * if ( domIsParent(cur, ref) ) ...
+ * if ( xpc_domIsParent(cur, ref) ) ...
*
* this function is very useful to resolve if an operation would cause
* circular references.
@@ -80,46 +80,46 @@
* the function returns 1 if the ref node is a parent of the cur node.
*/
int
-domIsParent( xmlNodePtr cur, xmlNodePtr ref );
+xpc_domIsParent( xmlNodePtr cur, xmlNodePtr ref );
/**
- * NAME domTestHierarchy
+ * NAME xpc_domTestHierarchy
* TYPE function
*
* tests the general hierachy error
*
* SYNOPSIS
- * if ( domTestHierarchy(cur, ref) ) ...
+ * if ( xpc_domTestHierarchy(cur, ref) ) ...
*
* this function tests the general hierarchy error.
* it tests if the ref node would cause any hierarchical error for
- * cur node. the function evaluates domIsParent() internally.
+ * cur node. the function evaluates xpc_domIsParent() internally.
*
* the function will retrun 1 if there is no hierarchical error found.
* otherwise it returns 0.
*/
int
-domTestHierarchy( xmlNodePtr cur, xmlNodePtr ref );
+xpc_domTestHierarchy( xmlNodePtr cur, xmlNodePtr ref );
/**
-* NAME domTestDocument
+* NAME xpc_domTestDocument
* TYPE function
* SYNOPSIS
-* if ( domTestDocument(cur, ref) )...
+* if ( xpc_domTestDocument(cur, ref) )...
*
-* this function extends the domTestHierarchy() function. It tests if the
+* this function extends the xpc_domTestHierarchy() function. It tests if the
* cur node is a document and if so, it will check if the ref node can be
* inserted. (e.g. Attribute or Element nodes must not be appended to a
* document node)
*/
int
-domTestDocument( xmlNodePtr cur, xmlNodePtr ref );
+xpc_domTestDocument( xmlNodePtr cur, xmlNodePtr ref );
/**
-* NAME domAddNodeToList
+* NAME xpc_domAddNodeToList
* TYPE function
* SYNOPSIS
-* domAddNodeToList( cur, prevNode, nextNode )
+* xpc_domAddNodeToList( cur, prevNode, nextNode )
*
* This function inserts a node between the two nodes prevNode
* and nextNode. prevNode and nextNode MUST be adjacent nodes,
@@ -145,7 +145,7 @@
* the list. otherwise the function returns 0.
*/
int
-domAddNodeToList( xmlNodePtr cur, xmlNodePtr prev, xmlNodePtr next );
+xpc_domAddNodeToList( xmlNodePtr cur, xmlNodePtr prev, xmlNodePtr next );
/**
* part A:
@@ -156,43 +156,43 @@
/* A.1 DOM specified section */
xmlChar *
-domName( xmlNodePtr node );
+xpc_domName( xmlNodePtr node );
void
-domSetName( xmlNodePtr node, xmlChar* name );
+xpc_domSetName( xmlNodePtr node, xmlChar* name );
xmlNodePtr
-domAppendChild( xmlNodePtr self,
+xpc_domAppendChild( xmlNodePtr self,
xmlNodePtr newChild );
xmlNodePtr
-domReplaceChild( xmlNodePtr self,
+xpc_domReplaceChild( xmlNodePtr self,
xmlNodePtr newChlid,
xmlNodePtr oldChild );
xmlNodePtr
-domRemoveChild( xmlNodePtr self,
+xpc_domRemoveChild( xmlNodePtr self,
xmlNodePtr Child );
xmlNodePtr
-domInsertBefore( xmlNodePtr self,
+xpc_domInsertBefore( xmlNodePtr self,
xmlNodePtr newChild,
xmlNodePtr refChild );
xmlNodePtr
-domInsertAfter( xmlNodePtr self,
+xpc_domInsertAfter( xmlNodePtr self,
xmlNodePtr newChild,
xmlNodePtr refChild );
/* A.3 extra functionality not specified in DOM L1/2*/
xmlChar*
-domGetNodeValue( xmlNodePtr self );
+xpc_domGetNodeValue( xmlNodePtr self );
void
-domSetNodeValue( xmlNodePtr self, xmlChar* value );
+xpc_domSetNodeValue( xmlNodePtr self, xmlChar* value );
void
-domSetParentNode( xmlNodePtr self, xmlNodePtr newParent );
+xpc_domSetParentNode( xmlNodePtr self, xmlNodePtr newParent );
xmlNodePtr
-domReplaceNode( xmlNodePtr old, xmlNodePtr new );
+xpc_domReplaceNode( xmlNodePtr old, xmlNodePtr new );
/**
* part B:
@@ -201,10 +201,10 @@
**/
/**
- * NAME domImportNode
+ * NAME xpc_domImportNode
* TYPE function
* SYNOPSIS
- * node = domImportNode( document, node, move);#
+ * node = xpc_domImportNode( document, node, move);#
*
* the function will import a node to the given document. it will work safe
* with namespaces and subtrees.
@@ -217,7 +217,7 @@
* is returned
*/
xmlNodePtr
-domImportNode( xmlDocPtr document, xmlNodePtr node, int move );
+xpc_domImportNode( xmlDocPtr document, xmlNodePtr node, int move );
/**
* part C:
@@ -226,24 +226,24 @@
**/
xmlNodeSetPtr
-domGetElementsByTagName( xmlNodePtr self, xmlChar* name );
+xpc_domGetElementsByTagName( xmlNodePtr self, xmlChar* name );
xmlNodeSetPtr
-domGetElementsByTagNameNS( xmlNodePtr self, xmlChar* nsURI, xmlChar* name );
+xpc_domGetElementsByTagNameNS( xmlNodePtr self, xmlChar* nsURI, xmlChar* name );
xmlNsPtr
-domNewNs ( xmlNodePtr elem , xmlChar *prefix, xmlChar *href );
+xpc_domNewNs ( xmlNodePtr elem , xmlChar *prefix, xmlChar *href );
xmlAttrPtr
-domHasNsProp(xmlNodePtr node, const xmlChar *name, const xmlChar *namespace);
+xpc_domHasNsProp(xmlNodePtr node, const xmlChar *name, const xmlChar *namespace);
xmlAttrPtr
-domSetAttributeNode( xmlNodePtr node , xmlAttrPtr attr );
+xpc_domSetAttributeNode( xmlNodePtr node , xmlAttrPtr attr );
int
-domNodeNormalize( xmlNodePtr node );
+xpc_domNodeNormalize( xmlNodePtr node );
int
-domNodeNormalizeList( xmlNodePtr nodelist );
+xpc_do...
[truncated message content] |
