/* $XTermId: graphics_regis.c,v 1.157 2025/04/03 09:53:05 tom Exp $ */

/*
 * Copyright 2014-2024,2025 by Thomas E. Dickey
 * Copyright 2014-2022,2023 by Ross Combs
 *
 *                         All Rights Reserved
 *
 * Permission is hereby granted, free of charge, to any person obtaining a
 * copy of this software and associated documentation files (the
 * "Software"), to deal in the Software without restriction, including
 * without limitation the rights to use, copy, modify, merge, publish,
 * distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to
 * the following conditions:
 *
 * The above copyright notice and this permission notice shall be included
 * in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 * IN NO EVENT SHALL THE ABOVE LISTED COPYRIGHT HOLDER(S) BE LIABLE FOR ANY
 * CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
 * TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
 * SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 * Except as contained in this notice, the name(s) of the above copyright
 * holders shall not be used in advertising or otherwise to promote the
 * sale, use or other dealings in this Software without prior written
 * authorization.
 */

#include <xterm.h>

#include <stdio.h>
#include <ctype.h>
#include <math.h>
#include <stdlib.h>

#include <fontutils.h>
#include <ptyx.h>

#include <assert.h>
#include <graphics.h>
#include <graphics_regis.h>

/* get rid of shadowing warnings (we will not draw Bessel functions) */
#define y1 my_y1
#define y0 my_y0

#define SCALE_FIXED_POINT 16U

#undef DEBUG_PARSING
#undef DEBUG_ALPHABET_LOOKUP
#undef DEBUG_ALPHABETS
#undef DEBUG_BEZIER
#undef DEBUG_SPLINE_SEGMENTS
#undef DEBUG_SPLINE_POINTS
#undef DEBUG_SPLINE_WITH_ROTATION
#undef DEBUG_SPLINE_WITH_OVERDRAW
#undef DEBUG_ARC_POINTS
#undef DEBUG_ARC_CENTER
#undef DEBUG_ARC_START
#undef DEBUG_ARC_END
#undef DEBUG_SPECIFIC_CHAR_METRICS
#define IS_DEBUG_CHAR(CH) ((CH) == 'W')		/* glyphs to dump to terminal */
#undef DEBUG_COMPUTED_FONT_METRICS
#undef DEBUG_FONT_NAME
#undef DEBUG_FONT_SIZE_SEARCH
#undef DEBUG_XFT_GLYPH_COPY
#undef DEBUG_GLYPH_RETRIEVAL
#undef DEBUG_XFT_GLYPH_LOADING
#undef DEBUG_LOAD

/* controls for extensions over VT3x0 limitations */
#define ENABLE_RGB_COLORSPECS
#undef ENABLE_FREE_ROTATION
#undef ENABLE_DISTORTIONLESS_ROTATION
#define ENABLE_UPLOAD_ALPHABET_FROM_FONT
#define ENABLE_UPLOAD_ALPHABET_ZERO
#define ENABLE_USER_FONT_SIZE
#define ENABLE_VARIABLE_ITALICS

#define MIN_ITERATIONS_BEFORE_REFRESH 10U
#define MIN_MS_BEFORE_REFRESH 33
/* *INDENT-OFF* */
typedef struct RegisPoint {
    int  x, y;
} RegisPoint;

typedef struct RegisWriteControls {
    unsigned     pv_multiplier;
    unsigned     pattern;
    unsigned     pattern_multiplier;
    unsigned     invert_pattern;
    unsigned     plane_mask;
    unsigned     write_style;
    RegisterNum  foreground;
    unsigned     shading_enabled;
    char         shading_character;
    int          shading_reference;
    unsigned     shading_reference_dim;
    unsigned     line_width;
} RegisWriteControls;

typedef struct RegisTextControls {
    unsigned  alphabet_num;
    unsigned  character_set_l; /* default: "(B" (ASCII) */
    unsigned  character_set_r; /* default: "-@" (Latin-1) */
    unsigned  character_display_w;
    unsigned  character_display_h;
    unsigned  character_unit_cell_w;
    unsigned  character_unit_cell_h;
    int       character_inc_x;
    int       character_inc_y;
    int       string_rotation;
    int       character_rotation;
    int       slant; /* for italic/oblique */
} RegisTextControls;

#define S_QUOTE '\''
#define D_QUOTE '"'

#define isQuote(ch)   ((ch) == S_QUOTE || (ch) == D_QUOTE)
#define PickQuote(ch) ((ch) == S_QUOTE ? D_QUOTE : S_QUOTE)

#define isName(c) ((c) == '_' || isalnum(CharOf(c)))

#define FixedCopy(dst, src, len) strncpy(dst, src, len - 1)[len - 1] = '\0'
#define CopyFontname(dst, src) FixedCopy(dst, src, (size_t) REGIS_FONTNAME_LEN)

#define MAX_REGIS_PAGES 8U

#define MAX_REGIS_ALPHABETS 8U
#define REGIS_ALPHABET_NAME_LEN 11U
#define REGIS_FONTNAME_LEN 256U
/* enough for a 16x24 font (about 100KB) */
#define MAX_REGIS_ALPHABET_BYTES (256U * 16U * 24U)
#define MAX_GLYPH_PIXELS 8192U
#define MAX_GLYPHS 256U
#define INVALID_ALPHABET_NUM ~0U

typedef struct RegisAlphabet {
    unsigned       alphabet_num;
    unsigned       pixw, pixh;
    char           name[REGIS_ALPHABET_NAME_LEN];
    char           fontname[REGIS_FONTNAME_LEN];
    int            use_font;
    int            loaded[MAX_GLYPHS];
    Char          *bytes;
} RegisAlphabet;

typedef struct RegisDataFragment {
    char const  *start;
    unsigned     pos;
    unsigned     len;
} RegisDataFragment;
/* *INDENT-ON* */

#define POSITION_STACK_SIZE 16U
#define DUMMY_STACK_X -32768
#define DUMMY_STACK_Y -32768

#define CURVE_POSITION_ARC_EDGE     0U
#define CURVE_POSITION_ARC_CENTER   1U
#define CURVE_POSITION_OPEN_CURVE   2U
#define CURVE_POSITION_CLOSED_CURVE 3U

#define MAX_INPUT_CURVE_POINTS 16U
#define MAX_CURVE_POINTS (MAX_INPUT_CURVE_POINTS + 4U)

#define MAX_FILL_POINTS 2048U

typedef struct RegisParseState {
    RegisDataFragment input;
    char *temp;
    unsigned templen;
    char command;
    char option;
    /* position stack */
    int stack_x[POSITION_STACK_SIZE];
    int stack_y[POSITION_STACK_SIZE];
    unsigned stack_next;	/* next empty position */
    /* curve options */
    int curve_mode;
    int arclen;
    int x_points[MAX_CURVE_POINTS];
    int y_points[MAX_CURVE_POINTS];
    unsigned num_points;
    /* load options */
    char load_name[REGIS_ALPHABET_NAME_LEN];
    unsigned load_alphabet;
    unsigned load_w, load_h;
    unsigned load_index;
    unsigned load_glyph;
    unsigned load_row;
    /* text options */
    unsigned text_tilt_state;
} RegisParseState;

#define TEXT_TILT_STATE_READY    0U
#define TEXT_TILT_STATE_GOT_D    1U
#define TEXT_TILT_STATE_GOT_DS   2U
#define TEXT_TILT_STATE_GOT_DSD  3U

typedef struct RegisGraphicsContext {
    XtermWidget current_widget;
    Graphic *destination_graphic;
    Graphic *display_graphic;
    int graphics_termid;
    int x_off, y_off;
    int x_div, y_div;
    int width, height;
    unsigned all_planes;
    RegisterNum background;
    char const *builtin_font;
    RegisAlphabet alphabets[MAX_REGIS_ALPHABETS];
    RegisWriteControls persistent_write_controls;
    RegisWriteControls temporary_write_controls;
    RegisTextControls persistent_text_controls;
    RegisTextControls temporary_text_controls;
    RegisTextControls *current_text_controls;
    int multi_input_mode;
    int graphics_output_cursor_x;
    int graphics_output_cursor_y;
    unsigned pattern_count;
    unsigned pattern_bit;
    int fill_mode;
    RegisPoint fill_points[MAX_FILL_POINTS];
    unsigned fill_point_count;
    unsigned destination_page;
    unsigned display_page;
    Boolean force_refresh;
} RegisGraphicsContext;

static RegisGraphicsContext persistent_context;
static RegisParseState persistent_state;

#define MAX_PATTERN_BITS 8U

#define WRITE_STYLE_OVERLAY 1U
#define WRITE_STYLE_REPLACE 2U
#define WRITE_STYLE_COMPLEMENT 3U
#define WRITE_STYLE_ERASE 4U

#define WRITE_SHADING_REF_Y 0U
#define WRITE_SHADING_REF_X 1U
#define WRITE_SHADING_REF_NONE 2U

/* keypress event example: http://iraf.net/forum/viewtopic.php?showtopic=61692 */

#define MIN2(X, Y) ( (X) < (Y) ? (X) : (Y) )
#define MIN3(X, Y, Z) ( MIN2(MIN2((X), (Y)), MIN2((Y), (Z))) )
#define MAX2(X, Y) ( (X) > (Y) ? (X) : (Y) )
#define MAX3(X, Y, Z) ( MAX2(MAX2((X), (Y)), MAX2((Y), (Z))) )

#define ROT_LEFT(V) ( (((V) << 1U) & 255U) | ((V) >> 7U) )

/* convert user coordinates to absolute pixel coordinates */
#define SCALE_XCOORD(C, X, S) (int) ( ( (long)(X) * (long)((C)->width  - 1) ) / ( (long)(C)->x_div * (long)(S) ) )
#define SCALE_YCOORD(C, Y, S) (int) ( ( (long)(Y) * (long)((C)->height - 1) ) / ( (long)(C)->y_div * (long)(S) ) )
#define TRANSLATE_XCOORD(C, X, S) SCALE_XCOORD((C), (X) - ((C)->x_off * (S)), (S) )
#define TRANSLATE_YCOORD(C, Y, S) SCALE_YCOORD((C), (Y) - ((C)->y_off * (S)), (S) )

#define READ_PIXEL(C, X, Y) read_pixel((C)->destination_graphic, (X), (Y))
#define DRAW_PIXEL(C, X, Y, COL) draw_solid_pixel((C)->destination_graphic, (X), (Y), (COL))
#define DRAW_ALL(C, COL) \
    draw_solid_rectangle((C)->destination_graphic, 0, 0, (C)->width, (C)->height, (COL))

static void get_bitmap_of_character(RegisGraphicsContext const *context,
				    int ch, unsigned maxw, unsigned maxh,
				    Char *pixels,
				    unsigned *w, unsigned *h,
				    unsigned max_pixels);

static void
init_regis_load_state(RegisParseState *state)
{
    state->load_index = MAX_REGIS_ALPHABETS;
    state->load_w = 8U;
    state->load_h = 10U;
    state->load_alphabet = 1U;	/* FIXME: is this the correct default */
    state->load_name[0] = '\0';
    state->load_glyph = (unsigned) (Char) '\0';
    state->load_row = 0U;
}

static void
init_regis_parse_state(RegisParseState *state)
{
    state->command = '_';
    state->option = '_';
    state->stack_next = 0U;
    state->load_index = MAX_REGIS_ALPHABETS;
    init_regis_load_state(state);
}

static int
ifloor(double d)
{
    double dl = floor(d);
    return (int) dl;
}

static int
isqrt(double d)
{
    double dl = sqrt(d);
    return (int) dl;
}

static void
draw_regis_pixel(RegisGraphicsContext *context, int x, int y,
		 unsigned value)
{
    unsigned color = 0;

    switch (context->temporary_write_controls.write_style) {
    case WRITE_STYLE_OVERLAY:
	/*
	 * Update pixels with foreground when pattern is 1,
	 * don't change when pattern is 0.
	 */
	if (!value) {
	    return;
	}

	if (context->temporary_write_controls.invert_pattern) {
	    color = context->background;
	} else {
	    color = context->temporary_write_controls.foreground;
	}
	break;

    case WRITE_STYLE_REPLACE:
	/*
	 * Update pixels with foreground when pattern is 1,
	 * set to background when pattern is 0.
	 */
	{
	    unsigned fg, bg;

	    if (context->temporary_write_controls.invert_pattern) {
		fg = context->background;
		bg = context->temporary_write_controls.foreground;
	    } else {
		fg = context->temporary_write_controls.foreground;
		bg = context->background;
	    }
	    color = value ? fg : bg;
	}
	break;

    case WRITE_STYLE_COMPLEMENT:
	/*
	 * Update pixels with background when pattern is 1,
	 * don't change when pattern is 0.
	 */
	if (!value) {
	    return;
	}

	color = READ_PIXEL(context, x, y);
	if (color == COLOR_HOLE)
	    color = context->background;
	color = color ^ context->all_planes;
	break;

    case WRITE_STYLE_ERASE:
	/* Update pixels to foreground. */
	if (context->temporary_write_controls.invert_pattern) {
	    color = context->temporary_write_controls.foreground;
	} else {
	    color = context->background;
	}
	break;
    }

    if (context->temporary_write_controls.plane_mask != context->all_planes) {
	unsigned old_color = READ_PIXEL(context, x, y);
	if (old_color == COLOR_HOLE)
	    old_color = context->background;
	color = (color & context->temporary_write_controls.plane_mask) |
	    (old_color & ~context->temporary_write_controls.plane_mask);
    }

    DRAW_PIXEL(context, x, y, color);
}

static void
shade_pattern_to_pixel(RegisGraphicsContext *context, unsigned dim, int ref,
		       int x, int y)
{
    unsigned value;

    if (dim == WRITE_SHADING_REF_X) {
	int delta = x > ref ? 1 : -1;
	int curr_x;

	context->pattern_bit = 1U << (((unsigned) y) & 7U);
	for (curr_x = ref; curr_x != x + delta; curr_x += delta) {
	    value = context->temporary_write_controls.pattern &
		context->pattern_bit;
	    draw_regis_pixel(context, curr_x, y, value);
	}
    } else if (dim == WRITE_SHADING_REF_Y) {
	int delta = y > ref ? 1 : -1;
	int curr_y;

	for (curr_y = ref; curr_y != y + delta; curr_y += delta) {
	    context->pattern_bit = 1U << (((unsigned) curr_y) & 7U);
	    value = context->temporary_write_controls.pattern &
		context->pattern_bit;
	    draw_regis_pixel(context, x, curr_y, value);
	}
    } else {
	TRACE(("ERROR: shading requested, but there is no reference axis\n"));
    }
}

#define ROT_SHEAR_SCALE 8192
#define SIGNED_UNSIGNED_MOD(VAL, BASE) ( (((VAL) % (int) (BASE)) + (int) (BASE)) % (int) (BASE) )

static unsigned
get_shade_character_pixel(Char const *pixels, unsigned w, unsigned h,
			  unsigned smaxf, unsigned scale, int slant_dx,
			  int px, int py)
{
    unsigned wx, wy;
    unsigned fx, fy;

    wx = (unsigned) SIGNED_UNSIGNED_MOD(px -
					(slant_dx * SIGNED_UNSIGNED_MOD(py, smaxf))
					/ ROT_SHEAR_SCALE, smaxf);
    wy = (unsigned) SIGNED_UNSIGNED_MOD(py, smaxf);

    fx = (wx * scale) >> SCALE_FIXED_POINT;
    fy = (wy * scale) >> SCALE_FIXED_POINT;
    if (fx < w && fy < h) {
	return (unsigned) pixels[fy * w + fx];
    }
    return 0U;
}

static void
shade_char_to_pixel(RegisGraphicsContext *context, Char const *pixels,
		    unsigned w, unsigned h, unsigned dim, int ref, int x, int y)
{
    unsigned xmaxf = context->current_text_controls->character_unit_cell_w;
    unsigned ymaxf = context->current_text_controls->character_unit_cell_h;
    unsigned smaxf;
    unsigned s;
    unsigned scale;
    unsigned value;

    if (xmaxf > ymaxf) {
	smaxf = ymaxf;
	s = h;
    } else {
	smaxf = xmaxf;
	s = w;
    }
    scale = (s << SCALE_FIXED_POINT) / smaxf;

    if (dim == WRITE_SHADING_REF_X) {
	int delta = x > ref ? 1 : -1;
	int curr_x;

	for (curr_x = ref; curr_x != x + delta; curr_x += delta) {
	    value = get_shade_character_pixel(pixels, w, h, smaxf, scale, 0,
					      curr_x, y);
	    draw_regis_pixel(context, curr_x, y, value);
	}
    } else if (dim == WRITE_SHADING_REF_Y) {
	int delta = y > ref ? 1 : -1;
	int curr_y;

	for (curr_y = ref; curr_y != y + delta; curr_y += delta) {
	    value = get_shade_character_pixel(pixels, w, h, smaxf, scale, 0, x,
					      curr_y);
	    draw_regis_pixel(context, x, curr_y, value);
	}
    } else {
	TRACE(("ERROR: shading requested, but there is no reference axis\n"));
    }
}

static void
draw_patterned_pixel(RegisGraphicsContext *context, int x, int y)
{
    if (context->pattern_count >=
	context->temporary_write_controls.pattern_multiplier) {
	context->pattern_count = 0U;
	context->pattern_bit = ROT_LEFT(context->pattern_bit);
    }
    context->pattern_count++;

    draw_regis_pixel(context, x, y,
		     context->temporary_write_controls.pattern &
		     context->pattern_bit);
}

static void
shade_to_pixel(RegisGraphicsContext *context, unsigned dim, int ref,
	       int x, int y)
{
    if (context->temporary_write_controls.shading_character != '\0') {
	unsigned xmaxf = context->current_text_controls->character_unit_cell_w;
	unsigned ymaxf = context->current_text_controls->character_unit_cell_h;
	char ch = context->temporary_write_controls.shading_character;
	Char pixels[MAX_GLYPH_PIXELS];
	unsigned w, h;

	get_bitmap_of_character(context, ch, xmaxf, ymaxf, pixels, &w, &h,
				MAX_GLYPH_PIXELS);
	if (w > 0 && h > 0) {
	    shade_char_to_pixel(context, pixels, w, h, dim, ref, x, y);
	}
    } else {
	shade_pattern_to_pixel(context, dim, ref, x, y);
    }
}

static void
draw_or_save_patterned_pixel(RegisGraphicsContext *context, int x, int y)
{
    if (context->fill_mode == 1) {
	if (context->fill_point_count >= MAX_FILL_POINTS) {
	    TRACE(("point %d,%d can not be added to filled polygon\n",
		   x, y));
	    return;
	}
	if (context->fill_point_count > 0U &&
	    context->fill_points[context->fill_point_count - 1U].x == x &&
	    context->fill_points[context->fill_point_count - 1U].y == y) {
	    return;
	}
	context->fill_points[context->fill_point_count].x = x;
	context->fill_points[context->fill_point_count].y = y;
	context->fill_point_count++;
	return;
    }

    if (context->temporary_write_controls.shading_enabled) {
	unsigned dim = context->temporary_write_controls.shading_reference_dim;
	int ref = context->temporary_write_controls.shading_reference;

	shade_to_pixel(context, dim, ref, x, y);
	return;
    }

    draw_patterned_pixel(context, x, y);
}

static int
sort_points(void const *l, void const *r)
{
    RegisPoint const *const lp = (RegisPoint const *) l;
    RegisPoint const *const rp = (RegisPoint const *) r;

    if (lp->y < rp->y)
	return -1;
    if (lp->y > rp->y)
	return +1;
    if (lp->x < rp->x)
	return -1;
    if (lp->x > rp->x)
	return +1;
    return 0;
}

static void
draw_shaded_polygon(RegisGraphicsContext *context)
{
    unsigned p;
    int old_x, old_y;
    int inside;
    Char pixels[MAX_GLYPH_PIXELS];
    unsigned w = 1, h = 1;

    char ch = context->temporary_write_controls.shading_character;
    unsigned xmaxf = context->current_text_controls->character_unit_cell_w;
    unsigned ymaxf = context->current_text_controls->character_unit_cell_h;

    get_bitmap_of_character(context, ch, xmaxf, ymaxf, pixels, &w, &h,
			    MAX_GLYPH_PIXELS);
    if (w < 1U || h < 1U) {
	return;
    }

    qsort(context->fill_points, (size_t) context->fill_point_count,
	  sizeof(context->fill_points[0]), sort_points);

    old_x = DUMMY_STACK_X;
    old_y = DUMMY_STACK_Y;
    inside = 0;
    for (p = 0U; p < context->fill_point_count; p++) {
	int new_x = context->fill_points[p].x;
	int new_y = context->fill_points[p].y;

	/*
	 * FIXME: This is using pixels to represent lines which loses
	 * information about exact slope and how many lines are present which
	 * causes misbehavior with some inputs (especially complex polygons).
	 * It also takes more room than remembering vertices, but I'd rather
	 * not have to implement line segments for arcs.  Maybe store a count
	 * at each vertex instead (doesn't fix the slope problem).
	 */
	/*
	 * FIXME: Change this to only draw inside of polygons, and round
	 * points in a uniform direction to avoid overlapping drawing.  As an
	 * option we could continue to support drawing the outline.
	 */
	if (new_y != old_y) {
	    if (inside) {
		/*
		 * Just draw the vertical line when there is not a matching
		 * edge on the right side.
		 */
		shade_char_to_pixel(context, pixels, w, h,
				    WRITE_SHADING_REF_X,
				    old_x, old_x, old_y);
	    }
	    inside = 1;
	} else {
	    if (inside) {
		shade_char_to_pixel(context, pixels, w, h,
				    WRITE_SHADING_REF_X,
				    old_x, new_x, new_y);
	    }
	    if (new_x > old_x + 1) {
		inside = !inside;
	    }
	}

	old_x = new_x;
	old_y = new_y;
    }

    context->destination_graphic->dirty = True;
}

static void
draw_filled_polygon(RegisGraphicsContext *context)
{
    unsigned p;
    int old_x, old_y;
    int inside;

    qsort(context->fill_points, (size_t) context->fill_point_count,
	  sizeof(context->fill_points[0]), sort_points);

    old_x = DUMMY_STACK_X;
    old_y = DUMMY_STACK_Y;
    inside = 0;
    for (p = 0U; p < context->fill_point_count; p++) {
	int new_x = context->fill_points[p].x;
	int new_y = context->fill_points[p].y;

	/*
	 * FIXME: This is using pixels to represent lines which loses
	 * information about exact slope and how many lines are present which
	 * causes misbehavior with some inputs (especially complex polygons).
	 * It also takes more room than remembering vertices, but I'd rather
	 * not have to implement line segments for arcs.  Maybe store a count
	 * at each vertex instead (doesn't fix the slope problem).
	 */
	/*
	 * FIXME: Change this to only draw inside of polygons, and round
	 * points in a uniform direction to avoid overlapping drawing.  As an
	 * option we could continue to support drawing the outline.
	 */
	if (new_y != old_y) {
	    if (inside) {
		/*
		 * Just draw the vertical line when there is not a matching
		 * edge on the right side.
		 */
		shade_pattern_to_pixel(context, WRITE_SHADING_REF_X,
				       old_x, old_x, old_y);
	    }
	    inside = 1;
	} else {
	    if (inside) {
		shade_pattern_to_pixel(context, WRITE_SHADING_REF_X,
				       old_x, new_x, new_y);
	    }
	    if (new_x > old_x + 1) {
		inside = !inside;
	    }
	}

	old_x = new_x;
	old_y = new_y;
    }

    context->destination_graphic->dirty = True;
}

static void
draw_patterned_line(RegisGraphicsContext *context, int x1, int y1,
		    int x2, int y2)
{
    int x, y;
    int dx, dy;
    int dir, diff;

    dx = abs(x1 - x2);
    dy = abs(y1 - y2);

    if (dx > dy) {
	if (x1 > x2) {
	    int tmp;
	    EXCHANGE(x1, x2, tmp);
	    EXCHANGE(y1, y2, tmp);
	}
	if (y1 < y2)
	    dir = 1;
	else if (y1 > y2)
	    dir = -1;
	else
	    dir = 0;

	diff = 0;
	y = y1;
	for (x = x1; x <= x2; x++) {
	    if (diff >= dx) {
		diff -= dx;
		y += dir;
	    }
	    diff += dy;
	    draw_or_save_patterned_pixel(context, x, y);
	}
    } else {
	if (y1 > y2) {
	    int tmp;
	    EXCHANGE(y1, y2, tmp);
	    EXCHANGE(x1, x2, tmp);
	}
	if (x1 < x2)
	    dir = 1;
	else if (x1 > x2)
	    dir = -1;
	else
	    dir = 0;

	diff = 0;
	x = x1;
	for (y = y1; y <= y2; y++) {
	    if (diff >= dy) {
		diff -= dy;
		x += dir;
	    }
	    diff += dx;
	    draw_or_save_patterned_pixel(context, x, y);
	}
    }

    context->destination_graphic->dirty = True;
}

typedef struct {
    int dxx;
    int dxy;
    int dyx;
    int dyy;
} quadmap_coords;

static void
draw_patterned_arc(RegisGraphicsContext *context,
		   int cx, int cy,
		   int ex, int ey,
		   int a_start, int a_length,
		   int *ex_final, int *ey_final)
{
    const double third = hypot((double) (cx - ex), (double) (cy - ey));
    const int radius = (int) third;
    const int ra = radius;
    const int rb = radius;
    const quadmap_coords neg_quadmap[4] =
    {
	{-1, 0, 0, +1},
	{0, -1, -1, 0},
	{+1, 0, 0, -1},
	{0, +1, +1, 0},
    };
    const quadmap_coords pos_quadmap[4] =
    {
	{-1, 0, 0, -1},
	{0, -1, +1, 0},
	{+1, 0, 0, +1},
	{0, +1, -1, 0},
    };
    const quadmap_coords *quadmap;
    int total_points;
    int half_degree;
    int points_start, points_stop;
    int points;
    unsigned iterations;
    long rx, ry;
    long dx, dy;
    int x, y;
    long e2;
    long error;

    TRACE(("orig a_length=%d a_start=%d\n", a_length, a_start));
    if (a_length == 0)
	return;
    if (a_length > 0) {
	quadmap = pos_quadmap;
    } else {
	quadmap = neg_quadmap;
	if (a_start != 0)
	    a_start = 3600 - a_start;
	a_length = abs(a_length);
    }
    TRACE(("positive a_length=%d a_start=%d\n", a_length, a_start));

    rx = -ra;
    ry = 0;
    e2 = rb;
    dx = (2 * rx + 1) * e2 * e2;
    dy = rx * rx;
    error = dx + dy;
    total_points = 0;
    do {
	total_points += 4;
	e2 = 2 * error;
	if (e2 >= dx) {
	    rx++;
	    dx += 2 * rb * rb;
	    error += dx;
	}
	if (e2 <= dy) {
	    ry++;
	    dy += 2 * ra * ra;
	    error += dy;
	}
    }
    while (rx <= 0);

    /* FIXME: This is apparently not accurate enough because some arcs start or
     * end a few pixels off.  Maybe compare line slopes in the loop below
     * instead?
     */
    half_degree = total_points * 5;
    points_start = (total_points * a_start - half_degree) / 3600;
    points_stop = (total_points * a_start +
		   total_points * a_length + half_degree) / 3600;
    TRACE(("drawing arc with %d points clockwise from %g degrees for %g degrees (from point %d to %d out of %d)\n",
	   total_points, a_start / 10.0, a_length / 10.0, points_start, points_stop,
	   total_points));

    /* FIXME: The four pixels at the cardinal directions are double-drawn. */
    points = 0;
    for (iterations = 0U; iterations < 8U; iterations++) {
	int q2 = iterations & 0x3;

	rx = -ra;
	ry = 0;
	e2 = rb;
	dx = (2 * rx + 1) * e2 * e2;
	dy = rx * rx;
	error = dx + dy;
	do {
#ifdef DEBUG_ARC_POINTS
	    double rad = atan2(
				  (double) (quadmap[q2].dyx * rx +
					    quadmap[q2].dyy * ry),
				  (double) (quadmap[q2].dxx * rx +
					    quadmap[q2].dxy * ry));
	    double deg = (360.0 * rad / (2.0 * M_PI));
	    if (deg < 0.0)
		deg += 360.0;
#endif

	    if (points >= points_start && points <= points_stop) {
		x = (int) (cx +
			   quadmap[q2].dxx * rx +
			   quadmap[q2].dxy * ry);
		y = (int) (cy +
			   quadmap[q2].dyx * rx +
			   quadmap[q2].dyy * ry);
#ifdef DEBUG_ARC_POINTS
		TRACE(("drawing point %u at %d,%d (%.5g deg)\n",
		       points, x, y, deg));
#endif
		draw_or_save_patterned_pixel(context, x, y);
		if (ex_final)
		    *ex_final = x;
		if (ey_final)
		    *ey_final = y;
	    } else {
#ifdef DEBUG_ARC_POINTS
		x = (int) (cx + quadmap[q2].dxx * rx + quadmap[q2].dxy * ry);
		y = (int) (cy + quadmap[q2].dyx * rx + quadmap[q2].dyy * ry);
		TRACE(("skipping point %u at %d,%d which is outside of range (%.5g deg)\n",
		       points, x, y, deg));
#endif
	    }
	    points++;

	    e2 = 2 * error;
	    if (e2 >= dx) {
		rx++;
		dx += 2 * rb * rb;
		error += dx;
	    }
	    if (e2 <= dy) {
		ry++;
		dy += 2 * ra * ra;
		error += dy;
	    }
	}
	while (rx <= 0);
    }

    context->destination_graphic->dirty = True;
}

/*
 * The plot* functions are based on optimized rasterization primitives written
 * by Zingl Alois.
 * See http://members.chello.at/easyfilter/bresenham.html
 */

/*
 * FIXME:
 * This is a terrible temporary hack.  The plot functions below can be adapted
 * to work like the other rasterization functions but there's no point in doing
 * that until we know we don't have to write something completely different.
 */
static RegisGraphicsContext *global_context;
static void
setPixel(int x, int y)
{
    draw_or_save_patterned_pixel(global_context, x, y);
}

static void
plotLine(int x0, int y0, int x1, int y1)
{
    int dx = abs(x1 - x0), sx = x0 < x1 ? 1 : -1;
    int dy = -abs(y1 - y0), sy = y0 < y1 ? 1 : -1;
    int err = dx + dy;		/* error value e_xy */

    for (;;) {			/* loop */
	int e2;
	setPixel(x0, y0);
	e2 = 2 * err;
	if (e2 >= dy) {		/* e_xy+e_x > 0 */
	    if (x0 == x1)
		break;
	    err += dy;
	    x0 += sx;
	}
	if (e2 <= dx) {		/* e_xy+e_y < 0 */
	    if (y0 == y1)
		break;
	    err += dx;
	    y0 += sy;
	}
    }
}

static void
plotQuadBezierSeg(int x0, int y0, int x1, int y1, int x2, int y2)
{				/* plot a limited quadratic Bezier segment */
    int sx = x2 - x1;
    int sy = y2 - y1;
    long xx = (x0 - x1);	/* relative values for checks */
    long yy = (y0 - y1);
    double cur = (double) (xx * sy - yy * sx);	/* curvature */

    assert(xx * sx <= 0 && yy * sy <= 0);	/* sign of gradient must not change */

    if (sx * (long) sx + sy * (long) sy > xx * xx + yy * yy) {	/* begin with longer part */
	x2 = x0;
	x0 = sx + x1;
	y2 = y0;
	y0 = sy + y1;
	cur = -cur;		/* swap P0 P2 */
    }
    if (cur != 0.0) {		/* no straight line */
	long xy;
	double dx, dy, err;

	xx += sx;
	xx *= (sx = (x0 < x2) ? 1 : -1);	/* x step direction */
	yy += sy;
	yy *= (sy = (y0 < y2) ? 1 : -1);	/* y step direction */
	xy = 2 * xx * yy;
	xx *= xx;
	yy *= yy;		/* differences 2nd degree */
	if (cur * sx * sy < 0) {	/* negated curvature? */
	    xx = -xx;
	    yy = -yy;
	    xy = -xy;
	    cur = -cur;
	}
	/* differences 1st degree */
	dx = ((4.0 * sy * cur * (x1 - x0)) + (double) xx) - (double) xy;
	dy = ((4.0 * sx * cur * (y0 - y1)) + (double) yy) - (double) xy;
	xx += xx;
	yy += yy;
	err = dx + dy + (double) xy;	/* error 1st step */
	do {
	    setPixel(x0, y0);	/* plot curve */
	    if (x0 == x2 && y0 == y2)
		return;		/* last pixel -> curve finished */
	    y1 = (2 * err) < dx;	/* save value for test of y step */
	    if ((2 * err) > dy) {
		x0 += sx;
		dx -= (double) xy;
		dy += (double) yy;
		err += dy;
	    }			/* x step */
	    if (y1) {
		y0 += sy;
		dy -= (double) xy;
		dx += (double) xx;
		err += dx;
	    }			/* y step */
	} while (dy < 0 && dx > 0);	/* gradient negates -> algorithm fails */
    }
    plotLine(x0, y0, x2, y2);	/* plot remaining part to end */
}

#if 0
static void
plotQuadBezier(int x0, int y0, int x1, int y1, int x2, int y2)
{				/* plot any quadratic Bezier curve */
    int x = x0 - x1;
    int y = y0 - y1;
    double t = x0 - 2 * x1 + x2;
    double r;

    if ((long) x * (x2 - x1) > 0) {	/* horizontal cut at P4? */
	if ((long) y * (y2 - y1) > 0)	/* vertical cut at P6 too? */
	    if (fabs((y0 - 2 * y1 + y2) / t * x) > abs(y)) {	/* which first? */
		x0 = x2;
		x2 = x + x1;
		y0 = y2;
		y2 = y + y1;	/* swap points */
	    }			/* now horizontal cut at P4 comes first */
	t = (x0 - x1) / t;
	r = (1 - t) * ((1 - t) * y0 + 2.0 * t * y1) + t * t * y2;	/* By(t=P4) */
	t = (x0 * x2 - x1 * x1) * t / (x0 - x1);	/* gradient dP4/dx=0 */
	x = ifloor(t + 0.5);
	y = ifloor(r + 0.5);
	r = (y1 - y0) * (t - x0) / (x1 - x0) + y0;	/* intersect P3 | P0 P1 */
	plotQuadBezierSeg(x0, y0, x, ifloor(r + 0.5), x, y);
	r = (y1 - y2) * (t - x2) / (x1 - x2) + y2;	/* intersect P4 | P1 P2 */
	x0 = x1 = x;
	y0 = y;
	y1 = ifloor(r + 0.5);	/* P0 = P4, P1 = P8 */
    }
    if ((long) (y0 - y1) * (y2 - y1) > 0) {	/* vertical cut at P6? */
	t = y0 - 2 * y1 + y2;
	t = (y0 - y1) / t;
	r = (1 - t) * ((1 - t) * x0 + 2.0 * t * x1) + t * t * x2;	/* Bx(t=P6) */
	t = (y0 * y2 - y1 * y1) * t / (y0 - y1);	/* gradient dP6/dy=0 */
	x = ifloor(r + 0.5);
	y = ifloor(t + 0.5);
	r = (x1 - x0) * (t - y0) / (y1 - y0) + x0;	/* intersect P6 | P0 P1 */
	plotQuadBezierSeg(x0, y0, ifloor(r + 0.5), y, x, y);
	r = (x1 - x2) * (t - y2) / (y1 - y2) + x2;	/* intersect P7 | P1 P2 */
	x0 = x;
	x1 = ifloor(r + 0.5);
	y0 = y1 = y;		/* P0 = P6, P1 = P7 */
    }
    plotQuadBezierSeg(x0, y0, x1, y1, x2, y2);	/* remaining part */
}
#endif

static void
plotCubicBezierSeg(int x0, int y0,
		   double x1, double y1,
		   double x2, double y2,
		   int x3, int y3)
{				/* plot limited cubic Bezier segment */
    int f, fx, fy, tt;
    int leg = 1;
    int sx = x0 < x3 ? 1 : -1;
    int sy = y0 < y3 ? 1 : -1;	/* step direction */
    double xc = -fabs(x0 + x1 - x2 - x3);
    double xa = xc - 4 * sx * (x1 - x2);
    double xb = sx * (x0 - x1 - x2 + x3);
    double yc = -fabs(y0 + y1 - y2 - y3);
    double ya = yc - 4 * sy * (y1 - y2);
    double yb = sy * (y0 - y1 - y2 + y3);
    double ab, ac, bc, cb, xx, xy, yy, dx, dy, ex, *pxy;
    double EP = 0.01;
    /* check for curve restrains */
    /* slope P0-P1 == P2-P3    and  (P0-P3 == P1-P2      or   no slope change) */
    assert((x1 - x0) * (x2 - x3) < EP &&
	   ((x3 - x0) * (x1 - x2) < EP || xb * xb < xa * xc + EP));
    assert((y1 - y0) * (y2 - y3) < EP &&
	   ((y3 - y0) * (y1 - y2) < EP || yb * yb < ya * yc + EP));

    if (xa == 0.0 && ya == 0.0) {	/* quadratic Bezier */
	sx = ifloor((3 * x1 - x0 + 1) / 2);
	sy = ifloor((3 * y1 - y0 + 1) / 2);	/* new midpoint */
	plotQuadBezierSeg(x0, y0, sx, sy, x3, y3);
	return;
    }
    x1 = (x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0) + 1;	/* line lengths */
    x2 = (x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3) + 1;
    do {			/* loop over both ends */
	ab = xa * yb - xb * ya;
	ac = xa * yc - xc * ya;
	bc = xb * yc - xc * yb;
	ex = ab * (ab + ac - 3 * bc) + ac * ac;		/* P0 part of self-intersection loop? */
	f = ((ex > 0.0)
	     ? 1
	     : isqrt(1 + 1024 / x1));	/* calculate resolution */
	ab *= f;
	ac *= f;
	bc *= f;
	ex *= f * f;		/* increase resolution */
	xy = 9 * (ab + ac + bc) / 8;
	cb = 8 * (xa - ya);	/* init differences of 1st degree */
	dx = 27 * (8 * ab * (yb * yb - ya * yc) +
		   ex * (ya + 2 * yb + yc)) / 64 - ya * ya * (xy - ya);
	dy = 27 * (8 * ab * (xb * xb - xa * xc) -
		   ex * (xa + 2 * xb + xc)) / 64 - xa * xa * (xy + xa);
	/* init differences of 2nd degree */
	xx = 3 * (3 * ab * (3 * yb * yb - ya * ya - 2 * ya * yc) -
		  ya * (3 * ac * (ya + yb) + ya * cb)) / 4;
	yy = 3 * (3 * ab * (3 * xb * xb - xa * xa - 2 * xa * xc) -
		  xa * (3 * ac * (xa + xb) + xa * cb)) / 4;
	xy = xa * ya * (6 * ab + 6 * ac - 3 * bc + cb);
	ac = ya * ya;
	cb = xa * xa;
	xy = 3 * (xy + 9 * f * (cb * yb * yc - xb * xc * ac) -
		  18 * xb * yb * ab) / 8;

	if (ex < 0) {		/* negate values if inside self-intersection loop */
	    dx = -dx;
	    dy = -dy;
	    xx = -xx;
	    yy = -yy;
	    xy = -xy;
	    ac = -ac;
	    cb = -cb;
	}			/* init differences of 3rd degree */
	ab = 6 * ya * ac;
	ac = -6 * xa * ac;
	bc = 6 * ya * cb;
	cb = -6 * xa * cb;
	dx += xy;
	ex = dx + dy;
	dy += xy;		/* error of 1st step */

	for (pxy = &xy, fx = fy = f; x0 != x3 && y0 != y3;) {
	    setPixel(x0, y0);	/* plot curve */
	    do {		/* move sub-steps of one pixel */
		if (dx > *pxy || dy < *pxy)
		    goto exit;	/* confusing values */
		y1 = 2 * ex - dy;	/* save value for test of y step */
		if (2 * ex >= dx) {	/* x sub-step */
		    fx--;
		    ex += dx += xx;
		    dy += xy += ac;
		    yy += bc;
		    xx += ab;
		}
		if (y1 <= 0) {	/* y sub-step */
		    fy--;
		    ex += dy += yy;
		    dx += xy += bc;
		    xx += ac;
		    yy += cb;
		}
	    } while (fx > 0 && fy > 0);		/* pixel complete? */
	    if (2 * fx <= f) {
		x0 += sx;
		fx += f;
	    }			/* x step */
	    if (2 * fy <= f) {
		y0 += sy;
		fy += f;
	    }			/* y step */
	    if (pxy == &xy && dx < 0 && dy > 0)
		pxy = &EP;	/* pixel ahead valid */
	}
      exit:
	EXCHANGE(x0, x3, tt);
	sx = -sx;
	xb = -xb;		/* swap legs */
	EXCHANGE(y0, y3, tt);
	sy = -sy;
	yb = -yb;
	x1 = x2;
    } while (leg--);		/* try other end */
    plotLine(x0, y0, x3, y3);	/* remaining part in case of cusp or crunode */
}

static void
plotCubicBezier(int x0, int y0, int x1, int y1,
		int x2, int y2, int x3, int y3)
{				/* plot any cubic Bezier curve */
    int n = 0, i = 0;
    long xc = x0 + x1 - x2 - x3;
    long xa = xc - 4 * (x1 - x2);
    long xb = x0 - x1 - x2 + x3;
    long xd = xb + 4 * (x1 + x2);
    long yc = y0 + y1 - y2 - y3;
    long ya = yc - 4 * (y1 - y2);
    long yb = y0 - y1 - y2 + y3;
    long yd = yb + 4 * (y1 + y2);
    double fx0 = x0;
    double fy0 = y0;
    double t1 = (double) (xb * xb - xa * xc), t2, t[5];

#ifdef DEBUG_BEZIER
    printf("plotCubicBezier(%d,%d, %d,%d, %d,%d, %d,%d\n",
	   x0, y0, x1, y1, x2, y2, x3, y3);
#endif
    /* sub-divide curve at gradient sign changes */
    if (xa == 0) {		/* horizontal */
	if (labs(xc) < 2 * labs(xb))
	    t[n++] = (double) xc / (2.0 * (double) xb);		/* one change */
    } else if (t1 > 0.0) {	/* two changes */
	t2 = sqrt(t1);
	t1 = ((double) xb - t2) / (double) xa;
	if (fabs(t1) < 1.0)
	    t[n++] = t1;
	t1 = ((double) xb + t2) / (double) xa;
	if (fabs(t1) < 1.0)
	    t[n++] = t1;
    }
    t1 = (double) (yb * yb - ya * yc);
    if (ya == 0) {		/* vertical */
	if (labs(yc) < 2 * labs(yb))
	    t[n++] = (double) yc / (2.0 * (double) yb);		/* one change */
    } else if (t1 > 0.0) {	/* two changes */
	t2 = sqrt(t1);
	t1 = ((double) yb - t2) / (double) ya;
	if (fabs(t1) < 1.0)
	    t[n++] = t1;
	t1 = ((double) yb + t2) / (double) ya;
	if (fabs(t1) < 1.0)
	    t[n++] = t1;
    }
    for (i = 1; i < n; i++)	/* bubble sort of 4 points */
	if ((t1 = t[i - 1]) > t[i]) {
	    t[i - 1] = t[i];
	    t[i] = t1;
	    i = 0;
	}

    t1 = -1.0;
    t[n] = 1.0;			/* begin / end point */
    for (i = 0; i <= n; i++) {	/* plot each segment separately */
	double fx1, fx2, fx3;
	double fy1, fy2, fy3;

	t2 = t[i];		/* sub-divide at t[i-1], t[i] */
	fx1 = (t1 * (t1 * (double) xb - (double) (2 * xc)) -
	       t2 * (t1 * (t1 * (double) xa - (double) (2 * xb)) + (double)
		     xc) + (double) xd) / 8 - fx0;
	fy1 = (t1 * (t1 * (double) yb - (double) (2 * yc)) -
	       t2 * (t1 * (t1 * (double) ya - (double) (2 * yb)) + (double)
		     yc) + (double) yd) / 8 - fy0;
	fx2 = (t2 * (t2 * (double) xb - (double) (2 * xc)) -
	       t1 * (t2 * (t2 * (double) xa - (double) (2 * xb)) + (double)
		     xc) + (double) xd) / 8 - fx0;
	fy2 = (t2 * (t2 * (double) yb - (double) (2 * yc)) -
	       t1 * (t2 * (t2 * (double) ya - (double) (2 * yb)) + (double)
		     yc) + (double) yd) / 8 - fy0;
	fx0 -= fx3 = (t2 * (t2 * ((double) (3 * xb) - t2 * (double) xa) -
			    (double) (3 * xc)) + (double) xd) / 8;
	fy0 -= fy3 = (t2 * (t2 * ((double) (3 * yb) - t2 * (double) ya) -
			    (double) (3 * yc)) + (double) yd) / 8;
	x3 = ifloor(fx3 + 0.5);
	y3 = ifloor(fy3 + 0.5);	/* scale bounds to int */
	if (fx0 != 0.0) {
	    fx1 *= fx0 = (x0 - x3) / fx0;
	    fx2 *= fx0;
	}
	if (fy0 != 0.0) {
	    fy1 *= fy0 = (y0 - y3) / fy0;
	    fy2 *= fy0;
	}
	if (x0 != x3 || y0 != y3)	/* segment t1 - t2 */
	    plotCubicBezierSeg(x0, y0,
			       x0 + fx1, y0 + fy1,
			       x0 + fx2, y0 + fy2,
			       x3, y3);
	x0 = x3;
	y0 = y3;
	fx0 = fx3;
	fy0 = fy3;
	t1 = t2;
    }
}

#if 0
static void
plotQuadSpline(int n, int x[], int y[], int skip_segments)
{				/* plot quadratic spline, destroys input arrays x,y */
#define M_MAX 12
    double mi = 1, m[M_MAX];	/* diagonal constants of matrix */
    int i, x0, y0, x1, y1, x2, y2;
#ifdef DEBUG_SPLINE_SEGMENTS
    int color = 0;
#endif

    assert(n > 1);		/* need at least 3 points P[0]..P[n] */

#ifdef DEBUG_SPLINE_POINTS
    {
	int save_pattern;

	i = 0;
	global_context->temporary_write_controls.foreground = 11;
	save_pattern = global_context->temporary_write_controls.pattern;
	global_context->temporary_write_controls.pattern = 0xff;
	draw_patterned_arc(global_context, x[i], y[i], x[i] + 2, y[i], 0,
			   3600, NULL, NULL);
	i++;
	global_context->temporary_write_controls.foreground = 15;
	for (; i < n; i++) {
	    draw_patterned_arc(global_context,
			       x[i], y[i],
			       x[i] + 2, y[i],
			       0, 3600, NULL, NULL);
	}
	global_context->temporary_write_controls.foreground = 10;
	draw_patterned_arc(global_context, x[i], y[n], x[i] + 2, y[i], 0,
			   3600, NULL, NULL);
	global_context->temporary_write_controls.pattern = save_pattern;
    }
#endif

    x2 = x[n];
    y2 = y[n];

    x[1] = x0 = 8 * x[1] - 2 * x[0];	/* first row of matrix */
    y[1] = y0 = 8 * y[1] - 2 * y[0];

    for (i = 2; i < n; i++) {	/* forward sweep */
	if (i - 2 < M_MAX)
	    m[i - 2] = mi = 1.0 / (6.0 - mi);
	x[i] = x0 = ifloor(8 * x[i] - x0 * mi + 0.5);	/* store yi */
	y[i] = y0 = ifloor(8 * y[i] - y0 * mi + 0.5);
    }
    x1 = ifloor((x0 - 2 * x2) / (5.0 - mi) + 0.5);	/* correction last row */
    y1 = ifloor((y0 - 2 * y2) / (5.0 - mi) + 0.5);

    for (i = n - 2; i > 0; i--) {	/* back substitution */
	if (i <= M_MAX)
	    mi = m[i - 1];
	x0 = ifloor((x[i] - x1) * mi + 0.5);	/* next corner */
	y0 = ifloor((y[i] - y1) * mi + 0.5);
#ifdef DEBUG_SPLINE_SEGMENTS
	color++;
	global_context->temporary_write_controls.foreground = color;
#endif
	if ((n - 2) - i < skip_segments)
	    plotQuadBezier((x0 + x1) / 2, (y0 + y1) / 2, x1, y1, x2, y2);
	x2 = (x0 + x1) / 2;
	x1 = x0;
	y2 = (y0 + y1) / 2;
	y1 = y0;
    }
#ifdef DEBUG_SPLINE_SEGMENTS
    color++;
    global_context->temporary_write_controls.foreground = color;
#endif
    if (skip_segments > 0)
	plotQuadBezier(x[0], y[0], x1, y1, x2, y2);
}
#endif

static void
plotCubicSpline(int n, int x[], int y[], int skip_first_last)
{
#define M_MAX 12
    double mi = 0.25, m[M_MAX];	/* diagonal constants of matrix */
    int x3, y3, x4, y4;
    int i, x0, y0, x1, y1, x2, y2;
#ifdef DEBUG_SPLINE_SEGMENTS
    RegisterNum color = 0;
#endif

    assert(n > 2);		/* need at least 4 points P[0]..P[n] */
#ifdef __CPPCHECK__
    memset(m, 0, sizeof(m));	/* work around false-positive */
#endif

#ifdef DEBUG_SPLINE_POINTS
    {
	unsigned save_pattern;

	i = 0;
	global_context->temporary_write_controls.foreground = 11;
	save_pattern = global_context->temporary_write_controls.pattern;
	global_context->temporary_write_controls.pattern = 0xff;
	draw_patterned_arc(global_context, x[i], y[i], x[i] + 2, y[i], 0,
			   3600, NULL, NULL);
	i++;
	global_context->temporary_write_controls.foreground = 15;
	for (; i < n; i++) {
	    draw_patterned_arc(global_context,
			       x[i], y[i],
			       x[i] + 2, y[i],
			       0, 3600, NULL, NULL);
	}
	global_context->temporary_write_controls.foreground = 10;
	draw_patterned_arc(global_context, x[i], y[i], x[i] + 2, y[i], 0,
			   3600, NULL, NULL);
	global_context->temporary_write_controls.pattern = save_pattern;
    }
#endif

    x3 = x[n - 1];
    y3 = y[n - 1];
    x4 = x[n];
    y4 = y[n];

    x[1] = x0 = 12 * x[1] - 3 * x[0];	/* first row of matrix */
    y[1] = y0 = 12 * y[1] - 3 * y[0];

    for (i = 2; i < n; i++) {	/* forward sweep */
	if (i - 2 < M_MAX)
	    m[i - 2] = mi = 0.25 / (2.0 - mi);
	x[i] = x0 = ifloor(12 * x[i] - 2 * x0 * mi + 0.5);
	y[i] = y0 = ifloor(12 * y[i] - 2 * y0 * mi + 0.5);
    }
    x2 = ifloor((x0 - 3 * x4) / (7 - 4 * mi) + 0.5);	/* correct last row */
    /* printf("y0=%d, y4=%d mi=%g\n", y0, y4, mi); */
    y2 = ifloor((y0 - 3 * y4) / (7 - 4 * mi) + 0.5);
    /* printf("y2=%d, y3=%d, y4=%d\n", y2, y3, y4); */
#ifdef DEBUG_SPLINE_SEGMENTS
    color++;
    global_context->temporary_write_controls.foreground = color;
#endif
    if (!skip_first_last)
	plotCubicBezier(x3, y3, (x2 + x4) / 2, (y2 + y4) / 2, x4, y4, x4, y4);

    if (n - 3 < M_MAX)
	mi = m[n - 3];
    x1 = ifloor((x[n - 2] - 2 * x2) * mi + 0.5);
    y1 = ifloor((y[n - 2] - 2 * y2) * mi + 0.5);
    for (i = n - 3; i > 0; i--) {	/* back substitution */
	if (i <= M_MAX)
	    mi = m[i - 1];
	x0 = ifloor((x[i] - 2 * x1) * mi + 0.5);
	y0 = ifloor((y[i] - 2 * y1) * mi + 0.5);
	x4 = ifloor((x0 + 4 * x1 + x2 + 3) / 6.0);	/* reconstruct P[i] */
	y4 = ifloor((y0 + 4 * y1 + y2 + 3) / 6.0);
#ifdef DEBUG_SPLINE_SEGMENTS
	color++;
	global_context->temporary_write_controls.foreground = color;
#endif
#define CB_PARM(num) ifloor((num) / 3.0 + 0.5)
	plotCubicBezier(x4, y4,
			CB_PARM(2 * x1 + x2),
			CB_PARM(2 * y1 + y2),
			CB_PARM(x1 + 2 * x2),
			CB_PARM(y1 + 2 * y2),
			x3, y3);
	x3 = x4;
	y3 = y4;
	x2 = x1;
	y2 = y1;
	x1 = x0;
	y1 = y0;
    }
    x0 = x[0];
    x4 = ifloor((3 * x0 + 7 * x1 + 2 * x2 + 6) / 12.0);		/* reconstruct P[1] */
    y0 = y[0];
    y4 = ifloor((3 * y0 + 7 * y1 + 2 * y2 + 6) / 12.0);
#ifdef DEBUG_SPLINE_SEGMENTS
    global_context->temporary_write_controls.foreground = 4;
#endif
    plotCubicBezier(x4, y4,
		    CB_PARM(2 * x1 + x2),
		    CB_PARM(2 * y1 + y2),
		    CB_PARM(x1 + 2 * x2),
		    CB_PARM(y1 + 2 * y2),
		    x3, y3);
#ifdef DEBUG_SPLINE_SEGMENTS
    color++;
    global_context->temporary_write_controls.foreground = color;
#endif
    if (!skip_first_last)
	plotCubicBezier(x0, y0, x0, y0, (x0 + x1) / 2, (y0 + y1) / 2, x4, y4);
}

static unsigned
find_free_alphabet_index(RegisGraphicsContext *context, unsigned alphabet,
			 unsigned pixw, unsigned pixh)
{
    unsigned ii, jj;

    /* try an exact match */
    for (ii = 0U; ii < MAX_REGIS_ALPHABETS; ii++) {
	if (context->alphabets[ii].alphabet_num == alphabet &&
	    context->alphabets[ii].pixw == pixw &&
	    context->alphabets[ii].pixh == pixh) {
	    return ii;
	}
    }

    /* otherwise use any empty slot */
    for (ii = 0U; ii < MAX_REGIS_ALPHABETS; ii++) {
	if (context->alphabets[ii].alphabet_num == INVALID_ALPHABET_NUM) {
	    context->alphabets[ii].alphabet_num = alphabet;
	    context->alphabets[ii].pixw = pixw;
	    context->alphabets[ii].pixh = pixh;
	    return ii;
	}
    }

    /* otherwise recycle a slot with a different font size */
    for (ii = 0U; ii < MAX_REGIS_ALPHABETS; ii++) {
	if (context->alphabets[ii].alphabet_num == alphabet) {
	    context->alphabets[ii].pixw = pixw;
	    context->alphabets[ii].pixh = pixh;
	    context->alphabets[ii].name[0] = '\0';
	    context->alphabets[ii].fontname[0] = '\0';
	    context->alphabets[ii].use_font = 0;
	    if (context->alphabets[ii].bytes != NULL) {
		free(context->alphabets[ii].bytes);
		context->alphabets[ii].bytes = NULL;
	    }
	    for (jj = 0U; jj < MAX_GLYPHS; jj++) {
		context->alphabets[ii].loaded[jj] = 0;
	    }
	    return ii;
	}
    }

    /* finally just recycle this arbitrary slot */
    context->alphabets[0U].alphabet_num = alphabet;
    context->alphabets[0U].pixw = pixw;
    context->alphabets[0U].pixh = pixh;
    context->alphabets[0U].name[0] = '\0';
    context->alphabets[0U].fontname[0] = '\0';
    context->alphabets[0U].use_font = 0;
    if (context->alphabets[0U].bytes != NULL) {
	free(context->alphabets[0U].bytes);
	context->alphabets[0U].bytes = NULL;
    }
    for (jj = 0U; jj < MAX_GLYPHS; jj++) {
	context->alphabets[0U].loaded[jj] = 0;
    }

    return 0U;
}

#ifdef DEBUG_SPECIFIC_CHAR_METRICS
static void
dump_bitmap_pixels(Char const *pixels, unsigned w, unsigned h)
{
    unsigned yy, xx;

    for (yy = 0U; yy < h; yy++) {
	printf(" ");
	for (xx = 0U; xx < w; xx++) {
	    if (pixels[yy * w + xx]) {
		printf("#");
	    } else {
		printf("_");
	    }
	}
	printf("\n");
    }
}
#endif

#if OPT_RENDERFONT && defined(HAVE_TYPE_FCCHAR32)
static int
copy_bitmap_from_xft_font(XtermWidget xw, XftFont *font, FcChar32 ch,
			  Char *pixels, unsigned w, unsigned h,
			  unsigned xmin, unsigned ymin)
{
    /*
     * FIXME: cache:
     * - the bitmap for the last M characters and target dimensions
     * - reuse the pixmap object where possible
     */
    Display *display = XtDisplay(xw);
    Screen *screen = XtScreen(xw);
    XftColor bg, fg;
    Pixmap bitmap;
    XftDraw *draw;
    XImage *image;
    GC glyph_gc;
    unsigned bmw, bmh;
    unsigned xx, yy;

    bmw = w + xmin;
    bmh = h;
    if (bmw < 1 || bmh < 1) {
	TRACE(("refusing impossible bitmap size w=%d h=%d xmin=%d ymin=%d for ch='%c'\n",
	       bmw, bmh, xmin, ymin, ch));
	return 0;
    }
    bitmap = XCreatePixmap(display,
			   DefaultRootWindow(display),
			   bmw, bmh, (unsigned) getVisualDepth(xw));
    if (bitmap == None) {
	TRACE(("unable to create Pixmap for Xft\n"));
	return 0;
    }
    draw = XftDrawCreate(display, bitmap, xw->visInfo->visual,
			 XDefaultColormap(display,
					  XScreenNumberOfScreen(screen)));
    if (!draw) {
	TRACE(("unable to create XftDraw\n"));
	XFreePixmap(display, bitmap);
	return 0;
    }

    bg.pixel = 0UL;
    bg.color.red = 0;
    bg.color.green = 0;
    bg.color.blue = 0;
    bg.color.alpha = 0x0;
    XftDrawRect(draw, &bg, 0, 0, bmw, bmh);

    fg.pixel = 1UL;
    fg.color.red = 0xffff;
    fg.color.green = 0xffff;
    fg.color.blue = 0xffff;
    fg.color.alpha = 0xffff;
    XftDrawString32(draw, &fg, font, -(int) xmin, font->ascent - (int) ymin,
		    &ch, 1);

    glyph_gc = XCreateGC(display, bitmap, 0UL, NULL);
    if (!glyph_gc) {
	TRACE(("unable to create GC\n"));
	XftDrawDestroy(draw);
	XFreePixmap(display, bitmap);
	return 0;
    }
    XSetForeground(display, glyph_gc, 1UL);
    XSetBackground(display, glyph_gc, 0UL);
    image = XGetImage(display, bitmap, 0, 0, w, h, 1UL, XYPixmap);
    if (!image) {
	TRACE(("unable to create XImage\n"));
	XFreeGC(display, glyph_gc);
	XftDrawDestroy(draw);
	XFreePixmap(display, bitmap);
	return 0;
    }

    for (yy = 0U; yy < h; yy++) {
#ifdef DEBUG_XFT_GLYPH_COPY
	TRACE(("'%c'[%02u]:", ch, yy));
#endif
	for (xx = 0U; xx < w; xx++) {
	    unsigned long pix;
	    pix = XGetPixel(image, (int) xx, (int) yy);
	    pixels[yy * w + xx] = (unsigned char) pix;
#ifdef DEBUG_XFT_GLYPH_COPY
	    TRACE((" %lu", pix));
#endif
	}
#ifdef DEBUG_XFT_GLYPH_COPY
	TRACE(("\n"));
#endif
    }

    XFreeGC(display, glyph_gc);
    XDestroyImage(image);
    XftDrawDestroy(draw);
    XFreePixmap(display, bitmap);
    return 1;
}

static void
get_xft_glyph_dimensions(XtermWidget xw, XftFont *font, unsigned *w,
			 unsigned *h, unsigned *xmin, unsigned *ymin)
{
    unsigned workw, workh;
    FcChar32 ch;
    Char *pixels;
    Char *pixelp;
    unsigned yy, xx;
    unsigned char_count, pixel_count;
    unsigned real_minx, real_maxx, real_miny, real_maxy;
    unsigned char_minx, char_maxx, char_miny, char_maxy;

    /*
     * For each ASCII or ISO-8859-1 printable code, find out what its
     * dimensions are.
     *
     * We actually render the glyphs and determine the extents ourselves
     * because the font library can lie by several pixels, and since we are
     * doing manual character placement in fixed areas the glyph boundary needs
     * to be accurate.
     *
     * Ignore control characters and spaces - their extent information is
     * misleading.
     */

    /* Our "work area" is just a buffer which should be big enough to hold the
     * largest glyph even if its size is under-reported by a couple of pixels
     * in each dimension.
     */
    workw = (unsigned) font->max_advance_width + 2U;
    if (font->ascent + font->descent > font->height) {
	workh = (unsigned) (font->ascent + font->descent) + 2U;
    } else {
	workh = (unsigned) font->height + 2U;
    }

    if (!(pixels = TypeMallocN(Char, (size_t) (workw * workh)))) {
	*w = 0U;
	*h = 0U;
#ifdef DEBUG_COMPUTED_FONT_METRICS
	TRACE(("reported metrics:\n"));
	TRACE((" %ux%u ascent=%u descent=%u\n", font->max_advance_width,
	       font->height, font->ascent, font->descent));
	TRACE(("computed metrics:\n"));
	TRACE((" (unable to allocate pixel array)\n"));
#endif
	return;
    }

    /* FIXME: ch is in UCS32 -- try to support non-ASCII characters */
    char_count = 0U;
    real_minx = workw - 1U;
    real_maxx = 0U;
    real_miny = workh - 1U;
    real_maxy = 0U;
    for (ch = 33; ch < 256; ++ch) {
	if (ch >= 127 && ch <= 160) {
#ifdef DEBUG_SPECIFIC_CHAR_METRICS
	    if (IS_DEBUG_CHAR(ch))
		printf("char: '%c' not in interesting range; ignoring\n",
		       (char) ch);
#endif
	    continue;
	}
	if (!FcCharSetHasChar(font->charset, ch)) {
#ifdef DEBUG_SPECIFIC_CHAR_METRICS
	    if (IS_DEBUG_CHAR(ch))
		printf("char: '%c' not in charset; ignoring\n", (char) ch);
#endif
	    continue;
	}

	if (!copy_bitmap_from_xft_font(xw, font, ch, pixels,
				       workw, workh, 0U, 0U)) {
#ifdef DEBUG_SPECIFIC_CHAR_METRICS
	    if (IS_DEBUG_CHAR(ch))
		printf("char: '%c' bitmap could not be copied; ignoring\n",
		       (char) ch);
#endif
	    continue;
	}

	pixel_count = 0U;
	char_minx = workh - 1U;
	char_maxx = 0U;
	char_miny = workh - 1U;
	char_maxy = 0U;
	pixelp = pixels;
	for (yy = 0U; yy < workh; yy++) {
	    for (xx = 0U; xx < workw; xx++) {
		if (*pixelp++) {
		    if (xx < char_minx)
			char_minx = xx;
		    else if (xx > char_maxx)
			char_maxx = xx;
		    if (yy < char_miny)
			char_miny = yy;
		    else if (yy > char_maxy)
			char_maxy = yy;
		    pixel_count++;
		}
	    }
	}
	if (pixel_count < 1U) {
#ifdef DEBUG_SPECIFIC_CHAR_METRICS
	    if (IS_DEBUG_CHAR(ch))
		printf("char: '%c' has no pixels; ignoring\n", (char) ch);
#endif
	    continue;
	}
#ifdef DEBUG_SPECIFIC_CHAR_METRICS
	if (IS_DEBUG_CHAR(ch)) {
	    printf("char: '%c' (%d)\n", (char) ch, ch);
	    printf(" minx: %u\n", char_minx);
	    printf(" maxx: %u\n", char_maxx);
	    printf(" miny: %u\n", char_miny);
	    printf(" maxy: %u\n", char_maxy);
	    dump_bitmap_pixels(pixels, workw, workh);
	    printf("\n");
	}
#endif

	if (char_minx < real_minx)
	    real_minx = char_minx;
	if (char_maxx > real_maxx)
	    real_maxx = char_maxx;
	if (char_miny < real_miny)
	    real_miny = char_miny;
	if (char_maxy > real_maxy)
	    real_maxy = char_maxy;
	char_count++;
    }

    free(pixels);

    if (char_count < 1U) {
#ifdef DEBUG_COMPUTED_FONT_METRICS
	TRACE(("reported metrics:\n"));
	TRACE((" %ux%u ascent=%u descent=%u\n", font->max_advance_width,
	       font->height, font->ascent, font->descent));
	TRACE(("computed metrics:\n"));
	TRACE((" (no characters found)\n"));
#endif
	*w = 0U;
	*h = 0U;
	return;
    }

    *w = (unsigned) (1 + real_maxx - real_minx);
    *h = (unsigned) (1 + real_maxy - real_miny);
    *xmin = real_minx;
    *ymin = real_miny;

#ifdef DEBUG_COMPUTED_FONT_METRICS
    printf("reported metrics:\n");
    printf(" %ux%u ascent=%u descent=%u\n", font->max_advance_width,
	   font->height, font->ascent, font->descent);
    printf("computed metrics:\n");
    printf(" real_minx=%u real_maxx=%u real_miny=%u real_maxy=%u\n",
	   real_minx, real_maxx, real_miny, real_maxy);
    printf(" final: %ux%u xmin=%u ymin=%u\n", *w, *h, *xmin, *ymin);
#endif
}

#define FONT_SIZE_CACHE_SIZE 32U

typedef struct {
    XftFont *font_data;
    char fontname[REGIS_FONTNAME_LEN];
    unsigned maxw, maxh, max_pixels;
    unsigned targeth;
    unsigned w, h;
    unsigned xmin;
    unsigned ymin;
} FONT_CACHE;

static FONT_CACHE font_cache[FONT_SIZE_CACHE_SIZE];

static void
close_xft_font(XtermWidget xw, XftFont *font)
{
    if (font != NULL) {
	Display *display = XtDisplay(xw);
	unsigned ii;
	for (ii = 0; ii < FONT_SIZE_CACHE_SIZE; ++ii) {
	    if (font == font_cache[ii].font_data) {
		font_cache[ii].font_data = NULL;
		break;
	    }
	}
	XftFontClose(display, font);
    }
}

/* Find the font pixel size which returns the font which is closest to the given
 * maxw and maxh without overstepping either dimension.
 */
static XftFont *
find_best_xft_font_size(XtermWidget xw,
			char const *fontname,
			unsigned maxw,
			unsigned maxh,
			unsigned max_pixels,
			unsigned *w,
			unsigned *h,
			unsigned *xmin,
			unsigned *ymin)
{
    Display *display = XtDisplay(xw);
    Screen *screen = XtScreen(xw);
    XftFont *font;
    unsigned targeth;
    unsigned ii;
    FONT_CACHE *cp = NULL;

    assert(display);
    assert(screen);
    assert(fontname);
    assert(w);
    assert(h);
    assert(xmin);
    assert(ymin);

#ifdef DEBUG_FONT_SIZE_SEARCH
    TRACE(("determining best size of font \"%s\" for %ux%u glyph with max_pixels=%u\n",
	   fontname, maxw, maxh, max_pixels));
#endif
    for (ii = 0U; ii < FONT_SIZE_CACHE_SIZE; ii++) {
	if (font_cache[ii].maxw == maxw &&
	    font_cache[ii].maxh == maxh &&
	    font_cache[ii].max_pixels == max_pixels &&
	    strcmp(font_cache[ii].fontname, fontname) == 0) {
	    cp = &font_cache[ii];
	    if (cp->font_data) {
		*w = cp->w;
		*h = cp->h;
		*xmin = cp->xmin;
		*ymin = cp->ymin;
		return cp->font_data;
	    }
	    break;
	}
    }

    if (cp != NULL) {
	targeth = cp->targeth;
    } else {
	targeth = maxh * 8U + 5U;
    }

#define MAX_TARGETH 720U	/* above this level, fontconfig chokes */
    if (targeth > MAX_TARGETH)
	targeth = MAX_TARGETH;

    for (;;) {
	if (targeth <= 5U) {
	    TRACE(("Giving up finding suitable Xft font size for \"%s\" at %ux%u.\n",
		   fontname, maxw, maxh));
	    return NULL;
	}

	/*
	 * Xft does a bad job at:
	 *  - two-color low-resolution anti-aliased fonts
	 *  - non-anti-aliased fonts at low resolution unless a font size is
	 *    given (pixel size does not help, and the value of the font size
	 *    doesn't appear to matter).
	 *
	 * In those two cases it literally drops pixels, sometimes whole
	 * columns, making the glyphs unreadable and at least ugly even when
	 * readable.
	 */
	font = NULL;
	/*
	 * FIXME:
	 * Also, we need to scale the width and height separately.  The
	 * CHAR_WIDTH and CHAR_HEIGHT attributes would seem to be ideal, but
	 * don't appear to have any effect if set.  Instead we will manually
	 * scale the bitmap later, which may be very ugly because we won't try
	 * to identify different parts of glyphs or preserve density.
	 */
	{
	    XftPattern *pat;
	    XftPattern *match;
	    XftResult status;

	    if ((pat = XftNameParse(fontname)) != NULL) {
#ifdef DEBUG_FONT_SIZE_SEARCH
		TRACE(("trying targeth=%g\n", targeth / 10.0));
#endif
		XftPatternBuild(pat,
				XFT_PIXEL_SIZE, XftTypeDouble, (double)
				targeth / 10.0,
				XFT_SPACING, XftTypeInteger, XFT_MONO,
				XFT_SLANT, XftTypeInteger, 0,
				XFT_ANTIALIAS, XftTypeBool, False,
				NULL);
		if ((match = XftFontMatch(display,
					  XScreenNumberOfScreen(screen),
					  pat, &status)) != NULL) {
		    font = XftFontOpenPattern(display, match);
		    maybeXftCache(xw, font);
		}
		XftPatternDestroy(pat);
	    }
	}
	if (!font) {
	    TRACE(("unable to open a monospaced Xft font matching \"%s\" with pixelsize %g\n",
		   fontname, targeth / 10.0));
	    return NULL;
	}
#ifdef DEBUG_FONT_SIZE_SEARCH
	{
	    char buffer[1024];

	    if (XftNameUnparse(font->pattern, buffer, (int) sizeof(buffer))) {
		TRACE(("Testing font named \"%s\"\n", buffer));
	    } else {
		TRACE(("Testing unknown font\n"));
	    }
	}
#endif

	if (cp != NULL &&
	    targeth == cp->targeth) {
	    *w = cp->w;
	    *h = cp->h;
	    *xmin = cp->xmin;
	    *ymin = cp->ymin;
	} else {
	    get_xft_glyph_dimensions(xw, font, w, h, xmin, ymin);

	    if (*w < 1 || *h < 1) {
#ifdef DEBUG_FONT_SIZE_SEARCH
		TRACE(("got %ux%u dimensions for target size targeth=%d; trying reduced target size\n",
		       *w, *h, targeth));
#endif
		targeth--;
		continue;
	    }
	}
#ifdef DEBUG_FONT_SIZE_SEARCH
	TRACE(("checking max=%ux%u targeth=%u.%u\n", maxw, maxh, targeth /
	       10U, targeth % 10U));
#endif

	if (*h > maxh) {
	    float ratio = (float) (*h) / (float) maxh;
	    XftFontClose(display, font);
#ifdef DEBUG_FONT_SIZE_SEARCH
	    TRACE(("got %ux%u glyph; too tall; reducing target size\n", *w, *h));
#endif
	    if (targeth >= 10U && ratio > 1.1) {
		targeth = (unsigned) ((float) targeth / ratio);
	    } else {
		targeth--;
	    }
	    continue;
	}
	if (*w > maxw) {
	    float ratio = (float) (*w) / (float) maxw;
	    XftFontClose(display, font);
#ifdef DEBUG_FONT_SIZE_SEARCH
	    TRACE(("got %ux%u glyph; too wide; reducing target size\n", *w, *h));
#endif
	    if (targeth >= 10U && ratio > 1.1) {
		targeth = (unsigned) ((float) targeth / ratio);
	    } else {
		targeth--;
	    }
	    continue;
	}
	if (*w * *h > max_pixels) {
	    XftFontClose(display, font);
#ifdef DEBUG_FONT_SIZE_SEARCH
	    TRACE(("got %ux%u glyph; too many pixels; reducing target size\n",
		   *w, *h));
#endif
	    if (*w * *h > 2U * max_pixels) {
		unsigned min = *w < *h ? *w : *h;
		unsigned divisor = (*w * *h) / (max_pixels * min);
		if (divisor > 1U) {
		    targeth /= divisor;
		} else if (targeth > 10U) {
		    targeth -= 10U;
		} else {
		    targeth--;
		}
	    } else {
		targeth--;
	    }
	    continue;
	}
#ifdef DEBUG_FONT_NAME
	{
	    char buffer[1024];

	    if (XftNameUnparse(font->pattern, buffer, (int) sizeof(buffer))) {
		TRACE(("Final font for \"%s\" max %dx%d is \"%s\"\n",
		       fontname, maxw, maxh, buffer));
	    } else {
		TRACE(("Final font for \"%s\" max %dx%d is unknown\n",
		       fontname, maxw, maxh));
	    }
	}
#endif

	if (cp == NULL) {
	    for (ii = 0U; ii < FONT_SIZE_CACHE_SIZE; ii++) {
		if (font_cache[ii].maxw == 0U ||
		    font_cache[ii].maxh == 0U ||
		    font_cache[ii].max_pixels == 0U) {
		    cp = &font_cache[ii];
		    break;
		}
	    }
	    if (cp == NULL) {
		ii = targeth % FONT_SIZE_CACHE_SIZE;
		cp = &font_cache[ii];
		close_xft_font(xw, cp->font_data);
	    }
	    CopyFontname(cp->fontname, fontname);
	    cp->maxw = maxw;
	    cp->maxh = maxh;
	    cp->max_pixels = max_pixels;
	    cp->targeth = targeth;
	    cp->w = *w;
	    cp->h = *h;
	    cp->xmin = *xmin;
	    cp->ymin = *ymin;
	}
	cp->font_data = font;
	return font;
    }
}
#endif

static int
get_xft_bitmap_of_character(RegisGraphicsContext const *context,
			    char const *fontname, int ch,
			    unsigned maxw, unsigned maxh, Char *pixels,
			    unsigned max_pixels, unsigned *w, unsigned *h)
{
    /*
     * See Xft / RENDERFONT stuff in fontutils.c and used in utils.c
     * Add a separate configuration for ReGIS.
     */
    /*
     * FIXME: cache:
     * - reuse the font where possible
     */
#ifdef XRENDERFONT
    XtermWidget xw = context->destination_graphic->xw;
    XftFont *font;
    unsigned xmin = 0U, ymin = 0U;

# ifdef DEBUG_XFT_GLYPH_LOADING
    TRACE(("trying to load glyph '%c' at max size %dx%d\n", ch, maxw, maxh));
# endif
    if (!(font = find_best_xft_font_size(xw, fontname, maxw, maxh,
					 max_pixels, w, h, &xmin, &ymin))) {
	TRACE(("Unable to find suitable Xft font\n"));
	return 0;
    }

    if (*w == 0U || *h == 0U) {
	TRACE(("empty glyph found for '%c'\n", ch));
	close_xft_font(xw, font);
	return 1;
    }

    if (!copy_bitmap_from_xft_font(xw, font, CharOf(ch), pixels, *w, *h,
				   xmin, ymin)) {
	TRACE(("Unable to create bitmap for '%c'\n", ch));
	close_xft_font(xw, font);
	return 0;
    }
# ifdef DEBUG_XFT_GLYPH_LOADING
    TRACE(("loaded glyph '%c' at max size %dx%d\n", ch, maxw, maxh));
# endif

    return 1;
#else
    (void) context;
    (void) fontname;
    (void) ch;
    (void) maxw;
    (void) maxh;
    (void) pixels;
    (void) max_pixels;
    (void) w;
    (void) h;

    TRACE(("Not rendering Xft font for ReGIS (support not compiled in).\n"));
    return 0;
#endif
}

static unsigned
find_best_alphabet_index(RegisGraphicsContext const *context,
			 unsigned minw, unsigned minh,
			 unsigned targetw, unsigned targeth,
			 unsigned max_pixels)
{
    unsigned ii;
    unsigned bestmatch;
    unsigned bestw, besth;

    assert(context);
    assert(targetw);
    assert(targeth);
    assert(max_pixels);

    bestmatch = MAX_REGIS_ALPHABETS;
    bestw = 0U;
    besth = 0U;
    for (ii = 0U; ii < MAX_REGIS_ALPHABETS; ii++) {
	if (context->alphabets[ii].alphabet_num ==
	    context->current_text_controls->alphabet_num &&
	    context->alphabets[ii].pixw >= minw &&
	    context->alphabets[ii].pixh >= minh &&
	    context->alphabets[ii].pixw <= targetw &&
	    context->alphabets[ii].pixh <= targeth &&
	    ((context->alphabets[ii].pixw >= bestw &&
	      context->alphabets[ii].pixh > besth) ||
	     (context->alphabets[ii].pixw > bestw &&
	      context->alphabets[ii].pixh >= besth)) &&
	    context->alphabets[ii].pixw *
	    context->alphabets[ii].pixh <= max_pixels) {
	    bestmatch = ii;
	    bestw = context->alphabets[ii].pixw;
	    besth = context->alphabets[ii].pixh;
	}
    }

    /* If we can't find one to scale up, look for one to scale down. */
    if (bestmatch == MAX_REGIS_ALPHABETS) {
	bestw = max_pixels;
	besth = max_pixels;
	for (ii = 0U; ii < MAX_REGIS_ALPHABETS; ii++) {
	    if (context->alphabets[ii].alphabet_num ==
		context->current_text_controls->alphabet_num &&
		context->alphabets[ii].pixw >= minw &&
		context->alphabets[ii].pixh >= minh &&
		((context->alphabets[ii].pixw <= bestw &&
		  context->alphabets[ii].pixh < besth) ||
		 (context->alphabets[ii].pixw < bestw &&
		  context->alphabets[ii].pixh <= besth)) &&
		context->alphabets[ii].pixw *
		context->alphabets[ii].pixh <= max_pixels) {
		bestmatch = ii;
		bestw = context->alphabets[ii].pixw;
		besth = context->alphabets[ii].pixh;
	    }
	}
    }
#ifdef DEBUG_ALPHABET_LOOKUP
    if (bestmatch < MAX_REGIS_ALPHABETS) {
	TRACE(("for target size %ux%u alphabet %u found index %u size %ux%u font=%s\n",
	       targetw, targeth, context->current_text_controls->alphabet_num,
	       bestmatch,
	       bestw, besth,
	       context->alphabets[bestmatch].use_font ?
	       context->alphabets[bestmatch].fontname : "(none)"));
    } else {
	TRACE(("for target size %ux%u alphabet %u found no suitable alphabets\n",
	       targetw, targeth, context->current_text_controls->alphabet_num));
    }
#endif

    return bestmatch;
}

#define GLYPH_WIDTH_BYTES(PIXW) ( ((PIXW) + 7U) >> 3U )

static int
get_user_bitmap_of_character(RegisGraphicsContext const *context,
			     int ch,
			     unsigned alphabet_index,
			     Char *pixels,
			     unsigned int max_pixels)
{
    const Char *glyph;
    unsigned w, h;
    unsigned xx, yy;
    unsigned byte, bit;

    assert(context);
    assert(pixels);

    if (!context->alphabets[alphabet_index].loaded[(Char) ch]) {
	TRACE(("BUG: in alphabet %u with alphabet index %u user glyph for '%c' not loaded\n",
	       context->current_text_controls->alphabet_num, alphabet_index,
	       ch));
	return 0;
    }

    assert(context->alphabets[alphabet_index].bytes);

    w = context->alphabets[alphabet_index].pixw;
    h = context->alphabets[alphabet_index].pixh;
    glyph = &context->alphabets[alphabet_index]
	.bytes[(Char) ch * GLYPH_WIDTH_BYTES(w) * h];

    if (w * h > max_pixels) {
	TRACE(("in alphabet %u with alphabet index %u user glyph for '%c' is too large: %ux%u (max_pixels=%u)\n",
	       context->current_text_controls->alphabet_num, alphabet_index,
	       ch, w, h, max_pixels));
	return 0;
    }

    for (yy = 0U; yy < h; yy++) {
	for (xx = 0U; xx < w; xx++) {
	    byte = yy * GLYPH_WIDTH_BYTES(w) + (xx >> 3U);
	    bit = xx & 7U;
	    pixels[yy * w + xx] = (Char) (((unsigned) glyph[byte]
					   >> (7U - bit)) & 1U);
	}
    }

    return 1;
}

/*
 * alphabets
 *  0    built-in
 *  1-N  custom (max is 3 on VT3X0 -- up to MAX_REGIS_ALPHABETS with xterm)
 *
 * built-in 7-bit charsets
 *  (B    ASCII
 *  (0    DEC special graphics
 *  (>    DEC technical
 *  (A    NCR British
 *  (4    NCR Dutch
 *  (5    NCR Finnish
 *  (R    NCR French
 *  (9    NCR French Canadian
 *  (K    NCR German
 *  (Y    NCR Italian
 *  ('    NCR Norwegian/Danish
 *  (!6   NCR Portuguese
 *  (Z    NCR Spanish
 *  (7    NCR Swedish
 *  (-    NCR Swiss
 *
 * -@   ???
 *
 * built-in 8-bit charsets
 *  )%5   DEC supplemental graphics
 *  -A    ISO Latin-1 supplemental
 *  )<    user-preferred supplemental (94 chars)
 *
 * defaults
 *  terminal  char cell size   charsets      angle
 *  VT3x0     S1               0:ASCII(94)   0 (positive)
 *
 */
static void
get_bitmap_of_character(RegisGraphicsContext const *context, int ch,
			unsigned maxw, unsigned maxh, Char *pixels,
			unsigned *w, unsigned *h, unsigned max_pixels)
{
    unsigned bestmatch;
    char const *fontname = NULL;

    assert(context);
    assert(w);
    assert(h);

#ifdef DEBUG_GLYPH_RETRIEVAL
    TRACE(("getting bitmap of glyph %d, current alphabet %d\n", ch,
	   context->current_text_controls->alphabet_num));
#endif

    if (maxw < 1U || maxh < 1U || max_pixels < 1U) {
	*w = 0U;
	*h = 0U;
	return;
    }

    if (context->current_text_controls->alphabet_num == 0)
	fontname = context->builtin_font;

    *w = 0U;
    *h = 0U;

    bestmatch = find_best_alphabet_index(context, 1U, 1U, maxw, maxh,
					 max_pixels);
    if (bestmatch < MAX_REGIS_ALPHABETS) {
	RegisAlphabet const *alpha = &context->alphabets[bestmatch];

#ifdef DEBUG_GLYPH_RETRIEVAL
	TRACE(("checking user glyph for slot=%u alphabet=%d use_font=%d loaded=%d\n",
	       bestmatch, alpha->alphabet_num, alpha->use_font,
	       alpha->loaded[ch]));
#endif
	if (!alpha->use_font &&
	    get_user_bitmap_of_character(context, ch, bestmatch, pixels,
					 max_pixels)) {
#ifdef DEBUG_GLYPH_RETRIEVAL
	    TRACE(("found user glyph for alphabet number %d (index %u)\n\n",
		   alpha->alphabet_num, bestmatch));
#endif
	    *w = alpha->pixw;
	    *h = alpha->pixh;
	    return;
	}

	if (alpha->use_font)
	    fontname = alpha->fontname;
    }

    if (fontname) {
#ifdef DEBUG_GLYPH_RETRIEVAL
	TRACE(("using xft font \"%s\"\n", fontname));
#endif
	if (get_xft_bitmap_of_character(context, fontname, ch,
					maxw, maxh, pixels,
					max_pixels, w, h)) {
	    if (*w > maxw) {
		TRACE(("BUG: Xft glyph is too wide: %ux%u but max is %ux%u\n",
		       *w, *h, maxw, maxh));
	    } else if (*h > maxh) {
		TRACE(("BUG: Xft glyph is too tall: %ux%u but max is %ux%u\n",
		       *w, *h, maxw, maxh));
	    } else if (*w * *h > max_pixels) {
		TRACE(("BUG: Xft glyph has too many pixels: %u but max is %u\n",
		       *w * *h, max_pixels));
	    } else {
		TRACE(("got glyph from \"%s\" for alphabet number %d\n",
		       fontname, context->current_text_controls->alphabet_num));
#ifdef DEBUG_SPECIFIC_CHAR_METRICS
		if (IS_DEBUG_CHAR(ch)) {
		    printf("got %ux%u Xft bitmap for '%c' target size %ux%u:\n",
			   *w, *h,
			   ch, maxw, maxh);
		    dump_bitmap_pixels(pixels, *w, *h);
		    printf("\n");
		}
#endif
		return;
	    }
	}
    }

    TRACE(("unable to load any bitmap for character '%c' in alphabet number %u at %ux%u\n",
	   ch, context->current_text_controls->alphabet_num, maxw, maxh));

    /*
     * The VT3x0 series (and probably earlier ReGIS implementations) use a solid
     * block glyph for unknown glyphs.
     */
    {
	unsigned xx, yy;

	*w = MIN2(8U, maxh);
	*h = MIN2(10U, maxw);
	for (yy = 0U; yy < *h; yy++)
	    for (xx = 0U; xx < *w; xx++)
		pixels[yy * *w + xx] = '\1';
    }
}

static void
draw_character(RegisGraphicsContext *context, int ch,
	       int slant_dx, int rot_shear_x,
	       int rot_shear_y, int x_sign_x, int x_sign_y,
	       int y_sign_x, int y_sign_y)
{
    const unsigned xmaxd = context->current_text_controls->character_display_w;
    const unsigned ymaxd = context->current_text_controls->character_display_h;
    const unsigned xmaxf = context->current_text_controls->character_unit_cell_w;
    const unsigned ymaxf = context->current_text_controls->character_unit_cell_h;
    unsigned w, h;
    unsigned xscale, yscale;
    unsigned fx, fy;
    unsigned px, py;
    int sx;
    int rx, ry;
    int ox, oy;
    unsigned pad_left, pad_right;
    unsigned pad_top, pad_bottom;
    Char pixels[MAX_GLYPH_PIXELS];
    unsigned value;

    get_bitmap_of_character(context, ch, xmaxf, ymaxf, pixels, &w, &h,
			    MAX_GLYPH_PIXELS);
    if (w < 1 || h < 1) {
	return;
    }

    if (xmaxd > xmaxf) {
	pad_left = (xmaxd - xmaxf) / 2U;
	pad_right = (xmaxd - xmaxf) - pad_left;
    } else {
	pad_left = 0U;
	pad_right = 0U;
    }
    if (ymaxd > ymaxf) {
	pad_top = (ymaxd - ymaxf) / 2U;
	pad_bottom = (ymaxd - ymaxf) - pad_top;
    } else {
	pad_top = 0U;
	pad_bottom = 0U;
    }

    xscale = (w << SCALE_FIXED_POINT) / xmaxf;
    yscale = (h << SCALE_FIXED_POINT) / ymaxf;

    for (py = 0U; py < ymaxd; py++) {
	for (px = 0U; px < xmaxd; px++) {
	    if (py < pad_top || px < pad_left ||
		py >= ymaxd - pad_bottom || px >= xmaxd - pad_right) {
		value = 0U;
	    } else {
		fx = ((px - pad_left) * xscale) >> SCALE_FIXED_POINT;
		fy = ((py - pad_top) * yscale) >> SCALE_FIXED_POINT;
		if (fx < w && fy < h) {
		    value = (unsigned) pixels[fy * w + fx];
		} else {
		    value = 0U;
		}
	    }

	    sx = (int) px + (slant_dx * (int) py) / ROT_SHEAR_SCALE;
	    rx = x_sign_x * sx + x_sign_y * (int) py;
	    ry = y_sign_x * sx + y_sign_y * (int) py;
	    ox = rx + (rot_shear_x * ry) / ROT_SHEAR_SCALE;
	    oy = ry + (rot_shear_y * ox) / ROT_SHEAR_SCALE;
	    ox += (rot_shear_x * oy) / ROT_SHEAR_SCALE;

	    draw_regis_pixel(context,
			     (int) context->graphics_output_cursor_x + ox,
			     (int) context->graphics_output_cursor_y + oy,
			     value);
	}
    }
}

static void
move_text(RegisGraphicsContext *context, int dx, int dy)
{
    double total_rotation;
    int str_invert;
    int str_shear_x, str_shear_y;
    int ox, oy;

    total_rotation = 2.0 * M_PI *
	context->current_text_controls->string_rotation / 360.0;
    while (total_rotation > 1.5 * M_PI) {
	total_rotation -= 2.0 * M_PI;
    }
    if (total_rotation > 0.5 * M_PI) {
	total_rotation -= M_PI;
	str_invert = -1;
    } else {
	str_invert = 1;
    }
    str_shear_x = (int) (ROT_SHEAR_SCALE * -tan(0.5 * -total_rotation));
    str_shear_y = (int) (ROT_SHEAR_SCALE * sin(-total_rotation));

    total_rotation = 2.0 * M_PI *
	context->current_text_controls->character_rotation / 360.0;
    while (total_rotation > 1.5 * M_PI) {
	total_rotation -= 2.0 * M_PI;
    }

    TRACE(("str_shear: %.5f, %.5f (sign=%d)\n",
	   str_shear_x / (double) ROT_SHEAR_SCALE,
	   str_shear_y / (double) ROT_SHEAR_SCALE,
	   str_invert));

    ox = str_invert * dx + (str_shear_x * dy) / ROT_SHEAR_SCALE;
    oy = str_invert * dy + (str_shear_y * ox) / ROT_SHEAR_SCALE;
    ox += (str_shear_x * oy) / ROT_SHEAR_SCALE;

    TRACE(("after pv output updating position %+d,%+d\n", ox, oy));
    context->graphics_output_cursor_x += ox;
    context->graphics_output_cursor_y += oy;

    return;
}

#define UPSCALE_TEXT_DIMENSION(D) do { \
	    *(D) = (unsigned)((double)(*(D)) * M_SQRT2); \
	} while (0)

static void
draw_text(RegisGraphicsContext *context, char const *str)
{
#ifndef ENABLE_DISTORTIONLESS_ROTATION
    RegisTextControls *old_text_controls = NULL;
    static RegisTextControls scratch_text_controls;
#endif
    double total_rotation;
    size_t ii;
    int str_invert;
    int str_shear_x, str_shear_y;
    int slant_dx;
    int chr_x_sign_x, chr_x_sign_y;
    int chr_y_sign_x, chr_y_sign_y;
    int chr_shear_x, chr_shear_y;
    int begin_x, begin_y;
    int rx, ry;
    int ox, oy;

#ifdef DEBUG_ALPHABETS
    {
	unsigned n;

	for (n = 0U; n < MAX_REGIS_ALPHABETS; n++) {
	    printf("alphabet index %u\n", n);
	    if (context->alphabets[n].alphabet_num != INVALID_ALPHABET_NUM) {
		printf(" alphabet_num=%u\n", context->alphabets[n].alphabet_num);
		printf(" pixw=%d\n", context->alphabets[n].pixw);
		printf(" pixh=%d\n", context->alphabets[n].pixh);
		printf(" name=\"%s\"\n", context->alphabets[n].name);
		printf(" use_font=%d\n", context->alphabets[n].use_font);
		printf(" fontname=\"%s\"\n", context->alphabets[n].fontname);
		printf(" bytes=%p\n", context->alphabets[n].bytes);
	    }
	}
    }
#endif

    if (context->current_text_controls->slant <= -75 ||
	context->current_text_controls->slant >= +75) {
	TRACE(("ERROR: unsupported character slant angle %d\n",
	       context->current_text_controls->slant));
	return;
    }

    /* FIXME: grab when first entering command */
    begin_x = context->graphics_output_cursor_x;
    begin_y = context->graphics_output_cursor_y;

#ifndef ENABLE_DISTORTIONLESS_ROTATION
    if (context->current_text_controls->character_rotation != 0 &&
	context->current_text_controls->character_rotation != 90 &&
	context->current_text_controls->character_rotation != 180 &&
	context->current_text_controls->character_rotation != 270) {
	old_text_controls = context->current_text_controls;
	scratch_text_controls = *context->current_text_controls;
	UPSCALE_TEXT_DIMENSION(&scratch_text_controls.character_display_w);
	UPSCALE_TEXT_DIMENSION(&scratch_text_controls.character_display_h);
	/* FIXME: Not sure if this is really scaled.  The increment seems to
	 * _not_ be scaled.
	 */
	UPSCALE_TEXT_DIMENSION(&scratch_text_controls.character_unit_cell_w);
	UPSCALE_TEXT_DIMENSION(&scratch_text_controls.character_unit_cell_h);
	context->current_text_controls = &scratch_text_controls;
	TRACE(("scaled up text to %dx%d\n",
	       scratch_text_controls.character_display_w,
	       scratch_text_controls.character_display_h));
    }
#endif

    total_rotation = 2.0 * M_PI *
	context->current_text_controls->string_rotation / 360.0;
    while (total_rotation > 1.5 * M_PI) {
	total_rotation -= 2.0 * M_PI;
    }
    if (total_rotation > 0.5 * M_PI) {
	total_rotation -= M_PI;
	str_invert = -1;
    } else {
	str_invert = 1;
    }
    str_shear_x = (int) (ROT_SHEAR_SCALE * -tan(0.5 * -total_rotation));
    str_shear_y = (int) (ROT_SHEAR_SCALE * sin(-total_rotation));

    total_rotation = 2.0 * M_PI *
	context->current_text_controls->character_rotation / 360.0;
    while (total_rotation > 1.5 * M_PI) {
	total_rotation -= 2.0 * M_PI;
    }
    if (total_rotation > 0.5 * M_PI) {
	total_rotation -= M_PI;
	chr_x_sign_x = -1;
	chr_x_sign_y = 0;
	chr_y_sign_x = 0;
	chr_y_sign_y = -1;
    } else {
	chr_x_sign_x = 1;
	chr_x_sign_y = 0;
	chr_y_sign_x = 0;
	chr_y_sign_y = 1;
    }
    chr_shear_x = (int) (ROT_SHEAR_SCALE * -tan(0.5 * -total_rotation));
    chr_shear_y = (int) (ROT_SHEAR_SCALE * sin(-total_rotation));

    {
	const int slant = context->current_text_controls->slant;

	TRACE(("float version: %.5f\n", tan(2.0 * M_PI * abs(slant) / 360.0)));
	/* The slant is negative for forward-leaning characters. */
	if (slant > 0) {
	    slant_dx = (int) +(tan(2.0 * M_PI * abs(slant) / 360.0) * ROT_SHEAR_SCALE);
	} else if (slant < 0) {
	    slant_dx = (int) -(tan(2.0 * M_PI * abs(slant) / 360.0) * ROT_SHEAR_SCALE);
	} else {
	    slant_dx = 0;
	}
	TRACE(("string rotation: %d\n",
	       context->current_text_controls->string_rotation));
	TRACE(("character rotation: %d\n",
	       context->current_text_controls->character_rotation));
	TRACE(("character slant: %d (%.5f pixels per line)\n",
	       slant, slant_dx / (double) ROT_SHEAR_SCALE));
    }

    TRACE(("str_shear: %.5f, %.5f (sign=%d)\n",
	   str_shear_x / (double) ROT_SHEAR_SCALE,
	   str_shear_y / (double) ROT_SHEAR_SCALE,
	   str_invert));
    TRACE(("chr_shear: %.5f, %.5f (xsign=%d,%d, ysign=%d,%d)\n",
	   chr_shear_x / (double) ROT_SHEAR_SCALE,
	   chr_shear_y / (double) ROT_SHEAR_SCALE,
	   chr_x_sign_x, chr_x_sign_y,
	   chr_y_sign_x, chr_y_sign_y));
    TRACE(("character_inc: %d,%d\n",
	   context->current_text_controls->character_inc_x, context->current_text_controls->character_inc_y));

    rx = 0;
    ry = 0;
    for (ii = 0U; ii < strlen(str); ii++) {
	switch (str[ii]) {
	case '\r':
	    rx = 0;
	    break;
	case '\n':
	    ry += (int) context->current_text_controls->character_display_h;
	    break;
	case '\b':
	    rx -= context->current_text_controls->character_inc_x;
	    ry -= context->current_text_controls->character_inc_y;
	    break;
	case '\t':
	    rx += context->current_text_controls->character_inc_x;
	    ry += context->current_text_controls->character_inc_y;
	    break;
	default:
	    ox = str_invert * rx + (str_shear_x * ry) / ROT_SHEAR_SCALE;
	    oy = str_invert * ry + (str_shear_y * ox) / ROT_SHEAR_SCALE;
	    ox += (str_shear_x * oy) / ROT_SHEAR_SCALE;
	    TRACE(("during text output updating position to %d,%d + %+d,%+d for '%c'\n",
		   begin_x, begin_y, ox, oy, str[ii]));
	    context->graphics_output_cursor_x = begin_x + ox;
	    context->graphics_output_cursor_y = begin_y + oy;
	    draw_character(context, str[ii], slant_dx,
			   chr_shear_x, chr_shear_y,
			   chr_x_sign_x, chr_x_sign_y,
			   chr_y_sign_x, chr_y_sign_y);
	    rx += context->current_text_controls->character_inc_x;
	    ry += context->current_text_controls->character_inc_y;
	}
    }

    ox = str_invert * rx + (str_shear_x * ry) / ROT_SHEAR_SCALE;
    oy = str_invert * ry + (str_shear_y * ox) / ROT_SHEAR_SCALE;
    ox += (str_shear_x * oy) / ROT_SHEAR_SCALE;
    TRACE(("after text output updating position to %d,%d + %+d,%+d\n",
	   begin_x, begin_y, ox, oy));
    context->graphics_output_cursor_x = begin_x + ox;
    context->graphics_output_cursor_y = begin_y + oy;

#ifndef ENABLE_DISTORTIONLESS_ROTATION
    if (context->current_text_controls->character_rotation != 0 &&
	context->current_text_controls->character_rotation != 90 &&
	context->current_text_controls->character_rotation != 180 &&
	context->current_text_controls->character_rotation != 270) {
	context->current_text_controls = old_text_controls;
    }
#endif

    context->destination_graphic->dirty = True;
    return;
}

/*
 * standard character cell sizes
 *   number  disp cell   unit cell       offset
 *   S0      [  9, 10]   [  8, disp_h]   [disp_w, 0]
 *   S1      [  9, 20]   [  8, disp_h]   [disp_w, 0]
 *   S2      [ 18, 30]   [ 16, disp_h]   [disp_w, 0]
 *   S3      [ 27, 45]   [ 24, disp_h]   [disp_w, 0]
 *   S4      [ 36, 60]   [ 32, disp_h]   [disp_w, 0]
 *   S5      [ 45, 75]   [ 40, disp_h]   [disp_w, 0]
 *   S6      [ 54, 90]   [ 48, disp_h]   [disp_w, 0]
 *   S7      [ 63,105]   [ 56, disp_h]   [disp_w, 0]
 *   S8      [ 72,120]   [ 64, disp_h]   [disp_w, 0]
 *   S9      [ 81,135]   [ 72, disp_h]   [disp_w, 0]
 *   S10     [ 90,150]   [ 80, disp_h]   [disp_w, 0]
 *   S11     [ 99,165]   [ 88, disp_h]   [disp_w, 0]
 *   S12     [108,180]   [ 96, disp_h]   [disp_w, 0]
 *   S13     [117,195]   [104, disp_h]   [disp_w, 0]
 *   S14     [126,210]   [112, disp_h]   [disp_w, 0]
 *   S15     [135,225]   [120, disp_h]   [disp_w, 0]
 *   S16     [144,240]   [128, disp_h]   [disp_w, 0]
 */
static int
get_standard_character_size(int standard, unsigned *disp_w, unsigned
			    *disp_h, unsigned *unit_w, unsigned *unit_h,
			    int *off_x, int *off_y)
{
    switch (standard) {
    case 0:
	*disp_w = 9U;
	*disp_h = 10U;
	*unit_w = 8U;
	break;
    case 1:
	*disp_w = 9U;
	*disp_h = 20U;
	*unit_w = 8U;
	break;
    case 2:
	*disp_w = 18U;
	*disp_h = 30U;
	*unit_w = 16U;
	break;
    case 3:
	*disp_w = 27U;
	*disp_h = 45U;
	*unit_w = 24U;
	break;
    case 4:
	*disp_w = 36U;
	*disp_h = 60U;
	*unit_w = 32U;
	break;
    case 5:
	*disp_w = 45U;
	*disp_h = 75U;
	*unit_w = 40U;
	break;
    case 6:
	*disp_w = 54U;
	*disp_h = 90U;
	*unit_w = 48U;
	break;
    case 7:
	*disp_w = 63U;
	*disp_h = 105U;
	*unit_w = 56U;
	break;
    case 8:
	*disp_w = 72U;
	*disp_h = 120U;
	*unit_w = 64U;
	break;
    case 9:
	*disp_w = 81U;
	*disp_h = 135U;
	*unit_w = 72U;
	break;
    case 10:
	*disp_w = 90U;
	*disp_h = 150U;
	*unit_w = 80U;
	break;
    case 11:
	*disp_w = 99U;
	*disp_h = 165U;
	*unit_w = 88U;
	break;
    case 12:
	*disp_w = 108U;
	*disp_h = 180U;
	*unit_w = 96U;
	break;
    case 13:
	*disp_w = 117U;
	*disp_h = 195U;
	*unit_w = 104U;
	break;
    case 14:
	*disp_w = 126U;
	*disp_h = 210U;
	*unit_w = 112U;
	break;
    case 15:
	*disp_w = 135U;
	*disp_h = 225U;
	*unit_w = 120U;
	break;
    case 16:
	*disp_w = 144U;
	*disp_h = 240U;
	*unit_w = 128U;
	break;
    default:
	return 1;
    }
    *unit_h = *disp_h;
    *off_x = (int) *disp_w;
    *off_y = 0;

    return 0;
}

static void
init_fragment(RegisDataFragment *fragment, char const *str)
{
    assert(fragment);
    assert(str);

    fragment->start = str;
    fragment->len = (unsigned) strlen(str);
    fragment->pos = 0U;
}

static void
copy_fragment(RegisDataFragment *dst, RegisDataFragment const *src)
{
    assert(dst);
    assert(src);

    dst->start = src->start;
    dst->len = src->len;
    dst->pos = src->pos;
}

static char
peek_fragment(RegisDataFragment const *fragment)
{
    assert(fragment);

    if (fragment->pos < fragment->len) {
	return fragment->start[fragment->pos];
    }
    return '\0';
}

static char
pop_fragment(RegisDataFragment *fragment)
{
    assert(fragment);

    if (fragment->pos < fragment->len) {
	return fragment->start[fragment->pos++];
    }
    return '\0';
}

static char
get_fragment(RegisDataFragment const *fragment, unsigned pos)
{
    assert(fragment);

    if (fragment->pos + pos < fragment->len) {
	return fragment->start[fragment->pos + pos];
    }
    return '\0';
}

#define fragment_length(f) (f)->len

static unsigned
fragment_remaining(RegisDataFragment const *fragment)
{
    assert(fragment);

    if (fragment->pos > fragment->len)
	return 0U;
    return fragment->len - fragment->pos;
}

static int
fragment_consumed(RegisDataFragment const *fragment)
{
    assert(fragment);

    return fragment->pos >= fragment->len;
}

static void
fragment_to_string(RegisDataFragment const *fragment, char *out,
		   unsigned outlen)
{
    unsigned remaininglen;
    unsigned endpos;

    assert(fragment);
    assert(out);

    if (!outlen)
	return;
    remaininglen = fragment->len - fragment->pos;
    if (remaininglen < outlen - 1U) {
	endpos = remaininglen;
    } else {
	endpos = outlen - 1U;
    }
    strncpy(out, &fragment->start[fragment->pos], (size_t) endpos);
    out[endpos] = '\0';
}

#define MAX_FRAG 1024
static char const *
fragment_to_tempstr(RegisDataFragment const *fragment)
{
    static char tempstr[MAX_FRAG];

    assert(fragment);

    fragment_to_string(fragment, tempstr, MAX_FRAG);
    return tempstr;
}

static int
skip_regis_whitespace(RegisDataFragment *input)
{
    int skipped = 0;

    assert(input);

    while (!fragment_consumed(input)) {
	char ch = peek_fragment(input);
	if (ch != ',' && !IsSpace(ch)) {
	    break;
	}
	if (ch == '\n') {
	    TRACE(("end of input line\n\n"));
	}
	skipped = 1;
	pop_fragment(input);
    }

    if (skipped)
	return 1;
    return 0;
}

static int
extract_regis_extent(RegisDataFragment *input, RegisDataFragment *output)
{
    char ch;

    assert(input);
    assert(output);

    output->start = &input->start[input->pos];
    output->len = 0U;
    output->pos = 0U;

    if (input->pos >= input->len)
	return 0;

    ch = input->start[input->pos];
    if (ch != '[')
	return 0;
    input->pos++;
    output->start++;

    /* FIXME: truncate to 16 bit signed integers */
    for (; input->pos < input->len; input->pos++, output->len++) {
	ch = input->start[input->pos];
	if (ch == ';') {
	    TRACE(("DATA_ERROR: end of input before closing bracket\n"));
	    break;
	}
	if (ch == ']')
	    break;
    }
    if (ch == ']')
	input->pos++;

    return 1;
}

static int
extract_regis_num(RegisDataFragment *input, RegisDataFragment *output)
{
    char ch = 0;
    int has_digits = 0;

    assert(input);
    assert(output);

    output->start = &input->start[input->pos];
    output->len = 0U;
    output->pos = 0U;

    if (input->start[input->pos] == '-' ||
	input->start[input->pos] == '+') {
	input->pos++;
	output->len++;
    }

    for (; input->pos < input->len; input->pos++, output->len++) {
	ch = input->start[input->pos];
	if (ch != '0' && ch != '1' && ch != '2' && ch != '3' &&
	    ch != '4' && ch != '5' && ch != '6' && ch != '7' &&
	    ch != '8' && ch != '9') {
	    break;
	}
	has_digits = 1;
    }

    /* FIXME: what degenerate forms should be accepted ("E10" "1E" "1e" "1." "1ee10")? */
    /* FIXME: the terminal is said to support "floating point values", truncating to int... what do these look like? */
    if (has_digits && ch == 'E') {
	input->pos++;
	output->len++;
	for (; input->pos < input->len; input->pos++, output->len++) {
	    ch = input->start[input->pos];
	    if (ch != '0' && ch != '1' && ch != '2' && ch != '3' &&
		ch != '4' && ch != '5' && ch != '6' && ch != '7' &&
		ch != '8' && ch != '9') {
		break;
	    }
	}
    }

    return has_digits;
}

static int
extract_regis_pixelvector(RegisDataFragment *input, RegisDataFragment *output)
{
    char ch;
    int has_digits;

    assert(input);
    assert(output);

    output->start = &input->start[input->pos];
    output->len = 0U;
    output->pos = 0U;

    if (input->pos < input->len) {
	ch = input->start[input->pos];
	if (ch == '+' || ch == '-') {
	    input->pos++;
	    output->len++;
	}
    }

    has_digits = 0;
    for (; input->pos < input->len; input->pos++, output->len++) {
	ch = input->start[input->pos];
	if (ch != '0' && ch != '1' && ch != '2' && ch != '3' &&
	    ch != '4' && ch != '5' && ch != '6' && ch != '7') {
	    break;
	}
	has_digits = 1;
    }

    return has_digits;
}

static int
extract_regis_command(RegisDataFragment *input, char *command)
{
    char ch;

    assert(input);
    assert(command);

    if (input->pos >= input->len)
	return 0;

    ch = input->start[input->pos];
    if (ch == '\0' || ch == ';') {
	return 0;
    }
    if (!islower(CharOf(ch)) && !isupper(CharOf(ch)) && ch != '@') {
	return 0;
    }
    *command = ch;
    input->pos++;

    return 1;
}

/*
 * Check a ReGIS alphabet name before reporting it, to pick an appropriate
 * delimiter.  If the string is empty, or contains nonreportable characters,
 * just return NUL.
 */
static int
pick_quote(const char *value)
{
    Bool s_quote = False;
    Bool d_quote = False;

    if (*value != '\0') {
	while (*value != '\0') {
	    int ch = CharOf(*value++);
	    if (ch == D_QUOTE)
		d_quote = True;
	    else if (ch == S_QUOTE)
		s_quote = True;
	    else if (!isName(ch))
		s_quote = d_quote = True;
	}
    } else {
	s_quote = d_quote = True;
    }
    return ((s_quote && d_quote)
	    ? 0
	    : (s_quote
	       ? D_QUOTE
	       : S_QUOTE));
}

static int
extract_regis_string(RegisDataFragment *input, char *out, unsigned maxlen)
{
    char open_quote_ch;
    char ch;
    unsigned outlen;

    assert(input);
    assert(out);
    assert(maxlen > 0U);

    if (input->pos >= input->len)
	return 0;

    ch = peek_fragment(input);
    if (!isQuote(ch))
	return 0;
    open_quote_ch = ch;
    outlen = 0U;
    pop_fragment(input);

    ch = '\0';
    while (!fragment_consumed(input)) {
	char prev_ch = ch;
	ch = peek_fragment(input);
	/* ';' (resync) and '@' (macrograph) are not recognized in strings */
	if (prev_ch == open_quote_ch) {
	    if (ch == open_quote_ch) {
		if (outlen < maxlen) {
		    out[outlen] = ch;
		}
		outlen++;
		pop_fragment(input);
		ch = '\0';
		continue;
	    }
	    if (outlen < maxlen)
		out[outlen] = '\0';
	    else
		out[maxlen] = '\0';
	    return 1;
	}
	if (ch == '\0')
	    break;
	if (ch != open_quote_ch) {
	    if (outlen < maxlen)
		out[outlen] = ch;
	    outlen++;
	}
	pop_fragment(input);
    }
    if (ch == open_quote_ch) {
	pop_fragment(input);
	if (outlen < maxlen)
	    out[outlen] = '\0';
	else
	    out[maxlen] = '\0';
	return 1;
    }
    /* FIXME: handle multiple strings concatenated with commas */

    TRACE(("DATA_ERROR: end of input before closing quote\n"));
    return 0;
}

static int
extract_regis_parenthesized_data(RegisDataFragment *input,
				 RegisDataFragment *output)
{
    char ch;
    char open_quote_ch;
    int nesting;

    assert(input);
    assert(output);

    output->start = &input->start[input->pos];
    output->len = 0U;
    output->pos = 0U;

    if (input->pos >= input->len)
	return 0;

    ch = input->start[input->pos];
    if (ch != '(')
	return 0;
    input->pos++;
    output->start++;
    nesting = 1;
    open_quote_ch = '\0';

    ch = '\0';
    for (; input->pos < input->len; input->pos++, output->len++) {
	char prev_ch = ch;
	ch = input->start[input->pos];
	if (isQuote(ch)) {
	    if (open_quote_ch == '\0') {
		open_quote_ch = ch;
	    } else {
		if (ch == prev_ch && prev_ch == open_quote_ch) {
		    ch = '\0';
		} else if (ch == open_quote_ch) {
		    open_quote_ch = '\0';
		}
	    }
	    continue;
	}
	if (open_quote_ch != '\0')
	    continue;

	if (ch == ';') {
	    TRACE(("leaving parenthesized data nested %d levels deep due to command termination character\n",
		   nesting));
	    break;
	}
	if (ch == '(')
	    nesting++;
	if (ch == ')') {
	    nesting--;
	    if (nesting == 0) {
		input->pos++;
		return 1;
	    }
	}
    }

    TRACE(("DATA_ERROR: end of input before closing paren (%d levels deep)\n",
	   nesting));
    return 0;
}

static int
extract_regis_option(RegisDataFragment *input,
		     char *option,
		     RegisDataFragment *output)
{
    char ch;
    int paren_level, bracket_level;
    char open_quote_ch;

    assert(input);
    assert(option);
    assert(output);

    /* LETTER suboptions* value? */
    /*
     * FIXME: what are the rules for using separate parens vs. sharing between
     * options?
     */

    output->start = &input->start[input->pos];
    output->len = 0U;
    output->pos = 0U;

    if (input->pos >= input->len) {
	return 0;
    }

    ch = input->start[input->pos];
    /* FIXME: are options always letters or are some special characters ok? */
    if (ch == ';' || ch == ',' ||
	ch == '(' || ch == ')' ||
	ch == '[' || ch == ']' ||
	isQuote(ch) ||
	isdigit(CharOf(ch))) {
	return 0;
    }
    *option = ch;
    input->pos++;
    output->start++;
    paren_level = 0;
    bracket_level = 0;

    open_quote_ch = '\0';
    for (; input->pos < input->len; input->pos++, output->len++) {
	ch = input->start[input->pos];
	TRACE(("looking at char '%c' in option '%c'\n", ch, *option));
	/* FIXME: any special rules for commas? */
	/* FIXME: handle escaped quotes */
	if (isQuote(ch)) {
	    if (open_quote_ch == ch) {
		open_quote_ch = '\0';
	    } else {
		open_quote_ch = ch;
	    }
	    continue;
	}
	if (open_quote_ch != '\0')
	    continue;
	if (ch == '(') {
	    paren_level++;
	}
	if (ch == ')') {
	    paren_level--;
	    if (paren_level < 0) {
		TRACE(("DATA_ERROR: found ReGIS option has value with too many close parens \"%c\"\n",
		       *option));
		return 0;
	    }
	}
	if (ch == '[') {
	    bracket_level++;
	}
	if (ch == ']') {
	    bracket_level--;
	    if (bracket_level < 0) {
		TRACE(("DATA_ERROR: found ReGIS option has value with too many close brackets \"%c\"\n",
		       *option));
		return 0;
	    }
	}
	if (paren_level == 0 && bracket_level == 0) {
	    /*
	     * Top-level commas indicate the end of this option and the start of
	     * another.
	     */
	    if (ch == ',')
		break;
	    /*
	     * Top-level command/option/suboption names also indicate the end of
	     * this option.  "E" is valid as the exponent indicator in a numeric
	     * parameter.
	     */
	    if (ch != 'E' && ch != 'e' &&
		((ch >= 'A' && ch <= 'Z') || (ch >= 'a' && ch <= 'z')))
		break;
	}
	if (ch == ';')
	    break;
    }
    if (paren_level != 0) {
	TRACE(("DATA_ERROR: mismatched parens in argument to ReGIS option \"%c\"\n",
	       *option));
	return 0;
    }
    if (bracket_level != 0) {
	TRACE(("DATA_ERROR: mismatched brackets in argument to ReGIS option \"%c\"\n",
	       *option));
	return 0;
    }

    TRACE(("found ReGIS option and value \"%c\" \"%s\"\n",
	   *option,
	   fragment_to_tempstr(output)));
    return 1;
}

static int
regis_num_to_int(RegisDataFragment const *input, int *out)
{
    char ch;

    assert(input);
    assert(out);

    /* FIXME: handle exponential notation and rounding */
    /* FIXME: check for junk after the number */
    ch = peek_fragment(input);
    if (!isdigit(CharOf(ch)) &&
	ch != '+' &&
	ch != '-') {
	*out = 0;
	return 0;
    }

    TRACE(("converting \"%s\" to an int\n", fragment_to_tempstr(input)));
    *out = atoi(fragment_to_tempstr(input));
    return 1;
}

#define spec_H xBIT(0)
#define spec_L xBIT(1)
#define spec_S xBIT(2)

#define spec_HLS (spec_H | spec_L | spec_S)

#define spec_R xBIT(3)
#define spec_G xBIT(4)
#define spec_B xBIT(5)

#define spec_RGB (spec_R | spec_G | spec_B)

static int
load_regis_colorspec(RegisGraphicsContext const *context,
		     RegisDataFragment const *input,
		     ColorRegister *colors)
{
    RegisDataFragment colorspec;
    short r = colors->r;
    short g = colors->g;
    short b = colors->b;
    short l = -1;
    int simple;
    unsigned len;
    unsigned spec = 0;

    assert(context);
    assert(input);
    assert(colors);

    copy_fragment(&colorspec, input);
    TRACE(("colorspec option: \"%s\"\n", fragment_to_tempstr(&colorspec)));

    skip_regis_whitespace(&colorspec);
    simple = 0;
    if ((len = fragment_remaining(&colorspec)) == 1U) {
	simple = 1;
    } else if (len > 1U) {
	unsigned n;
	for (n = 1; n < len; ++n) {
	    char after = get_fragment(&colorspec, n);
	    /* if no parameters, we might see a right-parenthesis, but on error
	     * we can anything */
	    if (strchr("[(,)]", after) != NULL) {
		simple = 1;
		break;
	    } else if (!IsSpace(after)) {
		break;
	    }
	}
    }
    if (simple) {
	char ch = pop_fragment(&colorspec);

	TRACE(("got ReGIS RGB colorspec pattern '%c' with arguments: \"%s\"\n",
	       ch, fragment_to_tempstr(&colorspec)));
	switch (ch) {
	case 'D':
	case 'd':
	    r = 0;
	    g = 0;
	    b = 0;
	    l = 0;
	    break;
	case 'R':
	case 'r':
	    r = 100;
	    g = 0;
	    b = 0;
	    l = 46;
	    break;
	case 'G':
	case 'g':
	    r = 0;
	    g = 100;
	    b = 0;
	    l = 50;
	    break;
	case 'B':
	case 'b':
	    r = 0;
	    g = 0;
	    b = 100;
	    l = 50;
	    break;
	case 'C':
	case 'c':
	    r = 0;
	    g = 100;
	    b = 100;
	    l = 50;
	    break;
	case 'Y':
	case 'y':
	    r = 100;
	    g = 100;
	    b = 0;
	    l = 50;
	    break;
	case 'M':
	case 'm':
	    r = 100;
	    g = 0;
	    b = 100;
	    l = 50;
	    break;
	case 'W':
	case 'w':
	    r = 100;
	    g = 100;
	    b = 100;
	    l = 100;
	    break;
	default:
	    TRACE(("DATA_ERROR: unknown RGB color name: \"%c\"\n", ch));
	    return 0;
	}
    } else {
	RegisDataFragment num;
	int max, val;
	char comp;
	short h = -1;
	short s = -1;

	while (!fragment_consumed(&colorspec)) {
	    if (skip_regis_whitespace(&colorspec))
		continue;

	    comp = pop_fragment(&colorspec);
	    switch (comp) {
	    case ',':
		/* not sure if this is valid, but it is easy to handle */
		continue;
	    case 'H':
	    case 'h':
		max = 360;
		comp = 'H';
		break;
	    case 'L':
	    case 'l':
		max = 100;
		comp = 'L';
		break;
	    case 'S':
	    case 's':
		max = 100;
		comp = 'S';
		break;
#ifdef ENABLE_RGB_COLORSPECS
	    case 'R':		/* RLogin extension */
	    case 'r':
		max = 100;
		comp = 'R';
		break;
	    case 'G':		/* RLogin extension */
	    case 'g':
		max = 100;
		comp = 'G';
		break;
	    case 'B':		/* RLogin extension */
	    case 'b':
		max = 100;
		comp = 'B';
		break;
#endif
	    default:
		TRACE(("DATA_ERROR: unrecognized component in colorspec: '%c'\n",
		       comp));
		return 0;
	    }

	    skip_regis_whitespace(&colorspec);
	    if (!extract_regis_num(&colorspec, &num)) {
		TRACE(("DATA_ERROR: expected int after '%c' component in colorspec: \"%s\"\n",
		       comp, fragment_to_tempstr(&colorspec)));
		return 0;
	    }
	    if (!regis_num_to_int(&num, &val)) {
		TRACE(("DATA_ERROR: component value \"%s\" is not a number\n",
		       fragment_to_tempstr(&num)));
		return 0;
	    }
	    /* FIXME: error, truncate, wrap, ...? */
	    if (val < 0 || val > max) {
		TRACE(("DATA_ERROR: component value %d out of range\n", val));
		return 0;
	    }

	    switch (comp) {
	    case 'H':
		h = (short) val;
		spec |= spec_H;
		break;
	    case 'L':
		l = (short) val;
		spec |= spec_L;
		break;
	    case 'S':
		s = (short) val;
		spec |= spec_S;
		break;
	    case 'R':
		r = (short) val;
		spec |= spec_R;
		break;
	    case 'G':
		g = (short) val;
		spec |= spec_G;
		break;
	    case 'B':
		b = (short) val;
		spec |= spec_B;
		break;
	    }
	}

	if ((spec & spec_HLS) && (spec & spec_RGB)) {
	    TRACE(("DATA_ERROR: conflicting colorspec format\n"));
	    return 0;
	} else if (spec == spec_HLS) {
	    TRACE(("found HLS colorspec to be converted: %hd,%hd,%hd\n",
		   h, l, s));
	    hls2rgb(h, l, s, &r, &g, &b);
	    TRACE(("converted to RGB: %hd,%hd,%hd\n", r, g, b));
	} else if (spec == spec_RGB) {
	    TRACE(("found RGB colorspec: %hd,%hd,%hd\n", r, g, b));
	    l = (short) ((MIN3(r, g, b) + MAX3(r, g, b)) / 2);
	    TRACE(("calculated L: %d\n", l));
	} else if ((spec & spec_HLS)) {
	    short old_h, old_l, old_s;
	    TRACE(("using partial HLS %hd,%hd,%hd\n", h, l, s));
	    rgb2hls(r, g, b, &old_h, &old_l, &old_s);
	    if (h < 0)
		h = old_h;
	    if (l < 0)
		l = old_l;
	    if (s < 0)
		s = old_s;
	    TRACE(("resulting HLS colorspec to convert: %hd,%hd,%hd\n",
		   h, l, s));
	    hls2rgb(h, l, s, &r, &g, &b);
	    TRACE(("converted to RGB: %hd,%hd,%hd\n", r, g, b));
	} else {
	    TRACE(("DATA_ERROR: unrecognized colorspec format\n"));
	    return 0;
	}
    }

    /*
     * The VT240 and VT330 models convert to the closest grayscale value.
     */
    if (context->graphics_termid == 240 || context->graphics_termid == 330) {
	hls2rgb(0, l, 0, &r, &g, &b);
	TRACE(("converted to grayscale: %hd,%hd,%hd\n", r, g, b));
    }

    colors->r = r;
    colors->g = g;
    colors->b = b;

    skip_regis_whitespace(&colorspec);
    if (!fragment_consumed(&colorspec)) {
	char skip;

	skip = pop_fragment(&colorspec);
	(void) skip;		/* variable needed only if tracing */
	TRACE(("DATA_ERROR: ignoring unexpected character in ReGIS colorspec \"%c\"\n",
	       skip));
    }

    return 1;
}

static int
load_regis_regnum_or_colorspec(RegisGraphicsContext const *context,
			       RegisDataFragment const *input,
			       RegisterNum *out)
{
    int val;
    RegisDataFragment colorspec;
    RegisDataFragment num;
    RegisDataFragment coloroption;

    copy_fragment(&colorspec, input);
    TRACE(("looking at colorspec pattern: \"%s\"\n",
	   fragment_to_tempstr(&colorspec)));

    skip_regis_whitespace(&colorspec);

    if (extract_regis_num(&colorspec, &num)) {
	if (!regis_num_to_int(&num, &val)) {
	    TRACE(("DATA_ERROR: colorspec value \"%s\" is not a valid register\n",
		   fragment_to_tempstr(&num)));
	    return 0;
	}
	if (val < 0) {
	    /* FIXME: error, truncate, wrap, ...? */
	    TRACE(("DATA_ERROR: ignoring negative colorspec value: %d\n", val));
	    return 0;
	}
	if (val >= (int) context->destination_graphic->valid_registers) {
	    /* FIXME: error, truncate, wrap, ...? */
	    TRACE(("DATA_ERROR: colorspec value %d is too big; wrapping\n",
		   val));
	    val %= (int) context->destination_graphic->valid_registers;
	}

	TRACE(("colorspec contains index for register %u\n", val));
	*out = (RegisterNum) val;

	skip_regis_whitespace(&colorspec);
	if (!fragment_consumed(&colorspec)) {
	    char skip;

	    skip = pop_fragment(&colorspec);
	    (void) skip;	/* variable needed only if tracing */
	    TRACE(("DATA_ERROR: unexpected character after register \"%c\"\n",
		   skip));
	    return 0;
	}

	return 1;
    }

    if (extract_regis_parenthesized_data(&colorspec, &coloroption)) {
	ColorRegister find_reg =
	{-1, -1, -1};

	if (!load_regis_colorspec(context, &coloroption, &find_reg)) {
	    TRACE(("unable to parse colorspec\n"));
	    return 0;
	}

	*out = find_color_register(context->destination_graphic->color_registers,
				   find_reg.r, find_reg.g, find_reg.b);
	TRACE(("colorspec maps to closest register %u\n", *out));

	return 1;
    }

    TRACE(("expected register number or colorspec, but found: \"%s\"\n",
	   fragment_to_tempstr(&colorspec)));
    return 0;
}

static int
to_scaled_int(char const *num, int scale, int *value)
{
    unsigned long whole, frac;
    char *end;

    /* FIXME: handle whitespace? how about trailing junk? */
    whole = strtoul(num, &end, 10);
    if (end[0] == '.') {
	char temp[5] = "0000";

	if (end[1] != '\0') {
	    temp[0] = end[1];
	    if (end[2] != '\0') {
		temp[1] = end[2];
		if (end[3] != '\0') {
		    temp[2] = end[3];
		    if (end[4] != '\0') {
			temp[3] = end[4];
		    }
		}
	    }
	}
	frac = strtoul(temp, NULL, 10);
    } else if (end[0] == '\0' || end[0] == ',' || IsSpace(end[0])) {
	frac = 0;
    } else {
	TRACE(("unexpected character %c in number %s\n", end[0], num));
	return 0;
    }

    *value = (int) (whole * (unsigned) scale +
		    (frac * (unsigned) scale) / 10000);

    return 1;
}

static int
load_regis_raw_extent(char const *extent, int *relx, int *rely,
		      int *xloc, int *yloc, int scale)
{
    int xsign, ysign;
    char const *xpart;
    char const *ypart;

    xpart = extent;
    if ((ypart = strchr(extent, ',')) != NULL) {
	ypart++;
    } else {
	ypart = "";
    }

    while (IsSpace(xpart[0]))
	xpart++;
    while (IsSpace(ypart[0]))
	ypart++;

    if (xpart[0] == '-') {
	xsign = -1;
	xpart++;
    } else if (xpart[0] == '+') {
	xsign = +1;
	xpart++;
    } else {
	xsign = 0;
    }
    if (ypart[0] == '-') {
	ysign = -1;
	ypart++;
    } else if (ypart[0] == '+') {
	ysign = +1;
	ypart++;
    } else {
	ysign = 0;
    }

    if (xpart[0] == '\0' || xpart[0] == ',') {
	*relx = 1;
	*xloc = 0;
    } else if (xsign == 0) {
	int val;

	if (!to_scaled_int(xpart, scale, &val))
	    return 0;
	*relx = 0;
	*xloc = val;
    } else {
	int val;

	if (!to_scaled_int(xpart, scale, &val))
	    return 0;
	*relx = 1;
	*xloc = xsign * val;
    }
    if (ypart[0] == '\0') {
	*rely = 1;
	*yloc = 0;
    } else if (ysign == 0) {
	int val;

	if (!to_scaled_int(ypart, scale, &val))
	    return 0;
	*rely = 0;
	*yloc = val;
    } else {
	int val;

	if (!to_scaled_int(ypart, scale, &val))
	    return 0;
	*rely = 1;
	*yloc = ysign * val;
    }

    return 1;
}

static int
load_regis_mult_extent(char const *extent, int *w, int *h)
{
    int relx, rely;
    int px, py;

    if (!load_regis_raw_extent(extent, &relx, &rely, &px, &py, 1)) {
	TRACE(("invalid coordinates in extent \"%s\"\n", extent));
	return 0;
    }
    if (relx | rely) {
	TRACE(("invalid relative value in multiplier extent \"%s\"\n", extent));
	return 0;
    }

    *w = px;
    *h = py;

    return 1;
}

static int
load_regis_pixel_extent(char const *extent, int origx, int origy,
			int *xloc, int *yloc)
{
    int relx, rely;
    int px, py;

    if (!load_regis_raw_extent(extent, &relx, &rely, &px, &py, 1)) {
	TRACE(("invalid coordinates in extent \"%s\"\n", extent));
	return 0;
    }

    *xloc = px;
    *yloc = py;

    if (relx)
	*xloc += origx;
    if (rely)
	*yloc += origy;

    return 1;
}

#define COORD_SCALE 1000

static int
load_regis_coord_extent(RegisGraphicsContext const *context, char const *extent,
			int origx, int origy, int *xloc, int *yloc)
{
    int relx, rely;
    int ux, uy;

    if (!load_regis_raw_extent(extent, &relx, &rely, &ux, &uy, COORD_SCALE)) {
	TRACE(("invalid coordinates in extent \"%s\"\n", extent));
	return 0;
    }

    if (relx) {
	const int px = SCALE_XCOORD(context, ux, COORD_SCALE);
	TRACE(("converted relative user X coord %.03f to relative pixel X coord %d (width=%d xoff=%d xdiv=%d)\n",
	       ux / (double) COORD_SCALE, px, context->width,
	       context->x_off, context->x_div));
	*xloc = origx + px;
    } else {
	const int px = TRANSLATE_XCOORD(context, ux, COORD_SCALE);
	TRACE(("converted absolute user X coord %.03f to absolute pixel X coord %d\n",
	       ux / (double) COORD_SCALE, px));
	*xloc = px;
    }
    if (rely) {
	const int py = SCALE_YCOORD(context, uy, COORD_SCALE);
	TRACE(("converted relative user Y coord %.03f to relative pixel Y coord %d (height=%d yoff=%d ydiv=%d)\n",
	       uy / (double) COORD_SCALE, py, context->height,
	       context->y_off, context->y_div));
	*yloc = origy + py;
    } else {
	const int py = TRANSLATE_YCOORD(context, uy, COORD_SCALE);
	TRACE(("converted absolute user Y coord %.03f to absolute pixel Y coord %d\n",
	       uy / (double) COORD_SCALE, py));
	*yloc = py;
    }

    return 1;
}

static int
load_regis_raw_pixelvector_digit(char const *pixelvector,
				 unsigned *offset,
				 int *dx, int *dy, int mul)
{
    switch (pixelvector[*offset]) {
    case '0':
	*dx += mul;
	break;
    case '1':
	*dx += mul;
	*dy -= mul;
	break;
    case '2':
	*dy -= mul;
	break;
    case '3':
	*dx -= mul;
	*dy -= mul;
	break;
    case '4':
	*dx -= mul;
	break;
    case '5':
	*dx -= mul;
	*dy += mul;
	break;
    case '6':
	*dy += mul;
	break;
    case '7':
	*dx += mul;
	*dy += mul;
	break;
    default:
	return 0;
    }

    (*offset)++;
    return 1;
}

static int
load_regis_pixel_pixelvector(char const *pixelvector,
			     int mul,
			     int origx, int origy,
			     int *xloc, int *yloc)
{
    int found = 0;
    int px = 0, py = 0;
    unsigned offset = 0U;
    while (load_regis_raw_pixelvector_digit(pixelvector, &offset,
					    &px, &py,
					    mul))
	found = 1;
    if (pixelvector[offset] != '\0') {
	TRACE(("DATA_ERROR: ignoring unknown pixel vector digits: \"%s\"\n",
	       &pixelvector[offset]));
    }

    *xloc = origx + px;
    *yloc = origy + py;

    return found;
}

static int
load_regis_coord_pixelvector(RegisGraphicsContext const *context,
			     char const *pixelvector,
			     int origx, int origy,
			     int *xloc, int *yloc)
{
    const int mul = (int) (context->temporary_write_controls.pv_multiplier
			   * COORD_SCALE);
    int found = 0;
    int ux = 0, uy = 0;
    unsigned offset = 0U;

    while (load_regis_raw_pixelvector_digit(pixelvector, &offset,
					    &ux, &uy,
					    mul))
	found = 1;
    if (pixelvector[offset] != '\0') {
	TRACE(("DATA_ERROR: ignoring unknown pixel vector digits: \"%s\"\n",
	       &pixelvector[offset]));
    } {
	const int px = SCALE_XCOORD(context, ux, COORD_SCALE);
	const int py = SCALE_YCOORD(context, uy, COORD_SCALE);

	TRACE(("converted relative X coord %.03f to relative pixel X coord %d (width=%d xoff=%d xdiv=%d)\n",
	       ux / (double) COORD_SCALE, px, context->width,
	       context->x_off, context->x_div));
	*xloc = origx + px;

	TRACE(("converted relative Y coord %.03f to relative pixel Y coord %d (height=%d yoff=%d ydiv=%d)\n",
	       uy / (double) COORD_SCALE, py, context->height,
	       context->y_off, context->y_div));
	*yloc = origy + py;
    }

    return found;
}

static int
load_regis_coord_pixelvector_step(RegisGraphicsContext const *context,
				  char const *pixelvector,
				  unsigned *offset,
				  int origx, int origy,
				  int *xloc, int *yloc)
{
    const int mul = (int) (context->temporary_write_controls.pv_multiplier
			   * COORD_SCALE);
    int found = 0;
    int ux = 0, uy = 0;
    if (load_regis_raw_pixelvector_digit(pixelvector, offset, &ux, &uy, mul))
	found = 1;
    if (!found && pixelvector[*offset] != '\0') {
	TRACE(("DATA_ERROR: ignoring unknown pixel vector digits: \"%s\"\n",
	       &pixelvector[*offset]));
    } {
	const int px = SCALE_XCOORD(context, ux, COORD_SCALE);
	const int py = SCALE_YCOORD(context, uy, COORD_SCALE);

	TRACE(("converted relative X coord %.03f to relative pixel X coord %d (width=%d xoff=%d xdiv=%d)\n",
	       ux / (double) COORD_SCALE, px, context->width,
	       context->x_off, context->x_div));
	*xloc = origx + px;

	TRACE(("converted relative Y coord %.03f to relative pixel Y coord %d (height=%d yoff=%d ydiv=%d)\n",
	       uy / (double) COORD_SCALE, py, context->height,
	       context->y_off, context->y_div));
	*yloc = origy + py;
    }

    return found;
}

static int
load_regis_write_control(RegisParseState *state,
			 RegisGraphicsContext const *context,
			 int cur_x, int cur_y,
			 int option,
			 RegisDataFragment *arg,
			 RegisWriteControls *out)
{
    TRACE(("checking write control option \"%c\" with arg \"%s\"\n",
	   option, fragment_to_tempstr(arg)));
    switch (option) {
    case 'A':
    case 'a':
	TRACE(("write control alternate display method \"%s\"\n",
	       fragment_to_tempstr(arg)));
	{
	    int val;
	    if (!regis_num_to_int(arg, &val) || val < 0 || val >= 1) {
		TRACE(("DATA_ERROR: interpreting out of range value as 0 FIXME\n"));
		break;
	    }
	}
	break;
    case 'C':
    case 'c':
	TRACE(("write control compliment writing mode \"%s\"\n",
	       fragment_to_tempstr(arg)));
	out->write_style = WRITE_STYLE_COMPLEMENT;
	break;
    case 'E':
    case 'e':
	TRACE(("write control erase writing mode \"%s\"\n",
	       fragment_to_tempstr(arg)));
	out->write_style = WRITE_STYLE_ERASE;
	break;
    case 'F':
    case 'f':
	TRACE(("write control plane write mask \"%s\"\n",
	       fragment_to_tempstr(arg)));
	{
	    int val;
	    if (!regis_num_to_int(arg, &val) ||
		val < 0 || val >= (int) context->destination_graphic->valid_registers) {
		TRACE(("DATA_ERROR: interpreting out of range value as 0 FIXME\n"));
		out->plane_mask = 0U;
	    } else {
		out->plane_mask = (unsigned) val;
	    }
	}
	break;
    case 'I':
    case 'i':
	TRACE(("write control foreground color \"%s\"\n",
	       fragment_to_tempstr(arg)));
	if (!load_regis_regnum_or_colorspec(context, arg, &out->foreground)) {
	    TRACE(("DATA_ERROR: write control foreground color specifier not recognized: \"%s\"\n",
		   fragment_to_tempstr(arg)));
	    return 0;
	}
	break;
    case 'L':
    case 'l':
	TRACE(("write control line width \"%s\" (FIXME: currently ignored)\n",
	       fragment_to_tempstr(arg)));
	{
	    int val;
	    if (!regis_num_to_int(arg, &val) ||
		val < 0 || val >= (int) 9) {
		TRACE(("interpreting out of range value as 1 FIXME\n"));
		out->line_width = 1U;
	    } else {
		out->line_width = (unsigned) val;
	    }
	}
	break;
    case 'M':
    case 'm':
	TRACE(("write control found pixel multiplication factor \"%s\"\n",
	       fragment_to_tempstr(arg)));
	{
	    int val;
	    if (!regis_num_to_int(arg, &val) || val <= 0) {
		TRACE(("interpreting out of range value %d as 1 FIXME\n", val));
		out->pv_multiplier = 1U;
	    } else {
		out->pv_multiplier = (unsigned) val;
	    }
	}
	break;
    case 'N':
    case 'n':
	TRACE(("write control negative pattern control \"%s\"\n",
	       fragment_to_tempstr(arg)));
	{
	    int val;
	    if (!regis_num_to_int(arg, &val)) {
		val = -1;
	    }
	    switch (val) {
	    default:
		TRACE(("interpreting out of range value %d as 0 FIXME\n", val));
		out->invert_pattern = 0U;
		break;
	    case 0:
		out->invert_pattern = 0U;
		break;
	    case 1:
		out->invert_pattern = 1U;
		break;
	    }
	}
	break;
    case 'P':
    case 'p':
	TRACE(("write control found pattern control \"%s\"\n",
	       fragment_to_tempstr(arg)));
	{
	    RegisDataFragment suboptionset;
	    RegisDataFragment suboptionarg;
	    RegisDataFragment item;
	    char suboption;

	    while (!fragment_consumed(arg)) {
		if (skip_regis_whitespace(arg))
		    continue;

		TRACE(("looking for option in \"%s\"\n",
		       fragment_to_tempstr(arg)));
		if (extract_regis_parenthesized_data(arg, &suboptionset)) {
		    TRACE(("got write pattern suboptionset: \"%s\"\n",
			   fragment_to_tempstr(&suboptionset)));
		    while (!fragment_consumed(&suboptionset)) {
			skip_regis_whitespace(&suboptionset);
			if (extract_regis_option(&suboptionset, &suboption,
						 &suboptionarg)) {
			    skip_regis_whitespace(&suboptionarg);
			    TRACE(("inspecting write pattern suboption \"%c\" with value \"%s\"\n",
				   suboption,
				   fragment_to_tempstr(&suboptionarg)));
			    switch (suboption) {
			    case 'M':
			    case 'm':
				TRACE(("found pattern multiplier \"%s\"\n",
				       fragment_to_tempstr(&suboptionarg)));
				{
				    RegisDataFragment num;
				    int val;

				    if (extract_regis_num(&suboptionarg,
							  &num)) {
					if (!regis_num_to_int(&num, &val)
					    || val < 1) {
					    TRACE(("interpreting out of range pattern multiplier \"%s\" as 2 FIXME\n",
						   fragment_to_tempstr(&num)));
					    out->pattern_multiplier = 2U;
					} else {
					    out->pattern_multiplier =
						(unsigned) val;
					}
					skip_regis_whitespace(&suboptionarg);
				    }

				    if (!fragment_consumed(&suboptionarg)) {
					TRACE(("DATA_ERROR: unknown content after pattern multiplier \"%s\"\n",
					       fragment_to_tempstr(&suboptionarg)));
					return 0;
				    }
				}
				break;
			    default:
				TRACE(("DATA_ERROR: unknown ReGIS write pattern suboption '%c' arg \"%s\"\n",
				       suboption,
				       fragment_to_tempstr(&suboptionarg)));
				return 0;
			    }
			    continue;
			}

			TRACE(("DATA_ERROR: skipping unknown token in pattern control suboptionset (expecting option): \"%s\"\n",
			       fragment_to_tempstr(&suboptionset)));
			pop_fragment(&suboptionset);
		    }
		    continue;
		}

		TRACE(("looking for int in \"%s\"\n",
		       fragment_to_tempstr(arg)));
		if (extract_regis_num(arg, &item)) {
		    if (peek_fragment(&item) == '0' ||
			peek_fragment(&item) == '1') {
			unsigned pattern = 0U;
			unsigned bitcount;

			TRACE(("converting pattern bits \"%s\"\n",
			       fragment_to_tempstr(&item)));
			for (bitcount = 0;; bitcount++) {
			    char ch = pop_fragment(&item);
			    if (ch == '\0')
				break;
			    switch (ch) {
			    case '0':
				if (bitcount < MAX_PATTERN_BITS) {
				    pattern <<= 1U;
				}
				break;
			    case '1':
				if (bitcount < MAX_PATTERN_BITS) {
				    pattern <<= 1U;
				    pattern |= 1U;
				}
				break;
			    default:
				TRACE(("DATA_ERROR: unknown ReGIS write pattern bit value \"%c\"\n",
				       ch));
				return 0;
			    }
			}

			if (bitcount > 0U) {
			    unsigned extrabits;

			    for (extrabits = 0;
				 bitcount + extrabits < MAX_PATTERN_BITS;
				 extrabits++) {
				if (pattern & (1U << (bitcount - 1U))) {
				    pattern <<= 1U;
				    pattern |= 1U;
				} else {
				    pattern <<= 1U;
				}
			    }
			}

			out->pattern = pattern;
		    } else {
			int val;

			TRACE(("converting pattern id \"%s\"\n",
			       fragment_to_tempstr(&item)));
			if (!regis_num_to_int(&item, &val))
			    val = -1;
			switch (val) {	/* FIXME: exponential allowed? */
			case 0:
			    out->pattern = 0x00;	/* solid bg */
			    break;
			case 1:
			    out->pattern = 0xff;	/* solid fg */
			    break;
			case 2:
			    out->pattern = 0xf0;	/* dash */
			    break;
			case 3:
			    out->pattern = 0xe4;	/* dash dot */
			    break;
			case 4:
			    out->pattern = 0xaa;	/* dot */
			    break;
			case 5:
			    out->pattern = 0xea;	/* dash dot dot */
			    break;
			case 6:
			    out->pattern = 0x88;	/* sparse dot */
			    break;
			case 7:
			    out->pattern = 0x84;	/* asymmetric sparse dot */
			    break;
			case 8:
			    out->pattern = 0xc8;	/* sparse dash dot */
			    break;
			case 9:
			    out->pattern = 0x86;	/* sparse dot dash */
			    break;
			default:
			    TRACE(("DATA_ERROR: unknown ReGIS standard write pattern \"%d\"\n",
				   val));
			    return 0;
			}
		    }

		    TRACE(("final pattern is %02x\n", out->pattern));
		    continue;
		}
		skip_regis_whitespace(arg);

		TRACE(("DATA_ERROR: skipping unknown token in pattern suboption: \"%s\"\n",
		       fragment_to_tempstr(arg)));
		pop_fragment(arg);
	    }
	}
	break;
    case 'R':
    case 'r':
	TRACE(("write control switch to replacement writing mode \"%s\"\n",
	       fragment_to_tempstr(arg)));
	out->write_style = WRITE_STYLE_REPLACE;
	break;
    case 'S':
    case 's':
	TRACE(("write control shading control \"%s\"\n",
	       fragment_to_tempstr(arg)));
	{
	    RegisDataFragment suboptionset;
	    RegisDataFragment suboptionarg;
	    RegisDataFragment item;
	    char suboption;
	    char shading_character = '\0';
	    unsigned reference_dim = WRITE_SHADING_REF_Y;
	    /* FIXME: are relative offsets additive? */
	    int ref_x = cur_x, ref_y = cur_y;
	    int shading_enabled = 0;

	    while (!fragment_consumed(arg)) {
		if (skip_regis_whitespace(arg))
		    continue;

		if (extract_regis_string(arg, state->temp, state->templen)) {
		    TRACE(("found fill char \"%s\"\n", state->temp));
		    /* FIXME: allow longer strings, ignore extra chars, or treat as error? */
		    if (strlen(state->temp) != 1) {
			TRACE(("DATA_ERROR: expected exactly one char in fill string FIXME\n"));
			return 0;
		    }
		    shading_character = state->temp[0];
		    shading_enabled = 1;
		    TRACE(("shading character is: '%c' (%d)\n",
			   shading_character, (int) shading_character));
		    continue;
		}

		if (extract_regis_parenthesized_data(arg, &suboptionset)) {
		    skip_regis_whitespace(&suboptionset);
		    TRACE(("got shading control suboptionset: \"%s\"\n",
			   fragment_to_tempstr(&suboptionset)));
		    while (!fragment_consumed(&suboptionset)) {
			if (skip_regis_whitespace(&suboptionset))
			    continue;
			if (extract_regis_option(&suboptionset, &suboption,
						 &suboptionarg)) {
			    TRACE(("inspecting write shading suboption \"%c\" with value \"%s\"\n",
				   suboption,
				   fragment_to_tempstr(&suboptionarg)));
			    switch (suboption) {
			    case 'X':
			    case 'x':
				TRACE(("found horizontal shading suboption \"%s\"\n",
				       fragment_to_tempstr(&suboptionarg)));
				if (!fragment_consumed(&suboptionarg)) {
				    TRACE(("DATA_ERROR: unexpected value to horizontal shading suboption FIXME\n"));
				    return 0;
				}
				reference_dim = WRITE_SHADING_REF_X;
				shading_enabled = 1;
				break;
			    default:
				TRACE(("DATA_ERROR: unknown ReGIS write pattern suboption '%c' arg \"%s\"\n",
				       suboption,
				       fragment_to_tempstr(&suboptionarg)));
				return 0;
			    }
			    continue;
			}

			TRACE(("DATA_ERROR: skipping unknown token in shading control suboptionset (expecting option): \"%s\"\n",
			       fragment_to_tempstr(&suboptionset)));
			pop_fragment(&suboptionset);
		    }
		    continue;
		}

		if (extract_regis_extent(arg, &item)) {
		    TRACE(("found extent in shading option curr=%d,%d ref=%d,%d\n",
			   cur_x, cur_y, ref_x, ref_y));
		    if (!load_regis_coord_extent(context,
						 fragment_to_tempstr(&item),
						 ref_x, ref_y,
						 &ref_x, &ref_y)) {
			TRACE(("DATA_ERROR: unable to parse extent in write shading option '%c': \"%s\"\n",
			       option, fragment_to_tempstr(&item)));
			return 0;
		    }
		    TRACE(("shading reference = %d,%d (%s)\n", ref_x, ref_y,
			   ((reference_dim == WRITE_SHADING_REF_X)
			    ? "X"
			    : "Y")));
		    continue;
		}

		if (extract_regis_num(arg, &item)) {
		    if (!regis_num_to_int(&item, &shading_enabled)) {
			TRACE(("DATA_ERROR: unable to parse int in write shading option '%c': \"%s\"\n",
			       option, fragment_to_tempstr(&item)));
			return 0;
		    }
		    if (shading_enabled < 0 || shading_enabled > 1) {
			TRACE(("interpreting out of range value %d as 0 FIXME\n",
			       shading_enabled));
			shading_enabled = 0;
		    }
		    TRACE(("shading enabled = %d\n", shading_enabled));
		    continue;
		}

		if (skip_regis_whitespace(arg)) {
		    continue;
		}

		TRACE(("DATA_ERROR: skipping unknown token in shade suboption: \"%s\"\n",
		       fragment_to_tempstr(arg)));
		pop_fragment(arg);
	    }

	    if (shading_enabled) {
		out->shading_enabled = 1U;
		out->shading_reference_dim = reference_dim;
		out->shading_reference = ((reference_dim == WRITE_SHADING_REF_X)
					  ? ref_x
					  : ref_y);
		out->shading_character = shading_character;
		TRACE(("final shading state: enabled, dim=%d ref=%d, char=%c\n",
		       out->shading_reference_dim, out->shading_reference,
		       out->shading_character));
	    } else {
		/* FIXME: confirm there is no effect if shading isn't enabled
		 * in the same command
		 */
		out->shading_enabled = 0U;
		TRACE(("final shading state: shading disabled\n"));
	    }
	}
	break;
    case 'V':
    case 'v':
	TRACE(("write control switch to overlay writing mode \"%s\"\n",
	       fragment_to_tempstr(arg)));
	out->write_style = WRITE_STYLE_OVERLAY;
	break;
    default:
	TRACE(("DATA_ERROR: ignoring unknown ReGIS write option \"%c\" arg \"%s\"\n",
	       option, fragment_to_tempstr(arg)));
	return 0;
    }

    return 1;
}

static int
load_regis_write_control_set(RegisParseState *state,
			     RegisGraphicsContext const *context,
			     int cur_x, int cur_y,
			     RegisDataFragment *controls,
			     RegisWriteControls *out)
{
    RegisDataFragment optionset;
    RegisDataFragment arg;
    char option;

    while (!fragment_consumed(controls)) {
	if (skip_regis_whitespace(controls))
	    continue;

	if (extract_regis_parenthesized_data(controls, &optionset)) {
	    TRACE(("got write control optionset: \"%s\"\n",
		   fragment_to_tempstr(&optionset)));
	    while (!fragment_consumed(&optionset)) {
		skip_regis_whitespace(&optionset);
		if (extract_regis_option(&optionset, &option, &arg)) {
		    skip_regis_whitespace(&arg);
		    TRACE(("got write control option and value: \"%c\" \"%s\"\n",
			   option, fragment_to_tempstr(&arg)));
		    if (!load_regis_write_control(state, context,
						  cur_x, cur_y,
						  option, &arg, out)) {
			return 0;
		    }
		    continue;
		}

		TRACE(("DATA_ERROR: skipping unknown token in write control optionset (expecting option): \"%s\"\n",
		       fragment_to_tempstr(&optionset)));
		pop_fragment(&optionset);
	    }
	    continue;
	}

	TRACE(("DATA_ERROR: skipping unknown token in write controls (expecting optionset): \"%s\"\n",
	       fragment_to_tempstr(controls)));
	pop_fragment(controls);
    }

    return 1;
}

static void
init_regis_write_controls(int graphics_termid, unsigned all_planes,
			  RegisWriteControls *controls)
{
    controls->pv_multiplier = 1U;
    controls->pattern = 0xff;	/* solid */
    controls->pattern_multiplier = 2U;
    controls->invert_pattern = 0U;
    controls->plane_mask = all_planes;
    controls->write_style = WRITE_STYLE_OVERLAY;
    switch (graphics_termid) {
    case 125:			/* FIXME: verify */
    case 240:			/* FIXME: verify */
    case 241:			/* FIXME: verify */
    case 330:
	controls->foreground = 3U;
	break;
    case 340:
    default:
	controls->foreground = 7U;
	break;
    case 382:
	controls->foreground = 1U;	/* FIXME: verify */
	break;
    }
    controls->shading_enabled = 0U;
    controls->shading_character = '\0';
    controls->shading_reference = 0;	/* no meaning if shading is disabled */
    controls->shading_reference_dim = WRITE_SHADING_REF_NONE;
    controls->line_width = 1U;
    /* FIXME: add the rest */
}

static void
map_regis_graphics_pages(XtermWidget xw, RegisGraphicsContext *context)
{
    const int charrow = 0;
    const int charcol = 0;
    unsigned old_display_id = ~0U;

    if (context->destination_graphic)
	context->destination_graphic->hidden = True;
    if (context->display_graphic) {
	context->display_graphic->hidden = True;
	old_display_id = context->display_graphic->id;
    }

    context->destination_graphic =
	get_new_or_matching_graphic(xw,
				    charrow, charcol,
				    context->width,
				    context->height,
				    context->destination_page);
    if (context->destination_graphic) {
	context->destination_graphic->hidden = True;
	context->destination_graphic->valid = True;
    }

    context->display_graphic =
	get_new_or_matching_graphic(xw,
				    charrow, charcol,
				    context->width,
				    context->height,
				    context->display_page);
    if (context->display_graphic) {
	context->display_graphic->hidden = False;
	if (old_display_id != context->display_graphic->id) {
	    if (!context->display_graphic->valid) {
		draw_solid_rectangle(context->display_graphic, 0, 0,
				     context->width, context->height,
				     context->background);
	    }
	    context->display_graphic->dirty = True;
	    context->force_refresh = True;
	    /* FIXME: This isn't really enough.  If there are holes in the new
	     * graphic they should be cleared and set to the text from the same
	     * page.  But we don't have pages for text in xterm (the alt buffer
	     * is similar though).
	     */
	}
	context->display_graphic->valid = True;
    }

    TRACE(("using graphics destination=[%d -> %u] display=[%d -> %u]\n",
	   context->destination_page,
	   (context->destination_graphic
	    ? context->destination_graphic->id
	    : 0U),
	   context->display_page,
	   (context->display_graphic
	    ? context->display_graphic->id
	    : 0U)));
}

static void
copy_regis_write_controls(RegisWriteControls const *src,
			  RegisWriteControls *dst)
{
    dst->pv_multiplier = src->pv_multiplier;
    dst->pattern = src->pattern;
    dst->pattern_multiplier = src->pattern_multiplier;
    dst->invert_pattern = src->invert_pattern;
    dst->foreground = src->foreground;
    dst->plane_mask = src->plane_mask;
    dst->write_style = src->write_style;
    dst->shading_enabled = src->shading_enabled;
    dst->shading_character = src->shading_character;
    dst->shading_reference = src->shading_reference;
    dst->shading_reference_dim = src->shading_reference_dim;
    dst->line_width = src->line_width;
}

static void
init_regis_text_controls(RegisTextControls *controls)
{
    controls->alphabet_num = 0U;	/* built-in */
    controls->character_set_l = 0U;	/* ASCII */
    controls->character_set_r = 0U;	/* Latin-1 */
    get_standard_character_size(1, &controls->character_display_w,
				&controls->character_display_h,
				&controls->character_unit_cell_w,
				&controls->character_unit_cell_h,
				&controls->character_inc_x,
				&controls->character_inc_y);
    controls->string_rotation = 0;
    controls->character_rotation = 0;
    controls->slant = 0;
}

static void
copy_regis_text_controls(RegisTextControls const *src, RegisTextControls *dst)
{
    dst->alphabet_num = src->alphabet_num;
    dst->character_set_l = src->character_set_l;
    dst->character_set_r = src->character_set_r;
    dst->character_display_w = src->character_display_w;
    dst->character_display_h = src->character_display_h;
    dst->character_unit_cell_w = src->character_unit_cell_w;
    dst->character_unit_cell_h = src->character_unit_cell_h;
    dst->character_inc_x = src->character_inc_x;
    dst->character_inc_y = src->character_inc_y;
    dst->string_rotation = src->string_rotation;
    dst->character_rotation = src->character_rotation;
    dst->slant = src->slant;
}

static void
init_regis_alphabets(RegisGraphicsContext *context)
{
    unsigned alphabet_index;

    for (alphabet_index = 0U; alphabet_index < MAX_REGIS_ALPHABETS;
	 alphabet_index++) {
	context->alphabets[alphabet_index].alphabet_num = INVALID_ALPHABET_NUM;
	context->alphabets[alphabet_index].pixw = 0U;
	context->alphabets[alphabet_index].pixh = 0U;
	context->alphabets[alphabet_index].name[0] = '\0';
	context->alphabets[alphabet_index].fontname[0] = '\0';
	context->alphabets[alphabet_index].use_font = 0;
	context->alphabets[alphabet_index].bytes = NULL;
    }
}

static void
init_regis_graphics_context(int graphics_termid, int width, int height,
			    unsigned max_colors, const char *builtin_font,
			    RegisGraphicsContext *context)
{
    context->destination_graphic = NULL;
    context->display_graphic = NULL;
    context->display_page = 0U;
    context->destination_page = 0U;
    context->graphics_termid = graphics_termid;

    /* reset addressing / clear user coordinates */
    context->width = width;
    context->height = height;
    context->x_off = 0;
    context->y_off = 0;
    context->x_div = width - 1;
    context->y_div = height - 1;

    /*
     * Generate a mask covering all valid color register address bits
     * (but don't bother past 2**16).
     */
    context->all_planes = max_colors;
    context->all_planes--;
    context->all_planes |= 1U;
    context->all_planes |= context->all_planes >> 1U;
    context->all_planes |= context->all_planes >> 2U;
    context->all_planes |= context->all_planes >> 4U;
    context->all_planes |= context->all_planes >> 8U;

    context->builtin_font = builtin_font;

    init_regis_write_controls(graphics_termid, context->all_planes,
			      &context->persistent_write_controls);
    copy_regis_write_controls(&context->persistent_write_controls,
			      &context->temporary_write_controls);

    init_regis_text_controls(&context->persistent_text_controls);
    context->current_text_controls = &context->persistent_text_controls;
    init_regis_alphabets(context);

    context->multi_input_mode = 0;
    /* FIXME: coordinates */
    /* FIXME: scrolling */
    context->background = 0U;
    /* FIXME: input cursor location */
    /* FIXME: input cursor style */
    context->graphics_output_cursor_x = 0;
    context->graphics_output_cursor_y = 0;
    /* FIXME: output cursor style */

    context->force_refresh = False;
}

static int
parse_regis_command(RegisParseState *state)
{
    char ch;

    if (!extract_regis_command(&state->input, &ch))
	return 0;

    switch (ch) {
    case 'C':
    case 'c':
	/* Curve

	 * C
	 * (A)  # set the arc length in degrees (+ or nothing for
	 *      # counter-clockwise, - for clockwise, rounded to the
	 *      # closest integer degree)
	 * (B)  # begin closed curve sequence (must have at least two
	 *      # values; this option can not be nested)
	 * (C)  # position is the center, current location is the
	 *      # circumference (stays in effect until next command)
	 * (E)  # end curve sequence (drawing is performed here)
	 * (S)  # begin open curve sequence
	 * (W)  # temporary write options (see write command)
	 * [<center, circumference position>]  # center if (C), otherwise point on circumference
	 * [<point in curve sequence>]...  # if between (B) and (E)
	 * <pv>...  # if between (B) and (E)
	 */
	TRACE(("found ReGIS command \"%c\" (curve)\n", ch));
	state->command = 'c';
	state->curve_mode = CURVE_POSITION_ARC_EDGE;
	state->arclen = 360;
	state->num_points = 0U;
	break;
    case 'F':
    case 'f':
	/* Fill

	 * F
	 * (V)  # polygon (see vector command)
	 * (C)  # curve (see curve command)
	 * (W)  # temporary write options (see write command)
	 */
	TRACE(("found ReGIS command \"%c\" (filled polygon)\n", ch));
	state->command = 'f';
	break;
    case 'L':
    case 'l':
	/* Load

	 * L
	 * (A)  # set alphabet number or name
	 * (F)"fontname"  # load from font (xterm extension)
	 * (S)[w,h]  # set glyph size (xterm extension)
	 * "ascii"xx,xx,xx,xx,xx,xx,xx,xx  # pixel values
	 */
	TRACE(("found ReGIS command \"%c\" (load charset)\n", ch));
	state->command = 'l';
	break;
    case 'P':
    case 'p':
	/* Position

	 * P
	 * (B)  # begin bounded position stack (last point returns to first)
	 * (E)  # end position stack
	 * (P)  # select graphics page for the input and output cursors
	 * (S)  # begin unbounded position stack
	 * (W)  # temporary write options (see write command)
	 * <pv>  # move: 0 == right, 1 == upper right, ..., 7 == lower right
	 * [<position>]  # move to position (X, Y, or both)
	 *
	 * Note the stack does not need to be ended before the next command
	 * Note: maximum depth is 16 levels
	 */
	TRACE(("found ReGIS command \"%c\" (position)\n", ch));
	state->command = 'p';
	break;
    case 'R':
    case 'r':
	/* Report

	 * R
	 * (E)  # parse error
	 * (I<val>)  # set input mode (0 == one-shot, 1 == multiple) (always returns CR)
	 * (L)  # current alphabet number and name
	 * (M(<name>)  # macrograph contents
	 * (M(=)  # macrograph storage (free bytes of total bytes)
	 * (P)  # absolute output cursor position
	 * (P(I))  # interactive locator mode (in one-shot or multiple mode)
	 * (P(I[xmul,ymul]))  # interactive locator mode with arrow key movement multipliers
	 */
	TRACE(("found ReGIS command \"%c\" (report status)\n", ch));
	state->command = 'r';
	break;
    case 'S':
    case 's':
	/* Screen

	 * S
	 * (A[<upper left>][<lower right>])  # adjust screen coordinates
	 * (C<setting>  # 0 (cursor output off), 1 (cursor output on)
	 * (E)  # erase to background color, resets shades, curves, and stacks
	 * (F)  # print the graphic and erase the screen (DECprint extension)
	 * (H(P<printer offset>)[<print area cornet>][<print area corner>)
	 * (I<color register>)  # set the background to a specific register
	 * (I(<rgbcode>))  # set the background to the register closest to an "RGB" color
	 * (I(R<r>G<g>B<b>))  # set the background to the register closest to an RGB triplet (RLogin extension)
	 * (I(H<h>L<l>S<s>))  # set the background to the register closest to an HLS triplet
	 * (I(L<l>))  # set the background to the register closest to a grayscale value
	 * (M<color index to set>(<rgbcode>)...)  # codes are D (black), R (red), G (green), B (blue), C (cyan), Y (yellow), M (magenta), W (white) (sets color and grayscale registers)
	 * (M<color index to set>(A<rgbcode>)...)  # codes are D (black), R (red), G (green), B (blue), C (cyan), Y (yellow), M (magenta), W (white) (sets color registers only)
	 * (M<color index to set>(R<red>G<green>B<blue>)...)  # 0..100, 0..100, 0..100 (sets color and grayscale registers) (RLogin extension)
	 * (M<color index to set>(AR<red>G<green>B<blue>)...)  # 0..100, 0..100, 0..100 (sets color registers only) (RLogin extension)
	 * (M<color index to set>(H<hue>L<lightness>S<saturation>)...)  # 0..360, 0..100, 0..100 (sets color and grayscale registers)
	 * (M<color index to set>(AH<hue>L<lightness>S<saturation>)...)  # 0..360, 0..100, 0..100 (sets color registers only)
	 * (M<color index to set>(L<mono level>)...)  # level is 0 ... 100 (sets grayscale registers only)
	 * (P<graphics page number>)  # 0 (default) or 1
	 * (S(<scale>)  # scale screen output by scale (default 1, VT125:max=2, VT3x0:unsupported) FIXME
	 * (S(X<scale>)  # scale screen output horizontally by scale (default 1, VT125:max=2, VT3x0:unsupported) FIXME
	 * (S(Y<scale>)  # scale screen output vertically by scale (default 1, VT125:max=2, VT3x0:unsupported) FIXME
	 * (T(<time delay ticks>)  # delay (60 ticks is one second, up to 32767 ticks)
	 * (N<setting>)  # 0 == normal video, 1 == negative/reverse video (not supported on VT3x0)
	 * (W(M<factor>)  # PV multiplier
	 * <PV scroll offset>  # scroll data so given coordinate is at the upper-left
	 * [scroll offset]  # scroll data so given coordinate is at the upper-left
	 */
	TRACE(("found ReGIS command \"%c\" (screen)\n", ch));
	state->command = 's';
	break;
    case 'T':
    case 't':
	/* Text

	 * T
	 * (A)  # specify which alphabet/font to select glyphs from (0==builtin)
	 * (A0L"<designator>"))  # specify a built-in set for GL via two-char designator
	 * (A0R"<designator>"))  # specify a built-in set for GR via two-char or three-char designator
	 * (A<num>R"<designator>"))  # specify a user-loaded (1-3) set for GR via two-char or three-char designator
	 * (B)  # begin temporary text control
	 * (D<char angle>)  # specify a character tilt
	 * (D<str angle>S<size id>)  # specify a string tilt
	 * (D<str angle>S<size id>D<char angle>)  # specify a string and character tilt
	 * (E)  # end temporary text control
	 * (H<factor>)  # select a height multiplier (GIGI:1-16, VT340:1-256)
	 * (I<angle>)  # italic/oblique: no slant (0), lean forward (-1 though -45), lean back (+1 through +45)
	 * (M[width factor,height factor])  # select size multipliers (width 1-16) (height 1-256)
	 * (S<size id>)  # select one of the 17 standard character sizes
	 * (S[dimensions])  # set a custom display cell size (char with border)
	 * (U[dimensions])  # set a custom unit cell size (char size)
	 * (W<write command>)  # temporary write options (see write command)
	 * [<char offset>]  # optional manual offset between characters
	 * <PV spacing>  # move half-increments for subscripts and superscripts
	 * '<text>'  # optional
	 * "<text>"  # optional
	 */
	TRACE(("found ReGIS command \"%c\" (text)\n", ch));
	state->command = 't';
	state->text_tilt_state = TEXT_TILT_STATE_READY;
	break;
    case 'V':
    case 'v':
	/* Vector

	 * V
	 * (B)  # begin bounded position stack (last point returns to first)
	 * (E)  # end position stack
	 * (S)  # begin unbounded position stack
	 * (W)  # temporary write options (see write command)
	 * <pv>  # draw a line to the pixel vector
	 * []  # draw a dot at the current location
	 * [<position>]  # draw a line to position
	 */
	TRACE(("found ReGIS command \"%c\" (vector)\n", ch));
	state->command = 'v';
	break;
    case 'W':
    case 'w':
	/* Write

	 * W
	 * (A<setting>)  # 0 == disable alternate, 1 == enable alternate/blink FIXME
	 * (C)  # complement writing mode
	 * (E)  # erase writing mode
	 * (F<plane>)  # set the plane mask to control which pixel bits are updated
	 * (I<color register>)  # set the foreground to a specific register
	 * (I(<rgbcode>))  # set the foreground to the register closest to an "RGB" color
	 * (I(R<r>G<g>B<b>))  # set the foreground to the register closest to an RGB triplet (RLogin extension)
	 * (I(H<h>L<l>S<s>))  # set the foreground to the register closest to an HLS triplet
	 * (I(L<l>))  # set the foreground to the register closest to a grayscale value
	 * (L<width>)  # set the line width (RLogin extension) FIXME
	 * (M<pixel vector multiplier>)  # set the multiplication factor
	 * (N<setting>)  # 0 == negative patterns disabled, 1 == negative patterns enabled
	 * (P<pattern number>)  # 0..9: 0 == none, 1 == solid, 2 == 50% dash, 3 == dash-dot
	 * (P<pattern bits>)  # 2 to 8 bits represented as a 0/1 sequence
	 * (P<(M<pattern multiplier>))  # set the pattern multiplier
	 * (R)  # replacement writing mode
	 * (S'<character>')  # set shading character
	 * (S<setting>)  # 0 == disable shading, 1 == enable shading
	 * (S[reference point])  # set a horizontal reference line including this point (X ignored)
	 * (S(X)[reference point])  # set a vertical reference line including this point
	 * (V)  # overlay writing mode
	 */
	TRACE(("found ReGIS command \"%c\" (write parameters)\n", ch));
	state->command = 'w';
	break;
    case '@':
	/* Macrograph

	 * .  # clear all macrographs
	 * :<letter> ...@;  # define macrograph for letter
	 * <letter>  # expand macrograph for letter
	 */
	TRACE(("found ReGIS macrograph command\n"));
	state->command = '@';
	break;
    default:
	TRACE(("DATA_ERROR: unknown ReGIS command %04x (%c), setting to '_'\n",
	       (int) ch, ch));
	state->command = '_';
	state->option = '_';
	return 0;
    }

    state->option = '_';

    return 1;
}

static int
parse_regis_option(RegisParseState *state, RegisGraphicsContext *context)
{
    XtermWidget xw = context->display_graphic->xw;
    RegisDataFragment optionarg;

    if (!extract_regis_option(&state->input, &state->option, &optionarg))
	return 0;
    skip_regis_whitespace(&optionarg);

    TRACE(("found ReGIS option '%c', parsing argument \"%s\"\n",
	   state->option, fragment_to_tempstr(&optionarg)));

    switch (state->command) {
    case 'c':
	TRACE(("inspecting curve option \"%c\" with value \"%s\"\n",
	       state->option, fragment_to_tempstr(&optionarg)));
	switch (state->option) {
	case 'A':
	case 'a':
	    TRACE(("found arc length \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment arclen;

		if (!extract_regis_num(&optionarg, &arclen)) {
		    TRACE(("DATA_ERROR: expected int in curve arclen option: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
		TRACE(("arc length string %s\n",
		       fragment_to_tempstr(&arclen)));
		if (!regis_num_to_int(&arclen, &state->arclen)) {
		    TRACE(("DATA_ERROR: unable to parse int in curve arclen option: \"%s\"\n",
			   fragment_to_tempstr(&arclen)));
		    break;
		}
		TRACE(("value of arc length is %d\n", state->arclen));
		while (state->arclen < -360)
		    state->arclen += 360;
		while (state->arclen > 360)
		    state->arclen -= 360;
		TRACE(("using final arc length %d\n", state->arclen));

		skip_regis_whitespace(&optionarg);
		if (!fragment_consumed(&optionarg)) {
		    TRACE(("DATA_ERROR: ignoring trailing junk in arc length option \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
	    }
	    break;
	case 'B':
	case 'b':
	    TRACE(("begin closed curve \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: invalid closed curve option \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		break;
	    }
	    state->curve_mode = CURVE_POSITION_CLOSED_CURVE;
	    state->num_points = 0U;
	    state->x_points[state->num_points] =
		context->graphics_output_cursor_x;
	    state->y_points[state->num_points] =
		context->graphics_output_cursor_y;
	    state->num_points++;
	    break;
	case 'C':
	case 'c':
	    TRACE(("found center position mode \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: invalid center position option \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		break;
	    }
	    state->curve_mode = CURVE_POSITION_ARC_CENTER;
	    break;
	case 'E':
	case 'e':
	    TRACE(("found end curve \"%s\"\n", fragment_to_tempstr(&optionarg)));
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: ignoring unexpected arguments to curve option '%c' arg \"%s\"\n",
		       state->option, fragment_to_tempstr(&optionarg)));
	    }

	    switch (state->curve_mode) {
	    case CURVE_POSITION_CLOSED_CURVE:
		{
		    unsigned i;

#ifdef DEBUG_SPLINE_POINTS
		    printf("points: \n");
		    for (i = 0; i < state->num_points; i++)
			printf("  %d,%d\n",
			       state->x_points[i], state->y_points[i]);
#endif

#ifdef DEBUG_SPLINE_WITH_ROTATION
		    {
			static unsigned shift = 0;
			int temp_x[MAX_CURVE_POINTS], temp_y[MAX_CURVE_POINTS];
			shift++;
			shift = shift % state->num_points;
			for (i = 0; i < state->num_points; i++) {
			    temp_x[i] = state->x_points[i];
			    temp_y[i] = state->y_points[i];
			}
			for (i = 0; i < state->num_points; i++) {
			    state->x_points[i] =
				temp_x[(i + shift) % state->num_points];
			    state->y_points[i] =
				temp_y[(i + shift) % state->num_points];
			}

#ifdef DEBUG_SPLINE_POINTS
			printf("after shift %d: \n", shift);
			for (i = 0; i < state->num_points; i++)
			    printf("  %d,%d\n",
				   state->x_points[i], state->y_points[i]);
#endif
		    }
#endif

		    for (i = state->num_points; i > 0; i--) {
			state->x_points[i] = state->x_points[i - 1];
			state->y_points[i] = state->y_points[i - 1];
		    }
		    state->x_points[0] = state->x_points[state->num_points];
		    state->y_points[0] = state->y_points[state->num_points];
		    state->num_points++;
		    for (i = state->num_points; i != 0; i--) {
			state->x_points[i] = state->x_points[i - 1];
			state->y_points[i] = state->y_points[i - 1];
		    }
		    state->x_points[0] = state->x_points[state->num_points - 1];
		    state->y_points[0] = state->y_points[state->num_points - 1];
		    state->num_points++;
		    state->x_points[state->num_points] = state->x_points[2];
		    state->y_points[state->num_points] = state->y_points[2];
		    state->num_points++;
#ifdef DEBUG_SPLINE_WITH_OVERDRAW
		    state->x_points[state->num_points] = state->x_points[3];
		    state->y_points[state->num_points] = state->y_points[3];
		    state->num_points++;
		    state->x_points[state->num_points] = state->x_points[4];
		    state->y_points[state->num_points] = state->y_points[4];
		    state->num_points++;
#endif
#ifdef DEBUG_SPLINE_POINTS
		    printf("after points added: \n");
		    for (i = 0; i < state->num_points; i++)
			printf("  %d,%d\n",
			       state->x_points[i], state->y_points[i]);
#endif
		}

		TRACE(("drawing closed spline\n"));
		TRACE(("output location was: %d,%d\n",
		       context->graphics_output_cursor_x,
		       context->graphics_output_cursor_y));
		global_context = context;	/* FIXME: remove after updating spline code */
		plotCubicSpline((int) state->num_points - 1,
				state->x_points, state->y_points,
				1);
		TRACE(("output location now: %d,%d\n",
		       context->graphics_output_cursor_x,
		       context->graphics_output_cursor_y));
		TRACE(("output location finally: %d,%d\n",
		       context->graphics_output_cursor_x,
		       context->graphics_output_cursor_y));
		state->num_points = 0U;
		break;
	    case CURVE_POSITION_OPEN_CURVE:
#ifdef DEBUG_SPLINE_POINTS
		{
		    unsigned i;

		    printf("points: \n");
		    for (i = 0U; i < state->num_points; i++)
			printf("  %d,%d\n",
			       state->x_points[i], state->y_points[i]);
		}
#endif
		TRACE(("drawing open spline\n"));
		TRACE(("output location was: %d,%d\n",
		       context->graphics_output_cursor_x,
		       context->graphics_output_cursor_y));
		global_context = context;	/* FIXME: remove after updating spline code */
		plotCubicSpline((int) state->num_points - 1,
				state->x_points, state->y_points,
				1);
		TRACE(("output location now: %d,%d\n",
		       context->graphics_output_cursor_x,
		       context->graphics_output_cursor_y));

		context->graphics_output_cursor_x =
		    state->x_points[state->num_points - 1];
		context->graphics_output_cursor_y =
		    state->y_points[state->num_points - 1];
		TRACE(("output location finally: %d,%d\n",
		       context->graphics_output_cursor_x,
		       context->graphics_output_cursor_y));
		state->num_points = 0U;
		break;
	    default:
		TRACE(("DATA_ERROR: end curve option unexpected \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		break;
	    }
	    break;
	case 'S':
	case 's':
	    TRACE(("begin open curve \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: invalid open curve option \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		break;
	    }
	    state->curve_mode = CURVE_POSITION_OPEN_CURVE;
	    state->num_points = 0U;
	    state->x_points[state->num_points] =
		context->graphics_output_cursor_x;
	    state->y_points[state->num_points] =
		context->graphics_output_cursor_y;
	    state->num_points++;
	    TRACE(("first point on curve with location %d,%d\n",
		   context->graphics_output_cursor_x,
		   context->graphics_output_cursor_y));
	    break;
	case 'W':
	case 'w':
	    TRACE(("found temporary write options \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!load_regis_write_control_set(state, context,
					      context->graphics_output_cursor_x,
					      context->graphics_output_cursor_y,
					      &optionarg,
					      &context->temporary_write_controls)) {
		TRACE(("DATA_ERROR: invalid temporary write options \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		break;
	    }
	    break;
	default:
	    TRACE(("DATA_ERROR: ignoring unknown ReGIS curve command option '%c' arg \"%s\"\n",
		   state->option, fragment_to_tempstr(&optionarg)));
	    break;
	}
	break;
    case 'f':
	TRACE(("ERROR: fill commands should not be handled here\n"));
	break;
    case 'l':
	TRACE(("inspecting load option \"%c\" with value \"%s\"\n",
	       state->option, fragment_to_tempstr(&optionarg)));
	switch (state->option) {
	case 'A':
	case 'a':
	    TRACE(("found alphabet specifier option \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    for (;;) {
		RegisDataFragment alphabetarg;

		if (extract_regis_num(&optionarg, &alphabetarg)) {
		    int alphabet;

		    TRACE(("alphabet number: %s\n",
			   fragment_to_tempstr(&alphabetarg)));
		    if (!regis_num_to_int(&alphabetarg, &alphabet)) {
			TRACE(("DATA_ERROR: unable to parse int in load alphabet option: \"%s\"\n",
			       fragment_to_tempstr(&alphabetarg)));
			break;
		    }
		    if (alphabet < 0 ||
			(unsigned) alphabet >= MAX_REGIS_ALPHABETS) {
			TRACE(("DATA_ERROR: invalid alphabet: \"%d\"\n",
			       alphabet));
			break;
		    }
#ifndef ENABLE_UPLOAD_ALPHABET_ZERO
		    if (alphabet == 0) {
			TRACE(("DATA_ERROR: alphabet 0 can not be modified\n"));
			break;
		    }
#endif

		    TRACE(("setting load alphabet: %d\n", alphabet));
		    init_regis_load_state(state);
		    state->load_alphabet = (unsigned) alphabet;
		} else if (extract_regis_string(&optionarg, state->temp,
						state->templen)) {
		    TRACE(("alphabet name: %s\n", state->temp));
		    if (strlen(state->temp) == 0U ||
			strlen(state->temp) >= REGIS_ALPHABET_NAME_LEN) {
			TRACE(("DATA_ERROR: alphabet names must be between 1 and %u characters long: \"%s\" FIXME\n",
			       REGIS_ALPHABET_NAME_LEN - 1U, state->temp));
			break;
		    }

		    strcpy(state->load_name, state->temp);
		    TRACE(("using name for alphabet %u: %s\n",
			   state->load_alphabet, state->load_name));
		} else if (skip_regis_whitespace(&optionarg)) {
		    ;
		} else if (fragment_consumed(&optionarg)) {
		    break;
		} else {
		    TRACE(("DATA_ERROR: expected int or string in load alphabet option: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
	    }
	    break;
#ifdef ENABLE_UPLOAD_ALPHABET_FROM_FONT
	case 'F':
	case 'f':
	    TRACE(("found font option \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));

	    if (state->load_index == MAX_REGIS_ALPHABETS) {
		state->load_index = find_free_alphabet_index(context,
							     state->load_alphabet,
							     state->load_w,
							     state->load_h);
		TRACE(("current alphabet is %u and size is %ux%u; assigning alphabet index %u\n",
		       state->load_alphabet, state->load_w,
		       state->load_h, state->load_index));
	    }

	    for (;;) {
		RegisDataFragment fontarg;

		if (skip_regis_whitespace(&optionarg))
		    continue;
		if (extract_regis_num(&optionarg, &fontarg)) {
		    int enabled;

		    TRACE(("fontname enabled: %s\n",
			   fragment_to_tempstr(&fontarg)));
		    if (!regis_num_to_int(&fontarg, &enabled)) {
			TRACE(("DATA_ERROR: unable to parse int in load fontname option: \"%s\"\n",
			       fragment_to_tempstr(&fontarg)));
			break;
		    }
		    if (enabled != 0U && enabled != 1U) {
			TRACE(("DATA_ERROR: invalid fontname enable state: \"%d\"\n", enabled));
			break;
		    }

		    TRACE(("fontname enabled: %d\n", enabled));
		    context->alphabets[state->load_index].use_font = enabled;
		    continue;
		}
		if (extract_regis_string(&optionarg, state->temp,
					 state->templen)) {
		    if (strlen(state->temp) == 0U ||
			strlen(state->temp) >= REGIS_FONTNAME_LEN) {
			TRACE(("DATA_ERROR: font names must be between 1 and %u characters long: \"%s\"\n",
			       REGIS_FONTNAME_LEN - 1U, state->temp));
			break;
		    }

		    strcpy(context->alphabets[state->load_index].fontname,
			   state->temp);
		    context->alphabets[state->load_index].use_font = 1;
		    TRACE(("using backing font: %s\n",
			   context->alphabets[state->load_index].fontname));
		}

		if (fragment_consumed(&optionarg)) {
		    break;
		} else {
		    TRACE(("DATA_ERROR: unexpected text in load fontname option: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
	    }
	    break;
#endif
#ifdef ENABLE_USER_FONT_SIZE
	case 'S':
	case 's':
	    TRACE(("found glyph size option \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    while (!fragment_consumed(&optionarg)) {
		RegisDataFragment sizearg;

		if (skip_regis_whitespace(&optionarg))
		    continue;

		if (extract_regis_extent(&optionarg, &sizearg)) {
		    int w, h;
		    unsigned size;

		    TRACE(("glyph size: %s\n", fragment_to_tempstr(&sizearg)));
		    /* FIXME: verify that relative values don't work */
		    if (!load_regis_mult_extent(fragment_to_tempstr(&sizearg),
						&w, &h)) {
			TRACE(("DATA_ERROR: unable to parse extent in glyph size option: \"%s\"\n",
			       fragment_to_tempstr(&sizearg)));
			break;
		    }
		    if (w < 1 || h < 1) {
			TRACE(("DATA_ERROR: glyph dimensions must not be negative or zero: %dx%d\n",
			       w, h));
			break;
		    }
		    size = GLYPH_WIDTH_BYTES((unsigned) w) * (unsigned) h;
		    if (size > MAX_REGIS_ALPHABET_BYTES) {
			TRACE(("DATA_ERROR: glyph is too large (%u bytes, limit is %u bytes)\n",
			       size, MAX_REGIS_ALPHABET_BYTES));
			break;
		    }

		    if (state->load_index != MAX_REGIS_ALPHABETS) {
			TRACE(("DATA_ERROR: glyph size can not be changed after any data is loaded\n"));
			break;
		    }

		    TRACE(("using glyph size: %dx%d\n", w, h));
		    state->load_w = (unsigned) w;
		    state->load_h = (unsigned) h;
		    continue;
		}

		TRACE(("DATA_ERROR: expected extent in glyph size option: \"%s\"\n",
		       fragment_to_tempstr(&sizearg)));
		break;
	    }
	    break;
#endif
	default:
	    TRACE(("DATA_ERROR: ignoring unknown ReGIS load command option '%c' arg \"%s\"\n",
		   state->option, fragment_to_tempstr(&optionarg)));
	    break;
	}
	break;
    case 'p':
	TRACE(("inspecting position option \"%c\" with value \"%s\"\n",
	       state->option, fragment_to_tempstr(&optionarg)));
	switch (state->option) {
	case 'B':
	case 'b':
	    TRACE(("found begin bounded position stack \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    skip_regis_whitespace(&optionarg);
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: ignoring unexpected arguments to position option '%c' arg \"%s\"\n",
		       state->option, fragment_to_tempstr(&optionarg)));
	    }
	    if (state->stack_next >= POSITION_STACK_SIZE) {
		/* FIXME: ignore, error, update counter? */
		TRACE(("unable to push position to full stack\n"));
		break;
	    }
	    TRACE(("pushing location: %d,%d\n",
		   context->graphics_output_cursor_x,
		   context->graphics_output_cursor_y));

	    state->stack_x[state->stack_next] =
		context->graphics_output_cursor_x;
	    state->stack_y[state->stack_next] =
		context->graphics_output_cursor_y;
	    state->stack_next++;
	    break;
	case 'E':
	case 'e':
	    TRACE(("found end position stack \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    skip_regis_whitespace(&optionarg);
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: ignoring unexpected arguments to position option '%c' arg \"%s\"\n",
		       state->option, fragment_to_tempstr(&optionarg)));
	    }
	    if (state->stack_next == 0U) {
		TRACE(("DATA_ERROR: unable to pop position from empty stack\n"));
		break;
	    }

	    state->stack_next--;
	    if (state->stack_x[state->stack_next] != DUMMY_STACK_X ||
		state->stack_y[state->stack_next] != DUMMY_STACK_Y) {
		context->graphics_output_cursor_x =
		    state->stack_x[state->stack_next];
		context->graphics_output_cursor_y =
		    state->stack_y[state->stack_next];
		TRACE(("popped location: %d,%d\n",
		       context->graphics_output_cursor_x,
		       context->graphics_output_cursor_y));
	    } else {
		TRACE(("not popping location\n"));
	    }
	    break;
	case 'P':
	case 'p':
	    TRACE(("found graphics page destination option \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment pagearg;
		int page;

		if (!extract_regis_num(&optionarg, &pagearg)) {
		    TRACE(("DATA_ERROR: expected int in page destination option: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
		TRACE(("page option arg: %s\n", fragment_to_tempstr(&pagearg)));
		if (!regis_num_to_int(&pagearg, &page)) {
		    TRACE(("DATA_ERROR: unable to parse int in page destination option: \"%s\"\n",
			   fragment_to_tempstr(&pagearg)));
		    break;
		}
		if (page < 0 || (unsigned) page >= MAX_REGIS_PAGES) {
		    TRACE(("DATA_ERROR: invalid page: \"%d\"\n", page));
		    break;
		}

		TRACE(("using destination page number: %d\n", page));
		context->destination_page = (unsigned) page;
		map_regis_graphics_pages(context->destination_graphic->xw,
					 context);
	    }
	    break;
	case 'S':
	case 's':
	    TRACE(("found begin unbounded position stack \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    skip_regis_whitespace(&optionarg);
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: ignoring unexpected arguments to end position option '%c' arg \"%s\"\n",
		       state->option, fragment_to_tempstr(&optionarg)));
	    }
	    if (state->stack_next >= POSITION_STACK_SIZE) {
		/* FIXME: ignore, error, update counter? */
		TRACE(("unable to push dummy position to full stack\n"));
		break;
	    }

	    TRACE(("pushing dummy positions instead of %d,%d\n",
		   context->graphics_output_cursor_x,
		   context->graphics_output_cursor_y));
	    state->stack_x[state->stack_next] = DUMMY_STACK_X;
	    state->stack_y[state->stack_next] = DUMMY_STACK_Y;
	    state->stack_next++;
	    break;
	case 'W':
	case 'w':
	    TRACE(("found temporary write options \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!load_regis_write_control_set(state, context,
					      context->graphics_output_cursor_x,
					      context->graphics_output_cursor_y,
					      &optionarg,
					      &context->temporary_write_controls)) {
		TRACE(("DATA_ERROR: invalid temporary write options \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
	    }
	    break;
	default:
	    TRACE(("DATA_ERROR: ignoring unknown ReGIS position command option '%c' arg \"%s\"\n",
		   state->option, fragment_to_tempstr(&optionarg)));
	    break;
	}
	break;
    case 'r':
	TRACE(("inspecting report option \"%c\" with value \"%s\"\n",
	       state->option, fragment_to_tempstr(&optionarg)));
	switch (state->option) {
	case 'E':
	case 'e':
	    TRACE(("found parse error report \"%s\" FIXME\n",
		   fragment_to_tempstr(&optionarg)));
	    skip_regis_whitespace(&optionarg);
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: unexpected arguments to ReGIS report command option '%c' arg \"%s\"\n",
		       state->option, fragment_to_tempstr(&optionarg)));
		break;
	    } {
		unsigned err_code = 0U;
		unsigned err_char = 0U;

		TRACE(("got report last error condition\n"));
		/* FIXME: implement after adding error tracking */
		unparseputc(xw, D_QUOTE);
		unparseputn(xw, err_code);
		unparseputc(xw, ',');
		unparseputn(xw, err_char);
		unparseputc(xw, D_QUOTE);
		unparseputc(xw, '\r');
		unparse_end(xw);
	    }
	    break;
	case 'I':
	case 'i':
	    TRACE(("found set input mode \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment modearg;
		int mode;

		if (!extract_regis_num(&optionarg, &modearg)) {
		    TRACE(("DATA_ERROR: expected int in report input mode option: \"%s\"\n",
			   fragment_to_tempstr(&modearg)));
		    break;
		}

		TRACE(("input mode: %s\n", fragment_to_tempstr(&modearg)));
		if (!regis_num_to_int(&modearg, &mode)) {
		    TRACE(("DATA_ERROR: unable to parse int in report input mode option: \"%s\"\n",
			   fragment_to_tempstr(&modearg)));
		    break;
		}
		if (mode != 0 && mode != 1) {
		    TRACE(("DATA_ERROR: ignoring invalid input mode: \"%d\"\n",
			   mode));
		    break;
		}

		TRACE(("using input mode: %d (%s)\n", mode,
		       (mode == 0)
		       ? "one-shot"
		       : "multiple"));
		context->multi_input_mode = mode;
		if (context->multi_input_mode) {
		    TRACE(("ERROR: multi-mode input not implemented FIXME\n"));
		    /* FIXME: enable input cursor, send location on mouse clicks or non-arrowkey keypresses */
		} else {
		    /* FIXME: if in multi-mode, disable input cursor, stop tracking mouse clicks and keypresses */
		    /* FIXME: enable input cursor and disable drawing until location report request command is received */
		    /* FIXME: upon mouse click or keypress respond with location report */
		}
		/* FIXME: implement input cursor */
		/* FIXME: implement mouse tracking */
		/* FIXME: implement arrow key movement */
		/* FIXME: implement button/key collection */

		unparseputc(xw, '\r');
		unparse_end(xw);

		skip_regis_whitespace(&optionarg);
		if (!fragment_consumed(&optionarg)) {
		    TRACE(("DATA_ERROR: unexpected arguments to ReGIS report command option '%c' arg \"%s\"\n",
			   state->option, fragment_to_tempstr(&optionarg)));
		}
		/* FIXME: buffer commands until report request received */
	    }
	    break;
	case 'L':
	case 'l':
	    TRACE(("found character set load report \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: unexpected arguments to ReGIS report command option '%c' arg \"%s\"\n",
		       state->option, fragment_to_tempstr(&optionarg)));
	    } else if (state->load_index == MAX_REGIS_ALPHABETS) {
		/* If this happens something went wrong elsewhere. */
		TRACE(("DATA_ERROR: unable to report current load alphabet\n"));
		unparseputs(xw, "A0\"\"\r");
		unparse_end(xw);
	    } else {
		int delim = pick_quote(state->load_name);
		if (delim != '\0') {
		    unparseputs(xw, "A");
		    unparseputn(xw, state->load_alphabet);
		    unparseputc(xw, delim);
		    unparseputs(xw, state->load_name);
		    unparseputc(xw, delim);
		}
		unparseputc(xw, '\r');
		unparse_end(xw);
	    }
	    break;
	case 'M':
	case 'm':
	    TRACE(("found macrograph report \"%s\" request\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment suboptionarg;
		char name = '\0';

		if (extract_regis_parenthesized_data(&optionarg,
						     &suboptionarg)) {
		    skip_regis_whitespace(&suboptionarg);
		    TRACE(("got macrograph report character request: \"%s\"\n",
			   fragment_to_tempstr(&suboptionarg)));
		    if (!fragment_consumed(&suboptionarg)) {
			name = pop_fragment(&suboptionarg);
			if (islower(CharOf(name)))
			    name = (char) toupper(CharOf(name));

			skip_regis_whitespace(&suboptionarg);
			if (!fragment_consumed(&optionarg)) {
			    TRACE(("DATA_ERROR: unexpected content in ReGIS macrograph report suboptions: \"%s\"\n",
				   fragment_to_tempstr(&suboptionarg)));
			    break;
			}
		    }
		}
		skip_regis_whitespace(&optionarg);
		if (!fragment_consumed(&optionarg)) {
		    TRACE(("DATA_ERROR: unexpected arguments to ReGIS report command option '%c' arg \"%s\"\n",
			   state->option, fragment_to_tempstr(&optionarg)));
		    break;
		}

		if (name == '\0') {
		    TRACE(("DATA_ERROR: no macro name given to ReGIS macrograph report command\n"));
		    break;
		}

		if (name == '=') {
		    unsigned max_available = 1000U;
		    unsigned cur_available = max_available;

		    TRACE(("got report macrograph storage request\n"));
		    /* FIXME: Implement when macrographs are supported. */
		    unparseputc(xw, D_QUOTE);
		    unparseputn(xw, cur_available);
		    unparseputc(xw, ',');
		    unparseputn(xw, max_available);
		    unparseputc(xw, D_QUOTE);
		    unparseputc(xw, '\r');
		    unparse_end(xw);
		} else if (name < 'A' || name > 'Z') {
		    TRACE(("DATA_ERROR: invalid macrograph name: \"%c\"\n", name));
		    /* FIXME: what should happen? */
		    break;
		} else {
		    TRACE(("got report macrograph request for name '%c'\n", name));
		    unparseputs(xw, "@=");
		    unparseputc(xw, name);
		    /* FIXME: Allow this to be disabled for security reasons. */
		    /* FIXME: implement when macrographs are supported. */
		    unparseputs(xw, "@;");
		    unparseputc(xw, '\r');
		    unparse_end(xw);
		}
	    }
	    break;
	case 'P':
	case 'p':
	    TRACE(("found cursor position report \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment suboptionarg;
		int output = 1;

		if (extract_regis_parenthesized_data(&optionarg,
						     &suboptionarg)) {
		    skip_regis_whitespace(&suboptionarg);
		    TRACE(("got cursor position report suboption: \"%s\"\n",
			   fragment_to_tempstr(&suboptionarg)));
		    if (!fragment_consumed(&suboptionarg)) {
			char suboption;

			/* FIXME: handle cursor movement multipliers */
			suboption = pop_fragment(&suboptionarg);
			if (suboption == 'i' || suboption == 'I') {
			    output = 0;		/* input location report */
			} else {
			    TRACE(("DATA_ERROR: unknown ReGIS position report suboption '%c'\n",
				   suboption));
			    break;
			}

			skip_regis_whitespace(&suboptionarg);
			if (!fragment_consumed(&optionarg)) {
			    TRACE(("DATA_ERROR: unexpected content in ReGIS position report suboptions: \"%s\"\n",
				   fragment_to_tempstr(&suboptionarg)));
			    break;
			}
		    }
		}
		skip_regis_whitespace(&optionarg);
		if (!fragment_consumed(&optionarg)) {
		    TRACE(("DATA_ERROR: unexpected arguments to ReGIS report command option '%c' arg \"%s\"\n",
			   state->option, fragment_to_tempstr(&optionarg)));
		    break;
		}

		TRACE(("got report cursor position (output=%d)\n", output));

		/* FIXME: look into supporting ANSI locator reports (DECLRP) */
		unparseputc(xw, L_BLOK);
		if (output == 1) {
		    /* FIXME: verify in absolute, not user, coordinates */
		    unparseputn(xw, (unsigned) context->graphics_output_cursor_x);
		    unparseputc(xw, ',');
		    unparseputn(xw, (unsigned) context->graphics_output_cursor_y);
		} else if (context->multi_input_mode) {
		    /* FIXME: track input coordinates */
		    unsigned x = 0, y = 0;	/* placeholders */

		    /* send CSI240~[x,y]\r with current input cursor location */

		    /* FIXME: verify no leading char or button sequence */
		    /* FIXME: should we ever send an eight-bit CSI? */
		    /* FIXME: verify in absolute, not user, coordinates */
		    TRACE(("sending multi-mode input report at %u,%u\n", x, y));
		    unparseputn(xw, x);
		    unparseputc(xw, ',');
		    unparseputn(xw, y);
		} else {
		    char ch = ' ';	/* placeholder */
		    unsigned x = 0, y = 0;	/* placeholders */

		    /* FIXME: wait for first non-arrow keypress or mouse click, and don't update graphics while waiting */
		    /* send <key or button>[x,y]\r to report input cursor location */

		    /* null button: CSI240~ */
		    /* left button: CSI241~ */
		    /* middle button: CSI243~ */
		    /* right button: CSI245~ */
		    /* extra button: CSI247~ */
		    /* FIXME: support DECLBD to change button assignments */
		    /* FIXME: verify no leading char or button sequence */
		    TRACE(("sending one-shot input report with %c at %u,%u\n",
			   ch, x, y));
		    if (ch != '\177') {
			unparseputn(xw, x);
			unparseputc(xw, ',');
			unparseputn(xw, y);
		    }
		    /* FIXME: exit one-shot mode and disable input cursor */
		}
		unparseputc(xw, R_BLOK);
		unparseputc(xw, '\r');
		unparse_end(xw);
	    }
	    break;
	default:
	    TRACE(("DATA_ERROR: sending empty report for unknown ReGIS report command option '%c' arg \"%s\"\n",
		   state->option, fragment_to_tempstr(&optionarg)));
	    /* Unknown report request types must receive empty reports. */
	    unparseputs(xw, "\r");
	    unparse_end(xw);
	    break;
	}
	break;
    case 's':
	TRACE(("inspecting screen option \"%c\" with value \"%s\"\n",
	       state->option, fragment_to_tempstr(&optionarg)));
	switch (state->option) {
	case 'A':
	case 'a':
	    TRACE(("found address definition \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment address_extent;
		int got_ul = 0;
		int got_lr = 0;
		int ulx = 0, uly = 0, lrx = 0, lry = 0;

		while (!fragment_consumed(&optionarg)) {
		    if (skip_regis_whitespace(&optionarg))
			continue;

		    if (extract_regis_extent(&optionarg, &address_extent)) {
			int x, y;

			/* FIXME: are relative values supposed to be handled? */
			if (!load_regis_pixel_extent(fragment_to_tempstr(&address_extent),
						     0, 0, &x, &y)) {
			    TRACE(("DATA_ERROR: unable to parse extent in address definition: \"%s\"\n",
				   fragment_to_tempstr(&address_extent)));
			    break;
			}

			if (!got_ul) {
			    ulx = x;
			    uly = y;
			    got_ul = 1;
			} else if (!got_lr) {
			    lrx = x;
			    lry = y;
			    got_lr = 1;
			} else {
			    TRACE(("DATA_ERROR: ignoring extra extent argument in address definition: \"%s\"\n",
				   fragment_to_tempstr(&address_extent)));
			}
			continue;
		    }

		    TRACE(("DATA_ERROR: ignoring malformed ReGIS screen address definition: expected extent argument but found: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    return 1;
		}

		if (!got_ul || !got_lr) {
		    TRACE(("DATA_ERROR: ignoring malformed ReGIS screen address definition: one or both locations missing in definition\n"));
		    return 1;
		}
		if (ulx == lrx || uly == lry) {
		    TRACE(("DATA_ERROR: ignoring malformed ReGIS screen address definition: one or both dimensions are zero: ul=%d,%d lr=%d,%d\n",
			   ulx, uly, lrx, lry));
		    return 1;
		} {
		    const int cw = abs(ulx - lrx) + 1;
		    const int ch = abs(uly - lry) + 1;
		    int width, height;

		    /*
		     * FIXME: Should we attempt to resize existing contents?
		     * We are actually changing the output size, but terminals
		     * just changed coordinates.
		     */
#if 1
		    int scale;
		    const int mw = context->destination_graphic->max_width;
		    const int mh = context->destination_graphic->max_height;

		    TRACE(("custom screen size pre scaling: %dx%d\n", cw, ch));

		    width = cw;
		    height = ch;

		    scale = 1;
		    while (width * scale < 200 || height * scale < 200) {
			scale++;
		    }
		    width *= scale;
		    height *= scale;

		    scale = 1;
		    while (width / scale > mw || height / scale > mh) {
			scale++;
		    }
		    width /= scale;
		    height /= scale;
#else
		    width = context->width;
		    height = context->height;
#endif

		    TRACE(("custom screen address: ul=%d,%d lr=%d,%d\n",
			   ulx, uly, lrx, lry));

		    context->x_off = ulx;
		    context->y_off = uly;
		    context->x_div = lrx - ulx;
		    context->y_div = lry - uly;
		    context->width = width;
		    context->height = height;
		    context->destination_graphic->actual_width = width;
		    context->destination_graphic->actual_height = height;
		    context->destination_graphic->dirty = True;

		    TRACE(("conversion factors: off=%+d,%+d div=%+d,%+d width=%d, height=%d\n",
			   context->x_off, context->y_off,
			   context->x_div, context->y_div,
			   context->width, context->height));
		}
	    }
	    break;
	case 'C':
	case 'c':
	    TRACE(("found cursor control \"%s\" FIXME\n",
		   fragment_to_tempstr(&optionarg)));
	    /* FIXME: handle */
	    /* C0 == output cursor off, C1 == output cursor on */
	    /* C(H0) == output cursor diamond (default), C(H1) == output cursor diamond, C(H2) == output cursor crosshair */
	    /* C(I) == input cursor crosshair (default), C(I0) == input cursor crosshair, C(I1) == input cursor diamond, C(I2) == input cursor crosshair, C(I3) == input cursor rubber band line, C(I4) == input cursor rubber band rectangle */
	    /* C(I[X,Y]"FB")) == set input cursor to F in foreground B in background with hotspot at X,Y (using current text settings, trimmed to 16x24 max) */
	    if (fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: ignoring malformed ReGIS screen cursor control option value \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		return 1;
	    }
	    break;
	case 'E':
	case 'e':
	    TRACE(("found erase request \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: ignoring unexpected argument to ReGIS erase request \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		return 1;
	    }
	    DRAW_ALL(context, context->background);
	    /* FIXME: also set origin to 0,0 (presumably upper-left address, or maybe addressing is reset) */
	    context->fill_point_count = 0U;
	    context->fill_mode = 0;
	    state->num_points = 0U;
	    state->stack_next = 0U;
	    context->destination_graphic->dirty = True;
	    context->force_refresh = True;
	    break;
	case 'F':
	case 'f':
	    TRACE(("found page eject request \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: ignoring unexpected argument to ReGIS page eject request \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		return 1;
	    }
	    /* We aren't going to print anything so no need to deduplicate. */
	    DRAW_ALL(context, context->background);
	    context->destination_graphic->dirty = True;
	    context->force_refresh = True;
	    break;
	case 'H':
	case 'h':
	    TRACE(("found hardcopy control \"%s\" FIXME\n",
		   fragment_to_tempstr(&optionarg)));
	    /* FIXME: handle */
	    /* screen S(H), area to (input?/output?) cursor S(H[X,Y]), or area S(H[X,Y][X,Y]) */
	    if (fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: ignoring malformed ReGIS screen hardcopy control option value \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		return 1;
	    }
	    break;
	case 'I':
	case 'i':
	    TRACE(("found screen background color index \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!load_regis_regnum_or_colorspec(context, &optionarg,
						&context->background)) {
		TRACE(("DATA_ERROR: screen background color specifier not recognized: \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		return 1;
	    }
	    break;
	case 'M':
	case 'm':
	    TRACE(("found screen color register mapping \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment regnum;
		RegisDataFragment colorspec;

		while (!fragment_consumed(&optionarg)) {
		    if (skip_regis_whitespace(&optionarg))
			continue;

		    if (extract_regis_num(&optionarg, &regnum)) {
			int register_num;
			int color_only;
			ColorRegister my_reg;

			if (!regis_num_to_int(&regnum, &register_num)) {
			    TRACE(("DATA_ERROR: unable to parse int in screen color register mapping option: \"%s\"\n",
				   fragment_to_tempstr(&regnum)));
			    return 1;
			}
			if (register_num < 0 ||
			    register_num > (int) context->destination_graphic->valid_registers) {
			    TRACE(("interpreting out of range register number %d as 0 FIXME\n",
				   register_num));
			    register_num = 0;
			}
			skip_regis_whitespace(&optionarg);
			if (!extract_regis_parenthesized_data(&optionarg,
							      &colorspec)) {
			    TRACE(("DATA_ERROR: expected to find parentheses after register number: \"%s\"\n",
				   fragment_to_tempstr(&optionarg)));
			    return 1;
			}

			skip_regis_whitespace(&colorspec);
			switch (peek_fragment(&colorspec)) {
			case 'A':
			case 'a':
			    pop_fragment(&colorspec);
			    color_only = 1;
			    break;
			default:
			    color_only = 0;
			    break;
			}

			fetch_color_register(context->destination_graphic,
					     (RegisterNum) register_num,
					     &my_reg);

			TRACE(("mapping register %d %d,%d,%d to color spec: \"%s\"\n",
			       register_num,
			       my_reg.r,
			       my_reg.g,
			       my_reg.b,
			       fragment_to_tempstr(&colorspec)));
			if (!load_regis_colorspec(context, &colorspec, &my_reg)) {
			    TRACE(("DATA_ERROR: unable to use colorspec for mapping of register %d\n",
				   register_num));
			    return 1;
			}

			if (color_only &&
			    (context->graphics_termid == 240 ||
			     context->graphics_termid == 330)) {
			    TRACE(("NOT setting color register %d to %hd,%hd,%hd\n",
				   register_num, my_reg.r, my_reg.g, my_reg.b));
			} else {
			    TRACE(("setting color register %d to %hd,%hd,%hd\n",
				   register_num, my_reg.r, my_reg.g, my_reg.b));
			    update_color_register(context->destination_graphic,
						  (RegisterNum) register_num,
						  my_reg.r, my_reg.g, my_reg.b);
			}
			continue;
		    } {
			char skip;

			skip_regis_whitespace(&optionarg);
			skip = pop_fragment(&optionarg);
			(void) skip;	/* variable needed only if tracing */
			TRACE(("DATA_ERROR: ignoring mapping request with unexpected character \"%c\"\n",
			       skip));
			return 1;
		    }
		}
	    }
	    break;
	case 'P':
	case 'p':
	    TRACE(("found graphics page display option \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment pagearg;
		int page;

		if (!extract_regis_num(&optionarg, &pagearg)) {
		    TRACE(("DATA_ERROR: expected int in page display option: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
		TRACE(("page option arg: %s\n", fragment_to_tempstr(&pagearg)));
		if (!regis_num_to_int(&pagearg, &page)) {
		    TRACE(("DATA_ERROR: unable to parse int in page display option: \"%s\"\n",
			   fragment_to_tempstr(&pagearg)));
		    break;
		}
		if (page < 0 || (unsigned) page >= MAX_REGIS_PAGES) {
		    TRACE(("DATA_ERROR: invalid page: \"%d\"\n", page));
		    break;
		}

		TRACE(("using display page number: %d\n", page));
		context->display_page = (unsigned) page;
		map_regis_graphics_pages(xw, context);
	    }
	    break;
	case 'T':
	case 't':
	    TRACE(("found time delay \"%s\" FIXME\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment delayarg;
		int delay;

		if (!extract_regis_num(&optionarg, &delayarg)) {
		    TRACE(("DATA_ERROR: expected int in delay display option: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
		TRACE(("delay option arg: %s\n",
		       fragment_to_tempstr(&delayarg)));
		if (!regis_num_to_int(&delayarg, &delay)) {
		    TRACE(("DATA_ERROR: unable to parse int in delay display option: \"%s\"\n",
			   fragment_to_tempstr(&delayarg)));
		    break;
		}
		if (delay < 0 || delay > MAX_I_DELAY) {
		    TRACE(("DATA_ERROR: delay out of range: \"%d\"\n", delay));
		    break;
		}
		/* FIXME: terminals allow much larger values, but this is an easy DoS vector */
		if (delay > 60)
		    delay = 60;
		TRACE(("using delay for %d ticks\n", delay));
		refresh_modified_displayed_graphics(context->current_widget);
		usleep((useconds_t) delay * 10000U);
	    }
	    break;
	case 'W':
	case 'w':
	    /* Only M (pixel vector multiplier) is useful -- for the scrolling multiplier. */
	    TRACE(("found temporary write options \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!load_regis_write_control_set(state, context,
					      context->graphics_output_cursor_x,
					      context->graphics_output_cursor_y,
					      &optionarg,
					      &context->temporary_write_controls)) {
		TRACE(("DATA_ERROR: invalid temporary write options \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		break;
	    }
	    break;
	default:
	    TRACE(("DATA_ERROR: ignoring unknown ReGIS screen command option '%c' arg \"%s\"\n",
		   state->option, fragment_to_tempstr(&optionarg)));
	    break;
	}
	break;
    case 't':
	TRACE(("inspecting text option \"%c\" with value \"%s\"\n",
	       state->option, fragment_to_tempstr(&optionarg)));
	switch (state->option) {
	case 'A':
	case 'a':
	    TRACE(("found alphabet specifier option \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment alphabetarg;
		int alphabet;

		if (!extract_regis_num(&optionarg, &alphabetarg)) {
		    TRACE(("DATA_ERROR: expected int in text alphabet option: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
		TRACE(("alphabet: %s\n", fragment_to_tempstr(&alphabetarg)));
		if (!regis_num_to_int(&alphabetarg, &alphabet)) {
		    TRACE(("DATA_ERROR: unable to parse int in text alphabet option: \"%s\"\n",
			   fragment_to_tempstr(&alphabetarg)));
		    break;
		}
		if (alphabet < 0 ||
		    (unsigned) alphabet >= MAX_REGIS_ALPHABETS) {
		    TRACE(("DATA_ERROR: invalid alphabet: \"%d\"\n", alphabet));
		    break;
		}

		TRACE(("using alphabet number: %d\n", alphabet));
		context->current_text_controls->alphabet_num =
		    (unsigned) alphabet;

		skip_regis_whitespace(&optionarg);
		if (!fragment_consumed(&optionarg)) {
		    TRACE(("DATA_ERROR: ignoring trailing junk in text alphabet option \"%s\"\n",
			   fragment_to_tempstr(&alphabetarg)));
		    break;
		}
	    }
	    break;
	case 'B':
	case 'b':
	    TRACE(("found beginning of temporary text control \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    copy_regis_text_controls(&context->persistent_text_controls,
				     &context->temporary_text_controls);
	    context->current_text_controls = &context->temporary_text_controls;
	    break;
	case 'D':
	case 'd':
	    TRACE(("found text tilt control \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment rotationarg;
		int rotation;

		if (!extract_regis_num(&optionarg, &rotationarg)) {
		    TRACE(("DATA_ERROR: expected int in text tilt option: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
		TRACE(("tilt: %s\n", fragment_to_tempstr(&rotationarg)));
		if (!regis_num_to_int(&rotationarg, &rotation)) {
		    TRACE(("DATA_ERROR: unable to parse int in text tilt option: \"%s\"\n",
			   fragment_to_tempstr(&rotationarg)));
		    break;
		}
		while (rotation < 0) {
		    rotation += 360;
		}
		while (rotation >= 360) {
		    rotation -= 360;
		}
		/* FIXME: we don't have to be this restrictive, though the
		 * VT3x0 apparently was. What might depend on this?
		 */
#ifndef ENABLE_FREE_ROTATION
		/* Use closest value which is a multiple of 45 degrees. */
		rotation = 45 * ((rotation + 22) / 45);
#endif

		/* For some reason ReGIS reused the "D" option for the text
		 * command to represent two different attributes.  String tilt
		 * can only be modified if an "S" option is given after the
		 * "D" option.  In that case a second "D" option changes the
		 * character tilt.  But complicating things further, if no "S"
		 * or second "D" option is given, the "D" option refers to the
		 * character tilt.
		 */
		switch (state->text_tilt_state) {
		case TEXT_TILT_STATE_READY:
		    /* Setting a tilt after a cell size only affects the
		     * character tilt and not the string tilt.
		     */
		    TRACE(("character rotation (direction): %d\n", rotation));
		    context->current_text_controls->character_rotation
			= rotation;
		    state->text_tilt_state = TEXT_TILT_STATE_GOT_D;
		    break;
		case TEXT_TILT_STATE_GOT_D:
		    /* If there are multiple angles with no size only the last
		     * value is used.
		     */
		    TRACE(("character rotation (direction): %d\n", rotation));
		    context->current_text_controls->character_rotation
			= rotation;
		    break;
		case TEXT_TILT_STATE_GOT_DS:
		    TRACE(("changing character rotation (direction): %d\n",
			   rotation));
		    context->current_text_controls->character_rotation
			= rotation;
		    state->text_tilt_state = TEXT_TILT_STATE_GOT_DSD;
		    break;
		case TEXT_TILT_STATE_GOT_DSD:
		default:
		    /* If there are multiple angles with no size only the last
		     * value is used.
		     */
		    TRACE(("changing character rotation (direction): %d\n",
			   rotation));
		    context->current_text_controls->character_rotation
			= rotation;
		    break;
		}

		skip_regis_whitespace(&optionarg);
		if (!fragment_consumed(&optionarg)) {
		    TRACE(("DATA_ERROR: ignoring trailing junk in text tilt option \"%s\"\n",
			   fragment_to_tempstr(&rotationarg)));
		    break;
		}
	    }
	    break;
	case 'E':
	case 'e':
	    TRACE(("found end of temporary text control \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    context->current_text_controls = &context->persistent_text_controls;
	    break;
	case 'H':
	case 'h':
	    TRACE(("found height multiplier \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment multiarg;
		int multiplier;
		unsigned height;

		if (!extract_regis_num(&optionarg, &multiarg)) {
		    TRACE(("DATA_ERROR: expected int in text height multiplier option: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
		TRACE(("multiplier: %s\n", fragment_to_tempstr(&multiarg)));
		if (!regis_num_to_int(&multiarg, &multiplier)) {
		    TRACE(("DATA_ERROR: unable to parse int in text height multiplier option: \"%s\"\n",
			   fragment_to_tempstr(&multiarg)));
		    break;
		}
		if (multiplier < 0) {
		    TRACE(("DATA_ERROR: out of range height multiplier: \"%d\", using 0 FIXME\n",
			   multiplier));
		    multiplier = 0;	/* FIXME: verify zero is accepted */
		}
		if (multiplier > 256) {
		    TRACE(("DATA_ERROR: out of range height multiplier: \"%d\", using 256 FIXME\n",
			   multiplier));
		    multiplier = 256;
		}
		TRACE(("using height multiplier: %d\n", multiplier));
		height = (unsigned) multiplier *10U;	/* base character height */
		context->current_text_controls->character_display_h
		    = height;
		context->current_text_controls->character_unit_cell_h
		    = height;

		skip_regis_whitespace(&optionarg);
		if (!fragment_consumed(&optionarg)) {
		    TRACE(("DATA_ERROR: ignoring trailing junk in text multiplier option \"%s\"\n",
			   fragment_to_tempstr(&multiarg)));
		    break;
		}
	    }
	    break;
	case 'I':
	case 'i':
	    TRACE(("found italic control \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment italicarg;
		int italic;

		if (!extract_regis_num(&optionarg, &italicarg)) {
		    TRACE(("DATA_ERROR: expected int in text italic option: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
		TRACE(("italic angle: %s\n", fragment_to_tempstr(&italicarg)));
		if (!regis_num_to_int(&italicarg, &italic)) {
		    TRACE(("DATA_ERROR: unable to parse int in text italic option: \"%s\"\n",
			   fragment_to_tempstr(&italicarg)));
		    break;
		}

		/*
		 * This is overly-restrictive but matches what the docs say
		 * should happen.  Add an option to allow exact angles?
		 */
#ifndef ENABLE_VARIABLE_ITALICS
		if (italic <= -31) {
		    italic = -45;
		} else if (italic < 0) {
		    italic = -27;	/* docs say 22, but that gives .404 x:y ratio */
		} else if (italic >= 31) {
		    italic = 45;
		} else if (italic > 0) {
		    italic = 27;	/* docs say 22, but that gives .404 x:y ratio */
		}
#else
		if (italic <= -72) {
		    italic = -72;
		} else if (italic >= 72) {
		    italic = 72;
		}
#endif

		TRACE(("using italic angle: %d\n", italic));
		context->current_text_controls->slant = italic;

		skip_regis_whitespace(&optionarg);
		if (!fragment_consumed(&optionarg)) {
		    TRACE(("DATA_ERROR: ignoring trailing junk in text italic option \"%s\"\n",
			   fragment_to_tempstr(&italicarg)));
		    break;
		}
	    }
	    break;
	case 'M':
	case 'm':
	    TRACE(("found text command unit size multiplier \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment sizemultiplierarg;
		int sizemultiplier;
		int ww, hh;

		if (!extract_regis_extent(&optionarg, &sizemultiplierarg)) {
		    TRACE(("DATA_ERROR: expected extent in unit size multiplier option: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
		TRACE(("size multiplier: %s\n",
		       fragment_to_tempstr(&sizemultiplierarg)));
		/* FIXME: verify that relative values don't work */
		if (!load_regis_mult_extent(fragment_to_tempstr(&sizemultiplierarg),
					    &ww, &hh)) {
		    TRACE(("DATA_ERROR: unable to parse extent in '%c' command: \"%s\"\n",
			   state->option, fragment_to_tempstr(&sizemultiplierarg)));
		    break;
		}
		/* FIXME: support fractional values */
		if (!regis_num_to_int(&sizemultiplierarg, &sizemultiplier)) {
		    TRACE(("DATA_ERROR: unable to parse extent in size multiplier option: \"%s\"\n",
			   fragment_to_tempstr(&sizemultiplierarg)));
		    break;
		}
		if (ww < 1 || hh < 1) {
		    TRACE(("DATA_ERROR: invalid size multiplier: %d,%d FIXME\n",
			   ww, hh));
		    break;
		}
		if (ww > 16) {
		    ww = 16;
		}
		if (hh > 16) {
		    hh = 16;
		}

		TRACE(("using unit size multiplier: %d,%d\n", ww, hh));

		/* Times the base character unit cell dimensions (the VT3x0
		 * manual says this is with the height multiplier, but that
		 * seems to be incorrect).
		 */
		context->current_text_controls->character_unit_cell_w =
		    (unsigned) ww *8U;
		context->current_text_controls->character_unit_cell_h =
		    (unsigned) hh *10U;

		skip_regis_whitespace(&optionarg);
		if (!fragment_consumed(&optionarg)) {
		    TRACE(("DATA_ERROR: ignoring trailing junk in text unit cell size option \"%s\"\n",
			   fragment_to_tempstr(&sizemultiplierarg)));
		    break;
		}
	    }
	    break;
	case 'S':
	case 's':
	    TRACE(("found display size or standard character cell size \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    for (;;) {
		RegisDataFragment displaysizearg;

		skip_regis_whitespace(&optionarg);
		if (extract_regis_extent(&optionarg, &displaysizearg)) {
		    int disp_w, disp_h;

		    TRACE(("custom display size: %s\n",
			   fragment_to_tempstr(&displaysizearg)));
		    /* FIXME: verify that relative values don't work */
		    if (!load_regis_mult_extent(fragment_to_tempstr(&displaysizearg),
						&disp_w, &disp_h)) {
			TRACE(("DATA_ERROR: unable to parse extent in text display size option: \"%s\"\n",
			       fragment_to_tempstr(&displaysizearg)));
			break;
		    }
		    if (disp_w < 1 || disp_h < 1) {
			TRACE(("DATA_ERROR: invalid text display size: %dx%d FIXME\n",
			       disp_w, disp_h));
			break;
		    }

		    TRACE(("using display cell size: %d,%d\n", disp_w, disp_h));
		    context->current_text_controls->character_display_w =
			(unsigned) disp_w;
		    context->current_text_controls->character_display_h =
			(unsigned) disp_h;
		    TRACE(("using offset: %d,%d\n", disp_w, 0));
		    context->current_text_controls->character_inc_x = disp_w;
		    context->current_text_controls->character_inc_y = 0;

		    continue;
		}

		if (extract_regis_num(&optionarg, &displaysizearg)) {
		    int standard;
		    unsigned disp_w, disp_h, unit_w, unit_h;
		    int off_x, off_y;

		    TRACE(("standard display cell size: %s\n",
			   fragment_to_tempstr(&displaysizearg)));
		    if (!regis_num_to_int(&displaysizearg, &standard)) {
			TRACE(("DATA_ERROR: unable to parse int in text standard cell size option: \"%s\"\n",
			       fragment_to_tempstr(&displaysizearg)));
			break;
		    }
		    if (get_standard_character_size(standard,
						    &disp_w, &disp_h,
						    &unit_w, &unit_h,
						    &off_x, &off_y)) {
			TRACE(("DATA_ERROR: unrecognized standard cell size: \"%d\"\n",
			       standard));
			break;
		    }

		    TRACE(("using display cell size: %u,%u\n", disp_w, disp_h));
		    context->current_text_controls->character_display_w
			= disp_w;
		    context->current_text_controls->character_display_h
			= disp_h;
		    TRACE(("using offset: %d,%d\n", off_x, off_y));
		    context->current_text_controls->character_inc_x = off_x;
		    context->current_text_controls->character_inc_y = off_y;

		    /*
		     * Some ReGIS documentation implies that the "S" option only
		     * affects character spacing after a rotation option ("ReGIS
		     * uses the spacing value associated with the cell size to
		     * space the characters in the tilted string").  The 7-13
		     * example in the VT330/VT340 Programmer Reference Manual
		     * vol 2 appears to say otherwise.  FIXME: verify
		     */
		    if (1) {	/* forced for now */
			TRACE(("using unit cell size: %u,%u\n", unit_w, unit_h));
			context->current_text_controls->character_unit_cell_w =
			    unit_w;
			context->current_text_controls->character_unit_cell_h =
			    unit_h;
		    }

		    switch (state->text_tilt_state) {
		    case TEXT_TILT_STATE_READY:
			/* Nothing to do. */
			break;
		    case TEXT_TILT_STATE_GOT_D:
			TRACE(("upgrading character rotation to string and character rotation: %d\n", context->current_text_controls->character_rotation));
			context->current_text_controls->string_rotation
			    = context->current_text_controls->character_rotation;
			state->text_tilt_state = TEXT_TILT_STATE_GOT_DS;
			break;
		    case TEXT_TILT_STATE_GOT_DS:
			/* FIXME: It isn't clear what to do if there are two
			 * size options in a row after a tilt option.
			 */
			TRACE(("DATA_ERROR: unexpected duplicate size option: \"%s\" (state=%d)\n",
			       fragment_to_tempstr(&displaysizearg),
			       state->text_tilt_state));
			break;
		    case TEXT_TILT_STATE_GOT_DSD:
		    default:
			/* FIXME: It isn't clear what to do if there is a size
			 * option after both types of tilt angle have been set.
			 */
			TRACE(("DATA_ERROR: unexpected duplicate size option: \"%s\" (state=%d)\n",
			       fragment_to_tempstr(&displaysizearg),
			       state->text_tilt_state));
			break;
		    }
		    continue;
		}

		if (skip_regis_whitespace(&optionarg)) {
		    continue;
		}

		if (fragment_consumed(&optionarg)) {
		    break;
		}

		TRACE(("DATA_ERROR: expected int or extent in text display size option: \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		break;
	    }
	    break;
	case 'U':
	case 'u':
	    TRACE(("found text command custom unit cell size \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    {
		RegisDataFragment unitsizearg;
		int unitsize;
		int unit_w, unit_h;

		if (!extract_regis_extent(&optionarg, &unitsizearg)) {
		    TRACE(("DATA_ERROR: expected extent in text unit cell size option: \"%s\"\n",
			   fragment_to_tempstr(&optionarg)));
		    break;
		}
		TRACE(("unitsize cell size: %s\n",
		       fragment_to_tempstr(&unitsizearg)));
		/* FIXME: verify that relative values don't work */
		if (!load_regis_mult_extent(fragment_to_tempstr(&unitsizearg),
					    &unit_w, &unit_h)) {
		    TRACE(("DATA_ERROR: unable to parse extent in '%c' command: \"%s\"\n",
			   state->option, fragment_to_tempstr(&unitsizearg)));
		    break;
		}
		if (!regis_num_to_int(&unitsizearg, &unitsize)) {
		    TRACE(("DATA_ERROR: unable to parse extent in text unit cell size option: \"%s\"\n",
			   fragment_to_tempstr(&unitsizearg)));
		    break;
		}
		if (unit_w < 1 || unit_h < 1) {
		    TRACE(("DATA_ERROR: invalid text unit cell size: %dx%d FIXME\n",
			   unit_w, unit_h));
		    break;
		}

		TRACE(("using unit cell size: %d,%d\n", unit_w, unit_h));

		context->current_text_controls->character_unit_cell_w =
		    (unsigned) unit_w;
		context->current_text_controls->character_unit_cell_h =
		    (unsigned) unit_h;

		skip_regis_whitespace(&optionarg);
		if (!fragment_consumed(&optionarg)) {
		    TRACE(("DATA_ERROR: ignoring trailing junk in text unit cell size option \"%s\"\n",
			   fragment_to_tempstr(&unitsizearg)));
		    break;
		}
	    }
	    break;
	case 'W':
	case 'w':
	    TRACE(("found temporary write options \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!load_regis_write_control_set(state, context,
					      context->graphics_output_cursor_x,
					      context->graphics_output_cursor_y,
					      &optionarg,
					      &context->temporary_write_controls)) {
		TRACE(("DATA_ERROR: invalid temporary write options \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
		break;
	    }
	    break;
	default:
	    TRACE(("DATA_ERROR: ignoring unknown ReGIS text command option '%c' arg \"%s\"\n",
		   state->option, fragment_to_tempstr(&optionarg)));
	    break;
	}
	break;
    case 'v':
	TRACE(("inspecting vector option \"%c\" with value \"%s\"\n",
	       state->option, fragment_to_tempstr(&optionarg)));
	switch (state->option) {
	case 'B':
	case 'b':
	    TRACE(("found begin bounded position stack \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    skip_regis_whitespace(&optionarg);
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: ignoring unexpected arguments to vector option '%c' arg \"%s\"\n",
		       state->option, fragment_to_tempstr(&optionarg)));
	    }
	    if (state->stack_next >= POSITION_STACK_SIZE) {
		/* FIXME: ignore, error, update counter? */
		TRACE(("unable to push position to full stack\n"));
		break;
	    }
	    TRACE(("pushing location: %d,%d\n",
		   context->graphics_output_cursor_x,
		   context->graphics_output_cursor_y));

	    state->stack_x[state->stack_next] =
		context->graphics_output_cursor_x;
	    state->stack_y[state->stack_next] =
		context->graphics_output_cursor_y;
	    state->stack_next++;
	    break;
	case 'E':
	case 'e':
	    TRACE(("found end vector position stack \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    skip_regis_whitespace(&optionarg);
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: ignoring unexpected arguments to vector option '%c' arg \"%s\"\n",
		       state->option, fragment_to_tempstr(&optionarg)));
	    }
	    if (state->stack_next == 0U) {
		TRACE(("DATA_ERROR: unable to pop position from empty stack\n"));
		break;
	    }

	    state->stack_next--;
	    if (state->stack_x[state->stack_next] != DUMMY_STACK_X ||
		state->stack_y[state->stack_next] != DUMMY_STACK_Y) {
		int orig_x, orig_y;

		orig_x = context->graphics_output_cursor_x;
		orig_y = context->graphics_output_cursor_y;
		context->graphics_output_cursor_x =
		    state->stack_x[state->stack_next];
		context->graphics_output_cursor_y =
		    state->stack_y[state->stack_next];
		TRACE(("popped location: %d,%d\n",
		       context->graphics_output_cursor_x,
		       context->graphics_output_cursor_y));

		TRACE(("drawing line to popped location\n"));
		draw_patterned_line(context,
				    orig_x, orig_y,
				    context->graphics_output_cursor_x,
				    context->graphics_output_cursor_y);
	    } else {
		TRACE(("not popping location\n"));
	    }
	    break;
	case 'S':
	case 's':
	    TRACE(("found begin unbounded position stack \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    skip_regis_whitespace(&optionarg);
	    if (!fragment_consumed(&optionarg)) {
		TRACE(("DATA_ERROR: ignoring unexpected arguments to vector option '%c' arg \"%s\"\n",
		       state->option, fragment_to_tempstr(&optionarg)));
	    }
	    if (state->stack_next >= POSITION_STACK_SIZE) {
		/* FIXME: ignore, error, update counter? */
		TRACE(("unable to push dummy position to full stack\n"));
		break;
	    }

	    TRACE(("pushing dummy vector positions instead of %d,%d\n",
		   context->graphics_output_cursor_x,
		   context->graphics_output_cursor_y));
	    state->stack_x[state->stack_next] = DUMMY_STACK_X;
	    state->stack_y[state->stack_next] = DUMMY_STACK_Y;
	    state->stack_next++;
	    break;
	case 'W':
	case 'w':
	    TRACE(("found temporary write options \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!load_regis_write_control_set(state, context,
					      context->graphics_output_cursor_x,
					      context->graphics_output_cursor_y,
					      &optionarg,
					      &context->temporary_write_controls)) {
		TRACE(("DATA_ERROR: invalid temporary write options \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
	    }
	    break;
	default:
	    TRACE(("DATA_ERROR: ignoring unknown ReGIS vector command option '%c' arg \"%s\"\n",
		   state->option, fragment_to_tempstr(&optionarg)));
	    break;
	}
	break;
    case 'w':
	skip_regis_whitespace(&optionarg);
	TRACE(("inspecting permanent write option \"%c\" with value \"%s\"\n",
	       state->option, fragment_to_tempstr(&optionarg)));
	if (!load_regis_write_control(state, context,
				      context->graphics_output_cursor_x,
				      context->graphics_output_cursor_y,
				      state->option, &optionarg,
				      &context->persistent_write_controls)) {
	    TRACE(("DATA_ERROR: invalid write options\n"));
	    return 1;
	}
	break;
    default:
	TRACE(("DATA_ERROR: unexpected option in \"%c\" command: \"%s\"\n",
	       state->command, fragment_to_tempstr(&optionarg)));
	return 1;
    }

    return 1;
}

static int
expand_macrographs(RegisDataFragment *input, RegisGraphicsContext const *context)
{
    char op;
    char name;

    (void) context;		/* to be used later */
    op = get_fragment(input, 0U);
    if (op != '@')
	return 0;
    name = get_fragment(input, 1U);
    if (islower(CharOf(name)))
	name = (char) toupper(CharOf(name));
    if (name < 'A' || name > 'Z')
	return 0;

    TRACE(("expanding macrograph '%c' with %u characters FIXME\n", name, 0U));
    pop_fragment(input);
    pop_fragment(input);
    /* FIXME: implement */
    return 1;
}

static int
parse_regis_items(RegisParseState *state, RegisGraphicsContext *context)
{
    RegisDataFragment *const input = &state->input;
    RegisDataFragment item;

    if (fragment_consumed(input))
	return 0;

    if (extract_regis_extent(input, &item)) {
	TRACE(("found extent \"%s\"\n", fragment_to_tempstr(&item)));
	switch (state->command) {
	case 'c':
	    {
		int orig_x, orig_y;
		int new_x, new_y;

		if (state->num_points > 0) {
		    orig_x = state->x_points[state->num_points - 1];
		    orig_y = state->y_points[state->num_points - 1];
		} else {
		    orig_x = context->graphics_output_cursor_x;
		    orig_y = context->graphics_output_cursor_y;
		}
		if (!load_regis_coord_extent(context,
					     fragment_to_tempstr(&item),
					     orig_x, orig_y,
					     &new_x, &new_y)) {
		    TRACE(("DATA_ERROR: unable to parse extent in '%c' command: \"%s\"\n",
			   state->command, fragment_to_tempstr(&item)));
		    break;
		}

		switch (state->curve_mode) {
		case CURVE_POSITION_ARC_CENTER:
		case CURVE_POSITION_ARC_EDGE:
		    {
			double radians;
			int tenthdegs;
			int c_x, c_y;
			int e_x, e_y;
			int e_x_final = 0, e_y_final = 0;

			TRACE(("drawing arc: curve_mode=%d\n", state->curve_mode));
			TRACE(("drawing arc: new=%d,%d orig=%d,%d\n",
			       new_x, new_y, orig_x, orig_y));
			if (state->curve_mode == CURVE_POSITION_ARC_CENTER) {
			    c_x = new_x;
			    c_y = new_y;
			    e_x = orig_x;
			    e_y = orig_y;
			} else {
			    c_x = orig_x;
			    c_y = orig_y;
			    e_x = new_x;
			    e_y = new_y;
			}

			radians = atan2((double) (c_y - e_y),
					(double) (e_x - c_x));
			tenthdegs = (int) (0.5 + 3600.0 * radians / (2.0 * M_PI));
			if (tenthdegs < 0)
			    tenthdegs += 3600;

			TRACE(("drawing arc centered at location %d,%d to location %d,%d from %g degrees (%g radians) for %d degrees\n",
			       c_x, c_y,
			       e_x, e_y,
			       tenthdegs / 10., radians, state->arclen));
			draw_patterned_arc(context,
					   c_x, c_y,
					   e_x, e_y,
					   tenthdegs, state->arclen * 10,
					   &e_x_final, &e_y_final);

#ifdef DEBUG_ARC_CENTER
			DRAW_PIXEL(context, c_x + 1, c_y, 3U);
			DRAW_PIXEL(context, c_x - 1, c_y, 3U);
			DRAW_PIXEL(context, c_x, c_y + 1, 3U);
			DRAW_PIXEL(context, c_x, c_y - 1, 3U);
			DRAW_PIXEL(context, c_x, c_y, 3U);
#endif

#ifdef DEBUG_ARC_START
			DRAW_PIXEL(context, e_x + 1, e_y, 2U);
			DRAW_PIXEL(context, e_x - 1, e_y, 2U);
			DRAW_PIXEL(context, e_x, e_y + 1, 2U);
			DRAW_PIXEL(context, e_x, e_y - 1, 2U);
			DRAW_PIXEL(context, e_x, e_y, 2U);
#endif

#ifdef DEBUG_ARC_END
			DRAW_PIXEL(context, e_x_final + 1, e_y_final + 1, 1U);
			DRAW_PIXEL(context, e_x_final + 1, e_y_final - 1, 1U);
			DRAW_PIXEL(context, e_x_final - 1, e_y_final + 1, 1U);
			DRAW_PIXEL(context, e_x_final - 1, e_y_final - 1, 1U);
			DRAW_PIXEL(context, e_x_final, e_y_final, 1U);
#endif

			if (state->curve_mode == CURVE_POSITION_ARC_CENTER) {
			    TRACE(("moving cursor to final point on arc %d,%d\n",
				   e_x_final, e_y_final));
			    if (state->num_points > 0) {
				state->x_points[state->num_points - 1] =
				    e_x_final;
				state->y_points[state->num_points - 1] =
				    e_y_final;
			    }
			    context->graphics_output_cursor_x = e_x_final;
			    context->graphics_output_cursor_y = e_y_final;
			}
		    }
		    break;
		case CURVE_POSITION_OPEN_CURVE:
		case CURVE_POSITION_CLOSED_CURVE:
		    if (state->num_points >= MAX_INPUT_CURVE_POINTS) {
			TRACE(("DATA_ERROR: got curve point, but already have max points (%d)\n",
			       state->num_points));
			break;
		    }
		    state->x_points[state->num_points] = new_x;
		    state->y_points[state->num_points] = new_y;
		    state->num_points++;
		    TRACE(("adding point to curve with location %d,%d\n",
			   new_x, new_y));
		    break;
		default:
		    TRACE(("ERROR: got position, but curve mode %d is unknown\n",
			   state->curve_mode));
		    break;
		}
	    }
	    break;
	case 'p':
	    if (!load_regis_coord_extent(context,
					 fragment_to_tempstr(&item),
					 context->graphics_output_cursor_x,
					 context->graphics_output_cursor_y,
					 &context->graphics_output_cursor_x,
					 &context->graphics_output_cursor_y)) {
		TRACE(("DATA_ERROR: unable to parse extent in '%c' command: \"%s\"\n",
		       state->command, fragment_to_tempstr(&item)));
		break;
	    }
	    TRACE(("moving pen to location %d,%d\n",
		   context->graphics_output_cursor_x,
		   context->graphics_output_cursor_y));
	    break;
	case 's':
	    TRACE(("extent scroll argument to screen command: \"%s\"\n",
		   fragment_to_tempstr(&item)));
	    {
		int old_ul_x, old_ul_y;
		int new_ul_x, new_ul_y;
		int copy_w, copy_h;

		old_ul_x = 0;
		old_ul_y = 0;
		TRACE(("current upper-left coordinate in pixel coordinates: %d,%d\n",
		       old_ul_x, old_ul_y));
		/* FIXME: verify this is in user coordinates, not pixels */
		if (!load_regis_coord_extent(context,
					     fragment_to_tempstr(&item),
					     old_ul_x, old_ul_y,
					     &new_ul_x, &new_ul_y)) {
		    TRACE(("DATA_ERROR: unable to parse extent in '%c' command: \"%s\"\n",
			   state->command, fragment_to_tempstr(&item)));
		    break;
		}
		TRACE(("scrolling image to updated upper-left coordinate in pixel coordinates: %d,%d\n",
		       new_ul_x, new_ul_y));

		/* FIXME: does any write mode affect revealed background? */
		if (new_ul_x > 0)
		    copy_w = context->width - new_ul_x;
		else
		    copy_w = context->width;
		if (new_ul_y > 0)
		    copy_h = context->height - new_ul_y;
		else
		    copy_h = context->height;
		/* FIXME: verify this applies to write page, not display page */
		copy_overlapping_area(context->destination_graphic,
				      new_ul_x, new_ul_y,
				      0, 0,
				      (unsigned) copy_w, (unsigned) copy_h,
				      context->background);
		context->destination_graphic->dirty = True;
		context->force_refresh = True;
	    }
	    break;
	case 't':
	    /* FIXME: verify this is in pixels, not user coordinates */
	    if (!load_regis_pixel_extent(fragment_to_tempstr(&item),
					 0, 0,
					 &context->current_text_controls->character_inc_x,
					 &context->current_text_controls->character_inc_y)) {
		TRACE(("DATA_ERROR: unable to parse extent in '%c' command: \"%s\"\n",
		       state->command, fragment_to_tempstr(&item)));
		break;
	    }
	    TRACE(("setting character spacing to %d,%d\n",
		   context->current_text_controls->character_inc_x,
		   context->current_text_controls->character_inc_y));
	    break;
	case 'v':
	    {
		int orig_x, orig_y;

		orig_x = context->graphics_output_cursor_x;
		orig_y = context->graphics_output_cursor_y;
		if (!load_regis_coord_extent(context,
					     fragment_to_tempstr(&item),
					     orig_x, orig_y,
					     &context->graphics_output_cursor_x,
					     &context->graphics_output_cursor_y)) {
		    TRACE(("DATA_ERROR: unable to parse extent in '%c' command: \"%s\"\n",
			   state->command, fragment_to_tempstr(&item)));
		    break;
		}
		TRACE(("drawing line to location %d,%d\n",
		       context->graphics_output_cursor_x,
		       context->graphics_output_cursor_y));
		draw_patterned_line(context,
				    orig_x, orig_y,
				    context->graphics_output_cursor_x,
				    context->graphics_output_cursor_y);
	    }
	    break;
	default:
	    TRACE(("DATA_ERROR: unexpected extent in \"%c\" command: \"%s\"\n",
		   state->command, fragment_to_tempstr(&item)));
	    break;
	}
	return 1;
    }

    if (state->command != 'l' && extract_regis_pixelvector(input, &item)) {
	TRACE(("found pixel vector \"%s\"\n", fragment_to_tempstr(&item)));
	switch (state->command) {
	case 'c':
	    /* FIXME: parse, handle */
	    TRACE(("pixelvector in curve command FIXME\n"));
	    break;
	    /* FIXME: not sure if 'f' supports PVs */
	case 'p':
	    /* FIXME: error checking */
	    if (!load_regis_coord_pixelvector(context,
					      fragment_to_tempstr(&item),
					      context->graphics_output_cursor_x,
					      context->graphics_output_cursor_y,
					      &context->graphics_output_cursor_x,
					      &context->graphics_output_cursor_y)) {
		TRACE(("DATA_ERROR: unable to parse pixel vector in '%c' command: \"%s\"\n",
		       state->command, fragment_to_tempstr(&item)));
		break;
	    }
	    TRACE(("moving pen to location %d,%d\n",
		   context->graphics_output_cursor_x,
		   context->graphics_output_cursor_y));
	    break;
	case 's':
	    TRACE(("pixelvector scroll argument to screen command: \"%s\"\n",
		   fragment_to_tempstr(&item)));
	    {
		int old_ul_x, old_ul_y;
		int new_ul_x, new_ul_y;
		int copy_w, copy_h;

		old_ul_x = 0;
		old_ul_y = 0;
		TRACE(("current upper-left coordinate in pixel coordinates: %d,%d\n",
		       old_ul_x, old_ul_y));
		/* FIXME: verify this is in user coordinates, not pixels */
		/* FIXME: verify that multiple PV digits result in a single
		 * copy (this changes the contents of any exposed edge)
		 */
		if (!load_regis_coord_pixelvector(context,
						  fragment_to_tempstr(&item),
						  old_ul_x, old_ul_y,
						  &new_ul_x, &new_ul_y)) {
		    TRACE(("DATA_ERROR: unable to parse pixel vector in '%c' command: \"%s\"\n",
			   state->command, fragment_to_tempstr(&item)));
		    break;
		}
		TRACE(("scrolling image to updated upper-left coordinate in pixel coordinates: %d,%d\n",
		       new_ul_x, new_ul_y));

		/* FIXME: does any write mode affect revealed background? */
		if (new_ul_x > 0)
		    copy_w = context->width - new_ul_x;
		else
		    copy_w = context->width;
		if (new_ul_y > 0)
		    copy_h = context->height - new_ul_y;
		else
		    copy_h = context->height;
		/* FIXME: verify this applies to write page, not display page */
		copy_overlapping_area(context->destination_graphic,
				      new_ul_x, new_ul_y,
				      0, 0,
				      (unsigned) copy_w, (unsigned) copy_h,
				      context->background);
		context->destination_graphic->dirty = True;
		context->force_refresh = True;
	    }
	    break;
	case 't':
	    {
		int dx, dy;

		/* FIXME: verify this does not use user coordinates */
		if (!load_regis_pixel_pixelvector(fragment_to_tempstr(&item),
						  1, 0, 0, &dx, &dy)) {
		    TRACE(("DATA_ERROR: unable to parse pixel vector in '%c' command: \"%s\"\n",
			   state->command, fragment_to_tempstr(&item)));
		    break;
		}

		dx *= (int) (context->current_text_controls->character_display_w
			     >> 1U);
		dy *= (int) (context->current_text_controls->character_display_h
			     >> 1U);
		TRACE(("adding character offset %d,%d\n (ds=%dx%d)", dx, dy,
		       context->current_text_controls->character_display_w,
		       context->current_text_controls->character_display_h));
		move_text(context, dx, dy);
	    }
	    break;
	case 'v':
	    {
		char const *const pixelvector = fragment_to_tempstr(&item);
		unsigned offset;

		for (offset = 0U; pixelvector[offset] != '\0';) {
		    int orig_x = context->graphics_output_cursor_x;
		    int orig_y = context->graphics_output_cursor_y;
		    if (!load_regis_coord_pixelvector_step(context, pixelvector,
							   &offset,
							   orig_x, orig_y,
							   &context->graphics_output_cursor_x,
							   &context->graphics_output_cursor_y)) {
			TRACE(("DATA_ERROR: unable to parse pixel vector in '%c' command: \"%s\"\n",
			       state->command, fragment_to_tempstr(&item)));
			break;
		    }
		    TRACE(("drawing line to location %d,%d\n",
			   context->graphics_output_cursor_x,
			   context->graphics_output_cursor_y));
		    draw_patterned_line(context, orig_x, orig_y,
					context->graphics_output_cursor_x,
					context->graphics_output_cursor_y);
		}
	    }
	    break;
	default:
	    TRACE(("DATA_ERROR: unexpected pixel vector in \"%c\" command: \"%s\"\n",
		   state->command, fragment_to_tempstr(&item)));
	    break;
	}
	return 1;
    }

    if (extract_regis_string(input, state->temp, state->templen)) {
	switch (state->command) {
	case 'l':
	    /* FIXME: confirm that extra characters are ignored */
	    TRACE(("found character to load: \"%s\"\n", state->temp));
	    state->load_glyph = (unsigned) (Char) state->temp[0];
	    state->load_row = 0U;
	    break;
	case 't':
	    TRACE(("found string to draw: \"%s\"\n", state->temp));
	    draw_text(context, state->temp);
	    break;
	case '_':
	    TRACE(("found comment: \"%s\"\n", state->temp));
	    break;
	default:
	    TRACE(("DATA_ERROR: unexpected string argument to \"%c\" command: \"%s\"\n",
		   state->command, state->temp));
	    break;
	}
	return 1;
    }

    /* hex values */
    if (state->command == 'l') {
	unsigned digit;

	for (digit = 0U; digit < (state->load_w + 3U) >> 2U; digit++) {
	    char ch = peek_fragment(input);

	    if (!isxdigit(CharOf(ch))) {
		if (ch != ',' && ch != ';' &&
		    ch != ' ' && ch != '\r' &&
		    ch != '\n') {
		    TRACE(("found end of hexadecimal string witch '%c' on digit %u\n",
			   ch, digit));
		    /* FIXME: need to unput the digits up to this point */
		    /*
		     * Report success since we ate some characters,
		     * and the new char needs to be compared with commands
		     * and other top-level things.
		     */
		    if (digit != 0U)
			return 1;
		    return 0;
		}
		pop_fragment(input);
		break;
	    }

	    state->temp[digit] = ch;
	    pop_fragment(input);
	}
	state->temp[digit] = '\0';

	if (strlen(state->temp) > 0) {
	    unsigned long val;
	    unsigned glyph_size;

	    val = strtoul(state->temp, NULL, 16);
	    TRACE(("found row %u for glyph %u: \"%s\" value %02lx (%lu)\n",
		   state->load_row, state->load_glyph, state->temp, val, val));

	    if (state->load_row >= state->load_h) {
		TRACE(("DATA_ERROR: ignoring extra row for glyph %u\n",
		       state->load_glyph));
		return 0;
	    }

	    if (state->load_index == MAX_REGIS_ALPHABETS) {
		state->load_index = find_free_alphabet_index(context,
							     state->load_alphabet,
							     state->load_w,
							     state->load_h);
		TRACE(("current alphabet is %u and size is %ux%u; assigning alphabet index %u\n",
		       state->load_alphabet, state->load_w,
		       state->load_h, state->load_index));
	    }

	    glyph_size =
		GLYPH_WIDTH_BYTES(context->alphabets[state->load_index].pixw)
		* context->alphabets[state->load_index].pixh;
	    if (context->alphabets[state->load_index].bytes == NULL) {
		if (!(context->alphabets[state->load_index].bytes =
		      TypeCallocN(Char, (size_t) (MAX_GLYPHS * glyph_size)))) {
		    TRACE(("ERROR: unable to allocate %u bytes for glyph storage\n",
			   MAX_GLYPHS * glyph_size));
		    return 0;
		}
	    } {
		Char *glyph;
		unsigned bytew;
		unsigned byte;
		unsigned unused_bits;

		glyph = &context->alphabets[state->load_index]
		    .bytes[state->load_glyph * glyph_size];
		bytew = GLYPH_WIDTH_BYTES(context->alphabets[state->load_index]
					  .pixw);
		unused_bits = 8U - (context->alphabets[state->load_index].pixw
				    & 3U);
		if (unused_bits == 8U) {
		    unused_bits = 0U;
		}
		for (byte = 0U; byte < bytew; byte++) {
		    glyph[state->load_row * bytew + byte] =
			(Char) (((val << unused_bits) >>
				 ((bytew - (byte + 1U)) << 3U))
				& 255U);
#ifdef DEBUG_LOAD
		    TRACE(("bytew=%u val=%lx byte=%u output=%x\n",
			   bytew, val,
			   byte,
			   (unsigned) glyph[state->load_row * bytew + byte]));
#endif
		}

		state->load_row++;
		context->alphabets[state->load_index].use_font = 0;
		context->alphabets[state->load_index]
		    .loaded[state->load_glyph] = 1;
#ifdef DEBUG_LOAD
		TRACE(("marking alphabet %u at index %u glyph %u as loaded\n",
		       state->load_alphabet, state->load_index,
		       state->load_glyph));
#endif
		return 1;
	    }
	}
    }

    /* special symbols */
    if (state->command == '@') {
	char ch = peek_fragment(input);
	TRACE(("inspecting macrograph character \"%c\"\n", ch));
	switch (ch) {
	case '.':
	    pop_fragment(input);
	    TRACE(("clearing all macrographs\n"));
	    /* FIXME: implement when macrographs are supported. */
	    return 1;
	case ':':
	    pop_fragment(input);
	    TRACE(("defining macrograph\n"));
	    /* FIXME: what about whitespace before the name? */
	    if (fragment_consumed(input)) {
		TRACE(("DATA_ERROR: macrograph definition without name, ignoring\n"));
		return 1;
	    } {
#define MAX_MACROGRAPH_LEN 1024
		char temp[MAX_MACROGRAPH_LEN];
		char name;
		char prev = '\0';
		int len = 0;

		name = pop_fragment(input);
		if (islower(CharOf(name)))
		    name = (char) toupper(CharOf(name));
		TRACE(("defining macrograph for \"%c\"\n", name));
		if (name < 'A' || name > 'Z') {
		    TRACE(("DATA_ERROR: invalid macrograph name\n"));
		    /* FIXME: what should happen? */
		    return 1;
		}
		for (;;) {
		    char next = peek_fragment(input);
		    if (prev == '@' && next == ';') {
			/* FIXME: parse, handle  :<name><definition>; */
			pop_fragment(input);
			len--;
			break;
		    } else if (next == '\0') {
			TRACE(("DATA_ERROR: macrograph definition ends before semicolon\n"));
			/* FIXME: what should happen? */
			return 1;
		    }
		    pop_fragment(input);
		    if (len < MAX_MACROGRAPH_LEN) {
			temp[len++] = next;
		    }
		    prev = next;
		}
		if (len == MAX_MACROGRAPH_LEN) {
		    TRACE(("DATA_ERROR: macrograph definition too long\n"));
		    /* FIXME: what should happen? */
		    return 1;
		}
		temp[len] = '\0';

		(void) temp;	/* variable needed only if tracing */
		/* FIXME: implement when macrographs are supported. */
		TRACE(("ERROR: would have saved macrograph: \"%s\"\n", temp));
	    }
	    return 1;
	case ';':
	    pop_fragment(input);
	    TRACE(("DATA_ERROR: found extraneous terminator for macrograph definition\n"));
	    return 1;
	default:
	    pop_fragment(input);
	    TRACE(("DATA_ERROR: unknown macrograph command '%c'\n", ch));
	    return 1;
	}
    }

    return 0;
}

static int
parse_regis_toplevel(RegisParseState *state, RegisGraphicsContext *context)
{
    RegisDataFragment parenthesized;
    char ch;

#ifdef DEBUG_PARSING
    TRACE(("parsing top level: char %u of %u (next char '%c')\n",
	   state->input.pos,
	   fragment_length(&state->input),
	   peek_fragment(&state->input)));
#endif
    if (skip_regis_whitespace(&state->input))
	return 0;
    if (expand_macrographs(&state->input, context))
	return 0;

    /* FIXME: the semicolon terminates the current command even if inside of an optionset or extent */
    if (peek_fragment(&state->input) == ';') {
	pop_fragment(&state->input);
	TRACE(("ending '%c' command\n", state->command));
	state->command = '_';
	state->option = '_';
	return 1;
    }
    /* Load statements contain hex values which may look like commands. */
    ch = peek_fragment(&state->input);
    if (state->command != 'l' || !isxdigit(CharOf(ch))) {
#ifdef DEBUG_PARSING
	TRACE(("checking for top level command...\n"));
#endif
	if (parse_regis_command(state)) {
	    /* FIXME: verify that these are the things reset on a new command */
	    TRACE(("resetting temporary write controls and pattern state before handling command\n"));
	    copy_regis_write_controls(&context->persistent_write_controls,
				      &context->temporary_write_controls);
	    context->pattern_count = 0U;
	    context->pattern_bit = 1U;

	    /* FIXME: what happens if temporary text controls aren't closed? */
	    /* FIXME: what if temporary text controls are nested? */
	    context->current_text_controls = &context->persistent_text_controls;
	    return 1;
	}
    }
#ifdef DEBUG_PARSING
    TRACE(("checking for top level parentheses...\n"));
#endif
    if (extract_regis_parenthesized_data(&state->input, &parenthesized)) {
	RegisDataFragment keep;

	if (state->command == 'f') {	/* Fill */
	    TRACE(("found commands in fill mode \"%s\"\n",
		   fragment_to_tempstr(&parenthesized)));
	    copy_fragment(&keep, &state->input);
	    copy_fragment(&state->input, &parenthesized);
	    state->command = '_';
	    state->option = '_';
	    context->fill_mode = 1;
	    context->fill_point_count = 0U;
	    while (!fragment_consumed(&state->input))
		parse_regis_toplevel(state, context);
	    if (context->temporary_write_controls.shading_character != '\0') {
		draw_shaded_polygon(context);
	    } else {
		draw_filled_polygon(context);
	    }
	    context->fill_point_count = 0U;
	    context->fill_mode = 0;
	    state->command = 'f';
	    copy_fragment(&state->input, &keep);
	    return 1;
	} else {
	    TRACE(("parsing optionset \"%s\"\n",
		   fragment_to_tempstr(&parenthesized)));
	    copy_fragment(&keep, &state->input);
	    copy_fragment(&state->input, &parenthesized);
	    state->option = '_';
	    TRACE(("parsing at optionset level (char %u of %u)\n",
		   state->input.pos,
		   fragment_length(&state->input)));
	    for (;;) {
		if (fragment_consumed(&state->input))
		    break;
		TRACE(("looking at optionset character %u: \"%c\"\n",
		       state->input.pos, peek_fragment(&state->input)));
		if (skip_regis_whitespace(&state->input))
		    continue;
		if (parse_regis_option(state, context))
		    continue;
		if (parse_regis_items(state, context))
		    continue;
		if (fragment_consumed(&state->input))
		    break;
		{
		    char skip;

		    skip = pop_fragment(&state->input);
		    (void) skip;	/* variable needed only if tracing */
		    TRACE(("DATA_ERROR: skipping unexpected character in optionset: \"%c\"\n",
			   skip));
		}
		/* FIXME: suboptions */
	    }
	    state->option = '_';
	    copy_fragment(&state->input, &keep);
	    return 1;
	}
    }
    if (state->command == 'f') {	/* Fill */
	RegisDataFragment optionarg;
	if (extract_regis_option(&state->input, &state->option, &optionarg)) {
	    skip_regis_whitespace(&optionarg);

	    TRACE(("found temporary write options \"%s\"\n",
		   fragment_to_tempstr(&optionarg)));
	    if (!load_regis_write_control_set(state, context,
					      context->graphics_output_cursor_x,
					      context->graphics_output_cursor_y,
					      &optionarg,
					      &context->temporary_write_controls)) {
		TRACE(("DATA_ERROR: invalid temporary write options \"%s\"\n",
		       fragment_to_tempstr(&optionarg)));
	    }
	    return 1;
	}
	TRACE(("checking for top level items (though none should be present)...\n"));
	if (parse_regis_items(state, context))
	    return 1;
    } else {
#ifdef DEBUG_PARSING
	TRACE(("checking for top level items...\n"));
#endif
	if (parse_regis_items(state, context))
	    return 1;
    }

    if (!fragment_consumed(&state->input)) {
	char skip;

	skip = pop_fragment(&state->input);
	(void) skip;		/* variable needed only if tracing */
	TRACE(("DATA_ERROR: skipping unexpected character at top level: \"%c\"\n", ch));
    }
    return 0;
}

void
reset_regis(void)
{
    persistent_context.width = 0;
    persistent_context.height = 0;
}

void
parse_regis(XtermWidget xw, ANSI *params, char const *string)
{
    TScreen *screen = TScreenOf(xw);
    RegisGraphicsContext *const context = &persistent_context;
    RegisParseState *const state = &persistent_state;
    struct timeval prev_tv;
    struct timeval curr_tv;
    unsigned iterations;
    int Pmode;

    assert(params);
    assert(string);

    if (params->a_nparam > 0)
	Pmode = params->a_param[0];
    else
	Pmode = 0;

    TRACE(("ReGIS vector graphics mode, param_count=%d mode=%d\n",
	   params->a_nparam, Pmode));

    init_fragment(&state->input, string);
    state->templen = (unsigned) strlen(string) + 1U;
    if (!(state->temp = TypeMallocN(char, (size_t) state->templen))) {
	TRACE(("Unable to allocate temporary buffer of size %u\n",
	       state->templen));
	return;
    }

    context->current_widget = xw;

    /* Update the screen scrolling and do a refresh.
     * The refresh may not cover the whole graphic.
     */
    if (screen->scroll_amt)
	FlushScroll(xw);

    /* Only reset on the first ReGIS image unless it is being requested. */
    if (context->width == 0 || context->height == 0 ||
	Pmode == 1 || Pmode == 3) {
	init_regis_parse_state(state);
	init_regis_graphics_context(GraphicsTermId(screen),
				    screen->graphics_regis_def_wide,
				    screen->graphics_regis_def_high,
				    get_color_register_count(screen),
				    screen->graphics_regis_default_font,
				    context);
    }

    map_regis_graphics_pages(xw, context);

    X_GETTIMEOFDAY(&prev_tv);
    iterations = 0U;
    refresh_modified_displayed_graphics(xw);

    for (;;) {
	if (skip_regis_whitespace(&state->input))
	    continue;
	if (parse_regis_toplevel(state, context)) {
	    int need_refresh = 0;

	    /* FIXME: Move refresh logic out of the top level so that long
	     * sequences of filled drawing commands can be refreshed before the
	     * end of the fill command.
	     */
	    iterations++;
	    memset(&curr_tv, 0, sizeof(curr_tv));
	    if (context->force_refresh) {
		X_GETTIMEOFDAY(&curr_tv);
		need_refresh = 1;
	    } else if (iterations > MIN_ITERATIONS_BEFORE_REFRESH) {
		X_GETTIMEOFDAY(&curr_tv);
		if ((Time) curr_tv.tv_sec > (Time) prev_tv.tv_sec + 1UL) {
		    need_refresh = 1;
		} else {
#define DiffTime(TV) (TV.tv_sec * 1000L + TV.tv_usec / 1000L)
		    long diff = (long) (DiffTime(curr_tv) - DiffTime(prev_tv));
		    if (diff > MIN_MS_BEFORE_REFRESH)
			need_refresh = 1;
		}
	    }

	    if (need_refresh) {
		TRACE(("refreshing after %u iterations and %ldms\n",
		       iterations,
		       (long) (DiffTime(curr_tv) - DiffTime(prev_tv))));
		context->force_refresh = 0;
		prev_tv = curr_tv;
		iterations = 0U;
		refresh_modified_displayed_graphics(xw);
		xtermFlushDbe(xw);
	    }

	    continue;
	}

	if (fragment_consumed(&state->input))
	    break;
    }

    free(state->temp);

    refresh_modified_displayed_graphics(xw);
    TRACE(("DONE! Successfully parsed ReGIS data.\n"));
}
