standard.shar

The art and science of c_source code!

#! /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:  cslib cslib/Makefile cslib/exception.c cslib/exception.h
#   cslib/gcalloc.h cslib/genlib.c cslib/genlib.h cslib/graphics.c
#   cslib/graphics.h cslib/random.c cslib/random.h cslib/simpio.c
#   cslib/simpio.h cslib/strlib.c cslib/strlib.h
# Wrapped by [e-mail] on Fri Feb 24 19:44:56 1995
PATH=/bin:/usr/bin:/usr/ucb ; export PATH
if test ! -d 'cslib' ; then
    echo shar: Creating directory \"'cslib'\"
    mkdir 'cslib'
fi
if test -f 'cslib/Makefile' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/Makefile'\"
else
echo shar: Extracting \"'cslib/Makefile'\" \(2146 characters\)
sed "s/^X//" >'cslib/Makefile' <<'END_OF_FILE'
X# Makefile for cslib/standard directory
X# Last modified on Thu Oct 20 13:49:04 1994 by eroberts
X#****************************************************************
X
XOBJECTS = \
X    genlib.o \
X    exception.o \
X    strlib.o \
X    simpio.o \
X    random.o \
X    graphics.o
X
XCSLIB = cslib.a
X
XCC = gcc
XCFLAGS = -g -I. $(CCFLAGS)
X
X# ***************************************************************
X# Entry to bring the package up to date
X#    The "make all" entry should be the first real entry
X
Xall: $(CSLIB) gccx
X
X# ***************************************************************
X# Standard entries to remove files from the directories
X#    tidy    -- eliminate unwanted files
X#    clean   -- delete derived files in preparation for rebuild
X#    scratch -- synonym for clean
X
Xtidy:
X	rm -f ,* .,* *~ core a.out *.err
X
Xclean scratch: tidy
X	rm -f *.o *.a gccx
X
X# ***************************************************************
X# C compilations
X
Xgenlib.o: genlib.c genlib.h exception.h gcalloc.h
X	$(CC) $(CFLAGS) -c genlib.c
X
Xexception.o: exception.c exception.h genlib.h
X	$(CC) $(CFLAGS) -c exception.c
X
Xstrlib.o: strlib.c strlib.h genlib.h
X	$(CC) $(CFLAGS) -c strlib.c
X
Xsimpio.o: simpio.c simpio.h strlib.h genlib.h
X	$(CC) $(CFLAGS) -c simpio.c
X
Xgraphics.o: graphics.c graphics.h genlib.h
X	$(CC) $(CFLAGS) -c graphics.c
X
Xrandom.o: random.c random.h genlib.h
X	$(CC) $(CFLAGS) -c random.c
X
X# ***************************************************************
X# Entry to reconstruct the library archive
X
X$(CSLIB): $(OBJECTS)
X	-rm -f $(CSLIB)
X	ar cr $(CSLIB) $(OBJECTS)
X	ranlib $(CSLIB)
X
X# ***************************************************************
X# Entry to reconstruct the gccx script
X
Xgccx: Makefile
X	@echo '#! /bin/csh -f' > gccx
X	@echo 'set INCLUDE =' `pwd` >> gccx
X	@echo 'set CSLIB = $$INCLUDE/cslib.a' >> gccx
X	@echo 'set LIBRARIES = ($$CSLIB -lm)' >> gccx
X	@echo 'foreach x ($$*)' >> gccx
X	@echo '  if ("x$$x" == "x-c") then' >> gccx
X	@echo '    set LIBRARIES = ""' >> gccx
X	@echo '    break' >> gccx
X	@echo '  endif' >> gccx
X	@echo 'end' >> gccx
X	@echo 'gcc -g -I$$INCLUDE $$* $$LIBRARIES' >> gccx
X	@chmod a+x gccx
X	@echo '[gccx script created]'
END_OF_FILE
if test 2146 -ne `wc -c <'cslib/Makefile'`; then
    echo shar: \"'cslib/Makefile'\" unpacked with wrong size!
fi
# end of 'cslib/Makefile'
fi
if test -f 'cslib/exception.c' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/exception.c'\"
else
echo shar: Extracting \"'cslib/exception.c'\" \(3276 characters\)
sed "s/^X//" >'cslib/exception.c' <<'END_OF_FILE'
X/*
X * File: exception.c
X * Version: 1.0
X * Last modified on Sun Jul 24 10:28:11 1994 by eroberts
X * -----------------------------------------------------
X * This file implements the C exception handler.  Much of the
X * real work is done in the exception.h header file.
X */
X
X#include <stdio.h>
X#include <stdarg.h>
X
X#include "genlib.h"
X#include "gcalloc.h"
X#include "exception.h"
X
X/*
X * Constant: MaxUnhandledMessage
X * -----------------------------
X * This constant should be large enough to accommodate the
X * unhandled exception message, including the exception name.
X */
X
X#define MaxUnhandledMessage 100
X
X/* Publically accessible exceptions */
X
Xexception ANY = { "ANY" };
Xexception ErrorException = { "ErrorException" };
X
X/*
X * Global variable: exceptionStack
X * -------------------------------
X * This variable is the head pointer to a linked list of
X * context blocks that act as the exception stack.  The chain
X * pointer is referenced by the macros in exception.h and must
X * therefore be exported, but clients should not reference it
X * directly.
X */
X
Xcontext_block *exceptionStack = NULL;
X
X/* Private function prototypes */
X
Xstatic context_block *FindHandler(exception *e);
X
X/* Public entries */
X
X/*
X * Function: RaiseException
X * ------------------------
X * This function operates by finding an appropriate handler
X * and then using longjmp to return to the context stored
X * there after resetting the exception stack.  If no handler
X * exists, the function notes an unhandled exception.  Much
X * of the complexity comes from the fact that allocation
X * within the exception handler may fail.
X */
X
Xvoid RaiseException(exception *e, string name, void *value)
X{
X    context_block *cb;
X    char errbuf[MaxUnhandledMessage + 1];
X    string errmsg;
X    int errlen;
X
X    cb = FindHandler(e);
X    if (cb == NULL) {
X        sprintf(errbuf, "Unhandled exception (%.30s)", name);
X        errlen = strlen(errbuf);
X        if (_acb == NULL) {
X            errmsg = malloc(errlen + 1);
X        } else {
X            errmsg = _acb->allocMethod(errlen + 1);
X        }
X        if (errmsg == NULL) {
X            errmsg = "Unhandled exception: unknown";
X        } else {
X            strcpy(errmsg, errbuf);
X        }
X        Error(errmsg);
X    }
X    exceptionStack = cb;
X    cb->id = e;
X    cb->value = value;
X    cb->name = name;
X    longjmp(cb->jmp, ES_Exception);
X}
X
X/*
X * Function: HandlerExists
X * -----------------------
X * This public entry is used primarily by the Error function
X * to determine if ErrorException has been trapped, although
X * it is available to other clients as well.
X */
X
Xbool HandlerExists(exception *e)
X{
X    return (FindHandler(e) != NULL);
X}
X
X/* Private functions */
X
X/*
X * Function: FindHandler
X * ---------------------
X * This function searches the exception stack to find the
X * first active handler for the indicated exception.  If a
X * match is found, the context block pointer is returned.
X * If not, FindHandler returns NULL.
X */
X
Xstatic context_block *FindHandler(exception *e)
X{
X    context_block *cb;
X    exception *t;
X    int i;
X
X    for (cb = exceptionStack; cb != NULL; cb = cb->link) {
X        for (i = 0; i < cb->nx; i++) {
X            t = cb->array[i];
X            if (t == e || t == &ANY) return (cb);
X        }
X    }
X    return (NULL);
X}
END_OF_FILE
if test 3276 -ne `wc -c <'cslib/exception.c'`; then
    echo shar: \"'cslib/exception.c'\" unpacked with wrong size!
fi
# end of 'cslib/exception.c'
fi
if test -f 'cslib/exception.h' -a "${1}" != "-c" ; then 
  echo shar: Will not clobber existing file \"'cslib/exception.h'\"
else
echo shar: Extracting \"'cslib/exception.h'\" \(7974 characters\)
sed "s/^X//" >'cslib/exception.h' <<'END_OF_FILE'
X/*
X * File: exception.h
X * Version: 1.0
X * Last modified on Sat Nov 19 16:36:26 1994 by eroberts
X * -----------------------------------------------------
X * The exception package provides a general exception
X * handling mechanism for use with C that is portable
X * across a variety of compilers and operating systems.
X */
X
X#ifndef _exception_h
X#define _exception_h
X
X/*
X * Overview:
X * --------
X * The exception package makes it possible for clients to
X * specify a handler for an exceptional conditions in a
X * syntactically readable way.  As a client, your first step
X * is to declare an exception condition name by declaring
X * a variable of type exception, as in
X *
X *       exception MyException;
X *
X * Normal visibility rules apply, so that you should declare
X * the exception variable at the appropriate level.  For
X * example, if an exception is local to an implementation,
X * it should be declared statically within that module.  If
X * an exception condition is shared by many modules, the
X * exception variable should be declared in an interface
X * and exported to all clients that need it.  This package
X * defines and exports the exception ErrorException, which
X * is likely to be sufficient for many clients.
X *
X * The basic functionality of exceptions is that one piece
X * of code can "raise" an exception so that it can then be
X * "handled" by special code in a dynamically enclosing
X * section of the program.  Exceptions are raised by calling
X * the pseudo-function raise with the exception name, as in
X *
X *     raise(MyException);
X *
X * Exceptions are handled using the "try" statement
X * (actually implemented using macros), which has the form:
X *
X *     try {
X *        . . . statements in the body of the block . . .
X *     except(exception1)
X *        . . . statements to handle exception 1 . . .
X *     except(exception2)
X *        . . . statements to handle exception 2 . . .
X *     except(ANY)
X *        . . . statements to handle any exception . . .
X *     } endtry
X *
X * Any number of except clauses may appear (up to a
X * maximum defined by the constant MaxExceptionsPerScope),
X * and the ANY clause is optional.
X *
X * When the program encounters the "try" statement, the
X * statements in the body are executed.  If no exception
X * conditions are raised during that execution, either
X * in this block or by a function call nested inside
X * this block, control passes to the end of the "try"
X * statement when the last statement in the block is
X * executed.  If an exception is raised during the
X * dynamic execution of the block, control immediately
X * passes to the statements in the appropriate except
X * clause.  Only the statements in that clause are
X * executed; no break statement is required to exit
X * the block.  If no handler for the raised exception
X * appears anywhere in the control history, the program
X * exits with an error.
X *
X * Examples of use:
X *
X * 1.  Catching errors.
X *
X * The following code fragment traps calls to Error, so
X * that the program does not quit but instead returns
X * to the top-level read-and-execute loop.
X *
X *     while (TRUE) {
X *         try {
X *             printf("> ");
X *             cmd = ReadCommand();
X *             ExecuteCommand(cmd);
X *         except(ErrorException)
X *             printf("Error: %s\n", (string) GetExceptionValue());
X *             -- additional handling code, if any --
X *         } endtry
X *     }
X *
X * If either ReadCommand or ExecuteCommand calls Error,
X * control will be passed back to the main loop, after
X * executing any additional handler code.  The error
X * message is passed as the exception value and can be
X * printed as shown in the example.
X *
X * 2.  Handling control-C
X *
X * The following code extends the example above so that
X * typing ^C also returns to top-level.
X *
X *     #include <signal.h>
X *
X *     static exception ControlCException;
X *     static int errorCount = 0;
X *     static int ControlCHandler();
X *
X *     main()
X *     {
X *         string cmd;
X *
X *         signal(SIGINT, ControlCHandler);
X *         while (TRUE) {
X *             try {
X *                 printf("> ");
X *                 cmd = ReadCommand();
X *                 ExecuteCommand(cmd);
X *             except(ControlCException);
X *                 printf("^C\n");
X *                 signal(SIGINT, ControlCHandler);
X *             except(ErrorException)
X *                 errorCount++;
X *             } endtry
X *         }
X *     }
X *
X *     static int ControlCHandler()
X *     {
X *         raise(ControlCException);
X *     }
X */
X
X/*
X * Actual interface specification
X * ------------------------------
X * Most of the implementation of the exception mechanism is
X * actually done in the macros defined by this file.
X * Clients should ordinarily be able to read the description
X * above and ignore the detailed code below.
X */
X
X#include <setjmp.h>
X#include <string.h>
X#include "genlib.h"
X
X/* Define parameters and error status indicators */
X
X#define MaxExceptionsPerScope 10
X#define ETooManyExceptClauses 101
X#define EUnhandledException 102
X
X/* Codes to keep track of the state of the try handler */
X
X#define ES_Initialize 0
X#define ES_EvalBody 1
X#define ES_Exception 2
X
X/*
X * Type: exception
X * ---------------
X * Exceptions are specified by their address, so that the
X * actual structure does not matter.  Strings are used here
X * so that exporters of exceptions can store the exception
X * name for the use of debuggers and other tools.
X */
X
Xtypedef struct { string name; } exception;
X
X/*
X * Type: context_block
X * -------------------
X * This structure is used internally to maintain a chain of
X * exception scopes on the control stack.
X */
X
Xtypedef struct ctx_block {
X    jmp_buf jmp;
X    int nx;
X    exception *array[MaxExceptionsPerScope];
X    exception *id;
X    void *value;
X    string name;
X    struct ctx_block *link;
X} context_block;
X
X/* Declare the built-in exceptions */
X
Xextern exception ErrorException;
Xextern exception ANY;
X
X/* Declare a global pointer to the context stack */
X
Xextern context_block *exceptionStack;
X
X/*