new version from Steve Hayman <sahayman@iuvax.cs.indiana.edu>

SCCS-vsn: games/bcd/bcd.c 4.3

diff --git a/usr/src/games/bcd/bcd.c b/usr/src/games/bcd/bcd.c
index c46671e..4d27995 100644 (file)
--- a/usr/src/games/bcd/bcd.c
+++ b/usr/src/games/bcd/bcd.c
@@ -1,136 +1,183 @@
+/*
+ * Copyright (c) 1989 The Regents of the University of California.
+ * All rights reserved.
+ *
+ * This code is derived from software contributed to Berkeley by
+ * Steve Hayman of the Indiana University Computer Science Dept..
+ *
+ * Redistribution and use in source and binary forms are permitted
+ * provided that the above copyright notice and this paragraph are
+ * duplicated in all such forms and that any documentation,
+ * advertising materials, and other materials related to such
+ * distribution and use acknowledge that the software was developed
+ * by the University of California, Berkeley.  The name of the
+ * University may not be used to endorse or promote products derived
+ * from this software without specific prior written permission.
+ * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
+ * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
+ */

 
 

-static char sccsid[] = "       bcd.c   4.2     88/06/11        ";
-
-int chtab[] = {
-00000, /*   */
-03004, /* ! */
-02404, /* " */
-02040, /* sharp */
-02042, /* $ */
-02104, /* % */
-00001, /* & */
-03002, /* ' */
-02201, /* ( */
-02202, /* ) */
-02102, /* * */
-00005, /* + */
-02044, /* , */
-00002, /* - */
-02041, /* . */
-00014, /* / */
-00004, /* 0 */
-00010, /* 1 */
-00020, /* 2 */
-00040, /* 3 */
-00100, /* 4 */
-00200, /* 5 */
-00400, /* 6 */
-01000, /* 7 */
-02000, /* 8 */
-04000, /* 9 */
-02200, /* : */
-02402, /* ; */
-02401, /* < */
-02204, /* = */
-02400, /* > */
-03000, /* ? */
-02100, /* at */
- 011,
- 021,
- 041,
-0101,
-0201,
-0401,
-01001,
-02001,
-04001,
-012,
-022,
-042,
-0102,
-0202,
-0402,
-01002,
-02002,
-02002,
-024,
-044,
-0104,
-0204,
-0404,
-01004,
-02004,
-04004,
-02020, /* [ */
-03001, /* \ */
-02101, /* ] */
-00006, /* ^ */
-02024 /* _ */
+#ifndef lint
+char copyright[] =
+"@(#) Copyright (c) 1989 The Regents of the University of California.\n\
+ All rights reserved.\n";
+#endif /* not lint */
+
+#ifndef lint
+static char sccsid[] = "@(#)bcd.c      4.3 (Berkeley) %G%";
+#endif /* not lint */
+
+/*
+ * bcd --
+ *
+ * Read one line of standard input and produce something that looks like a
+ * punch card.  An attempt to reimplement /usr/games/bcd.  All I looked at
+ * was the man page.
+ *
+ * I couldn't find a BCD table handy so I wrote a shell script to deduce what
+ * the patterns were that the old bcd was using for each possible 8-bit
+ * character.  These are the results -- the low order 12 bits represent the
+ * holes.  (A 1 bit is a hole.)  These may be wrong, but they match the old
+ * program!
+ *
+ * Steve Hayman
+ * sahayman@iuvax.cs.indiana.edu
+ * 1989 11 30
+ */
+
+#include <sys/types.h>
+#include <stdio.h>
+#include <ctype.h>
+
+u_short holes[256] = {
+    0x0,        0x0,     0x0,     0x0,     0x0,     0x0,     0x0,     0x0,
+    0x0,        0x0,     0x0,     0x0,     0x0,     0x0,     0x0,     0x0,
+    0x0,        0x0,     0x0,     0x0,     0x0,     0x0,     0x0,     0x0,
+    0x0,        0x0,     0x0,     0x0,     0x0,     0x0,     0x0,     0x0,
+    0x0,        0x206,   0x20a,   0x042,   0x442,   0x222,   0x800,   0x406,
+    0x812,      0x412,   0x422,   0xa00,   0x242,   0x400,   0x842,   0x300,
+    0x200,      0x100,   0x080,   0x040,   0x020,   0x010,   0x008,   0x004,
+    0x002,      0x001,   0x012,   0x40a,   0x80a,   0x212,   0x00a,   0x006,
+    0x022,      0x900,   0x880,   0x840,   0x820,   0x810,   0x808,   0x804,
+    0x802,      0x801,   0x500,   0x480,   0x440,   0x420,   0x410,   0x408,
+    0x404,      0x402,   0x402,   0x280,   0x240,   0x220,   0x210,   0x208,
+    0x204,      0x202,   0x201,   0x082,   0x822,   0x600,   0x282,   0x30f,
+    0x900,      0x880,   0x840,   0x820,   0x810,   0x808,   0x804,   0x802,
+    0x801,      0x500,   0x480,   0x440,   0x420,   0x410,   0x408,   0x404,
+    0x402,      0x402,   0x280,   0x240,   0x220,   0x210,   0x208,   0x204,
+    0x202,      0x201,   0x082,   0x806,   0x822,   0x600,   0x282,   0x0,
+    0x0,        0x0,     0x0,     0x0,     0x0,     0x0,     0x0,     0x0,
+    0x0,        0x0,     0x0,     0x0,     0x0,     0x0,     0x0,     0x0,
+    0x0,        0x0,     0x0,     0x0,     0x0,     0x0,     0x0,     0x0,
+    0x0,        0x0,     0x0,     0x0,     0x0,     0x0,     0x0,     0x0,
+    0x206,      0x20a,   0x042,   0x442,   0x222,   0x800,   0x406,   0x812,
+    0x412,      0x422,   0xa00,   0x242,   0x400,   0x842,   0x300,   0x200,
+    0x100,      0x080,   0x040,   0x020,   0x010,   0x008,   0x004,   0x002,
+    0x001,      0x012,   0x40a,   0x80a,   0x212,   0x00a,   0x006,   0x022,
+    0x900,      0x880,   0x840,   0x820,   0x810,   0x808,   0x804,   0x802,
+    0x801,      0x500,   0x480,   0x440,   0x420,   0x410,   0x408,   0x404,
+    0x402,      0x402,   0x280,   0x240,   0x220,   0x210,   0x208,   0x204,
+    0x202,      0x201,   0x082,   0x806,   0x822,   0x600,   0x282,   0x30f,
+    0x900,      0x880,   0x840,   0x820,   0x810,   0x808,   0x804,   0x802,
+    0x801,      0x500,   0x480,   0x440,   0x420,   0x410,   0x408,   0x404,
+    0x402,      0x402,   0x280,   0x240,   0x220,   0x210,   0x208,   0x204,
+    0x202,      0x201,   0x082,   0x806,   0x822,   0x600,   0x282,   0x0

 };
 };

-       char s[128];
-       char *sp = {&s[0]};
+
+/*
+ * i'th bit of w.
+ */
+#define        bit(w,i)        ((w)&(1<<(i)))
+

 main(argc, argv)
 main(argc, argv)

-char *argv[];
+       int argc;
+       char **argv;

 {
 {

-       char *spp;
-       int i;
-       int j;
-       int c;
-       int l;
-
-       if (argc<2) {
-               puts("% ");
-               while ((c=getchar())!='\0'&c!='\n')
-                       *sp++ = c;
-               *sp = 0;
-               sp = &s[0];
+       char cardline[80];
+
+       /*
+        * The original bcd prompts with a "%" when reading from stdin,
+        * but this seems kind of silly.  So this one doesn't.
+        */
+
+       if (argc > 1) {
+               while (--argc)
+                       printcard(*++argv);

        } else
        } else

-               sp = *++argv;
-       puts("\n\n\n\n");
-       puts(" ________________________________");
-       puts("________________\n");
-       spp = sp;
-       while(*spp++);
-       spp--;
-       l = spp - sp;
+               while (fgets(cardline, sizeof(cardline), stdin))
+                       printcard(cardline);
+       exit(0);
+}
+
+#define        COLUMNS 48
+
+printcard(str)
+       register char *str;
+{
+       static char rowchars[] = "   123456789";
+       register int i, row;
+       register char *p;
+       char *index();
+
+       /* ruthlessly remove newlines and truncate at 48 characters. */
+       if ((p = index(str, '\n')))
+               *p = '\0';
+
+       if (strlen(str) > COLUMNS)
+               str[COLUMNS] = '\0';
+
+       /* make string upper case. */
+       for (p = str; *p; ++p)
+               if (isascii(*p) && islower(*p))
+                       *p = toupper(*p);
+
+        /* top of card */
+       putchar(' ');
+       for (i = 1; i <= COLUMNS; ++i)
+               putchar('_');
+       putchar('\n');
+
+       /*
+        * line of text.  Leave a blank if the character doesn't have
+        * a hole pattern.
+        */
+       p = str;

        putchar('/');
        putchar('/');

-       puts(sp);
-       i = 49 - l;
-       while(--i>0) putchar(' ');
-       puts("|\n");
-       j = 0;
-       spp = sp;
-       while (j++<12) {
+       for (i = 1; *p; i++, p++)
+               if (holes[*p])
+                       putchar(*p);
+               else
+                       putchar(' ');
+       while (i++ <= COLUMNS)
+               putchar(' ');
+       putchar('|');
+       putchar('\n');
+
+       /*
+        * 12 rows of potential holes; output a ']', which looks kind of
+        * like a hole, if the appropriate bit is set in the holes[] table.
+        * The original bcd output a '[', a backspace, five control A's,
+        * and then a ']'.  This seems a little excessive.
+        */
+       for (row = 0; row <= 11; ++row) {

                putchar('|');
                putchar('|');

-               i = 0;
-               spp = sp;
-               while (i<48) {
-                       if(i>l) c = 0;
-                       else c = *spp++ - 040;
-                       i++;
-                       if (c>='a'-040) c = c - 040;
-                       if (c<0 | c>137) c = 0;
-                       if ((chtab[c]>>(j-1))&1) 
-                               puts("[\010\01\01\01\01\01]");
+               for (i = 0, p = str; *p; i++, p++) {
+                       if (bit(holes[*p], 11 - row))
+                               putchar(']');

                        else
                        else

-                               putchar(j>3?'0'+j-3:' ');
+                               putchar(rowchars[row]);

                }
                }

-               puts("|\n");
+               while (i++ < COLUMNS)
+                       putchar(rowchars[row]);
+               putchar('|');
+               putchar('\n');

        }
        }

-       putchar('|');
-       puts("____________");
-       puts("____________________________________");
-       puts("|\n");
-       puts("\n\n\n\n");
-}

 
 

-puts(ss) char *ss; {
-       int i;
-       char t;
-       i = 0;
-       while(t = *ss++) {
-               if(t >= 'a' && t <= 'z')
-                       t += 'A'-'a';
-               putchar(t);
-       }
+       /* bottom of card */
+       putchar('|');
+       for (i = 1; i <= COLUMNS; i++)
+               putchar('_');
+       putchar('|');
+       putchar('\n');

 }
 }