/*
 * CDE - Common Desktop Environment
 *
 * Copyright (c) 1993-2012, The Open Group. All rights reserved.
 *
 * These libraries and programs are free software; you can
 * redistribute them and/or modify them under the terms of the GNU
 * Lesser General Public License as published by the Free Software
 * Foundation; either version 2 of the License, or (at your option)
 * any later version.
 *
 * These libraries and programs are distributed in the hope that
 * they will be useful, but WITHOUT ANY WARRANTY; without even the
 * implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
 * PURPOSE. See the GNU Lesser General Public License for more
 * details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with these libraries and programs; if not, write
 * to the Free Software Foundation, Inc., 51 Franklin Street, Fifth
 * Floor, Boston, MA 02110-1301 USA
 */
/*                                                                      *
 * (c) Copyright 1993, 1994 Hewlett-Packard Company                     *
 * (c) Copyright 1993, 1994 International Business Machines Corp.       *
 * (c) Copyright 1993, 1994 Sun Microsystems, Inc.                      *
 * (c) Copyright 1993, 1994 Novell, Inc.                                *
 */

#include <ctype.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <string.h>

#include "TermPrimLineFontP.h"

int getopt(int argc, char * const argv[], const char *optstring);
int ParseChar(char **str);
int parseCoord(char **str, char *val, signed char *offset);
char * parseToken(char **str);
void displayErrorString(FILE *f, char *orig, char *remain);
static void DumpChar(FILE *f, int charNum, charType *charList, int charListMax,
	rect *rectList, int rectListMax, line *lineList, int lineListMax,
	line *stippleList, int stippleListMax);
static void DumpGlyphs(FILE *f, char *prefix,
	GlyphInfo glyphList, int glyphListMax);
static int parseLine(char **bufPtr, line *line);
static int parseRectangle(char **bufPtr, rect *rectangle);
static void order(char *p1, char *p2, signed char *offset1, signed char *offset2);
static char *vis(char val);

int
main(int argc, char **argv)
{
    char buffer[BUFSIZ];
    char *bufPtr;
    char orig[BUFSIZ];
    int i;
    char *c;
    FILE *f;
    extern char *optarg;
    char *prefix = "_Term";

    charType *charList = (charType *) 0;
    int charListSize = 0;
    int charListMax = 0;

    rect *rectList = (rect *) 0;
    int rectListSize = 0;
    int rectListMax = 0;

    line *stippleList = (line *) 0;
    int stippleListSize = 0;
    int stippleListMax = 0;

    line *lineList = (line *) 0;
    int lineListSize = 0;
    int lineListMax = 0;

    GlyphInfo glyphList = (GlyphInfo) 0;
    int glyphListSize = 0;
    int glyphListMax = 0;

    int charCount = 0;			/* total number of chars in font*/

    char *datafilename = "linegen.data";

    while (EOF != (i = getopt(argc, argv, "p:f:"))) {
	switch (i) {
	case 'f' :
	    datafilename = optarg;
	    break;

	case 'p' :
	    prefix = optarg;
	    break;
	}
    }

    if (NULL == (f = fopen(datafilename, "r"))) {
	(void) perror(datafilename);
	(void) exit(1);
    }

    /* read through the file and generate each character...
     */
    while (fgets(buffer, sizeof(buffer), f)) {
	/* null out '\n'... */
	buffer[strlen(buffer) - 1] = '\0';

	/* if the line begins with '#', ignore it... */
	if (*buffer == '#')
	    continue;

	/* if the line begins with a '!', just print it out (with the
	 * '!' removed... */

	if (*buffer == '!') {
	    (void) fputs(buffer + 1, stdout);
	    (void) putc('\n', stdout);
	    continue;
	}

	/* back up buffer... */
	(void) strncpy(orig, buffer, BUFSIZ - 1);

	bufPtr = buffer;

	/* pull off token... */
	c = parseToken(&bufPtr);

	/* ignore blank lines... */
	if (!c || !*c)
	    continue;

	/* process the token... */
	if (!strcmp(c, "char")) {
	    /* dump the previous character... */
	    if (charListMax > 0) {
		(void) DumpChar(stdout, charCount++, charList, charListMax,
			 rectList, rectListMax, lineList, lineListMax,
			 stippleList, stippleListMax);
		lineListMax = 0;
		rectListMax = 0;
		stippleListMax = 0;
	    }

	    /* grow the glyph list if necessary... */
	    if (glyphListMax + 1 > glyphListSize) {
		glyphListSize += 10;
		glyphList = (GlyphInfo) realloc(glyphList,
			glyphListSize * sizeof(GlyphInfoRec));
	    }
	    /* bump count.  We need to remember that this is one high
	     * when we use it as an index...
	     */
	    glyphList[glyphListMax].numRects = 0;
	    glyphList[glyphListMax].numLines = 0;
	    glyphList[glyphListMax].numStipples = 0;
	    (void) glyphListMax++;

	    /* this is a list of characters... */
	    charListMax = 0;
	    charListSize = 10;
	    charList = (charType *)
		    malloc((unsigned) (charListSize * sizeof(charType)));

	    while (*bufPtr) {
		/* extend the charList if we need to (the 2 is 1 for this
		 * entry and 1 for the terminating 0...
		 */
		if (charListMax + 2 > charListSize) {
		    charListSize += 10;
		    charList = (charType *) realloc(charList,
			    charListSize * sizeof(charType));
		}

		if (0 == (charList[charListMax++] = ParseChar(&bufPtr))) {
		    (void) fprintf(stderr, "invalid \"char\" specification:\n");
		    (void) displayErrorString(stderr, orig, bufPtr);
		    (void) exit(1);
		}

		if (bufPtr && *bufPtr) {
		    if (*bufPtr == ',') {
			/* additional stuff... */
			(void) bufPtr++;
			/* skip whitespace... */
			while (*bufPtr && strchr(" \t", *bufPtr))
			    (void) bufPtr++;
		    } else {
			/* error -- invalid character... */
			(void) fprintf(stderr,
				"invalid \"char\" specification:\n");
			(void) displayErrorString(stderr, orig, bufPtr);
			(void) exit(1);
		    }
		}
	    }

	    /* null term the list... */
	    charList[charListMax] = 0;

	    /* save away the char list... */
	    glyphList[glyphListMax - 1].chars = charList;

	} else if (!strcmp(c, "rect")) {
	    if (rectListMax + 1 > rectListSize) {
		rectListSize += 10;
		rectList = (rect *) realloc(rectList,
			rectListSize * sizeof(rect));
	    }
		
	    if (parseRectangle(&bufPtr, &rectList[rectListMax])) {
		(void) fprintf(stderr, "invalid \"rect\" specification:\n");
		(void) displayErrorString(stderr, orig, bufPtr);
		(void) exit(1);
	    }

	    /* increment line count... */
	    (void) rectListMax++;

	    /* save away the rect list... */
	    glyphList[glyphListMax - 1].rects = rectList;
	    glyphList[glyphListMax - 1].numRects = rectListMax;

	} else if (!strcmp(c, "line")) {
	    if (lineListMax + 1 > lineListSize) {
		lineListSize += 10;
		lineList = (line *) realloc(lineList,
			lineListSize * sizeof(line));
	    }

	    /* did we error?... */
	    if (parseLine(&bufPtr, &lineList[lineListMax])) {
		(void) fprintf(stderr, "invalid \"line\" specification:\n");
		(void) displayErrorString(stderr, orig, bufPtr);
		(void) exit(1);
	    }

	    /* increment line count... */
	    (void) lineListMax++;

	    /* save away the line list... */
	    glyphList[glyphListMax - 1].lines = lineList;
	    glyphList[glyphListMax - 1].numLines = lineListMax;

	} else if (!strcmp(c, "stipple")) {
	    if (stippleListMax + 1 > stippleListSize) {
		stippleListSize += 10;
		stippleList = (line *) realloc(stippleList,
			stippleListSize * sizeof(line));
	    }
		
	    if (parseLine(&bufPtr, &stippleList[stippleListMax])) {
		(void) fprintf(stderr, "invalid \"stipple\" specification:\n");
		(void) displayErrorString(stderr, orig, bufPtr);
		(void) exit(1);
	    }


	    /* increment line count... */
	    (void) stippleListMax++;

	    /* save away the line list... */
	    glyphList[glyphListMax - 1].stipples = stippleList;
	    glyphList[glyphListMax - 1].numStipples = stippleListMax;

	} else {
	    /* unknown token... */
	    (void) fprintf(stderr, "invalid token:\n");
	    (void) displayErrorString(stderr, orig, orig);
	    (void) exit(1);
	}
    }

    /* dump out the last character(s)... */
    if (charListMax > 0) {
	(void) DumpChar(stdout, charCount++, charList, charListMax,
		 rectList, rectListMax, lineList, lineListMax,
		 stippleList, stippleListMax);
	lineListMax = 0;
	rectListMax = 0;
	stippleListMax = 0;
	charListMax = 0;
    }

    /* build the final structure... */
    (void) DumpGlyphs(stdout, prefix, glyphList, glyphListMax);

    (void) exit(0);
}

int
ParseChar(char **str)
{
    char *c = *str;
    char *ptr;
    int ret = 0;

    while (*c && strchr(" \t", *c))
	c++;

    if (*c == '\'') {
	/* char format (i.e., 'c')...
	 */

	/* skip over '\''... */
	(void) c++;
	if (*c == '\\') {
	    /* quoted character... */
	    /* skip over '\\'... */
	    (void) c++;
	    switch (*c++) {
	    case 'n' :
		ret = '\n';
		break;
	    case 'f' :
		ret = '\f';
		break;
	    case 'r' :
		ret = '\r';
		break;
	    case 'b' :
		ret = '\b';
		break;
	    case 't' :
		ret = '\t';
		break;
	    case '\'' :
		ret = '\'';
		break;
	    case '\\' :
		ret = '\\';
		break;
	    case '0':
	    case '1':
	    case '2':
	    case '3':
	    case '4':
	    case '5':
	    case '6':
	    case '7':
		/* backup... */
		(void) c--;
		ret = (int) strtol(c, &ptr, 8);
		c = ptr;
		break;
	    default :
		/* error... */
		*str = c - 1;
		return(0);
		break;
	    }
	} else {
	    /* unquoted char... */
	    ret = *c++;
	}

	/* need to finish parsing the closing quote... */
	if (*c++ != '\'') {
	    *str = c - 1;
	    return(0);
	}
    } else if ((*c >= '0') || (*c <= '9')) {
	/* a number...
	 */
	ret = (int) strtol(c, &ptr, 0);
    }

    /* skip over whitespace... */
    while (*c && strchr(" \t", *c))
	c++;

    /* update the pointer... */
    *str = c;
    return(ret);
}

int
parseCoord(char **str, char *val, signed char *offset)
{
    char *c = *str;
    char *ptr;
    int sign = 1;

    /* skip over whitespace... */
    while (*c && strchr(" \t", *c))
	c++;

    /* end of line?... */
    if (!*c) {
	*str = (char *) 0;
	return(-1);
    }

    /* parse off number... */
    *val = (char) strtol(c, &ptr, 0);
    c = ptr;

    /* skip over whitespace... */
    while (c && *c && strchr(" \t", *c))
	c++;

    /* parse off offset... */
    if (c && ((*c == '-') || (*c == '+'))) {
	if (*c == '-')
	    sign = -1;
	/* skip over sign... */
	(void) c++;
	/* skip over whitespace... */
	while (*c && strchr(" \t", *c))
	    c++;

	/* parse off offset... */
	*offset = (char) strtol(c, &ptr, 0);
	c = ptr;

	/* set sign of offset... */
	*offset *= sign;

	/* skip over whitespace... */
	while (c && *c && strchr(" \t", *c))
	    c++;
    } else {
	*offset = 0;
    }

    /* set up return ptr... */
    *str = c;

    return(0);
}

char *
parseToken(char **str)
{
    char *c = *str;
    char *ret;

    /* skip white space... */
    while (*c && strchr(" \t", *c))
	c++;

    /* we hit start of token... */
    ret = c;
    while (*c && !strchr(" \t", *c))
	c++;

    /* null out the first whitespace... */
    if (*c)
	*c++ = '\0';

    /* skip white space... */
    while (*c && strchr(" \t", *c))
	c++;

    *str = c;
    return(ret);
}

void
displayErrorString(FILE *f, char *orig, char *remain)
{
    int col;

    (void) fprintf(f, "        %s\n", orig);
    if (!remain || !*remain) {
	col = strlen(orig);
    } else {
	col = strlen(orig) - strlen(remain);
	if (col < 0)
	    /* this should not happen... */
	    col = 0;
    }

    /* add 8 for the indent... */
    col += 8;

    /* output space... */
    while (col-- > 0)
	(void) putc(' ', f);
    /* output an '^'... */
    (void) putc('^', f);
    (void) putc('\n', f);
}

static int
parseLine(char **bufPtr, line *line)
{
    signed char dummyChar;
    int error = 0;

    /* set the bits that correspond to this line... */
    /* parse off x1... */
    error = parseCoord(bufPtr, &(line->x1),
	    &(line->x1Offset));

    /* parse off y1... */
    if (!error)
	error = parseCoord(bufPtr, &(line->y1),
		&(line->y1Offset));

    /* parse off x2... */
    if (!error)
	error = parseCoord(bufPtr, &(line->x2),
		&(line->x2Offset));

    /* parse off y2... */
    if (!error)
	error = parseCoord(bufPtr, &(line->y2),
		&(line->y2Offset));

    /* parse off lineWidth... */
    if (!error)
	error = parseCoord(bufPtr, &(line->width),
		&dummyChar);

    /* did we error?... */
    if (error) {
	return(1);
    }

    /* order x and y coords... */
    (void) order(&(line->x1),
	    &(line->x2),
	    &(line->x1Offset),
	    &(line->x2Offset));
    (void) order(&(line->y1),
	    &(line->y2),
	    &(line->y1Offset),
	    &(line->y2Offset));

    return(0);
}

static int
parseRectangle(char **bufPtr, rect *rectangle)
{
    int error = 0;

    /* parse off x1... */
    error = parseCoord(bufPtr, &(rectangle->x1),
	    &(rectangle->x1Offset));

    /* parse off y1... */
    if (!error)
	error = parseCoord(bufPtr, &(rectangle->y1),
		&(rectangle->y1Offset));

    /* parse off x2... */
    if (!error)
	error = parseCoord(bufPtr, &(rectangle->x2),
		&(rectangle->x2Offset));

    /* parse off y2... */
    if (!error)
	error = parseCoord(bufPtr, &(rectangle->y2),
		&(rectangle->y2Offset));

    /* did we error?... */
    if (error) {
	return(1);
    }

    /* order x and y coords... */
    (void) order(&(rectangle->x1),
	    &(rectangle->x2),
	    &(rectangle->x1Offset),
	    &(rectangle->x2Offset));
    (void) order(&(rectangle->y1),
	    &(rectangle->y2),
	    &(rectangle->y1Offset),
	    &(rectangle->y2Offset));

    return(0);
}

static void
order(char *p1, char *p2, signed char *offset1, signed char *offset2)
{
    char swap;

    /* order coords... */
    if (*p1 > *p2) {
	/* swap p1 & p1 */
	swap = *p1;
	*p1 = *p2;
	*p2 = swap;

	swap = *offset1;
	*offset1 = *offset2;
	*offset2 = swap;
    }
}

static void
DumpGlyphs(FILE *f, char *prefix, GlyphInfo glyphList, int glyphListMax)
{
    int i1;
    int i2;

    /* print the full glyph array... */

    (void) fprintf(f, "int %sNumGlyphs = %d;\n", prefix, glyphListMax);
    (void) fprintf(f, "GlyphInfoRec %sGlyphs[] = {\n", prefix);
    for (i1 = 0; i1 < glyphListMax; i1++) {
	/* print the characters this is for... */
	(void) fputs("    /* data for ", f);
	for (i2 = 0; glyphList[i1].chars[i2] != 0; i2++) {
	    if (i2 > 0) {
		(void) putc(',', f);
	    }
	    (void) fputs(vis(glyphList[i1].chars[i2]), f);
	    (void) putc(' ', f);
	}
	(void) fputs("*/\n", f);
	(void) fprintf(f, "    {\n");

	(void) fprintf(f, "        chars%03d,           /* char list */\n",
		i1);

	if (glyphList[i1].numRects > 0) {
	    (void) fprintf(f, "        rects%03d,    %2d,", i1,
		    glyphList[i1].numRects);
	} else {
	    (void) fprintf(f, "        (rect *) 0,   0,");
	}
	(void) fprintf(f, "    /* rectangle list */\n");

	if (glyphList[i1].numLines > 0) {
	    (void) fprintf(f, "        lines%03d,    %2d,", i1,
		    glyphList[i1].numLines);
	} else {
	    (void) fprintf(f, "        (line *) 0,   0,");
	}
	(void) fprintf(f, "    /* line list */\n");

	if (glyphList[i1].numStipples > 0) {
	    (void) fprintf(f, "        stipples%03d, %2d,", i1,
		    glyphList[i1].numStipples);
	} else {
	    (void) fprintf(f, "        (line *) 0,   0,");
	}
	(void) fprintf(f, "    /* stipple list */\n");
	(void) printf("    },\n\n");
    }
    (void) printf("};\n");
}

static void
DumpChar(FILE *f, int charCount, charType *charList, int charListMax,
	rect *rectList, int rectListMax, line *lineList, int lineListMax,
	line *stippleList, int stippleListMax)
{
    int i;

    /* print the characters this is for... */
    (void) fputs("/* data for ", f);
    for (i = 0; i < charListMax; i++) {
	if (i > 0) {
	    (void) putc(',', f);
	}
	(void) fputs(vis(charList[i]), f);
	(void) putc(' ', f);
    }
    (void) fputs("*/\n", f);

    (void) fprintf(f, "static charType chars%03d[] = {", charCount);
    for (i = 0; i < charListMax; i++) {
	(void) fprintf(f, "0%03o, ", (int) charList[i]);
    }
    (void) fprintf(f, "0};\n");

    if (rectListMax > 0) {
	(void) fprintf(f, "static rect rects%03d[] = {\n", charCount);
	for (i = 0; i < rectListMax; i++) {
	    (void) fprintf(f, "    {%d, %d, %d, %d, %d, %d, %d, %d},\n",
		    rectList[i].x1, rectList[i].x1Offset,
		    rectList[i].y1, rectList[i].y1Offset,
		    rectList[i].x2, rectList[i].x2Offset,
		    rectList[i].y2, rectList[i].y2Offset);
	}
	(void) fprintf(f, "};\n");
    }

    if (lineListMax > 0) {
	(void) fprintf(f, "static line lines%03d[] = {\n", charCount);
	for (i = 0; i < lineListMax; i++) {
	    (void) fprintf(f, "    {%d, %d, %d, %d, %d, %d, %d, %d, %d},\n",
		    lineList[i].x1, lineList[i].x1Offset,
		    lineList[i].y1, lineList[i].y1Offset,
		    lineList[i].x2, lineList[i].x2Offset,
		    lineList[i].y2, lineList[i].y2Offset,
		    lineList[i].width);
	}
	(void) fprintf(f, "};\n");
    }

    if (stippleListMax > 0) {
	(void) fprintf(f, "static line stipples%03d[] = {\n", charCount);
	for (i = 0; i < stippleListMax; i++) {
	    (void) fprintf(f, "    {%d, %d, %d, %d, %d, %d, %d, %d, %d},\n",
		    stippleList[i].x1, stippleList[i].x1Offset,
		    stippleList[i].y1, stippleList[i].y1Offset,
		    stippleList[i].x2, stippleList[i].x2Offset,
		    stippleList[i].y2, stippleList[i].y2Offset,
		    stippleList[i].width);
	}
	(void) fprintf(f, "};\n");
    }
    (void) fprintf(f, "\n");
}

static char *
vis(char val)
{
    char buffer[BUFSIZ];

    if (isprint((int)val)) {
	if (val == '^') {
	    (void) strncpy(buffer, "'^^'", BUFSIZ);
	} else if (val == '\\') {
	    (void) strncpy(buffer, "'\\\\'", BUFSIZ);
	} else if (val == '\'') {
	    (void) strncpy(buffer, "'\\\''", BUFSIZ);
	} else {
	    (void) snprintf(buffer, BUFSIZ, "'%c'", val);
	}
    } else if (iscntrl((int)val)) {
	(void) snprintf(buffer, BUFSIZ, "'^%c'", val);
    } else {
	(void) snprintf(buffer, BUFSIZ, "'\\%03o'", val);
    }

    return(strdup(buffer));
}