rohrpost

+kdPOk1u0M2Yt8hPuAh (16412B)

---

 Return-Path: <moore@cs.utk.edu>
 Received: from thumper.bellcore.com by greenbush.bellcore.com (4.1/4.7)
 	id <AA11412> for nsb; Thu, 9 Jan 92 20:46:13 EST
 Received: from wilma.cs.utk.edu by thumper.bellcore.com (4.1/4.7)
 	id <AA27929> for nsb@greenbush; Thu, 9 Jan 92 20:46:10 EST
 Received: from LOCALHOST by wilma.cs.utk.edu with SMTP (5.61++/2.7c-UTK)
 	id AA02750; Thu, 9 Jan 92 20:45:55 -0500
 Message-Id: <9201100145.AA02750@wilma.cs.utk.edu>
 From: Keith Moore <moore@cs.utk.edu>
 To: Nathaniel Borenstein <nsb@thumper.bellcore.com>
 Cc: moore@cs.utk.edu
 Subject: comments on mime draft, esp. richtext
 In-Reply-To: Your message of "Tue, 07 Jan 92 15:14:49 EST."
              <sdOUctK0M2YtA_0OoM@thumper.bellcore.com>
 Content-Type: multipart/mixed; boundary="xyzzy"
 Date: Thu, 09 Jan 92 20:45:54 EST
 Sender: moore@cs.utk.edu
 
 --xyzzy
 content-type: text/richtext
 content-transfer-encoding: quoted-printable
 
 <flushleft>A few random things: </flushleft><paragraph>(a) it looks like t=
 here are strange font changes in the PostScript version. it switches from t=
 imes-roman to helvetica to helvetica bold to courier at random places.</par=
 agraph>
 <paragraph>(b) on page 25 of the postscript version, near the end of the se=
 cond paragraph, "but when soft line breaks immediately follow a <lt>newline=
 > or <lt>/paragraph>...", I assume you mean "a <fixed><lt>nl></fixed> or <f=
 ixed><lt>/paragraph></fixed>..."? (This rule seems a bit odd; I would prefe=
 r that either newlines are always ignored, or always ignored whenever they =
 immediately follow a command.) </paragraph>
 <paragraph>(c) I implemented a richtext-to-groff converter.  Using gxditvie=
 w, I now have the abiltity to read richtext messages on my X window display=
 . I noticed some oddities with some of the messages that you sent to the li=
 st. In particular, your mail composer generates things like:  <example><lt=
 >excerpt><italic>random text</italic><lt>newline><lt>/excerpt><lt>excerpt><=
 italic>more text</italic><lt>newline><lt>/excerpt></example>...where every =
 line of an excerpt is put in its own <fixed><lt>excerpt></fixed>...<fixed><=
 lt>/excerpt></fixed> block.  My initial implementation set off each excerpt=
  from the surrounding text with vertical white space ... which would be rea=
 sonable if all of the excerpted text appeared together in a single <fixed><=
 lt>excerpt></fixed>...<fixed><lt>/excerpt></fixed> block.  So this seems a =
 bit odd.</paragraph>
 <paragraph>In general it's not clear whether certain commands should cause =
 a "break" in running text.  I assume the following:  <flushleft>These caus=
 e a break:<nl><nl>
 <fixed>center<nl>
 flushleft<nl>
 flushright<nl>
 indent<nl>
 indentright<nl>
 outdent<nl>
 outdentright<nl>
 samepage<nl>
 excerpt<nl>
 paragraph<nl>
 signature<nl>
 nl<nl>
 np<nl>
 </fixed><nl>
 These do not cause a break: <nl><nl>
 <fixed>bold<nl>
 italic<nl>
 fixed<nl>
 smaller<nl>
 bigger<nl>
 underline<nl>
 subscript<nl>
 superscript<nl>
 heading<nl>
 footing<nl>
 iso-8859-x<nl>
 us-ascii<nl>
 comment<nl>
 no-op<nl>
 lt<nl>
 </fixed></flushleft></paragraph>
 <paragraph>Also, what is the initial state of the richtext interpreter?  Is=
  text to be wrapped and filled?  Justified left, right, or both?  what is t=
 he default font?  (fixed or ordinary roman).</paragraph>
 <paragraph>My richtext-to-groff converter is just a one-evening hack, but l=
 ots of questions cropped up, and I had only the messages you sent to the li=
 st as examples.  (I have enclosed a copy.)  So the question is, is the spec=
  in RFC-MIME precise enough to ensure good interoperability?  This message =
 looks pretty good on my screen.  How does it look on yours?</paragraph>
 <flushleft>-Keith</flushleft>
 --xyzzy
 content-type: text/plain; charset="us-ascii"
 x-content-type: application/octet-stream; file="richtogroff.c"
 content-description: richtext-to-groff converter
 content-transfer-encoding: quoted-printable
 
 /*
  * text/richtext to groff converter
  * Copyright =A9 January 1992 by Keith Moore <moore@cs.utk.edu>
  *
  * This program converts mail message bodies of content-type: text/richtex=
 t
  * to documents suitable for input to groff.  The output can be either
  * printed or viewed on an X window system display using gxditview.
  *
  * This program is free software; you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
  * the Free Software Foundation; either version 2 of the License, or
  * (at your option) any later version.
  * =
 
  * This program is distributed in the hope that it will be useful,
  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  * GNU General Public License for more details.
  *
  * You should have received a copy of the GNU General Public License
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  */
 
 #include <stdio.h>
 #include <ctype.h>
 
 int AtBOL =3D 0;=09=09=09/* true if at start of output line */
 int Broken =3D 0;=09=09=09/* true if we have emitted a break */
 int lineNumber =3D 1;=09=09/* current source line # */
 int PageWidth =3D ((5*72)+36);=09/* (in points) 5.5 inches by default */
 int PageHeight =3D 8*72;
 int LeftMargin =3D 0;
 int RightMargin =3D 0;
 int PageOffset =3D 0;
 
 void
 forceNewLine ()
 {
     if (!AtBOL)
 =09printf ("\n");
     AtBOL =3D 1;
 }
 
 void
 forceBreak ()
 {
     if (Broken)
 =09return;
     forceNewLine ();
     printf (".br\n");
     Broken =3D 1;
 }
 
 struct state {
     int font;
 #define FontPlain=0900
 #define FontBold=0901
 #define FontItalic=0902
 #define FontFixed=0904
     int adjust;
 #define AdjustBoth=0900
 #define AdjustLeft=0901
 #define AdjustRight=0902
 #define AdjustCenter=0903
     int leftMargin;
     int rightMargin;
 };
 
 struct state currentState =3D { FontPlain, AdjustBoth, 0, 0 };
 
 /*
  * font names for groff, assuming PostScript or X11 drivers
  */
 
 char *fontnames[] =3D {
 =09=09=09=09/* FIB */
     "TR",=09=09=09/* 000 (Times-Roman) */
     "TB",=09=09=09/* 001 (Times-Bold) */
     "TI",=09=09=09/* 010 (Times-Italic) */
     "TBI",=09=09=09/* 011 (Times-BoldItalic) */
     "CR",=09=09=09/* 100 (Courier-Roman) */
     "CB",=09=09=09/* 101 (Courier-Bold) */
     "CI",=09=09=09/* 110 (Courier-Italic) */
     "CBI",=09=09=09/* 111 (Courier-BoldItalic) */
 };
 
 char *adjust[] =3D {
     ".ad b\n.fi\n",=09=09/* AdjustBoth */
     ".ad l\n.fi\n",=09=09/* AdjustLeft */
     ".ad r\n.fi\n",=09=09/* AdjustRight */
     ".nf\n.ce 10000\n",=09=09/* AdjustCenter */
 };
 
 
 void
 changeState (oldState, newState, undo)
 struct state *oldState, *newState;
 int undo;
 {
     if (undo =3D=3D 0) {
 =09if (oldState->font !=3D newState->font) {
 =09    printf ("\\f[%s]", fontnames[newState->font]);
 =09    AtBOL =3D 0;
 =09    Broken =3D 0;
 =09}
     }
     if (oldState->leftMargin !=3D newState->leftMargin) {
 =09forceBreak ();
 =09printf (".in %4.2fi\n", (float) newState->leftMargin / 72.0);
 =09AtBOL =3D 1;
     }
     if (oldState->rightMargin !=3D newState->rightMargin) {
 =09forceBreak ();
 =09printf (".ll %4.2fi\n",
 =09=09(float) (PageWidth - newState->rightMargin) / 72.0);
 =09AtBOL =3D 1;
     }
     if (oldState->adjust !=3D newState->adjust) {
 =09forceBreak ();
 =09if (oldState->adjust =3D=3D AdjustCenter)
 =09    printf (".ce 0\n");
 =09printf ("%s", adjust[newState->adjust]);
 =09AtBOL =3D 1;
     }
     if (undo =3D=3D 1) {
 =09if (oldState->font !=3D newState->font) {
 =09    printf ("\\f[%s]", fontnames[newState->font]);
 =09    AtBOL =3D 0;
 =09    Broken =3D 0;
 =09}
     }
     currentState =3D *newState;
 }
 
 void
 changeFont (font)
 {
     struct state newState;
 
     newState =3D currentState;
     newState.font |=3D font;
     changeState (&currentState, &newState, 0);
 }
 
 void
 smaller (size)
 {
     printf ("\\s-%d", size);
     AtBOL =3D 0;
     Broken =3D 0;
 }
 
 void
 bigger (size)
 {
     printf ("\\s+%d", size);
     AtBOL =3D 0;
     Broken =3D 0;
 }
 
 
 void
 beginBlock (adjust)
 {
     struct state newState;
 
     newState =3D currentState;
     =
 
     forceBreak ();
     printf (".ne 3\n");
     AtBOL =3D 1;
     newState.adjust =3D adjust;
     changeState (&currentState, &newState, 0);
 }
 
 void
 beginExcerpt (x)
 int x;
 {
     struct state newState;
 
     newState =3D currentState;
     newState.font =3D FontItalic;
     changeState (&currentState, &newState, 0);
 }
 
 void
 beginExample (x)
 int x;
 {
     struct state newState;
 
     newState =3D currentState;
     newState.font =3D FontFixed;
     newState.adjust =3D AdjustLeft;
     newState.rightMargin =3D 0;
     changeState (&currentState, &newState, 0);
 }
 
 void
 indentLeft (x)
 int x;
 {
     struct state newState;
 
     newState =3D currentState;
     newState.leftMargin =3D currentState.leftMargin + x;
     if (newState.leftMargin < 0)
 =09newState.leftMargin =3D 0;
     changeState (&currentState, &newState, 0);
 }
 
 void
 indentRight (x)
 int x;
 {
     struct state newState;
 
     newState =3D currentState;
     newState.rightMargin =3D currentState.rightMargin + x;
     if (newState.rightMargin < 0)
 =09newState.rightMargin =3D 0;
     changeState (&currentState, &newState, 0);
 }
 
 
 void
 beginUnderline ()
 {
     forceNewLine ();
     printf (".ul 10000\n");
 }
 
 void
 endUnderline ()
 {
     forceNewLine ();
     printf (".ul 0\n");
 }
 
 void
 beginSub ()
 {
     printf ("\\d\\s-2");
 }
 
 void
 endSub ()
 {
     printf ("\\s+2\\u");
 }
 
 void
 beginSuper ()
 {
     printf ("\\u\\s-2");
 }
 
 void
 endSuper ()
 {
     printf ("\\s+2\\d");
 }
 
 struct stk {
     char *cmdName;
     int (*proc)();
     int arg;
     struct state savedState;
     struct stk *next;
 };
 
 struct stk *stack =3D NULL;
 
 char *
 strsave (s)
 char *s;
 {
     char *p =3D (char *) malloc (strlen (s) + 1);
     strcpy (p, s);
     return p;
 }
 
 void
 pushStack (cmdName, proc, arg, state)
 char *cmdName;
 int (*proc)();
 int arg;
 struct state *state;
 {
     struct stk *ptr =3D (struct stk *) malloc (sizeof (struct stk));
 
     ptr->cmdName =3D strsave (cmdName);
     ptr->proc =3D proc;
     ptr->arg =3D arg;
     ptr->savedState =3D *state;
     ptr->next =3D stack;
     stack =3D ptr;
 }
 
 void
 popStack ()
 {
     struct stk *ptr;
 
     if (stack) {
 =09ptr =3D stack->next;
 =09free (stack->cmdName);
 =09free (stack);
 =09stack =3D ptr;
     }
 }
 
 struct cmd {
     char *cmdName;
     void (*enter)();
     void (*leave)();
     int arg;
 } cmds[] =3D {
     { "bold", changeFont, NULL, FontBold },
     { "italic", changeFont, NULL, FontItalic },
     { "fixed", changeFont, NULL, FontFixed },
     { "smaller", smaller, bigger, 2 },
     { "bigger", bigger, smaller, 2 },
     { "example", beginExample, NULL, 0 },
     { "underline", beginUnderline, endUnderline, 0 },
     { "center", beginBlock, NULL, AdjustCenter },
     { "flushleft", beginBlock, NULL, AdjustLeft },
     { "flushright", beginBlock, NULL, AdjustRight },    =
 
     { "indent", indentLeft, NULL, 18 },
     { "indentright", indentRight, NULL, 18 },
     { "outdent", indentLeft, NULL, -18 },
     { "outdentright", indentRight, NULL, -18 },
 /*  { "samepage", noOp, NULL, 0 }, */
     { "subscript", beginSub, endSub, 0 },
     { "superscript", beginSuper, endSuper, 0 },
 /*  { "heading", noOp, NULL, 0 }, */
 /*  { "footing", noOp, NULL, 0 }, */
     { "excerpt", beginExcerpt, NULL, 0 },
     { "paragraph", beginBlock, NULL, AdjustBoth },
 /*  { "signature", noOp, NULL, 0 }, */
 };
 
 void
 doCommand (s)
 char *s;
 {
     int i;
 
     if (*s =3D=3D '/') {=09=09/* leave command */
 =09++s;
 =09if (stack =3D=3D NULL)
 =09    fprintf (stderr, "%d:stack underflow\n", lineNumber);
 =09else if (strcmp (s, stack->cmdName) =3D=3D 0) {
 =09    if (stack->proc)
 =09=09(*(stack->proc))(stack->arg);
 =09    changeState (&currentState, &(stack->savedState), 1);
 =09    popStack ();
 =09}
 =09else {
 =09    fprintf (stderr, "%d: incorrect nesting: found %s expected %s\n",
 =09=09     lineNumber, s, stack->cmdName);
 =09}
     }
     else {=09=09=09/* enter command */
 =09struct cmd *p;
 =09for (i =3D 0; i < sizeof cmds / sizeof *cmds; ++i) {
 =09    p =3D &(cmds[i]);
 =09    if (strcmp (s, p->cmdName) =3D=3D 0) {
 =09=09pushStack (p->cmdName, p->leave, p->arg, &currentState);
 =09=09if (p->enter)
 =09=09    (*(p->enter))(p->arg);
 =09=09return;
 =09    }
 =09}
 =09pushStack (s, NULL, 0, &currentState);
     }
 }
 
 char *
 getCmd ()
 {
     static char buf[52];
     char *ptr;
     int c;
 
     ptr =3D buf;
     while ((c =3D getchar ()) !=3D '>') {
 =09if (c =3D=3D EOF) {
 =09    fprintf (stderr, "%d: premature EOF\n", lineNumber);
 =09    exit (1);
 =09}
 =09if (ptr >=3D buf + 51) {
 =09    fprintf (stderr, "%d: no closing '>'\n", lineNumber);
 =09    exit (1);
 =09}
 =09if (isupper (c))
 =09    c =3D tolower (c);
 =09*ptr++ =3D c;
     }
     *ptr =3D '\0';
     return buf;
 }
 
 init ()
 {
     currentState.font =3D FontPlain;
     currentState.adjust =3D AdjustBoth;
     currentState.leftMargin =3D LeftMargin;
     currentState.rightMargin =3D RightMargin;
 
     printf (".pl %4.2fi\n", PageHeight / 72.0);=09/* 8 inches tall */
     printf (".po %4.2fi\n", PageOffset / 72.0);=09/* 0 page offset */
     printf (".ll %4.2fi\n",
 =09    (float) (PageWidth - currentState.rightMargin) / 72.0);
     printf (".lt %4.2fi\n",
 =09    (float) (PageWidth - currentState.rightMargin) / 72.0);
     printf (".de NP\n");=09/* do page breaks */
     printf ("'sp .3i\n");
     printf ("'bp\n");
     printf ("'sp .3i\n");
     printf ("..\n");
     printf (".wh -.4i NP\n");
     printf (".ft TR\n");=09/* Times-Roman font */
     printf (".nh\n");=09=09/* no hyphenation */
     printf (".ad l\n");=09=09/* justify both sides ? */
     printf (".fi\n");=09=09/* fill lines */
     AtBOL =3D 1;
     Broken =3D 1;
 }
 
 main(argc, argv)
 char **argv;
 {
     int c, i;
     char *command;
     double atof();
     int nestedComments =3D 0;
 
     /*
      * XXX add command-line parsing for page-width and page-length options
      */
 
     for (i =3D 1; i < argc; ++i) {
 =09if (strncmp (argv[i], "width=3D", 6) =3D=3D 0)
 =09    PageWidth =3D (int) (atof (argv[i] + 6) * 72.0);
 =09else if (strncmp (argv[i], "height=3D", 7) =3D=3D 0)
 =09    PageHeight =3D (int) (atof (argv[i] + 7) * 72.0);
 =09else if (strncmp (argv[i], "left=3D", 5) =3D=3D 0)
 =09    LeftMargin =3D (int) (atof (argv[i] + 5) * 72.0);
 =09else if (strncmp (argv[i], "right=3D", 6) =3D=3D 0)
 =09    RightMargin =3D (int) (atof (argv[i] + 6) * 72.0);
 =09else if (strncmp (argv[i], "offset=3D", 7) =3D=3D 0)
 =09    PageOffset =3D (int) (atof (argv[i] + 7) * 72.0);
     }
     init ();
     while ((c =3D getchar ()) !=3D EOF) {
 =09switch (c) {
 =09case '<':
 =09    command =3D getCmd ();
 
 =09    /*
 =09     * hack to make sure a newline following <nl> or
 =09     * </paragraph> is ignored.
 =09     */
 =09    if (strcmp (command, "nl") =3D=3D 0 ||
 =09=09strcmp (command, "/paragraph") =3D=3D 0) {
 =09=09if ((c =3D getchar ()) =3D=3D EOF)
 =09=09    break;
 =09=09else if (c !=3D '\n')
 =09=09    ungetc (c, stdin);
 =09    }
 
 =09    if (strcmp (command, "comment") =3D=3D 0) {
 =09=09nestedComments++;
 =09=09do {
                     while ((c =3D getchar ()) !=3D '<')
 =09=09=09if (c =3D=3D EOF) {
 =09=09=09    fprintf (stderr, "%d: premature EOF in comment\n",
 =09=09=09=09     lineNumber);
 =09=09=09    exit (1);
 =09=09=09}
 =09=09    command =3D getCmd ();
 =09=09    if (strcmp (command, "comment") =3D=3D 0)
 =09=09=09++nestedComments;
 =09=09    else if (strcmp (command, "/comment") =3D=3D 0)
 =09=09=09--nestedComments;
                 } while (nestedComments > 0);
 =09=09continue;
 =09    }
             else if (strcmp (command, "lt") =3D=3D 0) {
                 putchar ('<');
                 AtBOL =3D 0;
             }
 =09    else if (strcmp (command, "nl") =3D=3D 0) {
 =09=09if (Broken) {
 =09=09    printf ("\n");
 =09=09    AtBOL =3D 1;
 =09=09}
 =09=09else
 =09=09    forceBreak ();
             }
 =09    else if (strcmp (command, "np") =3D=3D 0) {
 =09=09forceNewLine ();
 =09=09printf (".NP\n");
                 AtBOL =3D 1;
             }
 =09    else
 =09=09doCommand (command);
 =09    break;
 =09case '\n':=09=09/* special for newline */
 =09    lineNumber++;
 =09    if (!AtBOL) {
 =09=09printf (" ");
 =09=09AtBOL =3D 0;
 =09=09Broken =3D 0;
 =09    }
 =09    break;
 =09case '\\':=09=09/* special for backslash */
 =09    printf ("\\e");
 =09    AtBOL =3D 0;
 =09    Broken =3D 0;
 =09    break;
 =09case '.':=09=09/* special for '.' at start of line */
 =09    if (AtBOL)
 =09=09printf ("\\.");
 =09    else
 =09=09printf (".");
 =09    AtBOL =3D 0;
 =09    Broken =3D 0;
 =09    break;
 =09default:
             putchar (c);
             AtBOL =3D 0;
 =09    Broken =3D 0;
 =09    break;
 =09}
     }
 }
 --xyzzy--