Path: utzoo!utgpu!jarvis.csri.toronto.edu!mailrus!cs.utexas.edu!usc!apple!uokmax!munnari.oz.au!cluster!metro!news
From: glenn@extro.ucc.su.oz.au (G Geers)
Newsgroups: comp.unix.xenix
Subject: LaTeX for Xenix (9 of 14)
Message-ID: <1990Feb15.234104.2993@metro.ucc.su.oz.au>
Date: 15 Feb 90 23:41:04 GMT
Reply-To: glenn@extro.ucc.su.oz.au (G Geers)
Organization: University Computing Service, Uni. of Sydney, Australia.
Lines: 2327


---- Cut Here and unpack ----
#!/bin/sh
# this is part 9 of a multipart archive
# do not concatenate these parts, unpack them in order with /bin/sh
# file hash.c continued
#
CurArch=9
if test ! -r s2_seq_.tmp
then echo "Please unpack part 1 first!"
     exit 1; fi
( read Scheck
  if test "$Scheck" != $CurArch
  then echo "Please unpack part $Scheck next!"
       exit 1;
  else exit 0; fi
) < s2_seq_.tmp || exit 1
echo "x - Continuing file hash.c"
sed 's/^X//' << 'SHAR_EOF' >> hash.c
X	ptr		p;
X
X	h = buffer[j];
X	for (k = j + 1; k < j + l; incr(k)) {
X		h = h + h + buffer[k];
X		while (h >= HASH_PRIME)
X			h -= HASH_PRIME;
X	}
X	for (p = h + HASH_BASE; ; p = next(p)) {
X		if (text(p) > 0 && length(text(p)) == l)
X			if (str_eq_buf(text(p), j))
X				return p;
X		if (next(p) == 0) {
X			if (no_new_control_sequence)
X				return UNDEFINED_CONTROL_SEQUENCE;
X			if (text(p) > 0) {
X				do
X					if (hash_is_full)
X						overflow("hash size", HASH_SIZE);
X					else decr(hash_used);
X				while (text(hash_used) != 0);
X				next(p) = hash_used;
X				p = hash_used;
X			}
X			str_room(l);
X			for (k = j; k < j + l; incr(k))
X				append_char(buffer[k]);
X			text(p) = make_string();
X#ifdef STAT
X			incr(cs_count);
X#endif
X			return p;
X		}
X	}
X}
X
Xprint_cs (p)
X	ptr		p;
X{	
X	if (p < HASH_BASE) {
X		if (p >= SINGLE_BASE) {
X			if (p == NULL_CS) {
X				print_esc("csname");
X				print_esc("endcsname");
X			} else {
X				print_esc(""); 
X				print_str(p - SINGLE_BASE); 
X				if (cat_code(p - SINGLE_BASE) == LETTER)
X					print_char(' ');
X			}
X		} else if (p < ACTIVE_BASE)
X			print_esc("IMPOSSIBLE.");
X		else print_str(p - ACTIVE_BASE);
X	} else if (p >= UNDEFINED_CONTROL_SEQUENCE)
X		print_esc("IMPOSSIBLE.");
X	else if (text(p) < 0 || text(p) >= str_ptr)
X		print_esc("NONEXISTENT.");
X	else {
X		print_esc("");
X		slow_print(text(p));
X		print_char(' ');
X	}
X}
X
Xsprint_cs (p)
X	ptr		p;
X{
X	if (p < HASH_BASE) {
X		if (p < SINGLE_BASE)
X			print_str(p - ACTIVE_BASE);
X		else if (p < NULL_CS) {
X			print_esc("");
X			print_str(p - SINGLE_BASE);
X		} else {
X			print_esc("csname");
X			print_esc("endcsname");
X		}
X	} else {
X		print_esc("");
X		slow_print(text(p));
X	}
X}
X
X#ifdef INIT
Xprimitive (s, c, o)
X	char*	s;
X	qword	c;
X	hword	o;
X{
X	int		j;
X	int		k;
X	int		l;
X	str		new_str;
X
X	if (s[1] == NUL)
X		cur_val = s[0] + SINGLE_BASE;
X	else {
X		new_str = make_string_given(s);
X		k = str_start[new_str];
X		l = length(new_str);
X		for (j = 0; j < l; incr(j))
X			buffer[j] = str_pool[k + j];
X		cur_val = id_lookup(0, l);
X		flush_string();
X		text(cur_val) = new_str;
X	}
X	eq_level(cur_val) = LEVEL_ONE;
X	eq_type(cur_val) = c;
X	equiv(cur_val) = o;
X}
X#endif
SHAR_EOF
echo "File hash.c is complete"
chmod 0444 hash.c || echo "restore of hash.c fails"
set `wc -c hash.c`;Sum=$1
if test "$Sum" != "2748"
then echo original size 2748, current size $Sum;fi
echo "x - extracting hash.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > hash.h &&
X
X/*
X *    Copyright 1986, 1987 Pat Joseph Monardo. All rights reserved.
X *    Copying of this file is granted according to the provisions 
X *    specified in the file COPYING which must accompany this file.
X */
X
X
X/*
X *		hash.h
X */
X
X#define	next(H)				hash[H].hh1.lh
X#define	text(H)				hash[H].hh1.rh
X#define	font_id_text(H)		text(FONT_ID_BASE + H)
X
X#define	hash_is_full		(hash_used == HASH_BASE)
X
Xglobal	twoh	hash[];
Xglobal	ptr		hash_used;
Xglobal	bool	no_new_control_sequence;
Xglobal	int		cs_count;
X
Xptr		id_lookup();
Xint		print_cs();
Xint		sprint_cs();
X
X#ifdef	INIT
Xint		primitive();
X#endif
SHAR_EOF
chmod 0444 hash.h || echo "restore of hash.h fails"
set `wc -c hash.h`;Sum=$1
if test "$Sum" != "591"
then echo original size 591, current size $Sum;fi
echo "x - extracting heap.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > heap.c &&
X
X/*
X *    Copyright 1986, 1987 Pat Joseph Monardo. All rights reserved.
X *    Copying of this file is granted according to the provisions 
X *    specified in the file COPYING which must accompany this file.
X */
X
X
X/*
X *		heap.c
X */
X
X#include "tex.h"
X#include "eq.h"
X#include "arith.h"
X#include "box.h"
X#include "evalstack.h"
X#include "par.h"
X#include "page.h"
X#include "print.h"
X#include "error.h"
X#include "heap.h"
X
Xmword	mem[MEM_MAX-MEM_MIN+1];
Xptr		mem_end;
Xptr		lo_mem_max;
Xptr		hi_mem_min;
Xptr		avail;
Xint		dyn_used;
Xptr		rover;
Xint		var_used;
Xint		max_var_used;
Xptr		temp_ptr;
X
Xptr
Xget_avail ()
X{
X	ptr		p;
X
X	p = avail;
X	if (p != NULL)
X		avail = link(avail);
X	else if (mem_end < MEM_MAX) {
X		incr(mem_end);
X		p = mem_end;
X	} else {
X		decr(hi_mem_min);
X		p = hi_mem_min;
X		if (hi_mem_min <= lo_mem_max) {
X			runaway();
X			overflow("main memory size", MEM_MAX - MEM_MIN);
X		}
X	}
X	link(p) = NULL;
X#ifdef STAT
X	incr(dyn_used);
X#endif
X	return p;
X}
X
Xptr
Xget_node (s)
X	int		s;
X{
X	ptr		p;
X	ptr		q;
X	int		r;
X	int		t;
X
Xrestart:
X	p = rover;
X	do {
X		q = p + node_size(p);
X		while (is_empty(q)) {
X			t = rlink(q);
X			if (q == rover)
X				rover = t;
X			llink(t) = llink(q);
X			rlink(llink(q)) = t;
X			q += node_size(q);
X		}
X		r = q - s;
X		if (r > (int) p + 1)  {
X			node_size(p) = r - p;
X			rover = p;
X			goto found;
X		}
X		if (r == p && (rlink(p) != rover || llink(p) != rover)) {
X			rover = rlink(p);
X			t = llink(p);
X			llink(rover) = t;
X			rlink(t) = rover;
X			goto found;
X		}
X		node_size(p) = q - p;
X		p = rlink(p);
X	} while (p != rover);
X	if (s == 010000000000)
X		return MAX_HALFWORD;
X	if (lo_mem_max + 2 < hi_mem_min && 
X		lo_mem_max + 2 <= MEM_BOT + MAX_HALFWORD) {
X		if (lo_mem_max + 1000 < hi_mem_min)
X			t = lo_mem_max + 1000;
X		else t = (lo_mem_max + hi_mem_min + 2) / 2;
X		p = llink(rover);
X		q = lo_mem_max;
X		rlink(p) = q;
X		llink(rover) = q;
X		if (t > MEM_BOT + MAX_HALFWORD)
X			t = MEM_BOT + MAX_HALFWORD;
X		rlink(q) = rover;
X		llink(q) = p;
X		link(q) = EMPTY_FLAG;
X		node_size(q) = t - lo_mem_max;
X		lo_mem_max = t;
X		link(lo_mem_max) = NULL;
X		info(lo_mem_max) = NULL; 
X		rover = q;
X		goto restart;
X	}
X
X	overflow("main memory size", MEM_MAX + 1 - MEM_MIN);
X
Xfound:
X	link(r) = NULL;
X#ifdef STAT
X	var_used += s;
X#endif
X	return r;
X}
X
Xfree_node (p, s)
X	ptr		p;
X	hword	s;
X{
X	ptr		q;
X
X	node_size(p) = s;
X	link(p) = EMPTY_FLAG;
X	q = llink(rover);
X	llink(p) = q;
X	rlink(p) = rover;
X	llink(rover) = p;
X	rlink(q) = p;
X#ifdef STAT
X	var_used -= s;
X#endif
X}
X
Xinit_mem ()
X{
X	int		k;
X	
X#ifdef INIT
X	for (k = MEM_BOT + 1; k <= LO_MEM_STAT_MAX; k++)
X		mem[k].sc = 0;
X	for (k = MEM_BOT; k <= LO_MEM_STAT_MAX; k += GLUE_SPEC_SIZE) {
X		glue_ref_count(k) = NULL + 1;
X		stretch_order(k) = NORMAL;
X		shrink_order(k) = NORMAL;
X	}
X	stretch(fil_glue) = UNITY;
X	stretch_order(fil_glue) = FIL;
X	stretch(fill_glue) = UNITY;
X	stretch_order(fill_glue) = FILL;
X	stretch(ss_glue) = UNITY;
X	stretch_order(ss_glue) = FIL;
X	shrink(ss_glue) = UNITY;
X	shrink_order(ss_glue) = FIL;
X	stretch(fil_neg_glue) = -UNITY;
X	stretch_order(fil_neg_glue) = FIL;
X	
X	rover = LO_MEM_STAT_MAX + 1;
X	link(rover) = EMPTY_FLAG;
X	node_size(rover) = 1000;
X	llink(rover) = rover;
X	rlink(rover) = rover;
X
X	lo_mem_max = rover + 1000;
X	link(lo_mem_max) = NULL;
X	info(lo_mem_max) = NULL;
X	for (k = HI_MEM_STAT_MIN; k <= MEM_TOP; incr(k))
X		mem[k] = mem[lo_mem_max];
X
X	link(end_span) = MAX_QUARTERWORD + 1;
X	info(end_span) = NULL;
X	type(last_active) = HYPHENATED;
X	subtype(last_active) = 0;
X	line_number(last_active) = MAX_HALFWORD;
X	type(page_ins_head) = SPLIT_UP;
X	subtype(page_ins_head) = qi(255);
X	link(page_ins_head) = page_ins_head;
X	type(page_head) = GLUE_NODE;
X	subtype(page_head) = NORMAL;
X
X	avail = NULL;
X	mem_end = MEM_TOP;
X	hi_mem_min = HI_MEM_STAT_MIN;
X	var_used = LO_MEM_STAT_MAX + 1 - MEM_BOT;
X	dyn_used = HI_MEM_STAT_USAGE;
X#endif
X}
X
Xsort_avail()
X{
X	ptr		p;
X	ptr		q;
X	ptr		r;
X	ptr		old_rover;
X
X#ifdef INIT
X	get_node(010000000000);
X	p = rlink(rover);
X	rlink(rover) = MAX_HALFWORD;
X	old_rover = rover;
X	while (p != old_rover) {
X		if (p < rover) {
X			q = p;
X			p = rlink(q);
X			rlink(q) = rover;
X			rover = q;
X		} else {
X			q = rover;
X			while (rlink(q) < p)
X				q = rlink(q);
X			r = rlink(p);
X			rlink(p) = rlink(q);
X			rlink(q) = p;
X			p = r;
X		}
X	}
X	p = rover;
X	while (rlink(p) != MAX_HALFWORD) {
X		llink(rlink(p)) = p;
X		p = rlink(p);
X	}
X	rlink(p) = rover;
X	llink(rover) = p;
X#endif
X}
SHAR_EOF
chmod 0444 heap.c || echo "restore of heap.c fails"
set `wc -c heap.c`;Sum=$1
if test "$Sum" != "4344"
then echo original size 4344, current size $Sum;fi
echo "x - extracting heap.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > heap.h &&
X
X/*
X *    Copyright 1986, 1987 Pat Joseph Monardo. All rights reserved.
X *    Copying of this file is granted according to the provisions 
X *    specified in the file COPYING which must accompany this file.
X */
X
X
X/*
X *		heap.h
X */
X
X#define	qi(M)			(M + MIN_QUARTERWORD)
X#define	qo(M)			(M - MIN_QUARTERWORD)
X#define	hi(M)			(M + MIN_HALFWORD)
X#define	ho(M)			(M - MIN_HALFWORD)
X
X#ifdef NULL
X#undef NULL
X#endif
X#define	NULL			MIN_HALFWORD
X
Xglobal	mword	mem[];
Xglobal	ptr		lo_mem_max;
Xglobal	ptr		hi_mem_min;
X
Xglobal	int		var_used;
Xglobal	int		max_var_used;
Xglobal	int		dyn_used;
X
X#define	link(M)			mem[M].hh.hh1.rh
X#define	info(M)			mem[M].hh.hh1.lh
X
Xglobal	ptr	 	avail;
Xglobal	ptr		mem_end;
X
Xptr get_avail();
X
X
X#ifdef	STAT
X#define	fast_get_avail(M) \
X	{M = avail; \
X	if (M == NULL) M = get_avail(); \
X	else {avail = link(M); link(M) = NULL; incr(dyn_used);}}
X#else
X#define	fast_get_avail(M) \
X	{M = avail; \
X	if (M == NULL) M = get_avail(); \
X	else {avail = link(M); link(M) = NULL;}}
X#endif
X
X
X#ifdef STAT
X#define free_avail(M) \
X	{link(M) = avail; avail = M; decr(dyn_used);}
X#else
X#define free_avail(M) \
X	{link(M) = avail; avail = M;}
X#endif
X
Xint		flush_list();
X
X#define	is_empty(M)			(link(M) == EMPTY_FLAG)
X#define	EMPTY_FLAG			MAX_HALFWORD
X#define	node_size			info
X#define	llink(M)			info(M + 1)
X#define	rlink(M) 			link(M + 1)
X
Xglobal	ptr	rover;
X
Xptr		get_node();
Xint		free_node();
X
Xglobal	ptr	temp_ptr;
X
X#define	zero_glue 		MEM_BOT
X#define	fil_glue 		(zero_glue + GLUE_SPEC_SIZE)
X#define	fill_glue 		(fil_glue + GLUE_SPEC_SIZE)
X#define	ss_glue  		(fill_glue + GLUE_SPEC_SIZE)
X#define	fil_neg_glue 	(ss_glue + GLUE_SPEC_SIZE)
X
X#define	LO_MEM_STAT_MAX	(fil_neg_glue + GLUE_SPEC_SIZE - 1)
X
X#define	page_ins_head 	(MEM_TOP)
X#define	contrib_head  	(MEM_TOP - 1)
X#define	page_head  		(MEM_TOP - 2)
X#define	temp_head  		(MEM_TOP - 3)
X#define	hold_head  		(MEM_TOP - 4)
X#define	adjust_head		(MEM_TOP - 5)
X#define	active  		(MEM_TOP - 7)
X#define	align_head  	(MEM_TOP - 8)
X#define	end_span  		(MEM_TOP - 9)
X#define	lig_trick  		(MEM_TOP - 10)
X#define	garbage  		(MEM_TOP - 10)
X
X#define	HI_MEM_STAT_MIN		(MEM_TOP - 10)
X#define	HI_MEM_STAT_USAGE	11
X
Xbool	init_mem();
X
X#ifdef INIT
Xint		sort_avail();
X#endif
SHAR_EOF
chmod 0444 heap.h || echo "restore of heap.h fails"
set `wc -c heap.h`;Sum=$1
if test "$Sum" != "2203"
then echo original size 2203, current size $Sum;fi
echo "x - extracting hyph.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > hyph.c &&
X
X/*
X *    Copyright 1986, 1987 Pat Joseph Monardo. All rights reserved.
X *    Copying of this file is granted according to the provisions 
X *    specified in the file COPYING which must accompany this file.
X */
X
X
X/*
X *		hyph.c
X */
X
X#include	"tex.h"
X#include	"cmds.h"
X#include	"heap.h"
X#include	"token.h"
X#include	"eq.h"
X#include	"str.h"
X#include	"tfm.h"
X#include	"box.h"
X#include	"scan.h"
X#include	"tokenstack.h"
X#include	"par.h"
X#include	"print.h"
X#include	"error.h"
X#include	"hyph.h"
X
Xptr		ha;
Xptr		hb;
Xhword	hc[66];
Xfnt		hf;
Xint		hn;
Xascii	hu[64];
Xbyte	hyf[65];
Xint		hyf_char;
Xint		hyf_distance[256];
Xqword	hyf_next[256];
Xint		hyf_num[256];
Xint		hyph_count;
Xptr		hyph_list[HYPH_SIZE+1];
Xstr		hyph_word[HYPH_SIZE+1];
Xint		hyphen_passed;
Xint		trie_max;
Xqword	trie_op_ptr;
Xtwoh	trie[TRIE_SIZE+1];
X
Xhyphenate ()
X{
X	ascii	c;
X	int		h;
X	int		i;
X	int		j;
X	str		k;
X	int		l;
X	ptr		q;
X	ptr		r;
X	ptr		s;
X	int		u;
X	qword	v;
X	int		z;
X	ptr		hyf_node;
X	ptr		major_tail;
X	ptr		minor_tail;
X
X	for (j = 0; j <= hn; incr(j))
X		hyf[j] = 0;
X	h = hc[1];
X	for (j = 2; j <= hn; incr(j))
X		h = (h + h + hc[j]) % HYPH_SIZE;
X	loop {
X		k = hyph_word[h];
X		if (k == 0) goto not_found;
X		if (length(k) < hn)	goto not_found;
X		if (length(k) == hn) {
X			j = 1;
X			u = str_start[k];
X			do {
X				if (str_pool[u] < hc[j]) goto not_found;
X				if (str_pool[u] > hc[j]) goto done;
X				incr(u); incr(j);
X			} while (j <= hn);
X			for (s = hyph_list[h]; s != NULL; s = link(s))
X				hyf[info(s)] = 1;
X			goto found;
X		}
X
X	done:
X		if (h > 0)
X			decr(h);
X		else h = HYPH_SIZE;
X	}
X
Xnot_found:
X	hc[0] = 127;
X	hc[hn + 1] = 127;
X	hc[hn + 2] = 256;
X	for (j = 0; j <= hn - 2; incr(j)) {
X		z = hc[j];
X		l = j;
X		while (hc[l] == trie_char(z)) {
X			if (trie_op(z) != MIN_QUARTERWORD) {
X				v = trie_op(z);
X				do {
X					i = l - hyf_distance[v];
X					if (hyf_num[v] > hyf[i])
X						hyf[i] = hyf_num[v];
X					v = hyf_next[v];
X				} while (v != MIN_QUARTERWORD);
X			}
X			incr(l);
X			z = trie_link(z) + hc[l];
X		}
X	}
X
Xfound:
X	hyf[1] = 0;
X	hyf[hn - 2] = 0;
X	hyf[hn - 1] = 0;
X	hyf[hn] = 0;
X
X	for (j = 2; j <= hn - 3; incr(j))
X		if (odd(hyf[j])) goto found1;
X	return;
X
Xfound1:
X	q = link(hb);
X	link(hb) = NULL;
X	s = cur_p;
X	while (link(s) != ha)
X		s = link(s);
X	link(s) = NULL;
X	flush_node_list(ha);
X	j = 0;
X	do {
X		l = j;
X		j = reconstitute(j + 1, hn);
X		if (hyphen_passed != 0) {
X			r = get_node(SMALL_NODE_SIZE);
X			link(s) = r;
X			link(r) = link(hold_head);
X			type(r) = DISC_NODE;
X			major_tail = link(hold_head);
X			if (link(major_tail) != NULL)
X				major_tail = link(major_tail);
X			i = hyphen_passed;
X			minor_tail = NULL;
X			hyf_node = new_character(hf, (ascii) hyf_char);
X			if (hyf_node != NULL) {
X				incr(i);
X				c = hu[i];
X				hu[i] = hyf_char;
X			}
X			do {
X				l = reconstitute(l + 1, i);
X				if (minor_tail == NULL)
X					pre_break(r) = link(hold_head);
X				else link(minor_tail) = link(hold_head);
X				minor_tail = link(hold_head);
X				if (link(minor_tail) != NULL)
X					minor_tail = link(minor_tail);
X			} while (l != i);
X			if (hyf_node != NULL) {
X				hu[i] = c;
X				free_avail(hyf_node);
X				decr(i);
X				l = i;
X			}
X			hyf[i] = 0;
X			minor_tail = NULL;
X			post_break(r) = NULL;
X			while (l < j) {
X				do {
X					l = reconstitute(l + 1, hn);
X					if (minor_tail == NULL)
X						post_break(r) = link(hold_head);
X					else link(minor_tail) = link(hold_head);
X					minor_tail = link(hold_head);
X					if (link(minor_tail) != NULL) {
X						hyf[l] = 0;
X						minor_tail = link(minor_tail);
X					}
X				} while (l < j);
X				while (l > j) {
X					j = reconstitute(j + 1, hn);
X					link(major_tail) = link(hold_head);
X					major_tail = link(hold_head);
X					if (link(major_tail) != NULL) {
X						hyf[j] = 0;
X						major_tail = link(major_tail);
X					}
X				}
X			}
X			i = 0; 
X			s = r;
X			while(link(s) != NULL) {
X				incr(i);
X				s =  link(s);
X			}
X			replace_count(r) = i;
X		} else {
X			link(s) = link(hold_head);
X			s = link(s);
X			if (link(s) != NULL)
X				s = link(s);
X		}
X		if (odd(hyf[j])) {
X			r = new_disc();
X			pre_break(r) = new_character(hf, (ascii) hyf_char);
X			link(s) = r;
X			s = r;
X		}
X	} while (j != hn);
X	link(s) = q;
X}
X	
Xreconstitute (j, n)
X	int		j;
X	int		n;
X{
X	qword	c;
X	qword	d;
X	ptr		p;
X	fourq	q;
X	int		r;
X	ptr		s;
X	scal	w;
X
X	hyphen_passed = 0;
X	s = hold_head;
X	w = 0;
X	c = d = qi(hu[j]);
X	loop {
Xcontin: p = get_avail();
X		font(p) = hf;
X		character(p) = c;
X		link(s) = p;
X		if (j == n) break;
X		q = char_info(hf, d);
X		if (char_tag(q) != LIG_TAG) break;
X		r = lig_kern_start(hf, q);
X		c = qi(hu[j + 1]);
X		loop {
X			q = font_info[r].qqqq;
X			if (next_char(q) == c) {
X				if (odd(hyf[j]) && hyphen_passed == 0)
X					hyphen_passed = j;
X				if (op_bit(q) < KERN_FLAG) {
X					d = rem_byte(q);
X					incr(j);
X					s = p;
X					goto contin;
X				} else {
X					w = char_kern(hf, q);
X					goto done;
X				}
X			} else if (stop_bit(q) < STOP_FLAG)
X				incr(r);
X			else goto done;
X		}
X	}
X
Xdone:
X	if (s != hold_head) {
X		p = new_ligature(hf, d, link(hold_head));
X		link(hold_head) = p;
X	}
X	if (w != 0)
X		link(link(hold_head)) = new_kern(w);
X	return j;
X}
X
Xnew_hyph_exceptions ()
X{
X	int		h;
X	int		j;
X	str		k;
X	int		n;
X	ptr		p;
X	ptr		q;
X	str		s;
X	str		t;
X	int		u;
X	int		v;
X
X	n = 0;
X	p = NULL;
X	scan_left_brace();
X	loop {
X		get_x_token();
X
X	reswitch:
X		switch (cur_cmd)
X		{
X		case LETTER:
X		case OTHER_CHAR:
X		case CHAR_GIVEN:
X			if (cur_chr == '-') {
X				if (n > 1) {
X					q = get_avail();
X					link(q) = p;
X					info(q) = n;
X					p = q;
X				}
X			} else {
X				if (cur_chr > 127 || lc_code(cur_chr) == 0) {
X					print_err("Not a letter");
X					help_hyph_lccode();
X					error();
X				} else if (n < 63) {
X					incr(n);
X					hc[n] = lc_code(cur_chr) - 1;
X				}
X			}
X			break;
X		
X		case CHAR_NUM:
X			scan_char_num();
X			cur_chr = cur_val;
X			cur_cmd = CHAR_GIVEN;
X			goto reswitch;
X			break;
X
X		case SPACER:
X		case RIGHT_BRACE:
X			if (n > 4) {
X				str_room(n);
X				h = 0;
X				for (j = 1; j <= n; incr(j)) {
X					h = (h + h + hc[j]) % HYPH_SIZE;
X					append_char(hc[j]);
X				}
X				s = make_string();
X				loop {
X					if (p == NULL)
X						break;
X					if (info(p) < n - 2)
X						break;
X					q = link(p);
X					free_avail(p);
X					p = q;
X				}
X				if (hyph_count == HYPH_SIZE)
X					overflow("exception dictionary", HYPH_SIZE);
X				incr(hyph_count);
X				while (hyph_word[h] != 0) {
X					k = hyph_word[h];
X					if (length(k) < length(s))
X						goto found;
X					if (length(k) > length(s))
X						goto not_found;
X					u = str_start[k];
X					v = str_start[s];
X					do {
X						if (str_pool[u] < str_pool[v])
X							goto found;
X						if (str_pool[u] > str_pool[v])
X							goto not_found;
X						incr(u); incr(v);
X					} while (u != str_start[k + 1]);
X
X				found:
X					q = hyph_list[h];
X					hyph_list[h] = p;
X					p = q;
X					t = hyph_word[h];
X					hyph_word[h] = s;
X					s = t;
X				
X			not_found:
X					if (h > 0)
X						decr(h);
X					else h = HYPH_SIZE;
X				}
X				hyph_word[h] = s;
X				hyph_list[h] = p;
X			}
X			if (cur_cmd == RIGHT_BRACE)
X				return;
X			n = 0;
X			p = NULL;
X			break;
X
X		default:
X			print_err("Improper ");
X			print_esc("hyphenation");
X			print(" will be flushed");
X			help_hyph();
X			error();
X			break;
X		}
X	}
X}
X
X/*
X *	Help text
X */
X
Xhelp_hyph_lccode ()
X{
X	help2("Letters in \\hyphenation words must have \\lccode > 0",
X	"Proceed; I'll ignore the character I just read.");
X}
X
Xhelp_hyph ()
X{
X	help2("Hyphenation exceptions must contain only letters",
X	"and hyphens. But continue; I'll forgive and forget.");
X}
X
X#ifdef INIT
X
Xqword	trie_op_hash[TRIE_OP_HASH_SIZE+1];	
Xqword	trie_op_ptr;
X
Xint		trie_hash[TRIE_SIZE+1];
Xascii	trie_c[TRIE_SIZE+1];
Xqword	trie_o[TRIE_SIZE+1];
Xint		trie_l[TRIE_SIZE+1];
Xint		trie_r[TRIE_SIZE+1];
Xint		trie_min;
Xint		trie_ptr;
Xbool	trie_taken[TRIE_SIZE+1];
X
Xqword
Xnew_trie_op (d, n, v)
X	int		d;
X	int		n;
X	qword	v;
X{
X	int		h;
X	qword	u;
X
X/*	h = abs((n + 313 * d + 361 * v)) % TRIE_OP_HASH_SIZE; */
X	if ((h=(n+313*d+361*v))<0)
X		h=(-h);		/* patch to overcome a bug in /lib/ccom
X				** on Dual  DHD 3/89
X				*/
X	h %= TRIE_OP_HASH_SIZE;
X	loop {
X		u = trie_op_hash[h];
X		if (u == MIN_QUARTERWORD) {
X			if (trie_op_ptr == MAX_QUARTERWORD)
X				return MIN_QUARTERWORD;
X			incr(trie_op_ptr);
X			hyf_distance[trie_op_ptr] = d;
X			hyf_num[trie_op_ptr] = n;
X			hyf_next[trie_op_ptr] = v;
X			trie_op_hash[h] = trie_op_ptr;
X			return trie_op_ptr;
X		}
X		if (hyf_distance[u] == d && 
X			hyf_num[u] == n &&
X			hyf_next[u] == v)
X				return u;
X		if (h > 0)
X			decr(h);
X		else h = TRIE_OP_HASH_SIZE;
X	}
X}
X		
Xtrie_node (p)
X	int		p;
X{
X	int		h;
X	int		q;
X
X/*	h = abs(trie_c[p] + 
X			1009 * trie_o[p] +
X			2718 * trie_l[p] +
X			3142 * trie_r[p])
X			% TRIE_SIZE; */
X	if ((h = (trie_c[p] + 
X			1009 * trie_o[p] +
X			2718 * trie_l[p] +
X			3142 * trie_r[p])) < 0)
X		h = (-h);
X	h %= TRIE_SIZE;		/*  Similar patch to above  */
X	loop {
X		q = trie_hash[h];
X		if (q == 0) {
X			trie_hash[h] = p; 
X			return p;
X		}
X		if (trie_c[q] == trie_c[p] &&
X			trie_o[q] == trie_o[p] &&
X			trie_l[q] == trie_l[p] && 
X			trie_r[q] == trie_r[p])
X			return q;
X		if (h > 0) 
X			decr(h);
X		else h = TRIE_SIZE;
X	}
X}
X
Xcompress_trie (p)
X	int		p;
X{
X	if (p == 0)
X		return 0;
X	else {
X		trie_l[p] = compress_trie(trie_l[p]);
X		trie_r[p] = compress_trie(trie_r[p]);
X		return (trie_node(p));
X	}
X}
X
Xinit_pattern_memory ()
X{
X	int		h;
X	int		p;
X
X	for (h = 0; h <= TRIE_OP_HASH_SIZE; incr(h))
X		trie_op_hash[h] = MIN_QUARTERWORD;
X	trie_op_ptr = MIN_QUARTERWORD;
X	trie_root = 0;
X	trie_c[0] = 0;
X	trie_ptr = 0;
X	for (p = 0; p <= TRIE_SIZE; incr(p))
X		trie_hash[p] = 0;
X}
X
Xinit_trie_memory ()
X{
X	int		p;
X
X	for (p = 0; p <= trie_ptr; incr(p))
X		trie_ref[p] = 0;
X	trie_max = trie_min = 128;
X	trie_link(0) = 1;
X	trie_taken[0] = FALSE;
X	for (p = 1; p <= 128; p++) {
X		trie_back(p) = p - 1;
X		trie_link(p) = p + 1;
X		trie_taken[p] = FALSE;
X	}
X}
X
Xfirst_fit (p)
X	int		p;
X{
X	ascii	c;
X	int		h;
X	int		q;
X	int		z;
X
X	c = trie_c[p];
X	if (c < trie_min)
X		trie_min = c;
X	z = trie_link(trie_min - 1);
X	loop {
X		if (z < c)
X			goto not_found;
X		h = z - c;
X		if (trie_max < h + 128) {
X			if (TRIE_SIZE <= h + 128)
X				overflow("pattern memory", TRIE_SIZE);
X			do {
X				incr(trie_max); 
X				trie_taken[trie_max] = FALSE;
X				trie_link(trie_max) = trie_max + 1;
X				trie_back(trie_max) = trie_max - 1;
X			} while (trie_max != h + 128);
X		}
X		if (trie_taken[h])
X			goto not_found;
X		for (q = trie_r[p]; q > 0; q = trie_r[q])
X			if (trie_link(h + trie_c[q]) == 0)
X				goto not_found;
X		goto found;
X
X	not_found:
X		z = trie_link(z);
X	}
X
Xfound:
X	trie_taken[h] = TRUE;
X	trie_ref[p] = h;
X	q = p;
X	do {
X		z = h + trie_c[q];
X		trie_back(trie_link(z)) = trie_back(z);
X		trie_link(trie_back(z)) = trie_link(z);
X		trie_link(z) = 0;
X		q = trie_r[q];
X	} while (q != 0);
X}
X
Xtrie_pack (p)
X	int		p;
X{
X	int		q;
X
X	do {	
X		q = trie_l[p];
X		if (q > 0 && trie_ref[q] == 0) {
X			first_fit(q);
X			trie_pack(q);
X		}
X		p = trie_r[p];
X	} while (p != 0);
X}
X
Xtrie_fix (p)
X	int		p;
X{
X	ascii	c;
X	int		q;
X	int		z;
X
X	z = trie_ref[p];
X	while (p != 0) {
X		q = trie_l[p];
X		c = trie_c[p];
X		trie_link(z + c) = trie_ref[q];
X		trie_char(z + c) = c;
X		trie_op(z + c) = trie_o[p];
X		if (q > 0)
X			trie_fix(q);
X		p = trie_r[p];
X	}
X}
X
Xnew_patterns ()
X{
X	ascii	c;
X	twoh	h;
X	int		k;
X	int		l;
X	int		p;
X	int		q;
X	int		r;
X	int		s;
X	qword	v;
X	bool	digit_sensed;
X	bool	first_child;
X
X	scan_left_brace();
X	init_pattern_memory();
X	k = 0;
X	hyf[0] = 0;
X	digit_sensed = FALSE;
X	loop {
X		get_x_token();
X		switch (cur_cmd)
X		{
X		case LETTER:
X		case OTHER_CHAR:
X			if (digit_sensed || cur_chr < '0' || cur_chr > '9') {
X				if (cur_chr == '.')
X					cur_chr = 128;
X				else {
X					cur_chr = lc_code(cur_chr);
X					if (cur_chr == 0) {
X						print_err("Nonletter");
X						help1("(See Appendix H.)");
X						error();
X						cur_chr = 128;
X					}
X				}
X				if (k < 63) {
X					incr(k);
X					hc[k] = cur_chr - 1;
X					hyf[k] = 0;
X					digit_sensed = FALSE;
X				}
X			} else {
X				hyf[k] = cur_chr - '0';
X				if (k < 63)
X					digit_sensed = TRUE;
X			}
X			break;
X
X		case SPACER:
X		case RIGHT_BRACE:
X			if (k > 0) {
X				if (hc[1] == 127)
X					hyf[0] = 0;
X				if (hc[k] == 127)
X					hyf[k] = 0;
X				l = k;
X				v = MIN_QUARTERWORD;
X				loop {
X					if (hyf[l] != 0)
X						v = new_trie_op(k - l, hyf[l], v);
X					if (l > 0)
X						decr(l);
X					else break;
X				}
X				q = 0; 
X				while (l < k) {
X					incr(l);
X					c = hc[l];
X					p = trie_l[q];
X					first_child = TRUE;
X					while (p > 0 && c > trie_c[p]) {
X						q = p;
X						p = trie_r[q];
X						first_child = FALSE;
X					}
X					if (p == 0 || c < trie_c[p]) {
X						if (trie_ptr == TRIE_SIZE)
X							overflow("pattern memory", TRIE_SIZE);
X						incr(trie_ptr);
X						trie_r[trie_ptr] = p;
X						p = trie_ptr;
X						trie_l[p] = 0;
X						if (first_child)
X							trie_l[q] = p;
X						else trie_r[q] = p;
X						trie_c[p] = c;
X						trie_o[p] = MIN_QUARTERWORD;
X					}
X					q = p;
X				}
X				if (trie_o[q] != MIN_QUARTERWORD) {
X					print_err("Duplicate pattern");
X					help1("(See Appendix H.)");
X					error();
X				}
X				trie_o[q] = v;
X			}
X			if (cur_cmd == RIGHT_BRACE)
X				goto done;
X			k = 0;
X			hyf[0] = 0;
X			digit_sensed = FALSE;
X			break;
X
X		default:
X			print_err("Bad ");
X			print_esc("patterns");
X			help1("(See Appendix H.)");
X			error();
X			break;
X		}
X	}
X
Xdone:
X	trie_root = compress_trie(trie_root);
X	init_trie_memory();
X	if (trie_root != 0) {
X		first_fit(trie_root);
X		trie_pack(trie_root);
X	}
X	r = 0;
X	while (trie_taken[r])
X		incr(r);
X	trie_ref[0] = r;
X	trie_fix(trie_root);
X	r = 0;
X	h.hh2.rh = 0;
X	h.hh2.b0 = 0;
X	h.hh2.b1 = 0;
X	do {
X		s = trie_link(r);
X		trie[r] = h;
X		r = s;
X	} while (r <= trie_max);
X}
X#endif
X
Xinit_hyph ()
X{
X#ifdef INIT
X	int		k;
X	int		z;
X
X	trie_op_ptr = MIN_QUARTERWORD;
X	trie_link(0) = 0;
X	trie_char(0) = 0;
X	trie_op(0) = 0;
X	for (k = 1; k <= 127; k++)
X		trie[k] = trie[0];
X	trie_max = 127;
X	for (z = 0; z <= HYPH_SIZE; z++) {
X		hyph_word[z] = 0;
X		hyph_list[z] = NULL;
X	}
X	hyph_count = 0;
X#endif
X}
SHAR_EOF
chmod 0444 hyph.c || echo "restore of hyph.c fails"
set `wc -c hyph.c`;Sum=$1
if test "$Sum" != "13684"
then echo original size 13684, current size $Sum;fi
echo "x - extracting hyph.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > hyph.h &&
X
X/*
X *    Copyright 1986, 1987 Pat Joseph Monardo. All rights reserved.
X *    Copying of this file is granted according to the provisions 
X *    specified in the file COPYING which must accompany this file.
X */
X
X
X/*
X *		hyph.h
X */
X
Xglobal	ptr		ha;
Xglobal	ptr		hb;
Xglobal	hword	hc[];
Xglobal	int		hn;
Xglobal	fnt		hf;
Xglobal	ascii	hu[];
Xglobal	int		hyf_char;
X
Xint		hyphenate();
X
Xglobal	byte	hyf[];
Xglobal	int		hyphen_passed;
X
Xint		reconstitute();
X
X#define	trie_link(T)		trie[T].hh2.rh
X#define	trie_char(T)		trie[T].hh2.b1
X#define	trie_op(T)			trie[T].hh2.b0
X
Xglobal	twoh	trie[];
Xglobal	qword	trie_op_ptr;
Xglobal	int		trie_max;
X
Xglobal	int		hyf_distance[];
Xglobal	int		hyf_num[];
Xglobal	qword	hyf_next[];
X
Xint		new_hyph_exceptions();
X
Xglobal	str		hyph_word[];
Xglobal	ptr		hyph_list[];
Xglobal	int		hyph_count;
X
X#ifdef INIT
X
Xglobal	qword	trie_op_hash[];
Xglobal	int		trie_min;
X
Xqword	new_trie_op();
X
X#define	trie_root		trie_l[0]
X
Xglobal	int		trie_ptr;
Xglobal	ascii	trie_c[];
Xglobal	qword	trie_o[];
Xglobal	int		trie_l[];
Xglobal	int		trie_r[];
X
Xglobal	int		trie_hash[];
X
Xint		trie_node();
Xint		compress_trie();
X
Xint		init_pattern_memory();
X
X#define	trie_ref			trie_hash
X#define	trie_back(T)		trie[T].hh1.lh
X
Xglobal	bool	trie_taken[];
X
Xint		init_trie_memory();
X
Xint		first_fit();
Xint		trie_pack();
Xint		trie_fix();
X
Xint		new_patterns();
X
X#endif
SHAR_EOF
chmod 0444 hyph.h || echo "restore of hyph.h fails"
set `wc -c hyph.h`;Sum=$1
if test "$Sum" != "1335"
then echo original size 1335, current size $Sum;fi
echo "x - extracting io.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > io.c &&
X
X/*
X *    Copyright 1986, 1987 Pat Joseph Monardo. All rights reserved.
X *    Copying of this file is granted according to the provisions 
X *    specified in the file COPYING which must accompany this file.
X */
X
X
X/*
X *		io.c
X */
X
X#include "tex.h"
X#include "char.h"
X#include "str.h"
X#include "tokenstack.h"
X#include "print.h"
X#include "file.h"
X#include "io.h"
X
Xint		last;
Xascii	buffer[BUF_SIZE];
Xint		first;
Xint		max_buf_stack;
X
XFILE *
Xa_open_in ()
X{
X	if (test_access(READ_ACCESS, INPUT_FILE_PATH))
X		return (fopen(name_of_file, "r"));
X	return NULL;
X}
X
XFILE *
Xa_open_out ()
X{
X	if (test_access(WRITE_ACCESS, NO_FILE_PATH))
X		return (fopen(name_of_file, "w"));
X	return NULL;
X}
X
XFILE *
Xb_open_in ()
X{
X	if (test_access(READ_ACCESS, FONT_FILE_PATH))
X		return (fopen(name_of_file, "r"));
X	return NULL;
X}
X
XFILE *
Xb_open_out ()
X{
X	if (test_access(WRITE_ACCESS, NO_FILE_PATH))
X		return (fopen(name_of_file, "w"));
X	return NULL;
X}
X
XFILE *
Xw_open_in ()
X{
X	if (test_access(READ_ACCESS, FORMAT_FILE_PATH))
X		return (fopen(name_of_file, "r"));
X	return NULL;
X}
X
XFILE *
Xw_open_out ()
X{
X	if (test_access(WRITE_ACCESS, NO_FILE_PATH))
X		return (fopen(name_of_file, "w"));
X	return NULL;
X}
X
Xbool 
Xinput_ln (f, bypass_eoln)
X	alpha_file	f;
X	bool		bypass_eoln;
X{
X	int			c;
X
X	last = first;
X	loop {
X		c = getc(f);
X		if (c == EOLN)
X			break;
X		if (c == EOF) {
X			if (last == first)
X				return FALSE;
X			else
X				break;
X		}
X		if (last > max_buf_stack) {
X			max_buf_stack = last + 1;
X			if (max_buf_stack == BUF_SIZE - 1)
X				overflow("buffer size", BUF_SIZE);
X		}
X		buffer[last] = xord[c];
X		incr(last);
X	}
X	loop {
X		if (last == first)
X			break;	
X		else if (buffer[last - 1] != ' ')
X			break;
X		else decr(last);
X	}
X	return TRUE;
X}
X
Xterm_input ()
X{
X	int		k;
X
X	update_terminal();
X	if (!input_ln(term_in, FALSE)) 
X		fatal_error("! End of file on the terminal");
X	term_offset = 0;
X	decr(selector);
X	if (last != first)
X		for (k = first; k < last; incr(k))
X			print_char(buffer[k]);
X	print_ln();
X	incr(selector);
X}
X
Xbool
Xinit_terminal ()
X{
X	loop {
X		fputs("**", stdout);
X		update_terminal();
X		if (!input_ln(term_in, FALSE)) {
X			puts("\n! End of file on the terminal...why?");
X			return FALSE;
X		}
X		loc = first;
X		while (loc < last && buffer[loc] == ' ')
X			incr(loc);
X		if (loc < last)
X			return TRUE;
X		puts("Please type the name of your input file.");
X	}
X}
SHAR_EOF
chmod 0444 io.c || echo "restore of io.c fails"
set `wc -c io.c`;Sum=$1
if test "$Sum" != "2327"
then echo original size 2327, current size $Sum;fi
echo "x - extracting io.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > io.h &&
X
X/*
X *    Copyright 1986, 1987 Pat Joseph Monardo. All rights reserved.
X */
X
X
X/*
X *		io.h
X */
X
Xglobal	int		last;
Xglobal	ascii	buffer[];
Xglobal	int		first;
Xglobal	int		max_buf_stack;
X
XFILE	*a_open_in();
XFILE	*a_open_out();
X
XFILE	*b_open_in();
XFILE	*b_open_out();
X
XFILE	*w_open_in();
XFILE	*w_open_out();
X
X#define	a_close(FD)				(fclose(FD))
X#define	b_close(FD)				(fclose(FD))
X#define	w_close(FD)				(fclose(FD))
X
X#define	prompt_input(S)			{print(S); term_input();}
X
Xbool 	init_terminal();
Xint		term_input();
Xbool	input_ln();
X
X#define	term_in					stdin
X#define	term_out				stdout
X#define	t_open_in()
X#define	t_open_out()
X#define	update_terminal()		fflush(stdout)
X#define	clear_terminal()
SHAR_EOF
chmod 0444 io.h || echo "restore of io.h fails"
set `wc -c io.h`;Sum=$1
if test "$Sum" != "686"
then echo original size 686, current size $Sum;fi
echo "x - extracting math.c (Text)"
sed 's/^X//' << 'SHAR_EOF' > math.c &&
X
X/*
X *    Copyright 1986, 1987 Pat Joseph Monardo. All rights reserved.
X *    Copying of this file is granted according to the provisions 
X *    specified in the file COPYING which must accompany this file.
X */
X
X
X/*
X *		math.c
X */
X
X#include "tex.h"
X#include "heap.h"
X#include "eq.h"
X#include "scan.h"
X#include "evalstack.h"
X#include "arith.h"
X#include "str.h"
X#include "box.h"
X#include "tfm.h"
X#include "print.h"
X#include "pack.h"
X#include "math.h"
X
Xtwoh	empty_field;
X
Xptr
Xnew_style (s)
X	int		s;
X{
X	ptr		p;
X
X	p = get_node(STYLE_NODE_SIZE);
X	type(p) = STYLE_NODE;
X	subtype(p) = s;
X	width(p)= 0;
X	depth(p) = 0;
X
X	return p;
X}
X
Xptr
Xnew_choice ()
X{
X	ptr		p;
X
X	p = get_node(STYLE_NODE_SIZE);
X	type(p) = CHOICE_NODE;
X	subtype(p) = 0;
X	display_mlist(p) = NULL;
X	text_mlist(p) = NULL;
X	script_mlist(p) = NULL;
X	script_script_mlist(p) = NULL;
X
X	return p;
X}
X
Xptr
Xnew_noad ()
X{
X	ptr		p;
X
X	p = get_node(NOAD_SIZE);
X	type(p) = ORD_NOAD;
X	subtype(p) = NORMAL;
X	mem[nucleus(p)].hh = empty_field;
X	mem[subscr(p)].hh = empty_field;
X	mem[supscr(p)].hh = empty_field;
X
X	return p;
X}
X
Xprint_fam_and_char (p)
X	ptr		p;
X{
X	print_esc("fam");
X	print_int(fam(p));
X	print_char(' ');
X	print_ASCII(qo(character(p)));
X}
X
Xprint_delimiter (p)
X	ptr		p;
X{
X	val		a;
X
X	a = small_fam(p) * 256 + qo(small_char(p));
X	a = a * 0x1000 + large_fam(p) * 256 + qo(large_char(p));
X	if (a < 0)
X		print_val(a);
X	else print_hex(a);
X}
X
Xprint_subsidiary_data (p, c)
X	ptr		p;
X	ascii	c;
X{
X	if (cur_length() >= depth_threshold) {
X		if (math_type(p) != EMPTY)
X			print(" []");
X		return;
X	}
X	append_char(c);
X	temp_ptr = p;
X	switch (math_type(p))
X	{
X	case MATH_CHAR:
X		print_ln();
X		print_current_string();
X		print_fam_and_char(p);
X		break;
X	
X	case SUB_BOX:
X		show_info();
X		break;
X	
X	case SUB_MLIST:
X		if (info(p) == NULL) {
X			print_ln();
X			print_current_string();
X			print("{}");
X		} else show_info();
X		break;
X	}
X	flush_char();
X}
X
Xprint_style (c)
X	int	  c;
X{
X	switch (c / 2) 
X	{
X	case 0:
X		print_esc("displaystyle");
X		break;
X
X	case 1:
X		print_esc("textstyle");
X		break;
X
X	case 2:
X		print_esc("scriptstyle");
X		break;
X
X	case 3:
X		print_esc("scriptscriptstyle");
X		break;
X
X	default:
X		print("Unknown style!");
X		break;
X	}
X}
X
Xprint_size (s)
X	int		s;
X{
X	if (s == 0)
X		print_esc("textfont");
X	else if (s == SCRIPT_SIZE)
X		print_esc("scriptfont");
X	else print_esc("scriptscriptfont");
X}
X
Xshow_normal_noad (p)
X	ptr		p;
X{
X	switch (type(p)) 
X	{
X	case ORD_NOAD:
X		print_esc("mathord");
X		break;
X
X	case OP_NOAD:
X		print_esc("mathop");
X		break;
X
X	case BIN_NOAD:
X		print_esc("mathbin");
X		break;
X
X	case REL_NOAD:
X		print_esc("mathrel");
X		break;
X
X	case OPEN_NOAD:
X		print_esc("mathopen");
X		break;
X
X	case CLOSE_NOAD:	
X		print_esc("mathclose");
X		break;
X
X	case PUNCT_NOAD:
X		print_esc("mathpunct");
X		break;
X
X	case INNER_NOAD:
X		print_esc("mathinner");
X		break;
X
X	case OVER_NOAD:
X		print_esc("overline");
X		break;
X
X	case UNDER_NOAD:
X		print_esc("underline");
X		break;
X
X	case VCENTER_NOAD:
X		print_esc("vcenter");
X		break;
X
X	case RADICAL_NOAD:
X		print_esc("radical");
X		print_delimiter(left_delimiter(p));
X		break;
X
X	case ACCENT_NOAD:
X		print_esc("accent");
X		print_fam_and_char(accent_chr(p));
X		break;
X
X	case LEFT_NOAD:
X		print_esc("left");
X		print_delimiter(nucleus(p));
X		break;
X
X	case RIGHT_NOAD:
X		print_esc("right");
X		print_delimiter(nucleus(p));
X		break;
X
X	}
X	if (subtype(p) != NORMAL)
X		if (subtype(p) == LIMITS)
X			print_esc("limits");
X		else print_esc("nolimits");
X	if (type(p) < LEFT_NOAD)
X		print_subsidiary_data(nucleus(p), '.');
X	print_subsidiary_data(supscr(p), '^');
X	print_subsidiary_data(subscr(p), '_');
X}
X
Xshow_fraction_noad (p)
X	ptr		p;
X{
X	print_esc("fraction, thickness ");
X	if (thickness(p) == DEFAULT_CODE)
X		print("= default");
X	else print_scaled(thickness(p));
X	if (small_fam(left_delimiter(p)) != 0 ||
X		small_char(left_delimiter(p)) != MIN_QUARTERWORD ||
X		large_fam(left_delimiter(p)) != 0 ||
X		large_char(left_delimiter(p)) != MIN_QUARTERWORD) {
X		print(", left-delimiter ");
X		print_delimiter(left_delimiter(p));
X	}
X	if (small_fam(right_delimiter(p)) != 0 ||
X		small_char(right_delimiter(p)) != MIN_QUARTERWORD ||
X		large_fam(right_delimiter(p)) != 0 ||
X		large_char(right_delimiter(p)) != MIN_QUARTERWORD) {
X		print(", right-delimiter ");
X		print_delimiter(right_delimiter(p));
X	}
X	print_subsidiary_data(numerator(p), '\\');
X	print_subsidiary_data(denominator(p), '/');
X}
X
Xshow_choice_node (p)
X	ptr 	p;
X{
X	print_esc("mathchoice");
X	append_char('D');
X	show_node_list(display_mlist(p));
X	flush_char();
X	append_char('T');
X	show_node_list(text_mlist(p));
X	flush_char();
X	append_char('S');
X	show_node_list(script_mlist(p));
X	flush_char();
X	append_char('s');
X	show_node_list(script_script_mlist(p));
X	flush_char();
X}
X
Xptr
Xfraction_rule (t)
X	scal	t;
X{
X	ptr		p;
X
X	p = new_rule();
X	height(p) = t;
X	depth(p) = 0;
X
X	return p;
X}
X
Xptr
Xoverbar (b, k, t)
X	ptr		b;
X	scal	k;
X	scal	t;
X{
X	ptr		p;
X	ptr		q;
X
X	p = new_kern(k);
X	link(p) = b;
X	q = fraction_rule(t);
X	link(q) = p;
X	p = new_kern(t);
X	link(p) = q;
X	return (vpack(p, NATURAL));
X}
X
Xptr
Xvar_delimiter (d, s, v)
X	ptr		d;
X	int		s;
X	scal	v;
X{
X	ptr		b;
X	qword	c;
X	fnt		f;
X	fnt		g;
X	int		m;
X	int		n;
X	fourq	q;
X	fourq	r;
X	scal	u;
X	scal	w;
X	qword	x;
X	qword	y;
X	int		z;
X	byte	hd;
X	bool	large_attempt;
X
X	f = NULL_FONT;
X	w = 0;
X	large_attempt = FALSE;
X	z = small_fam(d);
X	x = small_char(d);
X	loop {
X		if (z != 0 || x != MIN_QUARTERWORD) {
X			z = z + s + 16;
X			do {
X				z = z - 16;
X				g = fam_fnt(z);
X				if (g != NULL_FONT) {
X					y = x;
X			contin:
X					if (qo(y) >= font_bc[g] && qo(y) <= font_ec[g]) {
X						q = char_info(g, y);
X						if (char_exists(q)) {
X							if (char_tag(q) == EXT_TAG)  {
X								f = g;
X								c = y;
X								goto found;
X							}
X							hd = height_depth(q);
X							u = char_height(g, hd) + char_depth(g, hd);
X							if (u > w) {
X								f = g;
X								c = y;
X								w = u;
X								if (u >= v)
X									goto found;
X							}
X							if (char_tag(q) == LIST_TAG) {
X								y = rem_byte(q);
X								goto contin;
X							}
X						}
X					}
X				}
X			} while (z >= 16);
X		}
X		if (large_attempt)
X			goto found;
X		large_attempt = TRUE;
X		z = large_fam(d);
X		x = large_char(d);
X	}
X
Xfound:
X	if (f != NULL_FONT) {
X		if (char_tag(q) == EXT_TAG) {
X			b = new_null_box();
X			type(b) = VLIST_NODE;
X			r = font_info[exten_base[f] + rem_byte(q)].qqqq;
X			c = ext_rep(r);
X			u = height_plus_depth(f, c);
X			w = 0;
X			q = char_info(f, c);
X			width(b) = char_width(f, q) + char_italic(f, q);
X			c = ext_bot(r); 
X			if (c != MIN_QUARTERWORD)
X				w += height_plus_depth(f, c);
X			c = ext_mid(r);
X			if (c != MIN_QUARTERWORD)
X				w += height_plus_depth(f, c);
X			c = ext_top(r);
X			if (c != MIN_QUARTERWORD)
X				w += height_plus_depth(f, c);
X			n = 0;
X			if (u > 0) {
X				while (w < v) {
X					w = w + u;
X					incr(n);
X					if (ext_mid(r) != MIN_QUARTERWORD)
X						w = w + u;
X				}
X			}
X			c = ext_bot(r);
X			if (c != MIN_QUARTERWORD)
X				stack_into_box(b, f, c);
X			c = ext_rep(r);
X			for (m = 1; m <= n; incr(m)) 
X				stack_into_box(b, f, c);
X			c = ext_mid(r);
X			if (c != MIN_QUARTERWORD) {
X				stack_into_box(b, f, c);
X				c = ext_rep(r);
X				for (m = 1; m <= n; incr(m))
X					stack_into_box(b, f, c);
X			}
X			c = ext_top(r);
X			if (c != MIN_QUARTERWORD)
X				stack_into_box(b, f, c);
X			depth(b) = w - height(b);
X		} else
X			b = char_box(f, c);
X	} else {
X		b = new_null_box();
X		width(b) = null_delimiter_space;
X	}
X	shift_amount(b) = half(height(b) - depth(b)) - axis_height(s);
X	return b;
X}
X
Xptr
Xchar_box (f, c)
X	fnt		f;
X	qword	c;
X{
X	ptr		b;
X	ptr		p;
X	fourq	q;
X	byte	hd;
X
X	q = char_info(f, c);
X	hd = height_depth(q);
X	b = new_null_box();
X	width(b) = char_width(f, q) + char_italic(f, q);
X	height(b) = char_height(f, hd);
X	depth(b) = char_depth(f, hd);
X	p = get_avail();
X	character(p) = c;
X	font(p) = f;
X	list_ptr(b) = p;
X	
X	return b;
X}
X
Xstack_into_box (b, f, c)
X	ptr		b;
X	fnt		f;
X	qword	c;
X{
X	ptr		p;
X
X	p = char_box(f, c);
X	link(p) = list_ptr(b);
X	list_ptr(b) = p;
X	height(b) = height(p);
X}
X
Xscal
Xheight_plus_depth (f, c)
X	fnt		f;
X	qword	c;
X{
X	fourq	q;
X	byte	hd;
X
X	q = char_info(f, c);
X	hd = height_depth(q);
X	return (char_height(f, hd) + char_depth(f, hd));
X}
X
Xptr
Xrebox (b, w)
X	ptr		b;
X	scal	w;
X{
X	fnt		f;
X	ptr		p;
X	scal	v;
X
X	if (width(b) != w && list_ptr(b) != NULL) {
X		if (type(b) == VLIST_NODE)
X			b = hpack(b, NATURAL);
X		p = list_ptr(b);
X		if (is_char_node(p) && link(p) == NULL) {
X			f = font(p);
X			v = char_width(f, char_info(f, character(p)));
X			if (v != width(b)) 
X				link(p) = new_kern(width(b) - v);
X		}
X		free_node(b, BOX_NODE_SIZE);
X		b = new_glue(ss_glue);
X		link(b) = p;
X		while (link(p) != NULL)
X			p = link(p);
X		link(p) = new_glue(ss_glue); 
X		return (hpack(b, w, EXACTLY));
X	} else {
X		width(b) = w;
X		return b;
X	}
X}
X
X#define	mu_mult(x) \
X	nx_plus_y(n, x, xn_over_d(x, f, 0200000L))
X
Xptr
Xmath_glue (g, m)
X	ptr		g;
X	scal	m;
X{
X	scal	f;
X	val		n;
X	ptr		p;
X
X	n = x_over_n(m, 0200000L);
X	f = remainder;
X	p = get_node(GLUE_SPEC_SIZE);
X	width(p) = mu_mult(width(g));
X	stretch_order(p) = stretch_order(g);
X	if (stretch_order(p) == NORMAL)
X		stretch(p) = mu_mult(stretch(g));
X	else stretch(p) = stretch(g);
X	shrink_order(p) = shrink_order(g);
X	if (shrink_order(p) == NORMAL)
X		shrink(p) = mu_mult(shrink(g));
X	else shrink(p) = shrink(g);
X
X	return p;
X}
X
Xmath_kern (p, m)
X	ptr		p;
X	scal	m;
X{
X	scal	f;
X	val		n;
X
X	if (subtype(p) == MU_GLUE) {
X		n = x_over_n(m, 0200000L);
X		f = remainder;
X		width(p) = mu_mult(width(p));
X		subtype(p) = NORMAL;
X	}
X}
X
Xflush_math ()
X{
X	flush_node_list(link(head));
X	flush_node_list(incompleat_noad);
X	link(head) = NULL;
X	tail = head;
X	incompleat_noad = NULL;
X}
SHAR_EOF
chmod 0444 math.c || echo "restore of math.c fails"
set `wc -c math.c`;Sum=$1
if test "$Sum" != "9504"
then echo original size 9504, current size $Sum;fi
echo "x - extracting math.h (Text)"
sed 's/^X//' << 'SHAR_EOF' > math.h &&
X
X/*
X *    Copyright 1986, 1987 Pat Joseph Monardo. All rights reserved.
X *    Copying of this file is granted according to the provisions 
X *    specified in the file COPYING which must accompany this file.
X */
X
X
X/*
X *		math.h
X */
X
Xptr	new_style();
X
X#define	STYLE_NODE				(UNSET_NODE + 1)
X#define	STYLE_NODE_SIZE			3
X#define	DISPLAY_STYLE			0
X#define	TEXT_STYLE				2
X#define	SCRIPT_STYLE			4
X#define	SCRIPT_SCRIPT_STYLE		6
X#define	CRAMPED					1
X
Xptr	new_choice();
X
X#define	CHOICE_NODE				(UNSET_NODE + 2)
X#define	display_mlist(C)		info(C + 1)
X#define	text_mlist(C)			link(C + 1)
X#define	script_mlist(C)			info(C + 2)
X#define	script_script_mlist(C)	link(C + 2)
X
Xptr	new_noad();
X
X#define	NOAD_SIZE			4
X#define	nucleus(N)			(N + 1)
X#define	supscr(N)			(N + 2)
X#define	subscr(N)			(N + 3)
X#define	fam					font
X#define	math_type			link
X
X#define	ORD_NOAD			(UNSET_NODE + 3)
X#define	OP_NOAD				(ORD_NOAD + 1)
X#define	BIN_NOAD			(ORD_NOAD + 2)
X#define	REL_NOAD			(ORD_NOAD + 3)
X#define	OPEN_NOAD			(ORD_NOAD + 4)
X#define	CLOSE_NOAD			(ORD_NOAD + 5)
X#define	PUNCT_NOAD			(ORD_NOAD + 6)
X#define	INNER_NOAD			(ORD_NOAD + 7)
X
X#define	MATH_CHAR			1
X#define	SUB_BOX				2
X#define	SUB_MLIST			3
X#define	MATH_TEXT_CHAR		4
X
X#define	LIMITS				1
X#define	NO_LIMITS			2
X
X#define	left_delimiter(D)	(D + 4)
X#define	right_delimiter(D)	(D + 5)
X
X#define	small_fam(D)		mem[D].qqqq.b0
X#define	small_char(D)		mem[D].qqqq.b1
X#define	large_fam(D)		mem[D].qqqq.b2
X#define	large_char(D)		mem[D].qqqq.b3
X
X#define	RADICAL_NOAD		(INNER_NOAD + 1)
X#define	RADICAL_NOAD_SIZE	5
X#define	FRACTION_NOAD		(RADICAL_NOAD + 1)
X#define	FRACTION_NOAD_SIZE	6
X#define	DEFAULT_CODE		010000000000
X#define	thickness			width
X#define	numerator			supscr
X#define	denominator			subscr
X
X#define	null_delimiter		null_character
X
Xglobal	twoh	empty_field;
X
X#define	UNDER_NOAD			(FRACTION_NOAD + 1)
X#define	OVER_NOAD			(UNDER_NOAD + 1)
X#define	ACCENT_NOAD			(OVER_NOAD + 1)
X#define	ACCENT_NOAD_SIZE	5
X#define	accent_chr(A)		(A + 4)
X#define	VCENTER_NOAD		(ACCENT_NOAD + 1)
X#define	LEFT_NOAD			(VCENTER_NOAD + 1)
X#define	RIGHT_NOAD			(LEFT_NOAD + 1)
X#define	delimiter			nucleus	
X
X#define	scripts_allowed(N)	(type(N) >= ORD_NOAD && type(N) < LEFT_NOAD)
X
Xint		print_fam_and_char();
Xint		print_delimiter();
Xint		print_subsidiary_data();
Xint		print_style();
Xint		print_size();
X
X#define	TEXT_SIZE			0
X#define	SCRIPT_SIZE			16
X#define	SCRIPT_SCRIPT_SIZE	32
X
Xint		show_normal_noad();
Xint		show_fraction_noad();
X
X#define	mathsy(F, P) \
X	font_info[param_base[fam_fnt(2 + F)] + P].sc
X
X#define	math_x_height(F)	mathsy(F, 5)
X#define	math_quad(F)		mathsy(F, 6)
X#define	num1(F)				mathsy(F, 8)
X#define	num2(F)				mathsy(F, 9)
X#define	num3(F)				mathsy(F, 10)
X#define	denom1(F)			mathsy(F, 11)
X#define	denom2(F)			mathsy(F, 12)
X#define	sup1(F)				mathsy(F, 13)
X#define	sup2(F)				mathsy(F, 14)
X#define	sup3(F)				mathsy(F, 15)
X#define	sub1(F)				mathsy(F, 16)
X#define	sub2(F)				mathsy(F, 17)
X#define	sup_drop(F)			mathsy(F, 18)
X#define	sub_drop(F)			mathsy(F, 19)
X#define	delim1(F)			mathsy(F, 20)
X#define	delim2(F)			mathsy(F, 21)
X#define	axis_height(F)		mathsy(F, 22)
X
X#define	TOTAL_MATHSY_PARAMS	22
X
X#define	mathex(P) \
X	font_info[param_base[fam_fnt(3 + cur_size)] + P].sc
X
X#define	default_rule_thickness	mathex(8)
X#define	big_op_spacing1			mathex(9)
X#define	big_op_spacing2			mathex(10)
X#define	big_op_spacing3			mathex(11)
X#define	big_op_spacing4			mathex(12)
SHAR_EOF
echo "End of part 9"
echo "File math.h is continued in part 10"
echo "10" > s2_seq_.tmp
exit 0