int
endin_processf( fields *endin, char *p, char *filename, long nref )
{
newstr tag, data;
int n;
newstrs_init( &tag, &data, NULL );
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 = fields_num( endin );
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 );
}
}
}
newstrs_empty( &tag, &data, NULL );
}
newstrs_free( &tag, &data, NULL );
return 1;
}
static void
output_name_type( fields *info, FILE *outptr, int level,
char *map[], int nmap, char *tag )
{
newstr ntag;
int i, j, n=0, code, nfields;
newstr_init( &ntag );
nfields = fields_num( info );
for ( j=0; j<nmap; ++j ) {
for ( i=0; i<nfields; ++i ) {
code = extract_name_and_info( &ntag, &(info->tag[i]) );
if ( strcasecmp( ntag.data, map[j] ) ) continue;
if ( n==0 )
fprintf( outptr, "<%s><b:NameList>\n", tag );
if ( code != NAME )
output_name_nomangle( outptr, info->data[i].data );
else
output_name( outptr, info->data[i].data );
fields_setused( info, i );
n++;
}
}
newstr_free( &ntag );
if ( n )
fprintf( outptr, "</b:NameList></%s>\n", tag );
}
static int
bibtexin_crossref_oneref( fields *bibref, fields *bibcross )
{
int j, n, nl, ntype, fstatus, status = BIBL_OK;
char *type, *nt, *nv;
ntype = fields_find( bibref, "INTERNAL_TYPE", -1 );
type = ( char * ) fields_value( bibref, ntype, FIELDS_CHRP_NOUSE );
n = fields_num( bibcross );
for ( j=0; j<n; ++j ) {
nt = ( char * ) fields_tag( bibcross, j, FIELDS_CHRP_NOUSE );
if ( !strcasecmp( nt, "INTERNAL_TYPE" ) ) continue;
if ( !strcasecmp( nt, "REFNUM" ) ) continue;
if ( !strcasecmp( nt, "TITLE" ) ) {
if ( !strcasecmp( type, "Inproceedings" ) ||
!strcasecmp( type, "Incollection" ) )
nt = "booktitle";
}
nv = ( char * ) fields_value( bibcross, j, FIELDS_CHRP_NOUSE );
nl = fields_level( bibcross, j ) + 1;
fstatus = fields_add( bibref, nt, nv, nl );
if ( fstatus!=FIELDS_OK ) {
status = BIBL_ERR_MEMERR;
goto out;
}
}
out:
return status;
}
static int
medin_assembleref( xml *node, fields *info )
{
int status = BIBL_OK;
if ( node->down ) {
if ( xml_tagexact( node, "PubmedArticle" ) )
status = medin_pubmedarticle( node->down, info );
else if ( xml_tagexact( node, "MedlineCitation" ) )
status = medin_medlinecitation( node->down, info );
else
status = medin_assembleref( node->down, info );
}
if ( status!=BIBL_OK ) return status;
if ( node->next ) {
status = medin_assembleref( node->next, info );
if ( status!=BIBL_OK ) return status;
}
/* assume everything is a journal article */
if ( fields_num( info ) ) {
status = fields_add( info, "RESOURCE", "text", 0 );
if ( status!=FIELDS_OK ) return BIBL_ERR_MEMERR;
status = fields_add( info, "ISSUANCE", "continuing", 1 );
if ( status!=FIELDS_OK ) return BIBL_ERR_MEMERR;
status = fields_add( info, "GENRE", "periodical", 1 );
if ( status!=FIELDS_OK ) return BIBL_ERR_MEMERR;
status = fields_add( info, "GENRE", "academic journal", 1 );
if ( status!=FIELDS_OK ) return BIBL_ERR_MEMERR;
status = BIBL_OK;
}
return status;
}
/* 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 void
output_notes( fields *f, FILE *outptr, int level )
{
int i, n;
char *t;
n = fields_num( f );
for ( i=0; i<n; ++i ) {
if ( fields_level( f, i ) != level ) continue;
t = fields_tag( f, i, FIELDS_CHRP_NOUSE );
if ( !strcasecmp( t, "NOTES" ) )
output_fil( outptr, lvl2indent(level), "note", f, i, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
else if ( !strcasecmp( t, "PUBSTATE" ) )
output_fil( outptr, lvl2indent(level), "note", f, i, TAG_OPENCLOSE, TAG_NEWLINE, "type", "publication status", NULL );
else if ( !strcasecmp( t, "ANNOTE" ) )
output_fil( outptr, lvl2indent(level), "bibtex-annote", f, i, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
else if ( !strcasecmp( t, "TIMESCITED" ) )
output_fil( outptr, lvl2indent(level), "note", f, i, TAG_OPENCLOSE, TAG_NEWLINE, "type", "times cited", NULL );
else if ( !strcasecmp( t, "ANNOTATION" ) )
output_fil( outptr, lvl2indent(level), "note", f, i, TAG_OPENCLOSE, TAG_NEWLINE, "type", "annotation", NULL );
else if ( !strcasecmp( t, "ADDENDUM" ) )
output_fil( outptr, lvl2indent(level), "note", f, i, TAG_OPENCLOSE, TAG_NEWLINE, "type", "addendum", NULL );
else if ( !strcasecmp( t, "BIBKEY" ) )
output_fil( outptr, lvl2indent(level), "note", f, i, TAG_OPENCLOSE, TAG_NEWLINE, "type", "bibliography key", NULL );
}
}
/* output_url()
*
* <location>
* <url>URL</url>
* <url urlType="pdf">PDFLINK</url>
* <url displayLabel="Electronic full text" access="raw object">PDFLINK</url>
* <physicalLocation>LOCATION</physicalLocation>
* </location>
*/
static void
output_url( fields *f, FILE *outptr, int level )
{
int location = fields_find( f, "LOCATION", level );
int url = fields_find( f, "URL", level );
int fileattach = fields_find( f, "FILEATTACH", level );
int pdflink = fields_find( f, "PDFLINK", level );
int i, n;
if ( url==-1 && location==-1 && pdflink==-1 && fileattach==-1 ) return;
output_tag( outptr, lvl2indent(level), "location", NULL, TAG_OPEN, TAG_NEWLINE, NULL );
n = fields_num( f );
for ( i=0; i<n; ++i ) {
if ( f->level[i]!=level ) continue;
if ( strcasecmp( f->tag[i].data, "URL" ) ) continue;
output_fil( outptr, lvl2indent(incr_level(level,1)), "url", f, i, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
}
for ( i=0; i<n; ++i ) {
if ( f->level[i]!=level ) continue;
if ( strcasecmp( f->tag[i].data, "PDFLINK" ) ) continue;
/* output_fil( outptr, lvl2indent(incr_level(level,1)), "url", f, i, TAG_OPENCLOSE, TAG_NEWLINE, "urlType", "pdf", NULL ); */
output_fil( outptr, lvl2indent(incr_level(level,1)), "url", f, i, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
}
for ( i=0; i<n; ++i ) {
if ( f->level[i]!=level ) continue;
if ( strcasecmp( f->tag[i].data, "FILEATTACH" ) ) continue;
output_fil( outptr, lvl2indent(incr_level(level,1)), "url", f, i, TAG_OPENCLOSE, TAG_NEWLINE, "displayLabel", "Electronic full text", "access", "raw object", NULL );
}
if ( location!=-1 )
output_fil( outptr, lvl2indent(incr_level(level,1)), "physicalLocation", f, location, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
output_tag( outptr, lvl2indent(level), "location", NULL, TAG_CLOSE, TAG_NEWLINE, NULL );
}
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 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;
}
static void
modsout_report_unused_tags( fields *f, param *p, unsigned long numrefs )
{
int i, n, nwritten, nunused = 0, level;
char *tag, *value;
n = fields_num( f );
for ( i=0; i<n; ++i ) {
if ( fields_used( f, i ) ) continue;
nunused++;
}
if ( nunused ) {
if ( p->progname ) fprintf( stderr, "%s: ", p->progname );
fprintf( stderr, "Reference %lu has unused tags.\n", numrefs+1 );
/* Find author from level 0 */
nwritten = 0;
for ( i=0; i<n; ++i ) {
if ( fields_level( f, i ) != 0 ) continue;
tag = fields_tag( f, i, FIELDS_CHRP_NOUSE );
if ( strncasecmp( tag, "AUTHOR", 6 ) ) continue;
value = fields_value( f, i, FIELDS_CHRP_NOUSE );
if ( nwritten==0 ) fprintf( stderr, "\tAuthor(s) (level=0):\n" );
fprintf( stderr, "\t\t'%s'\n", value );
nwritten++;
}
nwritten = 0;
for ( i=0; i<n; ++i ) {
if ( fields_level( f, i ) != 0 ) continue;
tag = fields_tag( f, i, FIELDS_CHRP_NOUSE );
if ( strcasecmp( tag, "YEAR" ) && strcasecmp( tag, "PARTYEAR" ) ) continue;
value = fields_value( f, i, FIELDS_CHRP_NOUSE );
if ( nwritten==0 ) fprintf( stderr, "\tYear(s) (level=0):\n" );
fprintf( stderr, "\t\t'%s'\n", value );
nwritten++;
}
nwritten = 0;
for ( i=0; i<n; ++i ) {
if ( fields_level( f, i ) != 0 ) continue;
tag = fields_tag( f, i, FIELDS_CHRP_NOUSE );
if ( strncasecmp( tag, "TITLE", 5 ) ) continue;
value = fields_value( f, i, FIELDS_CHRP_NOUSE );
if ( nwritten==0 ) fprintf( stderr, "\tTitle(s) (level=0):\n" );
fprintf( stderr, "\t\t'%s'\n", value );
nwritten++;
}
fprintf( stderr, "\tUnused tags:\n" );
for ( i=0; i<n; ++i ) {
if ( fields_used( f, i ) ) continue;
tag = fields_tag( f, i, FIELDS_CHRP_NOUSE );
value = fields_value( f, i, FIELDS_CHRP_NOUSE );
level = fields_level( f, i );
fprintf( stderr, "\t\ttag: '%s' value: '%s' level: %d\n",
tag, value, level );
}
}
}
static void
endin_cleanref( fields *endin )
{
int i, n;
n = fields_num( endin );
for ( i=0; i<n; ++i ) {
if ( is_wiley_author( endin, i ) )
cleanup_wiley_author( endin, i );
}
}
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 int
original_items( fields *f, int level )
{
int i, targetlevel, n;
if ( level < 0 ) return 0;
targetlevel = -( level + 2 );
n = fields_num( f );
for ( i=0; i<n; ++i ) {
if ( fields_level( f, i ) == targetlevel )
return targetlevel;
}
return 0;
}
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_jstor( FILE *fp, fields *f )
{
newstr s;
int i;
newstr_init( &s );
for ( i=0; i<fields_num( f ); ++i ) {
if ( !fields_match_tag( f, i, "JSTOR" ) ) continue;
jstor_to_url( f, i, "URL", &s );
if ( s.len )
fprintf( fp, "UR - %s\n", s.data );
}
newstr_free( &s );
}
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;
}
/* 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 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_key()
*
* <subject>
* <topic>xxxx</topic>
* </subject>
*/
static void
output_key( fields *f, FILE *outptr, int level )
{
int i, n;
n = fields_num( f );
for ( i=0; i<n; ++i ) {
if ( fields_level( f, i ) != level ) continue;
if ( !strcasecmp( f->tag[i].data, "KEYWORD" ) ) {
output_tag( outptr, lvl2indent(level), "subject", NULL, TAG_OPEN, TAG_NEWLINE, NULL );
output_fil( outptr, lvl2indent(incr_level(level,1)), "topic", f, i, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
output_tag( outptr, lvl2indent(level), "subject", NULL, TAG_CLOSE, TAG_NEWLINE, NULL );
}
}
}
static void
output_jstor( FILE *fp, fields *f )
{
newstr jstor_url;
int i, n;
newstr_init( &jstor_url );
n = fields_num( f );
for ( i=0; i<n; ++i ) {
if ( !fields_match_tag( f, i, "JSTOR" ) ) continue;
jstor_to_url( f, i, "URL", &jstor_url );
if ( jstor_url.len )
fprintf( fp, "%%U %s\n", jstor_url.data );
}
newstr_free( &jstor_url );
}
static void
output_arxiv( FILE *fp, fields *f )
{
newstr arxiv_url;
int i, n;
newstr_init( &arxiv_url );
n = fields_num( f );
for ( i=0; i<n; ++i ) {
if ( !fields_match_tag( f, i, "ARXIV" ) ) continue;
arxiv_to_url( f, i, "URL", &arxiv_url );
if ( arxiv_url.len )
fprintf( fp, "%%U %s\n", arxiv_url.data );
}
newstr_free( &arxiv_url );
}
static void
output_doi( FILE *fp, fields *f )
{
newstr doi_url;
int i, n;
newstr_init( &doi_url );
n = fields_num( f );
for ( i=0; i<n; ++i ) {
if ( !fields_match_tag( f, i, "DOI" ) ) continue;
doi_to_url( f, i, "URL", &doi_url );
if ( doi_url.len )
fprintf( fp, "%%U %s\n", doi_url.data );
}
newstr_free( &doi_url );
}
static void
output_pmid( FILE *fp, fields *f )
{
newstr pmid_url;
int i, n;
newstr_init( &pmid_url );
n = fields_num( f );
for ( i=0; i<n; ++i ) {
if ( !fields_match_tag( f, i, "PMID" ) ) continue;
pmid_to_url( f, i, "URL", &pmid_url );
if ( pmid_url.len )
fprintf( fp, "%%U %s\n", pmid_url.data );
}
newstr_free( &pmid_url );
}
static void
output_sn( fields *f, FILE *outptr, int level )
{
convert sn_types[] = {
{ "isbn", "ISBN", 0, 0 },
{ "isbn", "ISBN13", 0, 0 },
{ "lccn", "LCCN", 0, 0 },
{ "issn", "ISSN", 0, 0 },
{ "citekey", "REFNUM", 0, 0 },
{ "doi", "DOI", 0, 0 },
{ "eid", "EID", 0, 0 },
{ "eprint", "EPRINT", 0, 0 },
{ "eprinttype","EPRINTTYPE",0, 0 },
{ "pubmed", "PMID", 0, 0 },
{ "medline", "MEDLINE", 0, 0 },
{ "pii", "PII", 0, 0 },
{ "arXiv", "ARXIV", 0, 0 },
{ "isi", "ISIREFNUM", 0, 0 },
{ "accessnum", "ACCESSNUM", 0, 0 },
{ "jstor", "JSTOR", 0, 0 },
{ "isrn", "ISRN", 0, 0 },
};
int ntypes = sizeof( sn_types ) / sizeof( sn_types[0] );
int i, n;
/* output call number */
n = fields_find( f, "CALLNUMBER", level );
output_fil( outptr, lvl2indent(level), "classification", f, n, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
/* output specialized serialnumber */
convert_findallfields( f, sn_types, ntypes, level );
for ( i=0; i<ntypes; ++i ) {
if ( sn_types[i].pos==-1 ) continue;
output_fil( outptr, lvl2indent(level), "identifier", f, sn_types[i].pos, TAG_OPENCLOSE, TAG_NEWLINE, "type", sn_types[i].mods, NULL );
}
/* output _all_ elements of type SERIALNUMBER */
n = fields_num( f );
for ( i=0; i<n; ++i ) {
if ( f->level[i]!=level ) continue;
if ( strcasecmp( f->tag[i].data, "SERIALNUMBER" ) ) continue;
output_fil( outptr, lvl2indent(level), "identifier", f, i, TAG_OPENCLOSE, TAG_NEWLINE, "type", "serial number", NULL );
}
}
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 void
output_thesisdetails( fields *info, FILE *outptr, int type )
{
char *tag;
int i, n;
if ( type==TYPE_PHDTHESIS )
output_fixed( outptr, "b:ThesisType", "Ph.D. Thesis", 0 );
else if ( type==TYPE_MASTERSTHESIS )
output_fixed( outptr, "b:ThesisType", "Masters Thesis", 0 );
n = fields_num( info );
for ( i=0; i<n; ++i ) {
tag = fields_tag( info, i, FIELDS_CHRP );
if ( strcasecmp( tag, "DEGREEGRANTOR" ) &&
strcasecmp( tag, "DEGREEGRANTOR:ASIS") &
strcasecmp( tag, "DEGREEGRANTOR:CORP"))
continue;
output_item( info, outptr, "b:Institution", "", i, 0 );
}
}
/* 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;
}
/* 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;
}
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;
}
static void
output_names( fields *f, FILE *outptr, int level )
{
convert names[] = {
{ "author", "AUTHOR", 0, MARC_AUTHORITY },
{ "editor", "EDITOR", 0, MARC_AUTHORITY },
{ "annotator", "ANNOTATOR", 0, MARC_AUTHORITY },
{ "artist", "ARTIST", 0, MARC_AUTHORITY },
{ "author", "2ND_AUTHOR", 0, MARC_AUTHORITY },
{ "author", "3RD_AUTHOR", 0, MARC_AUTHORITY },
{ "author", "SUB_AUTHOR", 0, MARC_AUTHORITY },
{ "author", "COMMITTEE", 0, MARC_AUTHORITY },
{ "author", "COURT", 0, MARC_AUTHORITY },
{ "author", "LEGISLATIVEBODY", 0, MARC_AUTHORITY },
{ "author of afterword, colophon, etc.", "AFTERAUTHOR", 0, MARC_AUTHORITY },
{ "author of introduction, etc.", "INTROAUTHOR", 0, MARC_AUTHORITY },
{ "cartographer", "CARTOGRAPHER", 0, MARC_AUTHORITY },
{ "collaborator", "COLLABORATOR", 0, MARC_AUTHORITY },
{ "commentator", "COMMENTATOR", 0, MARC_AUTHORITY },
{ "compiler", "COMPILER", 0, MARC_AUTHORITY },
{ "degree grantor", "DEGREEGRANTOR", 0, MARC_AUTHORITY },
{ "director", "DIRECTOR", 0, MARC_AUTHORITY },
{ "event", "EVENT", 0, NO_AUTHORITY },
{ "inventor", "INVENTOR", 0, MARC_AUTHORITY },
{ "organizer of meeting", "ORGANIZER", 0, MARC_AUTHORITY },
{ "patent holder", "ASSIGNEE", 0, MARC_AUTHORITY },
{ "performer", "PERFORMER", 0, MARC_AUTHORITY },
{ "producer", "PRODUCER", 0, MARC_AUTHORITY },
{ "recipient", "RECIPIENT", 0, MARC_AUTHORITY },
{ "redactor", "REDACTOR", 0, MARC_AUTHORITY },
{ "reporter", "REPORTER", 0, MARC_AUTHORITY },
{ "sponsor", "SPONSOR", 0, MARC_AUTHORITY },
{ "translator", "TRANSLATOR", 0, MARC_AUTHORITY },
{ "writer", "WRITER", 0, MARC_AUTHORITY },
};
int i, n, nfields, ntypes = sizeof( names ) / sizeof( convert );
int f_asis, f_corp, f_conf;
newstr role;
newstr_init( &role );
nfields = fields_num( f );
for ( n=0; n<ntypes; ++n ) {
for ( i=0; i<nfields; ++i ) {
if ( fields_level( f, i )!=level ) continue;
if ( f->data[i].len==0 ) continue;
f_asis = f_corp = f_conf = 0;
newstr_strcpy( &role, f->tag[i].data );
if ( newstr_findreplace( &role, ":ASIS", "" )) f_asis=1;
if ( newstr_findreplace( &role, ":CORP", "" )) f_corp=1;
if ( newstr_findreplace( &role, ":CONF", "" )) f_conf=1;
if ( strcasecmp( role.data, names[n].internal ) )
continue;
if ( f_asis ) {
output_tag( outptr, lvl2indent(level), "name", NULL, TAG_OPEN, TAG_NEWLINE, NULL );
output_fil( outptr, lvl2indent(incr_level(level,1)), "namePart", f, i, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
} else if ( f_corp ) {
output_tag( outptr, lvl2indent(level), "name", NULL, TAG_OPEN, TAG_NEWLINE, "type", "corporate", NULL );
output_fil( outptr, lvl2indent(incr_level(level,1)), "namePart", f, i, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
} else if ( f_conf ) {
output_tag( outptr, lvl2indent(level), "name", NULL, TAG_OPEN, TAG_NEWLINE, "type", "conference", NULL );
output_fil( outptr, lvl2indent(incr_level(level,1)), "namePart", f, i, TAG_OPENCLOSE, TAG_NEWLINE, NULL );
} else {
output_name(outptr, f->data[i].data, level);
}
output_tag( outptr, lvl2indent(incr_level(level,1)), "role", NULL, TAG_OPEN, TAG_NEWLINE, NULL );
if ( names[n].code & MARC_AUTHORITY )
output_tag( outptr, lvl2indent(incr_level(level,2)), "roleTerm", names[n].mods, TAG_OPENCLOSE, TAG_NEWLINE, "authority", "marcrelator", "type", "text", NULL );
else
output_tag( outptr, lvl2indent(incr_level(level,2)), "roleTerm", names[n].mods, TAG_OPENCLOSE, TAG_NEWLINE, "type", "text", NULL );
output_tag( outptr, lvl2indent(incr_level(level,1)), "role", NULL, TAG_CLOSE, TAG_NEWLINE, NULL );
output_tag( outptr, lvl2indent(level), "name", NULL, TAG_CLOSE, TAG_NEWLINE, NULL );
fields_setused( f, i );
}
}
newstr_free( &role );
}
