OpenGrok

/*
 * Copyright (c) 1984 through 2008, William LeFebvre
 * All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions are met:
 *
 *     * Redistributions of source code must retain the above copyright
 * notice, this list of conditions and the following disclaimer.
 *
 *     * 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.
 *
 *     * Neither the name of William LeFebvre nor the names of other
 * contributors may be used to endorse or promote products derived from
 * this software without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS 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 COPYRIGHT
 * OWNER 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.
 */

/*
 *  Top users/processes display for Unix
 *  Version 3
 */

/*
 * This file handles color definitions and access for augmenting
 * the output with ansi color sequences.
 *
 * The definition of a color setting is as follows, separated by
 * colons:
 *
 * tag=minimum,maximum#code
 *
 * "tag" is the name of the value to display with color.
 *
 * "minimum" and "maximum" are positive integer values defining a range:
 * when the value is within this range it will be shown with the
 * specified color.  A missing value indicates that no check should be
 * made (i.e.: ",25" is n <= 25; "25,50" is 25 <= n <= 50; and "50,"
 * is 50 <= n).
 *
 * "code" is the ansi sequence that defines the color to use with the
 * escape sequence "[m".  Semi-colons are allowed in this string to
 * combine attributes.
 */

#include "os.h"
#include "display.h"
#include "message.h"
#include "color.h"
#include "utils.h"

typedef struct color_entry {
    char *tag;
    int min;
    int max;
    char color;
    struct color_entry *next;
    struct color_entry *tagnext;
} color_entry;

static color_entry *entries = NULL;

static color_entry **bytag = NULL;
static char **bytag_names = NULL;
static int totaltags = 0;
static int tagcnt = 0;
static int color_off = 0;

static char **color_ansi = NULL;
static int num_color_ansi = 0;
static int max_color_ansi = 0;

static int
color_slot(const char *str)

{
    int i;

    for (i = 0; i < num_color_ansi; i++)
    {
	if (strcmp(color_ansi[i], str) == 0)
	{
	    return i;
	}
    }

    /* need a new slot */
    if (num_color_ansi >= max_color_ansi)
    {
	max_color_ansi += COLOR_ANSI_SLOTS;
	color_ansi = erealloc(color_ansi, max_color_ansi * sizeof(char *));
    }
    color_ansi[num_color_ansi] = estrdup(str);
    return num_color_ansi++;
}

/*
 * int color_env_parse(char *env)
 *
 * Parse a color specification "env" (such as one found in the environment) and
 * add them to the list of entries.  Always returns 0.  Should only be called
 * once.
 */

int
color_env_parse(char *env)

{
    char *p;
    char *min;
    char *max;
    char *str;
    int len;
    color_entry *ce;

    /* initialization */
    color_ansi = emalloc(COLOR_ANSI_SLOTS * sizeof(char *));
    max_color_ansi = COLOR_ANSI_SLOTS;

    /* color slot 0 is always "0" */
    color_slot("0");

    if (env != NULL)
    {
	p = strtok(env, ":");
	while (p != NULL)
	{
	    if ((min = strchr(p, '=')) != NULL &&
		(max = strchr(min, ',')) != NULL &&
		(str = strchr(max, '#')) != NULL)
	    {
		ce = emalloc(sizeof(color_entry));
		len = min - p;
		ce->tag = emalloc(len + 1);
		strncpy(ce->tag, p, len);
		ce->tag[len] = '\0';
		ce->min = atoi(++min);
		ce->max = atoi(++max);
		ce->color = color_slot(++str);
		ce->next = entries;
		entries = ce;
	    }
	    else
	    {
		if (min != NULL)
		{
		    len = min - p;
		}
		else
		{
		    len = strlen(p);
		}
		message_error(" %.*s: bad color entry", len, p);
	    }
	    p = strtok(NULL, ":");
	}
    }
    return 0;
}

/*
 * int color_tag(char *tag)
 *
 * Declare "tag" as a color tag.  Return a tag index to use when testing
 * a value against the tests for this tag.  Should not be called before
 * color_env_parse.
 */

int
color_tag(const char *tag)

{
    color_entry *entryp;
    color_entry *tp;

    /* check for absurd arguments */
    if (tag == NULL || *tag == '\0')
    {
	return -1;
    }

    dprintf("color_tag(%s)\n", tag);

    /* initial allocation */
    if (bytag == NULL)
    {
	totaltags = 10;
	bytag = emalloc(totaltags * sizeof(color_entry *));
	bytag_names = emalloc(totaltags * sizeof(char *));
    }

    /* if we dont have enough room then reallocate */
    if (tagcnt >= totaltags)
    {
	totaltags *= 2;
	bytag = erealloc(bytag, totaltags * sizeof(color_entry *));
	bytag_names = erealloc(bytag_names, totaltags * sizeof(char *));
    }

    /* initialize scan */
    entryp = entries;
    tp = NULL;

    /* look for tag in the list of entries */
    while (entryp != NULL)
    {
	if (strcmp(entryp->tag, tag) == 0)
	{
	    entryp->tagnext = tp;
	    tp = entryp;
	}
	entryp = entryp->next;
    }

    /* we track names in the array bytag */
    bytag[tagcnt] = tp;
    bytag_names[tagcnt] = estrdup(tag);

    /* return this index number as a reference */
    dprintf("color_tag: returns %d\n", tagcnt);
    return (tagcnt++);
}

/*
 * int color_test(int tagidx, int value)
 *
 * Test "value" against tests for tag "tagidx", a number previously returned
 * by color_tag.  Return the correct color number to use when highlighting.
 * If there is no match, return 0 (color 0).
 */

int
color_test(int tagidx, int value)

{
    color_entry *ce;

    /* sanity check */
    if (tagidx < 0 || tagidx >= tagcnt || color_off)
    {
	return 0;
    }

    ce = bytag[tagidx];

    while (ce != NULL)
    {
	if ((!ce->min || ce->min <= value) &&
	    (!ce->max || ce->max >= value))
	{
	    return ce->color;
	}
	ce = ce->tagnext;
    }

    return 0;
}

/*
 * char *color_setstr(int color)
 *
 * Return ANSI string to set the terminal for color number "color".
 */

char *
color_setstr(int color)

{
    static char v[32];

    v[0] = '\0';
    if (color >= 0 && color < num_color_ansi)
    {
	snprintf(v, sizeof(v), "\033[%sm", color_ansi[color]);
    }
    return v;
}

void
color_dump(FILE *f)

{
    color_entry *ep;
    int i;
    int col;
    int len;

    fputs("These color tags are available:", f);
    col = 81;
    for (i = 0; i < tagcnt; i++)
    {
	len = strlen(bytag_names[i]) + 1;
	if (len + col > 79)
	{
	    fputs("\n  ", f);
	    col = 2;
	}
	fprintf(f, " %s", bytag_names[i]);
	col += len;
    }

    fputs("\n\nTop color settings:\n", f);

    for (i = 0; i < tagcnt; i++)
    {
	ep = bytag[i];
	while (ep != NULL)
	{
	    fprintf(f, "   %s (%d-", ep->tag, ep->min);
	    if (ep->max != 0)
	    {
		fprintf(f, "%d", ep->max);
	    }
	    fprintf(f, "): ansi color %s, %sSample Text",
		    color_ansi[(int)ep->color],
		    color_setstr(ep->color));
	    fprintf(f, "%s\n", color_setstr(0));
	    ep = ep -> tagnext;
	}
    }
}

#ifdef notdef
void
color_debug(FILE *f)
{
    color_entry *ep;
    int i;

    fprintf(f, "color debug dump\n");
    ep = entries;
    while (ep != NULL)
    {
	fprintf(f, "%s(%d,%d): slot %d, ansi %s, %sSample Text",
		ep->tag, ep->min, ep->max, ep->color, color_ansi[(int)ep->color],
	       color_setstr(ep->color));
	fprintf(f, "%s\n", color_setstr(0));
	ep = ep -> next;
    }

    fprintf(f, "\ntags:");
    for (i = 0; i < tagcnt; i++)
    {
	fprintf(f, " %s", bytag_names[i]);
    }
    fprintf(f, "\n");
}
#endif

int
color_activate(int i)

{
    if (i == -1)
    {
	color_off = !color_off;
    }
    else
    {
	color_off = !i;
    }
    return color_off;
}