PROFF - Portable ROFF (3 of 5)
Ozan Yigit
oz at yetti.UUCP
Tue Jan 14 15:00:13 AEST 1986
#!/bin/sh
# This is a shell archive, meaning:
# 1. Remove everything above the #!/bin/sh line.
# 2. Save the resulting text in a file.
# 3. Execute the file with /bin/sh (not csh) to create the files:
# debug.h
# defs.h
# dostuff2.c
# eval.c
# look.c
# lookup.c
# lookup.h
# ltb.c
# makefile
# map.c
# This archive created: Mon Jan 13 23:53:32 1986
export PATH; PATH=/bin:$PATH
echo shar: extracting "'debug.h'" '(126 characters)'
if test -f 'debug.h'
then
echo shar: over-writing existing file "'debug.h'"
fi
sed 's/^X//' << \SHAR_EOF > 'debug.h'
X
X
X
X/*
X#define DEBUG
X#define PROFILE
X*/
X
X#ifdef PROFILE
X#define dprintf(str) printf((str));
X#else
X#define dprintf(str)
X#endif
X
SHAR_EOF
if test 126 -ne "`wc -c 'debug.h'`"
then
echo shar: error transmitting "'debug.h'" '(should have been 126 characters)'
fi
echo shar: extracting "'defs.h'" '(1580 characters)'
if test -f 'defs.h'
then
echo shar: over-writing existing file "'defs.h'"
fi
sed 's/^X//' << \SHAR_EOF > 'defs.h'
X
X/*
X * defs.h
X *
X * #define rainbow - rainbow CP/M-86 version
X * #define vms - vms version (predefined by VAX11C compiler)
X * #define unix - unix version
X */
X
X/*
X * Synonyms for ASCII control characters
X *
X */
X
X#define BACKSPACE 8
X#define BEL 7
X#define BELL 7
X#define BLANK 32
X#define CARRIAGE_RETURN 13
X#define NEWLINE 10
X#define RUBOUT 127
X#define TAB 9
X
X/*
X * misc. definitions
X *
X */
X
X#define EOS 0
X#define HUGE 30000
X#define NO 0
X#define OK 0
X#define YES 1
X#define FALSE 0
X#define TRUE 1
X#define FILENAMESIZE 50
X#define MAXCHARS 20
X#define MAXLINE 256
X#define MAXTOK 80
X#define ARB MAXLINE
X
X#define MAXCARD MAXLINE-1
X#define MAXNAME FILENAMESIZE
X
X#define NCHARS 33
X#define MAXOFILES 12
X
X#define ARGFLAG '$'
X#define INSIZE MAXLINE
X#define MAXOUT 2*MAXLINE
X#define MAXDEF 200
X#define NFILES MAXOFILES-4
X#define PAGENUM '#'
X#define CURRENTDATE '%'
X#define ESCAPE '@'
X#define VESCAPE '$'
X#define PAGEJECT 12 /* 12 is ASCII formfeed (control-L) */
X#define PAGEWIDTH 65
X#define PAGELEN 62
X#define BUFSIZE 512 /* push back buffer */
X/*
X * lexical analyser values
X *
X * include lexical analyser return constants
X * generated by ltb.
X *
X */
X#include "lextab.d" /* expended format & roff & runoff */
X
X#define UNKNOWN 999
X#define MACRO 0
X#define NEGATED -1
X#define LEFT 1
X#define CENTER 2
X#define RIGHT 3
X
X/*
X * structure definition for contents linked list
X *
X */
X
Xstruct clist { /* list struct for contents */
X char level;
X char *str;
X int page;
X struct clist *nextc;
X};
X
X#undef putchar
X#define putchar(c) putc((c),poutput);
X
SHAR_EOF
if test 1580 -ne "`wc -c 'defs.h'`"
then
echo shar: error transmitting "'defs.h'" '(should have been 1580 characters)'
fi
echo shar: extracting "'dostuff2.c'" '(2884 characters)'
if test -f 'dostuff2.c'
then
echo shar: over-writing existing file "'dostuff2.c'"
fi
sed 's/^X//' << \SHAR_EOF > 'dostuff2.c'
X
X
X
X
X#include <stdio.h>
X#include <ctype.h>
X#include "proff.h"
X#include "debug.h"
X
X/*
X * dodef - define a command macro (".de xx" is in buf.)
X *
X */
Xdodef(buf,fd)
Xchar buf[];
Xint fd;
X{
X char name[MAXNAME],defn[MAXDEF];
X int i,junk;
X
X dprintf("dodef ");
X i = 0;
X junk = getwrd(buf, &i, name);
X i = getwrd(buf, &i, name); /* get the name */
X if (i == 0)
X error("missing name in command def.");
X i = 0;
X while (ngetln(buf,fd) != NULL) {
X if (buf[0] == cchar && buf[1] == 'e' &&
X buf[2] == 'n' && !isalnum(buf[3]))
X break;
X junk = addstr(buf, defn, &i, MAXDEF);
X }
X if (addset(EOS, defn, &i, MAXDEF) == NO)
X error("definition too long.\n");
X if (install(name, defn, macrotab) == NULL)
X fprintf(stderr,"no room for new definition.\n");
X#ifdef DEBUG
X printf("dodef: %s (name) %s (defn)\n",name,defn);
X#endif
X}
X
X/*
X * doesc - expand escapes in buf
X *
X */
Xdoesc(buf, tbuf, size)
Xchar buf[];
Xchar tbuf[];
Xint size;
X{
X int i,j;
X
X dprintf("doesc ");
X j = 0;
X for (i = 0; buf[i] != EOS && j < size-1; i++)
X /*
X * clean up generic escapes along the way.
X */
X if (buf[i] == genesc)
X tbuf[j++] = buf[++i];
X
X else if (buf[i] != ESCAPE) {
X tbuf[j] = buf[i];
X j++;
X }
X else if (buf[i+1] == 'n' &&
X (buf[i+2] >= 'a' && buf[i+2] <= 'z')) {
X j += itoc(nr[buf[i+2] - 'a'],
X &tbuf[j], size - j - 1);
X i += 2;
X }
X else {
X tbuf[j] = buf[i];
X j++;
X }
X tbuf[j] = EOS;
X strcpy(buf, tbuf);
X}
X
X/*
X * dovar - expand variables in buf
X *
X */
Xdovar(tbuf, buf)
Xchar *buf;
Xchar *tbuf;
X{
X register char *c, *p, t;
X struct hashlist *xp;
X
X while (*buf != '\0') {
X if (*buf == genesc) {
X *tbuf++ = *buf++;
X *tbuf++ = *buf;
X }
X else if (*buf != VESCAPE)
X *tbuf++ = *buf;
X else {
X buf++; /* skip the ESCAPE */
X if (*buf == '{')
X buf++;
X p = buf; /* save the beginning address of variable */
X while (isalnum(*buf))
X buf++;
X t = *buf; /* save the character*/
X *buf = '\0'; /* hack a null there */
X if ((xp = lookup(p,gentab)) != NULL) {
X c = xp->def; /* point to def */
X while (*c != '\0')
X *tbuf++ = *c++;
X }
X if (*(p-1) != '{')
X *tbuf++ = t;
X else if (t != '}')
X fprintf(stderr, "missing \"}\" in %s\n",p);
X }
X buf++;
X }
X *tbuf = '\0';
X}
X
X
X/*
X * dotabs - expand tabs in buf
X *
X */
Xdotabs(buf,tbuf,size)
Xchar buf[];
Xchar tbuf[];
Xint size;
X{
X int i,j;
X dprintf("dotabs ");
X
X j = 0;
X for (i = 0; buf[i] != EOS && j < size - 1; i++)
X if (buf[i] == '\t')
X while (j < size - 1) {
X tbuf[j] = ' ';
X j++;
X if (tabs[j] == YES || j > INSIZE)
X break;
X }
X else {
X tbuf[j] = buf[i];
X j++;
X }
X tbuf[j] = EOS;
X strcpy(buf, tbuf);
X}
X
X/*
X * docline - produce a "contents" line.
X *
X */
Xdocline(str,width,cline,page)
Xchar *str;
Xint width;
Xchar *cline;
Xint page;
X{
X int i;
X
X for (i = 0; i < width - 6 && cline[i] != '\0'; i++)
X str[i] = cline[i];
X while (i < width - 6)
X str[i++] = '.';
X sprintf(str+i,"%5d\n",page);
X}
X
SHAR_EOF
if test 2884 -ne "`wc -c 'dostuff2.c'`"
then
echo shar: error transmitting "'dostuff2.c'" '(should have been 2884 characters)'
fi
echo shar: extracting "'eval.c'" '(1298 characters)'
if test -f 'eval.c'
then
echo shar: over-writing existing file "'eval.c'"
fi
sed 's/^X//' << \SHAR_EOF > 'eval.c'
X
X
X#include <stdio.h>
X#include <ctype.h>
X#include "proff.h"
X#include "debug.h"
X
X
X/*
X * eval - evaluate defined command (push back definition)
X *
X */
Xeval(buf,defn)
Xchar buf[];
Xchar defn[];
X{
X register int j,k;
X int i;
X int argptr[10];
X
X for (i = 0; i < 10 ; i++)
X argptr[i] = 0;
X
X buf[0] = '\0'; /* buf[0] is cchar */
X dprintf(defn);
X dprintf("eval ");
X i = 1;
X argptr[0] = 1; /* first parm is macro name */
X while (buf[i] != ' ' && buf[i] != '\t' &&
X buf[i] != '\n' && buf[i] != '\0')
X i++;
X buf[i++] = '\0'; /* EOS terminate */
X /*
X * start scanning remaining macro parameters.
X * delimiters are blanks or commas. Any string
X * enclosed with double quotes are accepted as
X * parameters as well
X *
X */
X for (j = 1; j < 10; j++) {
X skipbl(buf, &i);
X if (buf[i] == '\n' || buf[i] == '\0')
X break;
X argptr[j] = i;
X while (buf[i] != ' ' && buf[i] != '\t' &&
X buf[i] != ',' && buf[i] != '\n' && buf[i] != '\0')
X i++;
X buf[i] = '\0';
X i++;
X }
X for (k = strlen(defn) - 1; k >= 0; k--)
X if (defn[k-1] != ARGFLAG)
X putbak(defn[k]);
X else {
X if (defn[k] < '0' || defn[k] > '9')
X putbak(defn[k]);
X else {
X i = defn[k] - '0';
X i = argptr[i];
X pbstr(&buf[i]);
X k--; /* skip over $ */
X }
X }
X if (k = 0) /* do the last character */
X putbak(defn[k]);
X}
X
SHAR_EOF
if test 1298 -ne "`wc -c 'eval.c'`"
then
echo shar: error transmitting "'eval.c'" '(should have been 1298 characters)'
fi
echo shar: extracting "'look.c'" '(2939 characters)'
if test -f 'look.c'
then
echo shar: over-writing existing file "'look.c'"
fi
sed 's/^X//' << \SHAR_EOF > 'look.c'
X
X
X
X
X/*
X * from K&R "The C Programming language"
X * Table lookup routines
X *
X */
X#include <stdio.h>
X#include "lookup.h"
X/*
X * hash - for a hash value for string s
X *
X */
Xhash(s)
Xchar *s;
X{
X int hashval;
X
X for (hashval = 0; *s != '\0';)
X hashval += *s++;
X return (hashval % HASHMAX);
X}
X
X/*
X * lookup - lookup for a string s in the hash table
X *
X */
Xstruct hashlist
X*lookup(s, hashtab)
Xchar *s;
Xstruct hashlist *hashtab[];
X{
X struct hashlist *np;
X
X for (np = hashtab[hash(s)]; np != NULL; np = np->next)
X if (strcmp(s, np->name) == 0)
X return(np); /* found */
X return(NULL); /* not found */
X}
X
X/*
X * install - install a string name in hashtable and its value def
X * at a given hashtable.
X */
Xstruct hashlist
X*install(name,def,hashtab)
Xchar *name;
Xchar *def;
Xstruct hashlist *hashtab[];
X{
X int hashval;
X struct hashlist *np, *lookup();
X char *strsave(), *malloc();
X
X if ((np = lookup(name, hashtab)) == NULL) { /* not found.. */
X np = (struct hashlist *) malloc(sizeof(*np));
X if (np == NULL)
X return(NULL);
X if ((np->name = strsave(name)) == NULL)
X return(NULL);
X hashval = hash(np->name);
X np->next = hashtab[hashval];
X hashtab[hashval] = np;
X } else /* found.. */
X free(np->def); /* free prev. */
X if ((np->def = strsave(def)) == NULL)
X return(NULL);
X return(np);
X}
X
X/*
X * strsave - save string s somewhere
X *
X */
Xchar
X*strsave(s)
Xchar *s;
X{
X char *p, *malloc();
X register int n;
X
X n = strlen(s) + 1;
X if ((p = malloc(n)) != NULL)
X strcpy(p, s);
X return(p);
X}
X
X/*
X * lexinstal - instal a string name in hashtable and its value
X * used by lexical analyser to quickly match a token
X * and return its lexical value.
X *
X */
Xstruct lexlist
X*lexinstal(name,val,flag,lextable)
Xchar *name;
Xint val;
Xint flag;
Xstruct lexlist *lextable[];
X{
X int hashval;
X struct lexlist *np,*lexlook();
X char *strsave(), *malloc();
X
X if ((np = lexlook(name,lextable)) == NULL) { /* not found.. */
X np = (struct lexlist *) malloc(sizeof(*np));
X if (np == NULL)
X return(NULL);
X if ((np->name = strsave(name)) == NULL)
X return(NULL);
X hashval = hash(np->name);
X np->link = lextable[hashval];
X lextable[hashval] = np;
X }
X np->val = val; /* replace prev */
X np->flag = flag;
X return(np);
X}
X
X/*
X * lexlook - lookup for a string s in the hash table
X * used by lexinstal only.
X *
X */
Xstruct lexlist
X*lexlook(s,table)
Xchar *s;
Xstruct lexlist *table[];
X{
X struct lexlist *np;
X
X for (np = table[hash(s)]; np != NULL; np = np->link)
X if (strcmp(s, np->name) == 0)
X return(np); /* found */
X return(NULL); /* not found */
X}
X
X/*
X * remove an item from the hash table forever
X *
X */
Xstruct lexlist
X*remove(s, table)
Xchar *s;
Xstruct lexlist *table[];
X{
X struct lexlist *np, *xp;
X
X np = table[hash(s)];
X xp = np;
X while (np != NULL) {
X if (strcmp(s, np->name) == 0) {
X xp->link = np->link; /* remove the link */
X return(np); /* return the lost */
X }
X xp = np;
X np = np->link;
X }
X return(NULL);
X}
X
SHAR_EOF
if test 2939 -ne "`wc -c 'look.c'`"
then
echo shar: error transmitting "'look.c'" '(should have been 2939 characters)'
fi
echo shar: extracting "'lookup.c'" '(3017 characters)'
if test -f 'lookup.c'
then
echo shar: over-writing existing file "'lookup.c'"
fi
sed 's/^X//' << \SHAR_EOF > 'lookup.c'
X
X
X
X
X/*
X * from K&R "The C Programming language"
X * Table lookup routines
X *
X */
X#include <stdio.h>
X#include "proff.h"
X/*
X * hash - for a hash value for string s
X *
X */
Xhash(s)
Xchar *s;
X{
X int hashval;
X
X for (hashval = 0; *s != '\0';)
X hashval += *s++;
X return (hashval % HASHMAX);
X}
X
X/*
X * lookup - lookup for a string s in the hash table
X *
X */
Xstruct hashlist
X*lookup(s, hashtab)
Xchar *s;
Xstruct hashlist *hashtab[];
X{
X struct hashlist *np;
X
X for (np = hashtab[hash(s)]; np != NULL; np = np->next)
X if (strcmp(s, np->name) == 0)
X return(np); /* found */
X return(NULL); /* not found */
X}
X
X/*
X * install - install a string name in hashtable and its value def
X * at a given hashtable.
X */
Xstruct hashlist
X*install(name,def,hashtab)
Xchar *name;
Xchar *def;
Xstruct hashlist *hashtab[];
X{
X int hashval;
X struct hashlist *np, *lookup();
X char *strsave(), *malloc();
X
X if ((np = lookup(name, hashtab)) == NULL) { /* not found.. */
X np = (struct hashlist *) malloc(sizeof(*np));
X p_memoryus += sizeof(*np);
X if (np == NULL)
X return(NULL);
X if ((np->name = strsave(name)) == NULL)
X return(NULL);
X hashval = hash(np->name);
X np->next = hashtab[hashval];
X hashtab[hashval] = np;
X } else /* found.. */
X free(np->def); /* free prev. */
X if ((np->def = strsave(def)) == NULL)
X return(NULL);
X return(np);
X}
X
X/*
X * strsave - save string s somewhere
X *
X */
Xchar
X*strsave(s)
Xchar *s;
X{
X char *p, *malloc();
X register int n;
X
X n = strlen(s) + 1;
X if ((p = malloc(n)) != NULL) {
X p_memoryus += n;
X strcpy(p, s);
X }
X return(p);
X}
X
X/*
X * lexinstal - instal a string name in hashtable and its value
X * used by lexical analyser to quickly match a token
X * and return its lexical value.
X *
X */
Xstruct lexlist
X*lexinstal(name,val,flag,lextable)
Xchar *name;
Xint val;
Xint flag;
Xstruct lexlist *lextable[];
X{
X int hashval;
X struct lexlist *np,*lexlook();
X char *strsave(), *malloc();
X
X if ((np = lexlook(name,lextable)) == NULL) { /* not found.. */
X np = (struct lexlist *) malloc(sizeof(*np));
X p_memoryus += sizeof(*np);
X if (np == NULL)
X return(NULL);
X if ((np->name = strsave(name)) == NULL)
X return(NULL);
X hashval = hash(np->name);
X np->link = lextable[hashval];
X lextable[hashval] = np;
X }
X np->val = val; /* replace prev */
X np->flag = flag;
X return(np);
X}
X
X/*
X * lexlook - lookup for a string s in the hash table
X * used by lexinstal only.
X *
X */
Xstruct lexlist
X*lexlook(s,table)
Xchar *s;
Xstruct lexlist *table[];
X{
X struct lexlist *np;
X
X for (np = table[hash(s)]; np != NULL; np = np->link)
X if (strcmp(s, np->name) == 0)
X return(np); /* found */
X return(NULL); /* not found */
X}
X
X/*
X * remove an item from the hash table forever
X *
X */
Xstruct lexlist
X*remove(s, table)
Xchar *s;
Xstruct lexlist *table[];
X{
X struct lexlist *np, *xp;
X
X np = table[hash(s)];
X xp = np;
X while (np != NULL) {
X if (strcmp(s, np->name) == 0) {
X xp->link = np->link; /* remove the link */
X return(np); /* return the lost */
X }
X xp = np;
X np = np->link;
X }
X return(NULL);
X}
X
SHAR_EOF
if test 3017 -ne "`wc -c 'lookup.c'`"
then
echo shar: error transmitting "'lookup.c'" '(should have been 3017 characters)'
fi
echo shar: extracting "'lookup.h'" '(553 characters)'
if test -f 'lookup.h'
then
echo shar: over-writing existing file "'lookup.h'"
fi
sed 's/^X//' << \SHAR_EOF > 'lookup.h'
X
X
X
X/*
X * from K&R "The C Programming language"
X * Table lookup routines
X * structure and definitions
X *
X */
X
X /* basic table entry */
Xstruct hashlist {
X char *name;
X char *def;
X struct hashlist *next; /* next in chain */
X};
X /* basic table entry */
Xstruct lexlist {
X char *name;
X int val; /* lexical value */
X int flag; /* optional flag val */
X struct lexlist *link; /* next in chain */
X};
X
X
X#define HASHMAX 100 /* size of hashtable */
X
Xstruct
Xlexlist (*(*lextable))[];/* global pointer for lexical analyser hash table */
X
SHAR_EOF
if test 553 -ne "`wc -c 'lookup.h'`"
then
echo shar: error transmitting "'lookup.h'" '(should have been 553 characters)'
fi
echo shar: extracting "'ltb.c'" '(6222 characters)'
if test -f 'ltb.c'
then
echo shar: over-writing existing file "'ltb.c'"
fi
sed 's/^X//' << \SHAR_EOF > 'ltb.c'
X/*
X * ltb.c - Lexical Table Builder
X *
X * Functional description:
X *
X * This program builds a file containing the data
X * structures of a compile-time-initialised hash table.
X * This hash table may later be used for lexical analysis,
X * where number of symbols to look up is sufficiently large
X * to avoid a run-time table initialization.
X * In order to guarantee the success of this setup, the
X * hash routine, the lookup and install routines should be
X * the same between ltb and the lexical analysis.
X *
X * synopsis:
X *
X * ltb <input file> [table name]
X *
X * input file format:
X *
X * <token> <value identifier> [flag value]
X *
X * token: string of alphanumeric characters to be
X * matched by the lexical analyser (no blanks).
X * these token strings are "installed" to a hash
X * table by ltb to avoid run-time overhead.
X * value
X * identifier: A constant name to be used internally by the
X * lexical analyser in place of the actual
X * token value. a "#define <indentifier> <value>"
X * is generated for each value identifier, where
X * value is an odd and unique integer constant. If
X * the value identifier is a `*' (star), then the
X * previous value is repeated. Thus:
X *
X * token ident. flag
X *
X * sp SP 1
X * space * { inherits SP }
X * blank * { inherits SP }
X * . . .
X * . . .
X *
X * flag value: An additional integer field to pass flags etc. to
X * the lexical analyser. If not specified, set to
X * 0. token value field must be present for this field
X * to be obtained.
X *
X * outputs:
X *
X * ltb generates two C include files:
X *
X * [tablename].d: compile time lexical constants (defines)
X * [tablename].h: initialised hash table.
X *
X * where [tablename] is the name of the hash table as specified
X * in the command line of ltb. If not specified, "lextab" is used
X * as a default.
X *
X * routines used by LTB:
X *
X * hash, lookup and a modified version of install routines,
X * as defined in K&R, pp. 134 - 136.
X *
X * Application areas:
X *
X * Lexical analysers for compilers, interpreters, spelling
X * checkers.
X *
X * Author:
X * Ozan S. Yigit
X * Dept. of Computer Science
X * York University
X *
X */
X
X#define MAXLINE 80
X#define MAXSYM 80
X
X#include <stdio.h>
X#include <ctype.h>
X#include "lookup.h"
X
Xstatic struct lexlist *hashtab[HASHMAX];
Xstatic struct lexlist *defitab[HASHMAX];
X
Xchar *tabnam; /* table name */
X
Xmain(argc,argv)
Xint argc;
Xchar *argv[];
X{
X FILE *fp;
X char line[MAXLINE];
X char sym[MAXSYM],def[MAXSYM];
X register int val;
X register int prev, *p;
X register char *ptr;
X int flag;
X struct lexlist *np, *lexlook();
X
X if (argc <= 2) {
X fprintf(stderr,"%s [-<base>] <symbol file> [tablename]",
X argv[0]);
X exit(1);
X }
X
X if (*argv[1] == '-') {
X val = atoi(argv[1]+1); /* skip "-" and convert */
X val = (val & 1) ? val : val+1;
X p = argv[2];
X }
X else {
X val = 1;
X p = argv[1];
X }
X
X if (argc < 3)
X tabnam = "lextab";
X else
X tabnam = argv[argc-1];
X
X if ((fp = fopen(p,"r")) == NULL) {
X fprintf(stderr,"%s:cannot open.\n",argv[1]);
X exit(1);
X }
X else {
X prev = val;
X while (fgets(line,MAXLINE,fp) != NULL) {
X if (*line != '!') {
X flag = 0;
X def[0] = '\0';
X ptr = line;
X while (isspace(*ptr))
X ptr++;
X if (*ptr == '\0')
X continue;
X sscanf(line,"%s %s %d",sym,def,&flag);
X if (!(def[0] == '*' && def[1] == '\0')) {
X if ((np = lexlook(def,defitab)) == NULL) {
X /* value define */
X lexinstal(def,val,0,defitab);
X prev = val;
X val += 2;
X }
X else
X prev = np->val;
X }
X /* lexical token */
X lexinstal(sym,prev,flag,hashtab);
X }
X }
X defgen();
X lexgen();
X }
X}
X/*
X * lexgen - print out the hash table in static form
X *
X */
Xlexgen()
X{
X register int i;
X register struct lexlist *np;
X char filebuf[12];
X char *file;
X FILE *op;
X
X file = filebuf;
X
X strncpy(file,tabnam,8);
X strcat(file,".h");
X
X if ((op = fopen(file,"w")) == NULL) {
X fprintf(stderr,"%s: cannot create.\n",file);
X exit(1);
X }
X
X fprintf(op,"#ifndef STRUC_DEFINED\n\n");
X fprintf(op,"\/\*\t%s\t\*\/\n\n%s\n%s\n%s\n%s\n%s\n",file,
X "struct _lex_h { char *__s;",
X " int __v;",
X " int __f;",
X " struct _lex_h *__l;",
X "};");
X fprintf(op,"\n#define STRUC_DEFINED\n#endif\n");
X
X /*
X * generate the hash table entries.
X * each entry is followed by the next entry in its
X * chain.
X * In the operating systems with memory paging, this
X * should have the extra advantage of localized
X * memory referances.
X *
X */
X
X for (i=0; i < HASHMAX; i++)
X if ((np = hashtab[i]) != NULL)
X prnode(np,op);
X /*
X * At last, we generate the pointer array (hashtable).
X * this table should be assigned to lextable global
X * variable before using with lexlook() or lexinstal().
X * lextable is defined in lookup.h
X *
X */
X
X fprintf(op,"\n\n\/\* Hash Table \*\/\n\n");
X fprintf(op,"struct _lex_h *%s[%d] = {\n\t",tabnam,HASHMAX);
X for (i=0; i < HASHMAX - 1; i++) {
X np = hashtab[i];
X if(np == NULL)
X fprintf(op,"NULL,\t");
X else
X fprintf(op,"\&__%s,\t", np->name);
X if (i % 4 == 0)
X fprintf(op,"\n\t");
X }
X np = hashtab[i];
X if (np == NULL)
X fprintf(op,"NULL };\n");
X else
X fprintf(op,"\&__%s };\n", np->name);
X
X fclose(op);
X}
X
X/*
X * prnode - print the current node. This routine is
X * recursive such that printing starts from
X * the end of the given list
X *
X */
Xprnode(np,op)
Xregister struct
Xlexlist *np;
XFILE *op;
X{
X if (np->link != NULL)
X prnode(np->link,op);
X fprintf(op,"struct\n_lex_h __%s = { ",
X np->name);
X fprintf(op,"\"%s\",\n %6d,%6d,",
X np->name,
X np->val,
X np->flag);
X if (np->link != NULL)
X fprintf(op,"\&__%s };\n",
X (np->link)->name);
X else
X fprintf(op,"NULL };\n");
X}
X
X/*
X * defgen - generate a file containing the lexical
X * constants to be equated to lexical symbols
X */
Xdefgen()
X{
X register int i;
X register struct lexlist *np;
X char *file;
X char filebuf[12];
X FILE *op;
X
X file = filebuf;
X strncpy(file,tabnam,8);
X strcat(file,".d");
X
X if ((op = fopen(file,"w")) == NULL) {
X fprintf(stderr,"%s: cannot create.\n",file);
X exit(1);
X }
X for (i=0; i < HASHMAX; i++) {
X for (np = defitab[i]; np != NULL; np = np->link)
X fprintf(op,"\#define %s\t%d\n",
X np->name,
X np->val);
X }
X fclose(op);
X}
X
SHAR_EOF
if test 6222 -ne "`wc -c 'ltb.c'`"
then
echo shar: error transmitting "'ltb.c'" '(should have been 6222 characters)'
fi
echo shar: extracting "'makefile'" '(376 characters)'
if test -f 'makefile'
then
echo shar: over-writing existing file "'makefile'"
fi
sed 's/^X//' << \SHAR_EOF > 'makefile'
XCFLAGS=-O
XOBJS= proff.o proff01.o proff02.o lookup.o pinit.o putwrd.o\
X pxlex.o pxxparse.o dostuff2.o eval.o stack.o map.o
Xproff: $(OBJS)
X cc -s -o proff $(OBJS)
X
X$(OBJS): lextab.h lextab.d
X
Xlextab.h lextab.d: proffsym.new ltb
X ltb proffsym.new lextab
X
Xltb: ltb.o look.o
X cc -s -o ltb ltb.o look.o
Xclean:
X rm proff *.o
Xarch:
X ./archc Makefile *.c *.h proffsym.new >proff.arc
SHAR_EOF
if test 376 -ne "`wc -c 'makefile'`"
then
echo shar: error transmitting "'makefile'" '(should have been 376 characters)'
fi
echo shar: extracting "'map.c'" '(1224 characters)'
if test -f 'map.c'
then
echo shar: over-writing existing file "'map.c'"
fi
sed 's/^X//' << \SHAR_EOF > 'map.c'
X
X
X#include <stdio.h>
X/*
X * map map every character of s1 that is specified in s2
X * into s3 and replace in s. (source s1 remains untouched)
X */
X
Xmap(s,s1,s2,s3)
Xregister char *s;
Xregister char *s1;
Xregister char *s2;
Xregister char *s3;
X{
X char *t, *t1;
X if (*s1 != '\0') {
X t = s;
X t1 = s1;
X strcpy(t,t1);
X
X while (*s2 != '\0' && *s3 != '\0') {
X while (*t1 != '\0') {
X if (*t1 == *s2)
X *t = *s3;
X t++;
X t1++;
X }
X t = s;
X t1 = s1;
X s2++;
X s3++;
X }
X }
X else
X *s = '\0';
X}
X
X/*
X * roman - convert a numeric string into roman numerals
X *
X * icon version:
X *procedure roman(n)
X * local arabic, result
X * static equiv
X * initial equiv := ["","I","II","III","IV","V","VI","VII","VIII","IX"]
X * integer(n) > 0 | fail
X * result := ""
X * every arabic := !n do
X * result := map(result,"IVXLCDM","XLCDM**") || equiv[arabic+1]
X * if find("*",result) then fail else return result
X * end
X *
X */
Xint
Xcvtroman(num,rom)
Xchar *num;
Xchar *rom;
X{
X char tmp[20];
X
Xstatic char *equiv_U[] = { "","I","II","III","IV","V","VI","VII","VIII","IX" };
X
X *rom = NULL;
X while (*num != '\0') {
X map(tmp,rom,"IVXLCDM","XLCDM**");
X strcpy(rom,tmp);
X strcat(rom,equiv_U[*num - '0']);
X num++;
X }
X return(strlen(rom));
X}
X
SHAR_EOF
if test 1224 -ne "`wc -c 'map.c'`"
then
echo shar: error transmitting "'map.c'" '(should have been 1224 characters)'
fi
# End of shell archive
exit 0
--
Usenet: [decvax|allegra|linus|ihnp4]!utzoo!yetti!oz
Bitnet: oz@[yusol|yuyetti]
In the beginning, there was Word all right, except
it wasn't fixed number of bits.
More information about the Comp.sources.unix
mailing list