path: root/backend/dvi/mdvi-lib/pagesel.c

/* pagesel.c -- Page selection mechanism */
/*
 * Copyright (C) 2000, Matias Atria
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
 */

#include <config.h>
#include <stdlib.h>
#include <ctype.h>
#include <string.h>
#include <limits.h>

#include "mdvi.h"
#include "private.h"

char	*program_name = "page";

struct _DviPageSpec {
	DviRange *ranges;
	int	nranges;
};

DviRange *mdvi_parse_range(const char *format, DviRange *limit, int *nitems, char **endptr)
{
	int	quoted;
	int	size;
	int	curr;
	int	done;
	int	lower;
	int	upper;
	int	type;
	char *	cp;
	char *	copy;
	char *	text;
	DviRange one;
	DviRange *range;

	quoted = (*format == '{');
	if(quoted) format++;

	size  = 0;
	curr  = 0;
	range = NULL;
	copy  = mdvi_strdup(format);
	done  = 0;
	lower = 0;
	upper = 0;
	type  = MDVI_RANGE_UNBOUNDED;

	if(limit) {
		switch(limit->type) {
			case MDVI_RANGE_BOUNDED:
				lower = limit->from;
				upper = limit->to;
				break;
			case MDVI_RANGE_UPPER:
				lower = INT_MIN;
				upper = limit->to;
				break;
			case MDVI_RANGE_LOWER:
				lower = limit->from;
				upper = INT_MAX;
				break;
			case MDVI_RANGE_UNBOUNDED:
				lower = INT_MIN;
				upper = INT_MAX;
				break;
		}
		type = limit->type;
	} else {
		lower = INT_MIN;
		upper = INT_MAX;
		type  = MDVI_RANGE_UNBOUNDED;
	}
	one.type = type;
	one.from = lower;
	one.to   = upper;
	one.step = 1;
	for(cp = text = copy; !done; cp++) {
		char	*p;
		int	f, t, s;
		int	ch;
		int	this_type;
		int	lower_given = 0;
		int	upper_given = 0;

		if(*cp == 0 || *cp == '.' || (*cp == '}' && quoted))
			done = 1;
		else if(*cp != ',')
			continue;

		if(text == cp)
			continue;
		ch = *cp;
		*cp = 0;
		f = lower;
		t = upper;
		s = 1;

		p = strchr(text, ':');
		if(p) *p++ = 0;
		if(*text) {
			lower_given = 1;
			f = strtol(text, NULL, 0);
		}
		if(p == NULL) {
			if(lower_given) {
				upper_given = 1;
				t = f; s = 1;
			}
			goto finish;
		}
		text = p;
		p = strchr(text, ':');
		if(p) *p++ = 0;
		if(*text) {
			upper_given = 1;
			t = strtol(text, NULL, 0);
		}
		if(p == NULL)
			goto finish;
		text = p;
		if(*text)
			s = strtol(text, NULL, 0);
finish:
		if(lower_given && upper_given)
			this_type = MDVI_RANGE_BOUNDED;
		else if(lower_given) {
			if(!RANGE_HAS_UPPER(type))
				this_type = MDVI_RANGE_LOWER;
			else
				this_type = MDVI_RANGE_BOUNDED;
			t = upper;
		} else if(upper_given) {
			if(RANGE_HAS_UPPER(one.type)) {
				one.to++;
				this_type = MDVI_RANGE_BOUNDED;
			} else {
				one.to = lower;
				if(!RANGE_HAS_LOWER(type))
					this_type = MDVI_RANGE_UPPER;
				else
					this_type = MDVI_RANGE_BOUNDED;
			}
			f = one.to;
		} else {
			this_type = type;
			f = lower;
			t = upper;
		}
		one.type = this_type;
		one.to   = t;
		one.from = f;
		one.step = s;

		if(curr == size) {
			size += 8;
			range = mdvi_realloc(range, size * sizeof(DviRange));
		}
		memcpy(&range[curr++], &one, sizeof(DviRange));
		*cp = ch;
		text = cp + 1;
	}
	if(done)
		cp--;
	if(quoted && *cp == '}')
		cp++;
	if(endptr)
		*endptr = (char *)format + (cp - copy);
	if(curr && curr < size)
		range = mdvi_realloc(range, curr * sizeof(DviRange));
	*nitems = curr;
	mdvi_free(copy);
	return range;
}

DviPageSpec *mdvi_parse_page_spec(const char *format)
{
	/*
	 * a page specification looks like this:
	 *   '{'RANGE_SPEC'}'         for a DVI spec
	 *   '{'RANGE_SPEC'}' '.' ... for a TeX spec
	 */
	DviPageSpec *spec;
	DviRange *range;
	int	count;
	int	i;
	char	*ptr;

	spec = xnalloc(struct _DviPageSpec *, 11);
	for(i = 0; i < 11; i++)
		spec[i] = NULL;

	/* check what kind of spec we're parsing */
	if(*format != '*') {
		range = mdvi_parse_range(format, NULL, &count, &ptr);
		if(ptr == format) {
			if(range) mdvi_free(range);
			mdvi_error(_("invalid page specification `%s'\n"), format);
			return NULL;
		}
	} else
		range = NULL;

	if(*format == 'D' || *format == 'd' || *ptr != '.')
		i = 0;
	else
		i = 1;

	if(range) {
		spec[i] = xalloc(struct _DviPageSpec);
		spec[i]->ranges = range;
		spec[i]->nranges = count;
	} else
		spec[i] = NULL;

	if(*ptr != '.') {
		if(*ptr)
			mdvi_warning(_("garbage after DVI page specification ignored\n"));
		return spec;
	}

	for(i++; *ptr == '.' && i <= 10; i++) {
		ptr++;
		if(*ptr == '*') {
			ptr++;
			range = NULL;
		} else {
			char	*end;

			range = mdvi_parse_range(ptr, NULL, &count, &end);
			if(end == ptr) {
				if(range) mdvi_free(range);
				range = NULL;
			} else
				ptr = end;
		}
		if(range != NULL) {
			spec[i] = xalloc(struct _DviPageSpec);
			spec[i]->ranges = range;
			spec[i]->nranges = count;
		} else
			spec[i] = NULL;
	}

	if(i > 10)
		mdvi_warning(_("more than 10 counters in page specification\n"));
	else if(*ptr)
		mdvi_warning(_("garbage after TeX page specification ignored\n"));

	return spec;
}

/* returns non-zero if the given page is included by `spec' */
int	mdvi_page_selected(DviPageSpec *spec, PageNum page, int dvipage)
{
	int	i;
	int	not_found;

	if(spec == NULL)
		return 1;
	if(spec[0]) {
		not_found = mdvi_in_range(spec[0]->ranges,
			spec[0]->nranges, dvipage);
		if(not_found < 0)
			return 0;
	}
	for(i = 1; i <= 10; i++) {
		if(spec[i] == NULL)
			continue;
		not_found = mdvi_in_range(spec[i]->ranges,
			spec[i]->nranges, (int)page[i]);
		if(not_found < 0)
			return 0;
	}
	return 1;
}

void	mdvi_free_page_spec(DviPageSpec *spec)
{
	int	i;

	for(i = 0; i < 11; i++)
		if(spec[i]) {
			mdvi_free(spec[i]->ranges);
			mdvi_free(spec[i]);
		}
	mdvi_free(spec);
}

int	mdvi_in_range(DviRange *range, int nitems, int value)
{
	DviRange *r;

	for(r = range; r < range + nitems; r++) {
		int	cond;

		switch(r->type) {
		case MDVI_RANGE_BOUNDED:
			if(value == r->from)
				return (r - range);
			if(r->step < 0)
				cond = (value <= r->from) && (value >= r->to);
			else
				cond = (value <= r->to) && (value >= r->from);
			if(cond && ((value - r->from) % r->step) == 0)
				return (r - range);
			break;
		case MDVI_RANGE_LOWER:
			if(value == r->from)
				return (r - range);
			if(r->step < 0)
				cond = (value < r->from);
			else
				cond = (value > r->from);
			if(cond && ((value - r->from) % r->step) == 0)
				return (r - range);
			break;
		case MDVI_RANGE_UPPER:
			if(value == r->to)
				return (r - range);
			if(r->step < 0)
				cond = (value > r->to);
			else
				cond = (value < r->to);
			if(cond && ((value - r->to) % r->step) == 0)
				return (r - range);
			break;
		case MDVI_RANGE_UNBOUNDED:
			if((value % r->step) == 0)
				return (r - range);
			break;
		}
	}
	return -1;
}

int	mdvi_range_length(DviRange *range, int nitems)
{
	int	count = 0;
	DviRange *r;

	for(r = range; r < range + nitems; r++) {
		int	n;

		if(r->type != MDVI_RANGE_BOUNDED)
			return -2;
		n = (r->to - r->from) / r->step;
		if(n < 0)
			n = 0;
		count += n + 1;
	}
	return count;
}

#ifdef TEST

void	print_range(DviRange *range)
{
	switch(range->type) {
	case MDVI_RANGE_BOUNDED:
		printf("From %d to %d, step %d\n",
			range->from, range->to, range->step);
		break;
	case MDVI_RANGE_LOWER:
		printf("From %d, step %d\n",
			range->from, range->step);
		break;
	case MDVI_RANGE_UPPER:
		printf("From %d, step -%d\n",
			range->to, range->step);
		break;
	case MDVI_RANGE_UNBOUNDED:
		printf("From 0, step %d and %d\n",
			range->step, -range->step);
		break;
	}
}

int main()
{
#if 0
	char	buf[256];
	DviRange limit;

	limit.from = 0;
	limit.to = 100;
	limit.step = 2;
	limit.type = MDVI_RANGE_UNBOUNDED;
	while(1) {
		DviRange *range;
		char	*end;
		int	count;
		int	i;

		printf("Range> "); fflush(stdout);
		if(fgets(buf, 256, stdin) == NULL)
			break;
		if(buf[strlen(buf)-1] == '\n')
			buf[strlen(buf)-1] = 0;
		if(buf[0] == 0)
			continue;
		end = NULL;
		range = mdvi_parse_range(buf, &limit, &count, &end);
		if(range == NULL) {
			printf("range is empty\n");
			continue;
		}

		for(i = 0; i < count; i++) {
			printf("Range %d (%d elements):\n",
				i, mdvi_range_length(&range[i], 1));
			print_range(&range[i]);
		}
		if(end && *end)
			printf("Tail: [%s]\n", end);
		printf("range has %d elements\n",
			mdvi_range_length(range, count));
#if 1
		while(1) {
			int	v;

			printf("Value: "); fflush(stdout);
			if(fgets(buf, 256, stdin) == NULL)
				break;
			if(buf[strlen(buf)-1] == '\n')
				buf[strlen(buf)-1] = 0;
			if(buf[0] == 0)
				break;
			v = atoi(buf);
			i = mdvi_in_range(range, count, v);
			if(i == -1)
				printf("%d not in range\n", v);
			else {
				printf("%d in range: ", v);
				print_range(&range[i]);
			}
		}
#endif
		if(range) mdvi_free(range);
	}
#else
	DviPageSpec *spec;
	char	buf[256];

	while(1) {
		printf("Spec> "); fflush(stdout);
		if(fgets(buf, 256, stdin) == NULL)
			break;
		if(buf[strlen(buf)-1] == '\n')
			buf[strlen(buf)-1] = 0;
		if(buf[0] == 0)
			continue;
		spec = mdvi_parse_page_spec(buf);
		if(spec == NULL)
			printf("no spec parsed\n");
		else {
			int	i;

			printf("spec = ");
			for(i = 0; i < 11; i++) {
				printf("Counter %d:\n", i);
				if(spec[i]) {
					int	k;

					for(k = 0; k < spec[i]->nranges; k++)
						print_range(&spec[i]->ranges[k]);
				} else
					printf("\t*\n");
			}
			mdvi_free_page_spec(spec);
		}
	}
#endif
	exit(0);

}
#endif /* TEST */