fname.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 <jwsc/config.h>

#include <stdlib.h>
#include <string.h>
#include <assert.h>
#include <inttypes.h>

#include "jwsc/base/fname.h"

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


static const char* last_occurrence(const char* fname, char c)
{
    int len = strlen(fname);
    const char* fptr = fname+len-1;

    if (len == 1 && *fptr == c)
    {
        return fptr;
    }

    while (fptr != fname && *fptr != c)
    {
        fptr--;
    }

    if (fptr == fname && *fptr != c)
    {
        return 0;
    }

    return fptr;
}


int fname_has_suffix(const char* fname, const char* suffix)
{
    char* fsuffix = NULL;
    int len = strlen(suffix);
    int rval = 0;

    if ((fsuffix = get_fname_suffix(fname)))
    {
        rval = (strncmp(fsuffix, suffix, len) == 0);
    }

    free(fsuffix);
    return rval;
}


char* get_fname_suffix(const char* fname)
{
    const char* fsuffix;
    char*       suffix;

    if ((fsuffix = last_occurrence(fname, '.')) == 0)
    {
        return 0;
    }

    fsuffix++;

    suffix = malloc((strlen(fsuffix)+1)*sizeof(char));
    strcpy(suffix, fsuffix);

    return suffix;
}


char* get_fname_dir(const char* fname)
{
    uint32_t    len = strlen(fname);
    const char* fdir;
    char*       dir;

    /* remove any trailing slashes and try again */
    if (len > 1 && fname[ len-1 ] == '/')
    {
        char* dir2 = malloc(len*sizeof(char));
        strncpy(dir2, fname, len);
        dir2[len-1]='\0';
        dir = get_fname_dir(dir2);
        free(dir2);
        return dir;
    }

    /* copy file directory name */
    fdir = last_occurrence(fname, '/');
    len = fdir - fname;

    if (fdir == 0)
    {
        fname = ".";
        len = 1;
    }
    else if (len == 0)
    {
        fname = "/";
        len = 1;
    }

    dir = malloc((len+1)*sizeof(char));
    strncpy(dir, fname, len);
    dir[len]='\0';

    return dir;
}


char* get_fname_base(const char* fname)
{
    uint32_t    len = strlen(fname);
    const char* fbase;
    char*       base;

    /* remove any trailing slashes and try again */
    if (len > 1 && fname[ len-1 ] == '/')
    {
        char* base2 = malloc(len*sizeof(char));
        strncpy(base2, fname, len);
        base2[len-1]='\0';
        base = get_fname_base(base2);
        free(base2);
        return base;
    }

    /* copy file base name */
    fbase = last_occurrence(fname, '/');

    if (fbase == 0 || len == 1)
    {
        fbase = fname;
        len = strlen(fname);
    }
    else
    {
        fbase++;
    }

    base = malloc((strlen(fbase)+1)*sizeof(char));
    strcpy(base, fbase);

    return base;
}