Starlink-AST
view release on metacpan or search on metacpan
struct AstXmlElement {
AstXmlObject obj;
char *name;
AstXmlAttribute **attrs;
int nattr;
AstXmlContentItem **items;
int nitem;
char *defns;
char *prefix;
AstXmlNamespace **nsprefs;
int nnspref;
int complete;
};
struct AstXmlBlack {
AstXmlObject obj;
char *text;
};
struct AstXmlWhite {
ast/src/xml.c view on Meta::CPAN
} else {
/* Create a new XmlNamespace. */
ns = NewNamespace( prefix, uri, status );
/* If OK, indicate that the namespace is owned by the element. */
if( astOK ) {
( (AstXmlObject *) ns )->parent = (AstXmlParent *) this;
/* Save the number of namespace definitions currently stored in the element. */
nnspref = ( this->nsprefs ) ? this->nnspref : 0;
/* Search the existing prefixes to see if a namespace with the given
prefix already exists. */
oldi = -1;
for( i = 0; i < nnspref; i++ ) {
oldns = this->nsprefs[ i ];
if( !strcmp( oldns->prefix, ns->prefix ) ) {
oldi = i;
break;
}
}
/* If there is an existing namespace with the same prefix, replace the old
namespace with the new one created above. */
if( oldi > -1 ){
((AstXmlObject *)oldns)->parent = NULL;
oldns = astXmlAnnul( oldns );
this->nsprefs[ oldi ] = ns;
/* Otherwise, attempt to extend the array to hold an extra namespace definition. */
} else {
this->nsprefs = astGrow( this->nsprefs, nnspref + 1,
sizeof( AstXmlNamespace * ) );
/* Check all has gone OK. */
if( astOK ) {
/* Store the Namespace pointer in the array of Namespace pointers. */
this->nsprefs[ nnspref ] = ns;
/* Increment the number of namespaces in this element */
this->nnspref = nnspref + 1;
}
}
}
}
}
void *astXmlAnnul_( AstXmlObject *this, int *status ){
ast/src/xml.c view on Meta::CPAN
((AstXmlObject *) newelem->attrs[ i ])->parent = (AstXmlParent *) newelem;
}
newelem->items = astMalloc( sizeof( AstXmlContentItem *) * (size_t)elem->nitem );
newelem->nitem = elem->nitem;
for( i = 0; i < elem->nitem; i++ ) {
newelem->items[ i ] = (AstXmlContentItem *) astXmlCopy( elem->items[ i ] );
((AstXmlObject *) newelem->items[ i ])->parent = (AstXmlParent *) newelem;
}
newelem->nsprefs = astMalloc( sizeof( AstXmlNamespace *) * (size_t)elem->nnspref );
newelem->nnspref = elem->nnspref;
for( i = 0; i < elem->nnspref; i++ ) {
newelem->nsprefs[ i ] = (AstXmlNamespace *) astXmlCopy( elem->nsprefs[ i ] );
((AstXmlObject *) newelem->nsprefs[ i ])->parent = (AstXmlParent *) newelem;
}
if( elem->defns ) {
newelem->defns = astStore( NULL, elem->defns,
strlen( elem->defns ) + 1 );
}
newelem->complete = elem->complete;
ast/src/xml.c view on Meta::CPAN
if( !astOK ) return;
/* Initialise */
oldns = NULL;
/* Create a new XmlNamespace with blank URI. */
ns = NewNamespace( prefix, "", status );
if( astOK ) {
/* Get the number of namespace prefixes currently stored in the element. */
nns = ( this->nsprefs ) ? this->nnspref : 0;
/* Search the list of existing namespace prefixes to see if the given prefix
is included. */
oldi = -1;
for( i = 0; i < nns; i++ ) {
oldns = this->nsprefs[ i ];
if( !strcmp( oldns->prefix, ns->prefix ) ){
oldi = i;
break;
}
}
/* If the supplied namespace prefix was found in the list, delete it. */
if( oldi > -1 ) astXmlDelete( oldns );
/* Delete the temporary namespace structure. */
ast/src/xml.c view on Meta::CPAN
elem->name = astFree( elem->name );
elem->defns = astFree( elem->defns );
elem->prefix = astFree( elem->prefix );
while( elem->nattr > 0 ) astXmlDelete( elem->attrs[ 0 ] );
elem->attrs = astFree( elem->attrs );
while( elem->nitem > 0 ) astXmlDelete( elem->items[ 0 ] );
elem->items = astFree( elem->items );
while( elem->nnspref > 0 ) astXmlDelete( elem->nsprefs[ 0 ] );
elem->nsprefs = astFree( elem->nsprefs );
CleanXml( this, AST__XMLOBJECT, status );
} else if( type == AST__XMLATTR ){
attr = (AstXmlAttribute *) this;
attr->name = astFree( attr->name );
attr->value = astFree( attr->value );
attr->prefix = astFree( attr->prefix );
CleanXml( this, AST__XMLOBJECT, status );
ast/src/xml.c view on Meta::CPAN
}
elem->attrs[ --elem->nattr ] = NULL;
ok = 1;
break;
}
}
} else if( astXmlCheckType( obj, AST__XMLNAME ) ) {
n = elem->nnspref;
for( i = 0; i < n; i++ ) {
if( elem->nsprefs[ i ] == (AstXmlNamespace *) obj ) {
for( j = i + 1; j < n; j++ ) {
elem->nsprefs[ j - 1 ] = elem->nsprefs[ j ];
}
elem->nsprefs[ --elem->nnspref ] = NULL;
ok = 1;
break;
}
}
} else if( astXmlCheckType( obj, AST__XMLCONT ) ) {
n = elem->nitem;
for( i = 0; i < n; i++ ) {
if( elem->items[ i ] == (AstXmlContentItem *) obj ) {
for( j = i + 1; j < n; j++ ) {
ast/src/xml.c view on Meta::CPAN
}
result = astAppendString( result, &nc, elem->name );
if( elem->defns ) {
result = astAppendString( result, &nc, " xmlns=\"" );
result = astAppendString( result, &nc, elem->defns );
result = astAppendString( result, &nc, "\"" );
}
for( i = 0; i < elem->nnspref; i++ ) {
temp = Format( (AstXmlObject *) elem->nsprefs[ i ], -1, status );
if( temp ) {
result = AppendChar( result, &nc, ' ', status );
result = astAppendString( result, &nc, temp );
temp = astFree( (void *) temp );
}
}
for( i = 0; i < elem->nattr; i++ ) {
temp = Format( (AstXmlObject *) elem->attrs[ i ], -1, status );
if( temp ){
ast/src/xml.c view on Meta::CPAN
/* Initialise the parent XmlObject component. */
InitXmlObject( (AstXmlObject *) new, type, status );
/* Initialise the items specific to this class of structure. */
new->name = astStore( NULL, newname, strlen( newname ) + 1 );
new->attrs = NULL;
new->nattr = 0;
new->items = NULL;
new->nitem = 0;
new->defns = NULL;
new->nsprefs = NULL;
new->nnspref = 0;
new->complete = 0;
new->prefix = NULL;
if( newpref ) {
nc = strlen( newpref );
if( nc > 0 ) new->prefix = astStore( NULL, newpref, nc + 1 );
}
/* Free any name and prefix extracted from the supplied name string */
ast/src/xml.c view on Meta::CPAN
int i; /* Loop count */
/* Initialise */
result = NULL;
/* Check the global error status, and the supplied element. */
if( !astOK || !elem ) return result;
/* Loop round all the namespace definitions in the element. */
for( i = 0; i < elem->nnspref; i++ ) {
ns = elem->nsprefs[ i ];
/* Compare the namespace prefix with the supplied prefix (case sensitive).
Store a pointer to the associated URI if they match, and leave the
loop. */
if( !strcmp( ns->prefix, prefix ) ) {
result = ns->uri;
break;
}
}
ast/src/xml.h view on Meta::CPAN
/* Describes an XML element */
struct AstXmlElement {
AstXmlObject obj; /* General information for this XmlObject */
char *name; /* The type (name) of the element */
AstXmlAttribute **attrs; /* Ptr. to list of attributes of the element */
int nattr; /* Number of attributes in the above list */
AstXmlContentItem **items; /* Ptr. to list of items in the element's content */
int nitem; /* Number of items in above list */
char *defns; /* Default Namespace URI for element content */
char *prefix; /* Namespace prefix for this element */
AstXmlNamespace **nsprefs; /* Ptr. to list of new Namespaces defined by this element */
int nnspref; /* Number of Namespaces in above list */
int complete; /* Have the contents of the element been read? */
};
/* XmlBlack structure. */
/* ---------------------- */
/* Describes character data containing at least one non-blank character. */
struct AstXmlBlack {
AstXmlObject obj; /* General information for this XmlObject */
char *text; /* The character data */
( run in 2.310 seconds using v1.01-cache-2.11-cpan-8f98c5d2c55 )