Import upstream version 5.3.

[mup] / mup / mkmupfnt / mkmupfnt.c

char Copyright[] =
	"Copyright (c) 1999, 2000 by Arkkra Enterprises\nAll rights reserved\n\n";

/* This program generates a Mup fontfile, that will let you override a
 * Mup font with one of your own. It is done in C rather than with
 * a "shell script" to be portable to systems without a Unix-like shell.
 * See the "usage_message" for how to invoke this program.
 * It creates a PostScript program to print each character in the font
 * and print out its width, height, and ascent.
 * It runs Ghostscript on that program.
 */

#ifdef __DJGPP__
#define __DOS__
#endif

#include <stdio.h>
#include <stdlib.h>
#include <fcntl.h>
#include <string.h>
#ifdef __DOS__
#include <process.h>
#else
#include <unistd.h>
#include <sys/types.h>
#include <sys/wait.h>
#endif

#ifdef O_BINARY
#define READ_FLAGS (O_RDONLY | O_BINARY)
#define WRITE_FLAGS (O_WRONLY | O_BINARY | O_CREAT | O_TRUNC)
#else
#define READ_FLAGS (O_RDONLY)
#define WRITE_FLAGS (O_WRONLY | O_CREAT | O_TRUNC)
#endif

/* temp file used for PostScript program */
char *PS_script_file = "mkmupfnt.ps";
#ifdef __DOS__
char *GS_output = "mkmupfnt.tmp";
#endif

char Version[] = "5.3";

void usage(char *program_name);
void verify_valid_Mup_name(char *Mup_name);
int name_matches(char *namelist[], char *name, int namelength);
void run_Ghostscript(char *PostScript_name, char *Mup_name);
char * make_string(char *first_part, char *second_part);
void generate_PostScript_program(char *PS_file);
void cleanup(int exitcode);

int
main(int argc, char **argv)
{
	char *PostScript_name;
	char *Mup_name;
	char *outfile;

	fprintf(stderr, "%s Version %s\n%s", argv[0], Version, Copyright);

	if (argc < 4 || argc > 5) {
		usage(argv[0]);
	}

	PostScript_name = argv[1];
	Mup_name = argv[2];
	outfile = argv[3];

	verify_valid_Mup_name(Mup_name);

	if ((freopen(outfile, "w", stdout)) == (FILE *) 0) {
		fprintf(stderr, "Can't open '%s'\n", outfile);
		exit(1);
	}

	/* Generate a PostScript program to run, and redirect that program
	 * into Ghostscript. */
	generate_PostScript_program(argc == 5 ? argv[4] : (char *) 0);
	if ((freopen(PS_script_file, "r", stdin)) == (FILE *) 0) {
		fprintf(stderr, "Can't open '%s'\n", PS_script_file);
		cleanup(1);
	}
	run_Ghostscript(PostScript_name, Mup_name);

	/* If there is a PostScript file to add to the output, copy that */
	if (argc == 5) {
		int file;
		int n;
		char buff[BUFSIZ];

		if ((file = open(argv[4], READ_FLAGS)) < 0) {
			fprintf(stderr, "Can't open '%s'\n", argv[4]);
			cleanup(1);
		}
		while ((n = read(file, buff, BUFSIZ)) > 0) {
			write(1, buff, n);
		}
		close(file);
	}

	cleanup(0);
	/* This line is not reached, since cleanup() exits,
	 * but some compilers complain if function doesn't have a
	 * return or exit, so the return is here to appease them. */
	return(0);
}


char *usage_message =
	"PostScript_font_name Mup_font_name outfile [file]\n\n"
	" Generates a fontfile for Mup to use, to override a Mup font.\n"
	" Arguments are:\n\n"
	"    PostScript_font_name   the name of the font you want to add to Mup,\n"
	"                                  like 'Helvetica-Narrow'\n\n"
	"    Mup_font_name          the name of the Mup font you want to replace,\n"
	"                                  like 'HR' or 'helvetica rom'\n\n"
	"    outfile                the generated Mup fontfile\n\n"
	"    file                   can contain PostScript to be added to Mup prolog,\n"
	"                                  if needed to use the font.\n";

void
usage(char *program_name)
{
	fprintf(stderr, "usage: %s %s", program_name, usage_message);
	exit(1);
}

/* verify Mup font name is a valid one, give error and exit if not */

char *family_names[] = {
	"avantegarde",
	"bookman",
	"courier",
	"helvetica",
	"newcentury",
	"palatino",
	"times",
	(char *) 0
};

char *font_names[] = {
	"rom",
	"bold",
	"ital",
	"boldital",
	(char *) 0
};

void
verify_valid_Mup_name(char *Mup_name)
{
	char *space_loc;

	if (strlen(Mup_name) == 2 && strchr("ABCHNPT", Mup_name[0])
					&& strchr("RBIX", Mup_name[1]) ) {
		/* name is okay, an abbreviated name */
		return;
	}

	/* check long names */
	if ((space_loc = strchr(Mup_name, ' ')) != 0 &&
		name_matches(family_names, Mup_name, space_loc - Mup_name) &&
		name_matches(font_names, space_loc + 1, strlen(space_loc + 1))) {
		return;
	}

	fprintf(stderr, "'%s' is not a valid Mup font name\n", Mup_name);
	exit(1);
}

/* verify name given matches one on the list of valid names */

int
name_matches(char *namelist[], char *name, int namelength)
{
	int i;

	for (i = 0; namelist[i] != (char *) 0; i++) {
		if (strncmp(namelist[i], name, namelength) == 0 &&
					namelength == strlen(namelist[i])) {
			/* matches */
			return(1);
		}
	}
	return(0);
}

/* Run Ghostscript to write width/ascent/descent information for all
 * characters. */

void
run_Ghostscript(char *PostScript_name, char *Mup_name)
{
	char *	PS_option;
	char *	Mup_option;
#ifdef __DOS__
	char *	output_option;
	int	ret;
#endif
	int status;

	/* pass the arguments on to Ghostscript */
	PS_option = make_string("-sPostScript_name=", PostScript_name);
	Mup_option = make_string("-sMup_name=", Mup_name);
#ifdef __DOS__
	/* use temp file as a /dev/null */
	output_option = make_string("-sOutputFile=", GS_output);

	if ((ret = spawnlp(P_WAIT, "gs386", "gs386", "-sDEVICE=bit",
				"-dQUIET", output_option, Mup_option,
				PS_option, "-", (char *) 0)) != 0) {
		/* try just plain 'gs' */
		ret = spawnlp(P_WAIT, "gs", "gs", "-sDEVICE=bit",
				"-dQUIET", output_option, Mup_option,
				PS_option, "-", (char *) 0);
	}
	unlink(GS_output);
	if (ret != 0) {
		fprintf(stderr, "failed to execute gs\n");
		cleanup(1);
	}
#else
	switch (fork()) {
	case 0:
		execlp("gs", "gs", "-sDEVICE=bit", "-dQUIET",
			"-sOutputFile=/dev/null", Mup_option,
			PS_option, "-", (char *) 0);
		/* FALL THROUGH */
	case -1:
		fprintf(stderr, "failed to execute gs\n");
		cleanup(1);
	default:
		wait( &status);
		if (status != 0) {
			fprintf(stderr, "Ghostscript failed\n");
			cleanup(1);
		}
	}
#endif
}

/* given two strings, get enough space to concatenate them,
 * write them into the malloc-ed string, and return it. */

char *
make_string(char *first_part, char *second_part)
{
	char *new_string;

	if ((new_string = (char *) malloc(strlen(first_part)
					+ strlen(second_part) + 1)) == 0) {
		fprintf(stderr, "malloc failed\n");
		cleanup(1);
	}
	sprintf(new_string, "%s%s", first_part, second_part);
	return(new_string);
}

/* This is the PostScript program that actually extracts the
 * font size information. It is included here and generated as needed,
 * so that this can be a standalone program, and not have to search
 * for another file in order to run. In Unix, we could just pipe this
 * directly into Ghostscript, but on systems that don't have pipes,
 * a temp file would need to be used, so we do it that way everywhere
 * for consistency.
 */

char *PostScript_program =
"%% This PostScript program generates a fontfile for use by Mup.\n"
"% PostScript_name and Mup_name must be defined as strings\n"
"% when this is called.\n"
"% PostScript_name is the font you want to add to Mup, while\n"
"% Mup_name is name of the Mup font you want to replace.\n"
"% So, for example, if you want to replace the Mup Helvetica roman\n"
"% font with the PostScript Helvetica-Narrow font, these strings would be\n"
"% (Helvetica-Narrow) and (helvetica rom).\n"
"% These can be passed in using the Ghostscript -s option.\n"
"\n"
"1 setflat		% make bounding box very accurate\n"
"\n"
"/buff 50 string def	% number to string conversion buffer\n"
"/character 1 string def	% buffer for a character to get the bbox of\n"
"\n"
"%------------------------------------------------------------------\n"
"\n"
"\n"
"% Usage\n"
"%	given a one-character string in \"character\",\n"
"%	outputs its width in 1/1000ths of an inch\n"
"\n"
"/getwidth {\n"
"	% get width of character\n"
"	character stringwidth\n"
"\n"
"	% convert x to 1/1000th of an inch\n"
"	pop 1000 mul 72 div round cvi\n"
"\n"
"	% print results\n"
"	buff cvs (\\t) print print\n"
"} def\n"
"\n"
"%-----------------------------------\n"
"% Usage\n"
"%	given a one-character string in \"character\",\n"
"%	outputs its height in 1/1000ths of an inch\n"
"\n"
"/getheight {\n"
"	% place character at (100, 100) and get its pathbbox\n"
"	newpath\n"
"	100 100 moveto\n"
"	character true charpath flattenpath pathbbox\n"
"\n"
"	% save the top and bottom y coordinates of the bbox\n"
"	/top exch def pop\n"
"	/bot exch def pop\n"
"\n"
"	% if bot is above the baseline, the height is (top - baseline)\n"
"	 % otherwise it is (top - bot)\n"
"	bot 100 gt { top 100 sub } { top bot sub } ifelse\n"
"\n"
"	% space is special, use 9 points for height\n"
"	character ( ) eq { 9 add } if\n"
"\n"
"	% add 2 point of padding, one for top and one for bottom white space,\n"
"	% and convert to 1/1000ths of an inch\n"
"	2 add 1000 mul 72 div round cvi\n"
"\n"
"	% print the results\n"
"	buff cvs (\\t) print print\n"
"} def\n"
"\n"
"%----------------------------------\n"
"% Usage\n"
"%	given a one-character string in \"character\",\n"
"%	outputs its ascent in 1/1000ths of an inch\n"
"\n"
"/getascent {\n"
"	% place character at (100, 100) and get its pathbbox\n"
"	newpath\n"
"	100 100 moveto\n"
"	character true charpath flattenpath pathbbox\n"
"\n"
"	% save the top y coordinate of the bbox\n"
"	/top exch def pop pop pop\n"
"\n"
"	% ascent is top minus baseline\n"
"	top 100 sub\n"
"\n"
"	% space is special, use 6.8 points for ascent\n"
"	character ( ) eq { 6.8 add } if\n"
"\n"
"	% add 1 point of padding and convert to 1/1000ths of an inch\n"
"	1 add 1000 mul 72 div round cvi\n"
"\n"
"	% print results\n"
"	buff cvs (\\t) print print\n"
"} def\n"
"\n"
"\n"
"%-----------------------------------\n"
"\n"
"% generate width, height an ascent for a font.\n"
"% Usage:\n"
"%	fname mupfname do_a_font\n"
"\n"
"/do_a_font {\n"
"	% save arguments for later use\n"
"	/mupfname exch def\n"
"	/fname exch def\n"
"\n"
"	% Outut heading\n"
"	(# This is a Mup font file\\n) print\n"
"	(Mup font name: ) print mupfname print (\\n) print\n"
"	(PostScript font name: ) print fname buff cvs print (\\n) print\n"
"	(Size data:\\n) print\n"
"\n"
"	% Set up to use the desired font\n"
"	fname findfont\n"
"	12 scalefont setfont\n"
"\n"
"	% Mup uses ASCII character codes from 32 through 126\n"
"	32 1 126 {\n"
"		dup buff cvs print\n"
"		/val exch def character 0 val put\n"
"		getwidth\n"
"		getheight\n"
"		getascent\n"
"		(\\t# ') print character print ('\\n) print\n"
"	} for\n"
"\n"
"	(PostScript:\\n) print\n"
"} def\n"
"\n"
"%-----------------------------------\n"
"\n"
"% generate the output\n"
"PostScript_name cvn Mup_name do_a_font\n"
"\n"
"quit\n";

void
generate_PostScript_program(char *PS_file)
{
	int file;
	int length;

	if ((file = open(PS_script_file, WRITE_FLAGS, 0644)) < 0) {
		fprintf(stderr, "Can't generate '%s'\n", PS_script_file);
		exit(1);
	}

	/* If user gave a PostScript file, that probably implements the
	 * font, so include that in the script */
	if (PS_file != (char *) 0) {
		write(file, "(", 1);
		write(file, PS_file, strlen(PS_file));
		write(file, ") run\n", 6);
	}

	length = strlen(PostScript_program);
	if (write(file, PostScript_program, length) != length) {
		fprintf(stderr, "generation of PostScript program failed\n");
		cleanup(1);
	}
	close(file);
}

/* remove the temp file and exit */
 
void
cleanup(int exitcode)
{
	unlink(PS_script_file);
	exit(exitcode);
}