Subject: v15i047: Tools for nroff graphics on dot-matrix printers, Part02/02 Newsgroups: comp.sources.unix Sender: sources 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 '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 X#include 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 ). 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