bibtexq.c

Go to the documentation of this file.

/*
 * This work is licensed under a Creative Commons 
 * Attribution-Noncommercial-Share Alike 3.0 United States License.
 * 
 *    http://creativecommons.org/licenses/by-nc-sa/3.0/us/
 * 
 * You are free:
 * 
 *    to Share - to copy, distribute, display, and perform the work
 *    to Remix - to make derivative works
 * 
 * Under the following conditions:
 * 
 *    Attribution. You must attribute the work in the manner specified by the
 *    author or licensor (but not in any way that suggests that they endorse you
 *    or your use of the work).
 * 
 *    Noncommercial. You may not use this work for commercial purposes.
 * 
 *    Share Alike. If you alter, transform, or build upon this work, you may
 *    distribute the resulting work only under the same or similar license to
 *    this one.
 * 
 * For any reuse or distribution, you must make clear to others the license
 * terms of this work. The best way to do this is by including this header.
 * 
 * Any of the above conditions can be waived if you get permission from the
 * copyright holder.
 * 
 * Apart from the remix rights granted under this license, nothing in this
 * license impairs or restricts the author's moral rights.
 */


#include <config.h>

#include <stdlib.h>
#include <stdio.h>
#include <assert.h>
#include <errno.h>
#include <string.h>
#include <strings.h>
#include <regex.h>

#ifdef BIBTEXQ_HAVE_DMALLOC
#include <dmalloc.h>
#endif

#include <jwsc/base/option.h>
#include <jwsc/base/error.h>

#include "bibtex_entry.h"


#define  NUM_OPTS_NO_ARG    2
#define  NUM_OPTS_WITH_ARG  8


extern FILE* yyin;
extern int yyparse();


Bibtex_entry* entry = NULL;


static Option_no_arg opts_no_arg[NUM_OPTS_NO_ARG];

static Option_with_arg opts_with_arg[NUM_OPTS_WITH_ARG];

static const char* output_fname;

static FILE* output_fp;

static uint8_t query_type;

static uint8_t query_key;

static uint8_t query_author;

static uint8_t query_title;

static uint8_t query_project;

static uint8_t query_venue;

static uint8_t query_keyword;

static regex_t type_preg;

static regex_t key_preg;

static regex_t author_preg;

static regex_t title_preg;

static regex_t project_preg;

static regex_t venue_preg;

static regex_t keyword_preg;


static Error* init_regex(const char* value, regex_t* preg)
{
    int  errcode;
    char errbuf[256] = {0};

    if ((errcode = regcomp(preg, value, REG_EXTENDED | REG_ICASE | REG_NOSUB)))
    {
        regerror(errcode, preg, errbuf, 255);
        return JWSC_EARG(errbuf);
    }
    return NULL;
}

static void print_usage(void)
{
    fprintf(stderr, "usage: bibtexq OPTIONS <file.bib>\n");
    print_options(stderr, 25, NUM_OPTS_NO_ARG, opts_no_arg, NUM_OPTS_WITH_ARG,
            opts_with_arg);
}

static Error* process_help_opt(void)
{
    print_usage();
    exit(EXIT_SUCCESS);
    return NULL;
}

static Error* process_version_opt(void)
{
    fprintf(stderr, "%s\n", BIBTEXQ_PACKAGE_STRING);
    exit(EXIT_SUCCESS);
    return NULL;
}

static Error* process_output_opt(Option_arg arg)
{
    if (arg == NULL)
    {
        return JWSC_EARG("Option 'output' requires an argument");
    }
    output_fname = arg;
    return NULL;
}

static Error* process_type_opt(Option_arg arg)
{
    Error* e;

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'type' requires an argument");
    }
    if ((e = init_regex(arg, &type_preg)))
    {
        return e;
    }
    query_type = 1;
    return NULL;
}

static Error* process_key_opt(Option_arg arg)
{
    Error* e;

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'key' requires an argument");
    }
    if ((e = init_regex(arg, &key_preg)))
    {
        return e;
    }
    query_key = 1;
    return NULL;
}

static Error* process_author_opt(Option_arg arg)
{
    Error* e;

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'author' requires an argument");
    }
    if ((e = init_regex(arg, &author_preg)))
    {
        return e;
    }
    query_author = 1;
    return NULL;
}

static Error* process_title_opt(Option_arg arg)
{
    Error* e;

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'title' requires an argument");
    }
    if ((e = init_regex(arg, &title_preg)))
    {
        return e;
    }
    query_title = 1;
    return NULL;
}

static Error* process_project_opt(Option_arg arg)
{
    Error* e;

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'project' requires an argument");
    }
    if ((e = init_regex(arg, &project_preg)))
    {
        return e;
    }
    query_project = 1;
    return NULL;
}

static Error* process_venue_opt(Option_arg arg)
{
    Error* e;

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'venue' requires an argument");
    }
    if ((e = init_regex(arg, &venue_preg)))
    {
        return e;
    }
    query_venue = 1;
    return NULL;
}

static Error* process_keyword_opt(Option_arg arg)
{
    Error* e;

    if (arg == NULL)
    {
        return JWSC_EARG("Option 'keyword' requires an argument");
    }
    if ((e = init_regex(arg, &keyword_preg)))
    {
        return e;
    }
    query_keyword = 1;
    return NULL;
}

static void init_options(void)
{
    uint32_t i;

    i = 0;
    init_option_no_arg(&(opts_no_arg[i++]), "help", 'h', 
            "Prints program usage.", process_help_opt);
    init_option_no_arg(&(opts_no_arg[i++]), "version", 'v', 
            "Prints program version.", process_version_opt);

    i = 0;
    init_option_with_arg(&(opts_with_arg[i++]), "output", 'o',
            "File to write the queried entries to. Default is to use stdout.", 
            process_output_opt);
    init_option_with_arg(&(opts_with_arg[i++]), "type", '\0',
            "Entry type regular expression.", process_type_opt);
    init_option_with_arg(&(opts_with_arg[i++]), "key", '\0',
            "Unique entry key regular expression.", process_key_opt);
    init_option_with_arg(&(opts_with_arg[i++]), "author", '\0',
            "Author field regular expression.", process_author_opt);
    init_option_with_arg(&(opts_with_arg[i++]), "title", '\0',
            "Title field regular expression.", process_title_opt);
    init_option_with_arg(&(opts_with_arg[i++]), "project", '\0',
            "Project field regular expression.", process_project_opt);
    init_option_with_arg(&(opts_with_arg[i++]), "venue", '\0',
            "Venue field regular expression.", process_venue_opt);
    init_option_with_arg(&(opts_with_arg[i++]), "keyword", '\0',
            "Keyword field regular expression.", process_keyword_opt);
}



void query_bibtex_entry(Bibtex_entry* entry)
{
    uint32_t      i;
    uint8_t       match;
    uint8_t       queried_author;
    uint8_t       queried_title;
    uint8_t       queried_project;
    uint8_t       queried_venue;
    uint8_t       queried_keyword;
    Bibtex_field* field;

    match = 1;
    queried_author  = 0;
    queried_title   = 0;
    queried_project = 0;
    queried_venue   = 0;
    queried_keyword = 0;

    if (match && query_type)
    { 
        if (regexec(&type_preg, entry->type, 0, 0, 0) 
                == REG_NOMATCH)
        {
            match = 0;
        }
    }

    if (match && query_key)
    { 
        if (regexec(&key_preg, entry->key, 0, 0, 0) 
                == REG_NOMATCH)
        {
            match = 0;
        }
    }

    for (i = 0; match && i < entry->num_fields; i++)
    {
        field = entry->fields[ i ];

        if (match && query_author && strcasecmp(field->name, "author") == 0)
        {
            queried_author = 1;
            if (regexec(&author_preg, (const char*)field->value, 
                        0, 0, 0) == REG_NOMATCH)
            {
                match = 0;
            }
        }

        if (match && query_title && strcasecmp(field->name, "title") == 0)
        {
            queried_title = 1;
            if (regexec(&title_preg, (const char*)field->value, 
                        0, 0, 0) == REG_NOMATCH)
            {
                match = 0;
            }
        }

        if (match && query_project && strcasecmp(field->name, "projects") == 0)
        {
            queried_project = 1;
            if (regexec(&project_preg, (const char*)field->value, 
                        0, 0, 0) == REG_NOMATCH)
            {
                match = 0;
            }
        }

        if (match && query_venue && strcasecmp(field->name, "venue") == 0)
        {
            queried_venue = 1;
            if (regexec(&venue_preg, (const char*)field->value, 
                        0, 0, 0) == REG_NOMATCH)
            {
                match = 0;
            }
        }

        if (match && query_keyword && strcasecmp(field->name, "keywords") == 0)
        {
            queried_keyword = 1;
            if (regexec(&keyword_preg, (const char*)field->value, 
                        0, 0, 0) == REG_NOMATCH)
            {
                match = 0;
            }
        }
    }

    if ((query_author   &&  !queried_author ) ||
        (query_title    &&  !queried_title  ) ||
        (query_project  &&  !queried_project) ||
        (query_venue    &&  !queried_venue  ) ||
        (query_keyword  &&  !queried_keyword))
    {
        match = 0;
    }

    if (match)
    {
        write_bibtex_entry(entry, output_fp);
    }
}



int main(int argc, const char** argv)
{
    int         argi;
    const char* bibtex_fname;
    Error*      e;

    init_options();

    output_fp     = stdout;
    query_type    = 0;
    query_key     = 0;
    query_author  = 0;
    query_title   = 0;
    query_project = 0;
    query_venue   = 0;
    query_keyword = 0;

    if ((e = process_options(argc, argv, &argi, NUM_OPTS_NO_ARG, opts_no_arg,
                    NUM_OPTS_WITH_ARG, opts_with_arg)) != NULL)
    {
        print_error_msg_exit("bibtexq", e->msg);
    }

    if (output_fname && (output_fp = fopen(output_fname, "w")) == NULL)
    {
        print_error_msg("bibtexq", NULL);
        print_error_msg_exit(output_fname, strerror(errno));
    }

    if ((argc - argi) < 1)
    {
        print_error_msg_exit("bibtexq", "No BIBTEX file to query");
    }
    bibtex_fname = argv[ argi ];

    if ((yyin = fopen(bibtex_fname, "r")) == NULL)
    {
        print_error_msg("bibtexq", NULL);
        print_errno_exit(bibtex_fname);
    }

    yyparse();

    if (output_fp != stdout)
    {
        if (fclose(output_fp) != 0)
        {
            print_error_msg("bibtexq", NULL);
            print_errno_exit("output file");
        }
    }

    fclose(yyin);

    free_bibtex_entry(entry);

    return EXIT_SUCCESS;
}