bibtex_entry.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 <inttypes.h>
#include <string.h>
#include <assert.h>
#include <ctype.h>

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

#include "bibtex_entry.h"


static void remove_extra_spaces(char* str)
{
    char* chars;
    char* chars_shift;
    char  prev_char;
    int   len;

    chars = str;

    if (len == 0)
    {
        return;
    }
    else if (len == 1 && isspace(*chars))
    {
        *chars = '\0';
        return;
    }

    while (*chars != '\0')
    {
        if (*chars == '\n' || *chars == '\t')
        {
            chars_shift = chars;
            while (*chars_shift != '\0')
            {
                *chars_shift = *(chars_shift+1);
                chars_shift++;
            }
        }
        else
        {
            chars++;
        }
    }

    chars = str;
    prev_char = '\0';
    while (*chars != '\0')
    {
        if (prev_char == ' ' && *chars == ' ')
        {
            chars_shift = chars;
            while (*chars_shift != '\0')
            {
                *chars_shift = *(chars_shift+1);
                chars_shift++;
            }
        }
        else
        {
            prev_char = *chars;
            chars++;
        }
    }
}


static void create_bibtex_field
(
    Bibtex_field** field_out, 
    const char*    name, 
    const char*    value
)
{
    Bibtex_field* field;

    if (*field_out == NULL)
    {
        assert(*field_out = malloc(sizeof(Bibtex_field)));
        (*field_out)->name = NULL;
        (*field_out)->value = NULL;
    }
    field = *field_out;

    field->name = malloc(sizeof(char)*strlen(name));
    field->value = malloc(sizeof(char)*strlen(value));

    strcpy(field->name, name);
    strcpy(field->value, value);

    remove_extra_spaces(field->name);
    remove_extra_spaces(field->value);
}


static void free_bibtex_fields(Bibtex_field** fields, uint32_t num_fields)
{
    uint32_t i;

    if (fields == NULL || num_fields == 0)
        return;

    for (i = 0; i < num_fields; i++)
    {
        free(fields[ i ]->name);
        free(fields[ i ]->value);
        free(fields[ i ]);
    }
    free(fields);
}




void create_bibtex_entry
(
    Bibtex_entry** entry_out, 
    const char*    type, 
    const char*    key
)
{
    Bibtex_entry* entry;

    if (*entry_out == NULL)
    {
        assert(*entry_out = malloc(sizeof(Bibtex_entry)));
        (*entry_out)->type = NULL;
        (*entry_out)->key = NULL;
        (*entry_out)->fields = NULL;
        (*entry_out)->num_fields = 0;
        (*entry_out)->num_unused_fields = 0;
    }
    else
    {
        (*entry_out)->num_unused_fields += (*entry_out)->num_fields;
        (*entry_out)->num_fields = 0;
    }
    entry = *entry_out;

    entry->type = malloc(sizeof(char)*strlen(type));
    entry->key = malloc(sizeof(char)*strlen(key));

    strcpy(entry->type, type);
    strcpy(entry->key, key);
}


void free_bibtex_entry(Bibtex_entry* entry)
{
    if (entry == NULL)
        return;

    free_bibtex_fields(entry->fields, entry->num_fields + 
            entry->num_unused_fields);
    free(entry->type);
    free(entry->key);
    free(entry);
}


void add_field_to_bibtex_entry
(
    Bibtex_entry* entry,
    const char*   name,
    const char*   value
)
{
    Bibtex_field* field = NULL;

    if (entry->num_unused_fields > 0)
    {
        entry->num_unused_fields--;
        entry->num_fields++;;
        field = entry->fields[ entry->num_fields-1 ];
    }
    else
    {
        entry->num_fields++;
        assert(entry->fields = realloc(entry->fields, 
                entry->num_fields*sizeof(Bibtex_field*)));
    }

    create_bibtex_field(&field, name, value);
    entry->fields[ entry->num_fields-1 ] = field;
}


void write_bibtex_entry(Bibtex_entry* entry, FILE* fp)
{
    uint32_t i;

    fprintf(fp, "@%s{%s", entry->type, entry->key);

    for (i = 0; i < entry->num_fields; i++)
    {
        fprintf(fp, ",\n    %*s = {%s}", 10, 
                entry->fields[ i ]->name, entry->fields[ i ]->value);
    }

    fprintf(fp, "\n}\n");
}