Lout 3.18.

git-svn-id: http://svn.savannah.nongnu.org/svn/lout/trunk@5 9365b830-b601-4143-9ba8-b4a8e2c3339c

1 files changed, 1832 insertions, 0 deletions

diff --git a/prg2lout.c b/prg2lout.c
new file mode 100644
index 0000000..4df2187
--- /dev/null
+++ b/prg2lout.c
@@ -0,0 +1,1832 @@
+/*****************************************************************************/
+/*                                                                           */
+/*  PROG2LOUT: A PROGRAM TO CONVERT PROGRAM SOURCES INTO LOUT (VERSION 1.0)  */
+/*  COPYRIGHT (C) 2000 Jeffrey H. Kingston                                   */
+/*                                                                           */
+/*  Jeffrey H. Kingston (jeff@cs.su.oz.au)                                   */
+/*  Basser Department of Computer Science                                    */
+/*  The University of Sydney 2006                                            */
+/*  AUSTRALIA                                                                */
+/*                                                                           */
+/*  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, 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 <stdlib.h>
+
+/*****************************************************************************/
+/*                                                                           */
+/*  How to add another language to prg2lout's list                           */
+/*                                                                           */
+/*  Step 1.  Have a browse through the token declarations below, and work    */
+/*  out which of them you need for your language.  If you need a token that  */
+/*  isn't there already, you'll have to define it; there are many examples   */
+/*  there to help you.                                                       */
+/*                                                                           */
+/*  Step 2.  Browse through the language declarations, and declare your      */
+/*  language following those examples:  first you give a set of one or more  */
+/*  alternative names for your language, then the default printing style for */
+/*  it (either "fixed", "varying", or "symbol"), then you list the tokens    */
+/*  of the language, then you list the keywords.                             */
+/*                                                                           */
+/*  Step 3.  Add your language variable to the list in the initializer of    */
+/*  variable languages, as you can see the others have been done.            */
+/*                                                                           */
+/*  Step 4.  If any lists of initializers now contain more than              */
+/*  MAX_ARRAY_LENGTH-1 elements, increase MAX_ARRAY_LENGTH until they don't. */
+/*                                                                           */
+/*  Step 5.  Recompile and reinstall prg2lout, test "prg2lout -u" then       */
+/*  "prg2lout -l <mylanguage> <myfile> | lout -s > out.ps".                  */
+/*                                                                           */
+/*  Step 6.  Send your tested and verified changes to jeff@cs.usyd.edu.au    */
+/*  for incorporation in the next Lout release.  If you do this, please      */
+/*  try hard to ensure that your changes conform to the formal definition    */
+/*  of your language.                                                        */
+/*                                                                           */
+/*****************************************************************************/
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Character sets                                                           */
+/*                                                                           */
+/*  Here are prg2lout's definitions of various commonly needed sets of      */
+/*  characters.  May need enhancement for Latin1 etc.                        */
+/*                                                                           */
+/*****************************************************************************/
+
+char AllPrintable[] = 
+  " !\"#$%&'()*+,-./0123456789:;<=>?@[\\]^_`\\{|}~\
+ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ;
+
+char AllPrintablePlusNL[] =
+  " !\"#$%&'()*+,-./0123456789:;<=>?@[\\]^_`\\{|}~\
+ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n" ;
+
+char AllPrintableTabNL[] =
+  " !\"#$%&'()*+,-./0123456789:;<=>?@[\\]^_`\\{|}~\
+ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz\n\t" ;
+
+char NotDoubleQuote[] =
+  " !#$%&'()*+,-./0123456789:;<=>?@[\\]^_`\\{|}~\
+ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ;
+
+char NotQuote[] =
+  " !#$%&\"()*+,-./0123456789:;<=>?@[\\]^_`\\{|}~\
+ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ;
+
+char Letters[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" ;
+
+char Letter_Digit[] =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz_0123456789" ;
+
+#define SepLetters 							\
+"A", "B", "C", "D", "E", "F", "G", "H", "I", "J", "K", "L", "M",	\
+"N", "O", "P", "Q", "R", "S", "T", "U", "V", "W", "X", "Y", "Z",	\
+"a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m",	\
+"n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z"
+
+#define SepDigits "0", "1", "2", "3", "4", "5", "6", "7", "8", "9"
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  TOKEN - put your token declarations in this section                      */
+/*                                                                           */
+/*****************************************************************************/
+#define MAX_CHAR 256
+#define MAX_STRING_LENGTH 101
+#define MAX_ARRAY_LENGTH 101
+
+
+typedef struct token_rec {
+  char *name;			  /* the name of this token, e.g. "string"   */
+  char *command;		  /* the Lout command for it, e.g. "@D"      */
+  char *alternate_command;	  /* the alternate command for it, e.g. "@K" */
+  char *starts[MAX_ARRAY_LENGTH]; /* strings that start this token           */
+  char *legal;			  /* legal characters in this token          */
+  char *escape;			  /* the escape character e.g. "\\", or ""   */
+  char *escape_legal;		  /* legal characters after escape character */
+  char *inner_escape;		  /* inner escape, e.g. "`", or else ""      */
+  char *end_inner_escape;	  /* end inner escape, e.g. "'"              */
+  char *end_delimiter;		  /* the end delimiter, else ""              */
+
+  /* The following options are initialized by the program, so don't you      */
+  char chtype[MAX_CHAR];	  /* character types within token            */
+  char escape_chtype[MAX_CHAR];	  /* character types after escape            */
+} TOKEN;
+
+
+TOKEN CStringToken = {
+  "string",		/* used by error messages involving this token      */
+  "@S",			/* Lout command for formatting strings              */
+  "",			/* No alternate command                             */
+  { "\"" },		/* strings begin with a " character                 */
+  NotDoubleQuote,	/* inside, any printable except " is OK             */
+  "\\",			/* within strings, \\ is the escape character       */
+  AllPrintablePlusNL,	/* after escape char, any printable char or nl OK   */
+  "",			/* strings do not permit "inner escapes"            */
+  "",			/* and so there is no end innner escape either      */
+  "\""			/* strings end with a " character                   */
+};
+
+TOKEN CCharacterToken = {
+  "character",		/* used by error messages involving this token      */
+  "@C",			/* Lout command for formatting characters           */
+  "",			/* No alternate command                             */
+  { "'" },		/* characters begin with a ' character              */
+  NotQuote,		/* inside, any printable except ' is OK             */
+  "\\",			/* within characters, \\ is the escape character    */
+  AllPrintable,		/* after escape char, any printable char is OK      */
+  "",			/* characters do not permit "inner escapes"         */
+  "",			/* and so there is no end innner escape either      */
+  "'"			/* characters end with a ' character                */
+};
+
+TOKEN EiffelStringToken = {
+  "string",		/* used by error messages involving this token      */
+  "@S",			/* Lout command for formatting strings              */
+  "",			/* No alternate command                             */
+  { "\"" },		/* strings begin with a " character                 */
+  NotDoubleQuote,	/* inside, any printable except " is OK             */
+  "%",			/* within strings, % is the escape character        */
+  AllPrintable,		/* after escape char, any printable char is OK      */
+  "",			/* strings do not permit "inner escapes"            */
+  "",			/* and so there is no end innner escape either      */
+  "\""			/* strings end with a " character                   */
+};
+
+TOKEN EiffelCharacterToken = {
+  "character",		/* used by error messages involving this token      */
+  "@C",			/* Lout command for formatting characters           */
+  "",			/* No alternate command                             */
+  { "'" },		/* characters begin with a ' character              */
+  NotQuote,		/* inside, any printable except ' is OK             */
+  "%",			/* within characters, % is the escape character     */
+  AllPrintable,		/* after escape char, any printable char is OK      */
+  "",			/* characters do not permit "inner escapes"         */
+  "",			/* and so there is no end innner escape either      */
+  "'"			/* characters end with a ' character                */
+};
+
+TOKEN IdentifierToken = {
+  "identifier",		/* used by error messages involving this token      */
+  "@D",			/* Lout command for formatting identifiers          */
+  "@K",			/* Alternate command (for keywords)                 */
+  { SepLetters, "_" },	/* identifiers begin with any letter or _           */
+  Letter_Digit,		/* inside, letters, underscores, digits are OK      */
+  "",			/* no escape character within identifiers           */
+  "",			/* so nothing legal after escape char either        */
+  "",			/* identifiers do not permit "inner escapes"        */
+  "",			/* and so there is no end innner escape either      */
+  ""			/* identifiers do not end with a delimiter          */
+};
+
+TOKEN NumberToken = {
+  "number",		/* used by error messages involving this token      */
+  "@N",			/* Lout command for formatting numbers              */
+  "",			/* No alternate command                             */
+  { SepDigits },	/* numbers must begin with a digit                  */
+  "0123456789.eE",	/* inside, digits, decimal point, exponent          */
+  "",			/* no escape character within numbers               */
+  "",			/* so nothing legal after escape char either        */
+  "",			/* numbers do not permit "inner escapes"            */
+  "",			/* and so there is no end innner escape either      */
+  ""			/* numbers do not end with a delimiter              */
+};
+
+TOKEN CCommentToken = {
+  "comment",		/* used by error messages involving this token      */
+  "@C",			/* Lout command for formatting comments             */
+  "",			/* No alternate command                             */
+  { "/*" },		/* comments begin with this character pair          */
+  AllPrintableTabNL,	/* inside, any printable char, tab, or nl is OK     */
+  "",			/* no escape character within comments              */
+  "",			/* so nothing legal after escape char either        */
+  "",			/* C comments do not permit "inner escapes"         */
+  "",			/* and so there is no end innner escape either      */
+  "*/"			/* comments end with this character pair            */
+};
+
+TOKEN CCommentEscapeToken = {
+  "Lout escape",	/* used by error messages involving this token      */
+  NULL,			/* no Lout command since passed through unformatted */
+  "",			/* No alternate command                             */
+  { "/*@" },		/* comments begin with this character pair          */
+  AllPrintableTabNL,	/* inside, any printable char, tab, or nl is OK     */
+  "",			/* no escape character within comments              */
+  "",			/* so nothing legal after escape char either        */
+  "",			/* no "inner escape" in escape comments             */
+  "",			/* so no end of "inner escape" either               */
+  "*/"			/* comments end with this character pair            */
+};
+
+TOKEN CPPCommentToken = {
+  "comment",		/* used by error messages involving this token      */
+  "@C",			/* Lout command for formatting comments             */
+  "",			/* No alternate command                             */
+  { "//" },		/* comments begin with this character pair          */
+  AllPrintable,		/* inside, any printable char is OK (not NL)        */
+  "",			/* no escape character within comments              */
+  "",			/* so nothing legal after escape char either        */
+  "",			/* C comments do not permit "inner escapes"         */
+  "",			/* and so there is no end innner escape either      */
+  ""			/* no end delimiter (end of line will end it)       */
+};
+
+TOKEN CPPCommentEscapeToken = {
+  "Lout escape",	/* used by error messages involving this token      */
+  NULL,			/* no Lout command since passed through unformatted */
+  "",			/* No alternate command                             */
+  { "//@" },		/* comments begin with this character pair          */
+  AllPrintable,		/* inside, any printable char is OK                 */
+  "",			/* no escape character within comments              */
+  "",			/* so nothing legal after escape char either        */
+  "",			/* no "inner escape" in escape comments             */
+  "",			/* so no end of "inner escape" either               */
+  ""			/* no end delimiter (end of line will end it)       */
+};
+
+TOKEN EiffelCommentToken = {
+  "comment",		/* used by error messages involving this token      */
+  "@C",			/* Lout command for formatting comments             */
+  "",			/* No alternate command                             */
+  { "--" },		/* comments begin with this character pair          */
+  AllPrintable,		/* inside, any printable char is OK                 */
+  "",			/* no escape character within comments              */
+  "",			/* so nothing legal after escape char either        */
+  "`",			/* start of "inner escape" in Eiffel comment        */
+  "'",			/* end of "inner escape" in Eiffel comment          */
+  ""			/* no ending delimiter; end of line will end it     */
+};
+
+TOKEN EiffelCommentEscapeToken = {
+  "Lout escape",	/* used by error messages involving this token      */
+  NULL,			/* no Lout command since passed through unformatted */
+  "",			/* No alternate command                             */
+  { "--@" },		/* comments begin with this character pair          */
+  AllPrintable,		/* inside, any printable char is OK                 */
+  "",			/* no escape character within comments              */
+  "",			/* so nothing legal after escape char either        */
+  "",			/* no "inner escape" in escape comments             */
+  "",			/* so no end of "inner escape" either               */
+  ""			/* no ending delimiter; end of line will end it     */
+};
+
+TOKEN BlueCommentToken = {
+  "comment",		/* used by error messages involving this token      */
+  "@C",			/* Lout command for formatting comments             */
+  "",			/* No alternate command                             */
+  { "==", "--" },	/* comments begin with this character pair          */
+  AllPrintable,		/* inside, any printable char is OK                 */
+  "",			/* no escape character within comments              */
+  "",			/* so nothing legal after escape char either        */
+  "`",			/* start of "inner escape" in Blue comment          */
+  "'",			/* end of "inner escape" in Blue comment            */
+  ""			/* no ending delimiter; end of line will end it     */
+};
+
+TOKEN BlueCommentEscapeToken = {
+  "Lout escape",	/* used by error messages involving this token      */
+  NULL,			/* no Lout command since passed through unformatted */
+  "",			/* No alternate command                             */
+  { "==@", "--@" },	/* comments begin with this character pair          */
+  AllPrintable,		/* inside, any printable char is OK                 */
+  "",			/* no escape character within comments              */
+  "",			/* so nothing legal after escape char either        */
+  "",			/* no "inner escape" in escape comments             */
+  "",			/* so no end of "inner escape" either               */
+  ""			/* no ending delimiter; end of line will end it     */
+};
+
+
+#define FixedToken(str, command) /* define fixed-string token */	\
+{									\
+  str,			/* name used for debugging only       */	\
+  command,		/* Lout command for formatting this   */	\
+  "",			/* No alternate command               */	\
+  { str },		/* token begins (and ends!) with this */	\
+  "",			/* nothing inside, since no inside    */	\
+  "",			/* no escape character                */	\
+  "",			/* so nothing after escape character  */	\
+  "",			/* no inner escape either             */	\
+  "",			/* so no end inner escape             */	\
+  ""			/* no ending delimiter                */	\
+}
+
+TOKEN HashToken			= FixedToken("#",  "@O");
+TOKEN ExclamationToken		= FixedToken("!",  "@O");
+TOKEN PercentToken		= FixedToken("%",  "@O");
+TOKEN HatToken			= FixedToken("^",  "@O");
+TOKEN AmpersandToken		= FixedToken("&",  "@O");
+TOKEN StarToken			= FixedToken("*",  "@ST");
+TOKEN SlashToken		= FixedToken("/",  "@O");
+TOKEN ArrowToken		= FixedToken("->", "arrowright @A @O");
+TOKEN BackSlashToken		= FixedToken("\\", "@O");
+TOKEN LeftParenToken		= FixedToken("(",  "@O");
+TOKEN RightParenToken		= FixedToken(")",  "@O");
+TOKEN MinusToken		= FixedToken("-",  "@M");
+TOKEN PlusToken			= FixedToken("+",  "plus @A @O");
+TOKEN EqualToken		= FixedToken("=",  "equal @A @O");
+TOKEN LeftBraceToken		= FixedToken("{",  "@O");
+TOKEN RightBraceToken		= FixedToken("}",  "@O");
+TOKEN BarToken			= FixedToken("|",  "@O");
+TOKEN CircumToken		= FixedToken("~",  "@O");
+TOKEN LeftBracketToken		= FixedToken("[",  "@O");
+TOKEN RightBracketToken		= FixedToken("]",  "@O");
+TOKEN SemicolonToken		= FixedToken(";",  "@O");
+TOKEN ColonToken		= FixedToken(":",  "@O");
+TOKEN LessToken			= FixedToken("<",  "less @A @O");
+TOKEN GreaterToken		= FixedToken(">",  "greater @A @O");
+TOKEN QuestionToken		= FixedToken("?",  "@O");
+TOKEN CommaToken		= FixedToken(",",  "@O");
+TOKEN DotToken			= FixedToken(".",  "@O");
+TOKEN EiffelDotToken		= FixedToken(".",  "@ED");
+TOKEN LessEqualToken		= FixedToken("<=", "lessequal @A @O");
+TOKEN GreaterEqualToken		= FixedToken(">=", "greaterequal @A @O");
+TOKEN CNotEqualToken		= FixedToken("!=", "notequal @A @O");
+TOKEN EiffelNotEqualToken	= FixedToken("/=", "notequal @A @O");
+TOKEN BlueNotEqualToken		= FixedToken("<>", "notequal @A @O");
+TOKEN AssignToken		= FixedToken(":=", "@O");
+TOKEN QuestionAssignToken	= FixedToken("?=", "@O");
+TOKEN DollarToken		= FixedToken("$",  "@O");
+TOKEN ImpliesToken		= FixedToken("=>", "implies @A @O");
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  LANGUAGE - put your language declarations in this section.               */
+/*                                                                           */
+/*****************************************************************************/
+
+typedef struct lang_rec {
+  char *names[MAX_ARRAY_LENGTH];
+  char *default_style;
+  TOKEN *tokens[MAX_ARRAY_LENGTH];
+  char *keywords[MAX_ARRAY_LENGTH];
+} LANGUAGE;
+
+LANGUAGE CLanguage = {
+  { "C", "c", "C++", "c++"  },
+  "fixed",
+  {
+    &CStringToken, &CCharacterToken, &IdentifierToken, &NumberToken,
+    &CCommentToken, &CCommentEscapeToken,
+    &CPPCommentToken, &CPPCommentEscapeToken,
+    &HashToken, &ExclamationToken, &PercentToken, &HatToken,
+    &AmpersandToken, &StarToken, &LeftParenToken, &RightParenToken,
+    &MinusToken, &PlusToken, &EqualToken, &LeftBraceToken, &RightBraceToken,
+    &BarToken, &CircumToken, &LeftBracketToken, &RightBracketToken,
+    &SemicolonToken, &ColonToken, &LessToken, &GreaterToken,
+    &QuestionToken, &CommaToken, &DotToken, &SlashToken, &BackSlashToken,
+    &ArrowToken, &LessEqualToken, &GreaterEqualToken, &CNotEqualToken
+  },
+
+  { "asm", "auto", "break", "case", "catch", "char", "class", "const", 
+    "continue", "default", "delete", "do", "double", "else", "enum", 
+    "extern", "float", "for", "friend", "goto", "if", "inline", "int", 
+    "long", "new", "operator", "private", "protected", "public", "register", 
+    "return", "short", "signed", "sizeof", "static", "struct", "switch", 
+    "template", "this", "throw", "try", "typedef", "union", "unsigned", 
+    "virtual", "void", "volatile", "while", 
+  }
+};
+
+
+LANGUAGE EiffelLanguage = {
+  { "Eiffel", "eiffel" },
+  "varying",
+  {
+    &EiffelStringToken, &EiffelCharacterToken, &IdentifierToken, &NumberToken,
+    &EiffelCommentToken, &EiffelCommentEscapeToken,
+    &SemicolonToken, &CommaToken, &ColonToken, &EiffelDotToken,
+    &ExclamationToken, &EqualToken, &EiffelNotEqualToken, &LeftParenToken,
+    &RightParenToken, &LeftBracketToken, &RightBracketToken, &LeftBraceToken,
+    &RightBraceToken, &AssignToken, &QuestionAssignToken, &PlusToken,
+    &MinusToken, &DollarToken, &HatToken, &SlashToken, &BackSlashToken,
+    &LessToken, &GreaterToken, &LessEqualToken, &GreaterEqualToken
+  },
+
+  { "alias", "all", "and", "as", "check", "class", "creation", "debug",
+    "deferred", "do", "else", "elseif", "end", "ensure", "expanded",
+    "export", "external", "false", "feature", "from", "frozen", "if",
+    "implies", "indexing", "infix", "inherit", "inspect", "invariant",
+    "is", "like", "local", "loop", "obsolete", "old", "once", "or",
+    "prefix", "redefine", "rename", "require", "rescue", "retry", "select",
+    "separate", "strip", "then", "true", "undefine", "unique", "until",
+    "variant", "when", "xor", "not", "interface"
+  }
+};
+
+
+LANGUAGE BlueLanguage = {
+  { "Blue", "blue" },
+  "varying",
+  {
+    &CStringToken, &IdentifierToken, &NumberToken,
+    &BlueCommentToken, &BlueCommentEscapeToken,
+    &CommaToken, &LessToken, &GreaterToken, &ColonToken, &AssignToken,
+    &LeftParenToken, &RightParenToken, &LeftBracketToken, &RightBracketToken,
+    &QuestionAssignToken, &ExclamationToken, &EiffelDotToken, &ImpliesToken,
+    &EqualToken, &BlueNotEqualToken, &LeftBraceToken, &RightBraceToken,
+    &PlusToken, &MinusToken, &StarToken, &SlashToken, &HatToken,
+    &LessEqualToken, &GreaterEqualToken
+
+  },
+
+  { "and", "assert", "builtin", "case", "class", "const", "create",
+    "creation", "deferred", "div", "do", "else", "elseif", "end",
+    "Enumeration", "enumeration", "exit", "if", "in", "interface",
+    "internal", "invariant", "is", "loop", "manifest", "mod", "not",
+    "of", "old", "on", "or", "post", "pre", "redefined", "return",
+    "routines", "super", "then", "uses", "var"
+  }
+};
+
+
+LANGUAGE *languages[] = {
+  & CLanguage,
+  & EiffelLanguage,
+  & BlueLanguage,
+};
+
+/*****************************************************************************/
+/*                                                                           */
+/*  If you are adding a new language, you don't need to change anything      */
+/*  below this point.  Just repeating: don't change anything below here.     */
+/*                                                                           */
+/*****************************************************************************/
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Global constants and variables                                           */
+/*                                                                           */
+/*****************************************************************************/
+#define DEBUG_SETUP	0
+#define DEBUG_PROCESS	0
+#define DEBUG_TRIE	0
+#define DEBUG_NEXTCHAR	0
+#define DEBUG_PREFIXEQ	0
+#define DEBUG_EMIT	0
+#define DEBUG_MAIN	0
+
+#define PROG2LOUT_VERSION "prg2lout Version 1.0 (February 2000)"
+#define	BOOLEAN		unsigned
+#define	FALSE		0
+#define	TRUE		1
+#define	MAX_LINE	1024
+
+/* print styles */
+#define	NO_STYLE	0
+#define	FIXED_STYLE	1
+#define	VARYING_STYLE	2
+#define	SYMBOL_STYLE	3
+
+static char	file_name[MAX_LINE];	/* current input file name           */
+static char	curr_line[MAX_LINE];	/* current input line                */
+static int	line_num;		/* current input line number         */
+static int	line_pos;		/* current input column number       */
+static BOOLEAN	raw_seen;		/* TRUE if -r (raw mode)             */
+
+static BOOLEAN	headers_option;		/* TRUE if no -n option (headers)    */
+static int	style_option;		/* value of -p option, or NO_STYLE   */
+static char	*font_option;		/* value of -f option, else null     */
+static char	*size_option;		/* value of -s option, else null     */
+static char	*line_option;		/* value of -v option, else null     */
+static char	*tabin_option;		/* value of -t option, else null     */
+static char	*tabout_option;		/* value of -T option, else null     */
+static char	*language_option;	/* value of -l option, else null     */
+
+static BOOLEAN	tab_by_spacing;		/* TRUE if using space chars to tab  */
+static int	tab_in;			/* tab interval, value of -t option  */
+static float	tab_out;		/* tab interval width (-T option)    */
+static char 	tab_unit;		/* unit of measurement for tab       */
+
+char *ErrorHeader()
+{ static char buff[MAX_LINE];
+  if( line_num == 0 )
+    sprintf(buff, "prg2lout");
+  else if( raw_seen )
+    sprintf(buff, "prg2lout %d,%d", line_num, line_pos);
+  else
+    sprintf(buff, "prg2lout %s %d,%d", file_name, line_num, line_pos);
+  return buff;
+}
+
+#define GetArg(arg, message, null_ok)					\
+{ if( strcmp(argv[arg_pos]+2, "") != 0 )				\
+    arg = argv[arg_pos]+2;						\
+  else if( !null_ok && arg_pos < argc-1 && *argv[arg_pos+1] != '-' )	\
+    arg = argv[++arg_pos];						\
+  else if( null_ok )							\
+    arg = (char *) NULL;						\
+  else									\
+  { fprintf(err_fp, "%s: %s\n", ErrorHeader(), message);		\
+    exit(1);								\
+  }									\
+} /* end GetArg */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  char *EchoToken(TOKEN *t)                                                */
+/*                                                                           */
+/*  Print a brief resume of token t                                          */
+/*                                                                           */
+/*****************************************************************************/
+
+char *EchoToken(TOKEN *t)
+{ static char buff[MAX_LINE];
+  if( t == (TOKEN *) NULL )
+    sprintf(buff, "(NULL)");
+  else
+    sprintf(buff, "%s", t->name);
+  return buff;
+}
+
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  TRIE                                                                     */
+/*                                                                           */
+/*  We use a trie to match the input against the opening pattern of each     */
+/*  token, since some tokens (e.g. <=, // etc.) have multi-character         */
+/*  opening patterns.                                                        */
+/*                                                                           */
+/*****************************************************************************/
+
+typedef struct trie_node {
+  struct trie_node *sub[MAX_CHAR];
+  TOKEN		   *value[MAX_CHAR];
+} *TRIE;
+
+/*****************************************************************************/
+/*                                                                           */
+/*  BOOLEAN TrieInsert(&T, str, val)                                         */
+/*                                                                           */
+/*  Insert str into trie T.  May need a new root so pass T by reference.     */
+/*  Return FALSE if the insertion failed, either because the string was      */
+/*  empty, or because it was the same as a previously inserted string.       */
+/*                                                                           */
+/*****************************************************************************/
+
+BOOLEAN TrieInsert(TRIE *T, char *str, TOKEN *val)
+{ BOOLEAN res;
+  if( DEBUG_TRIE )
+    fprintf(stderr, "[ TrieInsert(T, %s, %s)\n", str, EchoToken(val));
+  if( *str == '\0' )
+    res = FALSE;
+  else
+  {
+    if( *T == (TRIE) NULL )
+      *T = (TRIE) calloc(1, sizeof(struct trie_node));  /* will set all to 0 */
+    if( *(str + 1) != '\0' )
+      res = TrieInsert(&((*T)->sub[(int) *str]), str + 1, val);
+    else if( (*T)->value[(int) *str] != (TOKEN *) NULL )
+      res = FALSE;
+    else
+    {
+      (*T)->value[(int) *str] = val;
+      res = TRUE;
+    }
+  }
+  if( DEBUG_TRIE )
+    fprintf(stderr, "] TrieInsert(T, %s, %s) returning %s\n", str,
+      EchoToken(val), res ? "TRUE" : "FALSE");
+  return res;
+}
+
+/*****************************************************************************/
+/*                                                                           */
+/*  TOKEN *TrieRetrieve(T, str, &len)                                        */
+/*                                                                           */
+/*  Find the longest prefix of string str in T.  If this is empty, return    */
+/*  NULL.  If non-empty, return the corresponding value as the result, and   */
+/*  the length of the prefix in *len.                                        */
+/*                                                                           */
+/*****************************************************************************/
+
+TOKEN *TrieRetrieve(TRIE T, char *str, int *len)
+{ TOKEN *res;  int i;
+  if( DEBUG_TRIE )
+    fprintf(stderr, "[ TrieRetrieve(T, %s, len)\n", str);
+  res = (TOKEN *) NULL;
+  *len = 0;
+  for( i = 0;  T != (TRIE) NULL;  T = T->sub[(int) str[i]], i++ )
+  {
+    if( DEBUG_TRIE )
+      fprintf(stderr, "  i = %d, res = %s\n", i, EchoToken(res));
+    if( T->value[(int) str[i]] != (TOKEN *) NULL )
+    {
+      res = T->value[(int) str[i]];
+      *len = i+1;
+    }
+  }
+  if( DEBUG_TRIE )
+    fprintf(stderr, "] TrieRetrieve returning (*len = %d) %s\n",
+      *len, EchoToken(res));
+  return res;
+}
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  HASH_TABLE                                                               */
+/*                                                                           */
+/*  We use a hash table to hold the keywords.  There is no associated        */
+/*  value, we just want to know whether they are there or not.               */
+/*                                                                           */
+/*  NB MAX_SYM must be somewhat larger than the number of keywords.          */
+/*                                                                           */
+/*****************************************************************************/
+#define MAX_SYM 309
+
+static char *HashTable[MAX_SYM];		/* will initialze to NULL    */
+static int HashTableCount = 0;			/* number of entries         */
+
+static int hash(char *key)
+{ int i, res;
+  res = 0;
+  for( i = 0;  key[i] != '\0';  i++ )
+  { res += key[i];
+  }
+  return res % MAX_SYM;
+} /* end hash */
+
+void HashTableInsert(char *str, FILE *err_fp)
+{ int i;
+  if( DEBUG_SETUP )
+    fprintf(stderr, "[ HashTableInsert(%s)\n", str);
+  if( HashTableCount >= MAX_SYM - 20 )
+  {
+    fprintf(err_fp, "%s internal error: full hash table (increase MAX_SYM)\n",
+      ErrorHeader());
+    abort();
+  }
+  for( i = hash(str);  HashTable[i] != (char *) NULL;  i = (i+1) % MAX_SYM );
+  HashTable[i] = str;
+  HashTableCount++;
+  if( DEBUG_SETUP )
+    fprintf(stderr, "] HashTableInsert(%s)\n", str);
+}
+
+BOOLEAN HashTableRetrieve(char *str)
+{ int i;
+  for( i = hash(str);  HashTable[i] != (char *) NULL;  i = (i+1) % MAX_SYM )
+    if( strcmp(HashTable[i], str) == 0 )
+      return TRUE;
+  return FALSE;
+}
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  BACK END                                                                 */
+/*                                                                           */
+/*  This is the code that actually prints the output file.  It accumulates   */
+/*  each token and only prints it at the end of the token, so that it can    */
+/*  check whether an alternative command ought to be printed (keywords).     */
+/*                                                                           */
+/*****************************************************************************/
+
+static char	save_token[MAX_LINE];		/* the token text            */
+static int	save_len;                       /* index of \0 in save_token */
+static BOOLEAN	save_on = FALSE;		/* TRUE when saving          */
+
+/*****************************************************************************/
+/*                                                                           */
+/*  EmitRaw(ch, out_fp, FILE *err_fp)                                        */
+/*                                                                           */
+/*  Emit this character immediately.  This is only legal when not saving.    */
+/*  All characters printed on the output file should pass through here,      */
+/*  since EmitRaw keeps track of where we are on the output line, in order   */
+/*  to handle tab characters correctly.                                      */
+/*                                                                           */
+/*  NB out_linepos is the column where the *next* character will go, and     */
+/*  it counts the first column on the line as column zero.  It understands   */
+/*  that a tab character always produces at least one space, and that the    */
+/*  character after a tab goes in a column whose number mod tab_in is zero.  */
+/*                                                                           */
+/*****************************************************************************/
+
+void EmitRaw(char ch, FILE *out_fp, FILE *err_fp)
+{
+  static int	 out_linepos = 0;		/* output line position      */
+  static BOOLEAN out_linestart = TRUE;		/* TRUE if out line start    */
+
+  if( DEBUG_EMIT )
+    fprintf(stderr, "EmitRaw(%c); out_linepos %d, out_linestart %s\n",
+      ch, out_linepos, out_linestart ? "TRUE" : "FALSE");
+  if( save_on )
+  {
+    fprintf(err_fp, "%s internal error (EmitRaw save_on)\n", ErrorHeader());
+    abort();
+  }
+  if( ch == '\t' )
+  {
+    if( tab_by_spacing )
+    { putc(' ', out_fp);
+      out_linepos++;
+      while( out_linepos % tab_in != 0 )
+      { putc(' ', out_fp);
+        out_linepos++;
+      }
+    }
+    else
+    {
+      out_linepos++;
+      while( out_linepos % tab_in != 0 )
+      { out_linepos++;
+      }
+      if( out_linestart )
+      { fprintf(out_fp, "$>%.1f%c {}", tab_out, tab_unit);
+	/* NB {} is required in case nothing follows on this line */
+      }
+      else
+      { fprintf(out_fp, "$>%.1f%ct {}", (out_linepos/tab_in)*tab_out, tab_unit);
+      }
+    }
+  }
+  else if( ch == '\n' )
+  {
+    fputc(ch, out_fp);
+    out_linepos = 0;
+    out_linestart = TRUE;
+  }
+  else
+  {
+    fputc(ch, out_fp);
+    out_linepos++;
+    if( ch != ' ' )
+      out_linestart = FALSE;
+  }
+  if( DEBUG_EMIT )
+    fprintf(stderr, "EmitRaw(%c) returning; out_linepos %d, out_linestart %s\n",
+      ch, out_linepos, out_linestart ? "TRUE" : "FALSE");
+} /* end EmitRaw */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  StartEmit(FILE *err_fp)                                                  */
+/*                                                                           */
+/*  Start the emission of a token.                                           */
+/*                                                                           */
+/*****************************************************************************/
+
+void StartEmit(FILE *err_fp)
+{
+  if( save_on )
+  {
+    fprintf(err_fp, "%s internal error (StartEmit)\n", ErrorHeader());
+    abort();
+  }
+  save_on = TRUE;
+  save_len = 0;
+}
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  EndEmit(LANGUAGE *lang, TOKEN *current_token, FILE *out_fp, *err_fp)     */
+/*                                                                           */
+/*  End emitting a token of this type on file out_fp.                        */
+/*                                                                           */
+/*****************************************************************************/
+
+void EndEmit(LANGUAGE *lang, TOKEN *current_token, FILE *out_fp, FILE *err_fp)
+{ BOOLEAN altern;  int i;
+  if( !save_on )
+  {
+    fprintf(err_fp, "%s internal error (EndEmit)\n", ErrorHeader());
+    abort();
+  }
+  save_on = FALSE;
+
+  if( save_len == 0 )
+  {
+    /* nothing in token, must be resumed after a newline or tab */
+    /* so emit nothing in this case */
+  }
+  else if( current_token->command == (char *) NULL )
+  {
+    /* no command, which means to emit this token without its delimiters */
+    for( i = 0;  i < save_len;  i++ )
+      EmitRaw(save_token[i], out_fp, err_fp);
+  }
+  else
+  {
+    /* if there is an alternate command in this language, check whether the  */
+    /* completed token is a keyword, and if so apply the alternate command.  */
+    altern = (lang != (LANGUAGE *) NULL
+		&& current_token->alternate_command[0] != '\0'
+		&& HashTableRetrieve(save_token));
+
+    putc('{', out_fp);
+    fputs(altern ? current_token->alternate_command : current_token->command,
+      out_fp);
+    putc('"', out_fp);
+    for( i = 0;  i < save_len;  i++ )
+    {
+      if( save_token[i] == '"' || save_token[i] == '\\' )
+	putc('\\', out_fp);
+      EmitRaw(save_token[i], out_fp, err_fp);
+    }
+    putc('"', out_fp);
+    putc('}', out_fp);
+  }
+} /* end EndEmit */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Emit(char ch, TOKEN *current_token, FILE *out_fp, FILE *err_fp)          */
+/*                                                                           */
+/*  Emit one character.                                                      */
+/*                                                                           */
+/*****************************************************************************/
+
+void Emit(char ch, TOKEN *current_token, FILE *out_fp, FILE *err_fp)
+{
+  if( !save_on )
+  {
+    fprintf(err_fp, "%s internal error (EmitChar)\n", ErrorHeader());
+    abort();
+  }
+  if( ch == '\n' || ch == '\t' )
+  {
+    EndEmit((LANGUAGE *) NULL, current_token, out_fp, err_fp);
+    EmitRaw(ch, out_fp, err_fp);
+    StartEmit(err_fp);
+  }
+  else
+  {
+    save_token[save_len++] = ch;
+    save_token[save_len] = '\0';
+  }
+} /* end Emit */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  SetupTokens(LANGUAGE *lang)                                              */
+/*                                                                           */
+/*  Set up the runtime token structures.  This involves initializing the     */
+/*  chtype and escape_chtype fields for each token type in the chosen        */
+/*  language, and loading the trie with all the opening delimiters of all    */
+/*  the tokens.                                                              */
+/*                                                                           */
+/*****************************************************************************/
+#define LEGAL		1
+#define ESCAPE		2
+#define INNER_ESCAPE	3
+
+TRIE Trie = (TRIE) NULL;
+
+void SetupTokens(LANGUAGE *lang, FILE *err_fp)
+{ TOKEN *t; int i, j;
+  if( DEBUG_SETUP )
+    fprintf(stderr, "SetupTokens(%s)\n", lang->names[0]);
+
+  /* set up each token in the language */
+  for( i = 0;  lang->tokens[i] != (TOKEN *) NULL; i++ )
+  {
+    t = lang->tokens[i];
+    if( DEBUG_SETUP )
+      fprintf(stderr, "SetupTokens token starting %s\n", t->starts[0]);
+
+    /* set up the chtype table for this token */
+    for( j = 0;  t->legal[j] != '\0'; j++ )
+      t->chtype[(int) t->legal[j]] = LEGAL;
+    if( t->escape[0] != '\0' )
+      t->chtype[(int) t->escape[0]] = ESCAPE;
+    if( t->inner_escape[0] != '\0' )
+      t->chtype[(int) t->inner_escape[0]] = INNER_ESCAPE;
+
+    /* set up the escape_chtype table for this token */
+    for( j = 0;  t->escape_legal[j] != '\0';  j++ )
+      t->escape_chtype[(int) t->escape_legal[j]] = LEGAL;
+
+    /* load the opening delimiters of this token into the trie */
+    for( j = 0;  t->starts[j] != (char *) NULL;  j++ )
+    {
+      if( !TrieInsert(&Trie, t->starts[j], t) )
+      {
+	if( *(t->starts[j]) == '\0' )
+	  fprintf(err_fp, "%s: empty starting delimiter\n", ErrorHeader());
+	else
+	  fprintf(err_fp, "%s: starting delimiter %s appears twice\n",
+	    ErrorHeader(), t->starts[j]);
+      }
+    }
+
+    if( DEBUG_SETUP )
+      fprintf(stderr, "SetupTokens token ending %s\n", t->starts[0]);
+  }
+
+  /* load the keyword hash table */
+  for( j = 0;  lang->keywords[j] != (char *) NULL;  j++ )
+    HashTableInsert(lang->keywords[j], err_fp);
+
+  if( DEBUG_SETUP )
+    fprintf(stderr, "SetupTokens(%s) returning.\n", lang->names[0]);
+} /* end SetupTokens */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  BOOLEAN PrefixEq(char *str, char *prefix)                                */
+/*                                                                           */
+/*  Returns TRUE if str (unterminated) begins with prefix (terminated).      */
+/*                                                                           */
+/*****************************************************************************/
+
+BOOLEAN PrefixEq(char *str, char *prefix)
+{ char *p, *q;
+  for( p = str, q = prefix; *q != '\0' && *p == *q; p++, q++ );
+  if( DEBUG_PREFIXEQ )
+    fprintf(stderr, "PrefixEq(%s, %s) returning %s\n",
+      str, prefix, *q == '\0' ? "TRUE" : "FALSE");
+  return (*q == '\0');
+} /* end PrefixEq */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  NextChar(FILE *in_fp)                                                    */
+/*                                                                           */
+/*  Move to next character in the input file.  This may involve changing     */
+/*  global variables curr_line, line_num, and line_pos; the new character    */
+/*  may be found in curr_line[line_pos].                                     */
+/*                                                                           */
+/*  NextChar does not skip any characters at all.  When end of file is       */
+/*  reached, curr_line[line_pos] contains '\0'.                              */
+/*                                                                           */
+/*****************************************************************************/
+
+void NextChar(FILE *in_fp)
+{
+  if( curr_line[line_pos] == '\n' )
+  {
+    /* need a new line */
+    line_num++;
+    line_pos = 1;
+    if( fgets(&curr_line[1], MAX_LINE+2, in_fp) == (char *) NULL )
+      curr_line[1] = '\0';
+  }
+  else line_pos++;  /* will yield '\0' as desired if EOF before end of line */
+  if( DEBUG_NEXTCHAR )
+    fprintf(stderr, "after NextChar, line_num %d, line_pos %d, curr_line %s",
+      line_num, line_pos, &curr_line[1]);
+} /* end NextChar */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  BOOLEAN Printable(char ch)                                               */
+/*                                                                           */
+/*  TRUE if ch is a printable character.  Used only by error messages so     */
+/*  can be slow.                                                             */
+/*                                                                           */
+/*****************************************************************************/
+
+BOOLEAN Printable(char ch)
+{ char *p;
+  for( p = AllPrintable;  *p != '\0' && *p != ch;  p++ );
+  return (*p == ch);
+} /* end Printable */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  Process(LANGUAGE*lang, FILE*in_fp, *out_fp, *err_fp, TOKEN *outer_token) */
+/*                                                                           */
+/*  Process a sequence of input tokens.  If we are currently recursing       */
+/*  inside some other token, outer_token is non-null and is that token,      */
+/*  and we stop when we reach the ending delimiter of the inner escape       */
+/*  of that token.  Otherwise, we stop at end of file.                       */
+/*                                                                           */
+/*****************************************************************************/
+#define	START				1
+#define	IN_TOKEN			2
+#define	IN_TOKEN_AFTER_ESCAPE		3
+#define	IN_TOKEN_AFTER_INNER_ESCAPE	4
+#define	STOP				5
+
+void Process(LANGUAGE *lang, FILE *in_fp, FILE *out_fp, FILE *err_fp,
+TOKEN *outer_token)
+{ TOKEN *current_token; int len, i, state;
+  if( DEBUG_PROCESS )
+    fprintf(stderr, "[ Process(%s, -, -, -, -)\n", lang->names[0]);
+
+  state = START;
+  while( curr_line[line_pos] != '\0' && state != STOP )
+  { 
+  if( DEBUG_PROCESS )
+    fprintf(stderr, "  state %d, ch %c\n", state, curr_line[line_pos]);
+  switch( state )
+  {
+    case START:  /* between tokens */
+
+      /* check whether outer_token's delimiter is current */
+      if( outer_token != (TOKEN *) NULL &&
+	  outer_token->end_inner_escape[0] != '\0' &&
+	  PrefixEq(&curr_line[line_pos], outer_token->end_inner_escape) )
+      {
+	len = strlen(outer_token->end_inner_escape);
+	for( i = 0;  i < len;  i++ )
+	  NextChar(in_fp);
+	state = STOP;
+      }
+      else switch( curr_line[line_pos] )
+      {
+
+	case ' ':
+	
+	  EmitRaw(' ', out_fp, err_fp);
+	  NextChar(in_fp);
+	  break;
+
+
+	case '\t':
+	
+	  if( outer_token != (TOKEN *) NULL )
+	  {
+	    fprintf(err_fp, "%s: replacing tab character in escape by space\n",
+	      ErrorHeader());
+	    EmitRaw(' ', out_fp, err_fp);
+	    NextChar(in_fp);
+	  }
+	  else
+	  {
+	    EmitRaw('\t', out_fp, err_fp);
+	    NextChar(in_fp);
+	  }
+	  break;
+
+
+	case '\n':
+	
+	  if( outer_token != (TOKEN *) NULL )
+	  {
+	    fprintf(err_fp, "%s: inserting %s to fix unterminated escape\n",
+	      ErrorHeader(), outer_token->end_inner_escape);
+	    state = STOP;
+	  }
+	  else
+	  {
+	    EmitRaw('\n', out_fp, err_fp);
+	    NextChar(in_fp);
+	  }
+	  break;
+
+
+	case '\f':
+	
+	  if( outer_token != (TOKEN *) NULL )
+	  {
+	    fprintf(err_fp, "%s: replacing formfeed character in escape by space\n",
+	      ErrorHeader());
+	    EmitRaw(' ', out_fp, err_fp);
+	    NextChar(in_fp);
+	  }
+	  else
+	  {
+	    fprintf(out_fp, "\n@NP");
+	    EmitRaw('\n', out_fp, err_fp);
+	    NextChar(in_fp);
+	  }
+	  break;
+
+
+	default:
+
+	  /* look up the trie to see which token we are starting */
+	  current_token = TrieRetrieve(Trie, &curr_line[line_pos], &len);
+	  if( current_token == (TOKEN *) NULL )
+	  {
+	    /* error; no token starts here, so print error message and skip */
+	    if( Printable(curr_line[line_pos]) )
+	      fprintf(err_fp, "%s: skipping unexpected %c character\n",
+		ErrorHeader(), curr_line[line_pos]);
+	    else
+	      fprintf(err_fp,
+		"%s: skipping unexpected unprintable character (octal %o)\n",
+		ErrorHeader(), (int) curr_line[line_pos]);
+	    NextChar(in_fp);
+	  }
+	  else
+	  {
+	    /* have a token, so start emitting it */
+	    if( DEBUG_PROCESS )
+	    {
+	      fprintf(stderr, "current_token (len = %d): %s\n",
+		len, EchoToken(current_token));
+	    }
+	    StartEmit(err_fp);
+	    for( i = 0;  i < len;  i++ )
+	    {
+	      /* ***
+	      if( DEBUG_PROCESS )
+		fprintf(stderr, "  emitting delim (i %d, len %d)\n", i, len);
+	      *** */
+	      if( current_token->command != (char *) NULL )
+	        Emit(curr_line[line_pos], current_token, out_fp, err_fp);
+	      NextChar(in_fp);
+	    }
+	    state = IN_TOKEN;
+	  }
+      }
+      break;
+
+
+    case IN_TOKEN:  /* within a token; current_token says which kind */
+
+      /* check for ending delimiter if there is one */
+      if( current_token->end_delimiter[0] != '\0' &&
+	  PrefixEq(&curr_line[line_pos], current_token->end_delimiter) )
+      {
+	if( DEBUG_PROCESS )
+	  fprintf(stderr, "  PrefixEq(-, %s) so finishing token\n",
+	    current_token->end_delimiter);
+	len = strlen(current_token->end_delimiter);
+	for( i = 0;  i < len;  i++ )
+	{ if( current_token->command != (char *) NULL )
+	    Emit(curr_line[line_pos], current_token, out_fp, err_fp);
+	  NextChar(in_fp);
+	}
+	EndEmit(lang, current_token, out_fp, err_fp);
+	state = START;
+      }
+      else switch( current_token->chtype[(int) curr_line[line_pos]] )
+      {
+
+	case LEGAL:
+
+	  Emit(curr_line[line_pos], current_token, out_fp, err_fp);
+	  NextChar(in_fp);
+	  break;
+
+
+	case ESCAPE:
+
+	  NextChar(in_fp);
+	  state = IN_TOKEN_AFTER_ESCAPE;
+	  break;
+
+
+	case INNER_ESCAPE:
+
+	  EndEmit(lang, current_token, out_fp, err_fp);
+	  NextChar(in_fp);
+	  Process(lang, in_fp, out_fp, err_fp, current_token);
+	  state = IN_TOKEN_AFTER_INNER_ESCAPE;
+	  break;
+
+
+	default:
+
+	  if( current_token->end_delimiter[0] != '\0' )
+	  {
+	    /* error: token ends at delimiter, not at unexpected character */
+	    if( Printable(curr_line[line_pos]) )
+	      fprintf(err_fp, "%s: skipping unexpected %c character in %s\n",
+		ErrorHeader(), curr_line[line_pos], current_token->name);
+	    else
+	      fprintf(err_fp,
+		"%s: skipping unexpected unprintable character (octal %o) in %s\n",
+		ErrorHeader(), (int) curr_line[line_pos], current_token->name);
+	    NextChar(in_fp);
+	  }
+	  else
+	  {
+	    /* normal termination after last legal character */
+	    EndEmit(lang, current_token, out_fp, err_fp);
+	    state = START;
+	  }
+	  break;
+
+
+      }
+      break;
+      
+
+    case IN_TOKEN_AFTER_ESCAPE:
+
+      if( current_token->escape_chtype[(int) curr_line[line_pos]] == LEGAL )
+      {
+	Emit(current_token->escape[0], current_token, out_fp, err_fp);
+	Emit(curr_line[line_pos], current_token, out_fp, err_fp);
+      }
+      else
+      {
+	if( Printable(curr_line[line_pos]) )
+	  fprintf(err_fp, "%s: skipping %c%c in %s, since %c not legal here\n",
+	    ErrorHeader(), current_token->escape[0], curr_line[line_pos],
+	    current_token->name, curr_line[line_pos]);
+	else
+	  fprintf(err_fp,
+	    "%s: skipping %c and unprintable unexpected character (octal %o)\n",
+	     ErrorHeader(), current_token->escape[0], (int) curr_line[line_pos]);
+      }
+      NextChar(in_fp);
+      state = IN_TOKEN;
+      break;
+
+
+    case IN_TOKEN_AFTER_INNER_ESCAPE:
+
+      /* ending delimiter of inner escape has been read over */
+      StartEmit(err_fp);
+      state = IN_TOKEN;
+      break;
+
+
+    default:
+
+      fprintf(err_fp, "%s internal error (state = %d)\n",
+	ErrorHeader(), state);
+      abort();
+      break;
+  }
+  }
+
+  /* at end, need to tidy up any residual messiness */
+  switch( state )
+  {
+
+    case START:
+    case STOP:
+
+      /* we stopped outside any token, or after an escape */
+      break;
+
+
+    case IN_TOKEN:
+
+      /* we stopped in a token (only a problem if it ends with a delimiter) */
+      if( current_token->end_delimiter[0] != '\0' )
+      {
+	if( outer_token == (TOKEN *) NULL )
+	  fprintf(err_fp, "%s: program text ended within %s\n", 
+	    ErrorHeader(), current_token->name);
+	else
+	  fprintf(err_fp, "%s: %s escape ended within %s\n",
+	    ErrorHeader(), outer_token->name, current_token->name);
+	EndEmit(lang, current_token, out_fp, err_fp);
+      }
+      break;
+
+
+    case IN_TOKEN_AFTER_ESCAPE:
+
+      /* we stopped after the escape character */
+      fprintf(err_fp, "%s: skipping %c at end of program text\n",
+	ErrorHeader(), current_token->escape[0]);
+      EndEmit(lang, current_token, out_fp, err_fp);
+      break;
+
+
+    case IN_TOKEN_AFTER_INNER_ESCAPE:
+
+      /* we stopped after an inner escape (NB no EndEmit in this case) */
+      if( current_token->end_delimiter[0] != '\0' )
+      {
+	if( outer_token == (TOKEN *) NULL )
+	  fprintf(err_fp, "%s: program text ended within %s after escape\n", 
+	    ErrorHeader(), current_token->name);
+	else
+	  fprintf(err_fp, "%s: %s escape ended within %s after escape\n",
+	    ErrorHeader(), outer_token->name, current_token->name);
+      }
+      break;
+
+
+    default:
+
+      fprintf(err_fp, "%s: internal error (state %d)\n",
+	ErrorHeader(), state);
+      abort();
+      break;
+
+  }
+} /* end Process */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  PrintUsage(fp)                                                           */
+/*                                                                           */
+/*  Print usage message on file fp.                                          */
+/*                                                                           */
+/*****************************************************************************/
+
+void PrintUsage(FILE *fp)
+{ int i;
+  fprintf(fp, "\n");
+  fprintf(fp, "usage: prg2lout <options> <files>\n\n");
+  fprintf(fp, "    where <options> can be\n");
+  fprintf(fp, "\n");
+  fprintf(fp, "    -r           raw mode (used within Lout only)\n");
+  fprintf(fp, "    -i<file>     take input from <file>\n");
+  fprintf(fp, "    -o<file>     send output to <file>\n");
+  fprintf(fp, "    -e<file>     send error messages to <file>\n");
+  fprintf(fp, "    -l<language> input is in this programming language\n");
+  fprintf(fp, "    -p<style>    print style: fixed, varying, symbol\n");
+  fprintf(fp, "    -f<family>   font family (e.g. Times)\n");
+  fprintf(fp, "    -s<size>     font size (e.g. 10p or 12p)\n");
+  fprintf(fp, "    -v<space>    line spacing (e.g. 1.1fx)\n");
+  fprintf(fp, "    -t<num>      tab interval (e.g. 8 is default)\n");
+  fprintf(fp, "    -T<dist>     output tab interval (e.g. 0.5i)\n");
+  fprintf(fp, "    -n           no file names as page headers\n");
+  fprintf(fp, "    -V           print version information and exit\n");
+  fprintf(fp, "    -u           print this usage message and exit\n");
+  fprintf(fp, "\n");
+  fprintf(fp, "    and <language> (which is compulsory) can be any one of:\n");
+  for( i = 0;  languages[i] != (LANGUAGE *) NULL;  i++ )
+    fprintf(fp, "        %s\n", languages[i]->names[0]);
+  fprintf(fp, "\n");
+} /* end PrintUsage */
+
+
+/*****************************************************************************/
+/*                                                                           */
+/*  main(argc, argv)                                                         */
+/*                                                                           */
+/*  Read command line and either process each file in turn, or, in the       */
+/*  raw case, do the actual conversion of one file.                          */
+/*                                                                           */
+/*****************************************************************************/
+
+int main(int argc, char *argv[])
+{ FILE *in_fp, *out_fp, *err_fp;
+  BOOLEAN stdin_seen;  int i, j, arg_pos;
+  char *infilename, *outfilename, *errfilename, *str;
+  LANGUAGE *language = (LANGUAGE *) NULL;
+  char *file_names[1024];  int file_count = 0;
+
+  /* echo command line */
+  if( DEBUG_MAIN )
+  {
+    for( i = 0;  i < argc;  i++ )
+      fprintf(stderr, i == 0 ? "%s" : " %s", argv[i]);
+    fprintf(stderr, "\n\n");
+  }
+
+  /* read command line */
+  in_fp = out_fp = (FILE *) NULL;
+  err_fp = stderr;
+  line_num = 0;
+  stdin_seen = raw_seen = FALSE;
+  tab_by_spacing = TRUE;
+  style_option = NO_STYLE;
+  tab_in = 8;
+  tab_out = 3;
+  tab_unit = 'f';
+  headers_option = TRUE;
+  font_option = size_option = line_option = tabin_option =
+    tabout_option = language_option = (char *) NULL;
+  if( argc == 1 )
+  { PrintUsage(err_fp);
+    exit(1);
+  }
+  for( arg_pos = 1;  arg_pos < argc;  arg_pos++ )
+  {
+    if( DEBUG_SETUP )
+      fprintf(stderr, "examining argument %d = \"%s\"\n",
+	arg_pos, argv[arg_pos]);
+    if( *argv[arg_pos] == '-' ) switch( *(argv[arg_pos]+1) )
+    {
+      case 'r':
+
+	if( arg_pos > 1 )
+	{ fprintf(err_fp, "%s: -r must be first if it occurs at all\n",
+	    ErrorHeader());
+	  exit(1);
+	}
+	raw_seen = TRUE;
+	break;
+
+
+      case 'i':
+     
+	/* read name of input file */
+	if( !raw_seen )
+	{ fprintf(err_fp, "%s: -i illegal with -r\n", ErrorHeader());
+	  exit(1);
+	}
+	if( in_fp != NULL )
+	{ fprintf(err_fp, "%s: -i seen twice\n", ErrorHeader());
+	  exit(1);
+	}
+	GetArg(infilename, "usage: -i<filename>", FALSE);
+
+	/* open the file */
+	in_fp = fopen(infilename, "r");
+	if( in_fp == NULL )
+	{ fprintf(err_fp, "%s: cannot open input file %s\n",
+	    ErrorHeader(), infilename);
+	  exit(1);
+	}
+
+	/* initialize file position */
+	strcpy(file_name, infilename);
+	line_num = 1;
+	line_pos = 0;
+	break;
+
+
+      case 'o':
+     
+	/* read name of output file */
+	if( out_fp != NULL )
+	{ fprintf(err_fp, "%s: -o seen twice\n", ErrorHeader());
+	  exit(1);
+	}
+	GetArg(outfilename, "usage: -o<filename>", FALSE);
+	out_fp = fopen(outfilename, "w");
+	if( out_fp == NULL )
+	{ fprintf(err_fp, "%s: cannot open output file %s\n",
+	    ErrorHeader(), outfilename);
+	  exit(1);
+	}
+	break;
+
+
+      case 'e':
+     
+	/* read name of error file */
+	GetArg(errfilename, "usage: -e<filename>", FALSE);
+	err_fp = fopen(errfilename, "w");
+	if( err_fp == NULL )
+	{ fprintf(stderr, "%s: cannot open error file %s",
+	    ErrorHeader(), errfilename);
+	  exit(1);
+	}
+	break;
+
+
+      case 'p':
+     
+	/* read print style */
+	if( raw_seen )
+	{ fprintf(err_fp, "%s: -p illegal with -r option\n", ErrorHeader());
+	  exit(1);
+	}
+	GetArg(str, "usage: -p<printstyle>", FALSE);
+	/* *** -l can set style, so don't do this now 
+	if( style_option != NO_STYLE )
+	{ fprintf(err_fp, "%s: -p option appears twice!\n", ErrorHeader());
+	  exit(1);
+	}
+	else
+	*** */
+	if( strcmp(str, "fixed") == 0 )
+	{ style_option = FIXED_STYLE;
+	}
+	else if( strcmp(str, "varying") == 0 )
+	{ style_option = VARYING_STYLE;
+	  tab_by_spacing = FALSE;
+	}
+	else if( strcmp(str, "symbol") == 0 )
+	{ style_option = SYMBOL_STYLE;
+	  tab_by_spacing = FALSE;
+	}
+	else
+	{ fprintf(err_fp, "%s: unknown -p option %s\n", ErrorHeader(), str);
+	  exit(1);
+	}
+	break;
+
+
+      case 'f':
+     
+	/* read font family */
+	if( raw_seen )
+	{ fprintf(err_fp, "%s: -f illegal with -r option\n", ErrorHeader());
+	  exit(1);
+	}
+	GetArg(font_option, "usage: -f<font_family>", FALSE);
+	break;
+
+
+      case 's':
+     
+	/* read font size */
+	if( raw_seen )
+	{ fprintf(err_fp, "%s: -s illegal with -r option\n", ErrorHeader());
+	  exit(1);
+	}
+	GetArg(size_option, "usage: -s<size>", FALSE);
+	break;
+
+
+      case 'v':
+     
+	/* read line spacing */
+	if( raw_seen )
+	{ fprintf(err_fp, "%s: -v illegal with -r option\n", ErrorHeader());
+	  exit(1);
+	}
+	GetArg(line_option, "usage: -v<line_spacing>", FALSE);
+	break;
+
+
+      case 't':
+     
+	/* read tab interval */
+	GetArg(tabin_option, "usage: -t<number>", TRUE);
+	if( tabin_option != NULL && sscanf(tabin_option,"%d",&tab_in) != 1 )
+	{ fprintf(err_fp, "%s usage: -t<number>\n", ErrorHeader());
+	  exit(1);
+	}
+	if( tab_in <= 0 )
+	{ fprintf(err_fp, "%s -t: tab interval must be greater than 0\n",
+	    ErrorHeader());
+	  exit(1);
+	}
+	break;
+
+
+      case 'T':
+     
+	/* read tab_out and tab_unit */
+	GetArg(tabout_option, "usage: -T<number><unit>", TRUE);
+	if( tabout_option != NULL )
+	{ if( sscanf(tabout_option, "%f%c",&tab_out,&tab_unit) != 2 )
+	  { fprintf(err_fp, "%s usage: -T<number><unit>\n", ErrorHeader());
+	    exit(1);
+	  }
+	  if( tab_out <= 0 || tab_out >= 50 )
+	  { fprintf(err_fp, "%s -T: unreasonably large or small tab interval\n",
+	      ErrorHeader());
+	    exit(1);
+	  }
+	  if( tab_unit != 'c' && tab_unit != 'i' && tab_unit != 'p' &&
+	      tab_unit != 'm' && tab_unit != 'f' && tab_unit != 's' &&
+	      tab_unit != 'v' )
+	  { fprintf(err_fp, "%s -T: tab unit must be one of cipmfsv\n",
+	      ErrorHeader());
+	    exit(1);
+	  }
+	  tab_by_spacing = FALSE;
+	}
+	break;
+
+
+      case 'n':
+     
+	if( raw_seen )
+	{ fprintf(err_fp, "%s: -n illegal with -r option\n", ErrorHeader());
+	  exit(1);
+	}
+	headers_option = FALSE;
+	break;
+
+
+      case 'V':
+     
+	if( raw_seen )
+	{ fprintf(err_fp, "%s: -V illegal with -r option\n", ErrorHeader());
+	  exit(1);
+	}
+	fprintf(err_fp, "%s\n", PROG2LOUT_VERSION);
+	exit(0);
+	break;
+
+
+      case 'u':
+     
+	if( raw_seen )
+	{ fprintf(err_fp, "%s: -u illegal with -r option\n", ErrorHeader());
+	  exit(1);
+	}
+	PrintUsage(err_fp);
+	exit(0);
+	break;
+
+
+      case 'l':
+     
+	if( language_option != (char *) NULL )
+	{ fprintf(err_fp, "%s: -l seen twice\n", ErrorHeader());
+	  exit(1);
+	}
+	GetArg(language_option, "usage: -l<language>", FALSE);
+	for( i = 0;  languages[i] != (LANGUAGE *) NULL;  i++ )
+	{
+	  for( j = 0;  languages[i]->names[j] != (char *) NULL;  j++ )
+	  {
+	    if( strcmp(languages[i]->names[j], language_option) == 0 )
+	      break;
+	  }
+	  if( languages[i]->names[j] != (char *) NULL )
+	    break;
+	}
+	if( languages[i] != (LANGUAGE *) NULL )
+	{
+	  language = languages[i];
+	}
+	else
+	{
+	  fprintf(err_fp, "%s: unknown language %s\n", ErrorHeader(),
+	    language_option);
+	  exit(1);
+	}
+
+	/* set style unless already done by a -p flag */
+	if( style_option == NO_STYLE )
+	{
+	  if( strcmp(language->default_style, "fixed") == 0 )
+	  { style_option = FIXED_STYLE;
+	  }
+	  else if( strcmp(language->default_style, "varying") == 0 )
+	  { style_option = VARYING_STYLE;
+	    tab_by_spacing = FALSE;
+	  }
+	  else if( strcmp(language->default_style, "symbol") == 0 )
+	  { style_option = SYMBOL_STYLE;
+	    tab_by_spacing = FALSE;
+	  }
+	  else
+	  { fprintf(err_fp,
+	      "%s internal error: bad default print style for language %s\n",
+	      ErrorHeader(), language_option);
+	    abort();
+	  }
+	}
+	break;
+
+
+      default:
+     
+	fprintf(err_fp, "%s: unknown command line flag %s\n", ErrorHeader(),
+	  argv[i]);
+	exit(1);
+	break;
+
+    }
+    else
+    {
+      if( raw_seen )
+      { fprintf(err_fp, "%s: file parameter illegal with -r flag\n",
+	    ErrorHeader());
+	  exit(1);
+      }
+      if( DEBUG_SETUP )
+	fprintf(stderr, "file_names[%d++] = argv[%d] = %s\n",
+	  file_count, arg_pos, argv[arg_pos]);
+      file_names[file_count++] = argv[arg_pos];
+    }
+  } /* for */
+
+  /* make sure we have a language */
+  if( language == (LANGUAGE *) NULL )
+  {
+    fprintf(err_fp, "%s: missing -l option\n", ErrorHeader());
+    exit(0);
+  }
+
+  /* do the actual work */
+  if( raw_seen )
+  {
+    /* check that input and output files are open */
+    if( in_fp == NULL )
+      in_fp = stdin;
+    if( out_fp == NULL )
+    { fprintf(err_fp, "%s -r: missing -o option\n", ErrorHeader());
+      exit(1);
+    }
+
+    /* process the file */
+    SetupTokens(language, err_fp);
+    line_pos = 1;
+    curr_line[line_pos] = '\n';  /* forces line read */
+    line_num = 0;
+    NextChar(in_fp);
+    Process(language, in_fp, out_fp, err_fp, (TOKEN *) NULL);
+  }
+  else if( file_count > 0 )
+  {
+    int ch;
+    char *style_str, *font_str, *size_str, *line_str, *face_str;
+    char *tabin_str, *tabout_str;
+
+    /* sort out the options' values */
+    switch( style_option )
+    {
+
+      case FIXED_STYLE:
+
+	style_str  = "fixed";
+	face_str   = "Base";
+	font_str   = font_option   != NULL ? font_option   : "Courier";
+	size_str   = size_option   != NULL ? size_option   : "9p";
+	line_str   = line_option   != NULL ? line_option   : "1.1fx";
+	tabin_str  = tabin_option  != NULL ? tabin_option  : "8";
+	tabout_str = tabout_option != NULL ? tabout_option : "8s";
+	break;
+
+
+      case NO_STYLE:
+      case VARYING_STYLE:
+
+	style_str  = "varying";
+	face_str   = "Slope";
+	font_str   = font_option   != NULL ? font_option   : "Times";
+	size_str   = size_option   != NULL ? size_option   : "10p";
+	line_str   = line_option   != NULL ? line_option   : "1.1fx";
+	tabin_str  = tabin_option  != NULL ? tabin_option  : "8";
+	tabout_str = tabout_option != NULL ? tabout_option : "3f";
+	break;
+
+
+      case SYMBOL_STYLE:
+
+	style_str  = "symbol";
+	face_str   = "Slope";
+	font_str   = font_option   != NULL ? font_option   : "Times";
+	size_str   = size_option   != NULL ? size_option   : "10p";
+	line_str   = line_option   != NULL ? line_option   : "1.1fx";
+	tabin_str  = tabin_option  != NULL ? tabin_option  : "8";
+	tabout_str = tabout_option != NULL ? tabout_option : "3f";
+	break;
+
+
+      default:
+
+	fprintf(err_fp, "%s internal error in -p option\n", ErrorHeader());
+	abort();
+	break;
+    }
+		 
+    /* make sure we have an output file */
+    if( out_fp == (FILE *) NULL )
+      out_fp = stdout;
+
+    /* print the initial @Use clauses etc.*/
+    fprintf(out_fp, "%s%s\n", "@Sy", "sInclude { progf }");
+    fprintf(out_fp, "%s%s\n", "@Sy", "sInclude { doc }");
+    fprintf(out_fp, "@Use { @ProgSetup\n");
+    fprintf(out_fp, "    language  { %s }\n", language_option);
+    fprintf(out_fp, "    style  { %s }\n", style_str);
+    fprintf(out_fp, "    %sfont   { %s }\n", style_str, font_str);
+    fprintf(out_fp, "    %ssize   { %s }\n", style_str, size_str);
+    fprintf(out_fp, "    %sline   { %s }\n", style_str, line_str);
+    fprintf(out_fp, "    %stabin  { %s }\n", style_str, tabin_str);
+    fprintf(out_fp, "    %stabout { %s }\n", style_str, tabout_str);
+    fprintf(out_fp, "}\n");
+    fprintf(out_fp, "@Document\n");
+    fprintf(out_fp, "    @InitialFont { \"%s\" \"%s\" \"%s\" }\n",
+      font_str, face_str, size_str);
+    fprintf(out_fp, "    @InitialBreak { lines \"%s\" nohyphen }\n", line_str);
+    fprintf(out_fp, "//\n");
+    fprintf(out_fp, "%s%s\n", "@Text @Be", "gin");
+ 
+    /* print each file, possibly with a header */
+    for( i = 0;  i < file_count;  i++ )
+    {
+      /* open file and initialize file position */
+      in_fp = fopen(file_names[i], "r");
+      if( in_fp == NULL )
+      { fprintf(err_fp, "%s: skipping input file %s (cannot open)\n",
+	  ErrorHeader(), file_names[i]);
+        continue;
+      }
+      strcpy(file_name, file_names[i]);
+
+      /* print @NP if not first, and header if required */
+      if( i > 0 )
+	fprintf(out_fp, "\n\n@NP\n\n");
+      if( headers_option )
+	fprintf(out_fp, "{ Times Bold \"+3p\" } @Font \"%s\"\n@DP\n",
+	  file_names[i]);
+
+      /* print file name and contents (don't format, let Lout call back) */
+      /* this string has been disguised so as not to fool progwlout!     */
+      fprintf(out_fp, "%s%s%s\n", "@P", "rog @Be", "gin");
+      while( (ch = getc(in_fp)) != EOF )
+        putc(ch, out_fp);
+      fprintf(out_fp, "%s%s%s\n", "@E", "nd @P", "rog");
+    }
+
+    /* finish off whole input */
+    fprintf(out_fp, "%s%s%s\n", "@E", "nd @T", "ext");
+
+  }
+  exit(0);
+} /* end main */