char *
xml_findend( char *buffer, char *tag )
{
newstr endtag;
char *p;
newstr_init( &endtag );
newstr_strcpy( &endtag, "</" );
if ( xml_pns ) {
newstr_strcat( &endtag, xml_pns );
newstr_addchar( &endtag, ':' );
}
newstr_strcat( &endtag, tag );
newstr_addchar( &endtag, '>' );
p = strsearch( buffer, endtag.data );
if ( p && *p ) {
if ( *p ) p++; /* skip <random_tag></end> combo */
while ( *p && *(p-1)!='>' ) p++;
}
newstr_free( &endtag );
return p;
}
static void
output_pages( FILE *fp, fields *info, unsigned long refnum, int format_opts )
{
newstr pages;
int sn, en;
sn = fields_find( info, "PAGESTART", -1 );
en = fields_find( info, "PAGEEND", -1 );
if ( sn==-1 && en==-1 ) {
output_articlenumber( fp, info, refnum, format_opts );
return;
}
newstr_init( &pages );
if ( sn!=-1 ) {
newstr_strcat( &pages, info->data[sn].data );
fields_setused( info, sn );
}
if ( sn!=-1 && en!=-1 ) {
if ( format_opts & BIBOUT_SINGLEDASH )
newstr_strcat( &pages, "-" );
else
newstr_strcat( &pages, "--" );
}
if ( en!=-1 ) {
newstr_strcat( &pages, info->data[en].data );
fields_setused( info, en );
}
output_element( fp, "pages", pages.data, format_opts );
newstr_free( &pages );
}
int
medin_readf( FILE *fp, char *buf, int bufsize, int *bufpos, newstr *line, newstr *reference, int *fcharset )
{
newstr tmp;
char *startptr = NULL, *endptr;
int haveref = 0, inref = 0, file_charset = CHARSET_UNKNOWN, m, type = -1;
newstr_init( &tmp );
while ( !haveref && newstr_fget( fp, buf, bufsize, bufpos, line ) ) {
if ( line->data ) {
m = xml_getencoding( line );
if ( m!=CHARSET_UNKNOWN ) file_charset = m;
}
if ( line->data ) {
startptr = medin_findstartwrapper( line->data, &type );
}
if ( startptr || inref ) {
if ( inref ) newstr_strcat( &tmp, line->data );
else {
newstr_strcat( &tmp, startptr );
inref = 1;
}
endptr = medin_findendwrapper( tmp.data, type );
if ( endptr ) {
newstr_segcpy( reference, tmp.data, endptr );
haveref = 1;
}
}
}
newstr_free( &tmp );
*fcharset = file_charset;
return haveref;
}
int
copacin_readf( FILE *fp, char *buf, int bufsize, int *bufpos, newstr *line, newstr *reference, int *fcharset )
{
int haveref = 0, inref=0;
char *p;
while ( !haveref && readmore( fp, buf, bufsize, bufpos, line ) ) {
/* blank line separates */
if ( line->data==NULL ) continue;
if ( inref && line->len==0 ) haveref=1;
p = &(line->data[0]);
if ( copacin_istag( p ) ) {
if ( inref ) newstr_addchar( reference, '\n' );
newstr_strcat( reference, p );
newstr_empty( line );
inref = 1;
} else if ( inref ) {
if ( p ) {
/* copac puts tag only on 1st line */
newstr_addchar( reference, ' ' );
if ( *p ) p++;
if ( *p ) p++;
if ( *p ) p++;
newstr_strcat( reference, p );
}
newstr_empty( line );
} else {
newstr_empty( line );
}
}
*fcharset = CHARSET_UNKNOWN;
return haveref;
}
static void
output_title( FILE *fp, fields *info, unsigned long refnum, char *bibtag, int level, int format_opts )
{
newstr title;
int n1 = -1, n2 = -1;
/* Option is for short titles of journals */
if ( ( format_opts & BIBOUT_SHORTTITLE ) && level==1 ) {
n1 = fields_find( info, "SHORTTITLE", level );
n2 = fields_find( info, "SHORTSUBTITLE", level );
}
if ( n1==-1 ) {
n1 = fields_find( info, "TITLE", level );
n2 = fields_find( info, "SUBTITLE", level );
}
if ( n1!=-1 ) {
newstr_init( &title );
newstr_newstrcpy( &title, &(info->data[n1]) );
fields_setused( info, n1 );
if ( n2!=-1 ) {
if ( info->data[n1].data[info->data[n1].len]!='?' )
newstr_strcat( &title, ": " );
else newstr_addchar( &title, ' ' );
newstr_strcat( &title, info->data[n2].data );
fields_setused( info, n2 );
}
output_element( fp, bibtag, title.data, format_opts );
newstr_free( &title );
}
}
static int
risin_readf( FILE *fp, char *buf, int bufsize, int *bufpos, newstr *line,
newstr *reference, int *fcharset )
{
int haveref = 0, inref = 0, readtoofar = 0;
unsigned char *up;
char *p;
*fcharset = CHARSET_UNKNOWN;
while ( !haveref && readmore( fp, buf, bufsize, bufpos, line ) ) {
if ( !line->data || line->len==0 ) continue;
p = &( line->data[0] );
/* Recognize UTF8 BOM */
up = (unsigned char * ) p;
if ( line->len > 2 &&
up[0]==0xEF && up[1]==0xBB && up[2]==0xBF ) {
*fcharset = CHARSET_UNICODE;
p += 3;
}
/* Each reference starts with 'TY - ' &&
* ends with 'ER - ' */
if ( strncmp(p,"TY - ",6)==0 ) {
if ( !inref ) {
inref = 1;
} else {
/* we've read too far.... */
readtoofar = 1;
inref = 0;
}
}
if ( risin_istag( p ) ) {
if ( !inref ) {
fprintf(stderr,"Warning. Tagged line not "
"in properly started reference.\n");
fprintf(stderr,"Ignored: '%s'\n", p );
} else if ( !strncmp(p,"ER -",5) ) {
inref = 0;
} else {
newstr_addchar( reference, '\n' );
newstr_strcat( reference, p );
}
}
/* not a tag, but we'll append to last values ...*/
else if ( inref && strncmp(p,"ER -",5)) {
newstr_addchar( reference, '\n' );
newstr_strcat( reference, p );
}
if ( !inref && reference->len ) haveref = 1;
if ( !readtoofar ) newstr_empty( line );
}
if ( inref ) haveref = 1;
return haveref;
}
static int
build_refnum( fields *info, long nrefs )
{
newstr refnum;
char *p, num[512];
int y, a;
newstr_init( &refnum );
y = fields_find( info, "YEAR", -1 );
if ( y==-1 ) y = fields_find( info, "PARTYEAR", -1 );
a = fields_find( info, "AUTHOR", -1 );
if ( a==-1 ) a = fields_find( info, "AUTHOR:CORP", -1 );
if ( a!=-1 && y!=-1 ) {
p = info->data[a].data;
while ( p && *p && *p!='|' )
newstr_addchar( &refnum, *p++ );
p = info->data[y].data;
while ( p && *p && *p!=' ' && *p!='\t' )
newstr_addchar( &refnum, *p++ );
} else {
sprintf( num, "%ld", nrefs );
newstr_strcpy( &refnum, "ref" );
newstr_strcat( &refnum, num );
}
fields_add( info, "REFNUM", refnum.data, 0 );
newstr_free( &refnum );
return fields_find( info, "REFNUM", 0 );
}
static void
bibtex_cleandata( newstr *s, fields *info, param *p )
{
list tokens;
int i;
if ( !s->len ) return;
list_init( &tokens );
bibtex_split( &tokens, s );
for ( i=0; i<tokens.n; ++i ) {
if ( !bibtex_protected( &(tokens.str[i] ) ) ) {
bibtex_usestrings( &(tokens.str[i]) );
} else {
if (!strncasecmp(tokens.str[i].data,"\\href{", 6)) {
bibtex_addtitleurl( info, &(tokens.str[i]) );
}
bibtex_cleantoken( &(tokens.str[i]), p );
}
}
newstr_empty( s );
for ( i=0; i<tokens.n; ++i ) {
if ( bibtex_protected( &(tokens.str[i]) ) )
bibtex_removeprotection( &(tokens.str[i]));
newstr_strcat( s, tokens.str[i].data );
}
list_free( &tokens );
}
int
endin_processf( fields *endin, char *p, char *filename, long nref )
{
newstr tag, data;
int n;
newstr_init( &tag );
newstr_init( &data );
while ( *p ) {
if ( endin_istag( p ) ) {
p = process_endline( &tag, &data, p );
/* no empty fields allowed */
if ( data.len ) {
fields_add( endin, tag.data, data.data, 0 );
}
} else {
p = process_endline2( &tag, &data, p );
/* endnote puts %K only on 1st line of keywords */
n = endin->nfields;
if ( n>0 && data.len ) {
if ( !strncmp( endin->tag[n-1].data, "%K", 2 ) ) {
fields_add( endin, "%K", data.data, 0 );
} else {
newstr_addchar( &(endin->data[n-1]), ' ' );
newstr_strcat( &(endin->data[n-1]), data.data );
}
}
}
newstr_empty( &tag );
newstr_empty( &data );
}
newstr_free( &tag );
newstr_free( &data );
return 1;
}
/* get reference name */
static char*
process_bibtexid( char *p, newstr *data )
{
newstr tmp;
char *start_p = p;
newstr_init( &tmp );
newstr_empty( data );
while ( *p && *p!=',' ) newstr_addchar( &tmp, *p++ );
if ( *p==',' ) p++;
p = skip_ws( p ); /* skip ending newline/carriage return */
if ( tmp.len ) {
if ( strchr( tmp.data, '=' ) ) {
/* Endnote writes bibtex files w/o fields, try to
* distinguish via presence of an equal sign.... if
* it's there, assume that it's a tag/data pair instead
* and roll back.
*/
p = start_p;
} else {
/* add '{' and '}' to protect from string expansion */
newstr_addchar( data, '{' );
newstr_strcat( data, tmp.data );
newstr_addchar( data, '}' );
}
}
newstr_free( &tmp );
return p;
}
static int
bibtex_matches_list( fields *info, char *tag, char *suffix, newstr *data, int level,
list *names, int *match )
{
int i, fstatus, status = BIBL_OK;
newstr newtag;
*match = 0;
if ( names->n==0 ) return status;
newstr_init( &newtag );
for ( i=0; i<names->n; ++i ) {
if ( strcmp( data->data, list_getc( names, i ) ) ) continue;
newstr_initstr( &newtag, tag );
newstr_strcat( &newtag, suffix );
fstatus = fields_add( info, newtag.data, data->data, level );
if ( fstatus!=FIELDS_OK ) {
status = BIBL_ERR_MEMERR;
goto out;
}
*match = 1;
goto out;
}
out:
newstr_free( &newtag );
return status;
}
int
isiin_processf( fields *isiin, char *p, char *filename, long nref )
{
newstr tag, data;
int n;
newstr_init( &tag );
newstr_init( &data );
while ( *p ) {
newstr_empty( &tag );
newstr_empty( &data );
p = process_isiline( &tag, &data, p );
if ( !data.len ) continue;
if ( (tag.len>1) && isiin_istag( tag.data ) ) {
fields_add( isiin, tag.data, data.data, 0 );
} else {
n = isiin->nfields;
if ( n>0 ) {
/* only one AU or AF for list of authors */
if ( !strcmp( isiin->tag[n-1].data,"AU") ){
fields_add( isiin, "AU", data.data, 0);
} else if ( !strcmp( isiin->tag[n-1].data,"AF") ){
fields_add( isiin, "AF", data.data, 0);
}
/* otherwise append multiline data */
else {
newstr_addchar( &(isiin->data[n-1]),' ');
newstr_strcat( &(isiin->data[n-1]), data.data );
}
}
}
}
newstr_free( &data );
newstr_free( &tag );
return 1;
}
static int
risin_processf( fields *risin, char *p, char *filename, long nref, param *pm )
{
newstr tag, data;
int status, n;
newstrs_init( &tag, &data, NULL );
while ( *p ) {
if ( risin_istag( p ) )
p = process_line( &tag, &data, p );
/* no anonymous fields allowed */
if ( tag.len ) {
status = fields_add( risin, tag.data, data.data, 0 );
if ( status!=FIELDS_OK ) return 0;
} else {
p = process_line2( &tag, &data, p );
n = fields_num( risin );
if ( data.len && n>0 ) {
newstr *od;
od = fields_value( risin, n-1, FIELDS_STRP );
newstr_addchar( od, ' ' );
newstr_strcat( od, data.data );
}
}
newstrs_empty( &tag, &data, NULL );
}
newstrs_free( &tag, &data, NULL );
return 1;
}
/* <AuthorList CompleteYN="Y">
* <Author>
* <LastName>Barondeau</LastName>
* <ForeName>David P</ForeName>
* ( or <FirstName>David P</FirstName> )
* <Initials>DP</Initials>
* </Author>
* <Author>
* <CollectiveName>Organization</CollectiveName>
* </Author>
* </AuthorList>
*/
static int
medin_author( xml *node, newstr *name )
{
char *p;
if ( xml_tagexact( node, "LastName" ) ) {
if ( name->len ) {
newstr_prepend( name, "|" );
newstr_prepend( name, xml_data( node ) );
}
else newstr_strcat( name, xml_data( node ) );
} else if ( xml_tagexact( node, "ForeName" ) ||
xml_tagexact( node, "FirstName" ) ) {
p = xml_data( node );
while ( p && *p ) {
if ( name->len ) newstr_addchar( name, '|' );
while ( *p && *p==' ' ) p++;
while ( *p && *p!=' ' ) newstr_addchar( name, *p++ );
}
} else if ( xml_tagexact( node, "Initials" ) && !strchr( name->data, '|' )) {
p = xml_data( node );
while ( p && *p ) {
if ( name->len ) newstr_addchar( name, '|' );
if ( !is_ws(*p) ) newstr_addchar( name, *p++ );
}
}
if ( node->next ) medin_author( node->next, name );
return BIBL_OK;
}
int
risin_processf( fields *risin, char *p, char *filename, long nref )
{
newstr tag, data;
newstr_init( &tag );
newstr_init( &data );
while ( *p ) {
if ( risin_istag( p ) ) {
p = process_line( &tag, &data, p );
/* no anonymous fields allowed */
/* if ( tag.len && data.len )*/
if ( tag.len )
fields_add( risin, tag.data, data.data, 0 );
} else {
p = process_line2( &tag, &data, p );
if ( data.len && risin->nfields>0 ) {
newstr *od;
od = &(risin->data[risin->nfields-1] );
newstr_addchar( od, ' ' );
newstr_strcat( od, data.data );
}
}
newstr_empty( &tag );
newstr_empty( &data );
}
newstr_free( &tag );
newstr_free( &data );
return 1;
}
/*
* readf()
*
* returns zero if cannot get reference and hit end of-file
* returns 1 if last reference in file, 2 if reference within file
*/
int
bibtexin_readf( FILE *fp, char *buf, int bufsize, int *bufpos, newstr *line, newstr *reference, int *fcharset )
{
int haveref = 0;
char *p;
*fcharset = CHARSET_UNKNOWN;
while ( haveref!=2 && readmore( fp, buf, bufsize, bufpos, line ) ) {
if ( line->len == 0 ) continue; /* blank line */
p = &(line->data[0]);
/* Recognize UTF8 BOM */
if ( line->len > 2 &&
(unsigned char)(p[0])==0xEF &&
(unsigned char)(p[1])==0xBB &&
(unsigned char)(p[2])==0xBF ) {
*fcharset = CHARSET_UNICODE;
p += 3;
}
p = skip_ws( p );
if ( *p == '%' ) { /* commented out line */
newstr_empty( line );
continue;
}
if ( *p == '@' ) haveref++;
if ( haveref && haveref<2 ) {
newstr_strcat( reference, p );
newstr_addchar( reference, '\n' );
newstr_empty( line );
} else if ( !haveref ) newstr_empty( line );
}
return haveref;
}
void
newstr_segdel( newstr *s, char *p, char *q )
{
newstr tmp1, tmp2;
char *r;
assert( s );
r = &(s->data[s->len]);
newstr_init( &tmp1 );
newstr_init( &tmp2 );
newstr_segcpy( &tmp1, s->data, p );
newstr_segcpy( &tmp2, q, r );
newstr_empty( s );
if ( tmp1.data ) newstr_strcat( s, tmp1.data );
if ( tmp2.data ) newstr_strcat( s, tmp2.data );
newstr_free( &tmp2 );
newstr_free( &tmp1 );
}
int
isiin_readf( FILE *fp, char *buf, int bufsize, int *bufpos, newstr *line, newstr *reference, int *fcharset )
{
int haveref = 0, inref = 0;
char *p;
while ( !haveref && readmore( fp, buf, bufsize, bufpos, line ) ) {
if ( !line->data ) continue;
p = &(line->data[0]);
/* Each reference ends with 'ER ' */
if ( isiin_istag( p ) ) {
if ( !strncmp( p, "FN ", 3 ) ) {
if (strncasecmp( p, "FN ISI Export Format",20)){
fprintf( stderr, ": warning file FN type not '%s' not recognized.\n", /*r->progname,*/ p );
}
} else if ( !strncmp( p, "VR ", 3 ) ) {
if ( strncasecmp( p, "VR 1.0", 6 ) ) {
fprintf(stderr,": warning file version number '%s' not recognized, expected 'VR 1.0'\n", /*r->progname,*/ p );
}
} else if ( !strncmp( p, "ER", 2 ) ) haveref = 1;
else {
newstr_addchar( reference, '\n' );
newstr_strcat( reference, p );
inref = 1;
}
newstr_empty( line );
}
/* not a tag, but we'll append to the last values */
else if ( inref ) {
newstr_addchar( reference, '\n' );
newstr_strcat( reference, p );
newstr_empty( line );
}
else {
newstr_empty( line );
/*
fprintf( stderr, "%s warning: '%s' outside of tag\n",
r->progname, p );
*/
}
}
*fcharset = CHARSET_UNKNOWN;
return haveref;
}
static void
output_fileattach( FILE *fp, fields *info, int format_opts )
{
newstr data;
int i;
newstr_init( &data );
for ( i=0; i<info->nfields; ++i ) {
if ( strcasecmp( info->tag[i].data, "FILEATTACH" ) ) continue;
newstr_strcpy( &data, ":" );
newstr_newstrcat( &data, &(info->data[i]) );
if ( strsearch( info->data[i].data, ".pdf" ) )
newstr_strcat( &data, ":PDF" );
else if ( strsearch( info->data[i].data, ".html" ) )
newstr_strcat( &data, ":HTML" );
else newstr_strcat( &data, ":TYPE" );
output_element( fp, "file", data.data, format_opts );
fields_setused( info, i );
newstr_empty( &data );
}
newstr_free( &data );
}
int
copacin_readf( FILE *fp, char *buf, int bufsize, int *bufpos, newstr *line, newstr *reference, int *fcharset )
{
int haveref = 0, inref=0;
char *p;
*fcharset = CHARSET_UNKNOWN;
while ( !haveref && readmore( fp, buf, bufsize, bufpos, line ) ) {
/* blank line separates */
if ( line->data==NULL ) continue;
if ( inref && line->len==0 ) haveref=1;
p = &(line->data[0]);
/* Recognize UTF8 BOM */
if ( line->len > 2 &&
(unsigned char)(p[0])==0xEF &&
(unsigned char)(p[1])==0xBB &&
(unsigned char)(p[2])==0xBF ) {
*fcharset = CHARSET_UNICODE;
p += 3;
}
if ( copacin_istag( p ) ) {
if ( inref ) newstr_addchar( reference, '\n' );
newstr_strcat( reference, p );
newstr_empty( line );
inref = 1;
} else if ( inref ) {
if ( p ) {
/* copac puts tag only on 1st line */
newstr_addchar( reference, ' ' );
if ( *p ) p++;
if ( *p ) p++;
if ( *p ) p++;
newstr_strcat( reference, p );
}
newstr_empty( line );
} else {
newstr_empty( line );
}
}
return haveref;
}
static void
output_people( FILE *fp, fields *info, unsigned long refnum, char *tag,
char *ctag, char *atag, char *bibtag, int level,
int format_opts )
{
newstr allpeople;
int i, npeople, person, corp, asis;
/* primary citation authors */
npeople = 0;
for ( i=0; i<info->nfields; ++i ) {
if ( level!=-1 && info->level[i]!=level ) continue;
person = ( strcasecmp( info->tag[i].data, tag ) == 0 );
corp = ( strcasecmp( info->tag[i].data, ctag ) == 0 );
asis = ( strcasecmp( info->tag[i].data, atag ) == 0 );
if ( person || corp || asis ) {
if ( npeople==0 ) newstr_init( &allpeople );
else {
if ( format_opts & BIBOUT_WHITESPACE )
newstr_strcat(&allpeople,"\n\t\tand ");
else newstr_strcat( &allpeople, "\nand " );
}
if ( corp ) {
newstr_addchar( &allpeople, '{' );
newstr_strcat( &allpeople, info->data[i].data );
newstr_addchar( &allpeople, '}' );
} else if ( asis ) {
newstr_addchar( &allpeople, '{' );
newstr_strcat( &allpeople, info->data[i].data );
newstr_addchar( &allpeople, '}' );
} else add_person( &allpeople, info->data[i].data );
fields_setused( info, i );
npeople++;
}
}
if ( npeople ) {
output_element( fp, bibtag, allpeople.data, format_opts );
newstr_free( &allpeople );
}
}
/*
* return 1 on a nomangle with a newtag value
* return 0 on a name to mangle
*/
static int
name_nomangle( char *tag, char *data, newstr *newtag, list *asis, list *corps )
{
int corp_tag_flag, corp_list_flag;
int asis_tag_flag, asis_list_flag;
name_determine_flags( &corp_tag_flag, &corp_list_flag,
&asis_tag_flag, &asis_list_flag, tag, data, asis, corps );
if ( corp_tag_flag || corp_list_flag || asis_tag_flag || asis_list_flag ) {
newstr_strcpy( newtag, tag );
if ( corp_tag_flag ) { /* do nothing else */
} else if ( corp_list_flag && !asis_tag_flag ) {
newstr_strcat( newtag, ":CORP" );
} else if ( corp_list_flag && asis_tag_flag ) {
newstr_findreplace( newtag, ":ASIS", ":CORP" );
} else if ( asis_tag_flag ) { /* do nothing else */
} else if ( asis_list_flag ) {
newstr_strcat( newtag, ":ASIS" );
}
return 1;
}
else return 0;
}
/* wordin_person_first()
*
* From an xml list, extract the value of any
* <b:First>xxxx</b:First> and append "|xxxx" to name.
*
* Returns BIBL_ERR_MEMERR on memory error, BIBL_OK otherwise
*/
static int
wordin_person_first( xml *node, newstr *name )
{
for ( ; node; node=node->next ) {
if ( !xml_tagexact( node, "b:First" ) ) continue;
if ( node->value->len ) {
if ( name->len ) newstr_addchar( name, '|' );
newstr_strcat( name, node->value->data );
if ( newstr_memerr( name ) ) return BIBL_ERR_MEMERR;
}
}
return BIBL_OK;
}
int
endin_readf( FILE *fp, char *buf, int bufsize, int *bufpos, newstr *line, newstr *reference, int *fcharset )
{
int haveref = 0, inref = 0;
unsigned char *up;
char *p;
*fcharset = CHARSET_UNKNOWN;
while ( !haveref && readmore( fp, buf, bufsize, bufpos, line ) ) {
if ( !line->data ) continue;
p = &(line->data[0]);
/* Skip <feff> Unicode header information */
/* <feff> = ef bb bf */
up = (unsigned char* ) p;
if ( line->len > 2 && up[0]==0xEF && up[1]==0xBB &&
up[2]==0xBF ) {
*fcharset = CHARSET_UNICODE;
p += 3;
}
if ( !*p ) {
if ( inref ) haveref = 1; /* blank line separates */
else continue; /* blank line to ignore */
}
/* Each reference starts with a tag && ends with a blank line */
if ( endin_istag( p ) ) {
if ( reference->len ) newstr_addchar( reference, '\n' );
newstr_strcat( reference, p );
inref = 1;
} else if ( inref && p ) {
newstr_addchar( reference, '\n' );
newstr_strcat( reference, p );
}
newstr_empty( line );
}
if ( reference->len ) haveref = 1;
return haveref;
}
/* output article number as pages if true pages aren't found */
static void
output_articlenumber( FILE *fp, fields *info, unsigned long refnum,
int format_opts )
{
int ar = fields_find( info, "ARTICLENUMBER", -1 );
if ( ar!=-1 ) {
newstr pages;
newstr_init( &pages );
newstr_strcat( &pages, info->data[ar].data );
output_element( fp, "pages", pages.data, format_opts );
fields_setused( info, ar );
newstr_free( &pages );
}
}
static void
bibl_checkrefid( bibl *b, param *p )
{
fields *ref;
long i;
char buf[512];
int n;
for ( i=0; i<b->nrefs; ++i ) {
ref = b->ref[i];
n = fields_find( ref, "REFNUM", 0 );
if ( n==-1 ) n = build_refnum( ref, i+1 );
if ( p->addcount ) {
sprintf( buf, "_%ld", i+1 );
newstr_strcat( &(ref->data[n]), buf );
}
}
}
char *
xml_findstart( char *buffer, char *tag )
{
newstr starttag;
char *p;
newstr_init( &starttag );
newstr_addchar( &starttag, '<' );
newstr_strcat( &starttag, tag );
newstr_addchar( &starttag, ' ' );
p = strsearch( buffer, starttag.data );
if ( !p ) {
starttag.data[ starttag.len-1 ] = '>';
p = strsearch( buffer, starttag.data );
}
newstr_free( &starttag );
return p;
}
int
xml_tagexact( xml *node, char *s )
{
newstr tag;
int found = 0;
if ( xml_pns ) {
newstr_init( &tag );
newstr_strcpy( &tag, xml_pns );
newstr_addchar( &tag, ':' );
newstr_strcat( &tag, s );
if ( node->tag->len==tag.len &&
!strcasecmp( node->tag->data, tag.data ) )
found = 1;
newstr_free( &tag );
} else {
if ( node->tag->len==strlen( s ) &&
!strcasecmp( node->tag->data, s ) )
found = 1;
}
return found;
}
int
test_strcat( newstr *s )
{
int failed = 0;
int numshort = 5, numstrings = 1000, i;
/* ...adding empty strings to an empty string shouldn't change length */
newstr_empty( s );
for ( i=0; i<numstrings; ++i )
newstr_strcat( s, "" );
if ( test_consistency( s, 0, __FUNCTION__ ) || test_identity( s, "" ) )
failed++;
/* ...adding empty strings to a defined string shouldn't change string */
newstr_strcpy( s, "1" );
for ( i=0; i<numstrings; ++i )
newstr_strcat( s, "" );
if ( test_consistency( s, 1, __FUNCTION__ ) || test_identity( s, "1" ) )
failed++;
/* ...build "1111" with newstr_strcat */
newstr_empty( s );
for ( i=0; i<numshort; ++i )
newstr_strcat( s, "1" );
if ( test_consistency( s, numshort, __FUNCTION__ ) || test_identity( s, "11111" ) )
failed++;
/* ...build "xoxoxoxoxo" with newstr_strcat */
newstr_empty( s );
for ( i=0; i<numshort; ++i )
newstr_strcat( s, "xo" );
if ( test_consistency( s, numshort*2, __FUNCTION__ ) || test_identity( s, "xoxoxoxoxo" ) )
failed++;
newstr_empty( s );
for ( i=0; i<numstrings; ++i )
newstr_strcat( s, "1" );
if ( test_consistency( s, numstrings, __FUNCTION__ ) )
failed++;
newstr_empty( s );
for ( i=0; i<numstrings; ++i ) {
newstr_strcat( s, "XXOO" );
}
failed += test_consistency( s, numstrings*4, __FUNCTION__ );
return failed;
}
/* get reference type */
static char*
process_bibtextype( char *p, newstr *data )
{
newstr tmp;
newstr_init( &tmp );
newstr_empty( data );
if ( *p=='@' ) p++; /* skip '@' character */
while ( *p && *p!='{' && *p!='(' ) newstr_addchar( &tmp, *p++ );
if ( *p=='{' || *p=='(' ) p++;
p = skip_ws( p );
if ( tmp.len ) {
/* add '{' and '}' to protect from string expansion */
newstr_addchar( data, '{' );
newstr_strcat( data, tmp.data );
newstr_addchar( data, '}' );
}
newstr_free( &tmp );
return p;
}
