source: downloads/boost_1_33_1/tools/build/jam_src/hcache.c @ 12

/*
 * This file has been donated to Jam.
 */

# include "jam.h"
# include "lists.h"
# include "parse.h"
# include "rules.h"
# include "regexp.h"
# include "headers.h"
# include "newstr.h"
# include "hash.h"
# include "hcache.h"
# include "variable.h"
# include "search.h"

#ifdef OPT_HEADER_CACHE_EXT

/*
 * Craig W. McPheeters, Alias|Wavefront.
 *
 * hcache.c hcache.h - handle cacheing of #includes in source files
 *
 * Create a cache of files scanned for headers.  When starting jam,
 * look for the cache file and load it if present.  When finished the
 * binding phase, create a new header cache.  The cache contains
 * files, their timestamps and the header files found in their scan.
 * During the binding phase of jam, look in the header cache first for
 * the headers contained in a file.  If the cache is present and
 * valid, use its contents.  This results in dramatic speedups with
 * large projects (eg. 3min -> 1min startup for one project.)
 *
 * External routines:
 *    hcache_init() - read and parse the local .jamdeps file.
 *    hcache_done() - write a new .jamdeps file
 *    hcache() - return list of headers on target.  Use cache or do a scan.
 *    
 * The dependency file format is an ascii file with 1 line per target.
 * Each line has the following fields:
 * @boundname@ timestamp @file@ @file@ @file@ ... \n
 * */

struct hcachedata {
    char                *boundname;
    time_t              time;
    LIST                *includes;
    LIST                *hdrscan; /* the HDRSCAN value for this target */
    int                 age;    /* if too old, we'll remove it from cache */
    struct hcachedata   *next;
} ;

typedef struct hcachedata HCACHEDATA ;


static struct hash *hcachehash = 0;
static HCACHEDATA  *hcachelist = 0; 

static int queries = 0;
static int hits = 0;

#define CACHE_FILE_VERSION "version 4"
#define CACHE_RECORD_HEADER "header"
#define CACHE_RECORD_END "end"

/*
 * Return the name of the header cache file.  May return NULL.
 *
 * The user sets this by setting the HCACHEFILE variable in a Jamfile.
 * We cache the result so the user can't change the cache file during
 * header scanning.
 */
static char*
cache_name(void)
{
    static char* name = 0;
    if (!name) {
        LIST *hcachevar = var_get("HCACHEFILE");

        if (hcachevar) {
            TARGET *t = bindtarget( hcachevar->string );

            pushsettings( t->settings );
        /* Don't expect cache file to be generated, so pass 0
           as third argument to search. */
            t->boundname = search( t->name, &t->time, 0 );
            popsettings( t->settings );

            if (hcachevar) {
                name = copystr(t->boundname);
            }
        }
    }
    return name;
}

/*
 * Return the maximum age a cache entry can have before it is purged
 * from the cache.
 */
static int
cache_maxage(void)
{
    int age = 100;
    LIST *var = var_get("HCACHEMAXAGE");

    if (var) {
        age = atoi(var->string);
        if (age < 0)
            age = 0;
    }

    return age;
}

/*
 * Read a netstring.  The caveat is that the string can't contain
 * ASCII 0.  The returned value is as returned by newstr(), so it need
 * not be freed.
 */
char*
read_netstring(FILE* f)
{
    unsigned long len;
    static char* buf = NULL;
    static unsigned long buf_len = 0;

    if (fscanf(f, " %9lu", &len) != 1)
        return NULL;
    if (fgetc(f) != (int)'\t')
        return NULL;

    if (len > 1024 * 64)
        return NULL;            /* sanity check */

    if (len > buf_len)
    {
        unsigned long new_len = buf_len * 2;
        if (new_len < len)
            new_len = len;
        buf = (char*)realloc(buf, new_len + 1);
        if (buf)
            buf_len = new_len;
    }

    if (!buf)
        return NULL;

    if (fread(buf, 1, len, f) != len)
        return NULL;
    if (fgetc(f) != (int)'\n')
        return NULL;

    buf[len] = 0;
    return newstr(buf);
}

/*
 * Write a netstring.
 */
void
write_netstring(FILE* f, const char* s)
{
    if (!s)
        s = "";
    fprintf(f, "%lu\t%s\n", strlen(s), s);
}

void
hcache_init()
{
    HCACHEDATA  cachedata, *c;
    FILE        *f;
    char        *version;
    int         header_count = 0;
    char*       hcachename;

    hcachehash = hashinit (sizeof (HCACHEDATA), "hcache");

    if (! (hcachename = cache_name()))
        return;

    if (! (f = fopen (hcachename, "rb" )))
        return;
    
    version = read_netstring(f);
    if (!version || strcmp(version, CACHE_FILE_VERSION)) {
        fclose(f);
        return;
    }

    while (1)
    {
        char* record_type;
        char *time_str;
        char *age_str;
        char *includes_count_str;
        char *hdrscan_count_str;
        int i, count;
        LIST *l;

        record_type = read_netstring(f);
        if (!record_type) {
            fprintf(stderr, "invalid %s\n", hcachename);
            goto bail;
        }
        if (!strcmp(record_type, CACHE_RECORD_END)) {
            break;
        }
        if (strcmp(record_type, CACHE_RECORD_HEADER)) {
            fprintf(stderr, "invalid %s with record separator <%s>\n",
                    hcachename, record_type ? record_type : "<null>");
            goto bail;
        }
        
        c = &cachedata;
            
        c->boundname = read_netstring(f);
        time_str = read_netstring(f);
        age_str = read_netstring(f);
        includes_count_str = read_netstring(f);
        
        if (!c->boundname || !time_str || !age_str
            || !includes_count_str)
        {
            fprintf(stderr, "invalid %s\n", hcachename);
            goto bail;
        }

        c->time = atoi(time_str);
        c->age = atoi(age_str) + 1;

        count = atoi(includes_count_str);
        for (l = 0, i = 0; i < count; i++) {
            char* s = read_netstring(f);
            if (!s) {
                fprintf(stderr, "invalid %s\n", hcachename);
                goto bail;
            }
            l = list_new(l, s);
        }
        c->includes = l;

        hdrscan_count_str = read_netstring(f);
        if (!includes_count_str) {
            list_free(c->includes);
            fprintf(stderr, "invalid %s\n", hcachename);
            goto bail;
        }

        count = atoi(hdrscan_count_str);
        for (l = 0, i = 0; i < count; i++) {
            char* s = read_netstring(f);
            if (!s) {
                fprintf(stderr, "invalid %s\n", hcachename);
                goto bail;
            }
            l = list_new(l, s);
        }
        c->hdrscan = l;

        if (!hashenter(hcachehash, (HASHDATA **)&c)) {
            fprintf(stderr, "can't insert header cache item, bailing on %s\n",
                    hcachename);
            goto bail;
        }

        c->next = hcachelist;
        hcachelist = c;

        header_count++;
    }

    if (DEBUG_HEADER) {
        printf("hcache read from file %s\n", hcachename);
    }
    
 bail:
    fclose(f);
}

void
hcache_done()
{
    FILE        *f;
    HCACHEDATA  *c;
    int         header_count = 0;
    char*       hcachename;
    int         maxage;
    
    if (!hcachehash)
        return;

    if (! (hcachename = cache_name()))
        return;

    if (! (f = fopen (hcachename, "wb" )))
        return;

    maxage = cache_maxage();

    /* print out the version */
    write_netstring(f, CACHE_FILE_VERSION);

    c = hcachelist;
    for (c = hcachelist; c; c = c->next) {
        LIST    *l;
        char time_str[30];
        char age_str[30];
        char includes_count_str[30];
        char hdrscan_count_str[30];

        if (maxage == 0)
            c->age = 0;
        else if (c->age > maxage)
            continue;

        sprintf(includes_count_str, "%lu", list_length(c->includes));
        sprintf(hdrscan_count_str, "%lu", list_length(c->hdrscan));
        sprintf(time_str, "%lu", c->time);
        sprintf(age_str, "%lu", c->age);

        write_netstring(f, CACHE_RECORD_HEADER);
        write_netstring(f, c->boundname);
        write_netstring(f, time_str);
        write_netstring(f, age_str);
        write_netstring(f, includes_count_str);
        for (l = c->includes; l; l = list_next(l)) {
            write_netstring(f, l->string);
        }
        write_netstring(f, hdrscan_count_str);
        for (l = c->hdrscan; l; l = list_next(l)) {
            write_netstring(f, l->string);
        }
        fputs("\n", f);
        header_count++;
    }
    write_netstring(f, CACHE_RECORD_END);

    if (DEBUG_HEADER) {
        printf("hcache written to %s.   %d dependencies, %.0f%% hit rate\n",
               hcachename, header_count,
               queries ? 100.0 * hits / queries : 0);
    }

    fclose (f);
}

LIST *
hcache (TARGET *t, int rec, regexp *re[], LIST *hdrscan)
{
    HCACHEDATA  cachedata, *c = &cachedata;
    LIST        *l = 0;

    ++queries;

    c->boundname = t->boundname;

    if (hashcheck (hcachehash, (HASHDATA **) &c))
    {
        if (c->time == t->time)
        {
            LIST *l1 = hdrscan, *l2 = c->hdrscan;
            while (l1 && l2) {
                if (l1->string != l2->string) {
                    l1 = NULL;
                } else {
                    l1 = list_next(l1);
                    l2 = list_next(l2);
                }
            }
            if (l1 || l2) {
                if (DEBUG_HEADER)
                    printf("HDRSCAN out of date in cache for %s\n",
                           t->boundname);

                printf("HDRSCAN out of date for %s\n", t->boundname);
                printf(" real  : ");
                list_print(hdrscan);
                printf("\n cached: ");
                list_print(c->hdrscan);
                printf("\n");

                list_free(c->includes);
                list_free(c->hdrscan);
                c->includes = 0;
                c->hdrscan = 0;
            } else {
                if (DEBUG_HEADER)
                    printf ("using header cache for %s\n", t->boundname);
                c->age = 0;
                ++hits;
                l = list_copy (0, c->includes);
                return l;
            }
        } else {
            if (DEBUG_HEADER)
                printf ("header cache out of date for %s\n", t->boundname);
            list_free (c->includes);
            list_free(c->hdrscan);
            c->includes = 0;
            c->hdrscan = 0;
        }
    } else {
        if (hashenter (hcachehash, (HASHDATA **)&c)) {
            c->boundname = newstr (c->boundname);
            c->next = hcachelist;
            hcachelist = c;
        }
    }

    /* 'c' points at the cache entry.  Its out of date. */

    l = headers1 (0, t->boundname, rec, re);

    c->time = t->time;
    c->age = 0;
    c->includes = list_copy (0, l);
    c->hdrscan = list_copy(0, hdrscan);

    return l;
}

#endif