Failed assertion in cplus-lex.c
Doug Moore
function. Nevertheless, it shouldn't give this error message:
g++ version 1.37.1 (based on GCC 1.37)
/usr/local/lib/gcc-cpp -+ -v -undef -D__GNUC__ -D__GNUG__ -D__cplusplus -Dsparc
-Dsun -Dunix -D__sparc__ -D__sun__ -D__unix__ -Wall SExpression.eval.cc /usr/tm
p/cca05982.cpp
GNU CPP version 1.37.1
/usr/local/lib/gcc-cc1plus /usr/tmp/cca05982.cpp -quiet -dumpbase SExpression.e
val.cc -Wall -version -o /usr/tmp/cca05982.s
GNU C++ version 1.37.1 (based on GCC 1.37) (sparc) compiled by GNU C version 1.3
7.1.
default target switches: -mfpu -mepilogue
Failed assertion `i != LAST_CPLUS_TREE_CODE' at line 575 of `cplus-lex.c'.
g++: Program cc1plus got fatal signal 6.
The code follows.
Dougm
#! /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 shell archive."
# Contents: SExpression.eval.cc SExpression.h Token.h Bignum.h
# Wrapped by comp212@great-gray on Mon Mar 26 00:22:43 1990
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test -f 'SExpression.eval.cc' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'SExpression.eval.cc'\"
else
echo shar: Extracting \"'SExpression.eval.cc'\" \(11839 characters\)
sed "s/^X//" >'SExpression.eval.cc' <<'END_OF_FILE'
X#include "SExpression.h"
X
XSExpression badArgs(BADARGS);
X
Xbool SExpression::atomErr(AtomClass atmClass)
X{
X return !isAnAtom ||
X xatom->atmClass != atmClass;
X}
X
XSymbolTable symbolInit(void)
X // Initialize a symbol table
X{
X const int nSymbols = 'z' - 'a' + 1;
X SymbolTable symbolTbl = new SExpression[nSymbols];
X
X for (char c = 'a'; c <= 'z'; ++c)
X {
X symbolTbl[c - 'a'].isAnAtom = TRUE;
X symbolTbl[c - 'a'].xatom = new Atom;
X symbolTbl[c - 'a'].xatom->atmClass = ERROR_ATOM;
X symbolTbl[c - 'a'].xatom->errorVal = new ErrorName;
X *symbolTbl[c - 'a'].xatom->errorVal = UNBOUND;
X }
X return symbolTbl;
X}
X
X// Find the nth argument in a list
XSExpression SExpression::nthCar(int nthTerm)
X{
X if (xcons == NULL) return badArgs;
X if (nthTerm == 0) return xcons->car;
X return xcons->cdr.nthCar(--nthTerm);
X}
X
X// Is the nth cdr NULL?
Xbool SExpression::wrongNArgs(int nArgs)
X{
X if (isAnAtom && xatom == NULL) return (nArgs != 0);
X if (isAnAtom) return TRUE;
X if (nArgs == 0) return TRUE;
X return xcons->cdr.wrongNArgs(--nArgs);
X}
X
X// Produce a Boolean atom
XSExpression::SExpression(bool booleanVal)
X{
X isAnAtom = TRUE;
X xatom = new Atom;
X xatom->atmClass = BOOLEAN_ATOM;
X xatom->boolVal = new bool;
X *xatom->boolVal = booleanVal;
X}
X
X// Produce an error atom
XSExpression::SExpression(ErrorName errorNameVal)
X{
X isAnAtom = TRUE;
X xatom = new Atom;
X xatom->atmClass = ERROR_ATOM;
X xatom->errorVal = new ErrorName;
X *xatom->errorVal = errorNameVal;
X}
X
X// Produce a Bignum atom
XSExpression::SExpression(const Bignum &num)
X{
X isAnAtom = TRUE;
X xatom = new Atom;
X xatom->atmClass = BIGNUM_ATOM;
X xatom->bignumVal = new Bignum(num);
X}
X
X
X// Evaluate an SExpression, using the values in symbolMap
XSExpression SExpression::eval(SymbolTable symbolMap)
X{
X if (isAnAtom)
X if (xatom != NULL &&
X xatom->atmClass == SYMBOL_ATOM)
X return symbolMap[*xatom->symbolVal - 'a'];
X else
X return *this;
X
X //function is Procedure or error
X SExpression functionSExpr = nthCar(0).eval(symbolMap);
X
X if (functionSExpr.atomErr(PROCEDURE_ATOM)) return badArgs;
X
X ProcedureName functionName = *functionSExpr.xatom->procedureVal;
X
X // Select and execute the appropriate function
X SExpression arg1, arg2, newSExpr;
X SExpression args;
X bool bVal;
X Bignum num;
X switch(functionName)
X {
X case QUOTE:
X if (wrongNArgs(2)) return badArgs;
X return nthCar(1);
X break;
X
X case IF:
X if (wrongNArgs(4)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X if (arg1.atomErr(BOOLEAN_ATOM)) return badArgs;
X return nthCar(*arg1.xatom->boolVal ? 2 : 3).eval(symbolMap);
X break;
X
X case ATOMQ:
X if (wrongNArgs(2)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X return SExpression(arg1.isAnAtom);
X break;
X
X case NULLQ:
X if (wrongNArgs(2)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X bVal = arg1.isAnAtom && arg1.isAnAtom && arg1.xatom == NULL;
X return SExpression(bVal);
X break;
X
X case BOOLEANQ:
X case PROCEDUREQ:
X case SYMBOLQ:
X case BIGNUMQ:
X case ERRORQ:
X if (wrongNArgs(2)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X bVal = arg1.isAnAtom && arg1.xatom->atmClass == AtomClass(functionName);
X return SExpression(bVal);
X break;
X
X case CONS:
X if (wrongNArgs(3)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X arg2 = nthCar(2).eval(symbolMap);
X newSExpr.isAnAtom = FALSE;
X newSExpr.xcons = new Cons;
X newSExpr.xcons->car = arg1;
X newSExpr.xcons->cdr = arg2;
X return newSExpr;
X break;
X
X case CAR:
X if (wrongNArgs(2)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X if (arg1.isAnAtom) return badArgs;
X return arg1.xcons->car;
X break;
X
X case CDR:
X if (wrongNArgs(2)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X if (arg1.isAnAtom) return badArgs;
X return arg1.xcons->cdr;
X break;
X
X case SET_CAR:
X if (wrongNArgs(3)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X if (arg1.isAnAtom) return badArgs;
X arg2 = nthCar(2).eval(symbolMap);
X return arg1.xcons->car = arg2;
X break;
X
X case SET_CDR:
X if (wrongNArgs(3)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X if (arg1.isAnAtom) return badArgs;
X arg2 = nthCar(2).eval(symbolMap);
X return arg1.xcons->cdr = arg2;
X break;
X
X case SET_VALUE:
X if (wrongNArgs(3)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X if (arg1.atomErr(SYMBOL_ATOM)) return badArgs;
X arg2 = nthCar(2).eval(symbolMap);
X return symbolMap[*arg1.xatom->symbolVal - 'a'] = arg2;
X break;
X
X case PLUS:
X return xcons->cdr.arithApply(0, operator +, symbolMap);
X#if 0
X args = xcons->cdr;
X num = tiny(0);
X while (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X num += *arg1.xatom->bignumVal;
X args = args.xcons->cdr;
X }
X if (args.xatom != NULL) return badArgs;
X return SExpression(num);
X#endif 0
X break;
X
X case NEG:
X if (wrongNArgs(2)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X num = -*arg1.xatom->bignumVal;
X return SExpression(num);
X break;
X
X case MINUS:
X if (wrongNArgs(3)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X arg2 = nthCar(2).eval(symbolMap);
X if (arg2.atomErr(BIGNUM_ATOM)) return badArgs;
X num = *arg1.xatom->bignumVal;
X num -= *arg2.xatom->bignumVal;
X return SExpression(num);
X break;
X
X case TIMES:
X args = xcons->cdr;
X num = tiny(1);
X while (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X num *= *arg1.xatom->bignumVal;
X args = args.xcons->cdr;
X }
X if (args.xatom != NULL) return badArgs;
X return SExpression(num);
X break;
X
X case DIV:
X if (wrongNArgs(3)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X arg2 = nthCar(2).eval(symbolMap);
X if (arg2.atomErr(BIGNUM_ATOM)) return badArgs;
X if (!*arg2.xatom->bignumVal) return SExpression(ZERODIVIDE);
X num = *arg1.xatom->bignumVal;
X num /= *arg2.xatom->bignumVal;
X return SExpression(num);
X break;
X
X case MOD:
X if (wrongNArgs(3)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X arg2 = nthCar(2).eval(symbolMap);
X if (arg2.atomErr(BIGNUM_ATOM)) return badArgs;
X if (!*arg2.xatom->bignumVal) return SExpression(ZERODIVIDE);
X num = *arg1.xatom->bignumVal;
X num %= *arg2.xatom->bignumVal;
X return SExpression(num);
X break;
X
X case GCD:
X args = xcons->cdr;
X num = tiny(0);
X while (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X num.gcdEQ(*arg1.xatom->bignumVal);
X args = args.xcons->cdr;
X }
X if (args.xatom != NULL) return badArgs;
X return SExpression(num);
X break;
X
X case LCM:
X args = xcons->cdr;
X num = tiny(1);
X while (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X num.lcmEQ(*arg1.xatom->bignumVal);
X args = args.xcons->cdr;
X }
X if (args.xatom != NULL) return badArgs;
X return SExpression(num);
X break;
X
X case LESS:
X args = xcons->cdr;
X bVal = TRUE;
X if (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X num = *arg1.xatom->bignumVal;
X args = args.xcons->cdr;
X }
X while (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X bVal &= (num < *arg1.xatom->bignumVal);
X args = args.xcons->cdr;
X }
X if (args.xatom != NULL) return badArgs;
X return SExpression(bVal);
X break;
X
X case MORE:
X args = xcons->cdr;
X bVal = TRUE;
X if (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X num = *arg1.xatom->bignumVal;
X args = args.xcons->cdr;
X }
X while (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X bVal &= (num > *arg1.xatom->bignumVal);
X args = args.xcons->cdr;
X }
X if (args.xatom != NULL) return badArgs;
X return SExpression(bVal);
X break;
X
X case LESSEQ:
X args = xcons->cdr;
X bVal = TRUE;
X if (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X num = *arg1.xatom->bignumVal;
X args = args.xcons->cdr;
X }
X while (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X bVal &= (num <= *arg1.xatom->bignumVal);
X args = args.xcons->cdr;
X }
X if (args.xatom != NULL) return badArgs;
X return SExpression(bVal);
X break;
X
X case MOREEQ:
X args = xcons->cdr;
X bVal = TRUE;
X if (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X num = *arg1.xatom->bignumVal;
X args = args.xcons->cdr;
X }
X while (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X bVal &= (num >= *arg1.xatom->bignumVal);
X args = args.xcons->cdr;
X }
X if (args.xatom != NULL) return badArgs;
X return SExpression(bVal);
X break;
X
X case SAME:
X args = xcons->cdr;
X bVal = TRUE;
X if (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X num = *arg1.xatom->bignumVal;
X args = args.xcons->cdr;
X }
X while (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X bVal &= (num == *arg1.xatom->bignumVal);
X args = args.xcons->cdr;
X }
X if (args.xatom != NULL) return badArgs;
X return SExpression(bVal);
X break;
X
X case NOT:
X if (wrongNArgs(2)) return badArgs;
X arg1 = nthCar(1).eval(symbolMap);
X if (arg1.atomErr(BOOLEAN_ATOM)) return badArgs;
X bVal = !*arg1.xatom->boolVal;
X return SExpression(bVal);
X break;
X
X case AND:
X args = xcons->cdr;
X while (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BOOLEAN_ATOM)) return badArgs;
X if (!*arg1.xatom->boolVal)
X return SExpression(FALSE);
X args = args.xcons->cdr;
X }
X if (args.xatom != NULL) return badArgs;
X return SExpression(TRUE);
X break;
X
X case OR:
X args = xcons->cdr;
X while (!args.isAnAtom)
X {
X arg1 = args.xcons->car.eval(symbolMap);
X if (arg1.atomErr(BOOLEAN_ATOM)) return badArgs;
X if (*arg1.xatom->boolVal)
X return SExpression(TRUE);
X args = args.xcons->cdr;
X }
X if (args.xatom != NULL) return badArgs;
X return SExpression(FALSE);
X break;
X
X default: // Should never reach this case
X exit(1);
X break;
X }
X}
X
XSExpression SExpression::arithApply(tiny base,
X Bignum & (Bignum::*opEQ)(const Bignum &),
X SymbolTable symbolMap)
X{
X Bignum num(base);
X SExpression args = *this;
X while (!args.isAnAtom)
X {
X SExpression arg1(args.xcons->car.eval(symbolMap));
X if (arg1.atomErr(BIGNUM_ATOM)) return badArgs;
X (num.*opEQ)(*arg1.xatom->bignumVal);
X args = args.xcons->cdr;
X }
X if (args.xatom != NULL) return badArgs;
X return SExpression(num);
X}
END_OF_FILE
if test 11839 -ne `wc -c <'SExpression.eval.cc'`; then
echo shar: \"'SExpression.eval.cc'\" unpacked with wrong size!
fi
# end of 'SExpression.eval.cc'
fi
if test -f 'SExpression.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'SExpression.h'\"
else
echo shar: Extracting \"'SExpression.h'\" \(1363 characters\)
sed "s/^X//" >'SExpression.h' <<'END_OF_FILE'
X// Original Program by...
X/* SExpression.h Leo Artalejo
X 8 February, 1990 */
X// Modified significantly by Doug Moore
X
X//header file containing SExpression class and components
X
X#ifndef SExpression_h
X#pragma once
X#define SExpression_h 1
X
X#include <bool.h>
X#include <stream.h>
X#include "Token.h"
X
Xclass Cons;
Xclass SExpression;
Xtypedef SExpression *SymbolTable;
X
Xclass SExpression
X{
X friend istream & operator >> (istream &is, SExpression &sExpr);
X friend ostream & operator << (ostream &os, SExpression sExpr);
X friend SymbolTable symbolInit(void);
X
Xpublic:
X SExpression(void) {}
X SExpression(bool);
X SExpression(ErrorName);
X SExpression(const Bignum &);
X ~SExpression(void) {}
X SExpression eval(SymbolTable);
X
Xprivate:
X bool isAnAtom;
X union
X {
X Atom *xatom;
X Cons *xcons;
X };
X
X // used in parser
X static bool dotAtEnd; // was the most recently read list terminator a dot?
X istream & readCars(istream &is);
X
X // used in evaluator
X SExpression nthCar(int nthTerm);
X bool wrongNArgs(int nArgs);
X bool atomErr(AtomClass);
X SExpression arithApply(tiny base,
X Bignum & (Bignum::*)(const Bignum &),
X SymbolTable);
X};
X
X
Xclass Cons
X{
X friend class SExpression;
X friend ostream & operator << (ostream &os, SExpression sExpr);
Xprivate:
X SExpression car;
X SExpression cdr;
X};
X
X#endif SExpression_h
END_OF_FILE
if test 1363 -ne `wc -c <'SExpression.h'`; then
echo shar: \"'SExpression.h'\" unpacked with wrong size!
fi
# end of 'SExpression.h'
fi
if test -f 'Token.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'Token.h'\"
else
echo shar: Extracting \"'Token.h'\" \(1520 characters\)
sed "s/^X//" >'Token.h' <<'END_OF_FILE'
X// Original Token.h by...
X/* Token.h Karen Barefield
X 2 February, 1990 */
X// Modifications: Doug Moore
X
X#ifndef Token_h
X#pragma once
X#define Token_h 1
X
X
X#include <stream.h>
X#include <String.h>
X#include <bool.h>
X#include "Bignum.h"
X
Xenum ProcedureName {CONS, CAR, CDR, SET_VALUE, SET_CAR, SET_CDR,
X IF, QUOTE, ATOMQ, BOOLEANQ, SYMBOLQ, PROCEDUREQ,
X BIGNUMQ, ERRORQ, NULLQ, PLUS, NEG, MINUS, TIMES,
X DIV, MOD, GCD, LCM, LESS, MORE, LESSEQ, MOREEQ,
X SAME, NOT, AND, OR,
X FIRST_PROC = CONS, LAST_PROC = OR};
X// Order here must match order in ProcNameString, defined in Token.cc
X
Xenum ErrorName {BADARGS, ZERODIVIDE, UNBOUND,
X FIRST_ERROR = BADARGS, LAST_ERROR = UNBOUND};
X// Order here must match order in ProcNameString, defined in Token.cc
X
Xenum AtomClass {BOOLEAN_ATOM = BOOLEANQ,
X SYMBOL_ATOM = SYMBOLQ,
X PROCEDURE_ATOM = PROCEDUREQ,
X BIGNUM_ATOM = BIGNUMQ,
X ERROR_ATOM = ERRORQ};
Xclass Atom
X{
X friend istream & operator >> (istream &, Atom &);
X friend ostream & operator << (ostream &, Atom);
Xpublic:
X AtomClass atmClass;
X union
X {
X bool *boolVal;
X char *symbolVal;
X ProcedureName *procedureVal;
X Bignum *bignumVal;
X ErrorName *errorVal;
X };
X};
X
Xenum TokenClass {ATOM_TOKEN, LEFTP_TOKEN, RIGHTP_TOKEN, DOT_TOKEN};
Xclass Token
X{
X friend istream & operator >> (istream &, Token &);
X friend ostream & operator << (ostream &, Token);
X
Xpublic:
X TokenClass tokClass;
X Atom atomData;
X};
X
X#endif Token_h
END_OF_FILE
if test 1520 -ne `wc -c <'Token.h'`; then
echo shar: \"'Token.h'\" unpacked with wrong size!
fi
# end of 'Token.h'
fi
if test -f 'Bignum.h' -a "${1}" != "-c" ; then
echo shar: Will not clobber existing file \"'Bignum.h'\"
else
echo shar: Extracting \"'Bignum.h'\" \(1905 characters\)
sed "s/^X//" >'Bignum.h' <<'END_OF_FILE'
X#ifndef Bignum_h
X#define Bignum_h
X
X#include <stream.h>
X#include <bool.h>
X
Xtypedef unsigned char tiny;
X
Xclass DigitLink;
Xclass Bignum
X{
X friend class DigitLink;
X friend istream & operator >> (istream &, Bignum &);
X friend ostream & operator << (ostream &, Bignum &);
Xpublic:
X Bignum(void);
X Bignum(tiny);
X Bignum(int);
X Bignum(const Bignum &);
X Bignum & operator = (const Bignum &);
X ~Bignum(void);
X
X friend Bignum operator + (const Bignum &, const Bignum &);
X Bignum & operator += (const Bignum &);
X
X friend Bignum operator - (const Bignum &, const Bignum &);
X Bignum & operator -= (const Bignum &);
X
X Bignum operator - (void) const;
X Bignum & negate(void);
X
X Bignum operator * (const Bignum &) const;
X Bignum & operator *= (const Bignum &);
X friend Bignum operator * (const Bignum &, tiny digit);
X Bignum & operator *= (tiny digit);
X
X Bignum operator / (const Bignum &) const;
X Bignum & operator /= (const Bignum &);
X Bignum & operator /= (tiny digit);
X Bignum operator % (const Bignum &) const;
X Bignum & operator %= (const Bignum &);
X tiny operator % (tiny digit) const;
X
X
X Bignum gcd (const Bignum &) const;
X Bignum & gcdEQ (const Bignum &);
X Bignum lcm (const Bignum &) const;
X Bignum & lcmEQ (const Bignum &);
X
X bool isEven(void) const;
X bool isNeg(void) const;
X bool operator ! (void) const;
X bool operator < (const Bignum &) const;
X bool operator > (const Bignum &) const;
X bool operator == (const Bignum &) const;
X bool operator != (const Bignum &) const;
X bool operator <= (const Bignum &) const;
X bool operator >= (const Bignum &) const;
X
Xprivate:
X DigitLink * head;
X int log(void) const;
X Bignum & divide(Bignum "ient, const Bignum &denom);
X Bignum & operator <<= (int twoPower);
X};
X
Xclass DigitLink
X{
Xfriend class Bignum;
Xprivate:
X DigitLink(tiny);
X DigitLink(void);
X ~DigitLink(void);
X tiny digit;
X DigitLink *next;
X};
X
X#endif Bignum_h
END_OF_FILE
if test 1905 -ne `wc -c <'Bignum.h'`; then
echo shar: \"'Bignum.h'\" unpacked with wrong size!
fi
# end of 'Bignum.h'
fi
echo shar: End of shell archive.
exit 0