wnp@killer.Dallas.TX.US (Wolf Paul) (03/27/89)
Newsgroups: comp.sources.unix
Subject: v15i047: Tools for nroff graphics on dot-matrix printers, Part02/02
Message-ID: <912@fig.bbn.com>
Date: 7 Jun 88 18:30:46 GMT
Lines: 1221
Approved: rsalz@uunet.UU.NET
Submitted-by: snark!eric (Eric Raymond)
Posting-number: Volume 15, Issue 47
Archive-name: nroffgraphics/part02
#! /bin/sh
# This is a shell archive. Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file". To overwrite existing
# files, type "sh file -c". You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g.. If this archive is complete, you
# will see the following message at the end:
# "End of archive 2 (of 2)."
# Contents: dotmatrix.c mx80.pix
# Wrapped by rsalz@fig.bbn.com on Tue Jun 7 14:26:53 1988
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'dotmatrix.c' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'dotmatrix.c'\"
else
echo shar: Extracting \"'dotmatrix.c'\" \(14559 characters\)
sed "s/^X//" >'dotmatrix.c' <<'END_OF_FILE'
X/*
X * dotmatrix.c -- make driver & postprocessor tables for dot-matrix printers
X *
X * This code brought to you as a public service by Eric S. Raymond, Feb 1988
X * and is copyrighted (c)1988 by the author. Use, distribute, and mangle
X * freely, but don't try to make money selling it unless you're going to send
X * me a cut. Send bug reports, love letters and death threats to eric@snark
X * aka ...!rutgers!vu-vlsi!snark!eric.
X */
X/*LINTLIBRARY*/ /* this suppresses some bogus messages about _iob */
X#include <stdio.h>
X#include <ctype.h>
X
Xextern char *strcpy(), *strchr();
X
X#define TRUE 1
X#define FALSE 0
X
X/*
X * General equates. Note that this code has insidious ASCII dependencies all
X * through it (in particular, it counts on being able to step through all the
X * normal printables by starting at <sp>). EBCDIC sites can eat flaming death
X * for all I care. Have a nice day.
X */
X#define MAXGLEN 64 /* maximum width of a graphic in bits */
X#define CDEPTH 24 /* MX80 graphics are 8 bits deep */
X#define NAMSIZE 10 /* maximum size of character names */
X#define STAR '*' /* bit-on character for picture files */
X#define SI 0x17 /* ASCII SI starts a graphics escape */
X#define SO 0x16 /* ASCII SO ends a graphics escape */
X#define FNS 15 /* maximum size of a local filename + 1 */
X#define MAXLINE 80 /* maximum size of an input line */
X#define MAXMODE 10 /* maximum number of print modes supported */
X
Xtypedef struct
X{
X char name[NAMSIZE]; /* the mode name */
X int width; /* dot-matrix elements per character width */
X int height; /* height of chars in this mode */
X char fmt[NAMSIZE]; /* format string for graphics emission */
X}
Xmode_t;
X
Xstatic mode_t modes[MAXMODE]; /* printer mode table */
Xstatic mode_t *maxmode = &modes[0]; /* next free mode slot */
X
Xstatic char dtabfile[FNS] = "tab.mx80"; /* driver table source */
Xstatic FILE *dtabfp; /* dtabfile open for output */
X
Xstatic char postproto[FNS] = "post.proto"; /* postprocessor template */
Xstatic FILE *protofp; /* postproto open for input */
X
Xstatic char postcode[FNS] = "mx80.c"; /* result postprocessor */
Xstatic FILE *postfp; /* postcode open for output */
X
Xstatic char testfile[FNS] = "mx80.test"; /* result test file */
Xstatic FILE *testfp; /* testfile open for output */
X
X/* miscellaneous globals */
Xstatic char line[MAXLINE]; /* buffer for line processing */
Xstatic char comment[MAXLINE]; /* description of the type */
Xstatic char *ptype = "mx80"; /* device type we're customizing for */
Xstatic int trigger = ' '; /* trigger character for postprocessor */
Xstatic int verbose = FALSE; /* debugging flag */
Xstatic int quiet = FALSE; /* if true, suppress stdout msgs */
Xstatic int testflag = TRUE; /* test file creation flag */
Xstatic int postflag = TRUE; /* postprocessor creation flag */
Xstatic int dtabflag = TRUE; /* driver table creation flag */
Xstatic int forcepost = FALSE; /* set true to suppress optimization */
Xstatic int errline = 0; /* count of input lines processed */
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X void transpix(), exit();
X int c;
X extern int optind;
X
X while ((c = getopt(argc, argv, "nvtpdq")) != EOF)
X {
X switch(c)
X {
X case 'n': /* don't try to emit printer controls from the table */
X forcepost = TRUE;
X break;
X
X case 'v': /* be verbose when parsing the picture file */
X verbose = TRUE;
X break;
X
X case 'q': /* suppress normal messages to stdout */
X quiet = TRUE;
X break;
X
X case 't': /* suppress test file creation */
X testflag = FALSE;
X break;
X
X case 'p': /* suppress postprocessor file creation */
X postflag = FALSE;
X break;
X
X case 'd': /* suppress driver table creation */
X dtabflag = FALSE;
X break;
X }
X }
X
X /* if the user gave a name, rename all files */
X if (optind < argc)
X {
X ptype = argv[optind];
X (void) sprintf(dtabfile, "tab%s.c", ptype);
X (void) sprintf(postcode, "%s.c", ptype);
X (void) sprintf(testfile, "%s.test", ptype);
X }
X
X /* open the postprocessor prototype if we're to create one */
X if (postflag && (protofp = fopen(postproto, "r")) == NULL)
X {
X (void) fprintf(stderr, "dotmatrix: can't open %s file!\n", postproto);
X exit(2);
X }
X
X /* open the postprocessor output if we're to generate one */
X if (postflag && (postfp = fopen(postcode, "w")) == NULL)
X {
X (void) fprintf(stderr, "dotmatrix: can't open %s file!\n", postcode);
X exit(2);
X }
X
X /* open the postprocessor output if we're to generate one */
X if (postflag && (postfp = fopen(postcode, "w")) == NULL)
X {
X (void) fprintf(stderr, "dotmatrix: can't open %s file!\n", postcode);
X exit(2);
X }
X
X /* open the driver file output if we're to create one */
X if (dtabflag && (dtabfp = fopen(dtabfile, "w")) == NULL)
X {
X (void) fprintf(stderr, "dotmatrix: can't open %s file!\n", dtabfile);
X exit(2);
X }
X
X /* open the test file output if we're to create one */
X if (testflag && (testfp = fopen(testfile, "w")) == NULL)
X {
X (void) fprintf(stderr, "dotmatrix: can't open %s file!\n", testfile);
X exit(2);
X }
X else if (testflag)
X (void) fprintf(testfp,
X ".\\\" %s -- special character test file\n", testfile);
X
X /* here's where we parse the picture file */
X if (postflag || dtabflag || testflag)
X {
X if (postflag)
X (void) fprintf(postfp,
X "/* %s -- postprocessor for %s */\n",
X postcode, dtabfile);
X
X while (fgets(line, sizeof(line), protofp) != NULL)
X if (strncmp(line, "$A", 2) == 0)
X {
X transpix();
X if (postflag)
X (void) fprintf(postfp, "#define MAXSPCH\t0%03o\n",trigger);
X }
X else
X (void) fputs(line, postfp);
X
X if (postflag)
X (void) fprintf(postfp, "/* %s ends here */\n", postcode);
X }
X
X /* if we are generating a test file, add a completeness indication */
X if (testflag)
X {
X (void) fprintf(testfp,".\\\" %s ends here\n", testfile);
X (void) fclose(testfp);
X }
X return(0);
X}
X
Xstatic void transpix()
X/* read and translate a picture file from stdin */
X{
X void readpic(), enter(), makemode(), makeover();
X char tgon[MAXGLEN], tgoff[MAXGLEN], *sp;
X char name[NAMSIZE];
X int pass = 1;
X
X for (;;)
X {
X /* read in a line to parse */
X if (gets(line) == NULL)
X return;
X else
X errline++;
X
X if (verbose)
X (void) fprintf(stdout, "%s\n", line);
X
X comment[0] = 0;
X
X /* copy out the comment if there is one */
X if ((sp = strchr(line, '#')) != NULL)
X {
X (void) strcpy(comment, sp + 1);
X while (isspace(*sp) || *sp == '#')
X sp--;
X *++sp = 0;
X }
X
X /* here's where we check for the end of the passthrough section */
X if (pass)
X {
X if (strcmp(line, "charset") == 0)
X pass = 0;
X (void) fprintf(dtabfp, "%s\n", line);
X continue;
X }
X
X /* after charset, if the line is blank ignore it */
X else if (strspn(line, "\t ") == strlen(line))
X continue;
X
X /* interpret 'comment' directives */
X if (strncmp("comment ", line, 8) == 0)
X {
X if (postflag)
X (void) fprintf(postfp, "/* %s */\n", line + 8);
X continue;
X }
X
X /* interpret 'mode' directives */
X if (strncmp("mode ", line, 5) == 0)
X {
X makemode(line);
X continue;
X }
X
X /* interpret 'toggle' directives */
X if (sscanf(line, "toggle %s \"%[^\"]\" \"%[^\"]\"", name, tgon, tgoff))
X {
X /* interpret escape sequences including \000 */
X int tgonl = escape(tgon, tgon);
X int tgoffl = escape(tgoff, tgoff);
X
X /* Name Width Tstate Size Data */
X enter(name, 0, 0, tgonl, tgon);
X enter(name, 0, 1, tgoffl, tgoff);
X
X /* now we may need to generate a test file line */
X if (testflag)
X (void) fprintf(testfp,
X "This is a test of the %s\\%s%s toggle\n.br\n",
X name, name, name);
X
X continue;
X }
X
X /* interpret 'picture' sections */
X if (strncmp("picture ", line, 8) == 0)
X {
X readpic();
X continue;
X }
X
X /* interpret 'test' directives */
X if (strncmp("test ", line, 5) == 0 && testflag)
X {
X (void) fprintf(testfp, "%s\n.br\n", line + 5);
X continue;
X }
X
X /* interpret 'overstrike ' directives */
X if (strncmp("overstrike ", line, 11) == 0)
X {
X makeover(line);
X continue;
X }
X
X /* else there's garbage on the line */
X (void) fprintf(stderr,
X "dotmatrix: unknown command, line %d\n", errline);
X exit(1);
X }
X}
X
Xstatic void makemode(mline)
X/* process a printer mode declaration */
Xchar *mline;
X{
X if (maxmode >= modes + MAXMODE - 1)
X {
X (void) fprintf(stderr, "dotmatrix: too many print modes\n");
X exit(1);
X }
X
X if (sscanf(mline, "mode %s %d %d \"%[^\"]\"",
X maxmode->name, &maxmode->width, &maxmode->height, maxmode->fmt)
X != 4)
X (void) fprintf(stderr, "dotmatrix: invalid mode line ignored\n");
X else if (maxmode->height > CDEPTH)
X (void) fprintf(stderr, "dotmatrix: height must be < %d\n", CDEPTH);
X else
X {
X (void) escape(maxmode->fmt, maxmode->fmt);
X maxmode++;
X }
X}
X
Xstatic void makeover(oline)
X/* interpret an overstrike directive */
Xchar *oline;
X{
X char name[NAMSIZE], value[MAXGLEN];
X int fc;
X
X if ((fc = sscanf(oline, "overstrike %s %s", name, value)) != 2)
X {
X (void) fprintf(stderr,
X "dotmatrix: overstrike directive invalid, %d arguments found\n",
X fc);
X exit(1);
X }
X else
X {
X (void) escape(value, value);
X enter(name, 0, 2, 1, value);
X
X /* now we may need to generate a test file line */
X if (testflag)
X (void) fprintf(testfp,
X "%sThis is a test%s of the \\%s overstrike\n.br\n",
X name, name, name);
X }
X}
X
Xstatic void readpic()
X/* process a single picture file entry */
X{
X char name[NAMSIZE]; /* nroff name of the graphic */
X int width = 1; /* the graphic width */
X char type[NAMSIZE]; /* type of the graphic (optional) */
X char value[MAXGLEN + NAMSIZE]; /* what we'll send */
X char graphic[MAXGLEN][CDEPTH]; /* where we'll read in the pattern */
X int lrow[CDEPTH]; /* the row lengths */
X int row, i, cwidth; /* scratch variables */
X char *sp, *tp; /* scratch variables */
X mode_t *mode; /* print mode selector */
X
X /* scan the header line */
X if (sscanf(line, "picture %s %d %s", name, &width, type) != 3)
X {
X (void) fprintf(stderr,
X "dotmatrix: invalid picture directive: %s\n", line);
X exit(1);
X }
X
X /* identify the print mode */
X for (mode = modes; mode <= maxmode; mode++)
X if (strcmp(type, mode->name) == 0)
X break;
X if (mode == maxmode)
X {
X (void) fprintf(stderr,
X "dotmatrix: %s is not a declared print mode, picture ignored\n",
X type);
X return;
X }
X
X /* next read in the pattern bits */
X for (row = 0; row < mode->height; row++)
X {
X if (fgets(graphic[row], MAXGLEN, stdin) == NULL)
X {
X (void) fprintf(stderr,
X "dotmatrix: ran out of graphic lines in %s\n",
X name);
X exit(1);
X }
X else if (verbose)
X (void) fprintf(stderr, "row %d: %s", row, graphic[row]);
X }
X
X /* emit the pattern strings if we're generating a postprocessor */
X if (postflag)
X {
X /* now interpret special escape */
X tp = value;
X cwidth = 0;
X for (sp = mode->fmt; *sp; sp++)
X {
X if (*sp != '%')
X {
X *tp++ = *sp;
X cwidth++;
X }
X else switch (*++sp)
X {
X case '%':
X *tp++ = '%';
X cwidth++;
X break;
X case 'h':
X *tp++ = ((width * mode->width) / 256);
X cwidth++;
X break;
X case 'l':
X *tp++ = (width * mode->width) % 256;
X cwidth++;
X break;
X case 'c':
X /* compute the row lengths */
X for (i = 0; i < mode->height; i++)
X lrow[i] = strlen(graphic[i]);
X
X /* now compute and emit Epson-flavored graphics bits */
X for (i = 0; i < width * mode->width; i++)
X {
X *tp++
X = (lrow[7] > i && graphic[7][i] == STAR) * 1
X + (lrow[6] > i && graphic[6][i] == STAR) * 2
X + (lrow[5] > i && graphic[5][i] == STAR) * 4
X + (lrow[4] > i && graphic[4][i] == STAR) * 8
X + (lrow[3] > i && graphic[3][i] == STAR) * 16
X + (lrow[2] > i && graphic[2][i] == STAR) * 32
X + (lrow[1] > i && graphic[1][i] == STAR) * 64
X + (lrow[0] > i && graphic[0][i] == STAR) * 128;
X }
X cwidth += width * mode->width;
X break;
X default:
X (void) fprintf(stderr,
X "dotmatrix: invalid escape in mode declaration\n");
X exit(1);
X break;
X }
X }
X enter(name, width, -1, cwidth, value);
X }
X
X /* now we may need to generate a test file line */
X if (testflag)
X (void) fprintf(testfp, "\\%s |%s| %s\n.br\n", name, name, comment);
X}
X
Xstatic void enter(name, width, tstate, len, bytes)
X/* generate a postprocessor table entry */
Xchar *name; /* name of the entry */
Xint width; /* its nroff width */
Xint tstate; /* the toggle state entry */
Xint len; /* number of data bytes in entry */
Xchar *bytes; /* data bytes to emit */
X{
X register int i;
X int funnycount = 0;
X char bbuf[MAXGLEN * 5 + 1];
X
X if (tstate != -1) /* force toggles to be done in the postprocessor */
X funnycount = 1;
X else
X /* test to see if the data contains nulls or plot-mode triggers */
X for (i = 0; i < len; i++)
X if (bytes[i] == 0 || (bytes[i] & 0200))
X funnycount++;
X
X /* if there are none, embed the sequence in the driver table */
X if (funnycount == 0 && !forcepost)
X {
X if (dtabflag)
X {
X char *np = name;
X
X if (np[0] == '\\' && np[1] == '(')
X np += 2;
X
X (void) expand(bytes, bbuf);
X (void) fprintf(dtabfp, "%s %d %s\n", np, width, bbuf);
X if (!quiet || verbose)
X (void) fprintf(stdout,
X "%s will be handled by the driver table\n", name);
X }
X return;
X }
X
X /* if we're generating a postprocessor, write the entry */
X if (postflag)
X {
X char *ttype = "";
X
X if (tstate == 0)
X ttype = " on ";
X else if (tstate == 1)
X ttype = " off";
X
X (void) fprintf(postfp,
X "/* %s%s */ {%d, %d, ", name, ttype, tstate, len);
X
X for (i = 0; i < len; i++)
X (void) fprintf(postfp, "0x%02x,", bytes[i] & 0xff);
X
X (void) fprintf(postfp, "},\n");
X }
X
X /* update the special character count and generate a driver change */
X if (tstate == 1) /* a toggle end string doesn't get its own entry, */
X trigger++; /* but must skip a postprocessor table slot */
X else /* a graphic or the start string of a toggle */
X {
X if (!forcepost && (!quiet || verbose))
X (void) fprintf(stdout,
X "%s will require postprocessor assistance\n",
X name);
X
X if (dtabflag)
X {
X char *np = name;
X
X if (np[0] == '\\' && np[1] == '(')
X np += 2;
X
X if (isprint(trigger) && trigger != '\\' && trigger != ' ')
X (void) fprintf(dtabfp, "%s %d \\%03.3o%c\\%03.3o\n",
X np, width, SI, trigger++, SO);
X else
X (void) fprintf(dtabfp, "%s %d \\%03.3o\\%03.3o\\%03.3o\n",
X np, width, SI, trigger++, SO);
X }
X }
X}
X
X/* dotmatrix.c ends here */
END_OF_FILE
if test 14559 -ne `wc -c <'dotmatrix.c'`; then
echo shar: \"'dotmatrix.c'\" unpacked with wrong size!
fi
# end of 'dotmatrix.c'
fi
if test -f 'mx80.pix' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'mx80.pix'\"
else
echo shar: Extracting \"'mx80.pix'\" \(7360 characters\)
sed "s/^X//" >'mx80.pix' <<'END_OF_FILE'
X# nroff driver table and postprocessor-generation data for Epson MX80
Xmx80
X# nroff/troff motion parameters
Xbset 0 # bits to set in c_oflag
Xbreset 0 # bits to reset in c_oflag
XHor 24 # horizontal grain (1/10th in.)
XVert 20 # vertical grain (1/12th in.)
XNewline 40 # 6 lines-per-inch
XChar 24 # 10 chars-per-inch
XEm 24 # an em is one character width
XHalfline 20 # a half-line width is a twelfth of an inch
XAdj 24 # the adjustment unit is an em
X#
X# MX80 highlight strings
Xtwinit "\033@" # printer initialization
Xtwrest "\033@" # printer reset
Xtwnl "\n" # newline & clear-highlight string
Xhlr "\0338" # move half-line up (col convention)
Xhlf "\0339" # move half-line down (col convention)
Xflr "\0337" # move full line up (col convention)
Xbdon "\033E" # turn bold on
Xbdoff "\033F" # turn bold off
Xiton "\033>" # turn italic on
Xitoff "\033=" # turn italic off
Xploton "" # plot mode on (not supported)
Xplotoff "" # plot mode off (not supported)
Xup "" # plot mode move up (not supported)
Xdown "" # plot mode move down (not supported)
Xright "" # plot mode move right (not supported)
Xleft "" # plot mode move left (not supported)
X
Xcharset
Xcomment This font implements most of the standard nroff graphics for the Epson
Xcomment MX80 and compatibles. Some of what would be greek-alphabet characters
Xcomment have been stolen for use as Epson highlight toggles; if you have new
Xcomment nroff, you can rename these to whatever you like and restore the orig-
Xcomment inal loadings. Composed by Eric S. Raymond, Feb 1988.
X# define Epson-compatible modes
Xmode single 6 8 "\eK%l%h%c" # 60 dpi
Xmode double 12 8 "\eL%l%h%c" # 120 dpi
Xmode triple 12 8 "\eY%l%h%c" # 120dpi at double speed (Not presently used)
Xmode quad 24 8 "\eZ%l%h%c" # 240dpi (Not presently used)
X# The following modes are good on the Star Micronics NX10 only
Xmode crt1 8 8 "\e*\004%l%h%c" # 80 dpi (Not presently used)
Xmode plotter 8 8 "\e*\005%l%h%c" # 72 dpi (Not presently used)
Xmode crt2 9 8 "\e*\006%l%h%c" # 90 dpi (Not presently used)
X# define start/end sequences for extra Epson highlights
Xtoggle \(*w "\eW\001" "\eW\000" # toggle double width
Xtoggle \(*g "\eG" "\eH" # toggle double strike
Xtoggle \(*s "\eS\000" "\eT" # toggle superscript
Xtoggle \(*r "\eS\001" "\eT" # toggle subscript
X#
X# define the slashout toggle
Xoverstrike \(*x /
Xoverstrike \(*u _
X#
X# tests for the two normal highlights
Xtest This is a \fBboldface\fR test
Xtest This is an \fIitalics\fR test
X
Xpicture \(sq 1 single 6 # square
X
X******
X* *
X* *
X* *
X* *
X******
X
Xpicture \(bu 1 single 6 # bullet
X
X **
X ****
X******
X******
X******
X ****
X **
Xpicture \(de 1 single 6 # degree
X *
X * *
X *
X
X
X
X
X
Xpicture \(dg 1 single 6 # dagger
X
X *
X *
X *****
X *
X *
X *
X *
Xpicture \(sc 1 single 6 # section-mark
X **
X * *
X **
X * *
X * *
X **
X * *
X **
Xpicture \(aa 1 single 6 # acute-accent
X *
X *
X
X
X
X
X
X
Xpicture \(ga 1 single 6 # grave-accent
X *
X *
X
X
X
X
X
X
Xpicture \(*a 1 single 6 # alpha
X
X
X
X *** *
X* *
X* *
X* *
X *** *
Xpicture \(*b 1 single 6 # beta
X ****
X* *
X* *
X*****
X* *
X* *
X*****
X*
Xpicture \(*d 1 single 6 # delta
X ****
X* *
X* *
X*
X ****
X* *
X* *
X ****
Xpicture \(*e 1 single 6 # epsilon
X
X ****
X *
X*
X******
X*
X *
X ****
Xpicture \(*p 1 single 6 # pi
X
X
X
X******
X * *
X * *
X * *
X * *
Xpicture \(*G 1 single 6 # cap-gamma
X
X *****
X * *
X *
X *
X *
X *
X***
Xpicture \(*H 1 single 6 # cap-theta
X **
X * *
X* *
X* *
X******
X* *
X * *
X **
Xpicture \(*C 1 single 6 # cap-xi
X
X******
X
X
X ****
X
X
X******
Xpicture \(*P 1 single 6 # cap-pi
X******
X * *
X * *
X * *
X * *
X * *
X * *
X** **
Xpicture \(*S 1 single 6 # cap-sigma
X******
X* *
X *
X *
X *
X *
X* *
X******
Xpicture \(*F 1 single 6 # cap-phi
X ****
X **
X ****
X* ** *
X* ** *
X ****
X **
X ****
Xpicture \(*W 1 single 6 # cap-omega
X ****
X* *
X* *
X* *
X* *
X* *
X * *
X** **
Xpicture \(ts 1 single 6 # terminal-sigma
X
X
X ***
X* *
X*
X ***
X *
X *
Xpicture \(>= 1 single 6 # greater-than
X *
X *
X *
X *
X *
X *
X *
X ****
Xpicture \(<= 1 single 6 # less-than
X *
X *
X *
X *
X *
X *
X *
X ****
Xpicture \(== 1 single 6 # identity
X
X
X******
X
X******
X
X******
X
Xpicture \(~= 1 single 6 # approximately-equals
X
X ** *
X* **
X
X******
X
X******
X
Xpicture \(-> 1 single 6 # right-arrow
X
X *
X *
X******
X *
X *
X
X
Xpicture \(<- 1 single 6 # left-arrow
X
X *
X *
X******
X *
X *
X
X
Xpicture \(ua 1 single 6 # up-arrow
X *
X ***
X * * *
X *
X *
X *
X *
X *
Xpicture \(da 1 single 6 # down-arrow
X *
X *
X *
X *
X *
X * * *
X ***
X *
Xpicture \(mu 1 single 6 # multiply-sign
X
X* *
X * *
X **
X **
X * *
X* *
X
Xpicture \(di 1 single 6 # divide-sign
X
X
X *
X*****
X *
X
X
X
Xpicture \(+- 1 single 6 # plus-or-minus
X
X *
X *
X*****
X *
X *
X*****
X
Xpicture \(cu 1 single 6 # union (cup)
X
X* *
X* *
X* *
X* *
X* *
X ****
X
Xpicture \(ca 1 single 6 # intersection (cap)
X
X ****
X* *
X* *
X* *
X* *
X* *
X
Xpicture \(sb 1 single 6 # subset
X
X
X *****
X*
X*
X*
X *****
X
Xpicture \(sp 1 single 6 # superset
X
X
X*****
X *
X *
X *
X*****
X
Xpicture \(ib 1 single 6 # improper-subset
X
X *****
X*
X*
X*
X *****
X
X******
Xpicture \(ip 1 single 6 # improper-superset
X
X*****
X *
X *
X *
X*****
X
X******
Xpicture \(if 1 single 6 # infinity
X
X
X ** *
X* * *
X* * *
X ** *
X
X
Xpicture \(pd 1 single 6 # partial-derivative
X
X ***
X * *
X *
X ****
X * *
X * *
X ***
Xpicture \(no 1 single 6 # not-sign
X
X
X
X *****
X *
X
X
X
Xpicture \(is 1 single 6 # integral
X *
X * *
X *
X *
X *
X *
X* *
X *
Xpicture \(pt 1 single 6 # proportional-to
X
X
X ** **
X* *
X* *
X ** **
X
X
Xpicture \(es 1 single 6 # empty-set
X
X ** *
X * *
X* * *
X* * *
X * *
X* **
X
Xpicture \(mo 1 single 6 # member-of
X
X
X *****
X*
X******
X*
X *****
X
Xpicture \(rg 1 single 6 # registration-mark
X ****
X* *
X*** *
X** * *
X*** *
X** * *
X* *
X ****
Xpicture \(co 1 single 6 # copyright
X ****
X* *
X* ** *
X** *
X** *
X* ** *
X* *
X ****
Xpicture \(br 1 single 6 # box-rule
X *
X *
X *
X *
X *
X *
X *
X *
Xpicture \(ct 1 single 6 # cent-sign
X
X *
X *****
X* *
X* *
X* *
X *****
X *
Xpicture \(dd 1 single 6 # double-dagger
X
X *
X *****
X *
X *
X *
X *****
X *
Xpicture \(lh 1 single 6 # left-hand
X
X
X**** *
X *****
X ****
X ** *
X
X
Xpicture \(rh 1 single 6 # right-hand
X
X
X* ****
X*****
X****
X* **
X
X
Xpicture \(ci 1 single 6 # circle
X
X **
X * *
X* *
X* *
X* *
X * *
X **
Xpicture \(lt 1 single 6 # curly-left-top
X **
X ***
X **
X **
X **
X **
X **
X **
Xpicture \(lb 1 single 6 # curly-left-bottom
X **
X **
X **
X **
X **
X **
X ***
X **
Xpicture \(rt 1 single 6 # curly-right-top
X **
X ***
X **
X **
X **
X **
X **
X **
Xpicture \(rb 1 single 6 # curly-right-bottom
X **
X **
X **
X **
X **
X **
X ***
X **
Xpicture \(lk 1 single 6 # curly-left-center
X **
X **
X **
X **
X **
X **
X **
X **
Xpicture \(rk 1 single 6 # curly-right-center
X **
X **
X **
X **
X **
X **
X **
X **
Xpicture \(bv 1 single 6 # bold-vertical-rule
X **
X **
X **
X **
X **
X **
X **
X **
Xpicture \(lf 1 single 6 # left-bottom-bracket
X **
X **
X **
X **
X **
X **
X **
X ****
Xpicture \(rf 1 single 6 # right-bottom-bracket
X **
X **
X **
X **
X **
X **
X **
X****
Xpicture \(lc 1 single 6 # left-top-bracket
X ****
X **
X **
X **
X **
X **
X **
X **
Xpicture \(rc 1 single 6 # right-top-bracket
X****
X **
X **
X **
X **
X **
X **
X **
X
END_OF_FILE
if test 7360 -ne `wc -c <'mx80.pix'`; then
echo shar: \"'mx80.pix'\" unpacked with wrong size!
fi
# end of 'mx80.pix'
fi
echo shar: End of archive 2 \(of 2\).
cp /dev/null ark2isdone
MISSING=""
for I in 1 2 ; do
if test ! -f ark${I}isdone ; then
MISSING="${MISSING} ${I}"
fi
done
if test "${MISSING}" = "" ; then
echo You have unpacked both archives.
rm -f ark[1-9]isdone
else
echo You still need to unpack the following archives:
echo " " ${MISSING}
fi
## End of shell archive.
exit 0
--
Please send comp.sources.unix-related mail to rsalz@uunet.uu.net.
--
Wolf N. Paul * 3387 Sam Rayburn Run * Carrollton TX 75007 * (214) 306-9101
UUCP: killer!wnp ESL: 62832882
DOMAIN: wnp@killer.dallas.tx.us TLX: 910-380-0585 EES PLANO UD