1 files changed, 491 insertions, 0 deletions
diff --git a/backend/dvi/mdvi-lib/pagesel.c b/backend/dvi/mdvi-lib/pagesel.c
new file mode 100644
index 00000000..5a153955
--- /dev/null
+++ b/backend/dvi/mdvi-lib/pagesel.c
@@ -0,0 +1,491 @@
+/* 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 */