OpenGrok

/*-
 * Copyright (c) 2010 The NetBSD Foundation, Inc.
 * All rights reserved.
 *
 * This code is derived from software contributed to The NetBSD Foundation
 * by David A. Holland.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
 * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
 * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
 * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
 * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
 * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
 * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
 * POSSIBILITY OF SUCH DAMAGE.
 */

#include <assert.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>

#include "utils.h"
#include "array.h"
#include "place.h"

struct placefile {
	struct place includedfrom;
	char *dir;
	char *name;
	int depth;
	bool fromsystemdir;
};
DECLARRAY(placefile, static UNUSED);
DEFARRAY(placefile, static);

static struct placefilearray placefiles;
static bool overall_failure;

static const char *myprogname;

static FILE *debuglogfile;

////////////////////////////////////////////////////////////
// placefiles

static
struct placefile *
placefile_create(const struct place *from, const char *name,
		 bool fromsystemdir)
{
	struct placefile *pf;
	const char *s;
	size_t len;

	pf = domalloc(sizeof(*pf));
	pf->includedfrom = *from;

	s = strrchr(name, '/');
	len = (s == NULL) ? 0 : s - name;
	pf->dir = dostrndup(name, len);

	pf->name = dostrdup(name);
	pf->fromsystemdir = fromsystemdir;

	if (from->file != NULL) {
		pf->depth = from->file->depth + 1;
	} else {
		pf->depth = 1;
	}
	return pf;
}

static
void
placefile_destroy(struct placefile *pf)
{
	dostrfree(pf->name);
	dofree(pf, sizeof(*pf));
}

DESTROYALL_ARRAY(placefile, );

const char *
place_getparsedir(const struct place *place)
{
	if (place->file == NULL) {
		return ".";
	}
	return place->file->dir;
}

static
struct placefile *
placefile_find(const struct place *incfrom, const char *name)
{
	unsigned i, num;
	struct placefile *pf;

	num = placefilearray_num(&placefiles);
	for (i=0; i<num; i++) {
		pf = placefilearray_get(&placefiles, i);
		if (place_eq(incfrom, &pf->includedfrom) &&
		    !strcmp(name, pf->name)) {
			return pf;
		}
	}
	return NULL;
}

void
place_changefile(struct place *p, const char *name)
{
	struct placefile *pf;

	assert(p->type == P_FILE);
	if (!strcmp(name, p->file->name)) {
		return;
	}
	pf = placefile_find(&p->file->includedfrom, name);
	if (pf == NULL) {
		pf = placefile_create(&p->file->includedfrom, name,
				      p->file->fromsystemdir);
		placefilearray_add(&placefiles, pf, NULL);
	}
	p->file = pf;
}

const struct placefile *
place_addfile(const struct place *place, const char *file, bool issystem)
{
	struct placefile *pf;

	pf = placefile_create(place, file, issystem);
	placefilearray_add(&placefiles, pf, NULL);
	if (pf->depth > 120) {
		complain(place, "Maximum include nesting depth exceeded");
		die();
	}
	return pf;
}

////////////////////////////////////////////////////////////
// places

void
place_setnowhere(struct place *p)
{
	p->type = P_NOWHERE;
	p->file = NULL;
	p->line = 0;
	p->column = 0;
}

void
place_setbuiltin(struct place *p, unsigned num)
{
	p->type = P_BUILTIN;
	p->file = NULL;
	p->line = num;
	p->column = 1;
}

void
place_setcommandline(struct place *p, unsigned line, unsigned column)
{
	p->type = P_COMMANDLINE;
	p->file = NULL;
	p->line = line;
	p->column = column;
}

void
place_setfilestart(struct place *p, const struct placefile *pf)
{
	p->type = P_FILE;
	p->file = pf;
	p->line = 1;
	p->column = 1;
}

void
place_addcolumns(struct place *p, unsigned cols)
{
	unsigned newcol;

	newcol = p->column + cols;
	if (newcol < p->column) {
		/* overflow (use the old place to complain) */
		complain(p, "Column numbering overflow");
		die();
	}
	p->column = newcol;
}

void
place_addlines(struct place *p, unsigned lines)
{
	unsigned nextline;

	nextline = p->line + lines;
	if (nextline < p->line) {
		/* overflow (use the old place to complain) */
		complain(p, "Line numbering overflow");
		die();
	}
	p->line = nextline;
}

const char *
place_getname(const struct place *p)
{
	switch (p->type) {
	    case P_NOWHERE: return "<nowhere>";
	    case P_BUILTIN: return "<built-in>";
	    case P_COMMANDLINE: return "<command-line>";
	    case P_FILE: return p->file->name;
	}
	assert(0);
	return NULL;
}

bool
place_samefile(const struct place *a, const struct place *b)
{
	if (a->type != b->type) {
		return false;
	}
	if (a->file != b->file) {
		return false;
	}
	return true;
}

bool
place_eq(const struct place *a, const struct place *b)
{
	if (!place_samefile(a, b)) {
		return false;
	}
	if (a->line != b->line || a->column != b->column) {
		return false;
	}
	return true;
}

static
void
place_printfrom(const struct place *p)
{
	const struct place *from;

	if (p->file == NULL) {
		return;
	}
	from = &p->file->includedfrom;
	if (from->type != P_NOWHERE) {
		place_printfrom(from);
		fprintf(stderr, "In file included from %s:%u:%u:\n",
			place_getname(from), from->line, from->column);
	}
}

////////////////////////////////////////////////////////////
// complaints

void
complain_init(const char *pn)
{
	myprogname = pn;
}

void
complain(const struct place *p, const char *fmt, ...)
{
	va_list ap;

	if (p != NULL) {
		place_printfrom(p);
		fprintf(stderr, "%s:%u:%u: ", place_getname(p),
			p->line, p->column);
	} else {
		fprintf(stderr, "%s: ", myprogname);
	}
	va_start(ap, fmt);
	vfprintf(stderr, fmt, ap);
	va_end(ap);
	fprintf(stderr, "\n");
}

void
complain_fail(void)
{
	overall_failure = true;
}

bool
complain_failed(void)
{
	return overall_failure;
}

////////////////////////////////////////////////////////////
// debug logging

void
debuglog_open(const struct place *p, /*const*/ char *file)
{
	assert(debuglogfile == NULL);
	debuglogfile = fopen(file, "w");
	if (debuglogfile == NULL) {
		complain(p, "%s: %s", file, strerror(errno));
		die();
	}
}

void
debuglog_close(void)
{
	if (debuglogfile != NULL) {
		fclose(debuglogfile);
		debuglogfile = NULL;
	}
}

PF(2, 3) void
debuglog(const struct place *p, const char *fmt, ...)
{
	va_list ap;

	if (debuglogfile == NULL) {
		return;
	}

	fprintf(debuglogfile, "%s:%u: ", place_getname(p), p->line);
	va_start(ap, fmt);
	vfprintf(debuglogfile, fmt, ap);
	va_end(ap);
	fprintf(debuglogfile, "\n");
	fflush(debuglogfile);
}

PF(3, 4) void
debuglog2(const struct place *p, const struct place *p2, const char *fmt, ...)
{
	va_list ap;

	if (debuglogfile == NULL) {
		return;
	}

	fprintf(debuglogfile, "%s:%u: ", place_getname(p), p->line);
	if (place_samefile(p, p2)) {
		fprintf(debuglogfile, "(block began at line %u) ",
			p2->line);
	} else {
		fprintf(debuglogfile, "(block began at %s:%u)",
			place_getname(p2), p2->line);
	}
	va_start(ap, fmt);
	vfprintf(debuglogfile, fmt, ap);
	va_end(ap);
	fprintf(debuglogfile, "\n");
	fflush(debuglogfile);
}

////////////////////////////////////////////////////////////
// module init and cleanup

void
place_init(void)
{
	placefilearray_init(&placefiles);
}

void
place_cleanup(void)
{
	placefilearray_destroyall(&placefiles);
	placefilearray_cleanup(&placefiles);
}