/*****************************************************************************/
/* */
/* 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 */
