static void
output_title( fields *f, FILE *outptr, int level )
{
int ttl = fields_find( f, "TITLE", level );
int subttl = fields_find( f, "SUBTITLE", level );
int shrttl = fields_find( f, "SHORTTITLE", level );
int parttl = fields_find( f, "PARTTITLE", level );
char *val;
output_tag( outptr, lvl2indent(level), "titleInfo", NULL, TAG_OPEN, TAG_NEWLINE, NULL );
output_fil( outptr, lvl2indent(incr_level(level,1)), "title", f, ttl, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
output_fil( outptr, lvl2indent(incr_level(level,1)), "subTitle", f, subttl, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
output_fil( outptr, lvl2indent(incr_level(level,1)), "partName", f, parttl, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
/* MODS output doesn't verify if we don't at least have a <title/> element */
if ( ttl==-1 && subttl==-1 )
output_tag( outptr, lvl2indent(incr_level(level,1)), "title", NULL, TAG_SELFCLOSE, TAG_NEWLINE, NULL );
output_tag( outptr, lvl2indent(level), "titleInfo", NULL, TAG_CLOSE, TAG_NEWLINE, NULL );
/* output shorttitle if it's different from normal title */
if ( shrttl!=-1 ) {
val = (char *) fields_value( f, shrttl, FIELDS_CHRP );
if ( ttl==-1 || subttl!=-1 || strcmp(f->data[ttl].data,val) ) {
output_tag( outptr, lvl2indent(level), "titleInfo", NULL, TAG_OPEN, TAG_NEWLINE, "type", "abbreviated", NULL );
output_tag( outptr, lvl2indent(incr_level(level,1)), "title", val, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
output_tag( outptr, lvl2indent(level), "titleInfo", NULL, TAG_CLOSE, TAG_NEWLINE, NULL );
}
}
}
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;
}
/* bibl_copy()
*
* returns 1 on success, 0 on failure (memory error)
*/
int
bibl_copy( bibl *bout, bibl *bin )
{
fields *refin, *refout;
int i, j, n, status, ok, level;
char *tag, *value;
for ( i=0; i<bin->nrefs; ++i ) {
refin = bin->ref[i];
refout = fields_new();
if ( !refout ) return 0;
n = fields_num( refin );
for ( j=0; j<n; ++j ) {
tag = fields_tag( refin, j, FIELDS_CHRP );
value = fields_value( refin, j, FIELDS_CHRP );
level = fields_level( refin, j );
if ( tag && value ) {
status = fields_add( refout, tag, value, level );
if ( status!=FIELDS_OK ) return 0;
}
}
ok = bibl_addref( bout, refout );
if ( !ok ) return 0;
}
return 1;
}
static int
get_type( fields *f )
{
int type = TYPE_UNKNOWN, i, n, level;
char *tag, *value;
n = fields_num( f );
for ( i=0; i<n; ++i ) {
tag = fields_tag( f, i, FIELDS_CHRP );
if ( strcasecmp( tag, "GENRE" ) &&
strcasecmp( tag, "NGENRE") ) continue;
value = fields_value( f, i, FIELDS_CHRP );
level = fields_level( f, i );
if ( !strcasecmp( value, "periodical" ) ||
!strcasecmp( value, "academic journal" ) ||
!strcasecmp( value, "journal article" ) ) {
type = TYPE_ARTICLE;
} else if ( !strcasecmp( value, "book" ) ) {
if ( level==0 ) type=TYPE_BOOK;
else type=TYPE_INBOOK;
} else if ( !strcasecmp( value, "book chapter" ) ) {
type = TYPE_INBOOK;
}
}
return type;
}
static void
output_Rtag( FILE *fp, fields *f, char *adstag, int type )
{
char out[20], ch;
int n, i;
long long page;
strcpy( out, "..................." );
/** YYYY */
n = fields_find( f, "YEAR", LEVEL_ANY );
if ( n==-1 ) n = fields_find( f, "PARTYEAR", LEVEL_ANY );
if ( n!=-1 ) output_4digit_value( out, atoi( fields_value( f, n, FIELDS_CHRP ) ) );
/** JJJJ */
n = get_journalabbr( f );
if ( n!=-1 ) {
i = 0;
while ( i<5 && journals[n][i]!=' ' && journals[n][i]!='\t' ) {
out[4+i] = journals[n][i];
i++;
}
}
/** VVVV */
n = fields_find( f, "VOLUME", LEVEL_ANY );
if ( n!=-1 ) output_4digit_value( out+9, atoi( fields_value( f, n, FIELDS_CHRP ) ) );
/** MPPPP */
n = fields_find( f, "PAGESTART", LEVEL_ANY );
if ( n==-1 ) n = fields_find( f, "ARTICLENUMBER", LEVEL_ANY );
if ( n!=-1 ) {
page = atoll( fields_value( f, n, FIELDS_CHRP ) );
output_4digit_value( out+14, page );
if ( page>=10000 ) {
ch = 'a' + (page/10000);
out[13] = ch;
}
}
/** A */
ch = toupper( (unsigned char) get_firstinitial( f ) );
if ( ch!='\0' ) out[18] = ch;
fprintf( fp, "%s %s\n", adstag, out );
}
static void
xxx_to_url( fields *f, int n, char *http_prefix, char *urltag, newstr *xxx_url )
{
newstr_empty( xxx_url );
construct_url( http_prefix, fields_value( f, n, FIELDS_STRP ), xxx_url );
if ( url_exists( f, urltag, xxx_url ) )
newstr_empty( xxx_url );
}
static void
output_datepieces( fields *f, FILE *outptr, int pos[ NUM_DATE_TYPES ] )
{
newstr *s;
int i;
for ( i=0; i<3 && pos[i]!=-1; ++i ) {
if ( i>0 ) fprintf( outptr, "-" );
/* zero pad month or days written as "1", "2", "3" ... */
if ( i==DATE_MONTH || i==DATE_DAY ) {
s = fields_value( f, pos[i], FIELDS_STRP_NOUSE );
if ( s->len==1 ) {
fprintf( outptr, "0" );
}
}
fprintf( outptr, "%s", (char *) fields_value( f, pos[i], FIELDS_CHRP ) );
}
}
int
copacin_convertf( fields *copacin, fields *out, int reftype, param *p, variants *all, int nall )
{
int process, level, i, n, nfields, ok, status = BIBL_OK;
newstr *tag, *data;
char *newtag;
nfields = fields_num( copacin );
for ( i=0; i<nfields; ++i ) {
tag = fields_tag( copacin, i, FIELDS_STRP );
n = translate_oldtag( tag->data, reftype, all, nall, &process, &level, &newtag );
if ( n==-1 ) {
copacin_report_notag( p, tag->data );
continue;
}
if ( process == ALWAYS ) continue; /*add these later*/
data = fields_value( copacin, i, FIELDS_STRP );
switch ( process ) {
case SIMPLE:
status = copacin_simple( out, newtag, data->data, level );
break;
case TITLE:
ok = title_process( out, newtag, data->data, level, p->nosplittitle );
if ( ok ) status = BIBL_OK;
else status = BIBL_ERR_MEMERR;
break;
case PERSON:
status = copacin_addname( out, newtag, data, level, &(p->asis), &(p->corps) );
break;
case SERIALNO:
ok = addsn( out, data->data, level );
if ( ok ) status = BIBL_OK;
else status = BIBL_ERR_MEMERR;
break;
default:
fprintf(stderr,"%s: internal error -- " "illegal process value %d\n", p->progname, process );
status = BIBL_OK;
break;
}
if ( status!=BIBL_OK ) return status;
}
return status;
}
static void
output_dateissued( fields *f, FILE *outptr, int level, int pos[ NUM_DATE_TYPES ] )
{
output_tag( outptr, lvl2indent(incr_level(level,1)), "dateIssued", NULL, TAG_OPEN, TAG_NONEWLINE, NULL );
if ( pos[ DATE_YEAR ]!=-1 || pos[ DATE_MONTH ]!=-1 || pos[ DATE_DAY ]!=-1 ) {
output_datepieces( f, outptr, pos );
} else {
fprintf( outptr, "%s", (char *) fields_value( f, pos[ DATE_ALL ], FIELDS_CHRP ) );
}
fprintf( outptr, "</dateIssued>\n" );
}
/* extents output
*
* <extent unit="page">
* <start>xxx</start>
* <end>xxx</end>
* </extent>
*/
static void
mods_output_extents( fields *f, FILE *outptr, int start, int end, int total, char *extype, int level )
{
char *val;
output_tag( outptr, lvl2indent(incr_level(level,1)), "extent", NULL, TAG_OPEN, TAG_NEWLINE, "unit", extype, NULL );
if ( start!=-1 ) {
val = (char *) fields_value( f, start, FIELDS_CHRP );
output_tag( outptr, lvl2indent(incr_level(level,2)), "start", val, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
}
if ( end!=-1 ) {
val = (char *) fields_value( f, end, FIELDS_CHRP );
output_tag( outptr, lvl2indent(incr_level(level,2)), "end", val, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
}
if ( total!=-1 ) {
val = (char *) fields_value( f, total, FIELDS_CHRP );
output_tag( outptr, lvl2indent(incr_level(level,2)), "total", val, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
}
output_tag( outptr, lvl2indent(incr_level(level,1)), "extent", NULL, TAG_CLOSE, TAG_NEWLINE, NULL );
}
static void
output_toc( fields *f, FILE *outptr, int level )
{
char *val;
int n;
n = fields_find( f, "CONTENTS", level );
if ( n!=-1 ) {
val = (char *) fields_value( f, n, FIELDS_CHRP );
output_tag( outptr, lvl2indent(level), "tableOfContents", val, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
}
}
/* output_fil()
*
* output XML tag, but lookup data in fields struct
*
* mode = [ TAG_OPEN | TAG_CLOSE | TAG_OPENCLOSE | TAG_SELFCLOSE ]
* newline = [ TAG_NEWLINE | TAG_NONEWLINE ]
*
* value looked up in fields will only be used in mode TAG_OPENCLOSE
*/
static void
output_fil( FILE *outptr, int nindents, char *tag, fields *f, int n, unsigned char mode, unsigned char newline, ... )
{
va_list attrs;
char *value;
if ( n!=-1 ) {
value = (char *) fields_value( f, n, FIELDS_CHRP );
va_start( attrs, newline );
output_tag_core( outptr, nindents, tag, value, mode, newline, &attrs );
va_end( attrs );
}
}
static int
bibtexin_cleanref( fields *bibin, param *p )
{
int i, n, status;
newstr *t, *d;
n = fields_num( bibin );
for ( i=0; i<n; ++i ) {
t = fields_tag( bibin, i, FIELDS_STRP_NOUSE );
d = fields_value( bibin, i, FIELDS_STRP_NOUSE );
status = bibtex_cleandata( t, d, bibin, p );
if ( status!=BIBL_OK ) return status;
}
return BIBL_OK;
}
static void
output_description( fields *f, FILE *outptr, int level )
{
char *val;
int n;
n = fields_find( f, "DESCRIPTION", level );
if ( n!=-1 ) {
val = ( char * ) fields_value( f, n, FIELDS_CHRP );
output_tag( outptr, lvl2indent(level), "physicalDescription", NULL, TAG_OPEN, TAG_NEWLINE, NULL );
output_tag( outptr, lvl2indent(incr_level(level,1)), "note", val, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
output_tag( outptr, lvl2indent(level), "physicalDescription", NULL, TAG_CLOSE, TAG_NEWLINE, NULL );
}
}
static int
url_exists( fields *f, char *urltag, newstr *doi_url )
{
int i, n;
if ( urltag ) {
n = fields_num( f );
for ( i=0; i<n; ++i ) {
if ( strcmp( fields_tag( f, i, FIELDS_CHRP ), urltag ) ) continue;
if ( strcmp( fields_value( f, i, FIELDS_CHRP ), doi_url->data ) ) continue;
return 1;
}
}
return 0;
}
static char
get_firstinitial( fields *f )
{
char *name;
int n;
n = fields_find( f, "AUTHOR", LEVEL_MAIN );
if ( n==-1 ) n = fields_find( f, "AUTHOR", LEVEL_ANY );
if ( n!=-1 ) {
name = fields_value( f, n, FIELDS_CHRP );
return name[0];
} else return '\0';
}
/* output_language_core()
*
* generates language output for tag="langauge" or tag="languageOfCataloging"
* if possible, outputs iso639-2b code for the language
*
* <language>
* <languageTerm type="text">xxx</languageTerm>
* </language>
*
* <language>
* <languageTerm type="text">xxx</languageTerm>
* <languageTerm type="code" authority="iso639-2b">xxx</languageTerm>
* </language>
*
*/
static void
output_language_core( fields *f, int n, FILE *outptr, char *tag, int level )
{
char *lang, *code;
lang = (char *) fields_value( f, n, FIELDS_CHRP );
code = iso639_2_from_language( lang );
output_tag( outptr, lvl2indent(level), tag, NULL, TAG_OPEN, TAG_NEWLINE, NULL );
output_tag( outptr, lvl2indent(incr_level(level,1)), "languageTerm", lang, TAG_OPENCLOSE, TAG_NEWLINE, "type", "text", NULL );
if ( code ) {
output_tag( outptr, lvl2indent(incr_level(level,1)), "languageTerm", code, TAG_OPENCLOSE, TAG_NEWLINE, "type", "code", "authority", "iso639-2b", NULL );
}
output_tag( outptr, lvl2indent(level), tag, NULL, TAG_CLOSE, TAG_NEWLINE, NULL );
}
static void
output_verbose( fields *f, unsigned long refnum )
{
char *tag, *value;
int i, n, level;
fprintf( stderr, "REF #%lu----\n", refnum+1 );
n = fields_num( f );
for ( i=0; i<n; ++i ) {
tag = fields_tag( f, i, FIELDS_CHRP_NOUSE );
value = fields_value( f, i, FIELDS_CHRP_NOUSE );
level = fields_level( f, i );
fprintf( stderr, "\t'%s'\t'%s'\t%d\n",
tag, value, level );
}
}
/* output_genre()
*
* <genre authority="marcgt">thesis</genre>
* <genre>Diploma thesis</genre>
*/
static void
output_genre( fields *f, FILE *outptr, int level )
{
char *value, *attr, *attrvalue="marcgt";
int i, n;
n = fields_num( f );
for ( i=0; i<n; ++i ) {
if ( fields_level( f, i ) != level ) continue;
if ( !fields_match_tag( f, i, "GENRE" ) && !fields_match_tag( f, i, "NGENRE" ) ) continue;
value = fields_value( f, i, FIELDS_CHRP );
attr = ( marc_findgenre( value ) == -1 ) ? NULL : "authority";
output_tag( outptr, lvl2indent(level), "genre", value, TAG_OPENCLOSE, TAG_NEWLINE, attr, attrvalue, NULL );
}
}
static int
get_journalabbr( fields *f )
{
char *jrnl;
int n, j;
n = fields_find( f, "TITLE", LEVEL_HOST );
if ( n!=-1 ) {
jrnl = fields_value( f, n, FIELDS_CHRP );
for ( j=0; j<njournals; j++ ) {
if ( !strcasecmp( jrnl, journals[j]+6 ) )
return j;
}
}
return -1;
}
/* refnum should start with a non-number and not include spaces -- ignore this */
static void
output_refnum( fields *f, int n, FILE *outptr )
{
char *p = fields_value( f, n, FIELDS_CHRP_NOUSE );
/* if ( p && ((*p>='0' && *p<='9') || *p=='-' || *p=='_' ))
fprintf( outptr, "ref" );*/
while ( p && *p ) {
if ( !is_ws(*p) ) fprintf( outptr, "%c", *p );
/* if ( (*p>='A' && *p<='Z') ||
(*p>='a' && *p<='z') ||
(*p>='0' && *p<='9') ||
(*p=='-') || (*p=='
(*p=='_') ) fprintf( outptr, "%c", *p );*/
p++;
}
}
/* output_resource()
*
* <typeOfResource>text</typeOfResource>
*/
static void
output_resource( fields *f, FILE *outptr, int level )
{
char *value;
int n;
n = fields_find( f, "RESOURCE", level );
if ( n!=-1 ) {
value = fields_value( f, n, FIELDS_CHRP );
if ( marc_findresource( value )!=-1 ) {
output_fil( outptr, lvl2indent(level), "typeOfResource", f, n, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
} else {
fprintf( stderr, "Illegal typeofResource = '%s'\n", value );
}
}
}
/* bibtexin_titleinbook_isbooktitle()
*
* Normally, the title field of inbook refers to the book. The
* section in a @inbook reference is untitled. If it's titled,
* the @incollection should be used. For example, in:
*
* @inbook{
* title="xxx"
* }
*
* the booktitle is "xxx".
*
* However, @inbook is frequently abused (and treated like
* @incollection) so that title and booktitle are present
* and title is now 'supposed' to refer to the section. For example:
*
* @inbook{
* title="yyy",
* booktitle="xxx"
* }
*
* Therefore report whether or not booktitle is present as well
* as title in @inbook references. If not, then make 'title'
* correspond to the title of the book, not the section.
*
*/
static int
bibtexin_titleinbook_isbooktitle( char *intag, fields *bibin )
{
int n;
/* ...look only at 'title="xxx"' elements */
if ( strcasecmp( intag, "TITLE" ) ) return 0;
/* ...look only at '@inbook' references */
n = fields_find( bibin, "INTERNAL_TYPE", -1 );
if ( n==-1 ) return 0;
if ( strcasecmp( fields_value( bibin, n, FIELDS_CHRP ), "INBOOK" ) ) return 0;
/* ...look to see if 'booktitle="yyy"' exists */
n = fields_find( bibin, "BOOKTITLE", -1 );
if ( n==-1 ) return 0;
else return 1;
}
static void
output_people( FILE *fp, fields *info, char *tag, char *entag, int level )
{
newstr oneperson;
int i, n, flvl;
char *ftag;
newstr_init( &oneperson );
n = fields_num( info );
for ( i=0; i<n; ++i ) {
flvl = fields_level( info, i );
if ( level!=LEVEL_ANY && flvl!=level ) continue;
ftag = fields_tag( info, i, FIELDS_CHRP );
if ( !strcasecmp( ftag, tag ) ) {
name_build_withcomma( &oneperson, fields_value( info, i, FIELDS_CHRP ) );
fprintf( fp, "%s %s\n", entag, oneperson.data );
}
}
newstr_free( &oneperson );
}
static int
bibtexin_crossref( bibl *bin, param *p )
{
int i, n, ncross, status = BIBL_OK;
fields *bibref, *bibcross;
for ( i=0; i<bin->nrefs; ++i ) {
bibref = bin->ref[i];
n = fields_find( bibref, "CROSSREF", -1 );
if ( n==-1 ) continue;
fields_setused( bibref, n );
ncross = bibtexin_findref( bin, (char*) fields_value( bibref, n, FIELDS_CHRP ) );
if ( ncross==-1 ) {
bibtexin_nocrossref( bin, i, n, p );
continue;
}
bibcross = bin->ref[ncross];
status = bibtexin_crossref_oneref( bibref, bibcross );
if ( status!=BIBL_OK ) goto out;
}
out:
return status;
}
/* look for thesis-type hint */
static int
risin_thesis_hints( fields *bibin, int reftype, param *p, fields *bibout )
{
int i, nfields, fstatus;
char *tag, *value;
if ( strcasecmp( p->all[reftype].type, "THES" ) ) return BIBL_OK;
nfields = fields_num( bibin );
for ( i=0; i<nfields; ++i ) {
tag = fields_tag( bibin, i, FIELDS_CHRP );
if ( strcasecmp( tag, "U1" ) ) continue;
value = fields_value( bibin, i, FIELDS_CHRP );
if ( !strcasecmp(value,"Ph.D. Thesis")||
!strcasecmp(value,"Masters Thesis")||
!strcasecmp(value,"Diploma Thesis")||
!strcasecmp(value,"Doctoral Thesis")||
!strcasecmp(value,"Habilitation Thesis")) {
fstatus = fields_add( bibout, "GENRE", value, 0 );
if ( fstatus!=FIELDS_OK ) return BIBL_ERR_MEMERR;
}
}
return BIBL_OK;
}
int
bibtexin_convertf( fields *bibin, fields *info, int reftype, param *p,
variants *all, int nall )
{
int process, level, i, n, nfields, status;
newstr *t, *d;
char *outtag;
nfields = fields_num( bibin );
for ( i=0; i<nfields; ++i ) {
if ( fields_used( bibin, i ) ) continue; /* e.g. successful crossref */
if ( fields_nodata( bibin, i ) ) continue;
t = fields_tag( bibin, i, FIELDS_STRP );
if ( t->len == 0 ) continue; /* Don't consider with null tags */
n = process_findoldtag( t->data, reftype, all, nall );
if ( n==-1 ) {
bibtexin_notag( p, t->data );
continue;
}
d = fields_value( bibin, i, FIELDS_STRP );
process = ((all[reftype]).tags[n]).processingtype;
level = ((all[reftype]).tags[n]).level;
outtag = ((all[reftype]).tags[n]).newstr;
switch( process ) {
case SIMPLE:
status = bibtex_simple( info, outtag, d, level );
break;
case TITLE:
status = bibtexin_title_process( info, "TITLE", bibin, t, d, level, p->nosplittitle );
break;
case PERSON:
status = bibtex_names( info, outtag, d, level, &(p->asis), &(p->corps) );
break;
case PAGES:
status = process_pages( info, d, level );
break;
case KEYWORD:
status = process_keywords( info, d, level );
break;
case HOWPUBLISHED:
status = process_howpublished( info, d, level );
break;
case LINKEDFILE:
status = process_file( info, d, level );
break;
case BT_NOTE:
status = process_note( info, d, level );
break;
case BT_SENTE:
status = process_sente( info, d, level );
break;
case BT_URL:
status = process_url( info, d, level );
break;
case BT_ORG:
status = process_organization( bibin, info, d, level );
break;
default:
status = BIBL_OK;
break;
}
if ( status!=BIBL_OK ) return status;
}
return status;
}
int
endin_convertf( fields *endin, fields *info, int reftype, param *p, variants *all, int nall )
{
int i, level, n, process, nfields, ok;
char *newtag, *t;
newstr *d;
nfields = fields_num( endin );
for ( i=0; i<nfields; ++i ) {
/* Ensure that data exists */
d = fields_value( endin, i, FIELDS_STRP_NOUSE );
if ( d->len == 0 ) {
fields_setused( endin, i );
continue;
}
/*
* All refer format tags start with '%'. If we have one
* that doesn't, assume that it comes from endx2xml
* and just copy and paste to output
*/
t = fields_tag( endin, i, FIELDS_CHRP );
if ( t[0]!='%' ) {
fields_add( info, t, d->data, endin->level[i] );
continue;
}
n = translate_oldtag( t, reftype, all, nall, &process, &level, &newtag );
if ( n==-1 ) {
endin_notag( p, t, d->data );
continue;
}
if ( process == ALWAYS ) continue; /* add these later */
fields_setused( endin, i );
switch ( process ) {
case SIMPLE:
ok = fields_add( info, newtag, d->data, level );
break;
case TYPE:
ok = endin_addtype( info, d->data, level );
break;
case TITLE:
ok = title_process( info, newtag, d->data, level, p->nosplittitle );
break;
case PERSON:
ok = name_add( info, newtag, d->data, level, &(p->asis), &(p->corps) );
break;
case DATE:
ok = endin_adddate( info, t, newtag,d->data,level);
break;
case PAGES:
ok = endin_addpage( info, d->data, level );
break;
case SERIALNO:
ok = addsn( info, d->data, level );
break;
case NOTES:
ok = endin_addnotes( info, newtag, d->data, level );
break;
default:
fprintf(stderr,"%s: internal error -- illegal process number %d\n", p->progname, process );
ok = 1;
break;
}
if ( !ok ) return BIBL_ERR_MEMERR;
}
return BIBL_OK;
}
/* Try to determine type of reference from
* <genre></genre>
*/
static int
get_type_genre( fields *f, param *p )
{
match_type match_genres[] = {
{ "academic journal", TYPE_ARTICLE },
{ "article", TYPE_ARTICLE },
{ "journal article", TYPE_ARTICLE },
{ "magazine", TYPE_MAGARTICLE },
{ "conference publication", TYPE_CONF },
{ "newspaper", TYPE_NEWS },
{ "legislation", TYPE_STATUTE },
{ "communication", TYPE_PCOMM },
{ "hearing", TYPE_HEAR },
{ "electronic", TYPE_ELEC },
{ "legal case and case notes", TYPE_CASE },
{ "book chapter", TYPE_INBOOK },
{ "Ph.D. thesis", TYPE_PHDTHESIS },
{ "Masters thesis", TYPE_MASTERSTHESIS },
{ "Diploma thesis", TYPE_DIPLOMATHESIS },
{ "Doctoral thesis", TYPE_DOCTORALTHESIS },
{ "Habilitation thesis", TYPE_HABILITATIONTHESIS },
{ "report", TYPE_REPORT },
{ "abstract or summary", TYPE_ABSTRACT },
{ "patent", TYPE_PATENT },
{ "unpublished", TYPE_UNPUBLISHED },
{ "map", TYPE_MAP },
};
int nmatch_genres = sizeof( match_genres ) / sizeof( match_genres[0] );
int type, i, j;
char *tag, *value;
type = TYPE_UNKNOWN;
for ( i=0; i<fields_num( f ); ++i ) {
if ( !fields_match_tag( f, i, "GENRE" ) &&
!fields_match_tag( f, i, "NGENRE" ) )
continue;
value = ( char * ) fields_value( f, i, FIELDS_CHRP );
for ( j=0; j<nmatch_genres; ++j )
if ( !strcasecmp( match_genres[j].name, value ) )
type = match_genres[j].type;
if ( p->verbose ) {
tag = ( char * ) fields_tag( f, i, FIELDS_CHRP );
if ( p->progname ) fprintf( stderr, "%s: ", p->progname );
fprintf( stderr, "Type from tag '%s' data '%s': ", tag, value );
write_type( stderr, type );
fprintf( stderr, "\n" );
}
if ( type==TYPE_UNKNOWN ) {
if ( !strcasecmp( value, "periodical" ) )
type = TYPE_ARTICLE;
else if ( !strcasecmp( value, "thesis" ) )
type = TYPE_THESIS;
else if ( !strcasecmp( value, "book" ) ) {
if ( fields_level( f, i )==0 ) type=TYPE_BOOK;
else type=TYPE_INBOOK;
}
else if ( !strcasecmp( value, "collection" ) ) {
if ( fields_level( f, i )==0 ) type=TYPE_BOOK;
else type=TYPE_INBOOK;
}
}
}
if ( p->verbose ) {
if ( p->progname ) fprintf( stderr, "%s: ", p->progname );
fprintf( stderr, "Type from genre element: " );
write_type( stderr, type );
fprintf( stderr, "\n" );
}
return type;
}
