Source Code 1994 March/Source_Code_CD-ROM_Walnut_Creek_March_1994.iso/compsrcs/games/volume18/xmpb/part08

Text File | 1993-07-11 | 19.4 KB | 598 lines

Path: uunet!news.tek.com!saab!billr
From: [e-mail] (Bill Randle)
Newsgroups: comp.sources.games
Subject: v18i008:  xmpb - multiplayer space combat for X, Part08/08
Date: 26 Jun 1993 00:33:06 GMT
Organization: Tektronix, Inc, Redmond, OR, USA
Lines: 585
Approved: [e-mail]
Message-ID: <20g5g2$[e-mail]>
NNTP-Posting-Host: saab.cna.tek.com
Xref: uunet comp.sources.games:1798

Submitted-by: [e-mail] (Damien De Paoli)
Posting-number: Volume 18, Issue 8
Archive-name: xmpb/Part08
Environment: X11, Xlib



#! /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 8 (of 8)."
# Contents:  bitmaps/atom bitmaps/cloud.1 bitmaps/cloud.3
#   bitmaps/cloud.4 bitmaps/cloud.5 bitmaps/cloud.6 bitmaps/dunno
#   bitmaps/dunno2 bitmaps/hvypulse bitmaps/jam100 bitmaps/jam25
#   bitmaps/jam50 bitmaps/jam75 bitmaps/magneto bitmaps/massdrive
#   bitmaps/mine bitmaps/pulse bitmaps/rail bitmaps/saturn1
#   bitmaps/seeker bitmaps/smallrock bitmaps/star1 bitmaps/star2
#   bitmaps/stipple bits.h clear_lock.c cos.c error.c mnemonics.h
#   save.c
# Wrapped by billr@saab on Fri Jun 25 16:30:16 1993
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'bitmaps/atom' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/atom'\"
else
echo shar: Extracting \"'bitmaps/atom'\" \(81 characters\)
sed "s/^X//" >'bitmaps/atom' <<'END_OF_FILE'
X#define atom_width 1
X#define atom_height 1
Xstatic char atom_bits[] = {
X   0x01};
END_OF_FILE
if test 81 -ne `wc -c <'bitmaps/atom'`; then
    echo shar: \"'bitmaps/atom'\" unpacked with wrong size!
fi
# end of 'bitmaps/atom'
fi
if test -f 'bitmaps/cloud.1' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/cloud.1'\"
else
echo shar: Extracting \"'bitmaps/cloud.1'\" \(434 characters\)
sed "s/^X//" >'bitmaps/cloud.1' <<'END_OF_FILE'
X#define cloud_width 19
X#define cloud_height 19
Xstatic char cloud_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00, 0xc0, 0x18, 0x00,
X   0x00, 0x09, 0x00, 0x00, 0x20, 0x00, 0x40, 0x00, 0x00, 0x00, 0x19, 0x00,
X   0x80, 0x10, 0x00, 0x80, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 434 -ne `wc -c <'bitmaps/cloud.1'`; then
    echo shar: \"'bitmaps/cloud.1'\" unpacked with wrong size!
fi
# end of 'bitmaps/cloud.1'
fi
if test -f 'bitmaps/cloud.3' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/cloud.3'\"
else
echo shar: Extracting \"'bitmaps/cloud.3'\" \(434 characters\)
sed "s/^X//" >'bitmaps/cloud.3' <<'END_OF_FILE'
X#define cloud_width 19
X#define cloud_height 19
Xstatic char cloud_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x80, 0x05, 0x00, 0x40, 0x00, 0x00,
X   0x80, 0x08, 0x00, 0x40, 0xd8, 0x00, 0x10, 0x02, 0x03, 0x08, 0x00, 0x00,
X   0x04, 0x80, 0x02, 0x08, 0x00, 0x02, 0x08, 0x10, 0x01, 0x10, 0x40, 0x00,
X   0x48, 0x08, 0x00, 0x10, 0x41, 0x00, 0x00, 0x02, 0x00, 0x00, 0x47, 0x00,
X   0xc0, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 434 -ne `wc -c <'bitmaps/cloud.3'`; then
    echo shar: \"'bitmaps/cloud.3'\" unpacked with wrong size!
fi
# end of 'bitmaps/cloud.3'
fi
if test -f 'bitmaps/cloud.4' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/cloud.4'\"
else
echo shar: Extracting \"'bitmaps/cloud.4'\" \(434 characters\)
sed "s/^X//" >'bitmaps/cloud.4' <<'END_OF_FILE'
X#define cloud_width 19
X#define cloud_height 19
Xstatic char cloud_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x08, 0x00, 0x40, 0x90, 0x00, 0x10, 0x00, 0x00, 0x08, 0x00, 0x00,
X   0x00, 0x80, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00, 0x01, 0x10, 0x40, 0x00,
X   0x40, 0x08, 0x00, 0x10, 0x41, 0x00, 0x00, 0x00, 0x00, 0x00, 0x45, 0x00,
X   0x40, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 434 -ne `wc -c <'bitmaps/cloud.4'`; then
    echo shar: \"'bitmaps/cloud.4'\" unpacked with wrong size!
fi
# end of 'bitmaps/cloud.4'
fi
if test -f 'bitmaps/cloud.5' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/cloud.5'\"
else
echo shar: Extracting \"'bitmaps/cloud.5'\" \(434 characters\)
sed "s/^X//" >'bitmaps/cloud.5' <<'END_OF_FILE'
X#define cloud_width 19
X#define cloud_height 19
Xstatic char cloud_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x40, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x40, 0x00,
X   0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00,
X   0x40, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 434 -ne `wc -c <'bitmaps/cloud.5'`; then
    echo shar: \"'bitmaps/cloud.5'\" unpacked with wrong size!
fi
# end of 'bitmaps/cloud.5'
fi
if test -f 'bitmaps/cloud.6' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/cloud.6'\"
else
echo shar: Extracting \"'bitmaps/cloud.6'\" \(434 characters\)
sed "s/^X//" >'bitmaps/cloud.6' <<'END_OF_FILE'
X#define cloud_width 19
X#define cloud_height 19
Xstatic char cloud_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00,
X   0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
X   0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 434 -ne `wc -c <'bitmaps/cloud.6'`; then
    echo shar: \"'bitmaps/cloud.6'\" unpacked with wrong size!
fi
# end of 'bitmaps/cloud.6'
fi
if test -f 'bitmaps/dunno' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/dunno'\"
else
echo shar: Extracting \"'bitmaps/dunno'\" \(126 characters\)
sed "s/^X//" >'bitmaps/dunno' <<'END_OF_FILE'
X#define dunno_width 8
X#define dunno_height 8
Xstatic char dunno_bits[] = {
X   0x3c, 0x18, 0x99, 0xe7, 0xe7, 0x99, 0x18, 0x3c};
END_OF_FILE
if test 126 -ne `wc -c <'bitmaps/dunno'`; then
    echo shar: \"'bitmaps/dunno'\" unpacked with wrong size!
fi
# end of 'bitmaps/dunno'
fi
if test -f 'bitmaps/dunno2' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/dunno2'\"
else
echo shar: Extracting \"'bitmaps/dunno2'\" \(117 characters\)
sed "s/^X//" >'bitmaps/dunno2' <<'END_OF_FILE'
X#define dunno2_width 6
X#define dunno2_height 6
Xstatic char dunno2_bits[] = {
X   0x12, 0x25, 0x10, 0x02, 0x29, 0x12};
END_OF_FILE
if test 117 -ne `wc -c <'bitmaps/dunno2'`; then
    echo shar: \"'bitmaps/dunno2'\" unpacked with wrong size!
fi
# end of 'bitmaps/dunno2'
fi
if test -f 'bitmaps/hvypulse' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/hvypulse'\"
else
echo shar: Extracting \"'bitmaps/hvypulse'\" \(129 characters\)
sed "s/^X//" >'bitmaps/hvypulse' <<'END_OF_FILE'
X#define hvypulse_width 7
X#define hvypulse_height 7
Xstatic char hvypulse_bits[] = {
X   0x3e, 0x6b, 0x5d, 0x77, 0x5d, 0x6b, 0x3e};
END_OF_FILE
if test 129 -ne `wc -c <'bitmaps/hvypulse'`; then
    echo shar: \"'bitmaps/hvypulse'\" unpacked with wrong size!
fi
# end of 'bitmaps/hvypulse'
fi
if test -f 'bitmaps/jam100' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/jam100'\"
else
echo shar: Extracting \"'bitmaps/jam100'\" \(105 characters\)
sed "s/^X//" >'bitmaps/jam100' <<'END_OF_FILE'
X#define jam100_width 4
X#define jam100_height 4
Xstatic char jam100_bits[] = {
X   0x0f, 0x0f, 0x0f, 0x0f};
END_OF_FILE
if test 105 -ne `wc -c <'bitmaps/jam100'`; then
    echo shar: \"'bitmaps/jam100'\" unpacked with wrong size!
fi
# end of 'bitmaps/jam100'
fi
if test -f 'bitmaps/jam25' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/jam25'\"
else
echo shar: Extracting \"'bitmaps/jam25'\" \(102 characters\)
sed "s/^X//" >'bitmaps/jam25' <<'END_OF_FILE'
X#define jam25_width 4
X#define jam25_height 4
Xstatic char jam25_bits[] = {
X   0x01, 0x04, 0x01, 0x04};
END_OF_FILE
if test 102 -ne `wc -c <'bitmaps/jam25'`; then
    echo shar: \"'bitmaps/jam25'\" unpacked with wrong size!
fi
# end of 'bitmaps/jam25'
fi
if test -f 'bitmaps/jam50' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/jam50'\"
else
echo shar: Extracting \"'bitmaps/jam50'\" \(102 characters\)
sed "s/^X//" >'bitmaps/jam50' <<'END_OF_FILE'
X#define jam50_width 4
X#define jam50_height 4
Xstatic char jam50_bits[] = {
X   0x05, 0x0a, 0x05, 0x0a};
END_OF_FILE
if test 102 -ne `wc -c <'bitmaps/jam50'`; then
    echo shar: \"'bitmaps/jam50'\" unpacked with wrong size!
fi
# end of 'bitmaps/jam50'
fi
if test -f 'bitmaps/jam75' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/jam75'\"
else
echo shar: Extracting \"'bitmaps/jam75'\" \(102 characters\)
sed "s/^X//" >'bitmaps/jam75' <<'END_OF_FILE'
X#define jam75_width 4
X#define jam75_height 4
Xstatic char jam75_bits[] = {
X   0x0e, 0x0b, 0x0e, 0x0b};
END_OF_FILE
if test 102 -ne `wc -c <'bitmaps/jam75'`; then
    echo shar: \"'bitmaps/jam75'\" unpacked with wrong size!
fi
# end of 'bitmaps/jam75'
fi
if test -f 'bitmaps/magneto' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/magneto'\"
else
echo shar: Extracting \"'bitmaps/magneto'\" \(248 characters\)
sed "s/^X//" >'bitmaps/magneto' <<'END_OF_FILE'
X#define magneto_width 13
X#define magneto_height 13
Xstatic char magneto_bits[] = {
X   0xe0, 0x00, 0xf8, 0x03, 0x4c, 0x06, 0xe6, 0x0c, 0x12, 0x09, 0x4b, 0x1a,
X   0xef, 0x1e, 0x4b, 0x1a, 0x12, 0x09, 0xe6, 0x0c, 0x4c, 0x06, 0xf8, 0x03,
X   0xe0, 0x00};
END_OF_FILE
if test 248 -ne `wc -c <'bitmaps/magneto'`; then
    echo shar: \"'bitmaps/magneto'\" unpacked with wrong size!
fi
# end of 'bitmaps/magneto'
fi
if test -f 'bitmaps/massdrive' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/massdrive'\"
else
echo shar: Extracting \"'bitmaps/massdrive'\" \(126 characters\)
sed "s/^X//" >'bitmaps/massdrive' <<'END_OF_FILE'
X#define massdrive_width 6
X#define massdrive_height 6
Xstatic char massdrive_bits[] = {
X   0x0c, 0x1e, 0x3f, 0x3f, 0x1e, 0x0c};
END_OF_FILE
if test 126 -ne `wc -c <'bitmaps/massdrive'`; then
    echo shar: \"'bitmaps/massdrive'\" unpacked with wrong size!
fi
# end of 'bitmaps/massdrive'
fi
if test -f 'bitmaps/mine' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/mine'\"
else
echo shar: Extracting \"'bitmaps/mine'\" \(123 characters\)
sed "s/^X//" >'bitmaps/mine' <<'END_OF_FILE'
X#define mine_width 8
X#define mine_height 8
Xstatic char mine_bits[] = {
X   0x81, 0x42, 0x3c, 0x3c, 0x3c, 0x3c, 0x42, 0x81};
END_OF_FILE
if test 123 -ne `wc -c <'bitmaps/mine'`; then
    echo shar: \"'bitmaps/mine'\" unpacked with wrong size!
fi
# end of 'bitmaps/mine'
fi
if test -f 'bitmaps/pulse' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/pulse'\"
else
echo shar: Extracting \"'bitmaps/pulse'\" \(108 characters\)
sed "s/^X//" >'bitmaps/pulse' <<'END_OF_FILE'
X#define pulse_width 5
X#define pulse_height 5
Xstatic char pulse_bits[] = {
X   0x0e, 0x1b, 0x15, 0x1b, 0x0e};
END_OF_FILE
if test 108 -ne `wc -c <'bitmaps/pulse'`; then
    echo shar: \"'bitmaps/pulse'\" unpacked with wrong size!
fi
# end of 'bitmaps/pulse'
fi
if test -f 'bitmaps/rail' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/rail'\"
else
echo shar: Extracting \"'bitmaps/rail'\" \(93 characters\)
sed "s/^X//" >'bitmaps/rail' <<'END_OF_FILE'
X#define rail_width 3
X#define rail_height 3
Xstatic char rail_bits[] = {
X   0x07, 0x07, 0x07};
END_OF_FILE
if test 93 -ne `wc -c <'bitmaps/rail'`; then
    echo shar: \"'bitmaps/rail'\" unpacked with wrong size!
fi
# end of 'bitmaps/rail'
fi
if test -f 'bitmaps/saturn1' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/saturn1'\"
else
echo shar: Extracting \"'bitmaps/saturn1'\" \(284 characters\)
sed "s/^X//" >'bitmaps/saturn1' <<'END_OF_FILE'
X#define saturn1_width 16
X#define saturn1_height 16
Xstatic char saturn1_bits[] = {
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
X   0xc0, 0x03, 0xe0, 0x02, 0x60, 0x03, 0xa0, 0x03, 0xe0, 0x01, 0x10, 0x00,
X   0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00};
END_OF_FILE
if test 284 -ne `wc -c <'bitmaps/saturn1'`; then
    echo shar: \"'bitmaps/saturn1'\" unpacked with wrong size!
fi
# end of 'bitmaps/saturn1'
fi
if test -f 'bitmaps/seeker' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/seeker'\"
else
echo shar: Extracting \"'bitmaps/seeker'\" \(192 characters\)
sed "s/^X//" >'bitmaps/seeker' <<'END_OF_FILE'
X#define seeker_width 9
X#define seeker_height 9
Xstatic char seeker_bits[] = {
X   0x28, 0x00, 0xba, 0x00, 0x7c, 0x00, 0xff, 0x01, 0xfe, 0x00, 0xff, 0x01,
X   0x7c, 0x00, 0xba, 0x00, 0x28, 0x00};
END_OF_FILE
if test 192 -ne `wc -c <'bitmaps/seeker'`; then
    echo shar: \"'bitmaps/seeker'\" unpacked with wrong size!
fi
# end of 'bitmaps/seeker'
fi
if test -f 'bitmaps/smallrock' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/smallrock'\"
else
echo shar: Extracting \"'bitmaps/smallrock'\" \(227 characters\)
sed "s/^X//" >'bitmaps/smallrock' <<'END_OF_FILE'
X#define smallrock_width 11
X#define smallrock_height 11
Xstatic char smallrock_bits[] = {
X   0x74, 0x00, 0xfc, 0x01, 0x4e, 0x02, 0xdf, 0x02, 0xf9, 0x07, 0xfa, 0x07,
X   0x7f, 0x06, 0xce, 0x03, 0xd2, 0x03, 0xfd, 0x02, 0x70, 0x00};
END_OF_FILE
if test 227 -ne `wc -c <'bitmaps/smallrock'`; then
    echo shar: \"'bitmaps/smallrock'\" unpacked with wrong size!
fi
# end of 'bitmaps/smallrock'
fi
if test -f 'bitmaps/star1' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/star1'\"
else
echo shar: Extracting \"'bitmaps/star1'\" \(102 characters\)
sed "s/^X//" >'bitmaps/star1' <<'END_OF_FILE'
X#define star1_width 4
X#define star1_height 4
Xstatic char star1_bits[] = {
X   0x04, 0x0a, 0x04, 0x00};
END_OF_FILE
if test 102 -ne `wc -c <'bitmaps/star1'`; then
    echo shar: \"'bitmaps/star1'\" unpacked with wrong size!
fi
# end of 'bitmaps/star1'
fi
if test -f 'bitmaps/star2' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/star2'\"
else
echo shar: Extracting \"'bitmaps/star2'\" \(90 characters\)
sed "s/^X//" >'bitmaps/star2' <<'END_OF_FILE'
X#define star2_width 2
X#define star2_height 2
Xstatic char star2_bits[] = {
X   0x03, 0x03};
END_OF_FILE
if test 90 -ne `wc -c <'bitmaps/star2'`; then
    echo shar: \"'bitmaps/star2'\" unpacked with wrong size!
fi
# end of 'bitmaps/star2'
fi
if test -f 'bitmaps/stipple' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bitmaps/stipple'\"
else
echo shar: Extracting \"'bitmaps/stipple'\" \(108 characters\)
sed "s/^X//" >'bitmaps/stipple' <<'END_OF_FILE'
X#define stipple_width 4
X#define stipple_height 4
Xstatic char stipple_bits[] = {
X   0x05, 0x0a, 0x05, 0x0a};
END_OF_FILE
if test 108 -ne `wc -c <'bitmaps/stipple'`; then
    echo shar: \"'bitmaps/stipple'\" unpacked with wrong size!
fi
# end of 'bitmaps/stipple'
fi
if test -f 'bits.h' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'bits.h'\"
else
echo shar: Extracting \"'bits.h'\" \(268 characters\)
sed "s/^X//" >'bits.h' <<'END_OF_FILE'
Xstruct menu_p {
X    char menu_name[40];
X    char menu_item[40][40];
X    char descr[40][480];
X    int     cost[40];
X    struct menu_p *next;
X};
X
Xstruct menu_p *head, *curr;
X
X#define ITEMS 0
X#define WEAPONS 1
X#define LS 7
X#define RS 8
X#define BS 9
X#define ENERGY 10
X
X#define NUMLRADS 9
X
END_OF_FILE
if test 268 -ne `wc -c <'bits.h'`; then
    echo shar: \"'bits.h'\" unpacked with wrong size!
fi
# end of 'bits.h'
fi
if test -f 'clear_lock.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'clear_lock.c'\"
else
echo shar: Extracting \"'clear_lock.c'\" \(263 characters\)
sed "s/^X//" >'clear_lock.c' <<'END_OF_FILE'
X#include <stdio.h>
X
Xint euid;
X
Xmain(argc, argv)
Xint argc;
Xchar *argv[];
X{
X    char buf[160];
X
X    if(argc!=2)
X    {
X        printf("Usage: %s Name\n", argv[0]);
X        exit(1);
X    }
X    euid=geteuid();
X    strcpy(buf, SAVEDIR);
X    strcat(buf, argv[1]);
X    strcat(buf, ".lock");
X    unlink(buf);
X}
END_OF_FILE
if test 263 -ne `wc -c <'clear_lock.c'`; then
    echo shar: \"'clear_lock.c'\" unpacked with wrong size!
fi
# end of 'clear_lock.c'
fi
if test -f 'cos.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'cos.c'\"
else
echo shar: Extracting \"'cos.c'\" \(391 characters\)
sed "s/^X//" >'cos.c' <<'END_OF_FILE'
X/* %M% - *** put a one line description here */
X
X#if !defined(lint)
Xstatic char sccs_id[] = "%Z%%M% %I% %E% XMPB";
X#endif
X#include <math.h>
X
Xmain()
X{
X
X    int i;
Xprintf("int mycostab[] = {\n");
X    for(i=0;i<361;i++)
X    {
X        double a;
X
X        a = (double)i/180.0*M_PI;
X        printf("%d",(int)(32768.0*cos(a)));
X        if(i != 360) printf(",");
X        if(i%10 == 0) printf("\n");
X
X    }
Xprintf("};\n");
X   return 0;
X}
X
END_OF_FILE
if test 391 -ne `wc -c <'cos.c'`; then
    echo shar: \"'cos.c'\" unpacked with wrong size!
fi
# end of 'cos.c'
fi
if test -f 'error.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'error.c'\"
else
echo shar: Extracting \"'error.c'\" \(174 characters\)
sed "s/^X//" >'error.c' <<'END_OF_FILE'
X/* error.c - *** Error handler */
X
Xstatic char sccs_id[] = "@(#)error.c 1.5 92/11/24 XMPB";
X#include <stdio.h>
Xxmpb_error(str)
Xchar *str;
X{
X    fprintf(stderr,str);
X    exit(0);
X}
END_OF_FILE
if test 174 -ne `wc -c <'error.c'`; then
    echo shar: \"'error.c'\" unpacked with wrong size!
fi
# end of 'error.c'
fi
if test -f 'mnemonics.h' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'mnemonics.h'\"
else
echo shar: Extracting \"'mnemonics.h'\" \(305 characters\)
sed "s/^X//" >'mnemonics.h' <<'END_OF_FILE'
Xchar ins_name[][6] = {"andr","lodi","lodm","stom","xorr","lter","orr","jmpi",
X                      "eqr","ltr","gtr","gter","notr","jmpc","inpr","oupr",
X                        "jsrc","ret","retc","addr","subr","mulr","divr","modr",
X                        "pushr","popr","pushm","popm","jsri","movr"};
X
END_OF_FILE
if test 305 -ne `wc -c <'mnemonics.h'`; then
    echo shar: \"'mnemonics.h'\" unpacked with wrong size!
fi
# end of 'mnemonics.h'
fi
if test -f 'save.c' -a "${1}" != "-c" ; then
  echo shar: Will not clobber existing file \"'save.c'\"
else
echo shar: Extracting \"'save.c'\" \(273 characters\)
sed "s/^X//" >'save.c' <<'END_OF_FILE'
Xsave default_save=
X{
X    "", "", "", 1000, 5000, 600, 600, 400,
X    {2, 1, 3, 2, 1, 3, 0, 0},
X    {100, 100, 100, 100, 100, -1, -1, 0 },
X    {1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0},
X    {1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1},
X    0,
X    288950
X};
X
END_OF_FILE
if test 273 -ne `wc -c <'save.c'`; then
    echo shar: \"'save.c'\" unpacked with wrong size!
fi
# end of 'save.c'
fi
echo shar: End of archive 8 \(of 8\).
cp /dev/null ark8isdone
MISSING=""
for I in 1 2 3 4 5 6 7 8 ; do
    if test ! -f ark${I}isdone ; then
    MISSING="${MISSING} ${I}"
    fi
done
if test "${MISSING}" = "" ; then
    echo You have unpacked all 8 archives.
    rm -f ark[1-9]isdone
else
    echo You still need to unpack the following archives:
    echo "        " ${MISSING}
fi
##  End of shell archive.
exit 0