STDWIN 0.9.5, Part 14/19

Guido van Rossum guido at cwi.nl
Mon Mar 4 21:58:19 AEST 1991


Archive-name: stdwin/part14

#! /bin/sh
# This is a shell archive.  Remove anything before this line, then unpack
# it by saving it into a file and typing "sh file".  To overwrite existing
# files, type "sh file -c".  You can also feed this as standard input via
# unshar, or by typing "sh <file", e.g..  If this archive is complete, you
# will see the following message at the end:
#		"End of archive 14 (of 19)."
# Contents:  Appls/bed/Dada Appls/bed/Woman Appls/dpv/dpvfunny.c
#   Appls/dpv/dpvparse.c Appls/dpv/dpvrestart.c Appls/test/magic.c
#   Appls/test/sevenseg.h H/vt.h Packs/vt/vtfunc.c Ports/alfa/timer.c
#   Ports/vtrm/uxtty.c
# Wrapped by guido at voorn.cwi.nl on Mon Mar  4 12:37:32 1991
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'Appls/bed/Dada' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Appls/bed/Dada'\"
else
echo shar: Extracting \"'Appls/bed/Dada'\" \(4767 characters\)
sed "s/^X//" >'Appls/bed/Dada' <<'END_OF_FILE'
X#define dadada_width	75
X#define dadada_height	75
Xstatic char dadada_bits[] {
X   0x20, 0x00, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00,
X   0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x1c, 0x00, 0xff, 0xff, 0x0f, 0x00,
X   0x00, 0x00, 0x10, 0x00, 0x24, 0x00, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00,
X   0x10, 0x00, 0x44, 0x00, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x10, 0x08,
X   0x84, 0x01, 0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x10, 0x30, 0x04, 0x02,
X   0xff, 0xff, 0x0f, 0x00, 0x00, 0x00, 0x10, 0x40, 0x04, 0x04, 0xff, 0xff,
X   0x0f, 0x00, 0x00, 0x00, 0x20, 0x80, 0x02, 0x18, 0xff, 0xff, 0x0f, 0x00,
X   0x00, 0x00, 0x20, 0xfe, 0xfc, 0xdf, 0x00, 0xfc, 0x0f, 0x00, 0x00, 0x00,
X   0x20, 0xfe, 0xf9, 0xbf, 0x00, 0xfc, 0x0f, 0x00, 0x00, 0x00, 0x40, 0xfe,
X   0xf6, 0x7f, 0xf1, 0xfb, 0x0f, 0x00, 0x00, 0x00, 0x40, 0xfe, 0xce, 0xff,
X   0x0e, 0xe4, 0x0f, 0x00, 0x00, 0x00, 0x80, 0x7e, 0xbf, 0xff, 0x07, 0x9c,
X   0x0f, 0x00, 0x00, 0x00, 0x80, 0x7e, 0x7f, 0x7f, 0x18, 0x7c, 0x0f, 0x00,
X   0x00, 0x00, 0x00, 0x9d, 0xff, 0xbc, 0x20, 0xfc, 0x0e, 0x00, 0x00, 0x00,
X   0x00, 0xe2, 0xff, 0xdb, 0x40, 0xfc, 0x0d, 0x00, 0x00, 0x00, 0x00, 0xfe,
X   0xff, 0xe7, 0x80, 0xfd, 0x0b, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xcf,
X   0x00, 0xfe, 0x0b, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xb7, 0xff, 0x03,
X   0x08, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0x77, 0xfe, 0x03, 0x08, 0x00,
X   0x00, 0x00, 0x00, 0xfe, 0xff, 0xf7, 0xfd, 0x03, 0x08, 0x00, 0x00, 0x00,
X   0x00, 0xfe, 0xff, 0xfb, 0xfb, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0xfe,
X   0xff, 0xfb, 0xe7, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xfb,
X   0xdf, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xfb, 0xbf, 0x03,
X   0x10, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xfb, 0x7f, 0x02, 0x10, 0x00,
X   0x00, 0x00, 0x00, 0xfe, 0xff, 0xfb, 0xff, 0x01, 0x10, 0x00, 0x00, 0x00,
X   0x00, 0xfe, 0xff, 0xfb, 0xff, 0x03, 0x10, 0x00, 0x00, 0x00, 0x00, 0xfe,
X   0xff, 0xf7, 0xff, 0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xf7,
X   0xff, 0x03, 0x08, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xf7, 0xff, 0x03,
X   0x08, 0x00, 0x00, 0x00, 0x00, 0xfe, 0xff, 0xef, 0xff, 0x03, 0x04, 0x00,
X   0x00, 0x00, 0x00, 0xfe, 0xff, 0xef, 0xff, 0x03, 0x04, 0x00, 0x00, 0x00,
X   0x00, 0xfe, 0xff, 0xdf, 0xff, 0x03, 0x02, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x40, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80,
X   0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x03, 0x60,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x18, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xf0, 0x07, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x7f, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80,
X   0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x02, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x04, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x04, 0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
X   0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x10, 0xff,
X   0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x10, 0xff, 0xff, 0xff,
X   0x00, 0x38, 0x00, 0x00, 0x08, 0x00, 0x08, 0xff, 0xff, 0xff, 0xe0, 0x07,
X   0x00, 0x00, 0x10, 0x00, 0x04, 0xff, 0xff, 0xff, 0x1f, 0x00, 0x00, 0x00,
X   0x20, 0x00, 0x02, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0xc0, 0x80,
X   0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7f, 0x00, 0xff,
X   0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0xff, 0xff, 0xff,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0xff, 0xff, 0xff, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0xf8, 0x01, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x07, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
X   0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff,
X   0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0xff, 0xff, 0xff, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 4767 -ne `wc -c <'Appls/bed/Dada'`; then
    echo shar: \"'Appls/bed/Dada'\" unpacked with wrong size!
fi
# end of 'Appls/bed/Dada'
fi
if test -f 'Appls/bed/Woman' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Appls/bed/Woman'\"
else
echo shar: Extracting \"'Appls/bed/Woman'\" \(4764 characters\)
sed "s/^X//" >'Appls/bed/Woman' <<'END_OF_FILE'
X#define woman_width	75
X#define woman_height	75
Xstatic char woman_bits[] {
X   0xfc, 0x7e, 0x40, 0x20, 0x90, 0x00, 0x07, 0x80, 0x23, 0x00, 0x00, 0xc6,
X   0xc1, 0x41, 0x98, 0xb8, 0x01, 0x07, 0x66, 0x00, 0x15, 0x9f, 0x03, 0x47,
X   0x8c, 0xc6, 0xdc, 0x7b, 0xcc, 0x00, 0xb0, 0x71, 0x0e, 0x4d, 0x06, 0x66,
X   0x73, 0x8e, 0x8f, 0x01, 0x18, 0xc4, 0x39, 0x4b, 0x02, 0x23, 0x0c, 0x04,
X   0x1e, 0x03, 0x0c, 0x08, 0xc7, 0xef, 0x08, 0x30, 0x06, 0x07, 0x1c, 0x02,
X   0x06, 0x30, 0x18, 0xae, 0xc8, 0x98, 0x3f, 0x78, 0x20, 0x06, 0x02, 0x20,
X   0x60, 0xa0, 0xc4, 0x1d, 0xc0, 0xff, 0x41, 0x04, 0xfa, 0x63, 0x80, 0xa1,
X   0xa4, 0xbd, 0x00, 0x84, 0xbf, 0x04, 0x0f, 0x06, 0xfc, 0xa1, 0x34, 0x6b,
X   0x01, 0x1c, 0xc9, 0x05, 0x06, 0xc7, 0x06, 0xbe, 0x11, 0x1e, 0x43, 0x30,
X   0x91, 0x07, 0xc3, 0x61, 0x02, 0x30, 0x1b, 0x30, 0xcc, 0x30, 0x11, 0x00,
X   0xc1, 0x3c, 0x03, 0x20, 0x0a, 0x00, 0xe8, 0x60, 0x21, 0x00, 0x61, 0x1b,
X   0xc1, 0x63, 0x08, 0xf0, 0xc6, 0xc7, 0x21, 0x03, 0xf8, 0x08, 0xe1, 0xcf,
X   0x0a, 0xfc, 0x4d, 0x99, 0x43, 0x07, 0x3c, 0x0c, 0xf1, 0x9f, 0x0b, 0xfc,
X   0x5b, 0x91, 0x47, 0x02, 0x16, 0x04, 0x31, 0x1c, 0x0b, 0x1f, 0x17, 0x89,
X   0x4d, 0x06, 0x1a, 0x04, 0x31, 0x38, 0x02, 0x07, 0x56, 0x99, 0x4b, 0x04,
X   0x0b, 0x04, 0xb1, 0x72, 0x82, 0xa1, 0x54, 0xba, 0x49, 0x04, 0x1d, 0x66,
X   0x50, 0xe7, 0xc2, 0xf0, 0x54, 0x9a, 0x58, 0x04, 0x0d, 0x62, 0xc1, 0x1f,
X   0x44, 0xfc, 0x51, 0x90, 0x90, 0x04, 0x86, 0x63, 0xe0, 0x74, 0x04, 0xef,
X   0x31, 0x1a, 0x91, 0x00, 0x02, 0xe2, 0xc1, 0xfd, 0x84, 0xf9, 0x30, 0x0a,
X   0x91, 0x00, 0x82, 0xa9, 0xc0, 0xb9, 0x84, 0xf9, 0x31, 0x16, 0x81, 0x00,
X   0x42, 0xa9, 0xdb, 0x7f, 0x0c, 0xff, 0x1c, 0x16, 0x11, 0x00, 0x02, 0x28,
X   0x0b, 0x07, 0x08, 0x60, 0x1c, 0x02, 0x91, 0x00, 0x46, 0x29, 0x0e, 0x00,
X   0x00, 0x00, 0x10, 0x16, 0x11, 0x02, 0x06, 0x29, 0x04, 0x00, 0x00, 0x00,
X   0x10, 0x16, 0x91, 0x06, 0xa6, 0x2a, 0x04, 0x00, 0x00, 0x00, 0x18, 0x24,
X   0x91, 0x04, 0x86, 0x2a, 0x04, 0x00, 0x00, 0x00, 0x18, 0x27, 0x93, 0x04,
X   0x96, 0x4a, 0x04, 0x00, 0x00, 0x20, 0x04, 0x02, 0x91, 0x04, 0x86, 0x4a,
X   0x0c, 0x00, 0x00, 0x00, 0x1e, 0x23, 0x93, 0x04, 0x56, 0x88, 0x08, 0x00,
X   0x00, 0x00, 0x90, 0x21, 0x93, 0x04, 0x52, 0x0a, 0x09, 0x80, 0x01, 0x00,
X   0xd0, 0x21, 0x95, 0x04, 0x57, 0x0a, 0x0f, 0x80, 0x27, 0x00, 0xd8, 0x20,
X   0x9d, 0x04, 0x5d, 0x08, 0x1c, 0x80, 0x67, 0x00, 0xe4, 0x01, 0x85, 0x04,
X   0x79, 0x8a, 0x3f, 0x00, 0x00, 0x00, 0xf4, 0x11, 0x85, 0x06, 0x39, 0x08,
X   0x7d, 0x00, 0x00, 0x18, 0xb7, 0x10, 0x81, 0x03, 0x29, 0x12, 0xcb, 0x00,
X   0x7e, 0x30, 0x28, 0x00, 0x85, 0x03, 0x29, 0x10, 0xbe, 0x81, 0xff, 0x27,
X   0x0c, 0x10, 0x85, 0x03, 0x29, 0x32, 0xfa, 0xc1, 0xff, 0x27, 0x94, 0x11,
X   0x85, 0x03, 0x28, 0x20, 0x6c, 0xe1, 0xff, 0x07, 0x0c, 0x01, 0x85, 0x01,
X   0x28, 0x62, 0x5c, 0xe3, 0x8f, 0x03, 0x4e, 0x91, 0x80, 0x05, 0x39, 0x40,
X   0xf4, 0xc2, 0xff, 0x00, 0x9f, 0x91, 0x84, 0x05, 0x31, 0xc6, 0xe8, 0x07,
X   0x7f, 0x80, 0xcd, 0x00, 0xc4, 0x04, 0x31, 0x06, 0xc9, 0x0e, 0x00, 0xc0,
X   0x48, 0x88, 0xe0, 0x04, 0x79, 0x04, 0xdb, 0x12, 0x00, 0x30, 0x0c, 0xc8,
X   0xe4, 0x04, 0x6d, 0x06, 0xb6, 0x23, 0x00, 0x18, 0x1c, 0xc0, 0x84, 0x06,
X   0x25, 0x0c, 0xff, 0xc2, 0x00, 0x4e, 0x06, 0xb0, 0x80, 0x04, 0x3f, 0x8a,
X   0xb3, 0x83, 0xff, 0xc3, 0x03, 0x91, 0x84, 0x04, 0x2e, 0xd8, 0x0f, 0x3f,
X   0x00, 0x00, 0x5f, 0x83, 0x84, 0x04, 0x2a, 0x70, 0xfd, 0x7f, 0x00, 0x00,
X   0xc8, 0xc0, 0x84, 0x04, 0x4b, 0xe2, 0x2f, 0x01, 0x00, 0x08, 0x58, 0x60,
X   0x80, 0x05, 0x5b, 0x82, 0xff, 0x01, 0x00, 0x08, 0xd0, 0xa0, 0x84, 0x04,
X   0x72, 0x80, 0xe5, 0x00, 0x00, 0x28, 0xd2, 0x20, 0x44, 0x04, 0xca, 0x02,
X   0xff, 0x00, 0x00, 0x08, 0xde, 0xa0, 0x44, 0x04, 0x82, 0x02, 0x6d, 0x00,
X   0x00, 0x08, 0xf6, 0xb0, 0x40, 0x02, 0x82, 0x07, 0x3f, 0x00, 0x00, 0x08,
X   0x44, 0x58, 0xc4, 0x02, 0x93, 0x3f, 0x1f, 0x00, 0x00, 0x30, 0x88, 0x4f,
X   0x44, 0x03, 0x83, 0x23, 0x3e, 0x00, 0x00, 0x00, 0x18, 0x60, 0xe0, 0x07,
X   0xe3, 0x0f, 0xfe, 0x00, 0x00, 0x00, 0x70, 0x70, 0xe4, 0x07, 0xc7, 0x1b,
X   0xfe, 0x01, 0x00, 0x40, 0xe0, 0x3c, 0xe4, 0x07, 0xc7, 0xe3, 0xfe, 0x1f,
X   0x00, 0x00, 0xff, 0x1f, 0xfc, 0x07, 0xc7, 0x03, 0xf8, 0x33, 0x00, 0xc0,
X   0xf0, 0x07, 0xff, 0x07, 0x87, 0x02, 0xfc, 0x43, 0x00, 0x60, 0xf0, 0xff,
X   0xff, 0x07, 0x8f, 0x06, 0xbe, 0x87, 0x00, 0x30, 0xf8, 0xff, 0xff, 0x07,
X   0x8f, 0x14, 0x9c, 0x8f, 0x00, 0x00, 0xfc, 0xff, 0xff, 0x07, 0x9f, 0x8d,
X   0x8a, 0x0f, 0x00, 0x00, 0xfe, 0xff, 0xff, 0x07, 0xbf, 0x0b, 0x80, 0x1f,
X   0x00, 0x40, 0xff, 0xff, 0xff, 0x07, 0x7f, 0x3a, 0x80, 0x3f, 0x00, 0x80,
X   0xff, 0xff, 0xff, 0x07, 0xff, 0x20, 0xc0, 0x3f, 0x00, 0x80, 0xff, 0xff,
X   0xff, 0x07, 0xff, 0x01, 0xe0, 0x7f, 0x00, 0xc0, 0xff, 0xff, 0xff, 0x07,
X   0xff, 0x0f, 0xf8, 0xff, 0x40, 0xe0, 0xff, 0xff, 0xff, 0x07, 0xff, 0xff,
X   0xff, 0xff, 0x40, 0xf0, 0xff, 0xff, 0xff, 0x07, 0xff, 0xff, 0xff, 0xff,
X   0x41, 0xf0, 0xff, 0xff, 0xff, 0x07};
END_OF_FILE
if test 4764 -ne `wc -c <'Appls/bed/Woman'`; then
    echo shar: \"'Appls/bed/Woman'\" unpacked with wrong size!
fi
# end of 'Appls/bed/Woman'
fi
if test -f 'Appls/dpv/dpvfunny.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Appls/dpv/dpvfunny.c'\"
else
echo shar: Extracting \"'Appls/dpv/dpvfunny.c'\" \(4890 characters\)
sed "s/^X//" >'Appls/dpv/dpvfunny.c' <<'END_OF_FILE'
X/* dpv -- ditroff previewer.  Funny character translation. */
X
X#include "dpv.h"
X#include "dpvmachine.h"
X#include "dpvoutput.h"
X
Xchar	*funnyfile;	/* File to read table from */
X
Xchar	*funnytries[]= {	/* Alternative files to try */
X		"funnytab",
X		"/usr/local/lib/funnytab",
X		"/userfs3/amoeba/lib/funnytab",
X		"/ufs/guido/lib/funnytab",
X		NULL
X	};
X
X/* Funny character translation table.
X   The table implies that character 'name' (the ditroff input name,
X   e.g. "bu" for bullet, which is input as "\(bu") must be translated
X   the string 'trans' drawn in font 'font', or in the current font
X   if 'font' is NULL.  'Trans' is a string because some characters
X   need several real characters to print them (e.g., ligatures).
X   For higher-quality output, the table should be extended to
X   include a point size increment/decrement and possibly a (dh, dv)
X   translation; but what the heck, this is only a previewer! */
X
Xstatic struct _funny {
X	char name[4];
X	char trans[4];
X	char *fontname;
X};
X
X/* Read funny character translation table.
X   File format:
X   	name	fontname	translation
X   where:
X   	name is the ditroff character name, e.g., bs for \(bs
X   	fontname is the font name, or - if the translation uses the current font
X   	translation is one or more hexadecimal numbers, or a string
X   	enclosed in double quotes
X   	In any case the string may be no more than 3 characters long
X*/
X
Xreadfunnytab(filename)
X	char *filename;
X{
X	char buf[BUFSIZ];
X	FILE *fp= fopen(filename, "r");
X	if (fp == NULL) {
X		if (dbg > 0)
X			fprintf(stderr, "Can't open funnytab %s\n", filename);
X		return FALSE;
X	}
X	if (dbg > 0)
X		fprintf(stderr, "Reading funnytab from %s\n", filename);
X	while (fgets(buf, sizeof buf, fp) != NULL) {
X		char *name;
X		char *fontname;
X		char *trans;
X		char ctrans[4];
X		char *p= buf;
X		while (*p != EOS && isspace(*p))
X			++p;
X		if (*p == EOS)
X			continue;
X		name= p;
X		while (*p != EOS && !isspace(*p))
X			++p;
X		if (*p == EOS)
X			continue;
X		*p++ = EOS;
X		while (*p != EOS && isspace(*p))
X			++p;
X		if (*p == EOS)
X			continue;
X		fontname= p;
X		while (*p != EOS && !isspace(*p))
X			++p;
X		if (*p == EOS)
X			continue;
X		*p++ = EOS;
X		while (*p != EOS && isspace(*p))
X			++p;
X		if (*p == EOS)
X			continue;
X		if (*p == '"') {
X			trans= ++p;
X			while (*p != EOS && *p != EOL && *p != '"')
X				++p;
X			*p= EOS;
X		}
X		else if (*p == '0' && p[1] == 'x') {
X			int a= 0, b= 0, c= 0;
X			(void) sscanf(p, "0x%x 0x%x 0x%x", &a, &b, &c);
X			ctrans[0]= a;
X			ctrans[1]= b;
X			ctrans[2]= c;
X			ctrans[3]= EOS;
X			trans= ctrans;
X		}
X		else
X			error(WARNING, "almost-match in funnytab");
X		addtranslation(name, fontname, trans);
X	}
X	fclose(fp);
X	sorttranslations();
X	return TRUE;
X}
X
Xint nfunny;
Xstruct _funny *funnytab;
X
Xstatic
Xaddtranslation(name, fontname, trans)
X	char *name, *fontname, *trans;
X{
X	struct _funny f;
X	strncpy(f.name, name, 4);
X	f.name[3]= EOS;
X	strncpy(f.trans, trans, 4);
X	f.trans[3]= EOS;
X	if (fontname == NULL || fontname[0] == EOS ||
X		fontname[0] == '-' && fontname[1] == EOS)
X		f.fontname= NULL;
X	else {
X		static char *lastfontname;
X		if (lastfontname == NULL ||
X			strcmp(fontname, lastfontname) != 0)
X			lastfontname= strdup(fontname);
X		f.fontname= lastfontname;
X	}
X	L_APPEND(nfunny, funnytab, struct _funny, f);
X	if (funnytab == NULL)
X		error(FATAL, "out of mem for funnytab");
X}
X
Xstatic
Xfunnycmp(p, q)
X	struct _funny *p, *q;
X{
X	return strcmp(p->name, q->name);
X}
X
Xstatic
Xsorttranslations()
X{
X	/* Don't sort -- the lookup algorithm depends on the order */
X#if 0
X	if (nfunny > 1)
X		qsort(funnytab, nfunny, sizeof(struct _funny), funnycmp);
X#endif
X}
X
X/* Draw a funny character.  Called from put1s. */
X
Xdrawfunny(name)
X	register char *name;
X{
X	register struct _funny *f;
X	TEXTATTR save;
X	static bool inited;
X	
X	if (!inited) {
X		if (funnyfile != NULL) {
X			/* Explicitly specified funnyfile -- must exist */
X			if (!readfunnytab(funnyfile))
X				error(FATAL, "can't find funnytab file %s",
X					funnyfile);
X		}
X		else {
X			/* Try to find default funnyfile */
X			int i= 0;
X			while ((funnyfile= funnytries[i++]) != NULL) {
X				if (readfunnytab(funnyfile))
X					break;
X			}
X			/* If not found, limp ahead... */
X			if (funnyfile == NULL)
X				error(WARNING,
X					"can't find default funnytab");
X		}
X		inited= TRUE;
X	}
X	
X	/* If this is too slow, could use binary search and/or
X	   replace the strcmp by an explicit comparison of two
X	   characters.  But spend your time on the program's
X	   main loop (especially, 'put1') first! */
X	for (f= funnytab; f < &funnytab[nfunny]; ++f) {
X		/* Assume names are always 1 or 2 chars */
X		if (f->name[0] == name[0] && f->name[1] == name[1])
X			break;
X	}
X	if (f >= &funnytab[nfunny])
X		return; /* Unknown character -- don't draw it */
X	if (f->fontname != NULL) {
X		char buf[256];
X		wgettextattr(&save);
X		fonthack(f->fontname);
X	}
X	wdrawtext(HWINDOW, VWINDOW - wbaseline(), f->trans, -1);
X	if (f->fontname != NULL)
X		wsettextattr(&save);
X}
END_OF_FILE
if test 4890 -ne `wc -c <'Appls/dpv/dpvfunny.c'`; then
    echo shar: \"'Appls/dpv/dpvfunny.c'\" unpacked with wrong size!
fi
# end of 'Appls/dpv/dpvfunny.c'
fi
if test -f 'Appls/dpv/dpvparse.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Appls/dpv/dpvparse.c'\"
else
echo shar: Extracting \"'Appls/dpv/dpvparse.c'\" \(4648 characters\)
sed "s/^X//" >'Appls/dpv/dpvparse.c' <<'END_OF_FILE'
X/* dpv -- ditroff previewer.  Parser for ditroff output. */
X
X#include "dpv.h"
X#include "dpvmachine.h"
X#include "dpvoutput.h"
X#include "dpvdoc.h" /* Descripton of ditroff output format */
X
X/* Parser main loop.  Read input from fp.
X   Stop when EOF hit, 'x stop' found, or nextpage returns < 0.
X   This makes calls to the machine module to update the
X   virtual machine's state, and to the output module to perform
X   actual output.
X   Code derived from a (not very robust) ditroff filter by BWK. */
X
Xparse(fp)
X	register FILE *fp;
X{
X	register int c, k;
X	int m, n, n1, m1;
X	char str[100], buf[300];
X	
X	while ((c = getc(fp)) != EOF) {
X		switch (c) {
X		case '\n':	/* when input is text */
X		case '\0':	/* occasional noise creeps in */
X		case '\t':
X		case ' ':
X			break;
X		case '{':	/* push down current environment */
X			t_push();
X			break;
X		case '}':
X			t_pop();
X			break;
X		case '0': case '1': case '2': case '3': case '4':
X		case '5': case '6': case '7': case '8': case '9':
X			/* two motion digits plus a character */
X			k= (c-'0')*10;
X			c= getc(fp);
X			k += c-'0';
X			hmot(k);
X			c= getc(fp);
X			put1(c);
X			break;
X		case 'c':	/* single ascii character */
X			c= getc(fp);
X			put1(c);
X			break;
X		case 'C':
X			fscanf(fp, "%s", str);
X			put1s(str);
X			break;
X		case 't':	/* straight text */
X			if (fgets(buf, sizeof(buf), fp) == NULL)
X			    error(FATAL, "unexpected end of input");
X			t_text(buf);
X			break;
X		case 'D':	/* draw function */
X			if (fgets(buf, sizeof(buf), fp) == NULL)
X			    error(FATAL, "unexpected end of input");
X			switch (buf[0]) {
X			case 'l':	/* draw a line */
X			    sscanf(buf+1, "%d %d", &n, &m);
X			    drawline(n, m);
X			    break;
X			case 'c':	/* circle */
X			    sscanf(buf+1, "%d", &n);
X			    drawcirc(n);
X			    break;
X			case 'e':	/* ellipse */
X			    sscanf(buf+1, "%d %d", &m, &n);
X			    drawellip(m, n);
X			    break;
X			case 'a':	/* arc */
X			    sscanf(buf+1, "%d %d %d %d", &n, &m, &n1, &m1);
X			    drawarc(n, m, n1, m1);
X			    break;
X			case '~':	/* wiggly line */
X			    /* HIRO: how to scan? */
X			    drawwig(buf+1, fp, 1);
X			    break;
X			default:
X			    error(FATAL, "unknown drawing function %s", buf);
X			    break;
X			}
X			recheck();
X			break;
X		case 's':
X			fscanf(fp, "%d", &n);
X			setsize(t_size(n));
X			break;
X		case 'f':
X			fscanf(fp, "%s", str);
X			setfont(t_font(str));
X			break;
X		case 'H':	/* absolute horizontal motion */
X			while ((c = getc(fp)) == ' ')
X				;
X			k = 0;
X			do {
X				k = 10 * k + c - '0';
X			} while (isdigit(c = getc(fp)));
X			ungetc(c, fp);
X			hgoto(k);
X			break;
X		case 'h':	/* relative horizontal motion */
X			while ((c = getc(fp)) == ' ')
X				;
X			k = 0;
X			do {
X				k = 10 * k + c - '0';
X			} while (isdigit(c = getc(fp)));
X			ungetc(c, fp);
X			hmot(k);
X			break;
X		case 'w':	/* word space */
X			break;
X		case 'V':
X			fscanf(fp, "%d", &n);
X			vgoto(n);
X			break;
X		case 'v':
X			fscanf(fp, "%d", &n);
X			vmot(n);
X			break;
X		case 'P':	/* new spread (Versatec hack) */
X			break;
X		case 'p':	/* new page */
X			fscanf(fp, "%d", &n);
X			if (t_page(n) < 0)
X				return;
X			break;
X		case 'n':	/* end of line */
X			t_newline();
X		/* Fall through */
X		case '#':	/* comment */
X			do {
X				c = getc(fp);
X			} while (c != EOL && c != EOF);
X			break;
X		case 'x':	/* device control */
X			if (devcntrl(fp) < 0)
X				return;
X			break;
X		default:
X			error(FATAL, "unknown input character %o %c", c, c);
X		}
X	}
X	error(WARNING, "read till EOF");
X}
X
X/* Parse rest of device control line.
X   Returns -1 upon receiving EOF or "stop" command. */
X
Xstatic int
Xdevcntrl(fp)
X	FILE *fp;
X{
X        char str[20], str1[50], buf[50];
X	extern char *namemap(); /* ??? */
X	int c, n;
X
X	fscanf(fp, "%s", str);
X	switch (str[0]) {	/* crude for now */
X	case 'i':	/* initialize */
X		t_init();
X		break;
X	case 't':	/* trailer */
X		break;
X	case 'p':	/* pause -- can restart */
X		t_reset('p');
X		break;
X	case 's':	/* stop */
X		t_reset('s');
X		return -1;
X	case 'r':	/* resolution assumed when prepared */
X		fscanf(fp, "%d", &res);
X		break;
X	case 'f':	/* font used */
X		fscanf(fp, "%d %s", &n, str);
X		(void) fgets(buf, sizeof buf, fp);   /* in case of filename */
X		ungetc(EOL, fp);		/* fgets goes too far */
X		str1[0] = 0;			/* in case nothing comes in */
X		(void) sscanf(buf, "%s", str1);
X		loadfont(n, str, str1);
X		break;
X	case 'H':	/* char height */
X		fscanf(fp, "%d", &n);
X		t_charht(n);
X		break;
X	case 'S':	/* slant */
X		fscanf(fp, "%d", &n);
X		t_slant(n);
X		break;
X	case 'T':	/* device name */
X		buf[0]= EOS;
X		fscanf(fp, "%s", buf);
X		if (buf[0] != EOS)
X			devname= strdup(buf);
X		break;
X
X	}
X	while ((c = getc(fp)) != EOL) {	/* skip rest of input line */
X		if (c == EOF)
X			return -1;
X	}
X	return 0;
X}
END_OF_FILE
if test 4648 -ne `wc -c <'Appls/dpv/dpvparse.c'`; then
    echo shar: \"'Appls/dpv/dpvparse.c'\" unpacked with wrong size!
fi
# end of 'Appls/dpv/dpvparse.c'
fi
if test -f 'Appls/dpv/dpvrestart.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Appls/dpv/dpvrestart.c'\"
else
echo shar: Extracting \"'Appls/dpv/dpvrestart.c'\" \(4228 characters\)
sed "s/^X//" >'Appls/dpv/dpvrestart.c' <<'END_OF_FILE'
X/* dpv -- ditroff previewer.  Functions to restart anywhere in the file. */
X
X#include "dpv.h"
X#include "dpvmachine.h"
X#include "dpvoutput.h"
X
Xtypedef struct _restartinfo {
X	long filepos;		/* File position for fseek */
X	int pageno;		/* External page number */
X	fontinfo fonts;		/* Mounted font table */
X	int font, size;		/* Current font and size */
X} restartinfo;
X
Xint		npages;		/* Number of pages so far */
Xbool		nomore;		/* Set when the last page has been seen */
Xrestartinfo	*pagelist;	/* State needed to start each page */
Xint		ipage;		/* Internal page in file */
Xint		showpage;	/* Internal page displayed in window */
Xint		prevpage;	/* Last page visited (for '-' command) */
Xint		stoppage;	/* Internal page where to stop */
XFILE		*ifile;		/* The input file */
X
X		/* In order to avoid passing the file pointer around from
X		   parse() via t_page() to nextpage(), the input file is
X		   made available as a global variable. */
X
X/* Initialize everything in the right order.  Tricky! */
X
Xinitialize(filename, firstpage)
X	char *filename;
X	int firstpage;
X{
X	ifile= fopen(filename, "r");
X	if (ifile == NULL)
X		error(ABORT, "%s: cannot open", filename);
X	setpageinfo(ftell(ifile), 0); /* Page 0 (== header) starts here */
X	
X	showpage= -1; /* Show no pages */
X	stoppage= 1; /* Stop at beginning of page 1 */
X	parse(ifile); /* Read the header */
X	
X	initoutput(filename); /* Create the window */
X	
X	showpage= 1;
X	skiptopage(firstpage);
X}
X
X/* Close the file */
X
Xcleanup()
X{
X	fclose(ifile);
X}
X
X/* Skip n pages forward, default 1 */
X
Xforwpage(n)
X	int n;
X{
X	if (n <= 0)
X		n= 1;
X	gotopage(showpage+n);
X}
X
X/* Skip n pages back, default 1 */
X
Xbackpage(n)
X	int n;
X{
X	if (n <= 0)
X		n= 1;
X	gotopage(showpage-n);
X}
X
X/* Go to internal page number n, and force a redraw */
X
Xgotopage(n)
X	int n;
X{
X	int saveshowpage= showpage;
X	skiptopage(n);
X	if (showpage != saveshowpage)
X		prevpage= saveshowpage;
X	changeall();
X}
X
X/* Skip to internal page number n -- don't force a redraw */
X
Xstatic
Xskiptopage(n)
X	int n;
X{
X	int orign= n;
X	if (n <= 0)
X		n= 1;
X	if (n == showpage) {
X		if (orign < n)
X			wfleep();
X		return;
X	}
X	if (n >= npages) {
X		if (nomore) {
X			n= npages-1;
X			if (n == showpage) {
X				wfleep();
X				return;
X			}
X			showpage= n;
X		}
X		else {
X			backtopage(npages-1);
X			showpage= -1;
X			stoppage= n;
X			parse(ifile);
X			showpage= npages-1;
X		}
X	}
X	else
X		showpage= n;
X}
X
X/* Draw procedure */
X
Xvoid
Xdrawproc(drawwin, left, top, right, bottom)
X	WINDOW *drawwin;
X	int left, top, right, bottom;
X{
X	topdraw= top;
X	botdraw= bottom;
X	backtopage(showpage);
X	stoppage= showpage+1;
X	parse(ifile);
X}
X
X/* Record the current file position as the start of the page
X   with (external) page number 'pageno'.
X   Note that the 'p' command has already been consumed by the parser.
X   Return < 0 if the parser can stop parsing. */
X
Xint
Xnextpage(pageno)
X	int pageno;
X{
X	++ipage;
X	setpageinfo(ftell(ifile), pageno);
X	if (ipage >= stoppage)
X		return -1; /* Stop parsing */
X	else
X		return 0;
X}
X
X/* Indicate that the end of the input has been reached.
X   No more new pages will be accepted. */
X
Xlastpage()
X{
X	nomore= TRUE;
X}
X
X/* Store info about coming page.
X   Called at start of file and after 'p' command processed */
X
Xstatic
Xsetpageinfo(filepos, pageno)
X	long filepos;
X	int pageno;
X{
X	if (statep != state)
X		error(FATAL, "setpageinfo: {} stack not empty");
X	if (ipage < npages) {
X		/* We've been here already.
X		   Might as well check consistency. */
X		/* HIRO */
X	}
X	else if (ipage > npages)
X		error(ABORT, "setpageinfo: ipage>npages (can't happen)");
X	else {
X		restartinfo r;
X		r.filepos= filepos;
X		r.pageno= pageno;
X		r.fonts= fonts;
X		r.font= font;
X		r.size= size;
X		L_APPEND(npages, pagelist, restartinfo, r);
X		if (pagelist == NULL)
X			error(FATAL, "out of mem for pagelist");
X	}
X}
X
X/* Position the input stream at the start of internal page i
X   and restore the machine state to the state remembered for that page */
X
Xstatic
Xbacktopage(i)
X	int i;
X{
X	restartinfo *p;
X	
X	if (i < 0 || i >= npages)
X		error(ABORT, "backtopage: called with wrong arg");
X	p= &pagelist[i];
X	if (fseek(ifile, p->filepos, 0) < 0)
X		error(FATAL, "backtopage: can't fseek");
X	ipage= i;
X	fonts= p->fonts;
X	font= p->font;
X	size= p->size;
X	hpos= 0;
X	vpos= 0;
X	statep= state;
X	usefont();
X}
END_OF_FILE
if test 4228 -ne `wc -c <'Appls/dpv/dpvrestart.c'`; then
    echo shar: \"'Appls/dpv/dpvrestart.c'\" unpacked with wrong size!
fi
# end of 'Appls/dpv/dpvrestart.c'
fi
if test -f 'Appls/test/magic.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Appls/test/magic.c'\"
else
echo shar: Extracting \"'Appls/test/magic.c'\" \(4520 characters\)
sed "s/^X//" >'Appls/test/magic.c' <<'END_OF_FILE'
X/* Magic -- tool to help editing magic squares */
X
X#include "stdwin.h"
X
X/* Arbitrary limitations */
X#define MAXSIZE 25
X#define DEFSIZE 5
X#define FARAWAY 10000
X
X/* Defining data */
Xint size;
Xchar sq[MAXSIZE][MAXSIZE];
X
X/* Derived data */
Xint rowsum[MAXSIZE];
Xint colsum[MAXSIZE];
Xint diagsum, secdiagsum;
Xint ok;
X
X/* Input parameters */
Xint last;
X
X/* Output parameters */
XWINDOW *win;
Xint origleft, origtop;
Xint rowheight, colwidth;
X
Xevaluate()
X{
X	int row, col;
X	int sum;
X	
X	diagsum = 0;
X	secdiagsum = 0;
X	for (row = 0; row < size; ++row) {
X		diagsum += sq[row][row];
X		secdiagsum += sq[row][size-1-row];
X	}
X	
X	ok = (diagsum == secdiagsum) && (diagsum > 0);
X	
X	for (row = 0; row < size; ++row) {
X		sum = 0;
X		for (col = 0; col < size; ++col)
X			sum += sq[row][col];
X		rowsum[row] = sum;
X		if (ok)
X			ok = (sum == diagsum);
X	}
X	
X	for (col = 0; col < size; ++col) {
X		sum = 0;
X		for (row = 0; row < size; ++row)
X			sum += sq[row][col];
X		colsum[col] = sum;
X		if (ok)
X			ok = (sum == diagsum);
X	}
X}
X
Xcenter(h, v, n)
X	int h, v;
X	int n;
X{
X	char buf[25];
X	int width;
X	
X	if (n == 0)
X		return;
X	sprintf(buf, "%d", n);
X	width = wtextwidth(buf, -1);
X	wdrawtext(h + (colwidth - width)/2, v + wlineheight()/2, buf, -1);
X}
X
Xvoid
Xdrawproc(win, left, top, right, bottom)
X	WINDOW *win;
X{
X	int h, v;
X	int row, col;
X	
X	v = origtop;
X	for (row = 0; row < size; ++row) {
X		h = origleft;
X		wdrawline(h, v, h+size*colwidth, v);
X		for (col = 0; col < size; ++col) {
X			center(h, v, sq[row][col]);
X			h += colwidth;
X		}
X		center(h+3, v, rowsum[row]);
X		v += rowheight;
X	}
X	wdrawline(origleft, v, origleft + size*colwidth, v);
X	
X	center(origleft - colwidth, v, secdiagsum);
X	
X	h = origleft;
X	for (col = 0; col < size; ++col) {
X		wdrawline(h, origtop, h, v);
X		center(h, v, colsum[col]);
X		h += colwidth;
X	}
X	wdrawline(h, origtop, h, v);
X	
X	center(h+3, v, diagsum);
X	
X	wdrawbox(origleft-1, origtop-1, h+2, v+2);
X	
X	if (last > 0 && ok)
X		wdrawbox(origleft-3, origtop-3, h+4, v+4);
X}
X
Xreset(newsize)
X	int newsize;
X{
X	int row, col;
X	char buf[100];
X	
X	size = newsize;
X	for (row = 0; row < size; ++row)
X		for (col = 0; col < size; ++col)
X			sq[row][col] = 0;
X	
X	evaluate();
X	
X	last = 0;
X	
X	sprintf(buf, "%dx%d Magic Square", size, size);
X	wsettitle(win, buf);
X	
X	wsetdocsize(win,
X			origleft + (size+1)*colwidth + 3,
X			origtop + (size+1)*rowheight);
X	
X	wchange(win, 0, 0, FARAWAY, FARAWAY);
X}
X
Xinit()
X{
X	colwidth = wtextwidth(" 000 ", -1);
X	rowheight = wlineheight() * 2;
X	origleft = colwidth;
X	origtop = rowheight;
X}
X
Xclick(h, v)
X	int h, v;
X{
X	int row, col;
X	int oldok;
X	
X	if (last >= size*size) {
X		wfleep();
X		return;
X	}
X	
X	if (h < origleft || v < origtop)
X		return;
X	
X	col = (h - origleft) / colwidth;
X	row = (v - origtop) / rowheight;
X	if (row >= size || col >= size)
X		return;
X	
X	if (sq[row][col] != 0) {
X		wfleep();
X		return;
X	}
X	
X	sq[row][col] = ++last;
X	
X	oldok = ok;
X	evaluate();
X	if (ok != oldok)
X		wchange(win, 0, 0, FARAWAY, FARAWAY);
X	else
X		change(row, col);
X}
X
Xchange(row, col)
X	int row, col;
X{
X	wchange(win,
X		origleft + col*colwidth + 1, origtop + row*rowheight + 1,
X		origleft + (col+1)*colwidth, origtop + (row+1)*rowheight);
X	wchange(win, 0, origtop + size*rowheight + 2, FARAWAY, FARAWAY);
X	wchange(win, origleft + size*colwidth + 2, 0, FARAWAY, FARAWAY);
X}
X
Xundo()
X{
X	int row, col;
X	int oldok;
X	
X	if (last == 0) {
X		wfleep();
X		return;
X	}
X	
X	for (row = 0; row < size; ++row) {
X		for (col = 0; col < size; ++col) {
X			if (sq[row][col] == last) {
X				sq[row][col] = 0;
X				--last;
X				oldok = ok;
X				evaluate();
X				if (ok != oldok)
X					wchange(win, 0, 0, FARAWAY, FARAWAY);
X				else
X					change(row, col);
X				return;
X			}
X		}
X	}
X	/* Shouldn't get here */
X	wfleep(); wfleep();
X}
X
Xmain(argc, argv)
X	int argc;
X	char **argv;
X{
X	EVENT e;
X	
X	winitargs(&argc, &argv);
X	init();
X	wsetdefwinsize(origleft + (DEFSIZE+2)*colwidth,
X			origtop + (DEFSIZE+2)*rowheight);
X	win = wopen("Magic Square", drawproc);
X	reset(DEFSIZE);
X	
X	for (;;) {
X		wgetevent(&e);
X		switch (e.type) {
X		case WE_MOUSE_UP:
X			click(e.u.where.h, e.u.where.v);
X			break;
X		case WE_COMMAND:
X			switch (e.u.command) {
X			case WC_CLOSE:
X				wdone();
X				exit(0);
X			case WC_CANCEL:
X				reset(size);
X				break;
X			case WC_BACKSPACE:
X				undo();
X				break;
X			}
X			break;
X		case WE_CLOSE:
X			wdone();
X			exit(0);
X		case WE_CHAR:
X			if (e.u.character >= '1' && e.u.character <= '9')
X				reset(e.u.character - '0');
X			else if (e.u.character == '0')
X				reset(size);
X			else if (e.u.character == 'q') {
X				wdone();
X				exit(0);
X			}
X			else
X				wfleep();
X			break;
X		}
X	}
X}
END_OF_FILE
if test 4520 -ne `wc -c <'Appls/test/magic.c'`; then
    echo shar: \"'Appls/test/magic.c'\" unpacked with wrong size!
fi
# end of 'Appls/test/magic.c'
fi
if test -f 'Appls/test/sevenseg.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Appls/test/sevenseg.h'\"
else
echo shar: Extracting \"'Appls/test/sevenseg.h'\" \(605 characters\)
sed "s/^X//" >'Appls/test/sevenseg.h' <<'END_OF_FILE'
X/* 7-segment digit definitions */
X
X#define __	<<1) | 1)
X#define  _	<<1) | 0)
X#define I __
X#define i  _
X#define AA ((((((((((((((0
X
Xshort sevenseg[10]= {
X
XAA	 __
X	I  I
X	  _
X	I  I
X	 __	,	/* 0 */
X
XAA	  _
X	i  I
X	  _
X	i  I
X	  _	,	/* 1 */
X
XAA	 __
X	i  I
X	 __
X	I  i
X	 __	,	/* 2 */
X
XAA	 __
X	i  I
X	 __
X	i  I
X	 __	,	/* 3 */
X
XAA	  _
X	I  I
X	 __
X	i  I
X	  _	,	/* 4 */
X
XAA	 __
X	I  i
X	 __
X	i  I
X	 __	,	/* 5 */
X
XAA	 __
X	I  i
X	 __
X	I  I
X	 __	,	/* 6 */
X
XAA	 __
X	i  I
X	  _
X	i  I
X	  _	,	/* 7 */
X
XAA	 __
X	I  I
X	 __
X	I  I
X	 __	,	/* 8 */
X
XAA	 __
X	I  I
X	 __
X	i  I
X	 __		/* 9 */
X
X};
X
X#undef __
X#undef  _
X#undef I
X#undef i
X#undef AA
END_OF_FILE
if test 605 -ne `wc -c <'Appls/test/sevenseg.h'`; then
    echo shar: \"'Appls/test/sevenseg.h'\" unpacked with wrong size!
fi
# end of 'Appls/test/sevenseg.h'
fi
if test -f 'H/vt.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'H/vt.h'\"
else
echo shar: Extracting \"'H/vt.h'\" \(5019 characters\)
sed "s/^X//" >'H/vt.h' <<'END_OF_FILE'
X/* Interface for VT (Virtual Terminal windows) package */
X
X/* WARNING: the cursor coordinate system is (row, col) here,
X   like in the ANSI escape sequences.
X   However, the origin is 0, and ranges are given in C style:
X   first, last+1.
X   ANSI escapes (which have origin 1) are translated as soon
X   as they are parsed. */
X
X#define VTNARGS 10		/* Max # args in ansi escape sequence */
X
X/* Structure describing a VT window */
X
Xtypedef struct _vt {
X	WINDOW *win;		/* Window used for display */
X	char **data;		/* Character data array [row][col] */
X	unsigned char **flags;	/* Corresponding flags per character */
X	short *llen;		/* Line length array */
X	short rows, cols;	/* Size of data matrix */
X	short cwidth, cheight;	/* Character cell size */
X	short cur_row, cur_col;	/* Cursor position */
X	short save_row, save_col;	/* Saved cursor position */
X	short scr_top, scr_bot;	/* Scrolling region */
X	short topterm;		/* Top line of emulated terminal */
X	short toscroll;		/* Delayed screen scrolling */
X	unsigned char gflags;	/* Global flags for inserted characters */
X
X	/* XXX The following Booleans are stored in characters.
X	   This is probably the most efficient way to store them.
X	   Since we normally have only one VT window per application,
X	   space considerations are not important and we could even use
X	   ints if they were faster. */
X
X	char insert;		/* Insert mode */
X	char keypadmode;	/* Send ESC O A for arrows, not ESC [ A */
X	char nlcr;		/* \n implies \r */
X	char lazy;		/* Delay output operations */
X	char mitmouse;		/* Send ESC [ M <button;col;row> on clicks */
X	char visualbell;	/* Blink instead of beep (for ctrl-G) */
X	char flagschanged;	/* Set when certain state flags changed */
X	char drawing;		/* Used by VT{BEGIN,END}DRAWING() macros */
X
X	/* State for the ANSI escape sequence interpreter */
X
X	char modarg;		/* \0: ansi vt100; '?': DEC private mode etc */
X	char *(*action)();	/* Function to call for next input */
X	short *nextarg;		/* Points to current arg */
X	short args[VTNARGS];	/* Argument list */
X
X	/* State for the selected region */
X
X	short sel_row1, sel_col1; /* Start of selected region, <0 if nothing */
X	short sel_row2, sel_col2; /* End of selected region */
X
X	/* XXX There ought to be an array of tab stops somewhere... */
X} VT;
X
X/* Flags in gflags and flags array.
X   These correspond to the ANSI codes used in ESC [ ... m.
X   Not all are implemented! */
X
X#define VT_BOLD		(1 << 1)
X#define VT_DIM		(1 << 2)
X#define VT_UNDERLINE	(1 << 4)
X#define VT_BLINK	(1 << 5)
X#define VT_INVERSE	(1 << 7)
X#define VT_SELECTED	(1 << 3)	/* <- This one does NOT correspond */
X
X/* Access macros */
X
X#define vtcheight(vt)			((vt)->cheight)
X#define vtcwidth(vt)			((vt)->cwidth)
X#define vtwindow(vt)			((vt)->win)
X
X#define vtsetnlcr(vt, new_nlcr)		((vt)->nlcr = (new_nlcr))
X#define vtsetlazy(vt, new_lazy)		((vt)->lazy= (new_lazy))
X#define vtsetflags(vt, new_flags)	((vt)->gflags= (new_flags))
X#define vtsetinsert(vt, new_insert)	((vt)->insert= (new_insert))
X
X/* Basic functions (vt.c) */
X
XVT *vtopen _ARGS((char *title, int rows, int cols, int save));
Xvoid vtclose _ARGS((VT *vt));
Xvoid vtputstring _ARGS((VT *vt, char *text, int len));
Xvoid vtsetcursor _ARGS((VT *vt, int row, int col));
Xvoid vtreset _ARGS((VT *vt));
XVT *vtfind _ARGS((WINDOW *win));
X
X/* Optional functions (vtansi.c, vtputs.c, vtresize.c) */
X
Xvoid vtansiputs _ARGS((VT *vt, char *text, int len));
Xvoid vtputs _ARGS((VT *vt, char *text));
X/*bool*/int vtresize _ARGS((VT *vt, int rows, int cols, int save));
X/*bool*/int vtautosize _ARGS((VT *vt));
X
X/* Functions used by the ANSI interface (vtfunc.c) */
X
Xvoid vtresetattr _ARGS((VT *vt));
Xvoid vtsetattr _ARGS((VT *vt, int bit));
Xvoid vtsavecursor _ARGS((VT *vt));
Xvoid vtrestorecursor _ARGS((VT *vt));
Xvoid vtarrow _ARGS((VT *vt, int code, int repeat));
Xvoid vteolclear _ARGS((VT *vt, int row, int col));
Xvoid vteosclear _ARGS((VT *vt, int row, int col));
Xvoid vtlinefeed _ARGS((VT *vt, int repeat));
Xvoid vtrevlinefeed _ARGS((VT *vt, int repeat));
Xvoid vtinslines _ARGS((VT *vt, int n));
Xvoid vtdellines _ARGS((VT *vt, int n));
Xvoid vtscrollup _ARGS((VT *vt, int r1, int r2, int n));
Xvoid vtscrolldown _ARGS((VT *vt, int r1, int r2, int n));
Xvoid vtinschars _ARGS((VT *vt, int n));
Xvoid vtdelchars _ARGS((VT *vt, int n));
Xvoid vtsetscroll _ARGS((VT *vt, int top, int bot));
Xvoid vtsendid _ARGS((VT *vt));
Xvoid vtsendpos _ARGS((VT *vt));
X
X/* Selection interface (vtselect.c) */
X
X/* XXX This will change */
Xint  vtselect _ARGS((VT *vt, EVENT *ep));
Xint  vtextendselection _ARGS((VT *vt, EVENT *ep));
X
X/* Macros to avoid too many wbegindrawing calls */
X
X#define VTBEGINDRAWING(vt) \
X	if (!(vt)->drawing) { wbegindrawing((vt)->win); (vt)->drawing= 1; }
X#define VTENDDRAWING(vt) \
X	if ((vt)->drawing) { wenddrawing((vt)->win); (vt)->drawing = 0; }
X
X/* Note -- the main application *MUST* call VTENDDRAWING(vt) before
X   it calls wgetevent(). */
X
X#ifndef NDEBUG
X
X/* Panic function.  The caller may provide one.  The library has a default. */
X
Xvoid vtpanic _ARGS((char *));
X
X#endif /* NDEBUG */
END_OF_FILE
if test 5019 -ne `wc -c <'H/vt.h'`; then
    echo shar: \"'H/vt.h'\" unpacked with wrong size!
fi
# end of 'H/vt.h'
fi
if test -f 'Packs/vt/vtfunc.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Packs/vt/vtfunc.c'\"
else
echo shar: Extracting \"'Packs/vt/vtfunc.c'\" \(4558 characters\)
sed "s/^X//" >'Packs/vt/vtfunc.c' <<'END_OF_FILE'
X/* Functions implementing ANSI operations */
X
X#include "vtimpl.h"
X
X/* Linefeed */
X
Xvoid
Xvtlinefeed(vt, n)
X	VT *vt;
X	int n;
X{
X	while (--n >= 0) {
X		if (vt->cur_row == vt->scr_bot - 1) {
X			int scr_top = vt->scr_top;
X			if (scr_top == vt->topterm)
X				scr_top = 0;
X			vtscrollup(vt, scr_top, vt->scr_bot, 1);
X		}
X		else
X			vtsetcursor(vt, vt->cur_row + 1, vt->cur_col);
X	}
X}
X
X/* Reverse linefeed */
X
Xvoid
Xvtrevlinefeed(vt, n)
X	VT *vt;
X	int n;
X{
X	while (--n >= 0) {
X		if (vt->cur_row == vt->scr_top)
X			vtscrolldown(vt, vt->scr_top, vt->scr_bot, 1);
X		else
X			vtsetcursor(vt, vt->cur_row - 1, vt->cur_col);
X	}
X}
X
X/* Reset underline, inverse video attributes */
X
Xvoid
Xvtresetattr(vt)
X	VT *vt;
X{
X	vtsetflags(vt, 0);
X}
X
X/* Set attribute flag (without clearing the others) */
X
Xvoid
Xvtsetattr(vt, bit)
X	VT *vt;
X	int bit;
X{
X	vtsetflags(vt, vt->gflags | (1 << bit));
X}
X
X/* Save cursor position */
X
Xvoid
Xvtsavecursor(vt)
X	VT *vt;
X{
X	vt->save_row = vt->cur_row;
X	vt->save_col = vt->cur_col;
X}
X
X/* Restore cursor position */
X
Xvoid
Xvtrestorecursor(vt)
X	VT *vt;
X{
X	vtsetcursor(vt, vt->save_row, vt->save_col);
X}
X
X/* Process an arrow key (possibly repeated) */
X
Xvoid
Xvtarrow(vt, code, repeat)
X	VT *vt;
X	int code;
X	int repeat;
X{
X	int row = vt->cur_row;
X	int col = vt->cur_col;
X	int minrow = 0, maxrow = vt->rows;
X	
X	CLIPMAX(col, vt->cols-1);
X	switch (code) {
X	case WC_LEFT:
X		col -= repeat;
X		break;
X	case WC_RIGHT:
X		col += repeat;
X		break;
X	case WC_UP:
X		row -= repeat;
X		break;
X	case WC_DOWN:
X		row += repeat;
X		break;
X	}
X	CLIPMAX(col, vt->cols-1);
X	CLIPMIN(col, 0);
X	if (vt->cur_row >= vt->scr_top)
X		minrow = vt->scr_top;
X	if (vt->cur_row < vt->scr_bot)
X		maxrow = vt->scr_bot;
X	CLIPMIN(row, minrow);
X	CLIPMAX(row, maxrow-1);
X	vtsetcursor(vt, row, col);
X}
X
X/* Clear to end of line */
X
Xvoid
Xvteolclear(vt, row, col)
X	VT *vt;
X	int row, col;
X{
X	if (row < vt->rows) {
X		if (vt->llen[row] > col) {
X			if (vt->lazy)
X				vtchange(vt, row, col, row + 1, vt->llen[row]);
X			else {
X				VTBEGINDRAWING(vt);
X				werase(col*vt->cwidth, row*vt->cheight,
X				    vt->llen[row]*vt->cwidth,
X				    (row+1)*vt->cheight);
X			}
X			vt->llen[row] = col;
X		}
X	}
X}
X
X/* Clear to end of screen */
X
Xvoid
Xvteosclear(vt, row, col)
X	VT *vt;
X	int row, col;
X{
X	vteolclear(vt, row, col);
X	if (vt->lazy)
X		vtchange(vt, row + 1, 0, vt->rows, vt->cols);
X	else {
X		VTBEGINDRAWING(vt);
X		werase(0, (row + 1) * vt->cheight,
X			vt->cols * vt->cwidth, vt->rows * vt->cheight);
X	}
X	for (row = row + 1; row < vt->rows; ++row)
X		vt->llen[row] = 0;
X}
X
X/* Delete n lines */
X
Xvoid
Xvtdellines(vt, n)
X	VT *vt;
X	int n;
X{
X	vtscrollup(vt, vt->cur_row, vt->scr_bot, n);
X}
X
X/* Insert n lines */
X
Xvoid
Xvtinslines(vt, n)
X	VT *vt;
X	int n;
X{
X	vtscrolldown(vt, vt->cur_row, vt->scr_bot, n);
X}
X
X/* Scroll a range of lines n positions up */
X
Xvoid
Xvtscrollup(vt, r1, r2, n)
X	VT *vt;
X	int r1, r2;
X	int n;
X{
X	if (n > 0 && r1 < r2) {
X		int i;
X		vtcirculate(vt, r1, r2, -n);
X		/* Clear lines at bottom of scrolling screenpart */
X		for (i = r2 - n; i < r2; ++i)
X			vt->llen[i] = 0;
X		vtscroll(vt, r1, 0, r2, vt->cols, -n, 0);
X	}
X}
X
X
X/* Scroll a range of lines n positions down */
X
Xvoid
Xvtscrolldown(vt, r1, r2, n)
X	VT *vt;
X	int r1, r2;
X	int n;
X{
X	if (n > 0 && r1 < r2) {
X		int i;
X		vtcirculate(vt, r1, r2, n);
X		for (i = r1 + n; --i >= r1; )
X			vt->llen[i] = 0;
X		vtscroll(vt, r1, 0, r2, vt->cols, n, 0);
X	}
X}
X
X/* Insert n characters */
X
Xvoid
Xvtinschars(vt, n)
X	VT *vt;
X	int n;
X{
X	int row;
X	
X	if (n > 0 && (row= vt->cur_row) < vt->rows) {
X		int col = vt->cur_col;
X		int len = vt->llen[row];
X		if (len > col) {
X			if (col+n >= vt->cols) {
X				vtchange(vt, row, col, row+1, len);
X				vt->llen[row] = col;
X			}
X			else {
X				register int i;
X				char *data = vt->data[row];
X				unsigned char *flags = vt->flags[row];
X				len += n;
X				if (len > vt->cols)
X					len = vt->cols;
X				for (i = len-n; --i >= col; )
X					data[i+n] = data[i];
X				vtscroll(vt, row, col, row+1, len, 0, n);
X				vt->llen[row] = len;
X				/* Clear the inserted stretch */
X				for (i = col+n; --i >= col; ) {
X					data[i] = ' ';
X					flags[i] = 0;
X				}
X			}
X		}
X	}
X}
X
X/* Delete n characters */
X
Xvoid
Xvtdelchars(vt, n)
X	VT *vt;
X	int n;
X{
X	int row;
X	
X	if (n > 0 && (row = vt->cur_row) < vt->rows) {
X		int col = vt->cur_col;
X		int len = vt->llen[row];
X		if (len > col) {
X			if (len <= col+n) {
X				vtchange(vt, row, col, row+1, len);
X				vt->llen[row] = col;
X			}
X			else {
X				register int i;
X				char *data = vt->data[row];
X				for (i = col+n; i < len; ++i)
X					data[i-n] = data[i];
X				vtscroll(vt, row, col, row+1, len, 0, -n);
X				vt->llen[row] -= n;
X			}
X		}
X	}
X}
END_OF_FILE
if test 4558 -ne `wc -c <'Packs/vt/vtfunc.c'`; then
    echo shar: \"'Packs/vt/vtfunc.c'\" unpacked with wrong size!
fi
# end of 'Packs/vt/vtfunc.c'
fi
if test -f 'Ports/alfa/timer.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Ports/alfa/timer.c'\"
else
echo shar: Extracting \"'Ports/alfa/timer.c'\" \(4449 characters\)
sed "s/^X//" >'Ports/alfa/timer.c' <<'END_OF_FILE'
X/* TERMCAP STDWIN -- Alarm timers (BSD-specific) */
X
X#include "alfa.h"
X
X#include <errno.h>
X#include <sys/time.h>
X
X#ifdef AMOEBA
X#define select(a, b, c, d, e) (-1) /* XXX just to get it to link... */
X#endif
X
X/* Alarm timer values must be stored as absolute times,
X   but since they are in tenths of a second and stored in a long,
X   there isn't enough space to store the true absolute time.
X   Therefore, they are stored relative to the second when the
X   first call to wsettimer was made, which is saved in torigin */
X
Xstatic long torigin;		/* Seconds */
Xstatic long nexttimer;		/* Deciseconds */
X
X/* Return the window with the first timer to go off, if any, NULL otherwise */
X
Xstatic WINDOW *
Xgetnexttimer()
X{
X	WINDOW *win;
X	WINDOW *cand= NULL;
X	
X	for (win= &winlist[0]; win < &winlist[MAXWINDOWS]; ++win) {
X		if (win->open) {
X			long t= win->timer;
X			if (t != 0) {
X				if (cand == NULL || t < cand->timer)
X					cand= win;
X			}
X		}
X	}
X	return cand;
X}
X
X/* Compute a new value for nexttimer.
X   Return the relevant window as a convenience. */
X
Xstatic WINDOW *
Xsetnexttimer()
X{
X	WINDOW *win= getnexttimer();
X	
X	if (win == NULL)
X		nexttimer= 0;
X	else
X		nexttimer= win->timer;
X	return win;
X}
X
X/* Set the alarm timer for a given window */
X
Xvoid
Xwsettimer(win, deciseconds)
X	WINDOW *win;
X	int deciseconds;
X{
X	win->timer= 0;
X	if (deciseconds > 0) {
X		struct timeval tv;
X		struct timezone tz;
X		
X		if (gettimeofday(&tv, &tz) >= 0) {
X			if (torigin == 0) {
X				torigin= tv.tv_sec;
X			}
X			win->timer= deciseconds + 10 * (tv.tv_sec - torigin) +
X				tv.tv_usec/100000;
X		}
X	}
X	(void) setnexttimer();
X}
X
X/* Return a pointer suitable as timeout parameter for BSD select(2).
X   If no alarms are currently set, return a NULL pointer. */
X
Xstatic struct timeval *
Xtimeout()
X{
X	if (nexttimer == 0) {
X		return NULL;
X	}
X	else {
X		static struct timeval tv;
X		struct timezone tz;
X		
X		if (gettimeofday(&tv, &tz) < 0) {
X			return NULL;
X		}
X		else {
X			long tout;
X			tout= nexttimer
X				- (tv.tv_sec - torigin) * 10
X				- tv.tv_usec / 100000;
X			if (tout <= 0)
X				tv.tv_sec= tv.tv_usec= 0;
X			else {
X				tv.tv_sec= tout / 10; 
X				tv.tv_usec= (tout % 10) * 100000;
X			}
X			return &tv;
X		}
X	}
X}
X
X/* Check if an alarm has gone off, and if so, generate an appropriate event.
X   This can be called at any time, but for efficiency reasons it should
X   only be called when an alarm has actually gone of (i.e., select has
X   timed out).  If an alarm has gone off, it will always be found by
X   this function. */
X
Xstatic bool
Xdotimer(ep)
X	EVENT *ep;
X{
X	WINDOW *win= setnexttimer();
X	struct timeval *tp;
X	
X	if (win == NULL) {
X		/* no event found (spurious call) */
X		return FALSE;
X	}
X	tp= timeout();
X	if (tp == NULL) {
X		/* unexpected NULL timeout() */
X		return FALSE;
X	}
X	if (tp->tv_sec == 0 && tp->tv_usec == 0) {
X		/* report timer event */
X		ep->type= WE_TIMER;
X		ep->window= win;
X		win->timer= 0;
X		(void) setnexttimer();
X		return TRUE;
X	}
X	else {
X		/* it is not yet time */
X		return FALSE;
X	}
X}
X
X/* Check for timer events.
X   Call this after trmavail() returns 0, just before calling trminput() */
X
Xbool
X_w_checktimer(ep, mayblock)
X	EVENT *ep;
X	bool mayblock;
X{
X	for (;;) {
X		struct timeval *tp= timeout();
X		/* This is naive.  BSD 4.3 really uses arrays of longs
X		   as arguments to select.  Fortunately, stdin is fd 0. */
X		unsigned long rd, wd, xd;
X		int fd, nfd;
X		int nfound;
X		if (!mayblock) {
X			return tp != NULL &&
X				tp->tv_sec == 0 && tp->tv_usec == 0 &&
X				dotimer(ep);
X		}
X		fd= 0; /* stdin */
X		rd= 1 << fd;
X		nfd= fd+1;
X		wd= xd= 0;
X		errno= 0;
X		nfound= select(nfd, &rd, &wd, &xd, tp);
X		/* Note: if select returns negative, we also break
X		   out of the loop -- better drop a timer event than
X		   loop forever on a select error.
X		   The only exception is EINTR, which may have been caused
X		   by an application's signal handler */
X		if (nfound < 0) {
X			if (errno == EINTR) {
X				continue;
X			}
X		}
X		if (nfound != 0)
X			break;
X		if (dotimer(ep))
X			return TRUE;
X	}
X	return FALSE;
X}
X
X/* P.S.: It is not necessary to recompute nextalarm when windows are
X   deleted.  This can at most cause a spurious time-out, after which
X   dotimeout() is called again which recomputes nextalarm as a side
X   effect (twice, even).  Applications incur a slight overhead if they
X   delete a window with a timer set and no other windows have timers
X   set; in this case a larger part of the timeout code is called until
X   the alarm goes off (which is then ignored!). */
END_OF_FILE
if test 4449 -ne `wc -c <'Ports/alfa/timer.c'`; then
    echo shar: \"'Ports/alfa/timer.c'\" unpacked with wrong size!
fi
# end of 'Ports/alfa/timer.c'
fi
if test -f 'Ports/vtrm/uxtty.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'Ports/vtrm/uxtty.c'\"
else
echo shar: Extracting \"'Ports/vtrm/uxtty.c'\" \(4997 characters\)
sed "s/^X//" >'Ports/vtrm/uxtty.c' <<'END_OF_FILE'
X/* VTRM -- unix-dependent tty twiddling. */
X
X#ifdef SYSV
X#define TERMIO
X#endif
X
X#include <stdio.h>
X#ifndef TERMIO
X#include <sgtty.h>
X#else
X#include <termio.h>
X#endif TERMIO
X#include <sys/types.h>
X#include <signal.h>
X
X#include "vtrm.h"
X#include "sigtype.h" /* Defines SIGTYPE as int or void */
X
Xtypedef char *string;
Xtypedef int bool;
X#define Yes 1
X#define No  0
X
Xextern short ospeed; /* Defined in vtrm.c, used by termcap's tgoto/tputs. */
X
X/* tty modes */
X#ifndef TERMIO
X
X/* v7/BSD tty control */
Xstatic struct sgttyb oldtty, newtty;
X#ifdef TIOCSETN
X/* Redefine stty to uses TIOCSETN, so type-ahead is not flushed */
X#define stty(fd, bp) ioctl(fd, TIOCSETN, (char *) bp)
X#endif
X
X#ifdef TIOCSLTC /* BSD -- local special chars, must all be turned off */
Xstatic struct ltchars oldltchars;
Xstatic struct ltchars newltchars= {-1, -1, -1, -1, -1, -1};
X#endif TIOCSLTC
X
X#ifdef TIOCSETC /* V7 -- standard special chars, some must be turned off too */
Xstatic struct tchars oldtchars;
Xstatic struct tchars newtchars;
X#endif TIOCSETC
X
X#else TERMIO
X
X/* AT&T tty control */
Xstatic struct termio oldtty, newtty;
X#define gtty(fd,bp) ioctl(fd, TCGETA, (char *) bp)
X#define stty(fd,bp) ioctl(fd, TCSETAW, (char *) bp)
X
X#endif TERMIO
X
Xstatic bool know_ttys = No;
X
Xint
Xsetttymode()
X{
X	if (!know_ttys) {
X		if (gtty(0, &oldtty) != 0 || gtty(0, &newtty) != 0)
X			return TE_NOTTY;
X#ifndef TERMIO
X		ospeed = oldtty.sg_ospeed;
X#ifdef PWB
X		newtty.sg_flags = (newtty.sg_flags & ~ECHO & ~CRMOD & ~XTABS)
X				  | RAW;
X#else PWB
X		newtty.sg_flags = (newtty.sg_flags & ~ECHO & ~CRMOD & ~XTABS)
X				  | CBREAK;
X#endif PWB
X#ifdef TIOCSLTC
X	ioctl(0, TIOCGLTC, (char *) &oldltchars);
X#endif
X#ifdef TIOCSETC
X	ioctl(0, TIOCGETC, (char *) &oldtchars);
X#endif
X
X#else TERMIO
X		/* ospeed= oldtty.c_lflag & CBAUD; /* BOGUS */
X		newtty.c_iflag &= ~ICRNL; /* No CR->NL mapping on input */
X		newtty.c_oflag &= ~ONLCR; /* NL doesn't output CR */
X		newtty.c_lflag &= ~(ICANON|ECHO|ISIG);
X				/* No line editing, no echo, no signals */
X		newtty.c_cc[VMIN]= 3; /* wait for 3 characters */
X		newtty.c_cc[VTIME]= 1; /* or 0.1 sec. */
X#endif TERMIO
X		know_ttys = Yes;
X	}
X	stty(0, &newtty);
X#ifndef TERMIO
X#ifdef TIOCSLTC
X	ioctl(0, TIOCSLTC, (char *) &newltchars);
X#endif TIOCSLTC
X#ifdef TIOCSETC
X	ioctl(0, TIOCGETC, (char *) &newtchars);
X	newtchars.t_intrc= -1;
X#ifdef NDEBUG
X	newtchars.t_quitc= -1;
X#endif
X	newtchars.t_eofc= -1;
X	newtchars.t_brkc= -1;
X	ioctl(0, TIOCSETC, (char *) &newtchars);
X#endif TIOCSETC
X#endif TERMIO
X	return TE_OK;
X}
X
Xresetttymode()
X{
X	if (know_ttys) {
X		stty(0, &oldtty);
X#ifndef TERMIO
X#ifdef TIOCSLTC
X		ioctl(0, TIOCSLTC, (char *) &oldltchars);
X#endif TIOCSLTC
X#ifdef TIOCSETC
X		ioctl(0, TIOCSETC, (char *) &oldtchars);
X#endif TIOCSETC
X#endif TERMIO
X		know_ttys= No;
X	}
X}
X
X
X/*
X * Return the next input character, or -1 if read fails.
X * Only the low 7 bits are returned, so reading in RAW mode is permissible
X * (although CBREAK is preferred if implemented).
X * To avoid having to peek in the input buffer for trmavail, we use the
X * 'read' system call rather than getchar().
X * (The interface allows 8-bit characters to be returned, to accomodate
X * larger character sets!)
X */
X
Xstatic int pushback= -1;
X
Xint
Xtrminput()
X{
X	char c;
X
X	if (pushback >= 0) {
X		c= pushback;
X		pushback= -1;
X		return c;
X	}
X	if (read(0, &c, 1) <= 0)
X		return -1;
X	return c & 0177;
X}
X
Xtrmpushback(c)
X	int c;
X{
X	pushback= c;
X}
X
X
X/*
X * See if there's input available from the keyboard.
X * The code to do this is dependent on the type of Unix you have
X * (BSD, System V, ...).
X * Return value: 0 -- no input; 1 -- input; -1 -- unimplementable.
X * Note that each implementation form should first check pushback.
X *
X * TO DO:
X *	- Implement it for other than 4.x BSD! (notably System 5)
X */
X
X#ifdef SELECT
X
X#include <sys/time.h>
X
Xint
Xtrmavail()
X{
X	int nfound, nfds, readfds;
X	static struct timeval timeout= {0, 0};
X
X	if (pushback >= 0)
X		return 1;
X	readfds= 1 << 0;
X	nfds= 0+1;
X	nfound= select(nfds, &readfds, (int*) NIL, (int*) NIL, &timeout);
X	return nfound > 0;
X}
X
X#define TRMAVAIL_DEFINED
X
X#endif SELECT
X
X#if !defined(TRMAVAIL_DEFINED) && defined(FIONREAD)
X
Xint
Xtrmavail()
X{
X	long n;
X
X	if (pushback >= 0)
X		return 1;
X	if (ioctl(0, FIONREAD, (char *) &n) < 0)
X		return -1;
X	return n > 0;
X}
X
X#define TRMAVAIL_DEFINED
X
X#endif FIONREAD
X
X#ifndef TRMAVAIL_DEFINED
X
Xint
Xtrmavail()
X{
X	if (pushback >= 0)
X		return 1;
X	return -1;
X}
X
X#endif
X
X
X/*
X * Suspend the editor.
X * Should be called only after trmend and before trmstart!
X */
X
Xtrmsuspend()
X{
X	SIGTYPE (*oldsig)();
X	
X	oldsig= signal(SIGTSTP, SIG_IGN);
X	if (oldsig == SIG_IGN)
X		return; /* Could spawn a subshell here... */
X	trmend(); /* Safety net */
X	(void) signal(SIGTSTP, oldsig);
X	kill(0, SIGSTOP);
X}
X
X/*
X * Get the true window size.
X * May return 0 if unknown.
X */
X
Xgettruewinsize(plines, pcols)
X	int *plines, *pcols;
X{
X#ifdef TIOCGWINSZ
X	struct winsize win;
X	
X	if (ioctl(0, TIOCGWINSZ, (char *) &win) == 0) {
X		*plines= win.ws_row;
X		*pcols= win.ws_col;
X	}
X	else
X#endif
X		*plines= *pcols= 0;
X}
END_OF_FILE
if test 4997 -ne `wc -c <'Ports/vtrm/uxtty.c'`; then
    echo shar: \"'Ports/vtrm/uxtty.c'\" unpacked with wrong size!
fi
# end of 'Ports/vtrm/uxtty.c'
fi
echo shar: End of archive 14 \(of 19\).
cp /dev/null ark14isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 ; do
    if test ! -f ark${I}isdone ; then
	MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 19 archives.
    rm -f ark[1-9]isdone ark[1-9][0-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0



More information about the Alt.sources mailing list